TFS 2010 API, determine en qué servidor de compilación se está ejecutando una compilación.

Question

Disculpas, esto es casi seguro que es un duplicado de this question pero como ese no ha sido respondido lo intentaré de nuevo.

Estoy tratando de construir una herramienta que me permita ver todas las compilaciones en cola o en ejecución en TFS.

Uno de los requisitos es poder ver en qué servidor de compilación se está ejecutando una compilación. Todas las propiedades y métodos de "BuildAgent" en IQueuedBuildsView están en desuso y no lanzan excepciones implementadas. Hay muchas maneras de consultar a un agente, pero necesita el agente uri o el nombre antes de poder hacer eso y me siento como si estuviera en una situación de gallina y huevo.

¿Alguien sabe cómo encontrar el nombre del servidor de compilación para una compilación en ejecución? Mi fragmento de código a continuación podría ser útil.

using System; 
using System.Collections.Generic; 
using System.Collections.ObjectModel; 
using System.Linq; 
using System.Net; 
using System.Text; 
using Microsoft.TeamFoundation.Server; 
using Microsoft.TeamFoundation.Build.Client; 
using Microsoft.TeamFoundation.VersionControl.Client; 
using Microsoft.TeamFoundation.Framework.Client; 
using Microsoft.TeamFoundation.Framework.Common; 
using Microsoft.TeamFoundation.Client; 


namespace TeamFoundationServerTools 
{ 
    public static class TeamBuildData 
    { 

     public static void Main() 
     { 

      Uri teamFoundationServerUri = new Uri("http://tfs:8080/tfs"); 
      Uri teamFoudationServerProjectCollectionUri = new Uri("http://tfs:8080/tfs/collection"); 
      string teamFoundationServerName = "tfs"; 
      string teamFoundationServerProjectCollectionName = string.Empty; 
      string teamFoundationServerProjectName = string.Empty; 

      try 
      { 

       Dictionary<string, Uri> collections = new Dictionary<string, Uri>(); 

       if (string.IsNullOrEmpty(teamFoundationServerProjectCollectionName)) 
       { 
        DetermineCollections(teamFoundationServerUri, collections); 
       } 
       else 
       { 
        collections.Add(teamFoundationServerName, teamFoudationServerProjectCollectionUri); 
       } 

       QueryCollections(teamFoundationServerName, teamFoundationServerProjectName, collections); 

      } 
      catch (Exception ex) 
      { 
       Console.Write(ex.ToString()); 
      } 
     } 

     /// <summary> 
     /// Queries the Team project collection for team builds 
     /// </summary> 
     /// <param name="teamFoundationServerName">the name of the TFS server</param> 
     /// <param name="teamFoundationServerProjectName">the name of the Team Project</param> 
     /// <param name="collections">the Team Project Collections to be queried</param> 
     private static void QueryCollections(string teamFoundationServerName, string teamFoundationServerProjectName, Dictionary<string, Uri> collections) 
     { 
      foreach (KeyValuePair<string, Uri> collection in collections) 
      { 
       // connect to the collection 
       using (TfsTeamProjectCollection teamProjectCollection = new TfsTeamProjectCollection(collection.Value, CredentialCache.DefaultCredentials)) 
       { 
        Console.WriteLine(teamProjectCollection.Name); 

        IBuildServer buildServer = (IBuildServer)teamProjectCollection.GetService(typeof(IBuildServer)); 

        // get ICommonStructureService (later to be used to list all team projects) 
        ICommonStructureService commonStructureService = (ICommonStructureService)teamProjectCollection.GetService(typeof(ICommonStructureService)); 

        // I need to list all the TFS Team Projects that exist on a server 
        ProjectInfo[] allTeamProjects; 

        if (!String.IsNullOrEmpty(teamFoundationServerProjectName)) 
        { 
         allTeamProjects = new ProjectInfo[1]; 
         allTeamProjects[0] = new ProjectInfo(); 
         allTeamProjects[0] = commonStructureService.GetProjectFromName(teamFoundationServerProjectName); 
        } 
        else 
        { 
         allTeamProjects = commonStructureService.ListProjects(); 
        } 

        // iterate thru the team project list 
        foreach (ProjectInfo teamProjectInfo in allTeamProjects) 
        { 
         Console.WriteLine(teamProjectInfo.Name); 

         // skip this team project if it is not WellFormed. 
         if (teamProjectInfo.Status != ProjectState.WellFormed) 
         { 
          continue; 
         } 

         IQueuedBuildsView queuedBuildsView = buildServer.CreateQueuedBuildsView(teamProjectInfo.Name); 
         queuedBuildsView.StatusFilter = QueueStatus.Queued | QueueStatus.InProgress | QueueStatus.Postponed; 

         queuedBuildsView.QueryOptions = QueryOptions.All; 

         queuedBuildsView.Refresh(false); 
         foreach (IQueuedBuild queuedBuild in queuedBuildsView.QueuedBuilds) 
         { 
          Console.WriteLine(queuedBuild.BuildDefinition.Name); 
          Console.WriteLine(queuedBuild.BuildController.Name); 
          Console.WriteLine(queuedBuild); 
          Console.WriteLine(queuedBuild.Status); 
          Console.WriteLine(queuedBuild.RequestedBy); 
          Console.WriteLine(queuedBuild.QueuePosition); 
          Console.WriteLine(queuedBuild.QueueTime); 
          Console.WriteLine(queuedBuild.Priority); 
          Console.WriteLine(); 

          if (queuedBuild.Status == QueueStatus.InProgress) 
          { 


          } 

          Console.WriteLine("***********************"); 

         } 
        } 
       } 
      } 

      Console.ReadLine(); 
     } 

