Installing TFS 2010 SP1 will solve the problem. (Also, please install TFS 2010 SP1 CU1 to fix the issues introduced by SP1.)

After running windows update on your TFS App Tier and your Team Build machines, automated builds will begin to fail or hang.  Looking into the event log will show the error below.  (Also, see notes below for other ways to test if you have the problem.)

The exception text reads something like:

Exception Message: Could not load file or assembly ‘System.Runtime.DurableInstancing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35′ or one of its dependencies. The located assembly’s manifest definition does not match the assembly reference. (Exception from HRESULT: 0×80131040) (type BuildServerException)

Exception Stack Trace:    at Microsoft.TeamFoundation.Client.TeamFoundationClientProxyBase.ProcessHttpResponse(HttpWebResponse response, Stream responseStream, WebException webException, XmlReader& xmlResponseReader)
   at Microsoft.TeamFoundation.Client.TeamFoundationClientProxyBase.ExecWebServiceRequest(HttpWebRequest request, XmlWriter requestXml, String methodName, HttpWebResponse& response)
   at Microsoft.TeamFoundation.Build.Client.AdministrationWebService.TestBuildControllerConnection(Uri controllerUri)
   at Microsoft.TeamFoundation.Build.Client.BuildServer.TestConnectionForBuildController(IBuildController controller)
   at Microsoft.TeamFoundation.Build.Machine.ControllerService.TestService()

Unfortunately, short of rolling back the Windows Update, you’re going to have to either install TFS 2010 SP1 immediately, or work some version re-direction magic in the GAC.  This means you’re likely installing SP1 under duress, but there are very limited options.

Don’t forget to install VS 2010 SP1 as well if you have Visual Studio 2010 or Team Explorer 2010 on any of your TFS 2010 or Team Build servers.

You can find downloads here:

• TFS 2010 SP1 (KB2182621) : http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=20506
• VS 2010 SP1 Web Installer (KB983509) : http://www.microsoft.com/download/en/details.aspx?id=23691
• TFS 2010 SP1 Cumulative Update 1 (KB2580221) : http://www.microsoft.com/download/en/details.aspx?id=26211

Your Team Builds will begin running immediately upon installing the TFS 2010 SP1 (and possibly a reboot), however, I really recommend getting everything up to the same versions while your in forced maintenance anyway.

1) Open up the TFS Administration Console, Select Build Configuration and click Properties on any of the Agents.

2) In the Build Agent Properties window, click the Test Connection button.  If you get the System.Runtime.DurableInstancing error, you have the problem and will need to install TFS 2010 SP1 to correct it.

Good luck!

This can raise a couple of challenges once you start to look at how you publish these samples. The issue is that a server based system will need some way to track the client side changes and with most popular version control systems this will involve the presence of extra files around the samples directories. As a consumer of the samples, the presence of these files in the published artefacts is far from ideal. I really don’t want to have the samples trying to connect to your remote server, or even a local instance of a version control provider I might not have installed.

So how do we break the dependency on the source control provider during the packaging of these samples for publishing? We could manually go through and delete all of the binding mechanisms, but that would expose us to the following types of waste:

• Defects – manual processes are more prone to defects
• Waiting – builds need to wait on the samples to be prepared for packaging
• Extra Processing – extra steps to make our packaging pick up our manually cleansed samples

We can avoid most of this waste by automating the process. So if it’s able to be automated, how do we do it?

Prerequisites

Download the following script https://gist.github.com/967976. This script is written originally by Damian Maclennan, and essentially removes the TFS source binding files, solution and project elements that reference the TFS instance.  My fork includes the ability to decide on if you want the files backed up before removal of the version control sections. I usually choose not to, I don’t want the backup files in the output and have the actual versions in version control if I need them. In addition you may want to do the following:

• Create a batch file wrapper for the script using the approach defined by Jason Stangroome at http://bit.ly/kmyfY2
• Commit the script to a path in your repository that is part of your build workspace with the same name as the PowerShell script

First Step: Create a custom build template

• Setup a build to create your packages, and when you get to choosing the process template clone the default template into a new template
• Check the new template into source control

Second Step: Set up a folder to publish to

• Open your cloned template and navigate to the point at which MSBuild is invoked with the ‘Build’ target
• Drop in a new sequence activity and name it ‘Publish Samples’

• Create an argument named ‘SampleDropFolder’.
• This will be the configurable name for the folder placed in the output directory with our samples inside.
• We’ll talk about how to surface this on the build configuration dialogue later.

