Grant Holliday's Blog

New book: Professional Team Foundation Server 2012

Grant Holliday - MSFT — Fri, 15 Feb 2013 14:34:20 GMT

I’m very pleased to announce that our new book Professional Team Foundation Server 2012 is now available!

It’s an update to the 2010 edition that reflects all the great new features and changes introduced in Visual Studio Team Foundation Server 2012. For example, there are whole new chapters on Managing Teams, Agile Planning Tools and Integration with Project Server. There’s also new content on the new Team Explorer interface, the Code Review tools, Local Workspaces and the updated Testing and Lab Management features. Throughout the book, we also talk about how to use the cloud hosted Team Foundation Service and talk about some of how the TFS internals have changed to support the service.

We hope that you enjoy this book as much as the previous one and we look forward to reading your reviews.

ISBN: 9781118314098

You can buy the book in the following ways:

And you can preview some of the book before you buy:

The book is broken up into five sections and its written in a way that you can either read the whole thing cover-to-cover or jump in to a particular part or chapter that interests you. My personal favourite chapters are the ones in Part V – Administration, since I wrote most of them.

Part I – Getting Started

1 – Introducing Team Foundation Server 2012

2 – Planning a Deployment

3 – Installation and Configuration

4 – Connecting to Team Foundation Server

Part II – Version Control

5 – Overview of Version Control

6 – Using Team Foundation Version Control

7 – Ensuring Code Quality

8 – Migration from Legacy Version Control Systems

9 – Branching and Merging

10 – Common Version Control Scenarios

Part III – Project Management

11 – Introducing Work-Item Tracking

12 – Customizing Process Templates

13 – Managing Teams and Agile Planning Tools

14 – Reporting and SharePoint Dashboards

15 – Integration with Project Server

Part IV – Team Foundation Build

16 – Overview of Build Automation

17 – Using Team Foundation Build

18 – Customizing the Build Process

Part V – Administration

19 – Introduction to Team Foundation Server Administration

20 – Scalability and High Availability

21 – Disaster Recovery

22 – Security and Privileges

23 – Monitoring Server Health and Performance

24 – Testing and Lab Management

25 – Upgrading Team Foundation Server

26 – Working with Geographically Distributed Teams

27 – Extending Team Foundation Server

Authors

With Ed joining Microsoft since the last book, that completes the set – all four authors work for Microsoft:

Ed Blankenship is the Microsoft Program Manager for the Lab Management scenarios for Team Foundation Server and the Visual Studio ALM product family. He was voted as Microsoft MVP of the Year for Visual Studio ALM & Team Foundation Server before joining Microsoft.
Martin Woodward is currently the Program Manager for the Microsoft Visual Studio Team Foundation Server Cross-Platform Tools Team. Before joining Microsoft, he was voted Team System MVP of the Year, and has spoken about Team Foundation Server at events internationally.
Grant Holliday is a Senior Premier Field Engineer for Microsoft in Australia. Prior to this role, he spent three years in Redmond, Washington as a program manager in the Visual Studio Team Foundation Server product group.
Brian Keller is a Principal Technical Evangelist for Microsoft specializing in Visual Studio and application lifecycle management. He has presented at conferences all over the world and has managed several early adopter programs for emerging Microsoft technologies.

This time around we also had long-time TFS/ALM MVP Steve St. Jean contributing on some of the book as well as being a Technical Editor and checking all our facts.

Q & A

When people find out that I’ve written a book, there’s a few questions that often come up.

How much money do you make from the book?

A colleague wrote a book many years ago and he set my expectations right from the start. He used to say: “You don’t make a lot of money by writing a book – especially technical books”. Personally, the royalties are a nice surprise when they come, but I’m not headed for early retirement with them.

There’s really two ways that authors get paid for their contributions:

Advance – This is a fixed sum, negotiated with the publisher before you sign a contract. Usually its paid in instalments, as you complete different milestones in the process. 50% draft, final draft, etc.
Royalties – This is a how much you will get for each sale of the book. There is not a single percentage and it varies depending on whether the book was sold in the USA, e-book, translation, etc.

For a more complete explanation of how it all works, check out Charles Petzold’s article on Book Royalties and Advances.

Then there’s the non-direct value – you get to say “I wrote the book” on your business card, which is instant credibility and opens up more opportunities.

You work for Microsoft – what do they think about you writing a book?

Microsoft has a Moonlighting policy which covers things like writing a book and building apps. Essentially, each of the authors had to seek approval from their manager before they could work on the book. The policy also has rules that say you can’t use any Microsoft resources and the work is not allowed to impact your daytime work duties.

Since the subject of the book is a Microsoft product and it helps educate people on how to use it, there was never going to be much resistance to the idea.

What’s the process for writing a book?

The Wiley author site has more information on the Life of a book, but in short the process is:

Proposal > Contract > Draft writing > Editors > Tech Editors > Author Review > Proofs > Printing

How long did it take you?

Writing a book takes a lot of time and it requires a lot of concentration. It took me a little while to settle into a rhythm, but eventually my style ended up as intense focus weekends every few weeks:

