TFS 2010 API, określ, na którym serwerze kompilacji działa kompilacja.

Question

Przepraszam, to prawie na pewno duplikat numeru this question, ale ponieważ nie otrzymałem odpowiedzi, spróbuję ponownie.

Próbuję zbudować narzędzie, które pozwoli mi zobaczyć wszystkie kompilacje w kolejce lub uruchomione na TFS.

Jednym z wymagań jest możliwość sprawdzenia, na którym serwerze kompilacji jest uruchamiana kompilacja. Wszystkie właściwości i metody "BuildAgent" w IQueuedBuildsView są przestarzałe i nie są implementowane wyjątki. Istnieje wiele sposobów sprawdzania agenta, ale zanim to zrobisz, potrzebujesz nazwy użytkownika lub nazwy agenta i mam wrażenie, że jestem w sytuacji związanej z kurczakiem i jajkiem.

Czy ktoś wie, jak znaleźć nazwę serwera kompilacji dla działającej wersji? Poniższy fragment kodu może pomóc.

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

W tym celu utworzyłem skrypt LinqPad. Poprzez zapytanie do wszystkich agentów na kontrolerze można zobaczyć kompilacje działające przeciwko każdemu z nich. W skrypcie jest kilka dodatkowych rzeczy, które dodałem dla własnych preferencji.

TFS Build Agents na moim SkyDrive

Answer 2

Oto skrypt PowerShell zrobić to samo. Zauważ, że będziesz musiał wymienić serwer TFT i zbudować łańcuchy nazw kontrolerów.

[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

Z tego, co widzę, masz 90% kodu; tutaj jest ostatni 10%, który powinien zakończyć pracę:

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