This picture was taken by a customer’s public relations and marketing photographer for use in the company newsletter where many thought I looked like some professional wrestler. As you can see from the Office logo on the shirt it was a while ago. This was back in my Microsoft Consulting days where I actually worked on the customer’s site for a couple of years. So, today the picture is used in jest when I am trying to keep the project leads focused on the target. But, what is Ruck you ask.

Ruck is the Rugby term used to define a “loose Scrum” and we (Willy-Peter came up with the use of the word) felt it was fitting to our Ranger process. Our process is one in which we strive for agility while learning how to overcome the constraints of a Ranger team. In this role I have been assisting and mentoring the Rangers in managing their teams and getting project lead role clarity for several Visual Studio 11 Readiness projects. We have learned allot with this wave of Ranger projects and are applying the learning from our retrospectives to our Ranger process. You can learn more about our process from our MSDN article, Visual Studio ALM Rangers—Reflections on Virtual Teams. I also had the opportunity to work on the MSDN VM Factory article, Visual Studio ALM Rangers: Rise of the VM Factory and an article that was published on Code Project, How the Visual Studio ALM Rangers use Team Foundation Service to Get Ready for Visual Studio 11. We have several more MSDN articles in the pipeline so look for these in forth coming MSDN magazine issues and keep your eyes on Willy-Peter’s blog for the most recent Ranger news.

Speaking of Willy, he is one of the most hard working and passionate Rangers I know. He is a machine that seems to operate non-stop for hours on end. And he is very gracious. He had some t-shirts made for some of the Rangers and it could have been paid for out of his own pocket. Here are pictures of the shirt. So, Willy is a kind hard working machine. Thanks Willy!

As time permits I will post new features that Brian doesn't cover and that I am working on in some way - mainly through our Ranger projects. The new features for Visual Studio Team System are many and we have a new SKU as well, one of the projects I am a lead on (I am on about 5 right now) we are creating guidance that will quickly get you up and aware of what is new and how to use the new feature. Our idea is that the guidance has a razor focus so that you can brief yourself quickly. I will be sharing more about these projects and VSTS 2010 in general in future posts.

Brian.

[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
private class REPARSE_MOUNTPOINT_DATA_BUFFER
{
    [FieldOffset(0)]
    internal uint ReparseTag;
    [FieldOffset(4)]
    internal uint ReparseDataLength;
    [FieldOffset(8)]
    internal ushort Reserved;
    [FieldOffset(10)]
    internal ushort ReparseTargetLength;
    [FieldOffset(12)]
    internal ushort ReparseTargetMaximumLength;
    [FieldOffset(14)]
    internal ushort Reserved1;
    [FieldOffset(16)]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_PATH * 3)]
    internal Char[] ReparseTarget = new Char[MAX_PATH * 3];
}

/// <summary>
/// REPARSE_DATA_BUFFER class
/// </summary>
[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
private class REPARSE_DATA_BUFFER
{
    [FieldOffset(0)]
    internal UInt32 ReparseTag;
    [FieldOffset(4)]
    internal ushort ReparseDataLength;
    [FieldOffset(6)]
    internal ushort Reserved;
    [FieldOffset(8)]
    internal ushort SSubstituteNameOffset;
    [FieldOffset(10)]
    internal ushort SSubstituteNameLength;
    [FieldOffset(12)]
    internal ushort SPrintNameOffset;
    [FieldOffset(14)]
    internal ushort SPrintNameLength;
    [FieldOffset(16)]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_PATH)]
    internal Char[] SPathBuffer = new Char[MAX_PATH];
    [FieldOffset(8)]
    internal ushort MSubstituteNameOffset;
    [FieldOffset(10)]
    internal ushort MSubstituteNameLength;
    [FieldOffset(12)]
    internal ushort MPrintNameOffset;
    [FieldOffset(14)]
    internal ushort MPrintNameLength;
    [FieldOffset(16)]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_PATH)]
    internal Char[] MPathBuffer = new Char[MAX_PATH];
}