Monday-Thursday: Start researching content for the chapter. Put all the links in a OneNote notebook. Do the hands on labs, etc. Basically immerse myself in the subject of that chapter and come up with a logical flow of sub-headings
Thursday night: Spend a few hours at home and take all the screenshots that I could possibly use.
Friday night, Saturday all day: Take my laptop to a local coffee shop without an Internet connection. Then just write, write, write. Fill out all the paragraphs for the sub-headings, put in all the screenshots and get the word count up to where it should be.
Sunday: Depending on where the word count was at, Sunday was usually spent reviewing and tidying up the formatting and getting it ready to submit. My goal was to upload the draft by Sunday night, since all our chapters were due on Mondays.

What is the most annoying part of writing a book?

Screenshots. We had it easy for the 2010 edition – the product was RTM, so nothing was changing. With the 2012 edition, we were writing the book before the product was released. That meant that every time the UI changed between Beta/RC/RTM/Update 1, we had to go back to check and update our screenshots.

Summary

To finish off, writing these books has been very personally rewarding experience. I saw it as a way of capturing 4-5 years worth of accumulated knowledge and experience and getting it down on paper so that others can learn from it. And hey, never in my wildest dreams did I imagine that I would see my name in Russian on the front of a book.

TFS2012: New tools for TFS Administrators

Grant Holliday - MSFT — Wed, 13 Feb 2013 10:06:55 GMT

This is a brand new feature in TFS 2012 that hasn’t really been documented or talked about yet. If you’re a TFS administrator and you browse to this address on your server, you will see a new web-based administration interface for some things inside of TFS:

http://your-server:8080/tfs/_oi/

Activity Log

The first page that we see, is a view on the TFS Activity Log. Internally, TFS has two tables in the Tfs_Configuration and Tfs_CollectionX databases called tbl_Command and tbl_Parameter. This tables keep a record of every single command that every single user has executed against TFS for the last 14 days.

In this screenshot, you can see that the following columns are displayed:

Command Id – A unique ID (per database) given to the command execution.
Application – Which component of TFS does it relate to? Version Control, WorkItem Tracking, Framework, Lab Management, etc
Command Name – The server name of the command. You can usually work out what the equivalent client/API call is – but these command names are not documented anywhere.
Status – 0 = Success, –1 = Failure
Start Time – When was the request first received by TFS
Execution Time – How long did the command run for (Divide by 1,000,000 to get seconds)
Identity Name – The user name of the user who executed the command
IP Address – IPv4 or IPv6 address
Unique Identifier – Used to group/correlate multiple server requests that originate from a single client request.
User Agent – the ‘User-Agent’ HTTP Header from the client. Tells you the name of the executable if it’s using the TFS API and what version/SKU.
Command Identifier – When using the TFS Command Line tools, this helps you correlate to what command the user was using. ‘tf get’, ‘tf edit’, etc.
Execution Count – How many times was this command executed. The logging mechanism has some smarts to reduce the noise in the log. If you download a bazillion files, it doesn’t log a bazillion individual rows in the log. It just sets this value to a bazillion for that entry.
Authentication Type – NTLM or Kerberos.

One of the things the TFS Activity Logger does, is that it logs the parameters passed in with a request when:

The command fails (i.e. a status of != 0)
Or, the command takes longer than 30 seconds

You can see these parameters by double-clicking a row in the table:

At the top of the Activity Log screen, you can also filter the log based upon Host/Collection and Identity Name. This is useful if a particular user complains about slow performance or TFS errors – you can easily look at the server logs to see what the server is seeing.

You can also click the ‘Export’ link to download a CSV file of the same content.

If you’d like to know more about how to query or interpret the contents of the TFS Activity Log – grab a copy of my Professional Team Foundation Server 2012 book and look at Chapter 23 – Monitoring Server Health and Performance.

TFS Job Monitoring

Built-in to TFS is the TFS Background Job Agent. This job agent is responsible for the scheduling and queuing of maintenance jobs and other jobs within TFS. You can see my blog post on all the different jobs in TFS 2012 for more information.

If we click the ‘Job Monitoring’ tab, we get some fairly ugly charts that give us some insight into how long the jobs are taking to execute.

There is another chart further down the ‘Job Summary’ page that shows us the number of times that a job has been run, and what was the status of each of those runs.

We can click on one of the green bars in that chart, or the blue bars in the previous chat, or the ‘Job History’ link in the navigation bar to see a different view of the TFS jobs.

This view shows us the number of jobs that were executing at a particular time, the average time that they waited in the job queue, and the average run time.

If you then click the ‘Job Queue’ link in the navigation bar, you can see which jobs are currently queued, their priorities and when they are expected to start.

TFS, Load Balancers, Idle Timeout settings and TCP Keep-Alives

Grant Holliday - MSFT — Wed, 13 Feb 2013 09:16:13 GMT

Since TFS 2010, it has been possible to have multiple Application Tier servers configured in a load-balanced configuration. If you use something like a F5 BIG-IP LTM device, then the default Idle Timeout settings for the TCP Profile can cause problems. (But don’t despair, read the whole post).

Here’s the scenario:

Between the TFS ASP.NET Application and SQL Server, there is a maximum execution timeout of 3600 seconds (1 hour)
In IIS/ASP.NET there is a maximum request timeout of 3600 seconds (it’s no coincidence that it matches)
This allows TFS operations to run for up to an hour before they get killed off. In reality, you shouldn’t see any TFS operations run for anywhere near this long – but on big, busy servers like the ones inside Microsoft, this was not uncommon.

