TFS server API only list the XAML build definitions

Question

I am trying to obtain information from TFS2015 build definitions. We have about 100 build definitions in XAML format and about 50 in the new 2015 format. The server is an inhouse Team foundation Server. (Microsoft Visual Studio Team Foundation Server Version 15.105.25910.0)

I am not using the rest api but the Microsoft.TeamFoundationServer.ExtendedClient as recommended here : https://blogs.msdn.microsoft.com/buckh/2015/08/10/nuget-packages-for-tfs-and-visual-studio-online-net-client-object-model/ .

Here is my code example:

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Microsoft.TeamFoundation.Build.Client;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.Framework.Client;
using Microsoft.TeamFoundation.Framework.Common;
using Serilog;

namespace TFSExperiment
{
    class Program
    {
        // see https://blogs.msdn.microsoft.com/buckh/2015/08/10/nuget-packages-for-tfs-and-visual-studio-online-net-client-object-model/
        //Needs nuget package Install-Package Microsoft.TeamFoundationServer.ExtendedClient -Version 14.102.0
        // to use serilogg: Install-Package  Serilog ; Install-Package Serilog.Sinks.RollingFile
        static void Main(string[] args)
        {
          var  myLog = new LoggerConfiguration()
                .WriteTo.RollingFile("..\\..\\Applog\\mylog-{Date}.log").CreateLogger();          
             TfsConfigurationServer configurationServer =
                TfsConfigurationServerFactory.GetConfigurationServer(new Uri("https://tfs.inhouseserver2015.org/tfs/"));
            ReadOnlyCollection<CatalogNode> collectionNodes =
                configurationServer.CatalogNode.QueryChildren(new[] {CatalogResourceTypes.ProjectCollection}, false,
                    CatalogQueryOptions.None);
            CatalogNode defultTfsCol = collectionNodes.AsQueryable().Single(c=>c.Resource.DisplayName.Equals("DefaultCollection"));
            Console.WriteLine(defultTfsCol.Resource.DisplayName);
                TfsTeamProjectCollection tfsProjectCollection =
                configurationServer.GetTeamProjectCollection(new Guid(defultTfsCol.Resource.Properties["InstanceId"]));
                tfsProjectCollection.Authenticate();
                var buildServer = (IBuildServer)tfsProjectCollection.GetService(typeof(IBuildServer));                
                ReadOnlyCollection<CatalogNode> projectNodes = defultTfsCol.QueryChildren(
                   new[] { CatalogResourceTypes.TeamProject },
                   false, CatalogQueryOptions.None);
                foreach (var proj in projectNodes)
                {
                    var buildDefinitionList = new List<IBuildDefinition>(buildServer.QueryBuildDefinitions(proj.Resource.DisplayName));
                    foreach (var buildDef in buildDefinitionList)
                    {                       
                        Console.WriteLine(buildDef.Name);                   
                        myLog.Information($"{buildDef.Id} --{buildDef.Name} --{buildDef.BuildServer.BuildServerVersion} ");
                    }
                }            
            Console.WriteLine(" Hit any key to exit ");
            Console.ReadKey();
        }
    }
}

Answer 1

As answered by Eddie - MSFT and Tore Østergaard I had to use the rest api. But It looks like I have to use the old api also to get all the information from the builddefinitions. From the restapi I got the name of build but not the deep information for the xaml builds.

I wanted to collect information from the variable that pointed out the Octopus Deploy project name. I Post the code here in case someone has similiar issue.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Text.RegularExpressions;
using Microsoft.TeamFoundation.Build.Client;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.Build.WebApi;
using Microsoft.TeamFoundation.Common;
using Microsoft.TeamFoundation.Framework.Client;
using Microsoft.TeamFoundation.Framework.Common;
using Newtonsoft.Json;
using Serilog;
using Serilog.Core;


namespace ListOctopusProjectsAndTfsBuilds
{
    class Program
    {
        // see https://blogs.msdn.microsoft.com/buckh/2015/08/10/nuget-packages-for-tfs-and-visual-studio-online-net-client-object-model/
        //Needs nuget package Install-Package Microsoft.TeamFoundationServer.ExtendedClient -Version 14.102.0
        // to use serilogg: Install-Package  Serilog ; Install-Package Serilog.Sinks.RollingFile

        static Logger _myLog = new LoggerConfiguration()
                .WriteTo.RollingFile($"..\\..\\Applog\\myBuildDeflog-{DateTime.Now:yyyyMMddHHHHmmss}.log").CreateLogger();
        static void Main(string[] args)
        {
            Console.WriteLine("Start looking for BuildDefs");
            Dictionary<string, string> octopusDeployDictionary = GetvNextBuildDefVariable( new Uri("https://inhouseserver2015/tfs/DefaultCollection"), "YourTfsProject", "OctoProj");
            Dictionary<string, string> octopusDeployXamlDictionary = GetXamlBuildDefVariable(new Uri("https://inhouseserver2015/tfs/DefaultCollection"), "YourTfsProject", "ArgOctopusProjectsToPublish");
            Console.WriteLine("Builds vnext defs -- Octopus project");
            foreach (var cd in octopusDeployDictionary)
            {
                Console.WriteLine($"{cd.Key}; {cd.Value}");
            }
            Console.WriteLine("Builds xaml defs -- Octopus project");
            foreach (var cd in octopusDeployXamlDictionary)
            {
                Console.WriteLine($"{cd.Key}; {cd.Value}");
            }
            Console.ReadLine();
        }

