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 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);
}
/// <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]);
}
}
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();
}