Load balancers, in their default configuration usually have an ‘Idle Timeout’ setting of around 5 minutes. The reason for this is that every request that stays open, is consuming memory in the load balancer device. A longer timeout means that more memory is consumed and it’s a potential Denial-of-Service attack vector. (Side note: What’s stopping somebody using TCP Keep-Alives like I describe below to keep a huge number of connections open and have the same DoS effect?)

So why is this a problem if your ‘Idle Timeout’ is set to something less than 3600 seconds? This is what can happen:

The client makes a request to TFS – for example: “Delete this really large workspace or branch”. That request/connection remains open until the command completes.
The TFS Application Tier then goes off and calls a SQL Stored Procedure to delete the content.
If that Stored Procedure takes longer than the ‘Idle Timeout’ value, the load balancer will drop the connection between the client and the application tier.
The request in IIS/ASP.NET will get abandoned, and the stored procedure will get cancelled.
The client will get an error message like ‘The underlying connection was closed: A connection that was expected to be kept alive was closed by the server’. Basically, this means that the connection got the rug pulled out from under it.

Prior to Visual Studio & Team Foundation Server 2012, I recommended that people talk to their Network Admin guys and get the load balancer configuration updated to a higher ‘TCP Idle Timeout’ setting. This usually involved lots of back-and-forth with the grumpy admins, and eventually you could convince them to begrudgingly change it, just for TFS, to 3600. If you think that you’re hitting this problem – one way to verify is to try the same command directly against one of your application tier servers, rather than via the load balancer. If it succeeds, then you’ve likely found your culprit.

HTTP Keep-Alives

If you’ve administered web sites/webservers before, you’ve likely heard of HTTP Keep-Alive. Basically, when they’re enabled on the client and the server, the client keeps the TCP connection open after making a HTTP GET request, and reuses the connection for subsequent HTTP GET requests. This avoids the overhead of closing and re-establishing a new TCP connection.

That doesn’t help our Idle Timeout problem, since we only make a single HTTP request. It’s that single HTTP request that gets killed halfway through – HTTP Keep-Alives won’t help us here.

Introducing TCP Keep-Alives

There’s a mechanism built-in to the TCP protocol that allows you to send a sort-of “PING” back and forth between the client and the server, but not pollute the HTTP request/response.

If you have a .NET client application, this is the little gem that you can use in your code:

webRequest.ServicePoint.SetTcpKeepAlive(true, 50 * 1000, 1000); // Enable TCP Keep-Alives. Send the first Keep-Alive after 50 seconds, then if no response is received in 1 second, send another keep-alive.

In this example NetMon network trace:

I deployed a web services to Windows Azure, where the load balancer had a TCP Idle Timeout set to 5 minutes (this has changed lately in Azure now that they moved to a software based load balancer).
This web services was coded to do a Thread.Sleep(seconds) for however long I told it to, then send a response back.

First of all, you’ll notice that I did this investigation quite some time ago (~2 years…). Next, you’ll see that there’s some other traffic that happens on my connection between the HTTP:Request at frame 179 and the HTTP:Response at frame 307. Those are the TCP Keep-Alive ‘PING’ and ‘ACK’ packets.

Finally, you can see that after 320 seconds have passed (i.e. 20 seconds after the load balancer should’ve closed the connection), I get a valid HTTP:Response back. This means that we have successfully avoided the load balancer killing our connection prematurely.

What’s in it for me?

The whole reason I did this investigation was when I was working on the TFS team and they were getting ready to launch the Team Foundation Service. Although it was quite rare, there were instances where users could hit this TCP Idle Timeout limitation.

The good news is that by working with the rock star dev on the Version Control team, Philip Kelley – we were able to include a change in the TFS 2010 Forward Compatibility update and the TFS 2012 RTM clients to send TCP Keep-Alives every 30 seconds, thus avoiding the issues altogether when talking to the Team Foundation Service, and on-premises TFS servers deployed behind a load balancer. You can see this for yourself in Microsoft.TeamFoundation.Client.Channels.TfsHttpRequestHelpers.PrepareWebRequest().

webRequest.ServicePoint.SetTcpKeepAlive(true, 30000, 5000);

A caveat

If you don’t have a direct connection between your client and your server, and you go via a HTTP proxy server or something like ISA/ForeFront Threat Management Gateway – the TCP Keep-Alive packets aren’t propagated through those proxies. You’ll get an error back with something like ‘502: Bad Gateway’, which basically means that the connection between the Proxy server and the TFS server was dropped.

Here’s what the NetMon trace looks like for this example:

TFS: How to Customize Work Item Types

Grant Holliday - MSFT — Wed, 13 Feb 2013 08:21:38 GMT

