Ejemplo n.º 1
0
        /// <summary>
        /// Executes the logic for this workflow activity.
        /// </summary>
        /// <returns>The <see cref="Microsoft.TeamFoundation.Build.Client.IBuildController"/>
        /// that is specified.</returns>
        protected override IBuildController InternalExecute()
        {
            IBuildServer buildServer         = this.BuildServer.Get(this.ActivityContext);
            string       buildControllerName = this.BuildControllerName.Get(this.ActivityContext);

            return(buildServer.GetBuildController(buildControllerName));
        }
Ejemplo n.º 2
0
        private IBuildDetailSpec GetBuildDetailSpec(
            IBuildServer buildServer,
            string project,
            string buildGroup,
            DateTime since)
        {
            IBuildDetailSpec spec = buildServer.CreateBuildDetailSpec(project, buildGroup);

            spec.MinFinishTime = since;

            spec.QueryOrder = BuildQueryOrder.StartTimeAscending;

            spec.InformationTypes = null;

            spec.InformationTypes = new[]
            {
                InformationTypes.ConfigurationSummary, InformationTypes.AssociatedCommit,
                InformationTypes.AssociatedChangeset, InformationTypes.CompilationSummary,
                InformationTypes.BuildError, InformationTypes.BuildWarning
            };

            spec.Status = BuildStatus.Failed
                          | BuildStatus.PartiallySucceeded
                          | BuildStatus.Succeeded;

            spec.QueryDeletedOption = QueryDeletedOption.ExcludeDeleted;
            return(spec);
        }