     /// <summary> 
     /// Determins the team project collections for a given TFS instance 
     /// </summary> 
     /// <param name="teamFoundationServerUri">the uri of the Team Foundation Server</param> 
     /// <param name="collections">a dictionary of collections to be added to</param> 
     private static void DetermineCollections(Uri teamFoundationServerUri, Dictionary<string, Uri> collections) 
     { 
      // get a list of Team Project Collections and their URI's 
      using (TfsConfigurationServer tfsConfigurationServer = new TfsConfigurationServer(teamFoundationServerUri)) 
      { 
       CatalogNode configurationServerNode = tfsConfigurationServer.CatalogNode; 

       // Query the children of the configuration server node for all of the team project collection nodes 
       ReadOnlyCollection<CatalogNode> tpcNodes = configurationServerNode.QueryChildren(
         new Guid[] { CatalogResourceTypes.ProjectCollection }, 
         false, 
         CatalogQueryOptions.None); 

       foreach (CatalogNode tpcNode in tpcNodes) 
       { 
        ServiceDefinition tpcServiceDefinition = tpcNode.Resource.ServiceReferences["Location"]; 

        ILocationService configLocationService = tfsConfigurationServer.GetService<ILocationService>(); 
        Uri tpcUri = new Uri(configLocationService.LocationForCurrentConnection(tpcServiceDefinition)); 

        collections.Add(tpcNode.Resource.DisplayName, tpcUri); 
       } 
      } 
     } 
    } 
} 

Answer 1

Creé un script LinqPad para hacer esto. Al consultar a todos los Agentes en un Controlador, puede ver las compilaciones ejecutándose contra cada uno. Hay algunas cosas adicionales en el guión que he agregado para mi propia preferencia.

TFS Build Agents en mi SkyDrive

Answer 2

Aquí es un script de PowerShell para hacer lo mismo. Tenga en cuenta que deberá reemplazar el servidor tfs y las cadenas de nombre del controlador de compilación.

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.TeamFoundation.Client") | Out-Null 
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.TeamFoundation.WorkItemTracking.Client") | Out-Null 
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.TeamFoundation.Build.Client") | Out-Null 

$teamProjectCollection = [Microsoft.TeamFoundation.Client.TfsTeamProjectCollectionFactory]::GetTeamProjectCollection("http://tfsserver:8080/tfs") 
$bs = $teamProjectCollection.GetService([type]"Microsoft.TeamFoundation.Build.Client.IBuildServer") 
$tfsapps_controller=$bs.QueryBuildControllers('true') | where {$_.Name -like '*YOURBUILDCONTROLLER*'} 
$agents=$tfsapps_controller.Agents 

foreach ($agent in $agents){ 
    if ($agent.IsReserved){ 
    $build=$bs.QueryBuildsByUri($agent.ReservedForBuild,'*','All') 
    Write-Host $build[0].BuildDefinition.Name, ' : ', $agent.MachineName 
    } 
} 

Answer 3

Según lo que veo, tiene el 90% del código; aquí es el último 10% que debe terminar el trabajo:

if (queuedBuild.Status == QueueStatus.InProgress) 
    { 
    //search agent associated to running build 
    foreach (IBuildAgent agent in queuedBuild.BuildController.Agents) 
    { 
     if (queuedBuild.Build.Uri.Equals(agent.ReservedForBuild)) 
     { 
      Console.WriteLine(" associated Build Agent =" + agent.Name); 
     } 
    } 
}