API TFS 2010, determinare su quale build è in esecuzione una build.

Question

Ci scusiamo, questo è quasi certamente un duplicato di this question ma siccome a quello non è stata data risposta, riproverò.

Sto provando a creare uno strumento che mi consenta di vedere tutte le build in coda o in esecuzione su TFS.

Uno dei requisiti è essere in grado di vedere su quale build è in esecuzione una build. Tutte le proprietà e i metodi "BuildAgent" in IQueuedBuildsView sono obsoleti e non implementano eccezioni implementate. Ci sono molti modi per interrogare un agente ma è necessario l'agente uri o il nome prima che tu possa farlo e mi sento come se fossi in una situazione di pollo e uova.

Qualcuno sa come trovare il nome del server di build per una build in esecuzione? Il mio frammento di codice qui sotto potrebbe aiutare.

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

Per creare questo script ho creato uno script LinqPad. Effettuando una query su tutti gli agenti su un controller, è possibile visualizzare le build in esecuzione su ciascuna di esse. Ci sono alcune cose extra nello script che ho aggiunto per le mie preferenze.

TFS Build Agents sul mio SkyDrive

Answer 2

Ecco uno script PowerShell per fare lo stesso. Nota che dovrai sostituire il server tfs e costruire le stringhe del nome del controller.

[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

Da quello che vedo, si ha il 90% del codice; qui è l'ultimo 10% che dovrebbe finire il lavoro:

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); 
     } 
    } 
}