Ejemplo n.º 3
0
        private TimeSpan GetLastSuccesfulBuildTime(IBuildServer buildServer, CatalogNode teamProjectNode,
                                                   IBuildDefinition def)
        {
            var buildTime = new TimeSpan();

            try
            {
                var inProgressBuildDetailSpec = buildServer.CreateBuildDetailSpec(teamProjectNode.Resource.DisplayName, def.Name);

                inProgressBuildDetailSpec.Status = BuildStatus.Succeeded;
                inProgressBuildDetailSpec.MaxBuildsPerDefinition = 1;
                inProgressBuildDetailSpec.QueryOrder             = BuildQueryOrder.FinishTimeDescending;

                var lastSuccesfulBuild = buildServer.QueryBuilds(inProgressBuildDetailSpec).Builds.FirstOrDefault();

                if (lastSuccesfulBuild != null)
                {
                    buildTime = lastSuccesfulBuild.FinishTime - lastSuccesfulBuild.StartTime;
                }
            }
            catch (Exception e)
            {
                LogService.WriteError(e);
                throw;
            }
            return(buildTime);
        }
        private IBuildController GetBuildController(IBuildServer buildServer, string buildController)
        {
            if (string.IsNullOrEmpty(buildController))
                return buildServer.QueryBuildControllers(false).First();

            return buildServer.GetBuildController(buildController);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Executes the logic for this workflow activity.
        /// </summary>
        /// <returns>The <see cref="Microsoft.TeamFoundation.Build.Client.IQueuedBuild"/>
        /// object that is returned after queueing the new build.</returns>
        protected override IQueuedBuild InternalExecute()
        {
            IBuildServer buildServer = this.BuildServer.Get(this.ActivityContext);

            IBuildDefinition buildDefinition = this.BuildDefinition.Get(this.ActivityContext);
            IBuildRequest    buildRequest    = buildServer.CreateBuildRequest(buildDefinition.Uri);

            buildRequest.Priority = this.Priority.Get(this.ActivityContext);

            if (Enum.IsDefined(typeof(QueuePriority), buildRequest.Priority) == false)
            {
                // Set default value to normal, if no value has been passed.
                buildRequest.Priority = QueuePriority.Normal;
            }

            string processParameters = this.ProcessParameters.Get(this.ActivityContext);

            if (!string.IsNullOrEmpty(processParameters))
            {
                buildRequest.ProcessParameters = processParameters;
            }

            IBuildController buildController = this.BuildController.Get(this.ActivityContext);

            if (buildController != null)
            {
                buildRequest.BuildController = buildController;
            }

            IQueuedBuild queuedBuild = buildServer.QueueBuild(buildRequest);

            return(queuedBuild);
        }
        public static SortedDictionary <string, string> GetBuilds(string projName, string defName)
        {
            SortedDictionary <string, string> lsBuildsQuery = new SortedDictionary <string, string>();

            try
            {
                IBuildServer buildServer     = (IBuildServer)tfs.GetService(typeof(IBuildServer));
                ILinking     iLinkingService = tfs.GetService <ILinking>(); //can be used later to get build URL link

                //Specify query
                IBuildDetailSpec spec = buildServer.CreateBuildDetailSpec(projName.Trim(), defName.Trim());
                spec.InformationTypes = null;                             // for speed improvement
                spec.MinFinishTime    = DateTime.Now.AddDays(-21);        //to get only builds of last 2 weeks
                //spec.MaxBuildsPerDefinition = 1; //get only one build per build definintion
                spec.QueryOrder   = BuildQueryOrder.FinishTimeDescending; //get the latest build only
                spec.QueryOptions = QueryOptions.All;

                IBuildDetail[]      bDetails  = buildServer.QueryBuilds(spec).Builds;
                List <IBuildDetail> ibDetails = bDetails.OrderBy(x => x.CompilationStatus == BuildPhaseStatus.Succeeded).OrderByDescending(x => x.StartTime).Take(10).ToList();
                foreach (IBuildDetail ibdet in ibDetails)
                {
                    lsBuildsQuery.Add(ibdet.BuildNumber, ibdet.Uri.Port.ToString());
                }
            }
            catch (Exception ex)
            {
                lsBuildsQuery.Add("Please Load the definition first", "-1");
            }
            return(lsBuildsQuery);
        }
Ejemplo n.º 7
0
 public Deployer(IConfigurationReader reader, IBuildServer buildServer, IMappingProcessor mappingProcessor, Func <BuildDetail, IBuildDetail, IPostDeployAction> postDeployActionFactory)
 {
     _configurationReader     = reader;
     _buildServer             = buildServer;
     _mappingProcessor        = mappingProcessor;
     _postDeployActionFactory = postDeployActionFactory;
 }
        private static void CleanBuildDefinition(string[] args, IBuildDefinition buildDefinition,
                                                 IBuildServer _bs, string TeamProject,
                                                 TfsTeamProjectCollection teamProjectCollection, Options options)
        {
            int nbTotal = RetourneNbBuildDef(_bs, TeamProject, buildDefinition, 10000).Count();

            Console.WriteLine(nbTotal + " Builds destroying");
            int nb = 0;

            do
            {
                var builds = RetourneNbBuildDef(_bs, TeamProject, buildDefinition, 100);
                nb = builds.Count();

                foreach (var buildDetail in builds)
                {
                    Console.WriteLine(String.Format("Cleaning of {0} / {1}", buildDefinition.Name,
                                                    buildDetail.BuildNumber));
                    DestroyBuild(teamProjectCollection.Uri.ToString(), buildDefinition.Name,
                                 buildDetail.BuildNumber, options.TeampProject);
                }
            } while (nb > 0);

            Console.WriteLine("=====Cleaning of " + buildDefinition.Name + " done=========");
        }
    public bool Execute()
    {
        // set up support for logging
        TaskLoggingHelper loggingHelper = new TaskLoggingHelper(this);

        // Log Variables
        loggingHelper.LogMessageFromText("Custom Task QueueBuild Starting", MessageImportance.High);
        loggingHelper.LogMessageFromText("tfsServer = " + tfsServer, MessageImportance.High);
        loggingHelper.LogMessageFromText("teamProject = " + teamProject, MessageImportance.High);
        loggingHelper.LogMessageFromText("buildDefinition = " + buildDefinition, MessageImportance.High);
        // Get the team foundation server
        TeamFoundationServer tfs = TeamFoundationServerFactory.GetServer(tfsServer);
        // Get the IBuildServer
        IBuildServer buildServer = (IBuildServer)tfs.GetService(typeof(IBuildServer));
        // Get the build definition for which a build is to be queued
        IBuildDefinition buildDef = buildServer.GetBuildDefinition(teamProject, buildDefinition);
        // Create variable for queuedBuild and queue the build
        var queuedBuild = buildServer.QueueBuild(buildDef);

        loggingHelper.LogMessageFromText("Waiting for newly queued build from Team Project : " + teamProject + " : and Build Definition : " + buildDefinition + " : to complete", MessageImportance.High);
        loggingHelper.LogMessageFromText("Pinging queuedBuild : " + queuedBuild + " : every 5 seconds to confirm when build is complete", MessageImportance.High);
        // Wait for the completion of newly queued build - Will ping build every 5 seconds to confirm completion for a max of 5 hours
        queuedBuild.WaitForBuildCompletion(TimeSpan.FromSeconds(5), TimeSpan.FromHours(5));
        loggingHelper.LogMessageFromText("Queued Build : " + queuedBuild.Build.BuildNumber + " has now completed", MessageImportance.High);
        loggingHelper.LogMessageFromText("Returning to original build", MessageImportance.High);
        return(true);
    }
Ejemplo n.º 10
0
 public void Dispose()
 {
     _buildServer = null;
     _tfsCollection?.Dispose();
     _buildDefinitions = null;
     GC.Collect();
 }
Ejemplo n.º 11
0
        private static GitHubFlowVersionContext CreateContext(GitHubFlowArguments arguments)
        {
            var context = new GitHubFlowVersionContext
            {
                Arguments        = arguments,
                WorkingDirectory =
                    arguments.WorkingDirectory ??
                    Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
            };
            var fallbackStrategy = new LocalBuild();
            var buildServers     = new IBuildServer[] { new TeamCity(context) };

            context.CurrentBuildServer = buildServers.FirstOrDefault(s => s.IsRunningInBuildAgent()) ?? fallbackStrategy;

            context.GitDirectory = GitDirFinder.TreeWalkForGitDir(context.WorkingDirectory);
            if (string.IsNullOrEmpty(context.GitDirectory))
            {
                if (context.CurrentBuildServer.IsRunningInBuildAgent()) //fail the build if we're on a TC build agent
                {
                    // This exception might have to change when more build servers are added
                    throw new Exception("Failed to find .git directory on agent. " +
                                        "Please make sure agent checkout mode is enabled for you VCS roots - " +
                                        "http://confluence.jetbrains.com/display/TCD8/VCS+Checkout+Mode");
                }

                throw new Exception("Failed to find .git directory.");
            }

            Console.WriteLine("Git directory found at {0}", context.GitDirectory);
            context.RepositoryRoot = Directory.GetParent(context.GitDirectory).FullName;

            return(context);
        }
Ejemplo n.º 12
0
        private void WriteFailureMessage(IBuildServer server, AggregateException exception)
        {
            if (server.ProcessId != 0)
            {
                _reporter.WriteLine(
                    string.Format(
                        LocalizableStrings.ShutDownFailedWithPid,
                        server.Name,
                        server.ProcessId,
                        exception.InnerException.Message).Red());
            }
            else
            {
                _reporter.WriteLine(
                    string.Format(
                        LocalizableStrings.ShutDownFailed,
                        server.Name,
                        exception.InnerException.Message).Red());
            }

            if (Reporter.IsVerbose)
            {
                Reporter.Verbose.WriteLine(exception.ToString().Red());
            }
        }
Ejemplo n.º 13
0
        public BuildWrapper(TeamExplorerIntergator teamExplorer)
        {
            tpCollection    = teamExplorer.tpCollection;
            teamProjectName = teamExplorer.tpName;

            buildSrv = (IBuildServer)tpCollection.GetService(typeof(IBuildServer));
        }
Ejemplo n.º 14
0
        public BuildWrapper(string tpCollectionUrl, string aTeamProjectName)
        {
            tpCollection    = new TfsTeamProjectCollection(new Uri(tpCollectionUrl));
            teamProjectName = aTeamProjectName;

            buildSrv = (IBuildServer)tpCollection.GetService(typeof(IBuildServer));
        }
Ejemplo n.º 15
0
        static void Main(string[] args)
        {
            // Try to parse options from command line
            var options = new Options();
            if (Parser.Default.ParseArguments(args, options))
            {
                try
                {
                    _collection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(options.TeamCollection));
                    _buildServer = _collection.GetService<IBuildServer>();
                    _commonStructureService = _collection.GetService<ICommonStructureService>();
                    _printer = new TabbedPrinter();

                    PrintDefinitions(options);
                }
                catch (Exception ex)
                {
                    Console.WriteLine();
                    Console.WriteLine("An error occured:");
                    Console.WriteLine(ex.Message);
                    Console.WriteLine();
                }
            }
            else
            {
                Console.WriteLine("Couldn't read options");
                Console.WriteLine();
            }
        }