Team Foundation Server has allowed you to modify your Work Item Type Definitions since the first version of TFS. (Side note: this is not the case with the Team Foundation Service, but the team hopes to enable that at some point in the future. At the moment, limiting the customization allows them to innovate the features in the Service at a faster pace without having to worry too much about everybody's customizations.)

The fundamentals for modifying Work Item Types are documented in the following places:

Customize Project Tracking Data, Forms, Workflow, and Other Objects
Process Editor - Team Foundation Server Power Tools (Once you have it installed, see the help file at: C:\Program Files (x86)\Microsoft Team Foundation Server 2012 Power Tools\Help\ProcessEditor.mht)
Customizing and Managing Work Item Types [witadmin]
witAdmin: Administering Objects for Tracking Work Items
Process Templates and Tools

In this post, I'm going to show you the tools and process that I personally use for customizing work item types.

Prerequisites / Tools

Real (Production) TFS server / project
Test (Staging) TFS server / project
ExportWITDs.cmd - A batch file (included below) that uses the 'witadmin.exe exportwitd' command
ImportWITDs.cmd
Visual Studio, XML editor with IntelliSense
Checkin.cmd - A batch file that uses tf.exe to prompt for a comment and check-in current changes.
Team Foundation Server Power Tools - Process Editor

Workflow

When I'm working with a customer and doing a series of process template or work item type customization, this is the workflow that I follow:

Run a script to export all Work Item Type definitions to my local machine
Check-in a copy of the definitions to source control, so that we have a baseline to work from and revert back to
Edit the XML definitions in Visual Studio as XML, with IntelliSense (see below)
Run a script to import the definition to my Test project
Verify the changes in a second copy of Visual Studio
Check-in the changes
Run a script to import the definition to my Production project

Step 1 - Export all work item types

The following script exports a list of the work item type names to a temporary file, then uses that list to export each of the work item types to a separate file in the current directory. It needs to be run from a Visual Studio Command Prompt, or you need to add ‘C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\ide’ to your PATH environment variable.

ExportWITDs.cmd:

SET collection="http://tfs-server:8080/tfs/DefaultCollection"

SET project="Project XYZ"

witadmin listwitd /collection:%collection% /p:%project% > %temp%\witd.txt

:: Remove quotes from project name

SET _string=###%project%###

SET _string=%_string:"###=%

SET _string=%_string:###"=%

SET _string=%_string:###=%

for /F "delims=" %%a in (%temp%\witd.txt) do witadmin exportwitd /collection:%collection% /p:%project% /n:"%%a" /f:"%3_%_string%_%%a.xml"

Step 2 - Check-in a copy

There’s no script for this step, since it’s a one-time thing. Just use Visual Studio, or ‘tf add . /R’ followed by ‘tf checkin . /R’

Step 3 - Open with XML Editor

See my previous blog post on how I enable IntelliSense for editing work item types as XML.

Step 4 - Import the changes to Test

Importing the changes is relatively straightforward. When I am rapidly iterating on a Work Item Type design, I like to create a 'ImportWITDs.cmd' batch file that imports everything that I'm currently working on. Then I can just leave a command prompt open and run it whenever I feel like it.

Now, for the seasoned witadmin pros, you'll know that there's also a '/v' option that allows you to validate the changes before you actually upload them to the server. In my experience, this is a waste of time - two reasons:

If the XML is invalid, then it's going to fail if you try and upload it without validating first.
The validation process doesn't validate everything - it misses some things. (I forget the specific cases, but I think it was something like fields that already exist or something like that).

So because of these two reasons and coupled with the fact that I'm also uploading to a test server first - I skip the '/v' validation step and try the import directly.

ImportWITDs.cmd:

SET collection="http://tfs-server:8080/tfs/DefaultCollection"

SET project="Project XYZ"

witadmin importwitd /collection:%collection% /p:%project% /f:"_DefaultCollection_Task.xml"

witadmin importwitd /collection:%collection% /p:%project% /f:"_DefaultCollection_Bug.xml"

witadmin importwitd /collection:%collection% /p:%project% /f:"_DefaultCollection_Issue.xml"

witadmin importwitd /collection:%collection% /p:%project% /f:"_DefaultCollection_Shared Steps.xml"

witadmin importwitd /collection:%collection% /p:%project% /f:"_DefaultCollection_Test Case.xml"

Step 5 - Verify the changes

Once I've run the ImportWITDs.cmd script, and it completes without any errors - then it's time to verify the changes. To do this, I normally have a second copy of Visual Studio open.

Before hitting 'Refresh' in Team Explorer, it's important to close all existing Work Item tabs. As having an open query or work item, can cause the metadata not to be reloaded correctly – then you start to wonder whether your changes were uploaded successfully or not.

Once everything is closed, hit the 'Refresh' button at the top of Team Explorer. Then go ahead and open a New Work Item form for the type that you have just modified.

Step 6 - Check-in the changes

If you have verified the changes and everything looks great - it's a good idea to check the XML in to source control. This gives you a point that you can roll-back to in the future. It also helps your successor understand what changes have been made to the work item types and why they were made.

After checking in the changes, we also check-out all the files again. (This is not strictly necessary if you are using Visual Studio 2012 and Local Workspaces, since the files will be read-write on disk and any changes will be detected anyway.)

Checkin.cmd:

@echo off

SET /P comment="Checkin comment?"

tf checkin . /r /noprompt /comment:"%comment%"

tf edit . /R

Step 7 - Import the changes to Production

Once we've checked-in a copy of our changes, it's time to upload the Work Item Type changes to the Production team project. If you're making the changes on behalf of a customer, then you would have them review the changes on your Test system first.

Since I normally iterate on a set of changes a few times and upload to Production once at the end, I usually just modify the Server/Collection/Project settings in ImportWITDs.cmd and use that, rather than creating a separate batch file.

Other Tools

Although they are not part of the "normal" workflow, there are some other tools that I have used in the past for special situations.

TFS Team Project Manager

I can’t recommend this tool from Jelle Druyts highly enough for doing what I call “Bulk Administration” tasks in TFS. It lets you easily take a set of Work Item Types and upload them to all projects in your project collection. It also lets you bulk edit build definitions, build process templates, fields, source control settings and more.

Codeplex: http://teamprojectmanager.codeplex.com/
Visual Studio Gallery: http://visualstudiogallery.msdn.microsoft.com/d5c7e795-2772-4e5c-b3c6-a3eff23a4938

ExportWITDSorted.exe

This is a little tool that I wrote for myself. The use case that I wrote it for was when you a working with heavily customised work item types that you don't have the original XML for.

Although the way that you modify work item types is all in XML - that is not how the work item types are defined in the TFS database. When you tell TFS to import your work item type XML file, it shreds the XML, parses out all the fields, layouts, transitions, etc and puts them in separate SQL tables. When you tell TFS to export a work item type as XML, it does the opposite. The ordering of the elements in the XML is basically the ordering of the rows from the database. No sorting.

If you are trying to do a diff of different work item type XML files, this can be pretty frustrating. Of course you can go and get a diff tool that understands XML semantics, but Visual Studio can't do this for you.

This tool I wrote uses the same APIs that 'witadmin exportwitd' uses to get an export of the work item type, but then it iterates through the XML elements and sorts them by the 'name' attribute. This makes it a little easier to diff with a 'dumb' text-diff tool like Visual Studio or WinMerge.

using System;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.WorkItemTracking.Client;
using System.Xml;
using System.Xml.XPath;

namespace ExportWitdSorted
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args == null || args.Length != 4)
            {
                Console.WriteLine("Usage:   ExportWitdSorted.exe <collection url> <project> <work item type> <outputfile>");
                Console.WriteLine("Example: ExportWitdSorted.exe http://tfsserver:8080/Collection MyProject \"My Bug\" mybug.xml");
                Environment.Exit(1);
            }

            // Connect to TFS
            TfsTeamProjectCollection tpc = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(args[0]));
            WorkItemStore wis = tpc.GetService<WorkItemStore>();
            Project project = wis.Projects[args[1]];
            WorkItemType type = project.WorkItemTypes[args[2]];

            // Export the work item definition to an XmlDocument
            XmlDocument originalDoc = type.Export(false);

            // Create a copy of the definition and remove all the <FIELD> nodes so that we can replace them with a sorted list
            XmlDocument sortedDoc = new XmlDocument();
            sortedDoc.LoadXml(originalDoc.OuterXml);
            sortedDoc.SelectSingleNode("//FIELDS").RemoveAll();

            // Get the nodes from the original document and sort them
            XmlNode node = originalDoc.SelectSingleNode("//FIELDS");
            XPathNavigator navigator = node.CreateNavigator();
            XPathExpression selectExpression = navigator.Compile("FIELD/@name");
            selectExpression.AddSort(".", XmlSortOrder.Ascending, XmlCaseOrder.None, "", XmlDataType.Text);
            XPathNodeIterator nodeIterator = navigator.Select(selectExpression);

            // Import the sorted nodes into the new document
            while (nodeIterator.MoveNext())
            {
                XmlNode fieldNode = originalDoc.SelectSingleNode("//FIELD[@name='" + nodeIterator.Current.Value + "']");
                XmlNode importedFieldNode = sortedDoc.ImportNode(fieldNode, true);
                sortedDoc.SelectSingleNode("//FIELDS").AppendChild(importedFieldNode);
            }

            sortedDoc.Save(args[3]);
        }
    }
}