/// <summary>
/// Class for GUID
/// </summary>
[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Ansi)]
private class aGUID
{
    [FieldOffset(0)]
    internal uint  Data1;
    [FieldOffset(4)]
    internal ushort Data2;
    [FieldOffset(6)]
    internal ushort Data3;
    [FieldOffset(8)]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
    internal Char[] Data4 = new Char[8];
}

/// <summary>
/// From WINNT.H
/// The reparse GUID structure is used by all 3rd party layered drivers to
/// store data in a reparse point. For non-Microsoft tags, The GUID field
/// cannot be GUID_NULL.
/// The constraints on reparse tags are defined below.
/// Microsoft tags can also be used with this format of the reparse point buffer.
/// </summary>
[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
private class REPARSE_GUID_DATA_BUFFER
{
    [FieldOffset(0)]
    internal UInt32  ReparseTag;
    [FieldOffset(4)]
    internal ushort ReparseDataLength;
    [FieldOffset(6)]
    internal ushort Reserved;
    [FieldOffset(8)]
    internal aGUID  ReparseGuid;
    [FieldOffset(24)]
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = MAX_REPARSE_SIZE)]
    internal Char[] DataBuffer = new Char[MAX_REPARSE_SIZE];
}

In my next blog entry I will post some code that shows how to use all this to create, delete, and interrogate junctions.

  /// CloseHandle function
  /// </summary>
  /// <param name="hObject">Handle to an open object.</param>
  /// <returns>If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.</returns>
  [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
  private extern static int CloseHandle(IntPtr hObject);

  /// <summary>
  /// CreateFile function
  /// </summary>
  /// <param name="FileName"></param>
  /// <param name="DesiredAccess"></param>
  /// <param name="ShareMode"></param>
  /// <param name="lpSecurityAttributes"></param>
  /// <param name="CreationDisposition"></param>
  /// <param name="dwFlagsAndAttributes"></param>
  /// <param name="hTemplateFile"></param>
  /// <returns>INVALID_HANDLE_VALUE on error or the handle to file if success</returns>
  [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
  private extern static IntPtr CreateFile(string FileName, uint DesiredAccess,
                                          uint ShareMode, IntPtr lpSecurityAttributes,
                                          uint CreationDisposition, uint dwFlagsAndAttributes,
                                          IntPtr hTemplateFile);

  /// <summary>
  /// Junction form of DeviceIoControl Win32 function
  /// </summary>
  /// <param name="hDevice">Handle of device opened with CreateFile</param>
  /// <param name="nIoControlCode">Code of DeviceIoControl operation</param>
  /// <param name="rmp">Pointer to a buffer that contains the REPARSE_MOUNTPOINT_DATA_BUFFER data required to perform the operation.</param>
  /// <param name="nBufferSize">Size of the buffer pointed to by lpInBuffer, in bytes.</param>
  /// <param name="lpOutBuffer">Pointer to a buffer that receives the operation's output data.</param>
  /// <param name="lpOutBufferSize">Size of the buffer pointed to by lpOutBuffer, in bytes.</param>
  /// <param name="lpBytesReturned">Receives the size, in bytes, of the data stored into the buffer pointed to by lpOutBuffer. </param>
  /// <param name="lpOverlapped">Pointer to an OVERLAPPED structure. Discarded for this case</param>
  /// <returns>If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.</returns>
  [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
  private extern static bool DeviceIoControl(IntPtr hDevice,
                                              uint nIoControlCode,
                                              REPARSE_MOUNTPOINT_DATA_BUFFER rmp,
                                              uint nBufferSize,
                                              IntPtr lpOutBuffer,
                                              IntPtr lpOutBufferSize,
                                              ref uint lpBytesReturned,
                                              IntPtr lpOverlapped);

  /// <summary>
  /// Junction form of DeviceIoControl Win32 function
  /// </summary>
  /// <param name="hDevice">Handle of device opened with CreateFile</param>
  /// <param name="nIoControlCode">Code of DeviceIoControl operation</param>
  /// <param name="lpInBuffer">Pointer to a buffer.</param>
  /// <param name="nBufferSize">Size of the buffer pointed to by lpInBuffer, in bytes.</param>
  /// <param name="lpOutBuffer">Pointer to a buffer that receives the operation's output data.</param>
  /// <param name="lpOutBufferSize">Size of the buffer pointed to by lpOutBuffer, in bytes.</param>
  /// <param name="lpBytesReturned">Receives the size, in bytes, of the data stored into the buffer pointed to by lpOutBuffer. </param>
  /// <param name="lpOverlapped">Pointer to an OVERLAPPED structure. Discarded for this case</param>
  /// <returns>If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.</returns>
  [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
  private extern static bool DeviceIoControl(IntPtr hDevice,
                                              uint nIoControlCode,
                                              IntPtr lpInBuffer,
                                              IntPtr lpBufferSize,
                                              IntPtr lpvReparseBuf,
                                              int nBufferSize,
                                              ref uint lpBytesReturned,
                                              IntPtr lpOverlapped);

  /// <summary>
  /// Junction form of GetFileAttributes Win32 function
  /// </summary>
  /// <param name="lpFileName">File Name</param>
  /// <returns>The attributes of the specified file or directory, returned in a DWORD, indicates success. 0xFFFFFFFF indicates failure.</returns>
  [System.Runtime.InteropServices.DllImport("Kernel32.dll", SetLastError = true)]
  private extern static uint GetFileAttributes(string FileName);

Branching strategy is one of the most important aspects of TFS deployment. The right strategy can lead to optimized team cooperation, increased productivity and a successful adoption. On the other hand, a bad branching strategy can cause frustrations, damage production and derail TFS adoption in an organization. We have therefore put a lot of effort in creating a set of practical guidance to educate our customers and partners and support their VSTS adoption efforts.

This guidance covers the common cases and not always the special cases. If you have a special case, i.e. Enterprise Scrums Teams with Continuous Integration then you may have different requirements and therefore different scenarios from the guidance. I plan to continue to contribute to the guidance regarding my experiences in implementing special scenarios.

If there is any one thing I can share with you it is that you need to prove out your assumptions and branching strategies in a test environment before you implement them in production. Too many times do I learn of organizations that use the production environment for testing.

https://www.codeplex.com/TFSBranchingGuideII

Visual Studio Team System Week on Channel 9 – Content Calendar

(Live version of this content calendar lives here with new URL’s being added every day this week)

Overview Day (Monday, September 29^th):
- Announcing Visual Studio Team System 2010

- Visual Studio Team System 2010 Week on Channel 9!
Architecture Day (Tuesday, September 30th):
- Cameron Skinner: Visual Studio Team System 2010 - Architecture
- "Top-down" design with Visual Studio Team System 2010
- "Bottom-up" Design with Visual Studio Team System 2010 Architect
- ARCast.TV - Peter Provost on what’s coming for Architects in Visual Studio Team System
Business Alignment (Wednesday, October 1st):
- Achieving Business Alignment with Visual Studio Team System 2010
- Agile Planning Templates in Visual Studio Team System 2010
- Enterprise Project Management with Visual Studio Team System 2010
- Requirements Management and Traceability with Visual Studio Team System 2010
Software Quality (Thursday, October 2nd):
- Better Software Quality with Visual Studio Team System 2010
- Manual Testing with Visual Studio Team System 2010
- Historical Debugger and Test Impact Analysis in Visual Studio Team System 2010
Team Foundation Server (Friday, October 3rd):
- Brian Harry: Team Foundation Server 2010
- Branching and Merging Visualization with Team Foundation Server 2010
- Enterprise Team Foundation Server Management with Mario Rodriguez
- Team Foundation Server 2010 Setup and Administration
- An early look at Team Foundation Build 2010 with Jim Lamb
- A first look at Visual Studio Team System Web Access 2010
- Update on Team Foundation Server Migration and Synchronization

Brian Blackman
Principal Application Development Consultant
Microsoft Services - ISV Practice

NTFS junction points are a type of reparse point where you can link to local directories. There are utilities out that allow you to create and delete junction points. You can find reference to them in this Microsoft Support Article: https://support.microsoft.com/kb/205524.

What I did was wrote C# code using Platform Invoke Support to call into NTFS to create, delete, and interrogate junction points. No rocket science but a challenge when you don't have access to the source code - that includes me.

In this post I will show you the layout of the reparse structures in C#. You can find references to this on the Internet, such as https://www.flexhex.com/docs/articles/hard-links.phtml, and in WinNT.h, WinIoCtrl.h, winbase.h. Much of the rest are just standard file i/o values.

To start you will need to define some maximum values.

// Our maximum reparse point name size
private const int MAX_NAME_LENGTH = 1024;
private const int MAX_PATH = 260;
// Maximum reparse buffer info size. The max user defined reparse
// data is 16KB, plus there's a header.
private const int MAX_REPARSE_SIZE = 17000;

// winnt.h
private const uint IO_REPARSE_TAG_SYMBOLIC_LINK = (0);
private const uint IO_REPARSE_TAG_MOUNT_POINT = (0xA0000003);
private const uint IO_REPARSE_TAG_HSM = (0xC0000004);
private const uint IO_REPARSE_TAG_SIS = (0x80000007);
private const uint IO_REPARSE_TAG_DFS = (0x8000000A);

private const uint REPARSE_MOUNTPOINT_HEADER_SIZE = 8;

// from WinIoCtl.h
private const uint FSCTL_SET_REPARSE_POINT = 589988;
private const uint FSCTL_GET_REPARSE_POINT = 589992;

// from winbase.h
private const int INVALID_HANDLE_VALUE = -1;
private const uint GENERIC_READ = 0x80000000;
private const uint GENERIC_WRITE = 0x40000000;
private const uint GENERIC_EXECUTE = 0x20000000;
private const uint GENERIC_ALL = 0x10000000;

//Sharing
private const uint FILE_SHARE_NONE = 0x00000000;
private const uint FILE_SHARE_READ = 0x00000001;
private const uint FILE_SHARE_WRITE = 0x00000002;
private const uint FILE_SHARE_DELETE = 0x00000004;

private const uint FILE_ATTRIBUTE_NORMAL = 0x00000080;
private const uint FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400  ;

//Create
private const uint CREATE_NEW = 1;
private const uint CREATE_ALWAYS = 2;
private const uint OPEN_EXISTING = 3;
private const uint OPEN_ALWAYS = 4;
private const uint TRUNCATE_EXISTING = 5;

//Reparse
private const uint FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000;
private const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;

In my next post I will show you some classes you need to create and the signatures for the PInvoke calls.

Of my 11+ years at Microsoft, I have spent most of that time in Services with a few attachments to the Product Groups, e.g. the early days of Microsoft Access (code name Cirrus and the predecessor to Omega) and Windows for Automotive (WfA).

I will blog and rant on just about anything I think is of value for someone outside of Microsoft, special announcements and reference to other important Microsoft employee blogs such as Brian Harry. I will post about technical topics, including code I have written that I think is worthy of your time without giving away any IP.

My first post introduction blog will be on creating NTFS Junctions through C#. It is something I did about a year ago and is no rockets science yet a challenge without source code access - that includes me! Yes, that is correct, just because you work at Microsoft does not mean you have source code access. In fact, customers will have access when I do not. I use to have access, but overtime we became more secure about such access. For example, I just lost my access to CE and WfA since I no longer work with those products or those product groups.

Until my next rant,

Brian