Ejemplo n.º 16
0
        public static BuildDefinitionDtoCollection GetBuildDefinitions(this TfsConfigurationServer tfsConfigurationServer, Guid teamProjectCollectionId, string teamProjectName)
        {
            if (tfsConfigurationServer == null)
            {
                throw new ArgumentNullException("tfsConfigurationServer");
            }

            TfsTeamProjectCollection tfsTeamProjectCollection = tfsConfigurationServer.GetTeamProjectCollection(teamProjectCollectionId);
            IBuildServer             buildServer = tfsTeamProjectCollection.GetService <IBuildServer>();

            IBuildDefinition[]           buildDefinitions             = buildServer.QueryBuildDefinitions(teamProjectName);
            BuildDefinitionDtoCollection buildDefinitionDtoCollection = new BuildDefinitionDtoCollection();

            foreach (IBuildDefinition buildDefinition in buildDefinitions)
            {
                BuildDefinitionDto buildDefinitionDto = new BuildDefinitionDto();
                buildDefinitionDto.TeamProjectName = buildDefinition.TeamProject;
                buildDefinitionDto.Name            = buildDefinition.Name;
                buildDefinitionDto.Id  = buildDefinition.Id;
                buildDefinitionDto.Uri = buildDefinition.Uri;
                buildDefinitionDtoCollection.Add(buildDefinitionDto);
            }

            return(buildDefinitionDtoCollection);
        }
Ejemplo n.º 17
0
        private static void Run(GitHubFlowArguments arguments, string workingDirectory)
        {
            var fallbackStrategy = new LocalBuild();
            var buildServers = new IBuildServer[] {new TeamCity()};
            var currentBuildServer = buildServers.FirstOrDefault(s => s.IsRunningInBuildAgent()) ?? fallbackStrategy;

            var gitDirectory = GitDirFinder.TreeWalkForGitDir(workingDirectory);
            if (string.IsNullOrEmpty(gitDirectory))
            {
                if (currentBuildServer.IsRunningInBuildAgent()) //fail the build if we're on a TC build agent
                {
                    // This exception might have to change when more build servers are added
                    throw new Exception("Failed to find .git directory on agent. " +
                                        "Please make sure agent checkout mode is enabled for you VCS roots - " +
                                        "http://confluence.jetbrains.com/display/TCD8/VCS+Checkout+Mode");
                }

                throw new Exception("Failed to find .git directory.");
            }

            Console.WriteLine("Git directory found at {0}", gitDirectory);
            var repositoryRoot = Directory.GetParent(gitDirectory).FullName;

            var gitHelper = new GitHelper();
            var gitRepo = new Repository(gitDirectory);
            var lastTaggedReleaseFinder = new LastTaggedReleaseFinder(gitRepo, gitHelper);
            var nextSemverCalculator = new NextSemverCalculator(new NextVersionTxtFileFinder(repositoryRoot),
                lastTaggedReleaseFinder);
            var buildNumberCalculator = new BuildNumberCalculator(nextSemverCalculator, lastTaggedReleaseFinder, gitHelper,
                gitRepo, currentBuildServer);

            var nextBuildNumber = buildNumberCalculator.GetBuildNumber();
            WriteResults(arguments, nextBuildNumber, currentBuildServer);
        }
Ejemplo n.º 18
0
        private static void FeedBuildData(ICollection <BuildDefinition> buildDefinitionCollection, TfsTeamProjectCollection tpc, string projectName)
        {
            IBuildServer bs = tpc.GetService <IBuildServer>();

            IBuildDefinition[] buildDefinitions = bs.QueryBuildDefinitions(projectName, QueryOptions.All);

            foreach (IBuildDefinition buildDefinition in buildDefinitions)
            {
                IBuildDetail[] buildDetails         = bs.QueryBuilds(buildDefinition);
                int            failedOrPartialCount = buildDetails.Count(x => x.Status == BuildStatus.Failed || x.Status == BuildStatus.PartiallySucceeded);
                IBuildDetail   lastFailedBuild      = buildDetails.Where(x => x.Status == BuildStatus.Failed).OrderBy(x => x.FinishTime).LastOrDefault();
                IBuildDetail   lastSucceededBuild   = buildDetails.Where(x => x.Status == BuildStatus.Succeeded).OrderBy(x => x.FinishTime).LastOrDefault();
                int            buildCount           = buildDetails.Count();

                BuildDefinition buildDef = new BuildDefinition()
                {
                    Name    = buildDefinition.Name,
                    Enabled = buildDefinition.Enabled,
                    ContinuousIntegrationType = buildDefinition.ContinuousIntegrationType.ToString(),
                    FailedOrPartialRatio      = failedOrPartialCount,
                    RetainedBuild             = buildCount,
                    LastSuccess = lastSucceededBuild != null ? lastSucceededBuild.FinishTime : DateTime.MinValue,
                    LastFail    = lastFailedBuild != null ? lastFailedBuild.FinishTime : DateTime.MinValue
                };
                buildDefinitionCollection.Add(buildDef);
            }
        }
        public G19BuildScreenAppletModel GetBuildInformation(IBuildServer buildServer, string buildDefinition, string teamProject)
        {
            G19BuildScreenAppletModel model = new G19BuildScreenAppletModel();

            if (buildServer != null)
            {
                IQueuedBuildSpec queed = buildServer.CreateBuildQueueSpec(teamProject, buildDefinition);

                IQueuedBuildQueryResult queryResult = buildServer.QueryQueuedBuilds(queed);

                IQueuedBuild queuedBuild = queryResult.QueuedBuilds.FirstOrDefault();
                if (queuedBuild == null)
                {
                    return null;
                }
                model.BuildDefinitionName = queuedBuild.Build.BuildDefinition.Name;

                switch (queuedBuild.Status)
                {
                    case QueueStatus.InProgress:
                        model.Status = queuedBuild.Status.ToString();
                        break;
                    case QueueStatus.Canceled:
                        model.Status = queuedBuild.Status.ToString();
                        break;
                    default:
                        model.Status = queuedBuild.Status.ToString();
                        break;
                }
                model.RequestedBy = queuedBuild.RequestedBy;
                model.TeamProjectName = queuedBuild.TeamProject;
                model.TimeRequested = queuedBuild.QueueTime;
            }
            return model;
        }
