private static void LogDeploymentInfo(ICommandOutputProvider outputProvider, DeploymentResource deploymentItem, ReleaseResource release, ChannelResource channel,
IDictionary <string, string> environmentsById, IDictionary <string, string> projectsById, IDictionary <string, string> tenantsById)
{
var nameOfDeploymentEnvironment = environmentsById[deploymentItem.EnvironmentId];
var nameOfDeploymentProject = projectsById[deploymentItem.ProjectId];
outputProvider.Information(" - Project: {Project:l}", nameOfDeploymentProject);
outputProvider.Information(" - Environment: {Environment:l}", nameOfDeploymentEnvironment);
if (!string.IsNullOrEmpty(deploymentItem.TenantId))
{
var nameOfDeploymentTenant = tenantsById[deploymentItem.TenantId];
outputProvider.Information(" - Tenant: {Tenant:l}", nameOfDeploymentTenant);
}
if (channel != null)
{
outputProvider.Information(" - Channel: {Channel:l}", channel.Name);
}
outputProvider.Information("\tCreated: {$Date:l}", deploymentItem.Created);
// Date will have to be fetched from Tasks (they need to be loaded) it doesn't come down with the DeploymentResource
//log.Information(" Date: {$Date:l}", deploymentItem.QueueTime);
outputProvider.Information("\tVersion: {Version:l}", release.Version);
outputProvider.Information("\tAssembled: {$Assembled:l}", release.Assembled);
outputProvider.Information("\tPackage Versions: {PackageVersion:l}", GetPackageVersionsAsString(release.SelectedPackages));
outputProvider.Information("\tRelease Notes: {ReleaseNotes:l}", GetReleaseNotes(release));
outputProvider.Information(string.Empty);
}
public void SetUp()
{
deployReleaseCommand = new DeployReleaseCommand(RepositoryFactory, Log, FileSystem);
var project = new ProjectResource();
var release = new ReleaseResource {
Version = "1.0.0"
};
var releases = new ResourceCollection <ReleaseResource>(new[] { release }, new LinkCollection());
var deploymentPromotionTarget = new DeploymentPromotionTarget {
Name = "TestEnvironment"
};
var promotionTargets = new List <DeploymentPromotionTarget> {
deploymentPromotionTarget
};
var deploymentTemplate = new DeploymentTemplateResource {
PromoteTo = promotionTargets
};
var deploymentPreviewResource = new DeploymentPreviewResource {
StepsToExecute = new List <DeploymentTemplateStep>()
};
var deployment = new DeploymentResource {
TaskId = "1"
};
taskResource = new TaskResource();
Repository.Projects.FindByName(ProjectName).Returns(project);
Repository.Projects.GetReleases(project).Returns(releases);
Repository.Releases.GetPreview(deploymentPromotionTarget).Returns(deploymentPreviewResource);
Repository.Releases.GetTemplate(release).Returns(deploymentTemplate);
Repository.Deployments.Create(Arg.Any <DeploymentResource>()).Returns(deployment);
Repository.Tasks.Get(deployment.TaskId).Returns(taskResource);
}
public string ReleaseTheCracken(string projectId, string releaseId, string environmentId)
{
try
{
var deploymentResource = new DeploymentResource
{
ProjectId = projectId,
EnvironmentId = environmentId,
ReleaseId = releaseId
};
var deployment = _repository.Deployments.Create(deploymentResource);
_cahManager.Remove($"{CacheKeys.LatestDeploysFromProject}_{projectId}");
return(deployment.TaskId);
}
catch (Exception e)
{
_log.Error(
$"The release of the Cracken failed. ProjectId: {projectId}, ReleaseId: {releaseId}, environmentId: {environmentId}", e);
}
return(null);
}
private void when_create_a_task()
{
before = () =>
{
_snapshotStep = new SnapshotStep();
_expectedTaskResource = new TaskResource {
Id = "Task01"
};
var deploymentResource = new DeploymentResource {
TaskId = _expectedTaskResource.Id
};
A.CallTo(() => _deployments.Create(A <DeploymentResource> ._)).Returns(deploymentResource);
A.CallTo(() => _tasks.Get(A <string> ._)).Returns(_expectedTaskResource);
};
act = () => { _actualTaskResource = _factory.Create(_snapshotStep, "Environment01"); };
it["should return a task"] = () => { _actualTaskResource.should_be(_expectedTaskResource); };
it["should create a deployment"] = () =>
{
A.CallTo(() => _deployments.Create(A <DeploymentResource> .That.Matches(x =>
x.ReleaseId == _snapshotStep.ReleaseId &&
x.ProjectId == _snapshotStep.ProjectId &&
x.EnvironmentId == "Environment01"
))).MustHaveHappened();
};
}
public void LogDeploymentInfo(DeploymentResource deployment, Dictionary <string, string> environmentsById)
{
var nameOfDeploymentEnvironment = environmentsById[deployment.EnvironmentId];
var taskId = deployment.Link("Task");
var task = Repository.Tasks.Get(taskId);
var release = Repository.Releases.Get(deployment.Link("Release"));
var propertiesToLog = new List <string>();
propertiesToLog.AddRange(FormatTaskPropertiesAsStrings(task));
propertiesToLog.AddRange(FormatReleasePropertiesAsStrings(release));
Log.InfoFormat(" - Environment: {0}", nameOfDeploymentEnvironment);
foreach (var property in propertiesToLog)
{
if (property == "State: Failed")
{
Log.ErrorFormat(" {0}", property);
}
else
{
Log.InfoFormat(" {0}", property);
}
}
Log.InfoFormat("");
}
async Task <OctopusJiraPayloadData> PrepareOctopusJiraPayload(string eventType,
string serverUri,
DeploymentResource deployment,
IJiraApiDeployment jiraApiDeployment,
CancellationToken cancellationToken,
EnvironmentResource deploymentEnvironment,
DeploymentEnvironmentSettingsMetadataProvider.JiraDeploymentEnvironmentSettings
environmentSettings)
{
var project = (await mediator.Request(new GetProjectRequest(deployment.ProjectId), cancellationToken)).Project;
var release = (await mediator.Request(new GetReleaseRequest(deployment.ReleaseId), cancellationToken)).Release;
var serverTask = (await mediator.Request(new GetServerTaskRequest(deployment.TaskId), cancellationToken)).Task;
TenantResource?tenant = null;
if (deployment.TenantId?.Value is not null)
{
tenant = (await mediator.Request(new GetTenantByIdOrNameRequest(deployment.TenantId.Value.ToTenantIdOrName()), cancellationToken)).Resource;
}
return(new OctopusJiraPayloadData
{
InstallationId = installationIdProvider.GetInstallationId().ToString(),
BaseHostUrl = store.GetBaseUrl() ?? string.Empty,
DeploymentsInfo = new JiraPayloadData
{
Deployments = new[]
private static void DeployRelease(ProjectResource project, Release release)
{
foreach (var deployment in release.Deployments)
{
var deploymentResource = new DeploymentResource()
{
DeploymentProcessId = project.DeploymentProcessId,
EnvironmentId = GetEnvironmentId(deployment.EnvironmentName),
ReleaseId = release.ReleaseResource.Id,
ChannelId = release.ReleaseResource.ChannelId,
ProjectId = release.ReleaseResource.ProjectId,
};
Log.Logger.Information($"Deploying [{project.Name}]->[{release.ReleaseResource.Version}]->[{deployment.EnvironmentName}]");
var dp = _repository.Deployments.Create(deploymentResource).Result;
TaskResource task;
do
{
task = _repository.Tasks.Get(dp.TaskId).Result;
} while (task.IsCompleted != true);
SetDeploymentTaskState(task, deployment.DeploymentState);
}
}
public async Task <Deployment> CreateDeploymentTask(ProjectDeployment project, string environmentId, string releaseId)
{
var user = await client.Repository.Users.GetCurrent();
var deployment = new DeploymentResource
{
ChannelId = project.ChannelId,
Comments = "Initiated by OctoPlus",
Created = DateTimeOffset.UtcNow,
EnvironmentId = environmentId,
LastModifiedBy = user.Username,
LastModifiedOn = DateTimeOffset.UtcNow,
Name = project.ProjectName + ":" + project.Packages?.First().PackageName,
ProjectId = project.ProjectId,
ReleaseId = releaseId,
};
if (project.RequiredVariables != null)
{
foreach (var variable in project.RequiredVariables)
{
deployment.FormValues.Add(variable.Id, variable.Value);
}
}
var deployResult = await client.Repository.Deployments.Create(deployment);
return(new Deployment {
TaskId = deployResult.TaskId
});
}
/// <summary>
/// Gathers the Deployment From the Task Passed
/// </summary>
/// <param name="octRepository">The repository to call against.</param>
/// <param name="task">Task to gather deployment from.</param>
/// <returns>DeploymentResource</returns>
public static DeploymentResource GetDeploymentFromTask(OctopusRepository octRepository, TaskResource task)
{
var deployment = new DeploymentResource();
deployment = octRepository.Deployments.Get(task.Arguments[ResourceStrings.DeploymentIdKey].ToString());
return(deployment);
}
private static void LogDeploymentInfo(ILogger log, DeploymentResource deploymentItem, ReleaseResource release, ChannelResource channel,
IDictionary <string, string> environmentsById, IDictionary <string, string> projectsById, IDictionary <string, string> tenantsById)
{
var nameOfDeploymentEnvironment = environmentsById[deploymentItem.EnvironmentId];
var nameOfDeploymentProject = projectsById[deploymentItem.ProjectId];
log.Information(" - Project: {Project:l}", nameOfDeploymentProject);
log.Information(" - Environment: {Environment:l}", nameOfDeploymentEnvironment);
if (!string.IsNullOrEmpty(deploymentItem.TenantId))
{
var nameOfDeploymentTenant = tenantsById[deploymentItem.TenantId];
log.Information(" - Tenant: {Tenant:l}", nameOfDeploymentTenant);
}
if (channel != null)
{
log.Information(" - Channel: {Channel:l}", channel.Name);
}
log.Information(" Created: {$Date:l}", deploymentItem.Created);
// Date will have to be fetched from Tasks (they need to be loaded) it doesn't come down with the DeploymentResource
//log.Information(" Date: {$Date:l}", deploymentItem.QueueTime);
log.Information(" Version: {Version:l}", release.Version);
log.Information(" Assembled: {$Assembled:l}", release.Assembled);
log.Information(" Package Versions: {PackageVersion:l}", GetPackageVersionsAsString(release.SelectedPackages));
log.Information(" Release Notes: {ReleaseNotes:l}", release.ReleaseNotes != null ? release.ReleaseNotes.Replace(Environment.NewLine, @"\n") : "");
log.Information("");
}
private static async Task <int> PromoteRelease(string server, string apiKey, string environmentName, string projectName, string semVer)
{
Console.WriteLine($"Promoting Octopus Deploy Release for project: {projectName} {semVer} to environment: {environmentName}");
try
{
var octoEndpoint = new OctopusServerEndpoint(server, apiKey);
using (var client = await OctopusAsyncClient.Create(octoEndpoint).ConfigureAwait(false))
{
var octoRepository = client.Repository;
var octoEnv = (await octoRepository.Environments.GetAll().ConfigureAwait(false)).First(x => x.Name.Equals(environmentName));
var octoProject = await octoRepository.Projects.FindOne(projectResource => projectResource.Name.Equals(projectName)).ConfigureAwait(false);
var octoRelease = await octoRepository.Releases.FindOne(releaseResource => releaseResource.Version.Equals(semVer) && releaseResource.ProjectId.Equals(octoProject.Id)).ConfigureAwait(false);
var octoDeploymentResource = new DeploymentResource
{
ReleaseId = octoRelease.Id,
ProjectId = octoRelease.ProjectId,
EnvironmentId = octoEnv.Id
};
await octoRepository.Deployments.Create(octoDeploymentResource).ConfigureAwait(false);
}
return(0);
}
catch (Exception ex)
{
Console.WriteLine($"Octopus Deploy Promote Release failed with message:{Environment.NewLine}{ex.Message}{Environment.NewLine}{ex.StackTrace}");
return(1);
}
}
private AppResource CreateApp(MockContext context, string rgName, string serviceName, string appName, string deploymentName)
{
AppPlatformManagementClient client = GetSpringManagementClient(context);
AppResource app = client.Apps.CreateOrUpdate(
rgName,
serviceName,
appName,
new AppResource()
);
DeploymentResource deployment = client.Deployments.CreateOrUpdate(
rgName,
serviceName,
app.Name,
deploymentName,
new DeploymentResource(
properties: new DeploymentResourceProperties(
source: new UserSourceInfo(
relativePath: "<default>",
type: "Jar"
))));
return(client.Apps.Update(
rgName,
serviceName,
appName,
new AppResource(
properties: new AppResourceProperties(
activeDeploymentName: deployment.Name
))));
}
/// <summary>
/// Get the DeploymentResource at the input environment of specific release version.
/// If the version is not specified, it will return the last deployment at the input environment
/// </summary>
/// <param name="env"></param>
/// <param name="releaseResource"></param>
/// <returns></returns>
public DeploymentResource GetDeployment(EnvironmentResource env, ReleaseResource releaseResource = null)
{
if (releaseResource != null)
{
return(GetAllDeployment(releaseResource).FirstOrDefault(deployment => deployment.EnvironmentId
== env.Id));
}
DeploymentResource lastDeployment = null;
foreach (var release in GetAllReleases().Take(int.Parse(ConfigurationManager
.AppSettings["ReleasesSelectionRange"])))
{
var deploy = GetAllDeployment(release).FirstOrDefault(deployment => deployment.EnvironmentId == env.Id);
if (deploy == null)
{
continue;
}
if (lastDeployment == null)
{
lastDeployment = deploy;
}
if (deploy.Created > lastDeployment.Created)
{
lastDeployment = deploy;
}
}
return(lastDeployment);
}
/// <summary>
/// Builds a DeploymentResource for the release and environment passed, allows you to directly pass the list of skipped steps
/// </summary>
/// <param name="octRepository">The repository to call against.</param>
/// <param name="release">Release to deploy.</param>
/// <param name="environment">Environment to deploy to.</param>
/// <param name="comment">Comment for the deployment.</param>
/// <param name="formValues">Form value variable dictionary.</param>
/// <param name="guidedFailure">Enable Guided Failure.</param>
/// <param name="skippedSteps">Steps to skip.</param>
/// <param name="dateToDeploy">Deployment Date.</param>
/// <returns>DeploymentResource</returns>
public static DeploymentResource BuildDeployment(OctopusRepository octRepository, ReleaseResource release, EnvironmentResource environment, string comment, Dictionary <string, string> formValues, bool guidedFailure, ReferenceCollection skippedSteps, DateTimeOffset?dateToDeploy)
{
var machineIDs = new ReferenceCollection();
var releaseTemplate = octRepository.Releases.GetTemplate(release);
var deploymentPromotionTarget = releaseTemplate.PromoteTo.SingleOrDefault(x => x.Id.Equals(environment.Id, StringComparison.OrdinalIgnoreCase));
var deploymentPreview = octRepository.Releases.GetPreview(deploymentPromotionTarget);
foreach (var element in deploymentPreview.Form.Elements)
{
var variableInput = element.Control as VariableValue;
if (variableInput != null)
{
var variableValue = formValues[variableInput.Label] ?? formValues[variableInput.Name];
if (string.IsNullOrWhiteSpace(variableValue) && element.IsValueRequired)
{
throw new ArgumentException(string.Format(ErrorStrings.MissingRequiredVar, variableInput.Label ?? variableInput.Name, ResourceStrings.FormValuesArgException));
}
}
}
var deploymentResource = new DeploymentResource
{
EnvironmentId = environment.Id,
SkipActions = skippedSteps,
ReleaseId = release.Id,
ForcePackageDownload = false,
UseGuidedFailure = guidedFailure,
SpecificMachineIds = machineIDs,
ForcePackageRedeployment = true,
FormValues = formValues,
QueueTime = dateToDeploy,
Comments = comment
};
return(deploymentResource);
}
private AppResource CreateApp(MockContext context, string rgName, string serviceName, string appName, string deploymentName)
{
AppPlatformManagementClient client = GetSpringManagementClient(context);
AppResource app = client.Apps.CreateOrUpdate(
rgName,
serviceName,
appName,
new AppResource()
);
DeploymentResource deployment = client.Deployments.CreateOrUpdate(
rgName,
serviceName,
app.Name,
deploymentName,
new DeploymentResource(
properties: new DeploymentResourceProperties(
source: new JarUploadedUserSourceInfo(
relativePath: "<default>"
))));
return(client.Apps.SetActiveDeployments(rgName, serviceName, appName,
new ActiveDeploymentCollection(new List <string> {
deployment.Name
})));
}
public static OctoDeployment ToOctoDeployment(this DeploymentResource resource)
{
var deploy = new OctoDeployment();
deploy.ID = resource.Id;
return(deploy);
}
/// <summary>
/// A simple and efficient way to manage DeploymentTasks
/// </summary>
/// <param name="octRepository">The repository to call against.</param>
/// <param name="deployment">The deployment to manage.</param>
public OctopusDeploymentTaskManager(OctopusRepository octRepository, DeploymentResource deployment)
{
octRepositoryToManage = octRepository;
deploymentToManage = deployment;
if (!string.IsNullOrWhiteSpace(deploymentToManage.TaskId))
{
taskToManage = octRepositoryToManage.Tasks.Get(deploymentToManage.TaskId);
}
}
public void SetUp()
{
deployReleaseCommand = new DeployReleaseCommand(RepositoryFactory, FileSystem, ClientFactory, CommandOutputProvider);
var project = new ProjectResource();
var release = new ReleaseResource {
Version = "1.0.0"
};
var releases = new ResourceCollection <ReleaseResource>(new[] { release }, new LinkCollection());
var deploymentPromotionTarget = new DeploymentPromotionTarget {
Name = ValidEnvironment, Id = "Env-1"
};
var promotionTargets = new List <DeploymentPromotionTarget> {
deploymentPromotionTarget
};
var tenantPromotionTarget1 = new DeploymentPromomotionTenant()
{
Id = "Tenant-1", PromoteTo = promotionTargets
};
var tenantPromotionTarget2 = new DeploymentPromomotionTenant()
{
Id = "Tenant-2", PromoteTo = new List <DeploymentPromotionTarget>()
};
var deploymentTemplate = new DeploymentTemplateResource {
PromoteTo = promotionTargets, TenantPromotions = { tenantPromotionTarget1, tenantPromotionTarget2 }
};
var deploymentPreviewResource = new DeploymentPreviewResource {
StepsToExecute = new List <DeploymentTemplateStep>()
};
var deployment = new DeploymentResource {
TaskId = "Task-1"
};
taskResource = new TaskResource()
{
Id = "Task-1"
};
Repository.Projects.FindByName(ProjectName).Returns(project);
Repository.Projects.GetReleases(project).Returns(releases);
Repository.Releases.GetPreview(deploymentPromotionTarget).Returns(deploymentPreviewResource);
Repository.Releases.GetTemplate(release).Returns(deploymentTemplate);
Repository.Deployments.Create(Arg.Any <DeploymentResource>()).Returns(deployment);
Repository.Tasks.Get(deployment.TaskId).Returns(taskResource);
Repository.Tenants.Get(Arg.Is <string[]>(arg => arg.All(arg2 => arg2 == "Tenant-1" || arg2 == "Tenant-2")))
.Returns(new List <TenantResource>()
{
new TenantResource()
{
Id = "Tenant-1"
},
new TenantResource()
{
Id = "Tenant-2"
},
});
}
public string[] DeploymentValues(DeploymentResource deployment)
{
if (string.IsNullOrEmpty(jiraServiceId))
{
throw new JiraDeploymentException("Service ID is empty. Please supply a Jira Service Desk Service ID and try again");
}
return(new[] { jiraServiceId });
}
public string[] DeploymentValues(DeploymentResource deployment)
{
return(deployment.Changes.SelectMany(
drn => drn.BuildInformation
.SelectMany(pm => pm.WorkItems)
.Where(wi => wi.Source == JiraConfigurationStore.CommentParser)
.Select(wi => wi.Id)
.Distinct())
.ToArray());
}
/// <summary>
/// Start the Deploy.
/// </summary>
public void StartDeploy()
{
if (taskToManage == null)
{
deploymentToManage = octRepositoryToManage.Deployments.Create(deploymentToManage);
taskToManage = octRepositoryToManage.Tasks.Get(deploymentToManage.TaskId);
}
else
{
throw new Exception(string.Format(ErrorStrings.DeploymentAlreadyStarted, deploymentToManage.Id));
}
}
private static void CreateDeploy(IOctopusRepository repo, ProjectResource project, EnvironmentResource environment, ReleaseSummaryResource latestRelease)
{
Console.WriteLine($"\t # deploying '{project.Name}' version {latestRelease.Version} to {environment.Name}");
var deploy = new DeploymentResource
{
ProjectId = project.Id,
ReleaseId = latestRelease.Id,
EnvironmentId = environment.Id
};
repo.Deployments.Create(deploy);
}
private Deployment ConvertDeployment(DeploymentResource dep)
{
return(new Deployment
{
EnvironmentId = dep.EnvironmentId,
ReleaseId = dep.ReleaseId,
TaskId = dep.TaskId,
LastModifiedBy = dep.LastModifiedBy,
LastModifiedOn = dep.LastModifiedOn,
Created = dep.Created
});
}
public static void Main(string[] args)
{
// Get your Account SID and Auth Token from https://twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var deploymentSid = "DLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
var deployment = DeploymentResource.Fetch(deploymentSid);
Console.WriteLine(deployment.Sid);
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
DeploymentResource.Delete(
pathFleetSid: "FLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
pathSid: "DLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
);
}
public TaskResource Create(SnapshotStep snapshotStep, string environmentId)
{
Log.Info($"Creating Delpoyment task.");
var deploymentResource = new DeploymentResource
{
ReleaseId = snapshotStep.ReleaseId,
ProjectId = snapshotStep.ProjectId,
EnvironmentId = environmentId
};
deploymentResource = _repository.Deployments.Create(deploymentResource);
return(_repository.Tasks.Get(deploymentResource.TaskId));
}
/// <summary>
/// Builds a base deployment with all steps enabled for the passed environment and release.
/// </summary>
/// <param name="release">Release to deploy.</param>
/// <param name="environment">Environment to deploy to.</param>
/// <param name="comment">Comment for the deployment.</param>
/// <param name="guidedFailure">Enable Guided Failure.</param>
/// <returns>DeploymentResource</returns>
public static DeploymentResource BuildDeployment(ReleaseResource release, EnvironmentResource environment, string comment, bool guidedFailure)
{
var deploymentResource = new DeploymentResource
{
EnvironmentId = environment.Id,
ReleaseId = release.Id,
ForcePackageDownload = false,
UseGuidedFailure = guidedFailure,
ForcePackageRedeployment = true,
Comments = comment
};
return(deploymentResource);
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var deployment = DeploymentResource.Create(
pathFleetSid: "FLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
);
Console.WriteLine(deployment.Sid);
}
public static void Main(string[] args)
{
// Get your Account SID and Auth Token from https://twilio.com/console
// To set up environmental variables, see http://twil.io/secure
const string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
const string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
TwilioClient.Init(accountSid, authToken);
var deploymentSid = "DLXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
var deployment = DeploymentResource.Fetch(deploymentSid);
Console.WriteLine(deployment.Sid);
}
public async Task <DeploymentResource> DeployReleaseAsync(string releaseId, string environmentId, bool forceRedeploy)
{
await InitializeClient();
var deploymentResource = new DeploymentResource
{
ReleaseId = releaseId,
EnvironmentId = environmentId,
Comments = "Deployed with Kraken"
};
if (!forceRedeploy)
{
var release = await _octopusClient.Repository.Releases.Get(releaseId);
DeploymentResource checkDeploy;
try
{
checkDeploy = (await _octopusClient.Repository.Releases.GetDeployments(release)).Items.FirstOrDefault(d => d.EnvironmentId == environmentId);
}
catch (OctopusResourceNotFoundException)
{
checkDeploy = null;
}
if (checkDeploy != null && checkDeploy.ReleaseId == releaseId)
{
var task = await _octopusClient.Repository.Tasks.Get(checkDeploy.TaskId);
// if the task hasn't completed, don't queue up another deploy
if (!task.IsCompleted)
{
return(null);
}
// if the task has finished successfully, only redeploy if there have been modifications made to the release since the deploy
if (task.FinishedSuccessfully)
{
// if no modifications have been made to a successful deploy since its creation, assume it's a redeploy
if (release.LastModifiedOn <= checkDeploy.Created)
{
return(null);
}
}
}
}
return(await _octopusClient.Repository.Deployments.Create(deploymentResource));
}
