public void CreateEnvironment(string project, string release, Guid environmentId, JObject jsonVariables)
{
ReleaseDefinition releaseDefinition = GetRelease(project, release);
ReleaseDefinitionEnvironmentTemplate environmentTemplate = GetEnvironmentTemplate(project, environmentId);
ReleaseDefinitionEnvironment environment = environmentTemplate.Environment;
int maxRank = releaseDefinition.Environments.Max(x => x.Rank);
environment.Rank = maxRank + 1;
environment.Name = Guid.NewGuid().ToString();
List <string> variables = environment.Variables.Keys.ToList();
foreach (var variable in variables)
{
environment.Variables[variable] = new ConfigurationVariableValue()
{
Value = ""
};
}
if (jsonVariables != null)
{
foreach (var variable in jsonVariables)
{
environment.Variables[variable.Key] = new ConfigurationVariableValue()
{
Value = variable.Value.ToString()
};
}
}
releaseDefinition.Environments.Add(environment);
Task <ReleaseDefinition> result = releaseClient.UpdateReleaseDefinitionAsync(releaseDefinition, project);
ReleaseDefinition update = result.Result;
}
private void UpdateTaskGroupId(ReleaseDefinition definitionToBeMigrated, IEnumerable <Mapping> TaskGroupMapping)
{
if (TaskGroupMapping is null)
{
return;
}
foreach (var environment in definitionToBeMigrated.Environments)
{
foreach (var deployPhase in environment.DeployPhases)
{
foreach (var WorkflowTask in deployPhase.WorkflowTasks)
{
if (WorkflowTask.DefinitionType != null && WorkflowTask.DefinitionType.ToLower() != "metaTask".ToLower())
{
continue;
}
var mapping = TaskGroupMapping.FirstOrDefault(d => d.SourceId == WorkflowTask.TaskId.ToString());
if (mapping == null)
{
Log.LogWarning("Can't find taskgroup {TaskGroupName} in the target collection.", WorkflowTask.Name);
}
else
{
WorkflowTask.TaskId = Guid.Parse(mapping.TargetId);
}
}
}
}
}
private string DoGetReleaseId(
string serviceName, string version, string branch, string prereqEnv)
{
ReleaseDefinition releaseDefintion =
this.releaseClient.GetReleaseDefinitions(serviceName, this.accessToken)
.FirstOrDefault();
if (releaseDefintion == null)
{
return(null);
}
int?defintionEnvId = GetDefintionEnvId(prereqEnv, releaseDefintion);
int?versionBuildId =
this.GetVersionBuildId(version, branch, releaseDefintion);
IEnumerable <Release> releases = this.releaseClient
.GetReleases(releaseDefintion.Id, this.accessToken, versionBuildId, defintionEnvId);
if (!releases.Any())
{
return(null);
}
return(releases.First().Id.ToString());
}
internal static void ResetData()
{
releaseDefinition = null;
ifRefresh = true;
approvalsList = null;
releasesList = null;
}
private void ShowReleases()
{
if (releasesList == null || releasesList.Count < 1 || ifRefresh)
{
ShowProgressBar();
Task.Factory.StartNew(() =>
{
if (releaseDefinition != null && releaseDefinition.Artifacts != null)
{
releaseDefinition = VSTSService.GetAReleaseDefinition(releaseDefinition.Id);
}
releasesList = VSTSService.GetReleases(releaseDefinition);
}).ContinueWith(async(Task t) =>
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
releasesLV.ItemsSource = releasesList;
HideProgressBar();
});
});
}
else
{
releasesLV.ItemsSource = releasesList;
HideProgressBar();
}
}
private void UpdateRepositoryId(ReleaseDefinition definitionToBeMigrated, IEnumerable <Mapping> gitRepoMapping)
{
if (gitRepoMapping is null)
{
return;
}
if (definitionToBeMigrated.Artifacts != null)
{
foreach (var artifact in definitionToBeMigrated.Artifacts)
{
if (artifact.Type.Equals("Git", StringComparison.CurrentCultureIgnoreCase) &&
artifact.DefinitionReference != null &&
artifact.DefinitionReference.Definition != null)
{
var mapping = gitRepoMapping.FirstOrDefault(d => d.SourceId == artifact.DefinitionReference.Definition.Id.ToString());
if (mapping == null)
{
Log.LogWarning("Can't find definition ID {Id} in the target collection.", artifact.DefinitionReference.Definition.Id);
}
else
{
if (artifact.DefinitionReference.Project != null)
{
artifact.DefinitionReference.Project.Id = Target.ProjectGuid;
artifact.DefinitionReference.Project.Name = Target.Options.Project;
}
artifact.DefinitionReference.Definition.Id = mapping.TargetId;
artifact.SourceId = string.Format("{0}:{1}", Target.ProjectGuid, mapping.TargetId);
}
}
}
}
}
static void RunOptions(Options opts)
{
VssCredentials creds = new VssBasicCredential(string.Empty, personalAccessToken);
// Connect to Azure DevOps Services
VssConnection connection = new VssConnection(new Uri(collectionUri), creds);
// Get a Release EndPoint
ReleaseHttpClient releaseHttpClient = connection.GetClient <ReleaseHttpClient>();
// Get data about a specific repository
ReleaseDefinition definition = releaseHttpClient.GetReleaseDefinitionAsync(opts.ProjectName, opts.ReleaseId).Result;
List <ReleaseDefinitionEnvironment> environments = definition.Environments as List <ReleaseDefinitionEnvironment>;
environments.Sort();
foreach (var env in environments)
{
Console.WriteLine();
Console.WriteLine($"## {env.Name}");
Console.WriteLine();
foreach (var variable in env.Variables)
{
Console.WriteLine($"{variable.Key}#{variable.Value.Value}");
}
}
}
public async Task FlowTest()
{
using (var scope = _containerFixture.Container.BeginLifetimeScope())
{
var sut = scope.Resolve <ReleaseHttpClient2>();
var vstsConfig = scope.Resolve <VstsConfiguration>();
ReleaseDefinition rd = null;
try
{
var template = await sut.GetReleaseDefinitionAsync(vstsConfig.VstsTargetProjectId,
vstsConfig.WebApiReleaseDefinitionTemplate.DefinitionId);
template.Name = Guid.NewGuid().ToString();
rd = await sut.CreateOrResetDefinition(template, vstsConfig.VstsTargetProjectId);
//asserts
var rds = await sut.GetReleaseDefinitionsAsync(vstsConfig.VstsTargetProjectId, template.Name);
rds.Should().ContainSingle();
}
finally
{
if (rd != null)
{
await sut.DeleteReleaseDefinitionIfFExists(vstsConfig.VstsTargetProjectId, rd.Name);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ReleaseDefinitionCard"/> class.
/// </summary>
/// <param name="releaseDefinition">A release definition.</param>
public ReleaseDefinitionCard(ReleaseDefinition releaseDefinition)
{
releaseDefinition.ThrowIfNull(nameof(releaseDefinition));
this.Title = releaseDefinition.Name;
this.Buttons.Add(new CardAction(ActionTypes.ImBack, Labels.Create, value: FormattableString.Invariant($"create {releaseDefinition.Id}")));
}
static Release CreateRelease(ReleaseHttpClient rmClient, ReleaseDefinition releaseDefinition)
{
ReleaseStartMetadata rmMetaData = new ReleaseStartMetadata();
rmMetaData.DefinitionId = releaseDefinition.Id;
return(rmClient.CreateReleaseAsync(rmMetaData, project: projectName).Result);
}
public IEnumerable <EventRuleElement> GetRulesMatch(string collection, IEnumerable <EventRuleElement> eventRules)
{
var rules = eventRules.Where(r => r.Events.HasFlag(TfsEvents.ReleaseCreated) &&
collection.IsMatchOrNoPattern(r.TeamProjectCollection) &&
ProjectName.IsMatchOrNoPattern(r.TeamProject) &&
TeamNames.IsMatchOrNoPattern(r.TeamName) &&
ReleaseDefinition.IsMatchOrNoPattern(r.ReleaseDefinition));
return(rules);
}
private ReleaseSummary Map(ReleaseDefinition toMap)
{
return(new ReleaseSummary
{
ReleaseDefinition = new NavigableItem {
Name = toMap.Name, Url = toMap.Url
},
LastProductionRelease = Map(toMap.LastProductionRelease),
DeployedAt = toMap.LastProductionRelease?.DeployedAt
});
}
private ReleaseDefinition GetReleaseDefinitionByName(string value)
{
ReleaseDefinition releaseDefinition = this.DevOpsClient
.ReleaseDefinition
.GetAllAsync(this.ProjectName)
.GetAwaiter()
.GetResult()
.FirstOrDefault(rd => rd.Name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0);
return(releaseDefinition);
}
public void Constructor()
{
var releaseDefinition = new ReleaseDefinition {
Id = 1, Name = "Release 1"
};
var target = new ReleaseDefinitionCard(releaseDefinition);
target.Title.Should().Be(releaseDefinition.Name);
target.Buttons.First().Value.Should().Be("create 1");
}
private static int?GetDefintionEnvId(string prereqEnv, ReleaseDefinition releaseDefintion)
{
int?defintionEnvId = null;
if (prereqEnv != null)
{
defintionEnvId = releaseDefintion.Environments?.FirstOrDefault(
e => e.Name.Equals(prereqEnv, StringComparison.InvariantCultureIgnoreCase))?
.Id;
}
return(defintionEnvId);
}
private ReleaseDefinition GetRelease(string project, string name)
{
List <ReleaseDefinition> releaseDefinitions = releaseClient.GetReleaseDefinitionsAsync(project, name).Result;
if (releaseDefinitions is null || releaseDefinitions.Count != 1)
{
throw new Exception($"Several release definitions match the name {name}");
}
int releaseId = releaseDefinitions[0].Id;
ReleaseDefinition releaseDefinition = releaseClient.GetReleaseDefinitionAsync(project, releaseId).Result;
return(releaseDefinition);
}
private IEnumerable <Build> GetVersionBuilds(
ReleaseDefinition releaseDefintion,
string version,
string branch)
{
Artifact primaryArtifact = releaseDefintion.Artifacts
.First(a => a.IsPrimary == true);
int artifactBuildDefinitionId =
Convert.ToInt32(primaryArtifact.DefinitionReference["definition"].Id);
return(this.releaseClient
.GetBuilds(artifactBuildDefinitionId, this.accessToken, version, branch));
}
/// <summary>
/// create or reset - delete & create definition
/// </summary>
/// <param name="client">extension method entry-point</param>
/// <param name="definition">definition to process</param>
/// <param name="targetProject">target vsts project id</param>
/// <returns>vsts release definition model</returns>
public static async Task <ReleaseDefinition> CreateOrResetDefinition(this ReleaseHttpClient2 client,
ReleaseDefinition definition, string targetProject)
{
var vstsDef =
(await client.GetReleaseDefinitionsAsync(targetProject, definition.Name, isExactNameMatch: true))
.FirstOrDefault();
if (vstsDef != null)
{
return(await client.UpdateReleaseDefinitionAsync(definition, targetProject));
}
//create new
return(await client.CreateReleaseDefinitionAsync(definition, targetProject));
}
public async Task <Release> CreateReleaseAsync(ReleaseDefinition releaseDefinition, Build build)
{
var clientCredentials = new VssBasicCredential(string.Empty, _connectInfo.PAT);
var connection = new VssConnection(_connectInfo.ServerUrl, clientCredentials);
var releaseServer = connection.GetClient <ReleaseHttpClient>(); // connect to the build server subpart
var releaseStartMetaData = new ReleaseStartMetadata()
{
DefinitionId = releaseDefinition.Id,
IsDraft = false,
};
return(await releaseServer.CreateReleaseAsync(releaseStartMetaData, project : _connectInfo.ProjectId));
}
public ReleaseDefinition GetReleaseDefinition()
{
string projectName = ClientSampleHelpers.FindAnyProject(this.Context).Name;
// Get a release client instance
VssConnection connection = Context.Connection;
ReleaseHttpClient releaseClient = connection.GetClient <ReleaseHttpClient>();
// Show a release definitions
ReleaseDefinition releaseDefinition = releaseClient.GetReleaseDefinitionAsync(project: projectName, definitionId: newlyCreatedReleaseDefinitionId).Result;
Console.WriteLine("{0} {1}", releaseDefinition.Id.ToString().PadLeft(6), releaseDefinition.Name);
return(releaseDefinition);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
Utility.SetStatusBarColor("#6A1B9A", "#ffffff", 1);
ReleaseDefinition rdReceived = e.Parameter as ReleaseDefinition;
defTB.Text = rdReceived.Name;
if (releaseDefinition == null || rdReceived.Id != releaseDefinition.Id)
{
ifRefresh = true;
releaseDefinition = rdReceived;
}
GetAndSetPItems();
}
private void UpdateQueueIdOnPhases(ReleaseDefinition definitionToBeMigrated, IEnumerable <Mapping> agentPoolMappings, IEnumerable <Mapping> deploymentGroupMappings)
{
foreach (var environment in definitionToBeMigrated.Environments)
{
foreach (var phase in environment.DeployPhases)
{
if (phase.PhaseType == "agentBasedDeployment")
{
UpdateQueueIdForPhase(phase, agentPoolMappings);
}
else if (phase.PhaseType == "machineGroupBasedDeployment")
{
UpdateQueueIdForPhase(phase, deploymentGroupMappings);
}
}
}
}
private void GetRDDetailsAndSetUI(string releaseDefinitionId)
{
ShowProgressBar();
Task.Factory.StartNew(() =>
{
releaseDefinition = VSTSService.GetAReleaseDefinition(releaseDefinitionId);
}).ContinueWith((async(Task t) =>
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
definitionTB.Text = releaseDefinition.Name;
GetArtifactsVersions();
HideProgressBar();
});
}));
}
private int?GetVersionBuildId(
string version,
string branch,
ReleaseDefinition releaseDefintion)
{
int?versionBuildId = null;
if (version != null || branch != null)
{
IEnumerable <Build> versionBuilds =
this.GetVersionBuilds(releaseDefintion, version, branch);
versionBuildId = versionBuilds.FirstOrDefault()?.Id;
}
return(versionBuildId);
}
public YamlPipelineGenerator(
BuildDefinition build,
ReleaseDefinition release,
Dictionary <Guid, Dictionary <int, TaskObj> > taskMap,
Dictionary <TaskGroupVersion, TaskGroup> taskGroupMap,
ConcurrentDictionary <TaskGroupVersion, Template> taskGroupTemplateMap,
Dictionary <int, Microsoft.TeamFoundation.DistributedTask.WebApi.VariableGroup> variableGroupMap,
bool inlineTaskGroups
)
{
_build = build;
_release = release;
_taskMap = taskMap;
_taskGroupMap = taskGroupMap;
_taskGroupTemplateMap = taskGroupTemplateMap;
_variableGroupMap = variableGroupMap;
_inlineTaskGroups = inlineTaskGroups;
}
private void ShowRDDetails()
{
ShowProgressBar();
detailsSP.Visibility = Visibility.Collapsed;
Task.Factory.StartNew(() =>
{
if (releaseDefinition == null || releaseDefinition.Artifacts == null)
{
releaseDefinition = VSTSService.GetAReleaseDefinition(releaseDefinition.Id);
}
}).ContinueWith(async(Task t) =>
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
detailsPI.DataContext = releaseDefinition;
HideProgressBar();
detailsSP.Visibility = Visibility.Visible;
});
});
}
public static void WithReleaseDefinition(this TestCompositionRoot root,
string name,
string repositoryName = null,
string buildName = null,
string url = "https://dev.azure.com/release/{0}",
string id = null,
string organization = "jrolstad",
string project = "the-project")
{
var item = new ReleaseDefinition
{
name = name,
id = id ?? Base64Encode(name),
RepositoryId = id ?? Base64Encode(repositoryName),
BuildId = Base64Encode(buildName),
_links = WithLinks(string.Format(url, name))
};
WithItem(organization, project, root.Context.ReleaseDefinitions, item);
}
private ReleaseDefinition CreateReleaseDefinition(Models.Releases.ReleaseDefinition releaseDefinition)
{
var dto = new ReleaseDefinition
{
Name = releaseDefinition.name,
Id = releaseDefinition.id
};
if (releaseDefinition.artifacts != null)
{
var artifact = releaseDefinition.artifacts.FirstOrDefault(x => x.isPrimary);
if (artifact != null && artifact.definitionReference != null && artifact.definitionReference.project != null)
{
var projectId = artifact.definitionReference.project;
dto.Project = projectRepository.GetProject(projectId.id);
}
}
return(dto);
}
private void CustomizeRingPipeline(VstsReleaseDefinition model, ReleaseDefinition pipeline)
{
var variableName = GetTenantSizePipelineVariableName(model.TenantSize);
if (!pipeline.Variables.ContainsKey(variableName))
{
throw new Exception($"Ring template #{pipeline.Id} does not contain expected variable {variableName}");
}
var tenantSubString = GetTenantPipelineVariableDefinition(model.TenantCode, 11111); //TODO: link to port management
var varValue = pipeline.Variables[variableName].Value;
if (!varValue.Contains(tenantSubString))
{
//append definition for this tenant
if (varValue.Length != 0)
{
varValue += TenantPipelineVariableSeparator;
}
varValue += tenantSubString;
}
pipeline.Variables[variableName].Value = varValue;
//also re-point all stages to correct artifact
foreach (var e in pipeline.Environments)
{
foreach (var p in e.DeployPhases)
{
var envInput = (AgentDeploymentInput)p.GetDeploymentInput();
var downloadInput = envInput.ArtifactsDownloadInput.DownloadInputs.FirstOrDefault();
if (downloadInput == null)
{
throw new Exception($"Ring template #{pipeline.Id}, environment {e.Name} does not have expected download input");
}
downloadInput.Alias = model.BuildDefinition.ToString();
}
}
}
private bool DoesReleaseDefinitionContainsTask(ReleaseDefinition definition, IList <Guid> taskIds)
{
var deployPhases = definition
.Environments
.SelectMany(environment => environment.DeployPhases)
.SelectMany(deployPhase => deployPhase.WorkflowTasks);
foreach (var taskId in taskIds)
{
var task = deployPhases
.Where(t => t?.TaskId == taskId)
.FirstOrDefault();
if (task != null)
{
return(true);
}
}
return(false);
}