Ejemplo n.º 20
0
 public MyTfsProjectCollection(MyTfsServer myTfsServer, CatalogNode teamProjectCollectionNode)
 {
     try
     {
         _myTfsServer = myTfsServer;
         Name         = teamProjectCollectionNode.Resource.DisplayName;
         ServiceDefinition tpcServiceDefinition = teamProjectCollectionNode.Resource.ServiceReferences["Location"];
         var configLocationService = myTfsServer.GetConfigLocationService();
         var tpcUri = new Uri(configLocationService.LocationForCurrentConnection(tpcServiceDefinition));
         _tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tpcUri);
         _commonStructureService   = _tfsTeamProjectCollection.GetService <ICommonStructureService>();
         _buildServer = _tfsTeamProjectCollection.GetService <IBuildServer>();
         _tswaClientHyperlinkService = _tfsTeamProjectCollection.GetService <TswaClientHyperlinkService>();
         CurrentUserHasAccess        = true;
     }
     catch (TeamFoundationServiceUnavailableException ex)
     {
         _log.Debug("Can't access " + Name + ". This could be because the project collection is currently offline.", ex);
         CurrentUserHasAccess = false;
     }
     catch (TeamFoundationServerUnauthorizedException ex)
     {
         _log.Debug("Unauthorized access to " + teamProjectCollectionNode, ex);
         CurrentUserHasAccess = false;
     }
 }
Ejemplo n.º 21
0
        /// <summary>
        /// Performs the action of this task.
        /// </summary>
        protected override void InternalExecute()
        {
            using (this.tfs = new TfsTeamProjectCollection(new Uri(this.TeamFoundationServerUrl)))
            {
                this.buildServer = (IBuildServer)this.tfs.GetService(typeof(IBuildServer));

                switch (this.TaskAction)
                {
                case GetLatestTaskAction:
                    this.GetLatestInfo();
                    break;

                case RelatedChangesetsTaskAction:
                    this.RelatedChangesets();
                    break;

                case RelatedWorkItemsTaskAction:
                    this.RelatedWorkItems();
                    break;

                case QueueTaskAction:
                    this.QueueBuild();
                    break;

                default:
                    this.Log.LogError(string.Format(CultureInfo.CurrentCulture, "Invalid TaskAction passed: {0}", this.TaskAction));
                    return;
                }
            }
        }
Ejemplo n.º 22
0
 public BuildFetcher(String serverAddress, String projectName, ICredentials credentials)
 {
     this.projectName = projectName;
     tfsServer = new TeamFoundationServer(serverAddress, credentials);
     tfsServer.Authenticate();
     buildServer = (IBuildServer) tfsServer.GetService(typeof (IBuildServer));
 }
Ejemplo n.º 23
0
        private static IBuildDetail Arrange(MockRepository mockRepository, IEnumerable <string> existingBuildNumbers)
        {
            IBuildDetail      mockBuildDetailForCurrentBuild = mockRepository.DynamicMock <IBuildDetail>();
            IBuildServer      mockBuildServer      = mockRepository.DynamicMock <IBuildServer>();
            IBuildDetailSpec  mockBuildDetailSpec  = mockRepository.DynamicMock <IBuildDetailSpec>();
            IBuildQueryResult mockBuildQueryResult = mockRepository.DynamicMock <IBuildQueryResult>();
            ArrayList         previousBuildsList   = new ArrayList();

            foreach (string existingBuildNumber in existingBuildNumbers)
            {
                IBuildDetail mockBuildDetailForPreviousBuild = mockRepository.DynamicMock <IBuildDetail>();
                previousBuildsList.Add(mockBuildDetailForPreviousBuild);
                Expect.Call(mockBuildDetailForPreviousBuild.BuildNumber).Return(existingBuildNumber);
            }

            IBuildDetail[] previousBuilds = (IBuildDetail[])previousBuildsList.ToArray(typeof(IBuildDetail));
            mockRepository.Record();
            Expect.Call(mockBuildDetailForCurrentBuild.BuildServer).Return(mockBuildServer);
            Expect.Call(mockBuildDetailForCurrentBuild.TeamProject).Return("TeamProjectName");
            Expect.Call(mockBuildServer.CreateBuildDetailSpec("TeamProjectName")).Return(mockBuildDetailSpec);
            Expect.Call(mockBuildServer.QueryBuilds(mockBuildDetailSpec)).Return(mockBuildQueryResult);
            Expect.Call(mockBuildQueryResult.Builds).Return(previousBuilds);

            return(mockBuildDetailForCurrentBuild);
        }
        public void Run(TFSConfiguration tfsConfiguration = null)
        {
            Logger.Log.Info("Run TFS integration");

            if (tfsConfiguration == null)
            {
                Logger.Log.Info($"Application runs from this location: {System.Reflection.Assembly.GetExecutingAssembly().Location}");
                Logger.Log.Info("Read configuration");
                tfsConfiguration = ReadTFSConfiguration(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), CONFIG_FILE));
            }

            Logger.Log.Info($"Authenticate to server {tfsConfiguration.TfsUrl}");
            NetworkCredential credentials = CredentialUtil.GetCredential(
                tfsConfiguration.TfsUrl.AbsoluteUri.Substring(0, tfsConfiguration.TfsUrl.AbsoluteUri.Length - tfsConfiguration.TfsUrl.AbsolutePath.Length + 1));
            TfsTeamProjectCollection tfs = new TfsTeamProjectCollection(tfsConfiguration.TfsUrl, credentials);

            tfs.Authenticate();


            Logger.Log.Info("Get build server!");
            IBuildServer buildServer = tfs.GetService <IBuildServer>();

            Logger.Log.Info($"Build server version: {buildServer.BuildServerVersion}!");

            Parallel.ForEach(tfsConfiguration.TFSSettings, (tfsIntegrationSettings) =>
            {
                Logger.Log.Info($"Get all build definitions from team project {tfsIntegrationSettings.TeamProject}.");
                IBuildDefinition[] buildDefinitions = buildServer.QueryBuildDefinitions(tfsIntegrationSettings.TeamProject, QueryOptions.Definitions);

                if (buildDefinitions == null || !buildDefinitions.Any())
                {
                    Logger.Log.Info("No build definitions found! Exiting!");
                    return;
                }

                Logger.Log.Info($"Found {buildDefinitions.Length} build definitions.");
                IBuildDefinition buildDefinition =
                    buildDefinitions.Where(build => build.Name == tfsIntegrationSettings.BuildDefinitionName)
                    .Select(b => b)
                    .FirstOrDefault();

                Logger.Log.Info($"Get build details from {buildDefinition.Name}.");
                IBuildDetail buildDetail = GetLatestBuildDetails(buildServer, buildDefinition,
                                                                 tfsIntegrationSettings.TeamProject);

                if (buildDetail != null)
                {
                    DownloadVantageInstaller(
                        Path.Combine(buildDetail.DropLocation, tfsIntegrationSettings.SourcePathFragment,
                                     tfsIntegrationSettings.SourceFile),
                        Path.Combine(tfsIntegrationSettings.CopyTo, tfsIntegrationSettings.BuildDefinitionName,
                                     buildDetail.BuildNumber, tfsIntegrationSettings.SourceFile));
                }

                Logger.Log.Info("Cleanup old builds");
                CleanUp(Path.Combine(tfsIntegrationSettings.CopyTo, tfsIntegrationSettings.BuildDefinitionName),
                        tfsIntegrationSettings.MaxBuildsToKeep);
                Logger.Log.Info("FINISHED");
            });
        }
        /// <summary>
        /// Executes the logic for this workflow activity.
        /// </summary>
        /// <param name="context">The workflow context.</param>
        /// <returns>The <see cref="Microsoft.TeamFoundation.Build.Client.IQueuedBuild"/>
        /// object that is returned after queueing the new build.</returns>
        protected override IQueuedBuild Execute(CodeActivityContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            IBuildServer buildServer = context.GetValue(this.BuildServer);

            IBuildDefinition buildDefinition = context.GetValue(this.BuildDefinition);
            IBuildRequest    buildRequest    = buildServer.CreateBuildRequest(buildDefinition.Uri);

            buildRequest.Priority = context.GetValue(this.Priority);

            string processParameters = context.GetValue(this.ProcessParameters);

            if (!string.IsNullOrEmpty(processParameters))
            {
                buildRequest.ProcessParameters = processParameters;
            }

            IBuildController buildController = context.GetValue(this.BuildController);

            if (buildController != null)
            {
                buildRequest.BuildController = buildController;
            }

            IQueuedBuild queuedBuild = buildServer.QueueBuild(buildRequest);

            return(queuedBuild);
        }