TFS2012: IntelliSense for customizing Work Item Types using XML

Grant Holliday - MSFT — Wed, 13 Feb 2013 06:52:37 GMT

Team Foundation Server allows you to modify the Work Item Type definitions. You can use a graphical interface like the Process Editor included in the Team Foundation Server Power Tool, or you can edit the raw XML.

For making changes across many work item types, I prefer to edit the raw XML in Visual Studio, since it allows me to use Find & Replace, Copy/Paste, and other useful text-editing functions.

One very useful feature of Visual Studio is IntelliSense for editing XML files. To activate IntelliSense for XML files, you need to have the XSD schema files in a special directory on your machine.

In this blog post, I will show you how you can enable IntelliSesnse for editing Work Item Tracking XML files. This gives you the flexibility of editing the raw XML, with the safety net of IntelliSense and XML validation. It's based upon an old blog post from Ben Day and updated for Team Foundation Server 2012.

Obtaining the latest schema files

Download here (11KB, Zip file)

Or, you can open Microsoft.TeamFoundation.WorkItemTracking.Common.dll from your GAC in Reflector and export out the schema files which are embedded as resources:

Setting them up so IntelliSense works

Extract the XSD files to this folder on your local machine:

C:\Program Files (x86)\Microsoft Visual Studio 11.0\Xml\Schemas

This is where the Visual Studio IntelliSense engine looks for matching schema files, when you open an XML file.

Opening Work Item Type definitions in XML editor, instead of Process Editor

