Recently, we were in need of executing a command on a remote server as part of our automated build process. For this we decided to make use of Windows Management Instrumentation (WMI). Before jumping to the code, copying and pasting it, there are always some security issues that need to be addressed. For this task there are also some service configurations that are required on the remote machine.

Note: All of the following settings are configured on the remote machine on which the command will be run remotely.

Security

Follow the steps below to set the WMI permissions for the build service account:

1. Click on Start > Control Panel > Administrative Tools > Computer Management.
2. Expand Service and Applications.
3. Right-click on WMI Control and click on Properties.
4. On the property dialog select the Security tab.
5. Expand Root > CIMV2.
6. Click on the Security button.
7. Click on Add and add <TFSSERVICE> account.
8. In the list of permissions, allow the following permissions:
   • Execute methods
   • Remote enable
9. Click on OK.

Follow the step below to set the Local Security Policy for the build service account:

1. Click on Start > Control Panel > Administrative Tools > Local Security Policy.
2. Expand Local Policies > User Rights Assignment.
3. Find and double-click on Log on as a service.
4. Click on Add User or Group and add <TFSSERVICE> account.
5. Click on OK.
6. Find and double-click Log on as a batch job.
7. Click on Add User or Group and add <TFSSERVICE> account.
8. Click on OK and close the Local Security Policy window.

Services

Follow the steps below set the dependent services to automatically start:

1. Click on Start > Control Panel > Administrative Tools.
2. Double click on Services.
3. Ensure that the following services are Started, and are set to start Automatic.
   • COM+ Event System
   • Remote Access Auto Connection Manager
   • Remote Access Connection Manager
   • Remote Procedure Call (RPC)
   • Remote Procedure Call (RPC) Locator
   • Remote Registry
   • Server
   • Windows Management Instrumentation
   • Windows Management Instrumentation Driver Extensions
   • WMI Performance Adapter
   • Workstation
4. Close the services dialog.

Here is the code for the build task that will execute a command on a remote machine:

/// <summary>
/// Executes a command line on a remote machine.
/// </summary>
public class RemoteExec : Task
{
 /// <summary>
 /// Initialises a new instance of the <see cref="RemoteExec"/> class.
 /// </summary>
 public RemoteExec()
 {
   RemoteMachine = Environment.MachineName;
 }

 /// <summary>
 /// Gets or sets the name of the machine on which to execute the command.
 /// </summary>
 public string RemoteMachine
 {
   get;
   set;
 }

 /// <summary>
 /// Gets or sets the command to execute on the remote machine.
 /// </summary>
 [Required]
 public string Command
 {
   get;
   set;
 }

 /// <summary>
 /// Executes the task on the remote machine.
 /// </summary>
 /// <returns>true if the task succeeded, otherwise, false</returns>
 public override bool Execute()
 {
   if (string.IsNullOrEmpty(Command))
   {
     Log.LogError("Command property was not set.");
     throw new ArgumentNullException("Command");
   }

   var connOptions = new ConnectionOptions();
   connOptions.Impersonation = ImpersonationLevel.Impersonate;
   connOptions.EnablePrivileges = true;

   var managementScope = new ManagementScope(
     string.Format(@"\\{0}\ROOT\CIMV2", RemoteMachine), connOptions);
   managementScope.Connect();

   Log.LogMessage(string.Format(CultureInfo.CurrentCulture, "Connected to {0}: {1}",
   RemoteMachine, managementScope.IsConnected));

   if (!managementScope.IsConnected)
   return false;

   var objectGetOptions = new ObjectGetOptions();
   var managementPath = new ManagementPath("Win32_Process");
   var processClass = new ManagementClass(managementScope, managementPath, objectGetOptions);

   var processParameters = processClass.GetMethodParameters("Create");

   processParameters["CommandLine"] = Command;
   try
   {
     var outParams = processClass.InvokeMethod("Create", processParameters, null);
     var processID = Convert.ToUInt32(outParams["processId"]);

     Log.LogMessage(string.Format(CultureInfo.CurrentCulture,
       "Creation of the process {0} returned: {1}", processID, outParams["returnValue"]));

     var stopQuery = new WqlEventQuery(string.Format(CultureInfo.CurrentCulture,
       "select * from Win32_ProcessStopTrace where ProcessID={0}", processID));

     var processStopEvent = new ManagementEventWatcher(managementScope, stopQuery);
     processStopEvent.Options.Timeout = new TimeSpan(0, 1, 0);

     Log.LogMessage("Waiting for process to complete...");
     processStopEvent.WaitForNextEvent();
     processStopEvent.Stop();

     Log.LogMessage("Completed.");
   }
   catch (Exception ex)
   {
     Log.LogError(ex.Message);
   }

   return true;
   }
}

The task can then be used as follows:

<UsingTask TaskName="RemoteExec" AssemblyFile="BuildTasks.dll"/>
<RemoteExec RemoteMachine="$(Server)" Command="application.exe" />

There we have it, executing a command remotely from MsBuild!

With our build process we decided on a deployment folder structure that required us to create NTFS Junction Points. Junction Points are links to other folders, also known as soft links. Below is an example of how these links appear in Windows 7. It also shows our deployment folders for various build types:

All the folders with shortcut arrows are junction points or links to folders in the Published folder. For each build, the binaries are copied to a build numbered folder in the Published folder. Only when a build is successful; meaning that all code compiled and unit tests passed; do we update the junction point to the relevant build numbered folder in Published.

By using the code written by Jeff Brown in this article, I was able to create a custom build task that enabled us to the create and delete junction points with relative ease. Here is a link to the source code for an MsBuild task that will enable you to manage junction points with MsBuild.