Ejemplo n.º 26
0
        /// <summary>
        /// Queries TFS for a list of build definitions
        /// </summary>
        /// <param name="projectName">If set, only builddefs for this project are queried</param>
        /// <param name="buildName"></param>
        /// <returns></returns>
        public static IEnumerable<IBuildDefinitionQueryResult> QueryBuildDefinitions(ICommonStructureService css, IBuildServer bs, string projectName = "", string buildName = "")
        {
            var specs = new List<IBuildDefinitionSpec>();

            if (String.IsNullOrWhiteSpace(projectName))
            {
                // Get a query spec for each team project
                if (String.IsNullOrWhiteSpace(buildName))
                    specs.AddRange(css.ListProjects().Select(pi => bs.CreateBuildDefinitionSpec(pi.Name)));
                else
                    specs.AddRange(css.ListProjects().Select(pi => bs.CreateBuildDefinitionSpec(pi.Name, buildName)));
            }
            else
            {
                // Get a query spec just for this team project
                if (String.IsNullOrWhiteSpace(buildName))
                    specs.Add(bs.CreateBuildDefinitionSpec(projectName));
                else
                    specs.Add(bs.CreateBuildDefinitionSpec(projectName, buildName));
            }

            // Query the definitions
            var results = bs.QueryBuildDefinitions(specs.ToArray());
            return results;
        }
Ejemplo n.º 27
0
        public static TeamBuildDtoCollection GetTeamBuilds(this TfsConfigurationServer tfsConfigurationServer, Guid teamProjectCollectionId, string teamProjectName, IEnumerable <string> teamBuildDefinitionNames)
        {
            if (tfsConfigurationServer == null)
            {
                throw new ArgumentNullException("tfsConfigurationServer");
            }

            if (teamBuildDefinitionNames == null)
            {
                throw new ArgumentNullException("teamBuildDefinitionNames");
            }

            TfsTeamProjectCollection tfsTeamProjectCollection = tfsConfigurationServer.GetTeamProjectCollection(teamProjectCollectionId);
            IBuildServer             buildServer            = tfsTeamProjectCollection.GetService <IBuildServer>();
            TeamBuildDtoCollection   teamBuildDtoCollection = new TeamBuildDtoCollection();

            foreach (string teamBuildDefinitionName in teamBuildDefinitionNames)
            {
                IBuildDetailSpec buildDetailSpec = buildServer.CreateBuildDetailSpec(teamProjectName, teamBuildDefinitionName);
                buildDetailSpec.Reason             = BuildReason.All;
                buildDetailSpec.QueryOrder         = BuildQueryOrder.FinishTimeDescending;
                buildDetailSpec.QueryDeletedOption = QueryDeletedOption.ExcludeDeleted;
                IBuildQueryResult buildQueryResult = buildServer.QueryBuilds(buildDetailSpec);
                foreach (IBuildDetail buildDetail in buildQueryResult.Builds)
                {
                    TeamBuildDto teamBuildDto = new TeamBuildDto();
                    teamBuildDto.BuildNumber    = buildDetail.BuildNumber;
                    teamBuildDto.Uri            = buildDetail.Uri;
                    teamBuildDto.DefinitionName = teamBuildDefinitionName;
                    teamBuildDtoCollection.Add(teamBuildDto);
                }
            }

            return(teamBuildDtoCollection);
        }