If you have the Team Foundation Server Power Tools installed, the Process Editor plug-in (ProejctTemplateEditor, in the list) is set as the default handler for work item XML files. So you get this UI view, rather than the raw XML:

To change this behaviour, you can go to

File > Open …
Select the Work Item XML file
Instead of clicking the ‘Open’ button, click the little arrow next to the ‘Open’ button and choose ‘Open With…’

You can then choose ‘XML (Text) Editor’ and optionally set it as the default editor for these files in the future.

Once you’ve followed all these steps, you get the joy of editing the Work Item Type XML file with the power and syntax checking of IntelliSense.

The entire Work Item Type XML schema is documented on MSDN at Index to XML Element Definitions for Work Item Types.

TFS2012: What are all the different Jobs built-in to TFS?

Grant Holliday - MSFT — Tue, 12 Feb 2013 22:37:00 GMT

This is a question that I get occasionally, and it’s covered in more detail in the Professional Team Foundation Server 2012 book that I wrote.

Team Foundation Server has a Job Agent built in. It’s implemented as a Windows Service that runs on your Application Tier servers. There are some tables and stored procedures in the Tfs_Configuration database and your collection databases that define the jobs, the job queue and the job history. You can read more about the internals of the TFS Background Job Agent in Chris Sidi’s blog post, including how to control it using the TFS API and PowerShell.

The following table describes all of the jobs across the configuration and collection databases and their default schedule:

Job Name	Scheduled Interval
Build Cleanup Job
Build Information Cleanup Job	2 days
Build Warehouse Sync	30 minutes
Cleanup Discussion Database	daily
Cleanup TestManagement Database	daily
Common Structures Warehouse Sync	30 minutes
File Container Cleanup	daily
Job History Cleanup Job	2 days
Message Queue Cleanup Job	2 days
Optimize Databases	7 days (collection) 1 day (configuration)
Prune Registry Audit Log	7 days
Repopulate Dynamic Suites	hourly
Security Identity Cleanup Job	daily
Synchronize Test Cases	10 minutes
Team Foundation Server Activity Logging Administration	2 days
Team Foundation Server Coverage Analysis	hourly
Team Foundation Server Event Processing	daily
Team Foundation Server Framework Data Cleanup	daily
Team Foundation Server Framework File Service Cleanup	daily
Team Foundation Server Send Mail Job	daily
Test Management Warehouse Sync	30 minutes
Upgrade - Version Control Code Churn Online
Version Control Administration	5 days
Version Control Code Churn	daily
Version Control Delta Processing	daily
Version Control Statistics Update	daily
Version Control Warehouse Sync	30 minutes
Work Item Tracking Administration	daily
Work Item Tracking Integration Synchronization	hourly
Work Item Tracking Referenced Identities Update	7 days
Work Item Tracking Remove Orphan Attachments	daily
Work Item Tracking Remove unused constants	14 days
Work Item Tracking Warehouse Sync	30 minutes

The ones that I often get questions about are the following:

Optimize Databases – This will reorganize/rebuild any indexes in SQL that exceed the fragmentation threshold
TFS Activity Log Administration – This will purge data in the activity log (tbl_Command) that is older than 14 days
Version Control Code Churn Online – This is a once-off job that runs after upgrade from TFS2010 to TFS2012. The format for storing the code churn data changed, so rather than converting that data during upgrade, it was done slowly over time post-upgrade by this job.

Update: Thanks for the comment Tommy - I forgot a very important aspect of some of these jobs. Although the default schedules are listed above, some of them are queued 'on demand' by events that happen in TFS. Two examples of this are:

Team Foundation Server Event Processing - This job is responsible for sending out email alert subscriptions and SOAP alert subscriptions. For example, when a work item is changed - this job is queued on demand to process any alerts.
The various Warehouse Sync jobs - These jobs are also triggered to run when data changes as well. By default, they don't run more often than every 5 minutes.

Another concept which you might come across is 'Host Dormancy'. This is a feature built-in to the 'kernel' of TFS that will pause jobs from running if a collection hasn't been accessed in a period of time. If a collection isn't being accessed, that means that the data isn't changing, so there's no need to run some jobs. This is key functionality that allows the Team Foundation Service to scale to thousands of collections.

Getting started on your new Microsoft Surface RT

Grant Holliday - MSFT — Mon, 17 Dec 2012 14:35:58 GMT

So, you've just unpacked your brand new Microsoft Surface with Windows RT. What now? Where do you start? Here's my list of things to do and hopefully it helps you.

Step 1 – Choose the right Microsoft account / Windows Live ID

"Microsoft account" is the new name given to "Windows Live ID". You might know it as your "Hotmail account" or your "Xbox Live login".

If you have a Windows Phone, then it's a good idea to use the same account that your phone is associated with. Then you will get all the goodness of a common SkyDrive and roaming settings (for apps that support it).

To find which account you're using on your Windows Phone:

On Start, flick left to the App list, tap Settings , and then tap Email+accounts.
Look for the first email account in the list that is named "Microsoft account" or "Windows Live".

Tip: If you renamed your primary account to something other than "Microsoft account" look for the first account that is listed with the Windows logo next to it.

Step 2 – Secure your Surface

With Windows 8, you no longer have to create a separate logon to your machine. You can just login using your Microsoft account and password. If you haven't set this up already, follow these steps to set it up:

