Quick Response Sample – Command line utility to create TFS Branch Scenarios

Quick Response Sample – Command line utility to create TFS Branch Scenarios

Rate This
  • Comments 2

Quick Response samples provide information directly from Visual Studio ALM Rangers working with the Microsoft Visual Studio Product Group and Microsoft Services, in response to feature gaps to supplement the product and knowledge base information.

Update 2012/11/22 - Please refer to the Quick Response Sample – Visual Studio Extension to support the ALM Rangers Branching and Merging guidance for the latest information and Visual Studio extension support for this quick response sample solution.

image

Issue

It is not simple to implement a consistent branching model as part of team project or team creation process, that complies with the VS TFS Branching and Merging Guide.

Resolution

Team Foundation Server has extensive support for version control and branching management through the object model. You can create your own solution, using the sample command line tool, in the Quick Response download package.

Sample

To use the sample, proceed as follows:

  • Rebuild the sample code using Visual Studio 2012, whereby you require the TFS Object Model (OM).
  • Run the TfsBranchTool.exe command line tool with the /? parameter to get started.

Examples:

  • TfsBranchTool /?
  • TfsBranchTool "Main only" /?
  • TfsBranchTool "Main only" /ProjectCollectionUrl:"http://vstsr-vm2012rtm:8080/tfs/DefaultCollection" /TeamProject:QRTest /RootFolder:"$/QRTest/cmdline/test/mainonly"
  • TfsBranchTool Basic /ProjectCollectionUrl:"http://vstsr-vm2012rtm:8080/tfs/DefaultCollection" /teamproject:QRTest /RootFolder:"$/QRTest/cmdline/test/basic"
  • TfsBranchTool Feature /ProjectCollectionUrl:"http://vstsr-vm2012rtm:8080/tfs/DefaultCollection" /TeamProject:QRTest /RootFolder:"$/QRTest/cmdline/test/feature" /FeatureName:f-One
    image

Team

Coffee break with the team

image
To highlight the team’s passion, vision and reason for the sample solution design, we asked each team member a question.

  • Mattias why did you sign up to lead this quick response solution, which is now your second?
    I’ve used the Branching guidance a lot, hate manual work, and missed an integrated and automated solution. This was a great opportunity to build something really useful. Once I started to think about a vision for what we could accomplish I was stuck. Knowing I could do it, together with some great people from across the globe, it was a no brainer...
  • Vladimir what is the rules engine all about and why did you pick the implemented design?
    The actions engine (aka Rules Engine) was designed as very abstract object model which allows defining any sequence of actions and execute them in order.
    The idea was to split branch tool operations into basic actions like create SCC folder, perform branch, check in, etc. Combining those basic actions into different sequences provides us ability to cover different branching models we have in the guidance. We anticipated that branching models may change frequently and there may be necessity to add more basic operations in the future. Given that, we designed action engine to be configured through XML and to be extendable even without recompilation. Design was very simple and powerful – XML lists all actions and parameters. You may pass output parameters to next action through the macro-expandable properties. Each action identified by name and engine loads action’s handler as add-in through the Managed Extensibility Framework.
  • Tomas what is special about the command line parser?
    The command line parser is not so special, but the characteristic very much align with the Action Engine in that it does just reflect that parameters from the xml config files. So first it asks for the commands available, and then the parameters for that command. The challenge has been to build a piece of software that interacts with another piece of software without that much of a specification and very little communication except for immediate questions. It has been interesting to realize that when you think you are finished you get aware that there is something you missed. That is due to the fact that it is a Quick Response solution, that you work for just a few hours a week and cooperate with people over several time zones that puts in their weekly effort in other days than your own – this makes it really interesting, inspiring and challenging! It is nice to work with really talented and devoted people!
  • Esteban what nuggets can you share after working with Mathias to design and implement the version control logic?
    Testing the version control logic proved to be a bit tricky since we couldn’t assume that we would always have an available TFS server to test against and of course, we were not verifying TFS’s functionality. So we decided to take a look at the new Fakes framework to mock all TFS functionality. This was a really rewarding experience as we were able to unit test our version control logic without any dependencies on TFS.

Other important highlights

This quick response sample was part of the “New Deliverable Experience” validation. Read more in Raising the Quality Bar for Tooling (Part 1) and … for Documentation (Part 2).

Future plans

  • Visual Studio Team Explorer extension … coming soon!
    image --> image
  • Team Project creation wizard extension.
  • Work with the ALM Rangers / ALM MVPs to extend the tooling for the community

More ideas?

image

Leave a Comment
  • Please add 5 and 7 and type the answer here:
  • Post
  • Nice.

    If I run the tool in the directory which maps to a workspace, does it retrieves collection URL, project and root directory automatically?

    And a couple of requests:

    1. Could you release binaries?

    2. Problem description and proposed resolution are too succinct. It's not clear how the tool helps in branching.

    3. Could you make screenshots a little bigger, hardly can read them?

    Thanks

  • Paul, thank you for the candid feedback!

    0. No, the tool does not perform the auto detection. Great feature which I will raise with the team for future consideration.

    1. For the "quick" response sample solutions we cannot release binaries as this would require us to go through an additional quality and signing process, which would not allow us to release these samples "quickly". The community, however, creates tooling based on these quick response samples and they are releasing binaries, for example blogs.msdn.com/.../community-tfs-team-tools-released-on-codeplex.aspx, which is based on our blogs.msdn.com/.../quick-response-sample-command-line-utility-to-manage-team-foundation-server-teams-and-users.aspx quick response sample.

    2. The intent of the sample solution is to demonstrate an example of how to build tooling that helps you easily create the initial branching model, as outlined in the vsarbranchingguide.codeplex.com guide.

    3.  We will ensure the quality is better in future posts. In the meantime take a peek at blogs.msdn.com/.../faq-tfsbranchtool-how-do-i-customi-s-z-e-a-tfs-branching-scenario-plan.aspx which has similar images. Click on those to get bigger, crisper images.

    Hope that helps!

Page 1 of 1 (2 items)