Ejemplo n.º 28
0
        private IEnumerable <BuildInfoDto> GetBuildInfoDtosPerBuildDefinition(List <IBuildDefinition> buildDefinitionList,
                                                                              IBuildServer buildServer, CatalogNode teamProjectNode,
                                                                              TfsTeamProjectCollection teamProjectCollection, ITestManagementService testService, DateTime filterDate)
        {
            var buildDtos = new List <BuildInfoDto>();

            try
            {
                Parallel.ForEach(buildDefinitionList, def =>
                {
                    var build = GetBuild(buildServer, teamProjectNode, def, filterDate);

                    if (build == null)
                    {
                        return;
                    }

                    var buildInfoDto = new BuildInfoDto
                    {
                        Builddefinition       = def.Name,
                        FinishBuildDateTime   = build.FinishTime,
                        LastBuildTime         = new TimeSpan(),
                        PassedNumberOfTests   = 0,
                        RequestedByName       = build.RequestedFor,
                        RequestedByPictureUrl = "",
                        StartBuildDateTime    = build.StartTime,
                        Status                = Char.ToLowerInvariant(build.Status.ToString()[0]) + build.Status.ToString().Substring(1),
                        TeamProject           = teamProjectNode.Resource.DisplayName,
                        TeamProjectCollection = teamProjectCollection.Name,
                        TotalNumberOfTests    = 0,
                        Id             = "TFS" + teamProjectNode.Resource.Identifier + def.Id,
                        BuildReportUrl = _helperClass.GetReportUrl(teamProjectCollection.Uri.ToString(), teamProjectNode.Resource.DisplayName, build.Uri.OriginalString)
                    };
                    //Retrieve testruns
                    var testResults = GetTestResults(teamProjectNode, testService, build);

                    if (testResults.ContainsKey("PassedTests"))
                    {
                        buildInfoDto.PassedNumberOfTests = testResults["PassedTests"];
                        buildInfoDto.TotalNumberOfTests  = testResults["TotalTests"];
                    }
                    //Add last succeeded build if in progress
                    if (build.Status == BuildStatus.InProgress)
                    {
                        buildInfoDto.LastBuildTime = GetLastSuccesfulBuildTime(buildServer, teamProjectNode, def);
                    }
                    lock (buildDtos)
                    {
                        buildDtos.Add(buildInfoDto);
                    }
                });
            }
            catch (Exception e)
            {
                LogService.WriteError(e);
                throw;
            }

            return(buildDtos);
        }
Ejemplo n.º 29
0
        protected override void Execute(CodeActivityContext context)
        {
            String[]     dirty       = context.GetValue(this.TfsProjectAndBuildDefinition);
            IBuildDetail buildDetail = context.GetValue(this.BuildDetail);

            var pds = Parse(dirty);
            //var workspace = buildDetail.BuildDefinition.Workspace;
            IBuildServer buildServer = buildDetail.BuildServer;

            foreach (var pd in pds)
            {
                try
                {
                    string message = string.Format("Queue new build \"{0}\"-\"{1}\"", pd.TfsProject, pd.BuildDefinition);
                    context.TrackBuildMessage(message);

                    IBuildDefinition buildDef = buildServer.GetBuildDefinition(pd.TfsProject, pd.BuildDefinition);
                    buildServer.QueueBuild(buildDef);
                }
                catch (Exception ex)
                {
                    string message = string.Format("Queue new build error \"{0}\"-\"{1}\", Exception : \"{2}\"",
                                                   pd.TfsProject, pd.BuildDefinition, ex.Message);
                    context.TrackBuildWarning(message);
                }
            }
        }
        public void SetConfiguration(ConfigurationBase newConfiguration)
        {
            if (timer != null)
            {
                timer.Change(Timeout.Infinite, Timeout.Infinite);
            }

            configuration = newConfiguration as TeamFoundationConfiguration;
            if (configuration == null)
            {
                throw new ApplicationException("Configuration can not be null.");
            }

            var credentialProvider = new PlainCredentialsProvider(configuration.Username, configuration.Password);

            var teamProjectCollection = new TfsTeamProjectCollection(new Uri(configuration.CollectionUri), credentialProvider);
            buildServer = teamProjectCollection.GetService<IBuildServer>();

            if (timer == null)
            {
                timer = new Timer(Tick, null, 0, configuration.PollInterval);
            }
            else
            {
                timer.Change(0, configuration.PollInterval);
            }
        }
Ejemplo n.º 31
0
 public MyTfsProjectCollection(CatalogNode teamProjectCollectionNode, TfsConfigurationServer tfsConfigurationServer, NetworkCredential networkCredential)
 {
     try
     {
         Name = teamProjectCollectionNode.Resource.DisplayName;
         ServiceDefinition tpcServiceDefinition = teamProjectCollectionNode.Resource.ServiceReferences["Location"];
         var configLocationService = tfsConfigurationServer.GetService<ILocationService>();
         var tpcUri = new Uri(configLocationService.LocationForCurrentConnection(tpcServiceDefinition));
         _tfsTeamProjectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(tpcUri, new MyCredentials(networkCredential));
         _commonStructureService = _tfsTeamProjectCollection.GetService<ICommonStructureService>();
         _buildServer = _tfsTeamProjectCollection.GetService<IBuildServer>();
         _tswaClientHyperlinkService = _tfsTeamProjectCollection.GetService<TswaClientHyperlinkService>();
         CurrentUserHasAccess = true;
     }
     catch (TeamFoundationServiceUnavailableException ex)
     {
         _log.Debug("Can't access " + Name + ". This could be because the project collection is currently offline.", ex);
         CurrentUserHasAccess = false;
     }
     catch (TeamFoundationServerUnauthorizedException ex)
     {
         _log.Debug("Unauthorized access to " + teamProjectCollectionNode, ex);
         CurrentUserHasAccess = false;
     }
 }
Ejemplo n.º 32
0
 public Deployer(IConfigurationReader reader, IAlert alert, IBuildServer buildServer, IMappingProcessor mappingProcessor)
 {
     _configurationReader = reader;
     _alerter             = alert;
     _buildServer         = buildServer;
     _mappingProcessor    = mappingProcessor;
 }
Ejemplo n.º 33
0
 public TfsBuildStatusPoll(IBuildServer buildServer, IDeployerFactory deployerFactory)
 {
     _buildServer      = buildServer;
     _deployerFactory  = deployerFactory;
     _webAccessLinks   = _buildServer.TeamProjectCollection.GetService <TswaClientHyperlinkService>();
     _structureService = _buildServer.TeamProjectCollection.GetService <ICommonStructureService>();
     _timer            = new Timer(state => PollBuildQualityChanges());
 }
 private static string FormatSuccessMessage(IBuildServer server)
 {
     if (server.ProcessId != 0)
     {
         return(string.Format(LocalizableStrings.ShutDownSucceededWithPid, server.Name, server.ProcessId).Green());
     }
     return(string.Format(LocalizableStrings.ShutDownSucceeded, server.Name).Green());
 }