From the Settings charm (swipe from the right of the screen), tap or click Change PC settings (at the very bottom of the screen).
In the left pane, tap or click Users.
Tap or click Switch to a Microsoft account and follow the instructions.

Create a picture password

One of the things that gets tiresome pretty quickly on a touch device, is having to type in your complex password all the time. This is easily solved by creating a picture password.

If you want to know more about picture passwords, see the following blog posts on the Building 8 blog: Signing in with a picture password and Optimizing picture password security

Step 3 – Apply latest Windows Updates

On the Surface RT, this is a critical step. The December 2012 updates include a firmware update that dramatically improves battery life. Also, since the Surface ships with the "Preview" version of Office 2013, you will need to download the update to the final version.

In total, it will be about 700MB of updates and one or two reboots – so it's a good idea if you are connected to a fast network and do it when you have some time to spare. Since this is such a large update, it's a good idea to do it proactively rather than wait for Windows to automatically do it for you.

From the Settings charm (swipe from the right of the screen), tap or click Change PC settings (at the very bottom of the screen).
In the left pane, scroll to the bottom and tap or click Windows Update.
Tap or click Check for updates now.
Repeat the process until there are no more updates to install.

Step 4 – Download a Windows theme

A theme is a combination of desktop background pictures, window colours, and sounds. Of course you can customise these things yourself, but it's very convenient to just apply a theme that catches your eye.

Browse the Windows themes
Terra Dynamic theme (95+ images, updated periodically)
Panorama themes (if you have dual monitors)

Step 5 – Apps from the Windows Store

Updating all your apps to the latest versions

If there are updates available for any of your installed apps, then the Store app Live Tile will have a little number on it, indicating the number of updates available.

Open the Store app and click the 'X updates available' text in the top right corner.

Re-installing apps that you have on another Windows 8 PC

A convenient feature of the Windows Store app lets you see which apps that you have previously installed on another Windows 8 PC. From this screen, you can then select all the apps and install them on your new Surface.

