public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
if (variablesFile != null && !File.Exists(variablesFile))
{
throw new CommandException("Could not find variables file: " + variablesFile);
}
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
var environment = new AwsEnvironmentGeneration(variables);
var stackEventLogger = new StackEventLogger(new LogWrapper());
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(x.Variables.Get(AwsSpecialVariables.CloudFormation.StackName));
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new DeleteCloudFormationStackConvention(environment, stackEventLogger, ClientFactory, StackProvider, waitForComplete)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var environment = AwsEnvironmentGeneration.Create(log, variables).GetAwaiter().GetResult();
var stackEventLogger = new StackEventLogger(log);
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(x.Variables.Get(AwsSpecialVariables.CloudFormation.StackName));
ChangeSetArn ChangesetProvider(RunningDeployment x) => new ChangeSetArn(x.Variables[AwsSpecialVariables.CloudFormation.Changesets.Arn]);
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new ExecuteCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider, waitForComplete),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
conventionRunner.RunConventions();
return(0);
}
/// <summary>
/// Updates the stack and returns the stack ID
/// </summary>
/// <param name="stack">The stack name or id</param>
/// <param name="deployment">The current deployment</param>
/// <param name="template">The CloudFormation template</param>
/// <returns>stackId</returns>
private async Task <string> UpdateCloudFormation(
RunningDeployment deployment,
StackArn stack,
CloudFormationTemplate template)
{
Guard.NotNull(deployment, "deployment can not be null");
try
{
var result = await ClientHelpers.CreateCloudFormationClient(awsEnvironmentGeneration).UpdateStackAsync(new UpdateStackRequest
{
StackName = stackName,
TemplateBody = template.Content,
Parameters = template.Inputs.ToList(),
Capabilities = capabilities,
RoleARN = roleArnProvider(deployment)
});
Log.Info(
$"Updated stack with id {result.StackId} in region {awsEnvironmentGeneration.AwsRegion.SystemName}");
return(result.StackId);
}
catch (AmazonCloudFormationException ex)
{
// Some stack states indicate that we can delete the stack and start again. Otherwise we have some other
// exception that needs to be dealt with.
if (!(await StackMustBeDeleted(stack)).SelectValueOrDefault(x => x))
{
// Is this an unrecoverable state, or just a stack that has nothing to update?
if (DealWithUpdateException(ex))
{
// There was nothing to update, but we return the id for consistency anyway
var result = await QueryStackAsync(clientFactory, stack);
return(result.StackId);
}
}
// If the stack exists, is in a ROLLBACK_COMPLETE state, and was never successfully
// created in the first place, we can end up here. In this case we try to create
// the stack from scratch.
await DeleteCloudFormation(stack);
await clientFactory.WaitForStackToComplete(CloudFormationDefaults.StatusWaitPeriod, stack, LogAndThrowRollbacks(clientFactory, stack, false));
return(await CreateCloudFormation(deployment, template));
}
catch (AmazonServiceException ex)
{
LogAmazonServiceException(ex);
throw ex;
}
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var filesInPackage = !string.IsNullOrWhiteSpace(pathToPackage);
var environment = AwsEnvironmentGeneration.Create(log, variables).GetAwaiter().GetResult();
var templateResolver = new TemplateResolver(fileSystem);
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(stackName);
ChangeSetArn ChangesetProvider(RunningDeployment x) => new ChangeSetArn(x.Variables[AwsSpecialVariables.CloudFormation.Changesets.Arn]);
string RoleArnProvider(RunningDeployment x) => x.Variables[AwsSpecialVariables.CloudFormation.RoleArn];
var iamCapabilities = JsonConvert.DeserializeObject <List <string> >(variables.Get(AwsSpecialVariables.IamCapabilities, "[]"));
CloudFormationTemplate TemplateFactory()
{
var resolvedTemplate = templateResolver.Resolve(templateFile, filesInPackage, variables);
var resolvedParameters = templateResolver.MaybeResolve(templateParameterFile, filesInPackage, variables);
if (templateParameterFile != null && !resolvedParameters.Some())
{
throw new CommandException("Could not find template parameters file: " + templateParameterFile);
}
var parameters = CloudFormationParametersFile.Create(resolvedParameters, fileSystem, variables);
return(CloudFormationTemplate.Create(resolvedTemplate, parameters, fileSystem, variables));
}
var stackEventLogger = new StackEventLogger(log);
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
//Create or Update the stack using changesets
new AggregateInstallationConvention(
new GenerateCloudFormationChangesetNameConvention(log),
new CreateCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, RoleArnProvider, TemplateFactory, iamCapabilities),
new DescribeCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider),
new ExecuteCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider, waitForComplete)
.When(ImmediateChangesetExecution),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
.When(ImmediateChangesetExecution)
).When(ChangesetsEnabled),
//Create or update stack using a template (no changesets)
new AggregateInstallationConvention(
new DeployAwsCloudFormationConvention(
ClientFactory,
TemplateFactory,
stackEventLogger,
StackProvider,
RoleArnProvider,
waitForComplete,
stackName,
iamCapabilities,
disableRollback,
environment),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
)
.When(ChangesetsDisabled)
};
var deployment = new RunningDeployment(pathToPackage, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
if (variablesFile != null && !File.Exists(variablesFile))
{
throw new CommandException("Could not find variables file: " + variablesFile);
}
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile,
sensitiveVariablesPassword);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var filesInPackage = !string.IsNullOrWhiteSpace(packageFile);
var environment = new AwsEnvironmentGeneration(variables);
var templateResolver = new TemplateResolver(fileSystem);
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(stackName);
ChangeSetArn ChangesetProvider(RunningDeployment x) => new ChangeSetArn(x.Variables[AwsSpecialVariables.CloudFormation.Changesets.Arn]);
string RoleArnProvider(RunningDeployment x) => x.Variables[AwsSpecialVariables.CloudFormation.RoleArn];
CloudFormationTemplate TemplateFactory()
{
var resolvedTemplate = templateResolver.Resolve(templateFile, filesInPackage, variables);
var resolvedParameters = templateResolver.MaybeResolve(templateParameterFile, filesInPackage, variables);
if (templateParameterFile != null && !resolvedParameters.Some())
{
throw new CommandException("Could not find template parameters file: " + templateParameterFile);
}
var parameters = CloudFormationParametersFile.Create(resolvedParameters, fileSystem, variables);
return(CloudFormationTemplate.Create(resolvedTemplate, parameters, fileSystem, variables));
}
var stackEventLogger = new StackEventLogger(new LogWrapper());
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new GenericPackageExtractorFactory().createStandardGenericPackageExtractor(), fileSystem),
//Create or Update the stack using changesets
new AggregateInstallationConvention(
new GenerateCloudFormationChangesetNameConvention(),
new CreateCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, RoleArnProvider, TemplateFactory, iamCapabilities),
new DescribeCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider),
new ExecuteCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider, waitForComplete)
.When(ImmediateChangesetExecution),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
.When(ImmediateChangesetExecution)
).When(ChangesetsEnabled),
//Create or update stack using a template (no changesets)
new AggregateInstallationConvention(
new DeployAwsCloudFormationConvention(
ClientFactory,
TemplateFactory,
stackEventLogger,
StackProvider,
RoleArnProvider,
waitForComplete,
stackName,
iamCapabilities,
disableRollback,
environment),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider, () => TemplateFactory().HasOutputs)
)
.When(ChangesetsDisabled)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var filesInPackage = !string.IsNullOrWhiteSpace(pathToPackage);
var environment = AwsEnvironmentGeneration.Create(log, variables).GetAwaiter().GetResult();
var templateResolver = new TemplateResolver(fileSystem);
IAmazonCloudFormation ClientFactory() => ClientHelpers.CreateCloudFormationClient(environment);
StackArn StackProvider(RunningDeployment x) => new StackArn(stackName);
ChangeSetArn ChangesetProvider(RunningDeployment x) => new ChangeSetArn(x.Variables[AwsSpecialVariables.CloudFormation.Changesets.Arn]);
string RoleArnProvider(RunningDeployment x) => x.Variables[AwsSpecialVariables.CloudFormation.RoleArn];
var iamCapabilities = JsonConvert.DeserializeObject <List <string> >(variables.Get(AwsSpecialVariables.IamCapabilities, "[]"));
var tags = JsonConvert.DeserializeObject <List <KeyValuePair <string, string> > >(variables.Get(AwsSpecialVariables.CloudFormation.Tags, "[]"));
var deployment = new RunningDeployment(pathToPackage, variables);
ICloudFormationRequestBuilder TemplateFactory() => string.IsNullOrWhiteSpace(templateS3Url)
? CloudFormationTemplate.Create(templateResolver,
templateFile,
templateParameterFile,
filesInPackage,
fileSystem,
variables,
stackName,
iamCapabilities,
disableRollback,
RoleArnProvider(deployment),
tags,
StackProvider(deployment),
ClientFactory)
: CloudFormationS3Template.Create(templateS3Url,
templateParameterS3Url,
fileSystem,
variables,
log,
stackName,
iamCapabilities,
disableRollback,
RoleArnProvider(deployment),
tags,
StackProvider(deployment),
ClientFactory);
var stackEventLogger = new StackEventLogger(log);
var conventions = new List <IConvention>
{
new LogAwsUserInfoConvention(environment),
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new StructuredConfigurationVariablesConvention(new StructuredConfigurationVariablesBehaviour(structuredConfigVariablesService)),
//Create or Update the stack using changesets
new AggregateInstallationConvention(
new GenerateCloudFormationChangesetNameConvention(log),
new CreateCloudFormationChangeSetConvention(ClientFactory,
stackEventLogger,
StackProvider,
TemplateFactory),
new DescribeCloudFormationChangeSetConvention(ClientFactory, stackEventLogger, StackProvider, ChangesetProvider),
new ExecuteCloudFormationChangeSetConvention(ClientFactory,
stackEventLogger,
StackProvider,
ChangesetProvider,
waitForComplete)
.When(ImmediateChangesetExecution),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider)
.When(ImmediateChangesetExecution)
).When(ChangesetsEnabled),
//Create or update stack using a template (no changesets)
new AggregateInstallationConvention(
new DeployAwsCloudFormationConvention(
ClientFactory,
TemplateFactory,
stackEventLogger,
StackProvider,
RoleArnProvider,
waitForComplete,
stackName,
environment),
new CloudFormationOutputsAsVariablesConvention(ClientFactory, stackEventLogger, StackProvider)
)
.When(ChangesetsDisabled)
};
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
conventionRunner.RunConventions();
return(0);
}