•  Create a variable to hold the full path to the output folder.
• I’ve named mine ‘SamplesDropFolder’ but that may be a bit close to the argument name for you.
• I also default this to a combination of the outputDirectory variable specified in the scope of the Compile and Test activity and the SampleDropFolder argument we’ve specified previously.

• Open up your ‘Publish Samples’ sequence activity and drop in a ‘Create Directory’ activity.
• Configure it with the ‘SamplesDropFolder’ variable we set up in the last step.
• This will set up a root directory we can copy all our samples to, and makes it easy to run our binding removal script later on.

Third Step: Copy the samples

Now we’ve got our directory, we need to work out what we want to put in it. In most cases, we’ll have more than a single set of folders to move, so we need to put some smarts around how we identify our targets.

• First create an Argument called ‘Samples’ and configure it to be of the type String[].

• Drop a ForEach activity into the ‘Publish Samples’ sequence and configure it to iterate over our Samples argument we just created.
• Add a variable to contain the local path of the sample directory we’re currently working with as a string with the name ‘sampleLocalPath’
• Inside the ForEach activity drop a ‘ConvertWorkspaceItem’ activity. This will take our server paths and work out the local path for the directories for us. You’ll need to configure it as follows:

• Drop in a ‘CopyDirectory’ activity to copy our sample directory from the source to the output directory.  Your ForEach should now look something like this:

Fourth Step: Remove the source control bindings

Now we’ve got our samples into the target directory, we need to strip out the source control bindings so our customers don’t try to connect to our server when they open the solutions.

• Add an Argument to specify the server path to the batch file we checked in back at the start of the process.

• Create a variable to house the local path of our binding removal script. I’ve named mine ‘SourceControlRemovalScriptLocalPath’
• Drop in another ‘ConvertWorkspaceItem’ activity after your ForEach activity. This will be used to convert the argument we just created with the server path to our source binding stripping script to its local path.  It should be configured like this:

Note: While the variables look like they are the same item, they aren't I promise!

• Drop in an ‘InvokeProcess’ activity after the ‘ConvertWorkspaceItem’ you just added.  A little care is required when configuring this activity to ensure we get a reliable execution, so I’ll list out how I’ve configured each property.

Arguments: Microsoft.VisualBasic.Chr(34) + SamplesDropPath + Microsoft.VisualBasic.Chr(34)

Display Name: Strip Source Control Bindings

File Name: Microsoft.VisualBasic.Chr(34) + SourceControlRemovalScriptLocalPath + Microsoft.VisualBasic.Chr(34)

Working Directory: BinariesDirectory

Any other properties remain unaltered from their default state

Your publish samples sequence activity should now look a little like this

Fifth Step: Surface the arguments

That’s nearly everything we need to do to support the publishing of samples into our output directory. However we’ve set up a few arguments in here to ensure our template is re-usable. We now need to surface them to users via the build configuration dialog. To do this:

• On the ‘Metadata’ Argument for the build workflow click the ellipsis. You should get a pop up dialog
• Configure the three arguments we’ve added as follows
• The samples list
• The samples drop folder name
• The source control removal script path
• These should be configured in the editor as follows:

The only thing that changes across the parameters are the Display Name – the name we surface to the editor, and the Parameter Name – the name we gave our argument that corresponds to this parameter

• Check in the template

Final Steps: Configure the build!

Now we’ve got our template done, let’s go configure a build! The only real point of interest here are the custom parameters we set up on our way through, so we’ll focus on them – this is a long enough read already!

The points of interest are all on the process tab, so let’s skip there. If you expand your custom section you should see something like this:

All you need to do is fill in the values, so it looks more like this:

Once that’s done, kick off a build and you should be able to locate your samples, without the binding configuration in the drop directory of your build output!

Conclusion

In this article I’ve shown you how to create a reusable template for including useful samples in your build output. I’ve used this particular approach with a few customers and what I particularly like about it is we aren’t moving too far from the out of the box activity set that comes with Team Build. This saves us on overhead, and allows the template to be put together pretty quickly.

Tagged: Publishing, Team Build, TFS

Steven Borg of Northwest Cadence (Microsoft Team System MVP) took a road trip to Portland to speak to a very interested audience about the new features of Team Build 2008, an inherent and powerful part of Visual Studio Team System 2008. 

There were a total of 68 students from 35 different companies in the Portland area.  Feedback from the attendees on what they believe was most valuable:

• “How build automation with Team Build can replace or enhance our current in-house development   system”
• “Step by step demo of MS Build and overview of ways VSTS can help my organization”
• “Using Team Build for automated deployment”
• “Learning what Build can do for us”
• “Tasks that check in to TFS can be traced in the build.  This really simplifies debugging”
• “High level oversight so as to better see the big picture”
• “References to best practices when using TFS”
• “The integration of work items and code check ins.  Setting up continuous integration”
• “Customizing the Team Build project file”
• “Implementing database scripts in build reporting”

At the end of the presentation, there were several prizes up for grabs; however, two attendees were especially lucky as the recipients of Vista Ultimate and a Microsoft Zune Digital Player.  But I think it is safe to say, all attendees were winners as they were energized by the dynamic speakers and enlightened as to the abundance of Team Build’s bells and whistles.

Let me get this straight: the guy’s name is Borg and it’s at Microsoft and you want people to voluntarily show up? No thanks I’ll just wait for them to show up at my house and assimilate me (just kidding).

Although I get that a lot with my last name, I thought this was very well written!

By the way, if you’re down in the Portland area, sign up for the Team Build presentation on November 5th, 2008.  You should also check out PADNUG, if you have an interest in all things .NET!

Upcoming Team System Events

October 24: MVP TV: Gaze into the Crystal Ball: Reporting in Team System made Easy! (Webcast)

You’ve paid your nickel and it’s time to ask the Zoltar Fortune Teller for your future: “Is my software development project going down the toilet? Will I be able to ship on time, with high quality? Can I hit my budget?” (Wait, three questions = three nickels.) Zoltar says… Let’s face it, traditional status reporting is about as accurate as I am, and worse, it takes a whole lot longer!!! Team System can help! Its built in reporting capabilities provide a strong foundation for understanding the current status of your project. Not only does it provide a series of built in reports, it gathers the metrics to allow for excellent ad-hoc reports! Using both the built in and ad hoc report capabilities, finding the current status of your project, and predicting your project’s probability of success or failure along several axis. Come learn how to predict your future! You’ll learn how to interpret the build in reports, learn what’s required to create the reports, and how to use Excel pivot tables to connect to the TFS cube for ad hoc reporting.

To register, go to: http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032391376&EventCategory=4&culture=en-US&CountryCode=US

November 5: Enterprise Build Automation w/VSTS 2008 Team System & Team Build (Portland)

Steven Borg of Northwest Cadence (Microsoft Team System MVP) will be covering some of the great new features of Team Build 2008, an inherent and powerful part of Visual Studio Team System 2008. You’ll learn to use Team Build 2008 to radically improve your code!

Come see real unit and functional tests being built, real code metrics being generated, and real work being done in an automated build. You’ll learn how to build legacy code, run tests and code metrics, rebuild your database, update your documentation, and even deploy your application into various test environments; all coordinated by a single command.

To register, go to: http://www.clicktoattend.com/?id=132684

November 15-16, 2008: Code Camp

Join Northwest Cadence and others at Code Camp where developers talk with – and learn from – fellow developers.  It is a community event and all are welcome to attend and speak.  Code Camps have been wildly successful, and we are excited to participate in this success in Seattle.  Check out https://seattle.codecamp.us for more details.

November 18: Coffee Talk – Welcome. Help Us Set the Stage! (Webcast)

We’ll briefly cover VSTS, ALM, and introduce you to the coffee talks.  Bring your questions, desires and needs.  We’ll have some fun, answer questions, and plan topics for future coffee talks.

To register, go to: http://www.clicktoattend.com/?id=132790

December 2: Coffee Talk – Visual Studio 2010 (Webcast)

You may have seen some of the fantastic new features of Visual Studio Team System 2010 (aka Rosario).  Drastically improved automated testing, architect tools that actually work, and tons of improvements to make your lives easier and time spent more productive.  We’ll cover several of the new features, and answer questions about the things you’re looking forward to.  Bring your own questions, too!

To register, go to: http://www.clicktoattend.com/?id=132791

December 4: Eagerly Awaiting VSTS 2010? (Kirkland)

Join Northwest Cadence and explore the new features of Visual Studio Team System 2010 and what it means for your business, productivity, application management, and quality. During this event, we will cover Team Foundation Server and the much-hyped hierarchical work items, new improvements to History, Merge, Work Item Queries, and the focus on Agile development.

Numerous improvements from the Architecture edition (including full support for UML 2.x) will be demonstrated, including the new Architecture Explorer which allows you to quickly and easily visualize an application from the high level down to the object dependencies. We will also highlight many Developer edition functionalities such as updated tools for performance profiling, the Historical Debugger (formerly called “Proteus”), and the ability to view affected tests based on changes to the code. Finally, we will cover the Test Edition with a focus on the “Camano” user interface, Manual Test Runner, Test Case Management, and how Team System 2010 is a strong and reliable testing platform.

