public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var configurationTransformer = ConfigurationTransformer.FromVariables(variables);
var transformFileLocator = new TransformFileLocator(fileSystem);
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var jsonVariableReplacer = new JsonConfigurationVariableReplacer();
ValidateArguments();
WriteVariableScriptToFile();
var conventions = new List <IConvention>
{
new StageScriptPackagesConvention(packageFile, fileSystem, new CombinedPackageExtractor(log)),
// Substitute the script source file
new DelegateInstallConvention(d => substituteInFiles.Substitute(d, ScriptFileTargetFactory(d).ToList())),
// Substitute any user-specified files
new DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator),
new ConfigurationVariablesConvention(fileSystem, replacer),
new JsonConfigurationVariablesConvention(jsonVariableReplacer, fileSystem),
new ExecuteScriptConvention(scriptEngine, commandLineRunner)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
var exitCode = variables.GetInt32(SpecialVariables.Action.Script.ExitCode);
deploymentJournalWriter.AddJournalEntry(deployment, exitCode == 0, packageFile);
return(exitCode.Value);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
variables.Set(KnownVariables.OriginalPackageDirectoryPath, Environment.CurrentDirectory);
var fileSystem = new WindowsPhysicalFileSystem();
var filesInPackage = !string.IsNullOrWhiteSpace(pathToPackage);
var templateResolver = new TemplateResolver(fileSystem);
var templateService = new TemplateService(fileSystem, templateResolver, new TemplateReplacement(templateResolver));
var conventions = new List <IConvention>
{
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(log, DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(log, DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new DeployAzureResourceGroupConvention(templateFile, templateParameterFile, filesInPackage, templateService, new ResourceGroupTemplateNormalizer()),
new PackagedScriptConvention(log, DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
};
var deployment = new RunningDeployment(pathToPackage, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
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 = new WindowsPhysicalFileSystem();
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new GenericPackageExtractor(), fileSystem),
new DeployAzureResourceGroupConvention(templateFile, templateParameterFile, fileSystem, new ResourceGroupTemplateParameterParser())
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
var packageFile = variables.GetPathToPrimaryPackage(fileSystem, true);
if (packageFile == null) // required: true in the above call means it will throw rather than return null, but there's no way to tell the compiler that. And ! doesn't work in older frameworks
{
throw new CommandException("Package File path could not be determined");
}
var journal = new DeploymentJournal(fileSystem, SemaphoreFactory.Get(), variables);
var conventions = new List <IConvention>
{
new AlreadyInstalledConvention(log, journal),
new TransferPackageConvention(log, fileSystem),
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
try
{
conventionRunner.RunConventions();
deploymentJournalWriter.AddJournalEntry(deployment, true);
}
catch (Exception)
{
deploymentJournalWriter.AddJournalEntry(deployment, false);
throw;
}
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var configurationTransformer = ConfigurationTransformer.FromVariables(variables, log);
var transformFileLocator = new TransformFileLocator(fileSystem, log);
var replacer = new ConfigurationVariablesReplacer(variables, log);
var allFileFormatReplacers = FileFormatVariableReplacers.BuildAllReplacers(fileSystem, log);
var structuredConfigVariablesService = new StructuredConfigVariablesService(allFileFormatReplacers, fileSystem, log);
ValidateArguments();
WriteVariableScriptToFile();
var conventions = new List <IConvention>
{
new StageScriptPackagesConvention(packageFile, fileSystem, new CombinedPackageExtractor(log)),
// Substitute the script source file
new DelegateInstallConvention(d => substituteInFiles.Substitute(d, ScriptFileTargetFactory(d).ToList())),
// Substitute any user-specified files
new SubstituteInFilesConvention(new SubstituteInFilesBehaviour(substituteInFiles)),
new ConfigurationTransformsConvention(new ConfigurationTransformsBehaviour(fileSystem, configurationTransformer, transformFileLocator, log)),
new ConfigurationVariablesConvention(new ConfigurationVariablesBehaviour(fileSystem, replacer, log)),
new StructuredConfigurationVariablesConvention(new StructuredConfigurationVariablesBehaviour(structuredConfigVariablesService)),
new ExecuteScriptConvention(scriptEngine, commandLineRunner)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
conventionRunner.RunConventions();
var exitCode = variables.GetInt32(SpecialVariables.Action.Script.ExitCode);
deploymentJournalWriter.AddJournalEntry(deployment, exitCode == 0, packageFile);
return(exitCode.Value);
}
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)
{
var packageFile = variables.GetPathToPrimaryPackage(fileSystem, true);
var journal = new DeploymentJournal(fileSystem, SemaphoreFactory.Get(), variables);
var conventions = new List <IConvention>
{
new AlreadyInstalledConvention(log, journal),
new TransferPackageConvention(log, fileSystem),
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
try
{
conventionRunner.RunConventions();
deploymentJournalWriter.AddJournalEntry(deployment, true);
}
catch (Exception)
{
deploymentJournalWriter.AddJournalEntry(deployment, false);
throw;
}
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 = new WindowsPhysicalFileSystem();
var conventions = new List <IConvention>
{
new ExtractPackageToStagingDirectoryConvention(
new GenericPackageExtractorFactory()
.createStandardGenericPackageExtractor(),
fileSystem,
null)
};
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);
Guard.NotNullOrWhiteSpace(packageFile, "No package file was specified. Please pass -cspkg YourPackage.cspkg");
if (!File.Exists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
var variables = new CalamariVariableDictionary();
variables.Set(SpecialVariables.Action.Azure.CloudServicePackagePath, packageFile);
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, !string.IsNullOrWhiteSpace(destinationDirectory) ? destinationDirectory : Path.GetDirectoryName(packageFile));
var fileSystem = new WindowsPhysicalFileSystem();
var conventions = new List <IConvention>
{
new EnsureCloudServicePackageIsCtpFormatConvention(fileSystem),
new ExtractAzureCloudServicePackageConvention(fileSystem),
};
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);
JavaRuntime.VerifyExists();
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var variables =
new CalamariVariableDictionary(variablesFile, sensitiveVariableFiles, sensitiveVariablesPassword);
var commandOutput =
new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables));
var commandLineRunner = new CommandLineRunner(commandOutput);
var embeddedResources = new AssemblyEmbeddedResources();
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new JavaStepConvention(actionType, new JavaRunner(commandLineRunner, variables)),
new FeatureRollbackConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine,
commandLineRunner, embeddedResources)
};
var deployment = new RunningDeployment(null, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
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);
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, Environment.CurrentDirectory);
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var fileSystem = new WindowsPhysicalFileSystem();
var filesInPackage = !string.IsNullOrWhiteSpace(packageFile);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new GenericPackageExtractorFactory().createStandardGenericPackageExtractor(), fileSystem),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new DeployAzureResourceGroupConvention(templateFile, templateParameterFile, filesInPackage, fileSystem, new ResourceGroupTemplateNormalizer()),
new PackagedScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
};
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);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
var packageFile = variables.GetEnvironmentExpandedPath(SpecialVariables.Tentacle.CurrentDeployment.PackageFilePath);
if (string.IsNullOrEmpty(packageFile))
{
throw new CommandException($"No package file was specified. Please provide `{SpecialVariables.Tentacle.CurrentDeployment.PackageFilePath}` variable");
}
if (!fileSystem.FileExists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
fileSystem.FreeDiskSpaceOverrideInMegaBytes = variables.GetInt32(SpecialVariables.FreeDiskSpaceOverrideInMegaBytes);
fileSystem.SkipFreeDiskSpaceCheck = variables.GetFlag(SpecialVariables.SkipFreeDiskSpaceCheck);
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var journal = new DeploymentJournal(fileSystem, SemaphoreFactory.Get(), variables);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new ContributePreviousInstallationConvention(journal),
new ContributePreviousSuccessfulInstallationConvention(journal),
new LogVariablesConvention(),
new AlreadyInstalledConvention(journal),
new TransferPackageConvention(fileSystem),
new RollbackScriptConvention(DeploymentStages.DeployFailed, fileSystem, new CombinedScriptEngine(), commandLineRunner),
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
try
{
conventionRunner.RunConventions();
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, true));
}
}
catch (Exception)
{
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, false));
}
throw;
}
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
Guard.NotNullOrWhiteSpace(packageFile,
"No package file was specified. Please pass --package YourPackage.nupkg");
if (!File.Exists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
if (variablesFile != null && !File.Exists(variablesFile))
{
throw new CommandException("Could not find variables file: " + variablesFile);
}
Log.Info("Deploying package: " + packageFile);
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
var fileSystem = new WindowsPhysicalFileSystem();
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var jsonReplacer = new JsonConfigurationVariableReplacer();
var scriptEngine = new CombinedScriptEngine();
var substituter = new FileSubstituter(fileSystem);
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var configurationTransformer =
new ConfigurationTransformer(
variables.GetFlag(SpecialVariables.Package.IgnoreConfigTransformationErrors),
variables.GetFlag(SpecialVariables.Package.SuppressConfigTransformationLogging));
var transformFileLocator = new TransformFileLocator(fileSystem);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new GenericPackageExtractor(), fileSystem),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, scriptEngine, fileSystem, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new SubstituteInFilesConvention(fileSystem, substituter),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator),
new ConfigurationVariablesConvention(fileSystem, replacer),
new JsonConfigurationVariablesConvention(jsonReplacer, fileSystem),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, scriptEngine, fileSystem, commandLineRunner),
new AzureWebAppConvention(),
new PackagedScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, scriptEngine, fileSystem, commandLineRunner),
};
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);
Guard.NotNullOrWhiteSpace(pathToPackage, "No package file was specified. Please pass --package YourPackage.nupkg");
if (!File.Exists(pathToPackage))
{
throw new CommandException("Could not find package file: " + pathToPackage);
}
Log.Info("Deploying package: " + pathToPackage);
var account = new AzureAccount(variables);
var fileSystem = new WindowsPhysicalFileSystem();
var embeddedResources = new AssemblyEmbeddedResources();
var azurePackageUploader = new AzurePackageUploader(log);
var certificateStore = new CalamariCertificateStore();
var cloudCredentialsFactory = new SubscriptionCloudCredentialsFactory(certificateStore);
var cloudServiceConfigurationRetriever = new AzureCloudServiceConfigurationRetriever();
var configurationTransformer = ConfigurationTransformer.FromVariables(variables);
var transformFileLocator = new TransformFileLocator(fileSystem);
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var jsonVariablesReplacer = new JsonConfigurationVariableReplacer();
var conventions = new List <IConvention>
{
new SwapAzureDeploymentConvention(fileSystem, embeddedResources, scriptEngine, commandLineRunner),
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new FindCloudServicePackageConvention(fileSystem),
new EnsureCloudServicePackageIsCtpFormatConvention(fileSystem),
new ExtractAzureCloudServicePackageConvention(log, fileSystem),
new ChooseCloudServiceConfigurationFileConvention(fileSystem),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(log, DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfigureAzureCloudServiceConvention(account, fileSystem, cloudCredentialsFactory, cloudServiceConfigurationRetriever, certificateStore),
new DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator),
new ConfigurationVariablesConvention(fileSystem, replacer),
new JsonConfigurationVariablesConvention(jsonVariablesReplacer, fileSystem),
new PackagedScriptConvention(log, DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new RePackageCloudServiceConvention(fileSystem),
new UploadAzureCloudServicePackageConvention(fileSystem, azurePackageUploader, cloudCredentialsFactory),
new DeployAzureCloudServicePackageConvention(fileSystem, embeddedResources, scriptEngine, commandLineRunner),
new PackagedScriptConvention(log, DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner)
};
var deployment = new RunningDeployment(pathToPackage, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
if (!File.Exists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
if (variablesFile != null && !File.Exists(variablesFile))
{
throw new CommandException("Could not find variables file: " + variablesFile);
}
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariableFiles, sensitiveVariablesPassword);
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var substituter = new FileSubstituter(fileSystem);
var extractor = new GenericPackageExtractorFactory().createStandardGenericPackageExtractor();
ValidateRequiredVariables(variables);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(extractor, fileSystem),
new StageScriptPackagesConvention(null, fileSystem, extractor, true),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new SubstituteInFilesConvention(fileSystem, substituter, _ => true, FileTargetFactory),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new HelmUpgradeConvention(scriptEngine, commandLineRunner, fileSystem),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
try
{
conventionRunner.RunConventions();
deploymentJournalWriter.AddJournalEntry(deployment, true, packageFile);
}
catch (Exception)
{
deploymentJournalWriter.AddJournalEntry(deployment, false, packageFile);
throw;
}
return(0);
}
public int Execute()
{
var deployment = new RunningDeployment(variables);
var conventions = new List <IConvention>
{
new StructuredConfigurationVariablesConvention(new StructuredConfigurationVariablesBehaviour(structuredConfigVariablesService))
};
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
if (string.IsNullOrEmpty(packageFile))
{
throw new CommandException($"No package file was specified. Please provide `{SpecialVariables.Tentacle.CurrentDeployment.PackageFilePath}` variable");
}
if (!fileSystem.FileExists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
fileSystem.FreeDiskSpaceOverrideInMegaBytes = variables.GetInt32(SpecialVariables.FreeDiskSpaceOverrideInMegaBytes);
fileSystem.SkipFreeDiskSpaceCheck = variables.GetFlag(SpecialVariables.SkipFreeDiskSpaceCheck);
var environment = AwsEnvironmentGeneration.Create(variables).GetAwaiter().GetResult();
var substituter = new FileSubstituter(fileSystem);
var targetType = GetTargetMode(targetMode);
var packageExtractor = new GenericPackageExtractorFactory().createStandardGenericPackageExtractor();
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(packageExtractor, fileSystem).When(_ => targetType == S3TargetMode.FileSelections),
new LogAwsUserInfoConvention(environment),
new CreateS3BucketConvention(environment, _ => bucket),
new UploadAwsS3Convention(
fileSystem,
environment,
bucket,
targetType,
new VariableS3TargetOptionsProvider(variables),
substituter
)
};
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);
Guard.NotNullOrWhiteSpace(pathToPackage,
"No package file was specified. Please pass --package YourPackage.nupkg");
if (!File.Exists(pathToPackage))
{
throw new CommandException("Could not find package file: " + pathToPackage);
}
Log.Info("Deploying package: " + pathToPackage);
var fileSystem = new WindowsPhysicalFileSystem();
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var jsonReplacer = new JsonConfigurationVariableReplacer();
var configurationTransformer = ConfigurationTransformer.FromVariables(variables);
var transformFileLocator = new TransformFileLocator(fileSystem);
var conventions = new List <IConvention>
{
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(log, DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator),
new ConfigurationVariablesConvention(fileSystem, replacer),
new JsonConfigurationVariablesConvention(jsonReplacer, fileSystem),
new PackagedScriptConvention(log, DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new AzureWebAppConvention(log),
new LogAzureWebAppDetails(log),
new PackagedScriptConvention(log, DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
};
var deployment = new RunningDeployment(pathToPackage, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
if (!string.IsNullOrEmpty(packageFile))
{
if (!fileSystem.FileExists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
}
fileSystem.FreeDiskSpaceOverrideInMegaBytes = variables.GetInt32(SpecialVariables.FreeDiskSpaceOverrideInMegaBytes);
fileSystem.SkipFreeDiskSpaceCheck = variables.GetFlag(SpecialVariables.SkipFreeDiskSpaceCheck);
var substituter = new FileSubstituter(fileSystem);
var packageExtractor = new GenericPackageExtractorFactory().createStandardGenericPackageExtractor();
var additionalFileSubstitution = variables.Get(TerraformSpecialVariables.Action.Terraform.FileSubstitution);
var runAutomaticFileSubstitution = variables.GetFlag(TerraformSpecialVariables.Action.Terraform.RunAutomaticFileSubstitution, true);
var enableNoMatchWarning = variables.Get(SpecialVariables.Package.EnableNoMatchWarning);
variables.Add(SpecialVariables.Package.EnableNoMatchWarning,
!String.IsNullOrEmpty(enableNoMatchWarning) ? enableNoMatchWarning : (!String.IsNullOrEmpty(additionalFileSubstitution)).ToString());
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(packageExtractor, fileSystem).When(_ => packageFile != null),
new SubstituteInFilesConvention(fileSystem, substituter,
_ => true,
_ => FileTargetFactory(runAutomaticFileSubstitution ? DefaultTerraformFileSubstitution : string.Empty, additionalFileSubstitution)),
step(fileSystem)
};
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 fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(),
new ServiceMessageCommandOutput(variables)));
fileSubstituter = new FileSubstituter(fileSystem);
var configurationTransformer = ConfigurationTransformer.FromVariables(variables);
var transformFileLocator = new TransformFileLocator(fileSystem);
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var jsonVariableReplacer = new JsonConfigurationVariableReplacer();
var extractor = new GenericPackageExtractorFactory().createStandardGenericPackageExtractor();
ValidateArguments();
WriteVariableScriptToFile();
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new ContributeVariablesFromJsonFileConvention(),
new LogVariablesConvention(),
new StageScriptPackagesConvention(packageFile, fileSystem, extractor),
// Substitute the script source file
new SubstituteInFilesConvention(fileSystem, fileSubstituter, _ => true, ScriptFileTargetFactory),
// Substitute any user-specified files
new SubstituteInFilesConvention(fileSystem, fileSubstituter),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator),
new ConfigurationVariablesConvention(fileSystem, replacer),
new JsonConfigurationVariablesConvention(jsonVariableReplacer, fileSystem),
new ExecuteScriptConvention(scriptEngine, commandLineRunner)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
var exitCode = variables.GetInt32(SpecialVariables.Action.Script.ExitCode);
deploymentJournalWriter.AddJournalEntry(deployment, exitCode == 0, packageFile);
return(exitCode.Value);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
if (string.IsNullOrEmpty(pathToPackage))
{
throw new CommandException($"No package file was specified. Please provide `{TentacleVariables.CurrentDeployment.PackageFilePath}` variable");
}
if (!fileSystem.FileExists(pathToPackage))
{
throw new CommandException("Could not find package file: " + pathToPackage);
}
var environment = AwsEnvironmentGeneration.Create(log, variables).GetAwaiter().GetResult();
var bucketKeyProvider = new BucketKeyProvider();
var targetType = GetTargetMode(targetMode);
var conventions = new List <IConvention>
{
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new LogAwsUserInfoConvention(environment),
new CreateS3BucketConvention(environment, _ => bucket),
new UploadAwsS3Convention(
log,
fileSystem,
environment,
bucket,
targetType,
new VariableS3TargetOptionsProvider(variables),
bucketKeyProvider,
substituteInFiles,
structuredConfigVariablesService
)
};
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 (!File.Exists(pathToPackage))
{
throw new CommandException("Could not find package file: " + pathToPackage);
}
ValidateRequiredVariables();
var conventions = new List <IConvention>
{
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new StageScriptPackagesConvention(null, fileSystem, new CombinedPackageExtractor(log, variables, commandLineRunner), true),
new ConfiguredScriptConvention(new PreDeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)),
// Any values.yaml files in any packages referenced by the step will automatically have variable substitution applied (we won't log a warning if these aren't present)
new DelegateInstallConvention(d => substituteInFiles.Substitute(d, DefaultValuesFiles().ToList(), false)),
// Any values files explicitly specified by the user will also have variable substitution applied
new DelegateInstallConvention(d => substituteInFiles.Substitute(d, ExplicitlySpecifiedValuesFiles().ToList(), true)),
new ConfiguredScriptConvention(new DeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)),
new HelmUpgradeConvention(log, scriptEngine, commandLineRunner, fileSystem),
new ConfiguredScriptConvention(new PostDeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner))
};
var deployment = new RunningDeployment(pathToPackage, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
try
{
conventionRunner.RunConventions();
deploymentJournalWriter.AddJournalEntry(deployment, true, pathToPackage);
}
catch (Exception)
{
deploymentJournalWriter.AddJournalEntry(deployment, false, pathToPackage);
throw;
}
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
JavaRuntime.VerifyExists();
var embeddedResources = new AssemblyEmbeddedResources();
var conventions = new List <IConvention>
{
new JavaStepConvention(actionType, new JavaRunner(commandLineRunner, variables)),
new FeatureRollbackConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine,
commandLineRunner, embeddedResources)
};
var deployment = new RunningDeployment(null, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
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 = new WindowsPhysicalFileSystem();
var filesInPackage = !string.IsNullOrWhiteSpace(packageFile);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new GenericPackageExtractorFactory().createStandardGenericPackageExtractor(), fileSystem),
new DeployAwsCloudFormationConvention(
templateFile,
templateParameterFile,
filesInPackage,
action,
!Boolean.FalseString.Equals(waitForComplete, StringComparison.InvariantCultureIgnoreCase), // true by default
stackName,
iamCapabilities,
Boolean.TrueString.Equals(disableRollback, StringComparison.InvariantCultureIgnoreCase), // false by default
fileSystem,
new AwsEnvironmentGeneration(variables))
};
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);
if (!File.Exists(pathToPackage))
{
throw new CommandException("Could not find package file: " + pathToPackage);
}
ValidateRequiredVariables();
var conventions = new List <IConvention>
{
new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)),
new StageScriptPackagesConvention(null, fileSystem, new CombinedPackageExtractor(log), true),
new ConfiguredScriptConvention(new PreDeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)),
new DelegateInstallConvention(d => substituteInFiles.Substitute(d, FileTargetFactory().ToList())),
new ConfiguredScriptConvention(new DeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)),
new HelmUpgradeConvention(log, scriptEngine, commandLineRunner, fileSystem),
new ConfiguredScriptConvention(new PostDeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner))
};
var deployment = new RunningDeployment(pathToPackage, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions, log);
try
{
conventionRunner.RunConventions();
deploymentJournalWriter.AddJournalEntry(deployment, true, pathToPackage);
}
catch (Exception)
{
deploymentJournalWriter.AddJournalEntry(deployment, false, pathToPackage);
throw;
}
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, "[]"));
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);
Guard.NotNullOrWhiteSpace(packageFile, "No package file was specified. Please pass --package YourPackage.nupkg");
if (!File.Exists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
Log.Info("Deploying package: " + packageFile);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
var scriptCapability = new CombinedScriptEngine();
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var generator = new AppSettingsJsonGenerator();
var substituter = new FileSubstituter(fileSystem);
var configurationTransformer = new ConfigurationTransformer(variables.GetFlag(SpecialVariables.Package.IgnoreConfigTransformationErrors), variables.GetFlag(SpecialVariables.Package.SuppressConfigTransformationLogging));
var embeddedResources = new CallingAssemblyEmbeddedResources();
var iis = new InternetInformationServer();
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var semaphore = new SystemSemaphore();
var journal = new DeploymentJournal(fileSystem, semaphore, variables);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new ContributePreviousInstallationConvention(journal),
new LogVariablesConvention(),
new AlreadyInstalledConvention(journal),
new ExtractPackageToApplicationDirectoryConvention(new LightweightPackageExtractor(), fileSystem, semaphore),
new FeatureScriptConvention(DeploymentStages.BeforePreDeploy, fileSystem, embeddedResources, scriptCapability, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, scriptCapability, fileSystem, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptCapability, commandLineRunner),
new FeatureScriptConvention(DeploymentStages.AfterPreDeploy, fileSystem, embeddedResources, scriptCapability, commandLineRunner),
new SubstituteInFilesConvention(fileSystem, substituter),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer),
new ConfigurationVariablesConvention(fileSystem, replacer),
new AppSettingsJsonConvention(generator),
new CopyPackageToCustomInstallationDirectoryConvention(fileSystem),
new FeatureScriptConvention(DeploymentStages.BeforeDeploy, fileSystem, embeddedResources, scriptCapability, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptCapability, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, scriptCapability, fileSystem, commandLineRunner),
new FeatureScriptConvention(DeploymentStages.AfterDeploy, fileSystem, embeddedResources, scriptCapability, commandLineRunner),
new LegacyIisWebSiteConvention(fileSystem, iis),
new FeatureScriptConvention(DeploymentStages.BeforePostDeploy, fileSystem, embeddedResources, scriptCapability, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptCapability, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, scriptCapability, fileSystem, commandLineRunner),
new FeatureScriptConvention(DeploymentStages.AfterPostDeploy, fileSystem, embeddedResources, scriptCapability, commandLineRunner),
new RollbackScriptConvention(DeploymentStages.DeployFailed, fileSystem, scriptCapability, commandLineRunner)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
try
{
conventionRunner.RunConventions();
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, true));
}
}
catch (Exception)
{
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, false));
}
throw;
}
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
Guard.NotNullOrWhiteSpace(packageFile, "No package file was specified. Please pass --package YourPackage.nupkg");
if (!File.Exists(packageFile))
{
throw new CommandException("Could not find package file: " + packageFile);
}
Log.Info("Deploying package: " + packageFile);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
fileSystem.FreeDiskSpaceOverrideInMegaBytes = variables.GetInt32(SpecialVariables.FreeDiskSpaceOverrideInMegaBytes);
fileSystem.SkipFreeDiskSpaceCheck = variables.GetFlag(SpecialVariables.SkipFreeDiskSpaceCheck);
var featureClasses = new List <IFeature>();
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var generator = new JsonConfigurationVariableReplacer();
var substituter = new FileSubstituter(fileSystem);
var configurationTransformer = ConfigurationTransformer.FromVariables(variables);
var transformFileLocator = new TransformFileLocator(fileSystem);
var embeddedResources = new AssemblyEmbeddedResources();
#if IIS_SUPPORT
var iis = new InternetInformationServer();
featureClasses.AddRange(new IFeature[] { new IisWebSiteBeforeDeployFeature(), new IisWebSiteAfterPostDeployFeature() });
#endif
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var semaphore = SemaphoreFactory.Get();
var journal = new DeploymentJournal(fileSystem, semaphore, variables);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new ContributePreviousInstallationConvention(journal),
new ContributePreviousSuccessfulInstallationConvention(journal),
new LogVariablesConvention(),
new AlreadyInstalledConvention(journal),
new ExtractPackageToApplicationDirectoryConvention(new GenericPackageExtractorFactory().createStandardGenericPackageExtractor(), fileSystem),
new FeatureConvention(DeploymentStages.BeforePreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new FeatureConvention(DeploymentStages.AfterPreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new SubstituteInFilesConvention(fileSystem, substituter),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator),
new ConfigurationVariablesConvention(fileSystem, replacer),
new JsonConfigurationVariablesConvention(generator, fileSystem),
new CopyPackageToCustomInstallationDirectoryConvention(fileSystem),
new FeatureConvention(DeploymentStages.BeforeDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new FeatureConvention(DeploymentStages.AfterDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
#if IIS_SUPPORT
new LegacyIisWebSiteConvention(fileSystem, iis),
#endif
new FeatureConvention(DeploymentStages.BeforePostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new PackagedScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new FeatureConvention(DeploymentStages.AfterPostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new RollbackScriptConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner),
new FeatureRollbackConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner, embeddedResources)
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
try
{
conventionRunner.RunConventions();
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, true));
}
}
catch (Exception)
{
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, false));
}
throw;
}
return(0);
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
Guard.NotNullOrWhiteSpace(archiveFile, "No archive file was specified. Please pass --archive YourPackage.jar");
JavaRuntime.VerifyExists();
if (!File.Exists(archiveFile))
{
throw new CommandException("Could not find archive file: " + archiveFile);
}
Log.Info("Deploying: " + archiveFile);
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
var semaphore = SemaphoreFactory.Get();
var journal = new DeploymentJournal(fileSystem, semaphore, variables);
var substituter = new FileSubstituter(fileSystem);
var commandOutput =
new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables));
var commandLineRunner = new CommandLineRunner(commandOutput);
var jsonReplacer = new JsonConfigurationVariableReplacer();
var jarTools = new JarTool(commandLineRunner, commandOutput, variables);
var packageExtractor = new JavaPackageExtractor(jarTools);
var embeddedResources = new AssemblyEmbeddedResources();
var javaRunner = new JavaRunner(commandLineRunner, variables);
var featureClasses = new List <IFeature>
{
new TomcatFeature(javaRunner),
new WildflyFeature(javaRunner)
};
var deployExploded = variables.GetFlag(SpecialVariables.Action.Java.DeployExploded);
var conventions = new List <IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new ContributePreviousInstallationConvention(journal),
new ContributePreviousSuccessfulInstallationConvention(journal),
new LogVariablesConvention(),
new AlreadyInstalledConvention(journal),
// If we are deploying the package exploded then extract directly to the application directory.
// Else, if we are going to re-pack, then we extract initially to a temporary directory
deployExploded
? (IInstallConvention) new ExtractPackageToApplicationDirectoryConvention(packageExtractor, fileSystem)
: new ExtractPackageToStagingDirectoryConvention(packageExtractor, fileSystem),
new FeatureConvention(DeploymentStages.BeforePreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new FeatureConvention(DeploymentStages.AfterPreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new SubstituteInFilesConvention(fileSystem, substituter),
new JsonConfigurationVariablesConvention(jsonReplacer, fileSystem),
new RePackArchiveConvention(fileSystem, jarTools),
new CopyPackageToCustomInstallationDirectoryConvention(fileSystem),
new FeatureConvention(DeploymentStages.BeforeDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new FeatureConvention(DeploymentStages.AfterDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new FeatureConvention(DeploymentStages.BeforePostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new PackagedScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner),
new FeatureConvention(DeploymentStages.AfterPostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources),
new RollbackScriptConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner),
new FeatureRollbackConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner, embeddedResources)
};
var deployment = new RunningDeployment(archiveFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
try
{
conventionRunner.RunConventions();
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, true));
}
}
catch (Exception)
{
if (!deployment.SkipJournal)
{
journal.AddJournalEntry(new JournalEntry(deployment, false));
}
throw;
}
return(0);
}