        private static Dictionary<string, string> GetXamlBuildDefVariable(Uri tfsUri, string tfsProject, string buildDefVar)
        {
            var collection = tfsUri.LocalPath.Split('/')[2];
            //Define Reg expression ahead so it can faster parse xml and find the Octopus Deploy projectname. 
            Regex findArgOctopusProjectsToPublish = null;
            try
            {
                findArgOctopusProjectsToPublish = new Regex($"x:Key=\"{buildDefVar}\".*<x:String>([^<]*)",
                    RegexOptions.IgnoreCase | RegexOptions.Singleline);
            }
            catch (ArgumentException ex)
            {
                _myLog.Error(ex, "Error with RegularExpression syntax");
            }
            Dictionary<string, string> tfsVarBuildDefDict = new Dictionary<string, string>();
            TfsConfigurationServer configurationServer =
                TfsConfigurationServerFactory.GetConfigurationServer(tfsUri));
            ReadOnlyCollection<CatalogNode> collectionNodes =
                configurationServer.CatalogNode.QueryChildren(new[] {CatalogResourceTypes.ProjectCollection}, false,
                    CatalogQueryOptions.None);
            CatalogNode defultTfsCol =
                collectionNodes.AsQueryable().Single(c => c.Resource.DisplayName.Equals(collection));
            TfsTeamProjectCollection tfsProjectCollection =
                configurationServer.GetTeamProjectCollection(new Guid(defultTfsCol.Resource.Properties["InstanceId"]));
            tfsProjectCollection.Authenticate();
            var buildServer = (IBuildServer) tfsProjectCollection.GetService(typeof(IBuildServer));
            ReadOnlyCollection<CatalogNode> projectNodes = defultTfsCol.QueryChildren(
                new[] {CatalogResourceTypes.TeamProject},
                false, CatalogQueryOptions.None);

                var buildDefinitionList =
                    new List<IBuildDefinition>(buildServer.QueryBuildDefinitions(tfsProject));
                foreach (var buildDef in buildDefinitionList)
                {
                Debug.Assert(findArgOctopusProjectsToPublish != null, "findArgOctopusProjectsToPublish != null");
                var octopusProjectsToPublish =
                        findArgOctopusProjectsToPublish?.Match(buildDef.ProcessParameters).Groups[1].Value;
                    if (octopusProjectsToPublish.IsNullOrEmpty())
                    {
                        octopusProjectsToPublish = "NoOctopus Projekt";
                    }
                tfsVarBuildDefDict.Add(buildDef.Name, octopusProjectsToPublish);
                    _myLog.Information($"{buildDef.Id} --{buildDef.Name} --{buildDef.BuildServer.BuildServerVersion} ");
                }

            return tfsVarBuildDefDict;
        }

        private static Dictionary<string, string> GetvNextBuildDefVariable(Uri tfsUri,string tfsProject,string buildDefVar)
        {
            Dictionary<string, string> tfsVarBuildDefDict = new Dictionary<string, string>();
            TfsTeamProjectCollection ttpc =
                new TfsTeamProjectCollection(tfsUri);
            BuildHttpClient bhc = ttpc.GetClient<BuildHttpClient>();
            var definitions = bhc.GetDefinitionsAsync(project: tfsProject);
            var client = new WebClient {UseDefaultCredentials = true};
            foreach (var buildDef in definitions.Result)
            {
                if (buildDef.Type == DefinitionType.Build)
                {
                    var json = client.DownloadString(buildDef.Url);
                    BuildDefinition result = JsonConvert.DeserializeObject<BuildDefinition>(json);
                    if (result.Variables.ContainsKey(buildDefVar))
                    {
                        tfsVarBuildDefDict.Add(buildDef.Name, result.Variables[buildDefVar].Value.ToString());
                        _myLog.Information($"{buildDef.Name} Octoproject: {result.Variables[buildDefVar].Value.ToString()}");
                    }
                }
                else
                {
                    _myLog.Information($"{buildDef.Name} BuildType  {buildDef.Type} ");
                }
            }
            return tfsVarBuildDefDict;
        }
    }
}

Answer 2

You are using the legacy soap API which can only get the XAML builds.

Assuming you have installed the latest .NET Client Libraries, you can use the Rest API in the libraries to get both XAML and vNext builds like this:

using System;
using System.Collections.Generic;
using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.Build.WebApi;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri tfsurl = new Uri("http://xxxx:8080/tfs/CollectionName");
            TfsTeamProjectCollection ttpc = new TfsTeamProjectCollection(tfsurl);
            BuildHttpClient bhc = ttpc.GetClient<BuildHttpClient>();
            List<Build> builds = bhc.GetBuildsAsync("ProjectName").Result;
            foreach (Build bu in builds)
            {
                Console.WriteLine(bu.BuildNumber);
            }
            Console.ReadLine();
        }
    }
}

Answer 3

The APIs in Microsoft.TeamFoundationServer.ExtendedClient are primarily there to supply backward compatibility with XAML builds. To my knowledge, they do not support Build vNext as they were written before their time.

As the link you supplied suggest, the REST API is the future way to follow.