private void QueueBuild() { if (string.IsNullOrEmpty(this.BuildDefinitionName)) { Log.LogError("BuildDefinitionName is required to queue a build"); return; } this.LogTaskMessage(string.Format(CultureInfo.CurrentCulture, "Queueing Build: {0}", this.BuildDefinitionName)); IBuildDefinition definition = this.buildServer.GetBuildDefinition(this.TeamProject, this.BuildDefinitionName); IBuildRequest request = definition.CreateBuildRequest(); if (this.DropLocation != null) { request.DropLocation = this.DropLocation; } // queue the build var queuedBuild = this.buildServer.QueueBuild(request, QueueOptions.None); // After adding the new prams, the Uri started throwing Null exceptions. // Added check to handle it if (queuedBuild.Build.Uri != null) { this.BuildUri = queuedBuild.Build.Uri.ToString(); } }
public static IBuildDefinition DialogShow(IBuildDefinition definition, FormActionMode mode) { IBuildDefinition result = null; if (form == null) { form = new FormDefinitionEdit(); } if (definition == null) { definition = new TempBuildDefinition(); } form.definition = definition; form.mode = mode; form.Initialize(); if (form.ShowDialog() == DialogResult.OK) { if (form.mode != FormActionMode.View) { result = new TempBuildDefinition(); // general result.Name = form.controlGeneral.DefinitionName; result.Description = form.controlGeneral.Description; result.Enabled = !form.controlGeneral.DisableBuildDefinition; // workspace } } return(result); }
/// <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); }
public static BuildTemplate DialogShow(BuildTemplate editTemplate, IBuildDefinition buildDefinition, FormActionMode mode) { bool saveChanges; return(DialogShow(editTemplate, buildDefinition, mode, out saveChanges)); }
/// <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); }
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 BuildDefinitionInfo(TeamCollectionInfo teamCollectionInfo, IBuildDefinition buildDefinition) { this.BuildDefinition = buildDefinition; this.TeamCollection = teamCollectionInfo; this.ReferencedAssemblies = new HashSet<string>(); this.Solutions = new List<SolutionInfo>(); }
public void Initialize(IBuildDefinition definition) { this.definition = definition; this.lvWorkspaces.Items.Clear(); if (definition != null) { this.lvWorkspaces.BeginUpdate(); try { List <IWorkspaceMapping> mappings = definition.Workspace.Mappings; mappings.Sort((mapping1, mapping2) => { return(string.Compare(mapping1.ServerItem, mapping2.ServerItem)); }); foreach (IWorkspaceMapping mapping in mappings) { AddItemToList(mapping, false); } AddItemToList(null, true); } finally { this.lvWorkspaces.EndUpdate(); } } UpdateWarning(); }
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"); }); }
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 void FocusAndSelectBuildTemplate(IBuildDefinition definition) { EnsureSelectedTeamProject(definition.TeamProject, false); ButtonClick(this.btnBuildDefinitions, EventArgs.Empty); this.controlDefinitions.FocusAndSelectDefinition(definition); }
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); }
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 MockBuild(string id, IBuildDefinition buildDefinition, string branchName) : this() { Id = id; Definition = buildDefinition; BranchName = branchName; }
public void RemapWorkspaces(IBuildDefinition buildDefinition) { var viewModel = new RemapWorkspacesViewModel(buildDefinition); var remapWorkSpacesWindow = new RemapWorkspaces(viewModel); remapWorkSpacesWindow.ShowDialog(); }
private void LoadCbBuilds(object sender) { cbBuilds.Items.Clear(); // bdef is the selected build definition var bdef = (((ComboBox)sender).SelectedItem) as IBuildDefinition; _builddef = bdef; if (bdef != null) { // _bs = IBuildServer service, create a new query IBuildDetailSpec def = bs.CreateBuildDetailSpec(_teamFoundationContext.TeamProjectName); // only bring back the last 100 deleted builds def.MaxBuildsPerDefinition = 100; // query for only deleted builds def.QueryDeletedOption = QueryDeletedOption.OnlyDeleted; // Last deleted should be returned 1st def.QueryOrder = BuildQueryOrder.FinishTimeDescending; // Only look for deleted builds in the chosen build definition def.DefinitionSpec.Name = bdef.Name; // Bring back deleted builds from any state def.Status = BuildStatus.All; // Pass this query for processing to the build service IBuildDetail[] builds = tfs.GetService <IBuildServer>().QueryBuilds(def).Builds; foreach (IBuildDetail build in builds) { cbBuilds.Items.Add(build.BuildNumber); } cbBuilds.IsEnabled = true; } }
internal IList<Build> GetBuildsFromDefinition(IBuildDefinition buildDefinition) { IList<Build> builds = new List<Build>(); foreach (var buildDetail in fetcher.GetBuildHistory(buildDefinition)) builds.Add(ConvertBuildDetailToDomainType(buildDetail)); return builds; }
private static void CloneRetentionPolicies(IBuildDefinition bd, IBuildDefinition newBuildDefinition) { newBuildDefinition.RetentionPolicyList.Clear(); foreach (var retpol in bd.RetentionPolicyList) { newBuildDefinition.AddRetentionPolicy(retpol.BuildReason, retpol.BuildStatus, retpol.NumberToKeep, retpol.DeleteOptions); } }
public void FocusAndSelectDefinition(IBuildDefinition definition) { this.lvDefinitions.SelectedItems.Clear(); SelectBuildDefinitions(new List <IBuildDefinition> { definition }); }
public BuildDetail(IBuildDefinition buildDef, IBuildDetail buildDetail) { Id = buildDef.Id; ContinuousIntegrationType = buildDef.ContinuousIntegrationType; BuildDefinitionName = buildDef.Name; Build = buildDetail; }
public void QueueBuild() { IBuildDefinition buildDefinition = SelectedBuildDefinition.BuildDefinition; IBuildRequest bdrequest; bdrequest = buildDefinition.CreateBuildRequest(); _buildserver.QueueBuild(bdrequest); }
public BuildTemplate(IBuildDefinition definition) { this.DefinitionName = definition.Name; this.TeamProject = definition.TeamProject; //this.BuildAgentName = definition.DefaultBuildAgent.Name; //this.BuildAgentUri = definition.DefaultBuildAgent.Uri.ToString(); this.DefaultDropLocation = definition.DefaultDropLocation; this.RunPriority = QueuePriority.Normal; }
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(); }
public BuildDefinitionViewModel(IBuildDefinition buildDefinition) { if (buildDefinition == null) { throw new ArgumentNullException(nameof(buildDefinition)); } BuildDefinition = buildDefinition; }
private void mniGotoDefinition_Click(object sender, EventArgs e) { var itemBuild = GetTreeView().SelectedItems[0].Tag as BuildInfo; IBuildDetail buildDetail = IsQueuedSelected ? itemBuild.queuedBuild.Build : itemBuild.buildDetail; IBuildDefinition definition = Context.BuildServer.GetBuildDefinition(buildDetail.BuildDefinition.Uri); //this.parentControl.FocusAndSelectBuildTemplate(definition); UIContext.Instance.ControlTeamBuilds.FocusAndSelectBuildTemplate(definition); }
public VersionControlType GetVersionControlType(IBuildDefinition buildDefinition) { if (buildDefinition.SourceProviders.Any(s => s.Name.ToUpperInvariant().Contains("GIT"))) { return(VersionControlType.Git); } return(VersionControlType.Tfvc); }
private static void ViewBuildDefinition(IBuildDefinition definition) { VsTeamFoundationBuild vsTfBuild = (VsTeamFoundationBuild)Get <IVsTeamFoundationBuild>(); if (vsTfBuild != null) { vsTfBuild.DefinitionManager.OpenDefinition(definition.Uri); } }
private static void CopySchedules(IBuildDefinition source, IBuildDefinition target) { foreach (var schedule in source.Schedules) { var newSchedule = target.AddSchedule(); newSchedule.DaysToBuild = schedule.DaysToBuild; newSchedule.StartTime = schedule.StartTime; newSchedule.TimeZone = schedule.TimeZone; } }
private static void CloneBuildSchedule(IBuildDefinition bd, IBuildDefinition newBuildDefinition) { foreach (var sched in bd.Schedules) { var newSched = newBuildDefinition.AddSchedule(); newSched.DaysToBuild = sched.DaysToBuild; newSched.StartTime = sched.StartTime; newSched.TimeZone = sched.TimeZone; } }
public void Dispose() { _buildServer = null; if (_tfsCollection != null) { _tfsCollection.Dispose(); } _buildDefinition = null; GC.Collect(); }
private IBuild CreateBuild(IBuildDefinition definition, IBranch branch, string id) { var build = Substitute.For <IBuild>(); build.Definition.Returns(definition); build.BranchName.Returns(branch.FullName); build.Id.Returns(id); return(build); }
/// <summary> /// Clears all workspace mappings from a build definition /// </summary> /// <param name="buildDefinition">Build definition to clear.</param> /// <remarks>The build definition is not saved after the mappings are cleared.</remarks> public static void ClearWorkspaceMappings(IBuildDefinition buildDefinition) { // Validation ArgumentValidation.ValidateObjectIsNotNull(buildDefinition, "buildDefinition"); var buildWorkspaceMappings = buildDefinition.Workspace.Mappings; while (buildWorkspaceMappings.Count > 0) { buildWorkspaceMappings.Remove(buildWorkspaceMappings[0]); } }
private BuildStoreEventSource CreateBuildStoreEventSource() { var eventSource = CreateBuildStoreEventSource(ProjectNameExclusionPattern, BuildDefinitionNameExclusionPattern); var firstProject = ProjectInfos[0]; DefinitionNamedBuildTrial = MockBuildServer.QueryBuildDefinitions(firstProject.Name).First(); DefinitionNamedBuildTrial.Name = "BuildTrial"; return eventSource; }
/// <summary> /// Adds a new workspace mapping to an existing build definition /// </summary> /// <param name="buildDefinition">Build definition for the new mapping</param> /// <param name="localItem">Local path for the mapping</param> /// <param name="serverItem">Server path for the mapping</param> /// <param name="mappingType">Type of mapping (map or cloak)</param> /// <param name="depth">The Mapping Depth</param> /// <returns>The created workspace mapping</returns> /// <remarks>The build definition is not saved after the mapping is added.</remarks> public static IWorkspaceMapping AddWorkspaceMapping(IBuildDefinition buildDefinition, string localItem, string serverItem, WorkspaceMappingType mappingType, WorkspaceMappingDepth depth) { // Validation ArgumentValidation.ValidateObjectIsNotNull(buildDefinition, "buildDefinition"); ArgumentValidation.ValidateStringIsNotEmpty(localItem, "localPath"); ArgumentValidation.ValidateStringIsNotEmpty(serverItem, "serverPath"); var mapping = buildDefinition.Workspace.AddMapping(serverItem, localItem, mappingType, depth); return mapping; }
public IBuildDefinition CloneBuildDefinition(TfsTeamProjectCollection tfsTeamProjectCollection, string projectName, IBuildDefinition sourceDefinition) { this.Logger().Trace("CloneBuildDefinition"); var buildServer = tfsTeamProjectCollection.GetService<IBuildServer>(); var clonedDefinition = buildServer.CreateBuildDefinition(projectName); clonedDefinition.CopyFrom(sourceDefinition); clonedDefinition.Name = string.Format("Copy of {0}", clonedDefinition.Name); clonedDefinition.Save(); return clonedDefinition; }
/// <summary> /// Adds a new workspace mapping to an existing build definition /// </summary> /// <param name="buildDefinition">Build definition for the new mapping</param> /// <param name="localItem">Local path for the mapping</param> /// <param name="serverItem">Server path for the mapping</param> /// <param name="mappingType">Type of mapping (map or cloak)</param> /// <param name="depth">The Mapping Depth</param> /// <returns>The created workspace mapping</returns> /// <remarks>The build definition is not saved after the mapping is added.</remarks> public static IWorkspaceMapping AddWorkspaceMapping(IBuildDefinition buildDefinition, string localItem, string serverItem, WorkspaceMappingType mappingType, WorkspaceMappingDepth depth) { // Validation ArgumentValidation.ValidateObjectIsNotNull(buildDefinition, "buildDefinition"); ArgumentValidation.ValidateStringIsNotEmpty(localItem, "localPath"); ArgumentValidation.ValidateStringIsNotEmpty(serverItem, "serverPath"); var mapping = buildDefinition.Workspace.AddMapping(serverItem, localItem, mappingType, depth); return(mapping); }
public string GetNotificationAddress(IBuildDefinition definition) { string buildName = definition.Name; BuildMapperElement element = _buildConfigurationManager .BuildMappers .OfType<BuildMapperElement>() .FirstOrDefault(x => x.TfsBuildToMonitor == buildName); if (element != null) return element.NotificationAddress; return null; }
private static void CopyMappings(IBuildDefinition source, IBuildDefinition target) { foreach (var mapping in source.Workspace.Mappings) { target.Workspace.AddMapping( mapping.ServerItem, mapping.LocalItem, mapping.MappingType, mapping.Depth ); } }
public static void SetRetentionPolicies(IBuildDefinition definition, int succeeded, int partiallySucceeded, int failed, int stopped) { definition.RetentionPolicyList.Clear(); definition.AddRetentionPolicy(BuildReason.ValidateShelveset, BuildStatus.Succeeded, succeeded, DeleteOptions.Details | DeleteOptions.DropLocation | DeleteOptions.Label | DeleteOptions.TestResults); definition.AddRetentionPolicy(BuildReason.ValidateShelveset, BuildStatus.PartiallySucceeded, partiallySucceeded, DeleteOptions.All); definition.AddRetentionPolicy(BuildReason.ValidateShelveset, BuildStatus.Failed, failed, DeleteOptions.All); definition.AddRetentionPolicy(BuildReason.ValidateShelveset, BuildStatus.Stopped, stopped, DeleteOptions.All); definition.AddRetentionPolicy(BuildReason.Triggered, BuildStatus.Succeeded, succeeded, DeleteOptions.Details | DeleteOptions.DropLocation | DeleteOptions.Label | DeleteOptions.TestResults); definition.AddRetentionPolicy(BuildReason.Triggered, BuildStatus.PartiallySucceeded, partiallySucceeded, DeleteOptions.All); definition.AddRetentionPolicy(BuildReason.Triggered, BuildStatus.Failed, failed, DeleteOptions.All); definition.AddRetentionPolicy(BuildReason.Triggered, BuildStatus.Stopped, stopped, DeleteOptions.All); }
private IBuildDetail[] GetPreviousBuildsWithSameName(IBuildDefinition buildDefinition, string suggestedName) { IBuildDetailSpec buildDetailSpec = _buildServer.CreateBuildDetailSpec(buildDefinition); buildDetailSpec.QueryOptions = QueryOptions.None; buildDetailSpec.QueryOrder = BuildQueryOrder.FinishTimeDescending; buildDetailSpec.QueryDeletedOption = QueryDeletedOption.IncludeDeleted; buildDetailSpec.MaxBuildsPerDefinition = 100; buildDetailSpec.BuildNumber = string.Concat(suggestedName, "*"); IBuildQueryResult queryResult = _buildServer.QueryBuilds(buildDetailSpec); return queryResult.Builds; }
private BuildStoreEventSource CreateBuildStoreEventSource() { var eventSource = CreateBuildStoreEventSource(null, null); var firstProject = ProjectInfos[0]; DisabledBuildDefinition = MockBuildServer.QueryBuildDefinitions(firstProject.Name).First(); DisabledBuildDefinition.QueueStatus = DefinitionQueueStatus.Disabled; PausedBuildDefinition = MockBuildServer.QueryBuildDefinitions(firstProject.Name).First(); PausedBuildDefinition.QueueStatus = DefinitionQueueStatus.Paused; return eventSource; }
public string GetUniqueBuildNumber(IBuildDefinition buildDefinition, string suggestedName) { IBuildDetail[] previousBuilds = GetPreviousBuildsWithSameName(buildDefinition, suggestedName); if (previousBuilds == null || previousBuilds.Length == 0) { return suggestedName; } else { string newBuildNumber = string.Format("{0}-{1}", suggestedName, previousBuilds.Count()); return newBuildNumber; } }
private static void CopyRetentionPolicies(IBuildDefinition source, IBuildDefinition target) { target.RetentionPolicyList.Clear(); foreach (var policy in source.RetentionPolicyList) { target.AddRetentionPolicy( policy.BuildReason, policy.BuildStatus, policy.NumberToKeep, policy.DeleteOptions ); } }
private static ObservableCollection<WorkspaceItemViewModel> InitializeWorkSpaceItems(IBuildDefinition buildDefinition) { var workspaceMappings = new ObservableCollection<WorkspaceItemViewModel>(); foreach (var mapping in buildDefinition.Workspace.Mappings) { workspaceMappings.Add(new WorkspaceItemViewModel() { Status = (mapping.MappingType == WorkspaceMappingType.Map) ? "Active" : "Cloaked", SourceControlFolder = mapping.ServerItem, RemappedSourceControlFolder = mapping.ServerItem }); } return workspaceMappings; }
public bool TryCloneQueryDefinition(out IBuildDefinition buildDefinition, TfsTeamProjectCollection collection, Project project, IBuildDefinition definition) { try { buildDefinition = _teamPilgrimTfsService.CloneBuildDefinition(collection, project.Name, definition); return true; } catch (Exception ex) { this.Logger().DebugException(ex); LastException = ex; } buildDefinition = null; return false; }
private static FakeBuildDetail[] CreateFakeBuildDetails(int quantity, IBuildDefinition definition, string teamProjectName) { var details = new FakeBuildDetail[quantity]; for (var i = 0; i < quantity; i++) { var detail = new FakeBuildDetail { Uri = new Uri(string.Format("http://fake/{0}", Guid.NewGuid())), StartTime = DateTime.Now.AddHours(-i), BuildDefinition = definition, TeamProject = teamProjectName }; details[i] = detail; } return details; }
static void Copy(IBuildDefinition source, IBuildDefinition target) { target.BatchSize = source.BatchSize; target.BuildController = source.BuildController; target.ContinuousIntegrationType = source.ContinuousIntegrationType; target.ContinuousIntegrationQuietPeriod = source.ContinuousIntegrationQuietPeriod; target.DefaultDropLocation = source.DefaultDropLocation; target.Description = source.Description; target.Process = source.Process; target.ProcessParameters = source.ProcessParameters; target.QueueStatus = source.QueueStatus; target.TriggerType = source.TriggerType; CopySchedules(source, target); CopyMappings(source, target); CopyRetentionPolicies(source, target); }
/// <summary> /// Removes a specified server mapping from a build definition /// </summary> /// <param name="buildDefinition">Build definition to remove the mapping from.</param> /// <param name="serverItem">Server mapping to remove.</param> /// <remarks>The build definition is not saved after the mappings are cleared.</remarks> public static void RemoveServerMapping(IBuildDefinition buildDefinition, string serverItem) { // Validation ArgumentValidation.ValidateObjectIsNotNull(buildDefinition, "buildDefinition"); ArgumentValidation.ValidateStringIsNotEmpty(serverItem, "serverMapping"); var buildWorkspaceMappings = buildDefinition.Workspace.Mappings; foreach (var mapping in buildWorkspaceMappings) { if (mapping.ServerItem.Equals(serverItem, StringComparison.OrdinalIgnoreCase)) { buildWorkspaceMappings.Remove(mapping); break; } } }
private static bool ChangeDefinition(IBuildDefinition definition, Options options) { try { var buildType = GetBuildType(definition); //// for now, skip CDN build definitions if (buildType == CustomBuildType.Cdn) return false; if (!CheckTemplates(buildType)) return false; var messages = new StringBuilder(); var changed = SetTemplate(definition, buildType, messages) || SetDropLocation(definition, options, buildType, messages); var paramValues = WorkflowHelpers.DeserializeProcessParameters(definition.ProcessParameters); var config = GetConfiguration(definition, options, buildType); foreach (var c in config) { if (options.SkipParameters != null && options.SkipParameters.Contains(c.Key)) { if (options.Verbose) messages.AppendFormat("Skip parameter '{0}' ('{1}')\r\n", c.Key, Helpers.ObjectToString(c.Value)); } else { changed = changed | AddOrUpdate(paramValues, c.Key, c.Value, messages); } } if (!changed) return false; definition.ProcessParameters = WorkflowHelpers.SerializeProcessParameters(paramValues); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("Build definition '{0}' ({1}) has changes", definition.Name, buildType); Console.ResetColor(); Console.WriteLine(messages); return true; } catch (Exception ex) { Console.WriteLine(ex); return false; } }
private static TFS.Common.WorkflowConfig.AssociatedBuildDefinition ConvertToAssociatedBuildDefinition(IBuildDefinition res) { var abd = new LabWorkflowManager.TFS.Common.WorkflowConfig.AssociatedBuildDefinition(); abd.Name = res.Name; abd.BuildControllerName = res.BuildController != null ? res.BuildController.Name : string.Empty; abd.BuildControllerUri = res.BuildControllerUri != null ? res.BuildControllerUri.ToString() : string.Empty; abd.ContinuousIntegrationQuietPeriod = res.ContinuousIntegrationQuietPeriod; abd.ContinuousIntegrationType = (LabWorkflowManager.TFS.Common.WorkflowConfig.BuildDefinitionContinuousIntegrationType)res.ContinuousIntegrationType; abd.DateCreated = res.DateCreated; abd.Description = res.Description; abd.Id = res.Id; abd.LastBuildUri = res.LastBuildUri != null ? res.LastBuildUri.ToString() : string.Empty; abd.LastGoodBuildLabel = res.LastGoodBuildLabel; abd.LastGoodBuildUri = res.LastGoodBuildUri != null ? res.LastGoodBuildUri.ToString() : string.Empty; abd.Builds = res.QueryBuilds().Select(o => new LabWorkflowManager.TFS.Common.WorkflowConfig.AssociatedBuildDetail() { Uri = o.Uri.ToString(), LabelName = o.LabelName }).ToList(); abd.Uri = res.Uri.ToString(); return abd; }
public void ConnectToTfsServer(string hostname, string teamCollection, string projectName, string buildDefinitionName = null) { _hostname = hostname; _isWebServer = _hostname.Contains("://"); try { string url; if (_isWebServer) { _hostname = _hostname.TrimEnd('\\', '/'); url = _hostname + "/" + teamCollection; _urlPrefix = hostname + "/" + teamCollection + "/" + projectName + "/_build#buildUri="; } else { url = "http://" + _hostname + ":8080/tfs/" + teamCollection; _urlPrefix = "http://" + hostname + ":8080/tfs/Build/Build.aspx?artifactMoniker="; } _tfsCollection = new TfsTeamProjectCollection(new Uri(url), new TfsClientCredentials()); _buildServer = _tfsCollection.GetService<IBuildServer>(); var buildDefs = _buildServer.QueryBuildDefinitions(projectName); if (buildDefs.Length != 0) { _buildDefinition = string.IsNullOrWhiteSpace(buildDefinitionName) ? buildDefs[0] : buildDefs.FirstOrDefault(b => string.Compare(b.Name, buildDefinitionName, StringComparison.InvariantCultureIgnoreCase) == 0); } } catch (Exception ex) { Trace.WriteLine(ex.Message); } }
public void ConnectToTfsServer(string hostname, string teamCollection, string projectName, string buildDefinitionName = null) { _hostname = hostname; _isWebServer = _hostname.Contains("://"); try { string url; if (_isWebServer) { _hostname = _hostname.TrimEnd('\\', '/'); url = _hostname + "/" + teamCollection; _urlPrefix = hostname + "/" + teamCollection + "/" + projectName + "/_build#buildUri="; } else { url = "http://" + _hostname + ":8080/tfs/" + teamCollection; _urlPrefix = "http://" + hostname + ":8080/tfs/Build/Build.aspx?artifactMoniker="; } // Get a connection to the desired Team Foundation Server _tfServer = TeamFoundationServerFactory.GetServer(url, new UICredentialsProvider()); // Get a reference to a build service _buildServer = _tfServer.GetService<IBuildServer>(); // Retrieve a list of build definitions var buildDefs = _buildServer.QueryBuildDefinitions(projectName); if (buildDefs.Length != 0) { if (string.IsNullOrWhiteSpace(buildDefinitionName)) _buildDefinition = buildDefs[0]; else { foreach (var buildDefinition in buildDefs) { if (string.Compare(buildDefinition.Name, buildDefinitionName, true) == 0) { _buildDefinition = buildDefinition; return; } } } } } catch (Exception ex) { Trace.WriteLine(ex.Message); } }
private static void ExportDefinition(IBuildDefinition b, string filePath) { ExportedBuildDefinition buildToExport = new ExportedBuildDefinition { Name = b.Name, Description = b.Description }; if (b.BuildController != null) { buildToExport.BuildController = b.BuildController.Name; } buildToExport.ContinuousIntegrationType = b.ContinuousIntegrationType; buildToExport.DefaultDropLocation = b.DefaultDropLocation; buildToExport.Schedules = new List<ExportedISchedule>(); foreach (var schedule in b.Schedules) { buildToExport.Schedules.Add(new ExportedISchedule { StartTime = schedule.StartTime, DaysToBuild = schedule.DaysToBuild, TimeZone = schedule.TimeZone }); } buildToExport.SourceProviders = new List<ExportedIBuildDefinitionSourceProvider>(); foreach (var provider in b.SourceProviders) { buildToExport.SourceProviders.Add(new ExportedIBuildDefinitionSourceProvider { Fields = provider.Fields, Name = provider.Name, SupportedTriggerTypes = provider.SupportedTriggerTypes }); } buildToExport.QueueStatus = b.QueueStatus; buildToExport.ContinuousIntegrationQuietPeriod = b.ContinuousIntegrationQuietPeriod; if (b.SourceProviders.All(s => s.Name != "TFGIT")) { buildToExport.Mappings = new List<ExportedIWorkspaceMapping>(); foreach (var map in b.Workspace.Mappings) { buildToExport.Mappings.Add(new ExportedIWorkspaceMapping { Depth = map.Depth, LocalItem = map.LocalItem, MappingType = map.MappingType, ServerItem = map.ServerItem }); } } buildToExport.RetentionPolicyList = new List<ExportedIRetentionPolicy>(); foreach (var rp in b.RetentionPolicyList) { buildToExport.RetentionPolicyList.Add(new ExportedIRetentionPolicy { BuildDefinition = rp.BuildDefinition, BuildReason = rp.BuildReason, BuildStatus = rp.BuildStatus, NumberToKeep = rp.NumberToKeep, DeleteOptions = rp.DeleteOptions }); } if (b.Process != null) { buildToExport.ProcessTemplate = b.Process.ServerPath; } var processParameters = WorkflowHelpers.DeserializeProcessParameters(b.ProcessParameters); if (processParameters.ContainsKey("AgentSettings")) { if (processParameters["AgentSettings"].GetType() == typeof(AgentSettings)) { AgentSettings ags = (AgentSettings)processParameters["AgentSettings"]; AgentSettingsBuildParameter agentSet = new AgentSettingsBuildParameter(); agentSet.MaxExecutionTime = ags.MaxExecutionTime; agentSet.MaxWaitTime = ags.MaxWaitTime; agentSet.Name = ags.Name; agentSet.Comparison = ags.TagComparison; agentSet.Tags = ags.Tags; buildToExport.TfvcAgentSettings = agentSet; } else if (processParameters["AgentSettings"].GetType() == typeof(BuildParameter)) { BuildParameter ags = (BuildParameter)processParameters["AgentSettings"]; { buildToExport.GitAgentSettings = ags; } } } buildToExport.ProcessParameters = WorkflowHelpers.DeserializeProcessParameters(b.ProcessParameters); File.WriteAllText(Path.Combine(filePath, b.Name + ".json"), JsonConvert.SerializeObject(buildToExport, Formatting.Indented)); }
private void ConfigMainBuildDefinitionSettings(LabWorkflowManager.TFS.Common.WorkflowConfig.LabBuildDefinitionDetails buildDefinitionDetails, IBuildDefinition buildDefinition) { buildDefinition.Name = buildDefinitionDetails.Name; buildDefinition.Description = buildDefinitionDetails.Description; buildDefinition.ContinuousIntegrationType = (ContinuousIntegrationType)buildDefinitionDetails.ContinuousIntegrationType; if (buildDefinition.ContinuousIntegrationType == ContinuousIntegrationType.Schedule || buildDefinition.ContinuousIntegrationType == ContinuousIntegrationType.ScheduleForced) { var schedule = buildDefinition.AddSchedule(); schedule.DaysToBuild = (ScheduleDays)buildDefinitionDetails.ScheduledDays; schedule.StartTime = buildDefinitionDetails.StartTime; } else if (buildDefinition.ContinuousIntegrationType == ContinuousIntegrationType.Batch) { buildDefinition.ContinuousIntegrationQuietPeriod = buildDefinitionDetails.QuietPeriod; } buildDefinition.BuildController = this.BuildServer.GetBuildController(string.Format("*{0}*", buildDefinitionDetails.ControllerName)); var buildDefinitionProcessTemplate = this.BuildServer.QueryProcessTemplates(this.connectivity.TeamProjects.First().Name).Where(t => t.ServerPath.Contains(buildDefinitionDetails.ProcessTemplateFilename)).First(); buildDefinition.Process = buildDefinitionProcessTemplate; }
public void CopyFrom(IBuildDefinition buildDefinition) { throw new NotImplementedException(); }
/// <summary> /// Adds a new workspace mapping to an existing build definition /// </summary> /// <param name="buildDefinition">Build definition for the new mapping</param> /// <param name="localItem">Local path for the mapping</param> /// <param name="serverItem">Server path for the mapping</param> /// <returns>The created workspace mapping</returns> /// <remarks>The build definition is not saved after the mapping is added.</remarks> public static IWorkspaceMapping AddWorkspaceMapping(IBuildDefinition buildDefinition, string localItem, string serverItem) { return AddWorkspaceMapping(buildDefinition, localItem, serverItem, WorkspaceMappingType.Map, WorkspaceMappingDepth.Full); }
private bool ShouldDefinitionBeIncluded(IBuildDefinition definition) { var isExcludedByRegex = false; if (buildDefinitionNameExclusionRegex != null) { isExcludedByRegex = buildDefinitionNameExclusionRegex.IsMatch(definition.Name); } return (definition.QueueStatus == DefinitionQueueStatus.Enabled) && !isExcludedByRegex; }
public void Dispose() { _buildServer = null; if (_tfServer != null) _tfServer.Dispose(); _buildDefinition = null; GC.Collect(); }