API TFS 2010, déterminez quel serveur de construction une construction est activé.

excuses, c'est presque certainement un double de Cette question Mais comme celui-ci n'a pas été répondu, je vais essayer de nouveau.

J'essaie de construire un outil qui me permettra de voir toutes les constructions en file d'attente ou en cours sur TFS. p>

L'une des exigences est de pouvoir voir quel serveur de construction une construction est activé. Toutes les propriétés "Buildagent" et les méthodes de l'iQueussueSuréeViews sont obsolètes et jettent non mis en œuvre des exceptions. Il y a beaucoup de façons d'interrogé d'un agent, mais vous avez besoin de l'URI de l'agent ou du nom avant de pouvoir le faire et je me sens comme si je suis dans une situation de poulet et d'oeuf. P>

Est-ce que quelqu'un sait comment trouver le Construire le nom du serveur pour une construction en cours d'exécution? Mon extrait de code ci-dessous pourrait aider. P>

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