Ejemplo n.º 35
0
        private IBuildServer GetBuildServer(string serverUri)
        {
            TfsTeamProjectCollection teamProjectCollection =
                TfsTeamProjectCollectionFactory.GetTeamProjectCollection(new Uri(serverUri));
            IBuildServer buildServer = teamProjectCollection.GetService <IBuildServer>();

            return(buildServer);
        }
 private static string FormatFailureMessage(IBuildServer server, string message)
 {
     if (server.ProcessId != 0)
     {
         return(string.Format(LocalizableStrings.ShutDownFailedWithPid, server.Name, server.ProcessId, message).Red());
     }
     return(string.Format(LocalizableStrings.ShutDownFailed, server.Name, message).Red());
 }
 private static string FormatShuttingDownMessage(IBuildServer server)
 {
     if (server.ProcessId != 0)
     {
         return(string.Format(LocalizableStrings.ShuttingDownServerWithPid, server.Name, server.ProcessId));
     }
     return(string.Format(LocalizableStrings.ShuttingDownServer, server.Name));
 }
Ejemplo n.º 38
0
        /// <summary>
        /// Executes the logic for this workflow activity.
        /// </summary>
        /// <returns>The <see cref="Microsoft.TeamFoundation.Build.Client.IBuildDefinition"/>
        /// that is specified.</returns>
        protected override IBuildDefinition InternalExecute()
        {
            IBuildServer buildServer         = this.BuildServer.Get(this.ActivityContext);
            string       teamProjectName     = this.TeamProjectName.Get(this.ActivityContext);
            string       buildDefinitionName = this.BuildDefinitionName.Get(this.ActivityContext);

            return(buildServer.GetBuildDefinition(teamProjectName, buildDefinitionName));
        }
Ejemplo n.º 39
0
        private static string ResolveCurrentBranch(IBuildServer buildServer, string targetBranch)
        {
            if (buildServer == null) return targetBranch;

            var currentBranch = buildServer.GetCurrentBranch() ?? targetBranch;
            Logger.WriteInfo("Branch from build environment: " + currentBranch);

            return currentBranch;
        }
Ejemplo n.º 40
0
 public Tfs2010BuildService(
     IBuildServer buildServer,
     VersionControlServer versionControlServer,
     ITestManagementService testManagementService)
 {
     this.buildServer = buildServer;
     this.versionControlServer = versionControlServer;
     this.testManagementService = testManagementService;
 }
 public BuildNumberCalculatorTests()
 {
     var gitRepo = Substitute.For<IRepository>();
     _nextSemver = Substitute.For<INextSemverCalculator>();
     _lastTaggedReleaseFinder = Substitute.For<ILastTaggedReleaseFinder>();
     _gitHelper = Substitute.For<IGitHelper>();
     _buildServer = Substitute.For<IBuildServer>();
     _sut = new BuildNumberCalculator(_nextSemver, _lastTaggedReleaseFinder, _gitHelper, gitRepo, _buildServer);
 }
Ejemplo n.º 42
0
        public BuildNumberChecker(IBuildServer buildServer)
        {
            if (buildServer == null)
            {
                throw new ArgumentNullException("buildServer");
            }

            _buildServer = buildServer;
        }
Ejemplo n.º 43
0
        private IBuildDetail GetLatestBuildDetails(IBuildServer buildServer, IBuildDefinition def)
        {
            IBuildDetailSpec spec = buildServer.CreateBuildDetailSpec(_configuration.TfsTeamProjectName, def.Name);
            spec.MaxBuildsPerDefinition = 1;
            spec.QueryOrder = BuildQueryOrder.FinishTimeDescending;

            var builds = buildServer.QueryBuilds(spec);
            return builds.Builds.FirstOrDefault();
        }
Ejemplo n.º 44
0
        /// <summary>
        /// Loads the build service.
        /// </summary>
        /// <exception cref="NullReferenceException">Thrown if no build service is found.</exception>
        public void LoadBuildService()
        {
            buildServer = teamProjectCollection.GetService<IBuildServer>();

            if (buildServer == null)
            {
                throw new NullReferenceException();
            }
        }
Ejemplo n.º 45
0
        /// <summary>
        /// Connects the specified URL.
        /// </summary>
        /// <param name="url">The URL.</param>
        /// <param name="projectName">Name of the project.</param>
        /// <returns></returns>
        public TfsConnector Connect(string url, string projectName)
        {
            var tfs = new TfsTeamProjectCollection(new Uri(url));

            this.buildServer = (IBuildServer) tfs.GetService(typeof (IBuildServer));
            this.buildDetailSpec = this.buildServer.CreateBuildDetailSpec(projectName);

            return this;
        }
Ejemplo n.º 46
0
        private IEnumerable<IBuildDetail> GetBuilds(IBuildServer server, string status, DateTime started, DateTime finished, string collection)
        {
            var query = server.CreateBuildDetailSpec(collection);
              query.Status = (BuildStatus)Enum.Parse(typeof(BuildStatus), status);
              query.MinFinishTime = started;
              query.MaxFinishTime = finished;

              return server.QueryBuilds(query).Builds;
        }
 public MainWindowViewModel()
 {
     server = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(
         RegisteredTfsConnections.GetProjectCollections().First().Uri);
     workItemStore = (WorkItemStore)server.GetService(typeof(WorkItemStore));
     versionControl = server.GetService<VersionControlServer>();
     buildServer = (IBuildServer)server.GetService(typeof(IBuildServer));
     historyLoader = new HistoryLoader(versionControl);
     loadHistoryCommand = new DelegateCommand(LoadHistory);
 }
Ejemplo n.º 48
0
        static void QueryBuildDefinitions(IBuildServer buildServer)
        {
            Console.WriteLine();
            Console.WriteLine("QueryBuildDefinitions:");

            IBuildDefinition[] buildDefinitions = buildServer.QueryBuildDefinitions("Contoso");
            foreach (var buildDefinition in buildDefinitions)
            {
                Console.WriteLine("\t{0}", buildDefinition.Name);
            }
        }
Ejemplo n.º 49
0
        static void CancelQueuedBuilds(IBuildServer buildServer)
        {
            IQueuedBuildsView queuedBuildsView = buildServer.CreateQueuedBuildsView("Contoso");
            queuedBuildsView.StatusFilter = QueueStatus.Queued;
            queuedBuildsView.QueryOptions = QueryOptions.Definitions | QueryOptions.Controllers;
            queuedBuildsView.Refresh(false);

            foreach (IQueuedBuild queuedBuild in queuedBuildsView.QueuedBuilds) {
                queuedBuild.Cancel();
            }
        }
