Chandru Ramakrishnan, a TFS Version Control Platform developer who keeps our internal dogfood server humming, noticed this morning that our internal TFS Version Control dogfood server has over 1 billion rows for local versions. That is over 1 billion files/folders served to internally!
The Team Foundation Power Tools for VS2008 are now available here. This is the first release of the Power Tools that work with VS2008. We did not want to just deliver a warmed over version of the VS2005 Power Tools, so we included lot of new goodies in this release.
Find In Source Control
From the Source Control Explorer you can right click on a folder and chose Find In Source Control. There is a sub menu containing Status search, wildcard search, and changeset. Below is a screen shot from a status search of all checked out *.cs files under $/Orcas/Migration:
This search shows all users that have files checked out under the specified path along with with the workspace and machine (shown between the []) name where the pending changes exist. From this view you can checkout files, undo changes (including someone else's changes if you have permission), view history, open the file (double click), and open the folder in Source Control Explorer.
Quick Label
The labeling functionality in TFS is very powerful, but sometimes you just want to create a quick simple label on a folder. Quick label does that.
Open in Windows Explorer
Have you ever wanted to open Source Control Explorer's currently selected folder in Windows Explorer? Now you can by selecting a folder that is mapped locally, right click, and choose Windows Explorer.
Team Build Notification
Now you can be notified on your desktop by a tray application when a Team Build of interest has been queued, started, or finished. This has been a highly requested feature that we are happy to deliver in this power tool release.
The Build Notification Application will pop up a "toast" message when build status changes. Below is an example of what you would see when the build is broken.
...and much more....
- Additional TFPT.EXE commands for configuring Team Explorer connection settings (tweakui) and for destroying Work Items and Work Items Type Definitions (destroyWI, destroyWITD).
- Updates to the TFS Best Practices Analyzer for use with a Team Foundation Server 2008 deployments.
- The Process Editor is updated for use with Microsoft Visual Studio Team System 2008. It also has several improvements, including: performance improvements, improved discoverability and bug fixes.
You can discuss TFS Power Tools here or report bugs here.
Enjoy!
Back in June we released the TFS Migration and Synchronization Toolkit - a toolkit that helps migrate data between 3rd party version control and bug tracking systems and TFS. Turns out that folks also want to migrate data between two TFS servers too, so work was begun on writing a TFS to TFS migration tool based on the toolkit. A pre-release of this TFS to TFS Migration Tool is now available on CodePlex! This tool enables migration of work items and version control items with history between TFS servers. To learn more about the tool, you can visit the TFS to TFS Migration Tool page on CodePlex.
The purpose of this pre-release is for testing and stabilizing of the tool before officially releasing the tool. We are hoping to get the kinks worked while in pre-release, so please keep in mind that while we've done a good amount of testing and a few successful customer migrations, there are many scenarios that we haven't run across yet.
For feedback or support with the tool, please send mail to TfsToTfs@microsoft.com
The current TFS Power Tools support TFC/VS 2005 only. However, there are beta customers of VS2008 (aka Orcas) who want to use the check-in policies from the TFS Power Tools.
With a few manual steps (below) you can get the TFS Power Tool Check-in policies to work with VS2008 and observe how .Net binding redirects work as a bonus. I've only done some basic ad-hoc testing with this approach, so standard disclaimers apply. This is provided "AS IS" with no warranties and confer no rights. No need to consult a physician first, but please back up where stated to back up.
Place Check-in Policy Assemblies
If your client machine has TFS 2005 installed, you can install the Power Tool setup as normal (if you have not already). If your machine only has TFC/VS2008, then you will need to find a machine that has VS 2005 installed, install the Power Tools, then copy the following binaries
Microsoft.TeamFoundation.PowerTools.CheckinPolicies.ChangesetComments.dll
Microsoft.TeamFoundation.PowerTools.CheckinPolicies.CustomPathPolicy.dll
Microsoft.TeamFoundation.PowerTools.CheckinPolicies.ForbiddenPatternsPolicy.dll
Microsoft.TeamFoundation.PowerTools.CheckinPolicies.WorkItemQueryPolicy.dll
For the rest of the steps, we'll use the same default location where the Power Tools install as the location for these check-in policies, namely,
C:\Program Files\Microsoft Team Foundation Server 2005 Power Tools\Check-in Policy Pack
Modify Registry so VS2008 (Orcas) Can Find The Policies
Edit the text below and put it in a .reg file. Be sure to replace the path to your installed path if is is not the same as shown below.
Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\TeamFoundation\SourceControl\Checkin Policies]
"Microsoft.TeamFoundation.PowerTools.CheckinPolicies.WorkItemQueryPolicy"="C:\\Program Files\\Microsoft Team Foundation Server 2005 Power Tools\\Check-in Policy Pack\\Microsoft.TeamFoundation.PowerTools.CheckinPolicies.WorkItemQueryPolicy.dll"
"Microsoft.TeamFoundation.PowerTools.CheckinPolicies.ChangesetComments"="C:\\Program Files\\Microsoft Team Foundation Server 2005 Power Tools\\Check-in Policy Pack\\Microsoft.TeamFoundation.PowerTools.CheckinPolicies.ChangesetComments.dll"
"Microsoft.TeamFoundation.PowerTools.CheckinPolicies.CustomPathPolicy"="C:\\Program Files\\Microsoft Team Foundation Server 2005 Power Tools\\Check-in Policy Pack\\Microsoft.TeamFoundation.PowerTools.CheckinPolicies.CustomPathPolicy.dll"
"Microsoft.TeamFoundation.PowerTools.CheckinPolicies.ForbiddenPatternsPolicy"="C:\\Program Files\\Microsoft Team Foundation Server 2005 Power Tools\\Check-in Policy Pack\\Microsoft.TeamFoundation.PowerTools.CheckinPolicies.ForbiddenPatternsPolicy.dll"
Set Binding Redirects in DevEnv.Exe.Config
Since the TFS Power Tool Check-in policy assemblies reference the 8.0 assemblies, we need to configure devenv.exe to use the 9.0 assemblies whenever the 8.0 assemblies are referenced. Here is how you do that.
1. Close all instances of devenv.exe
2. Find where VS2008 (Orcas) devenv.exe is installed. Typically
C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE
3. Backup the existing devenv.exe.config file
4. Edit devenv.exe.config by adding the following in the <runtime><assemblyBinding> section:
<dependentAssembly>
<assemblyIdentity name="Microsoft.TeamFoundation.WorkItemTracking.Client" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="8.0.0.0" newVersion="9.0.0.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="Microsoft.TeamFoundation.Client" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="8.0.0.0" newVersion="9.0.0.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="Microsoft.TeamFoundation.Common" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="8.0.0.0" newVersion="9.0.0.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="Microsoft.TeamFoundation.VersionControl.Client" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="8.0.0.0" newVersion="9.0.0.0"/>
</dependentAssembly>
<dependentAssembly>
<assemblyIdentity name="Microsoft.TeamFoundation.VersionControl.Common" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
<bindingRedirect oldVersion="8.0.0.0" newVersion="9.0.0.0"/>
</dependentAssembly>
5. Save devenv.exe.config
Restart Visual Studio 2008 (Orcas)
Restart Visual Studio 2008 (Orcas) and the Power Tool check-in policies will be available.
A frequent question among TFC 2008 beta customers is about check-in policy compatability. Will check-in policies work across TFC 2005 and 2008?
The answer is that evaluation works across versions in both directions, but editing the policy definition only works in one direction (TFC 2008 can edit a TFC 2005 policy but TFC 2005 cannot edit a 2008 policy).
|
Policy Version Added |
Evaluate Policy |
Edit Policy |
|
|
2005 |
2008 |
2005 |
2008 |
|
2005 |
Yes |
Yes |
Yes |
Yes |
|
2008 |
Yes |
Yes |
No |
Yes |
Policies are enforced on the client and require the proper assemblies to be installed on the client. If you have a custom or 3rd party check-in policy that works with TFC 2005, you will need a TFC 2008 version of the policy installed on TFC 2008 machines.
What about the popular Power Tool Check-in Policies?
Currently, the Power Tools target TFC 2005 only. The next Power Tool release will support TFC 2008.
%5B2%5D_thumb.png)
Formerly known as Team Plain, the Team System Web Access Power Tool is now officially supported by Microsoft Customer Support Services. You can download it here. Brian Harry has the best post on the details. Enjoy.
Technorati Profile
I am pleased to say the TFS Migration and Synchronization Toolkit (toolkit) is officially released. You can get it here on CodePlex. 
The toolkit provides a set of classes and a reference implementation (and a good example) for migrating and/or synchronizing third party version control and work item tracking systems to Team Foundation System. The toolkit makes our lessons learned and best practices available for others to use when writing converters between their existing systems and TFS. If you follow the Team Foundation System blogs, then you've seen Brian Harry's dogfood statistics for Microsoft's internal use of TFS. Well, those changesets and bugs are migrated and synchronized with the systems we used before TFS. This is necessary because our build labs and some of our internal tools have not all been converted to TFS (yet), so we still need the previous systems. Given the volume of users, files, and bugs, we have a great deal of experience with the issues involved in migrating and synchronizing with TFS.
If you download the toolkit, I encourage you to look at the reference implementation that migrates with SharePoint (WSS). This implementaiton migrates documents between SharePoint and TFS version control as well as migrating SharePoint task lists with TFS work item tracking. By following the code in this reference implementation, you will get a good feal of how to implement your own converter from end to end.
There are a lot of version control and work item tracking systems out there that need converters! Be the first to jump on this opportunity. The toolkit makes this easy.
My wife, who is a nurse, chuckles at the computer slang she hears me use. One of her favorite terms is dogfooding. Both the origins of the term dogfooding and the benefits are quite interesting. Nothing says, "fix this problem now!" louder than running into it yourself or the peer pressure when a coworker runs or should I say, steps into it.
We started dogfooding TFS within a subset of the TFS team back in 2004. From there we have expanded to all of TFS, to the Developer Division, to the Office team, and now we are starting a roll out to the big kuhuna, the Windows team (see Brian Keller's blog). With each expansion, TFS improves in performance, scalability, and we learn more about feature gaps and improvements we need to make. This feedback often turns into power tools and future product features. This cycle feeds on itself - as we improve TFS then Microsoft's application lifecycle management improves. This is the dogfood gravy train.
See Soma's blog about what Microsoft uses for software development.
Brian Harry has the June 2007 dogfood stats here.
Sidebar: Some companies changed the "eating your own dogfood" phrase to "sipping your own champagne". I prefer the dogfood phrase because the champagne phrase sounds like you are getting intoxicated about how great your product is from slow/casual (sipping) use. That is the opposite of what you are trying to do.
Doug Neumann, one of our program managers for TFS, had a chance to do a keynote at Micro Focus World in Orlando earlier this month. For those of you not familiar with Micro Focus, they sell a set of tools for COBOL development. While preparing for the keynote, we had an opportunity to use Team System and Team Foundation Server for managing COBOL assets.
The experience works pretty well. One of Micro Focus’ tools plugs into Visual Studio for building .NET applications in COBOL. We were able to use static analysis, unit testing, code coverage, and version control in the IDE with very little work. Once we had COBOL in TFS, Team Build compiled it without any customization. Doug showed that during the demo and apparently it went over pretty well.
Micro Focus also ships their own IDE for building native COBOL applications on Windows called Net Express. That IDE supports the Microsoft Source Code Control Interface so we were able to install the TFS MSSCCI Provider to get integrated version control working. There was one catch, though. The MSSCCI spec is kind of up for interpretation by the person implementing it, so our provider has to behave differently in different IDEs. We ship a set of registry keys that are used to customize the behavior for various IDEs, but we don’t set the keys for the Micro Focus’ Net Express IDE. So, if you’re developing in COBOL and you’d like to try this out, set the following reg key to get to work properly:
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\
Team Foundation Server MSSCCI Provider\Settings\Net Express]
“issues”=dword:000000e6
Join members of the Visual Studio Team System product group to discuss features available in Visual Studio Team Foundation Server, Team Editions for Architects, Developers, Database Pros, and Testers. In addition, discuss what's new in the in the Visual Studio code name “Orcas” Beta 1 releases for Team Suite and Team Foundation Server.
We will be holding two sessions:
Join the chat on Friday, April 27th, 2007 from 10:00am - 11:00am Pacific Time. Add to Calendar | Additional Time Zones
-or-
Join the chat on Friday, April 27th, 2007 from 4:00pm - 5:00pm Pacific Time. Add to Calendar | Additional Time Zones
Just released (or should I say, prereleased) tonight on Codeplex, the TFS Migration and Synchronization Toolkit (the toolkit) Prerelease. See here. We've be working on hard on this toolkit to make availalbe the best practices we have learned from migrating and synchronizing millions of files and work items internally and for customers. If you are thinking of migrating from an existing version control or work item tracking system to TFS, you'll definitely want to check this out. Let us know what you think.
Today is "Maroon and Orange Effect" day to honor the memory of the Virginia Tech students and faculty that died on Monday. As an alum of Virginia Tech it has been a difficult week to watch and read the news. However, it has been reassuring to see the support and encouragement from many individuals and organizations. A fellow alum forwarded me the following image that universities put together as a sign of solidarity.
Team Foundation client tracing is useful for viewing what is sent betweent the TFS client and server. Instructions on how to turn this on for Visual Studio are as follows:
Visual Studio
- Shut down Visual Studio
- Using Windows Explorer navigate to the following directory:
C:\Program Files\Microsoft Visual Studio 8\Common7\IDE
(replace c: with appropriate drive) - Make a backup copy of devenv.exe.config
- Edit devenv.exe.config by adding the following before the last </configuration> :
<appSettings>
<add key="VersionControl.EnableSoapTracing" value="true" />
<add key="VersionControl.TraceDownloadContent" value="false" />
<add key="VersionControl.EnableCompression" value="true" />
</appSettings>
<system.diagnostics>
<switches>
<add name="TeamFoundationSoapProxy" value="5" />
<add name="VersionControl" value="10" />
</switches>
<trace autoflush="true" indentsize="3">
<listeners>
<add name="myListener"
type="Microsoft.TeamFoundation.TeamFoundationTextWriterTraceListener,Microsoft.TeamFoundation.Common"
initializeData="c:\tfs-tracefile.log" />
<!--<add name="perfListener" type="Microsoft.TeamFoundation.Client.PerfTraceListener,Microsoft.TeamFoundation.Client, PublicKeyToken=b03f5f7f11d50a3a">-->
</listeners>
</trace>
</system.diagnostics>
- Trace data will be written to "c:\tfs-tracefile.log" (bold above). Change this file name if you prefer
- Save the file
- Start Visual Studio
- Run steps you are interested in tracing
- Open c:\tfs-tracefile.log or whatever file you specified in step 5
- This writes alot of data, so you will want to restore to the original setting when finished by copying the original file back or commenting out the lines in step 4 by surrounding the lines with <!-- and --> .
TF Command Line
You can trace commandline traffice between tf.exe and the TFS server by doing the save as above except to tf.exe.config
Microsoft has acquired DevBiz Business Solutions, the makers of TeamPlain Web Access for Team System. TeamPlain is available at no additional charge to Team Foundation Server customers and is accessible to any user properly licensed with a TFS CAL. You can download it here. See Brian Harry's blog for more details.
March 26, 2007 marks the 10th birthday for Visual Studio. I can hear the veterans out there saying, wait a minute I was using Visual C++ way before March of 1997. That is true, but 10 years ago it was all integrated into one great development environment that is Visual Studio. Happy Birthday!
