Now robocopy is replacing xcopy in my book and to make robocopy play nice, I add ^& exit 0 at the end. Like this:


robocopy \\networkdrive destpath *.* ^& exit 0


Still I got it fixed. Just two steps:
- set the management studio to run in XP SP3 compatibility mode
- if you have the UAC turned off, turn it on on the first level (raise the level from the bottom one notch)

Now it’s working like a charm.

where workitemid is the id given to the workitem by TFS

You can also see the documentation here

I thought alot on this. I am in holiday and the news intrigued me to say the least.
There has been alot of discussion and debate on the reason, starting from patent needs (motorola has 17000 patents and counting) to support infrastructure and enterprise targetting. I am more interested in the outcome. With this move we are witnessing a stalemate on the three side war. We have Microsoft Nokia, Apple and now Google Motorola. Of the three, only Apple is low on patents compared to the others, but they have alot of new ones and also important ones, and their powerfull market possition. This leads as I said to a stalemate with each side not in a power possition. What is going to happen next?
Well, all of them want market share and the only way to achieve that is through technological breakthroughs and services! As I said: rejoice. Good times are coming for smartphone users.

What I see: Mikrokia will deliver, Googrola will finally bring order in the chaos that is android and Apple will begin to listen and diminish the Jobs tax

Let us suppose you are a bank and need a new backend system. Your bank will move billions each day. What do you do? Will you choose a small very “passionate” company, or go for one that has processes in place and are transparent in their work and give you measurements about productivity and quality?
Of course, your company might not be a bank, and you do not expect something great, only something that it works and fast. Jump on the passionate wagon, they will certainly deliver.

Maybe the real problem resides in “when” should you apply all the TDD, reviews, processes, measurements and the like. I can only say: do what is needed to achieve your goals. If the goal is “zero defects” (I don’t agree with that but that’s another story) then go for the full-blown processes approach. If you need something fast, get a senior and a few devs and juniors, give them free hand and you are done.

Today I was chatting with someone from the company about the same article and he said: “if someone thinks that putting 5 guru’s in a team and letting them just do the product will work, I am willing to bet ALOT against it happening”; and I tend to agree, unless they devise their processes and plan the project to a certain degree, which if they are passionate enough – will not happen.

Cheers

[Any CPU/Release] /temp/global.asax(1,0): error ASPPARSE: Could not
load type 'TestMVCApp.MvcApplication'.

The reason is simple but not easy to find out. It seems the AspNetCompiler expects the dll’s to be found in the Bin directory and TFS puts the output in a different folder. Thus the AfterCompile step fails. To fix this we need to change (using notepad) the csproj of the web project.

Original:

<Target Name="AfterBuild" Condition="'$(MvcBuildViews)'=='true'">
  <AspNetCompiler VirtualPath="temp" PhysicalPath="$(ProjectDir)" />
</Target>

Fixed version:

<Target Name="AfterBuild" Condition="'$(MvcBuildViews)'=='true'">
  <AspNetCompiler Condition="'$(IsDesktopBuild)' != 'false'"
     VirtualPath="temp"
     PhysicalPath="$(ProjectDir)\..\$(ProjectName)" />
  <AspNetCompiler Condition="'$(IsDesktopBuild)' == 'false'"
     VirtualPath="temp"
     PhysicalPath="$(PublishDir)\_PublishedWebsites\$(ProjectName)" />
</Target>

Hopefully MS will fix this in the future.

Here are my “bad” points:
- address bar is skewed, again. I simply cannot choose from the last lets say 20 url’s entered and there is no way to do this. Think about::config in firefox
- the page tabs are squeezed on the right of the address bar. Excuse me! Where do I fit my usual 10 tabs. Group them? No, I don’t want that.
- page loading is simply unintuitive. I have no feedback on the status and from 10 pages at least 2 fail to load. No error message just a blank page

The good points (yes there are some):
- the interface is nice, feels more aero-like
- the perceived performance (once you actually get to see something) is good

I was planning to switch to IE9 from Firefox (the damned resource hog) but it is not there yet. Waiting for beta 2.

using System;
using System.Diagnostics.SymbolStore;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;

