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); }