/// <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)); }
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); }
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); }
/// <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); }
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); }
public void Dispose() { _buildServer = null; _tfsCollection?.Dispose(); _buildDefinitions = null; GC.Collect(); }
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); }
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()); } }
public BuildWrapper(TeamExplorerIntergator teamExplorer) { tpCollection = teamExplorer.tpCollection; teamProjectName = teamExplorer.tpName; buildSrv = (IBuildServer)tpCollection.GetService(typeof(IBuildServer)); }
public BuildWrapper(string tpCollectionUrl, string aTeamProjectName) { tpCollection = new TfsTeamProjectCollection(new Uri(tpCollectionUrl)); teamProjectName = aTeamProjectName; buildSrv = (IBuildServer)tpCollection.GetService(typeof(IBuildServer)); }
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(); } }
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); }
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); }
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; }
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; } }
/// <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; } } }
public BuildFetcher(String serverAddress, String projectName, ICredentials credentials) { this.projectName = projectName; tfsServer = new TeamFoundationServer(serverAddress, credentials); tfsServer.Authenticate(); buildServer = (IBuildServer) tfsServer.GetService(typeof (IBuildServer)); }
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); }
/// <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; }
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); }
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); }
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); } }
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; } }
public Deployer(IConfigurationReader reader, IAlert alert, IBuildServer buildServer, IMappingProcessor mappingProcessor) { _configurationReader = reader; _alerter = alert; _buildServer = buildServer; _mappingProcessor = mappingProcessor; }
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()); }
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)); }
/// <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)); }
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; }
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); }
public BuildNumberChecker(IBuildServer buildServer) { if (buildServer == null) { throw new ArgumentNullException("buildServer"); } _buildServer = buildServer; }
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(); }
/// <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(); } }
/// <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; }
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); }
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); } }
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(); } }
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; }
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; }
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; }
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); }
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; }
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(); } }
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; }
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)); }