public ReleaseEnvironment UpdateReleaseEnvironment(int releaseId, int targetEnvId, string accessToken)
{
if (releaseId < 0)
{
throw new ArgumentException("id cannot be less than 0", nameof(releaseId));
}
if (targetEnvId < 0)
{
throw new ArgumentException("id cannot be less than 0", nameof(targetEnvId));
}
if (string.IsNullOrWhiteSpace(accessToken))
{
throw new ArgumentException("parameter cannot be null or whitespace", nameof(accessToken));
}
this.logger.LogDebug($"updating release environment. release id:[{releaseId}], target environment id:[{targetEnvId}]");
ReleaseHttpClient client = this.GetClient <ReleaseHttpClient>(accessToken);
ReleaseEnvironmentUpdateMetadata environmentMetadata = new ReleaseEnvironmentUpdateMetadata()
{
Status = EnvironmentStatus.InProgress,
Comment = DeployMessage
};
return(client.UpdateReleaseEnvironmentAsync(
environmentMetadata,
this.vstsConfig.ProjectName,
releaseId,
targetEnvId).Result);
}
static ReleaseEnvironment DeployAnEnvironment(ReleaseHttpClient rmClient, int releaseId, int environmentIdToDeploy)
{
ReleaseEnvironmentUpdateMetadata envMetaData = new ReleaseEnvironmentUpdateMetadata();
envMetaData.Status = EnvironmentStatus.InProgress;
envMetaData.Comment = "Good to go";
return(rmClient.UpdateReleaseEnvironmentAsync(envMetaData, projectName, releaseId, environmentIdToDeploy).Result);
}
public static void CancelAllInProgressReleases(ReleaseHttpClient2 rmClient)
{
var maxModifiedTime = DateTime.Now.AddDays(-numberOfDaysBefore);
var minModifiedTime = DateTime.Now.AddDays(-numberOfDaysAfter);
try
{
int ctn = 0;
IPagedCollection <Release> releases = null;
do
{
releases = rmClient.GetReleasesAsync2(
definitionId: definitionId,
statusFilter: ReleaseStatus.Active,
minCreatedTime: minModifiedTime,
maxCreatedTime: maxModifiedTime,
top: 100,
continuationToken: ctn,
expand: ReleaseExpands.Environments).Result;
ReleaseEnvironmentUpdateMetadata envMetaData = new ReleaseEnvironmentUpdateMetadata();
envMetaData.Status = EnvironmentStatus.Canceled;
envMetaData.Comment = "Good to cancel as it's pretty old";
foreach (var release in releases)
{
foreach (var environment in release.Environments)
{
if (environment.Status == EnvironmentStatus.Queued || environment.Status == EnvironmentStatus.InProgress)
{
try
{
totalDeploymentToCancel++;
Console.WriteLine("Cancelling the environment with releaseId: {0} ReleaseEnvironmentId: {1} ", release.Id, environment.Id);
var result = rmClient.UpdateReleaseEnvironmentAsync(envMetaData, projectName, release.Id, environment.Id).Result;
// rmClient.DeleteReleaseAsync(projectName, release.Id).SyncResult();
}
catch (Exception ex)
{
Console.WriteLine("=======================");
Console.WriteLine("Not Cancelling the deployment with releaseId: {0} ReleaseEnvironmentId: {1} ", release.Id, environment.Id);
Console.WriteLine(ex.Message);
Console.WriteLine("=======================");
}
}
}
}
int.TryParse(releases.ContinuationToken, out ctn);
} while (releases.ContinuationToken != null);
Console.WriteLine("Total cancelled environments: {0}", totalDeploymentToCancel);
}
catch (Exception ex)
{
Console.WriteLine("Could not get releases with given information");
}
}
public async Task StartEnvironmentDeployment(VstsRelease vstsRelease, int releaseEnvironmentId)
{
ReleaseHttpClient releaseClient = _vssConnection.GetClient <ReleaseHttpClient>();
ReleaseEnvironmentUpdateMetadata releaseEnvironmentUpdateMetadata = new ReleaseEnvironmentUpdateMetadata()
{
Status = EnvironmentStatus.InProgress
};
await releaseClient.UpdateReleaseEnvironmentAsync(releaseEnvironmentUpdateMetadata, _configuration.Value.ProjectName, vstsRelease.Id, releaseEnvironmentId);
}
public async Task <bool> Handle(DeployReleaseQuery message, CancellationToken cancellationToken)
{
var connection = _tfsProvider.GetConnection() as VssConnection;
var releaseServer = connection.GetClient <ReleaseHttpClient>(); // connect to the build server subpart
var release = await releaseServer.GetReleaseAsync(project : message.ProjectId, releaseId : message.ReleaseIdentifier);
var releaseEnvironmentUpdateMetadata = new ReleaseEnvironmentUpdateMetadata()
{
Status = EnvironmentStatus.InProgress
};
int releaseEnvironmentId = release.Environments.First(e => e.DefinitionEnvironmentId == message.EnvironmentIdentifier).Id; // message.EnvironmentIdentifier;
// Start deployment to an environment
var releaseEnvironment = releaseServer.UpdateReleaseEnvironmentAsync(releaseEnvironmentUpdateMetadata, message.ProjectId, message.ReleaseIdentifier,
releaseEnvironmentId).Result;
return(true);
}
static void CancelAllInProgressDeployments(ReleaseHttpClient rmClient)
{
try
{
var allInProgressEnvironments = rmClient.GetDeploymentsAsync(
projectName,
deploymentStatus: DeploymentStatus.InProgress).Result;
foreach (var inProgressEnvironment in allInProgressEnvironments)
{
ReleaseEnvironmentUpdateMetadata envMetaData = new ReleaseEnvironmentUpdateMetadata();
envMetaData.Status = EnvironmentStatus.Canceled;
envMetaData.Comment = "Good to cancel";
var cancelledEnvironment = rmClient.UpdateReleaseEnvironmentAsync(
envMetaData,
projectName,
inProgressEnvironment.Release.Id,
inProgressEnvironment.ReleaseEnvironment.Id).Result;
}
}
catch (Exception)
{ }
}
public WebApiRelease StartDeployment()
{
string projectName = ClientSampleHelpers.FindAnyProject(this.Context).Name;
// Get a release client instance
VssConnection connection = Context.Connection;
ReleaseHttpClient releaseClient = connection.GetClient <ReleaseHttpClient>();
WebApiRelease release = CreateRelease(releaseClient, newlyCreatedReleaseDefinitionId, projectName);
ReleaseEnvironmentUpdateMetadata releaseEnvironmentUpdateMetadata = new ReleaseEnvironmentUpdateMetadata()
{
Status = EnvironmentStatus.InProgress
};
int releaseEnvironmentId = release.Environments.FirstOrDefault().Id;
// Start deployment to an environment
ReleaseEnvironment releaseEnvironment = releaseClient.UpdateReleaseEnvironmentAsync(releaseEnvironmentUpdateMetadata, projectName, release.Id, releaseEnvironmentId).Result;
Console.WriteLine("{0} {1}", releaseEnvironment.Id.ToString().PadLeft(6), releaseEnvironment.Name);
return(release);
}