To register, go to: http://www.clicktoattend.com/?id=132801

December 16: Coffee Talk – Reporting (webcast)

You may have seen some of the fantastic reports TFS provides out of the box at conferences and presentations.  We will answer lots of questions in this session: Have you wondered why the reports at your company don’t look quite as nice?  Are they missing enough data to make decisions?    What reports should you pay special attention to (Project Managers), and why should you even care about the reports (developers)?   We will also cover a few of things you need to do to really get the data into the reports and talk about how to interpret some of our favorite reports.  And, if you ask, we’ll cover how to interpret your favorites, too!

To register, go to: http://www.clicktoattend.com/?id=132792

December 30: Coffee Talk – Software Development Lifecycle

With the thousands of books and articles published on Software Development Life-Cycle (SDLC), do you ever feel overwhelmed sorting through what is hype vs. what is actually being adopted by .NET corporations?  During this Coffee Talk, we will answer this question plus others that you bring!  We will explore the complexity of software development, the current best practices for improving your Software Development Life Cycle, and industry best practices and the latest IT research.

To register, go to: http://www.clicktoattend.com/?id=132794

January 8: Eagerly Awaiting VSTS 2010? (Portland)

Join Northwest Cadence and explore the new features of Visual Studio Team System 2010 and what it means for your business, productivity, application management, and quality. During this event, we will cover Team Foundation Server and the much-hyped hierarchical work items, new improvements to History, Merge, Work Item Queries, and the focus on Agile development.

Numerous improvements from the Architecture edition (including full support for UML 2.x) will be demonstrated, including the new Architecture Explorer which allows you to quickly and easily visualize an application from the high level down to the object dependencies. We will also highlight many Developer edition functionalities such as updated tools for performance profiling, the Historical Debugger (formerly called “Proteus”), and the ability to view affected tests based on changes to the code. Finally, we will cover the Test Edition with a focus on the “Camano” user interface, Manual Test Runner, Test Case Management, and how Team System 2010 is a strong and reliable testing platform.

To register, go to: http://www.clicktoattend.com/?id=1328012

Here’s a short blurb!  For more information, or to register, send an email to info@nwcadence.com.

In this free, 3 hour Team System training session, we will explore the new features of Visual Studio Team System 2010 and what it means for your business, productivity, application management and quality. The areas we will cover are Team Foundation Server and the much hyped hierarchical work items as well as improvements to History, Merge, Work Item Queries and the focus on Agile development. The Architecture editions numerous improvements (including full support for UML 2.x) will be demonstrated as well as the new Architecture Explorer which allows you to quickly and easily visualize an application from the high level down to the object dependencies. The developer edition provides updated tools for performance profiling, the Historical Debugger (formerly called “Proteus”) and the ability to view affected tests based on changes to the code. Finally, we’ll cover the Test Edition with a focus on the “Camano” user interface, Manual Test Runner, Test Case Management and the fact that Team System 2010 is a reliable testing platform with the features you expect it to have!

Here’s a brief blurb.  To learn more, send an email to info@nwcadence.com.

The focus of this training course is on the effective use of Team System to improve an organization’s application management lifecycle. Software teams will learn not only how to use Team System effectively, but how to use Team System to improve their software development process. Developers will learn improve the quality of their code and speed development. Testers will learn to validate code quality and track test cases. Project managers will learn to use Team System to bring their projects under control. Configuration Managers will learn the best practices around branching strategies and will learn to create a tailored software configuration management strategy. As a team, you will learn how to use TFS to increase traceability, improve the quality of your code and ease the process of releasing your applications.

All the Interaction of the MSDN Chats but with the richer experience of Live meeting and hosted by the recognized world technology leaders –the Visual Studio Team System Microsoft MVP’s.
– Charles Sterling on MVP TV

I’m on TV!  MVP TV, that is!  I’ll be doing Gaze Into the Crystal Ball: Reporting in Team System made Easy! You can register for the event at the link above (or the one below!).

Here’s the announcement:

MVP TV: Gaze into the Crystal Ball: Reporting in Team System made Easy!

Target: This Product Group Interaction is open to all Developer MVPs in all Technical Expertise and public audience.