Ejemplo n.º 50
0
        public static IEnumerable<string> GenerateBuildLogOutput(SemanticVersion semanticVersion, IBuildServer buildServer)
        {
            var output = new List<string>();

            foreach (var variable in VariableProvider.GetVariablesFor(semanticVersion, new Config()))
            {
                output.AddRange(buildServer.GenerateSetParameterMessage(variable.Key, variable.Value));
            }

            return output;
        }
Ejemplo n.º 51
0
        public static IEnumerable<string> GenerateBuildLogOutput(IBuildServer buildServer, VersionVariables variables)
        {
            var output = new List<string>();

            foreach (var variable in variables)
            {
                output.AddRange(buildServer.GenerateSetParameterMessage(variable.Key, variable.Value));
            }

            return output;
        }
Ejemplo n.º 52
0
        private static IBuildDetailSpec GetBuildDetailSpec(int maxDays, string teamProject, string buildDefinition, IBuildServer buildServer)
        {
            IBuildDetailSpec spec = string.IsNullOrEmpty(buildDefinition) ?
                buildServer.CreateBuildDetailSpec(teamProject) :
                buildServer.CreateBuildDetailSpec(teamProject, buildDefinition);

            spec.MinFinishTime = DateTime.Now.Subtract(TimeSpan.FromDays(maxDays));
            spec.MaxFinishTime = DateTime.Now;
            spec.QueryDeletedOption = QueryDeletedOption.IncludeDeleted;
            return spec;
        }
Ejemplo n.º 53
0
        VersionVariables ExecuteInternal(string targetBranch, string commitId, IRepository repo, GitPreparer gitPreparer, string projectRoot, IBuildServer buildServer)
        {
            gitPreparer.Initialise(buildServer != null, ResolveCurrentBranch(buildServer, targetBranch, gitPreparer.IsDynamicGitRepository));

            var versionFinder = new GitVersionFinder();
            var configuration = ConfigurationProvider.Provide(projectRoot, fileSystem);

            var gitVersionContext = new GitVersionContext(repo, configuration, commitId : commitId);
            var semanticVersion = versionFinder.FindVersion(gitVersionContext);

            return VariableProvider.GetVariablesFor(semanticVersion, gitVersionContext.Configuration, gitVersionContext.IsCurrentCommitTagged);
        }
Ejemplo n.º 54
0
        static string ResolveCurrentBranch(IBuildServer buildServer, string targetBranch, bool isDynamicRepository)
        {
            if (buildServer == null)
            {
                return targetBranch;
            }

            var currentBranch = buildServer.GetCurrentBranch(isDynamicRepository) ?? targetBranch;
            Logger.WriteInfo("Branch from build environment: " + currentBranch);

            return currentBranch;
        }
 public BuildNumberCalculator(
     INextSemverCalculator nextSemverCalculator,
     ILastTaggedReleaseFinder lastTaggedReleaseFinder,
     IGitHelper gitHelper, IRepository gitRepo, 
     IBuildServer buildServer)
 {
     _nextSemverCalculator = nextSemverCalculator;
     _lastTaggedReleaseFinder = lastTaggedReleaseFinder;
     _gitHelper = gitHelper;
     _gitRepo = gitRepo;
     _buildServer = buildServer;
 }
 private static ProjectInfo[] CreateProjectInfos(int quantity, int buildDefinitionQuantity, int buildDetailQuantity, IBuildServer mockBuildServer)
 {
     var projectInfos = new ProjectInfo[quantity];
     for (var i = 0; i < quantity; i++)
     {
         var projectInfo = new ProjectInfo {Name = string.Format("TeamProject{0}", i)};
         projectInfos[i] = projectInfo;
         mockBuildServer.Stub(m => m.QueryBuildDefinitions(projectInfo.Name))
             .Return(CreateFakeBuildDefinitions(projectInfo.Name, buildDefinitionQuantity, buildDetailQuantity, mockBuildServer));
     }
     return projectInfos;
 }
Ejemplo n.º 57
0
        static void BulkUpdateController(IBuildServer buildServer)
        {
            IBuildDefinition[] buildDefinitions = buildServer.QueryBuildDefinitions("Contoso");

            IBuildController defaultBuildController = buildServer.QueryBuildServiceHosts("*")
                .Where(bsh => bsh.Controller != null).Select(bsh => bsh.Controller).First();

            foreach (IBuildDefinition buildDefinition in buildDefinitions)
            {
                buildDefinition.BuildController = defaultBuildController;
                buildDefinition.Save();
            }
        }
Ejemplo n.º 58
0
        public TfsBridge(IServiceProvider teamFoundationServiceProvider,
                                     string buildDefinitionNameExclusionPattern,
                                     IBuildConfigurationManager buildConfigurationManager)
        {
            _teamFoundationServiceProvider = teamFoundationServiceProvider;
            _buildConfigurationManager = buildConfigurationManager;

            if (!string.IsNullOrEmpty(buildDefinitionNameExclusionPattern))
            {
                _buildDefinitionNameExclusionRegex = new Regex(buildDefinitionNameExclusionPattern,
                                                               RegexOptions.IgnoreCase | RegexOptions.Compiled);
            }

            _buildServer = _teamFoundationServiceProvider.GetService<IBuildServer>();
        }
 protected static FakeBuildDefinition[] CreateFakeBuildDefinitions(string teamProjectName, int quantity, int buildDetailQuantity, IBuildServer mockBuildServer)
 {
     var definitions = new FakeBuildDefinition[quantity];
     for (var i = 0; i < quantity; i++)
     {
         var definition = new FakeBuildDefinition
                              {
                                  Name = string.Format("{0}_{1}", teamProjectName, i),
                                  TeamProject = teamProjectName,
                                  Enabled = true
                              };
         definitions[i] = definition;
         mockBuildServer.Stub(m => m.QueryBuilds(definition))
             .Return(CreateFakeBuildDetails(buildDetailQuantity, definition, teamProjectName));
     }
     return definitions;
 }
Ejemplo n.º 60
0
        public TfsApiRepository(string uri)
        {
            var tfsUri = new Uri(uri);
            //var credential = new NetworkCredential("*****@*****.**", "kubekstolik40");
            //_tfs = new TfsTeamProjectCollection(tfsUri,credential);
            _tfs = new TfsTeamProjectCollection(tfsUri);

            try
            {
                _tfs.EnsureAuthenticated();
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("Autentykacja sie nie powiodla.({0})", ex.Message));
            }

            _buildServer = (IBuildServer)_tfs.GetService(typeof(IBuildServer));
        }