On the Start screen, tap or click Store to open the Windows Store.
Swipe down from the top edge of the screen, and then tap Your apps. (If you're using a mouse, point to the top of the screen, right-click, and then click Your apps.)
Choose the apps you want to install, and then tap or click Install (from the bottom of the screen).

Essential apps for your Surface RT

OneNote – Although your Surface comes with the Desktop version of OneNote pre-installed, there is a Metro Windows Store version of OneNote available from the Store. It's pretty much the app for using your Surface in meeting to take notes. (I used it to draft this blog post, before copying and pasting over to Word 2013).

Lync – If you have access to Lync either via your work or an Office 365 subscription, then you'll want to download the Lync app. You can use it to have IM conversations join video conferences and make phone calls. If you allow it, it can run in the background all the time while you are using your Surface.

Skype – Now that Skype supports signing in with a Microsoft account, if you have logged on to Windows using a Microsoft account, it will automatically sign you in. This is one of the reasons why it's so important to get your Microsoft accounts in order.

Xbox SmartGlass – lets you control your Xbox from your Surface and view extra context about movies and games. See the Xbox SmartGlass Walkthrough video for more details.

Wordament – built by two Microsoft employees in their spare time, Wordament is just like Boggle – but you compete with hundreds of other players on the same board at the same time. Caution: it's addictive, especially once you start unlocking Xbox Live achievements for it (try playing in your non-native language for some fun..)

Step 6 - Configure your mail account(s)

Let's start with the bad news. There is no Outlook for Surface RT and the built-in Mail app is functional, but not great. The good news is that it supports multiple accounts (Exchange/Outlook.com/Hotmail/etc) and it integrates with the lock screen to show you unread messages.

How do I add my email account to Mail?

One of the things I like to do to my email accounts is customise the email signatures:

On Start, tap or click Mail.
Swipe in from the right edge of the screen, and then tap Settings.
(If you're using a mouse, point to the upper-right corner of the screen, move the mouse pointer down, and then click Settings.)
Tap or click Accounts.
Tap or click the account you want to change the signature for.
Decide how you want to change your signature:
Set Use a signature to either On or Off.
If you're using a signature, change the text. At this time, there aren't any options to add images or change font settings (like color or type) in your signature.

Step 7 – HomeGroup

A homegroup is a group of PCs on a home network that can share files and printers. Using a homegroup makes sharing easier. You can share pictures, music, videos, documents, and printers with other people in your homegroup.

One feature that existed in previous versions of Windows is HomeGroup. It's well worth the effort to set up the computers in your house on the same HomeGroup. I've never quite realised the benefits of HomeGroup until recently (see File History on the next step). Once you have connected your Surface to your home WiFi network, follow these instructions:

HomeGroup from start to finish

Step 8 – Continuous backups with File History

Have you thought about a backup strategy for your Surface? Obviously if you're storing all your documents/pictures/notebooks in your SkyDrive, then you will have a copy up there. But what about all those other files on your Surface?

This is where File History comes in. It's a continuous backup of all the files in your Library folders. It keeps multiple versions as well, in case you need to go back to a previous version.

The beauty is when you have both HomeGroup and File History configured. Your Surface can continuously and automatically backup your files to a HomeGroup PC when you're connected at home. The HomeGroup PC can also have an external USB drive connected (with BitLocker-To-Go encryption), so then you have a continuous, secure backup of your home PC and Surface.

Step 9 – Accessorize

If you're planning on watching a bunch of movies on a long plane trip or you just feel comfortable having more storage, you should invest in a large, fast microSD card. The Surface RT supports up to 64GB, which makes the SanDisk Ultra 64GB Class 10 microSD a good choice:

Personally, I like the safety blanket of a real mouse. A touchscreen is great and the touchpad on the keyboard is great as well, but for high-precision or mouse-intensive work, a real mouse is nice to have in your bag.

Most of the Microsoft mice that have come out in the last few years have had little USB dongles called "Nano transceivers". There's nothing wrong with those and they will all work with the Surface – but it does mean that you have to put the transceiver in your single USB port. A nicer looking option is to get one of the new Microsoft Wedge mice that use Bluetooth – no dongles.

Step 10 – Start building apps

If you have any sort of interest in building apps for the Windows Store, you'll want to do two things:

Although you can't write apps directly on the Surface, you can deploy and debug apps on your Surface from your development PC. See the following links:

And of course, if you want to track your work and store your code somewhere, you can sign up for free to http://tfs.visualstudio.com/

TFS2012: Monitoring Management Pack

Grant Holliday (granth) — Mon, 10 Dec 2012 00:08:13 GMT

The Visual Studio 2012 Team Foundation Server Monitoring Management Pack for monitoring TFS with System Center Operations Manager 2007 SP1 or 2012 is now available. You can download it here.

The Team Foundation Server 2012 Monitoring Management Pack provides both proactive and reactive monitoring of Microsoft Team Foundation Server 2012. It monitors TFS components such as application tier server instances, team project collections, build servers, and proxy servers.

Feature Summary
The monitoring provided by this management pack includes availability and configuration monitoring, performance data collection, and default thresholds. You can integrate the monitoring of Team Foundation Server components into your service-oriented monitoring scenarios.

Auto discovery of TFS components

Implements containment hierarchy, reflecting logical architecture of the Product

Implements a proper health model using Monitors

Contains tasks, diagnostic and recovery for certain failures

Provides events that indicate service outages

Provides alerts that show configuration issues and connected data source changes

Verification that all dependent services are running

Here’s a screenshot of the Health Explorer view, where you can see some of the monitors for some of the TFS events in the event log.

And here’s an example of the Availability Report available through SCOM for the application tier.

This monitoring pack has a dependency on and is meant to be used in conjunction with Microsoft Visual Studio Team Foundation Server 2012. For monitoring TFS2010, see the Visual Studio 2010 Team Foundation Server Monitoring Management Pack.

Visual Studio and Team Foundation Server 2012 Update 1 is now available

Grant Holliday (granth) — Mon, 26 Nov 2012 23:56:29 GMT

The Visual Studio Updates are a new mechanism that the team is using to provide ongoing value through the year to Visual Studio and Team Foundation Server customers. For more information on the updates, see:

Visual Studio 2012 Update 1
Visual Studio 2012 Update 1 Now Available (Soma’s Blog)
Visual Studio 2012 Downloads Page
What's New in Visual Studio 2012 (note the sections: “New in Visual Studio 2012 Update 1”)

Downloading the updates

Visual Studio 2012 Update 1 (web installer)
Team Foundation Server 2012 with Update 1 (web installer or 1.1 GB ISO file)

You’ll notice that there is no standalone or ISO installer available for the Visual Studio update. Fortunately you can still download all the packages locally and use that without being connected to the Internet. Just download the web installer, then run it with /Layout as the command line parameter.

en_visual_studio_2012_x86_update_1_1203928.exe /Layout

The installer will then run and prompt you where you would like to download the packages to, and then run through the process of downloading the packages without actually installing them.

This will then create a ‘packages’ folder with all the installation media that can be used to do an offline install of Visual Studio 2012 Update 1.

Brian Harry has blogged a list of improvements in TFS2012 Update 1. The major ones are:

Kanban support in TFS Web Access
Extend TFS server side path limits from 260 characters to 400 characters
Usability improvements for Version Control
TFS web access usability improvements
SCVMM 2012 SP1 support with Lab Management for Windows 2012 hosts

TFS Administration Tool 2.2 Released

Grant Holliday (granth) — Sun, 25 Nov 2012 01:29:09 GMT

I am pleased to announce that the TFS Administration Tool 2.2 has been released. This release works against Team Foundation Server 2012 and installs on a machine with Team Explorer 2012. You no longer need to install Team Explorer 2010 to use this tool.

Download TFS Administration Tool 2.2 (1.55 MB, MSI)

The TFS Administration Tool allows administrators to manage permissions across TFS, SharePoint and Reporting Services from one convenient interface.

Changes made:

Built the tool against the TFS2012 object model (v11.0 assemblies)
Updated the installer to look for the TFS2012 object model as a dependency
Updated the installer to support version upgrades in the future
Removed all references to 2.1 in the UI and installer
Updated assembly and installer versions to 2.2

There are no functional changes between the previous release (2.1) and this release – it was mostly just a recompile.

If you find a bug, please open an issue and include either the contents of the "Output" window or the contents of the log file saved in the "Logs" folder so that we can easily reproduce and investigate the problem.