You’ve paid your nickel and it’s time to ask the Zoltar Fortune Teller for your future: “Is my software development project going down the toilet? Will I be able to ship on time, with high quality? Can I hit my budget?” (Wait, three questions = three nickels.) Zoltar says… Let’s face it, traditional status reporting is about as accurate as I am, and worse, it takes a whole lot longer!!! Team System can help! Its built in reporting capabilities provide a strong foundation for understanding the current status of your project. Not only does it provide a series of built in reports, it gathers the metrics to allow for excellent ad-hoc reports! Using both the built in and ad hoc report capabilities, finding the current status of your project, and predicting your project’s probability of success or failure along several axis. Come learn how to predict your future! You’ll learn how to interpret the build in reports, learn what’s required to create the reports, and how to use Excel pivot tables to connect to the TFS cube for ad hoc reporting.

Note: The original delivery of this presentation was the second highest rating of all TechEd 2008 presentations and Steve has made it even BETTER!!

About Steven Borg: Steven Borg is a principal of Northwest Cadence, a Microsoft VSTS Inner Circle partner, that focuses exclusively on helping companies improve their Application Lifecycle Management using Team System. At Northwest Cadence, he is the VSTS Practice Lead, and has worked with dozens of corporations to improve their overall software development process, including identifying and reporting appropriate metrics supporting process improvement. In addition, he assists the Team System community as a Team System MVP.

Meeting Credentials:
Event URL: https://www.livemeeting.com/cc/mvp/join?id=ST6NTP&role=attend&pw=4449ml+WK3W

Event ID: 1032391376

Here’s the invite:

Enterprise Build Automation with VSTS 2008 Team System and Team Build

Steven Borg of Northwest Cadence (Microsoft Team System MVP) will be covering some of the great new features of Team Build 2008, an inherent and powerful part of Visual Studio Team System 2008. You’ll learn to use Team Build 2008 to radically improve your code!

Come see real unit and functional tests being built, real code metrics being generated, and real work being done in an automated build. You’ll learn how to build legacy code, run tests and code metrics, rebuild your database, update your documentation, and even deploy your application into various test environments; all coordinated by a single command.

This seminar is intended to provide demonstrations that will be most relevant to developers, testers, build and release engineers.

Date: November 5, 2008

Time: 9am – noon

Location: Microsoft Corporation, 10260 SW Greenburg Rd, Suite 600, Portland, OR 97223

To register:

http://www.clicktoattend.com/?id=132684

The screen shots below detail how the targets file is set up, how to use it within your build, and the output it produces.  You can find a link to download the targets file at towards the end of the post.

ShowAllProperties Target

The screen shot below shows an example of the custom target that was created to hold the sets of build in properties.  A PropertyGroup named ExtensibleProperties contains the built in property name and then value with each separated by a blank line (%0D%0A).

ShowAllProperties Message Output

Once all the property groups are defined for the various property category types, a message task is used to output them to the build log.

ShowAllProperties File Output

Code is also added using the WriteLinesToFile task to append all the information to a file called TeamBuildProperties.txt.  Notice there is no file path defined so the current output location of the file is the working directory of MSBuild during a TeamBuild.  If your build agent working directory is defined as C:\Work\$(BuildDefinitionPath), your Team Project is Project1, and your build definition is Build1, the local path where you would find the file would be C:\Work\Project1\Build1\BuildType\TeamBuildProperties.txt.

Targets File in Source Control

The TeamBuild.Properties.targets file where the ShowAllProperties target is defined is added to source control alongside the Team Build project definition.  Of course, in most instance you will want to be using this file across multiple build definitions so you would be better off storing it in a shared location and branching it into each project or using another strategy to maintain a single master copy in source control that can be easily maintained and utilized by multiple build defnitions.

Import Statement in TFSBuild.proj

An Import statement is used to pull the TeamBuild.Properties.targets file into the Team Build TFSBuild.proj file.  Since the targets file is added to source control at the same level as the Team Build project file, the $(MSBuildProjectDirectory) property is used to target this location.

Calling ShowAllProperties

To execute the target, the CallTarget task is used and called in the BeforeTest target in the example below.

Extensible Properties Output

The start of the property output is easily found within the build log by searching for **** which breaks up the various property categories.  Then you can see the property name and values at the time of the execution for the various categories as seen by the screen shots below.

Get Task Properties Output

Label Task Properties Output

Read Only Properties

You can download the custom targets file here TeamBuild.Properties.targets to use within your own build scripts.

I hope the ease of the targets file will help you in debugging your build scripts or stepping into team build for the first time and exploring the built in properties.  Automate your builds and enjoy!