namespace PdbTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly ass = Assembly.GetExecutingAssembly();
            ISymbolReader symreader = SymUtil.GetSymbolReaderForFile(ass.Location, null);

            MethodInfo m = ass.GetType("PdbTest.TestClass").GetMethod("GetStringRepresentation");
            ISymbolMethod met = symreader.GetMethod(new SymbolToken(m.MetadataToken));

            int count = met.SequencePointCount;

            ISymbolDocument[] docs = new ISymbolDocument[count];
            int[] offsets = new int[count];
            int[] lines = new int[count];
            int[] columns = new int[count];
            int[] endlines = new int[count];
            int[] endcolumns = new int[count];

            met.GetSequencePoints(offsets, docs, lines, columns, endlines, endcolumns);

            StreamReader reader = new StreamReader(docs[0].URL);
            string[] linesOfCode = reader.ReadToEnd().Split('\n');
            reader.Close();

            Console.WriteLine("The content of method PdbTest.TestClass.GetStringRepresentation");
            for (int i = lines[0]; i < endlines[count - 1] - 1; i++)
            {
                Console.WriteLine(linesOfCode[i]);
            }
        }
    }

    #region test class

    public enum MyEnum
    {
        Apples,
        Oranges
    }

    public partial class TestClass
    {
        public string GetStringRepresentation(MyEnum e)
        {
            MyEnum e2 = MyEnum.Apples;
            return e.ToString() + e2.ToString();
        }
    }

    #endregion test class

    #region Get a symbol reader for the given module

    // Encapsulate a set of helper classes to get a symbol reader from a file.
    // The symbol interfaces require an unmanaged metadata interface.
    static class SymUtil
    {
        static class NativeMethods
        {
            [DllImport("ole32.dll")]
            public static extern int CoCreateInstance(
                [In] ref Guid rclsid,
                [In, MarshalAs(UnmanagedType.IUnknown)] Object pUnkOuter,
                [In] uint dwClsContext,
                [In] ref Guid riid,
                [Out, MarshalAs(UnmanagedType.Interface)] out Object ppv);
        }

        // Wrapper.
        public static ISymbolReader GetSymbolReaderForFile(string pathModule, string searchPath)
        {
            return SymUtil.GetSymbolReaderForFile(
                new System.Diagnostics.SymbolStore.SymBinder(), pathModule, searchPath);
        }

        // We demand Unmanaged code permissions because we're reading from the file 
        // system and calling out to the Symbol Reader
        // @TODO - make this more specific.
        [System.Security.Permissions.SecurityPermission(
            System.Security.Permissions.SecurityAction.Demand,
            Flags = System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)]
        public static ISymbolReader GetSymbolReaderForFile(
           System.Diagnostics.SymbolStore.SymBinder binder, string pathModule, string searchPath)
        {
            // Guids for imported metadata interfaces.
            Guid dispenserClassID = new Guid(0xe5cb7a31, 0x7512, 0x11d2, 0x89,
                0xce, 0x00, 0x80, 0xc7, 0x92, 0xe5, 0xd8); // CLSID_CorMetaDataDispenser
            Guid dispenserIID = new Guid(0x809c652e, 0x7396, 0x11d2, 0x97, 0x71,
                0x00, 0xa0, 0xc9, 0xb4, 0xd5, 0x0c); // IID_IMetaDataDispenser
            Guid importerIID = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67,
                0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44); // IID_IMetaDataImport

            // First create the Metadata dispenser.
            object objDispenser;
            NativeMethods.CoCreateInstance(ref dispenserClassID, null, 1,
                ref dispenserIID, out objDispenser);

            // Now open an Importer on the given filename. We'll end up passing this importer 
            // straight through to the Binder.
            object objImporter;
            IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
            dispenser.OpenScope(pathModule, 0, ref importerIID, out objImporter);

            IntPtr importerPtr = IntPtr.Zero;
            ISymbolReader reader;
            try
            {
                // This will manually AddRef the underlying object, so we need to 
                // be very careful to Release it.
                importerPtr = Marshal.GetComInterfaceForObject(objImporter,
                    typeof(IMetadataImport));

                reader = binder.GetReader(importerPtr, pathModule, searchPath);
            }
            finally
            {
                if (importerPtr != IntPtr.Zero)
                {
                    Marshal.Release(importerPtr);
                }
            }
            return reader;
        }
    }
    #region Metadata Imports

    // We can use reflection-only load context to use reflection to query for 
    // metadata information rather
    // than painfully import the com-classic metadata interfaces.
    [Guid("809c652e-7396-11d2-9771-00a0c9b4d50c"),
        InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [ComVisible(true)]
    interface IMetaDataDispenser
    {
        // We need to be able to call OpenScope, which is the 2nd vtable slot.
        // Thus we need this one placeholder here to occupy the first slot..
        void DefineScope_Placeholder();

        //STDMETHOD(OpenScope)(                   // Return code.
        //LPCWSTR     szScope,                // [in] The scope to open.
        //  DWORD       dwOpenFlags,            // [in] Open mode flags.
        //  REFIID      riid,                   // [in] The interface desired.
        //  IUnknown    **ppIUnk) PURE;         // [out] Return interface on success.
        void OpenScope([In, MarshalAs(UnmanagedType.LPWStr)] String szScope,
            [In] Int32 dwOpenFlags, [In] ref Guid riid,
            [Out, MarshalAs(UnmanagedType.IUnknown)] out Object punk);

        // Don't need any other methods.
    }

    // Since we're just blindly passing this interface through managed code to the Symbinder, 
    // we don't care about actually importing the specific methods.
    // This needs to be public so that we can call Marshal.GetComInterfaceForObject() on 
    // it to get the underlying metadata pointer.
    [Guid("7DAC8207-D3AE-4c75-9B67-92801A497D44"),
        InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [ComVisible(true)]
    [CLSCompliant(true)]
    public interface IMetadataImport
    {
        // Just need a single placeholder method so that it doesn't complain
        // about an empty interface.
        void Placeholder();
    }
    #endregion

    #endregion Get a symbol reader for the given module
}

Thanks Mike.

Here are the steps:

1. If you don’t know what you are doing ask someone who does and go to step 10. If you don’t have someone to ask you can still proceed but at your own risk.
2. Log on onto the build machine as an administrator (just to avoid pesky security checks)
3. Go to c:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies – this may vary due to the OS being 32 or 64 and if you’re using TFS2008 (you go to vs 9.0 directory) or if you’re using TFS2010 (you go to vs 10.0 directory)
4. Copy TFSBuildService.exe as TFSBuildService2.exe (just make sure you have different executables for each build agent, I use numbers added to the name of the file)
5. Copy TFSBuildService.exe.config as TFSBuildService2.exe.config (same logic as above)
6. Edit TFSBuildService2.exe.config:
   • such that the “port” and “InteractivePort” have values not yet used. For the second agent these would be 9193 and 9194 which I will be using later in the process.
   • Here you can also fool the build agent to use whatever version of MSBuild you want by modifying MSBuildPath. For example I use the MSBuild of .Net 4.0 on a TFS2008.
   • Modify “SourcesSubdirectory” to “Sources\projectname” where projectname is an arbitrary value, just make sure it’s different for all build agents
   • Modify “BinariesSubdirectory” to “Binaries\projectname” – same logic as above
   • Modify “TestResultsSubdirectory” to “TestResults\projectname” – same logic as above
7. Create a service for the build agent. Open a visual studio command prompt (will save you to write fullpath to sc.exe) and run the command: sc create VSTFBUILD2 binpath= “C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies\TFSBuildService2.exe” displayname= “Visual Studio Team Foundation Build – projectName” start= auto. Observations:
   • the name of the service VSTFBUILD2 should differ from all other build agent services and thus I added the 2 suffix
   • the TFSBuildService2.exe should be the one you created at step 4
   • the display name is not very important but helps in identifying the service in the service manager window
8. Go to service manager window (start\control panel\administrative tools\services), find your newly created service, go to properties, the log-on tab and modify there to make the service to log on as the TFSService (default account for the TFS). Make sure you’re using also the domain there if you are in a domain.
9. Start the service
10. Create a folder where the build results will be added. Something like “c:\b\pname”. Be carefull to choose as shorter names as possible to not hit the 240 char limit of TFS when getting all the source code. Share this folder with the people that need to access build results and make sure TFSService has full rights on it
11. Log on to the TFS machine
12. Start visual studio (must have team explorer installed).
13. Use team explorer to navigate to your sollution and right click on the Builds and select Manage Build Agents. If you don’t see the option you may not have rights – get them.
14. Click New. Choose a display name. I choose buildmachine_2. In the computer name add buildmachine and the communication port you set at step; in this case 9193. Set the agent status to Enabled and finish.
15. Log on to your development machine. Use team explorer and go to the builds folder of your sollution.
16. Right click builds and choose New build definition.
    • Put a build definition name there,
    • select the trigger,
    • select the workspace (what needs to be retrieved by the source control) and put in the build agent folder the folder created at step 10.
    • In the Build defaults select in the build controller dropdown buildmachine_2 (if it is not yet visible there restart visual studio and try again). Also put into the build output folder textbox the UNC path to the share created as step 10.
    • In the project file put the source control path to the TFSBuild.proj if you have it already, if not you should be able to create it from this tab
    • done here. After saving this you should see your build definition in the builds folder in team explorer.
17. In the TFSBuild.proj file (seen at last step of step 16) modify:
    • BuildMachine – buildmachine_2 – this is just to make sure because it should be ignored normally
    • BuildDirectoryPath – put the full name of the directory created at step 10 (not the UNC path! but the path as seen when logged-on on the build machine, like “c:\b\pname”)
18. Done. You should be able to queue a new build.

Have fun.

]]> http://sorin.serbans.net/blog/index.php/2010/07/27/configure-build-in-tfs2010-and-multiple-build-agents-on-the-same-build-machine/feed/ 0