private CalamariVariableDictionary GetDictionaryWithSecret()
{
var cd = new CalamariVariableDictionary();
cd.Set("foo", "bar");
cd.SetSensitive("mysecrect", "KingKong");
return cd;
}
private CalamariResult ExecuteScript(IScriptEngine psse, string scriptName, CalamariVariableDictionary variables)
{
var capture = new CaptureCommandOutput();
var runner = new CommandLineRunner(capture);
var result = psse.Execute(scriptName, variables, runner);
return new CalamariResult(result.ExitCode, capture);
}
public void SetUp()
{
variables = new CalamariVariableDictionary();
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, stagingDirectory);
fileSystem = Substitute.For<ICalamariFileSystem>();
deployment = new RunningDeployment(packageFilePath, variables);
}
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);
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 embeddedResources = new CallingAssemblyEmbeddedResources();
var scriptEngine = new CombinedScriptEngine();
var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var azurePackageUploader = new AzurePackageUploader();
var certificateStore = new CalamariCertificateStore();
var cloudCredentialsFactory = new SubscriptionCloudCredentialsFactory(certificateStore);
var cloudServiceConfigurationRetriever = new AzureCloudServiceConfigurationRetriever();
var substituter = new FileSubstituter(fileSystem);
var configurationTransformer = new ConfigurationTransformer(variables.GetFlag(SpecialVariables.Package.IgnoreConfigTransformationErrors), variables.GetFlag(SpecialVariables.Package.SuppressConfigTransformationLogging));
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
var generator = new AppSettingsJsonGenerator();
var conventions = new List<IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new SwapAzureDeploymentConvention(fileSystem, embeddedResources, scriptEngine, commandLineRunner),
new ExtractPackageToStagingDirectoryConvention(new LightweightPackageExtractor(), fileSystem),
new FindCloudServicePackageConvention(fileSystem),
new EnsureCloudServicePackageIsCtpFormatConvention(fileSystem),
new ExtractAzureCloudServicePackageConvention(fileSystem),
new ChooseCloudServiceConfigurationFileConvention(fileSystem),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, scriptEngine, fileSystem, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new ConfigureAzureCloudServiceConvention(fileSystem, cloudCredentialsFactory, cloudServiceConfigurationRetriever),
new SubstituteInFilesConvention(fileSystem, substituter),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer),
new ConfigurationVariablesConvention(fileSystem, replacer),
new AppSettingsJsonConvention(generator),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, scriptEngine, fileSystem, commandLineRunner),
new RePackageCloudServiceConvention(fileSystem),
new UploadAzureCloudServicePackageConvention(fileSystem, azurePackageUploader, cloudCredentialsFactory),
new DeployAzureCloudServicePackageConvention(fileSystem, embeddedResources, scriptEngine, commandLineRunner),
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 void ShouldIncludeEncryptedSensitiveVariables()
{
CreateSensitiveVariableFile();
CreateInSensitiveVariableFile();
var result = new CalamariVariableDictionary(insensitiveVariablesFileName, sensitiveVariablesFileName, encryptionPassword);
Assert.AreEqual("sensitiveVariableValue", result.Get("sensitiveVariableName"));
Assert.AreEqual("insensitiveVariableValue", result.Get("insensitiveVariableName"));
}
public void SetUp()
{
fileSystem = Substitute.For<ICalamariFileSystem>();
variables = new CalamariVariableDictionary();
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, StagingDirectory);
deployment = new RunningDeployment(StagingDirectory, variables);
convention = new ChooseCloudServiceConfigurationFileConvention(fileSystem);
}
public void SetUp()
{
variables = new CalamariVariableDictionary();
fileSystem = Substitute.For<ICalamariFileSystem>();
iis = Substitute.For<IInternetInformationServer>();
deployment = new RunningDeployment("C:\\packages", variables)
{
StagingDirectory = stagingDirectory
};
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
var variables = new CalamariVariableDictionary(variablesFile, sensitiveVariablesFile, sensitiveVariablesPassword);
variables.EnrichWithEnvironmentVariables();
variables.LogVariables();
return InvokeScript(variables);
}
public CommandResult Execute(string scriptFile, CalamariVariableDictionary variables, ICommandLineRunner commandLineRunner)
{
var powerShellEngine = new PowerShellScriptEngine();
if (variables.Get(SpecialVariables.Account.AccountType) == "AzureSubscription")
{
return new AzurePowerShellContext().ExecuteScript(powerShellEngine, scriptFile, variables, commandLineRunner);
}
return powerShellEngine.Execute(scriptFile, variables, commandLineRunner);
}
private VariableDictionary AddEnvironmentVariables()
{
var variables = new CalamariVariableDictionary();
var convention = new ContributeEnvironmentVariablesConvention();
convention.Install(new RunningDeployment("C:\\Package.nupkg", variables));
Assert.That(variables.GetNames().Count, Is.GreaterThan(3));
Assert.That(variables.GetRaw(SpecialVariables.Tentacle.Agent.InstanceName), Is.EqualTo("#{env:TentacleInstanceName}"));
return variables;
}
public void SetUp()
{
fileSystem = Substitute.For<ICalamariFileSystem>();
configurationTransformer = Substitute.For<IConfigurationTransformer>();
variables = new CalamariVariableDictionary();
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, stagingDirectory);
deployment = new RunningDeployment("C:\\packages", variables);
}
public void ShouldIncludeCleartextSensitiveVariables()
{
CreateSensitiveVariableFile();
var sensitiveVariables = new Dictionary<string, string> { {"sensitiveVariableName", "sensitiveVariableValue"} };
File.WriteAllText(sensitiveVariablesFileName, JsonConvert.SerializeObject(sensitiveVariables));
var result = new CalamariVariableDictionary(insensitiveVariablesFileName, sensitiveVariablesFileName, null);
Assert.AreEqual("sensitiveVariableValue", result.Get("sensitiveVariableName"));
Assert.AreEqual("insensitiveVariableValue", result.Get("insensitiveVariableName"));
}
private int InvokeScript(CalamariVariableDictionary variables)
{
if (!File.Exists(scriptFile))
throw new CommandException("Could not find script file: " + scriptFile);
var scriptEngine = new CombinedScriptEngine();
var runner = new CommandLineRunner(
new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables)));
var result = scriptEngine.Execute(scriptFile, variables, runner);
return result.ExitCode;
}
static IEnumerable<string> GetVariableSwitchConditions(CalamariVariableDictionary variables)
{
return variables.GetNames().Select(variable =>
{
var variableValue = variables.IsSensitive(variable)
? DecryptValueCommand(variables.Get(variable))
: string.Format("decode_servicemessagevalue \"{0}\"", EncodeValue(variables.Get(variable)));
return string.Format(" \"{1}\"){0} {2} ;;{0}", Environment.NewLine, EncodeValue(variable), variableValue);
});
}
public void SetUp()
{
fileSystem = Substitute.For<ICalamariFileSystem>();
substituter = Substitute.For<IFileSubstituter>();
variables = new CalamariVariableDictionary();
deployment = new RunningDeployment(TestEnvironment.ConstructRootedPath("packages"), variables)
{
StagingDirectory = StagingDirectory
};
}
public void SetUp()
{
extractor = Substitute.For<IPackageExtractor>();
extractor.GetMetadata(PackageLocation).Returns(new PackageMetadata { Id = "Acme.Web", Version = "1.0.0" });
fileSystem = Substitute.For<ICalamariFileSystem>();
fileSystem.RemoveInvalidFileNameChars(Arg.Any<string>()).Returns(c => c.Arg<string>().Replace("!", ""));
variables = new CalamariVariableDictionary();
convention = new ExtractPackageToApplicationDirectoryConvention(extractor, fileSystem, new SystemSemaphore());
}
public void SetUp()
{
fileSystem = new WindowsPhysicalFileSystem();
configurationTransformer = Substitute.For<IConfigurationTransformer>();
var deployDirectory = BuildConfigPath(null);
variables = new CalamariVariableDictionary();
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, deployDirectory);
deployment = new RunningDeployment(deployDirectory, variables);
}
private static string DeclareVariables(CalamariVariableDictionary variables)
{
var output = new StringBuilder();
WriteScriptModules(variables, output);
output.AppendLine();
WriteVariableDictionary(variables, output);
output.AppendLine();
WriteLocalVariables(variables, output);
return output.ToString();
}
static string WriteVariableDictionary(CalamariVariableDictionary variables)
{
var builder = new StringBuilder();
foreach (var variable in variables.GetNames())
{
var variableValue = variables.IsSensitive(variable)
? EncryptVariable(variables.Get(variable))
: EncodeValue(variables.Get(variable));
builder.Append("\t\t\tthis[").Append(EncodeValue(variable)).Append("] = ").Append(variableValue).AppendLine(";");
}
return builder.ToString();
}
public void SetUp()
{
fileSystem = Substitute.For<ICalamariFileSystem>();
scriptEngine = Substitute.For<IScriptEngine>();
commandLineRunner = Substitute.For<ICommandLineRunner>();
scriptEngine.GetSupportedExtensions().Returns(new string[] { "ps1" });
variables = new CalamariVariableDictionary();
variables.Set(SpecialVariables.Package.EnabledFeatures, SpecialVariables.Features.CustomScripts);
deployment = new RunningDeployment("C:\\packages", variables) { StagingDirectory = stagingDirectory };
}
public CommandResult Execute(string scriptFile, CalamariVariableDictionary variables, ICommandLineRunner commandLineRunner)
{
var workingDirectory = Path.GetDirectoryName(scriptFile);
var executable = PowerShellBootstrapper.PathToPowerShellExecutable();
var boostrapFile = PowerShellBootstrapper.PrepareBootstrapFile(scriptFile, variables);
var arguments = PowerShellBootstrapper.FormatCommandArguments(boostrapFile);
using (new TemporaryFile(boostrapFile))
{
var invocation = new CommandLineInvocation(executable, arguments, workingDirectory);
return commandLineRunner.Execute(invocation);
}
}
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 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 conventions = new List<IConvention>
{
new ContributeEnvironmentVariablesConvention(),
new LogVariablesConvention(),
new ExtractPackageToStagingDirectoryConvention(new LightweightPackageExtractor(), fileSystem),
new ConfiguredScriptConvention(DeploymentStages.PreDeploy, scriptEngine, fileSystem, commandLineRunner),
new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner),
new SubstituteInFilesConvention(fileSystem, substituter),
new ConfigurationTransformsConvention(fileSystem, configurationTransformer),
new ConfigurationVariablesConvention(fileSystem, replacer),
new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner),
new ConfiguredScriptConvention(DeploymentStages.Deploy, scriptEngine, fileSystem, commandLineRunner),
new AzureWebAppConvention(variables),
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 CommandResult Execute(string scriptFile, CalamariVariableDictionary variables, ICommandLineRunner commandLineRunner)
{
var workingDirectory = Path.GetDirectoryName(scriptFile);
var executable = ScriptCSBootstrapper.FindScriptCSExecutable();
var configurationFile = ScriptCSBootstrapper.PrepareConfigurationFile(workingDirectory, variables);
var boostrapFile = ScriptCSBootstrapper.PrepareBootstrapFile(scriptFile, configurationFile, workingDirectory);
var arguments = ScriptCSBootstrapper.FormatCommandArguments(boostrapFile);
using (new TemporaryFile(configurationFile))
using (new TemporaryFile(boostrapFile))
{
return commandLineRunner.Execute(new CommandLineInvocation(executable, arguments, workingDirectory));
}
}
public static string PrepareConfigurationFile(string workingDirectory, CalamariVariableDictionary variables)
{
var configurationFile = Path.Combine(workingDirectory, "Configure." + Guid.NewGuid().ToString().Substring(10) + ".csx");
var builder = new StringBuilder(BootstrapScriptTemplate);
builder.Replace("{{VariableDeclarations}}", WriteVariableDictionary(variables));
using (var writer = new StreamWriter(configurationFile, false, Encoding.UTF8))
{
writer.Write(builder.ToString());
writer.Flush();
}
File.SetAttributes(configurationFile, FileAttributes.Hidden);
return configurationFile;
}
public static string PrepareConfigurationFile(string workingDirectory, CalamariVariableDictionary variables)
{
var configurationFile = Path.Combine(workingDirectory, "Configure." + Guid.NewGuid().ToString().Substring(10) + ".sh");
var builder = new StringBuilder(BootstrapScriptTemplate);
builder.Replace("#### VariableDeclarations ####", string.Join(Environment.NewLine, GetVariableSwitchConditions(variables)));
using (var writer = new StreamWriter(configurationFile, false, Encoding.ASCII))
{
writer.Write(builder.Replace(WindowsNewLine, Environment.NewLine));
writer.Flush();
}
File.SetAttributes(configurationFile, FileAttributes.Hidden);
return configurationFile;
}
public void SetUp()
{
fileSystem = Substitute.For<ICalamariFileSystem>();
packageUploader = Substitute.For<IAzurePackageUploader>();
credentialsFactory = Substitute.For<ISubscriptionCloudCredentialsFactory>();
credentialsFactory.GetCredentials(azureSubscriptionId, certificateThumbprint, certificateBytes)
.Returns(new FakeSubscriptionCloudCredentials(azureSubscriptionId));
variables = new CalamariVariableDictionary();
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, stagingDirectory);
variables.Set(SpecialVariables.Action.Azure.SubscriptionId, azureSubscriptionId);
variables.Set(SpecialVariables.Action.Azure.CertificateThumbprint, certificateThumbprint);
variables.Set(SpecialVariables.Action.Azure.CertificateBytes, certificateBytes);
variables.Set(SpecialVariables.Action.Azure.StorageAccountName, storageAccountName);
deployment = new RunningDeployment(stagingDirectory, variables);
convention = new UploadAzureCloudServicePackageConvention(fileSystem, packageUploader, credentialsFactory);
}
public CommandResult ExecuteScript(IScriptEngine scriptEngine, string scriptFile, CalamariVariableDictionary variables, ICommandLineRunner commandLineRunner)
{
var workingDirectory = Path.GetDirectoryName(scriptFile);
variables.Set("OctopusAzureTargetScript", scriptFile);
// If the Azure PowerShell module to use has not been explicitly configured, then default to the version
// bundled with Calamari
SetOutputVariable(SpecialVariables.Action.Azure.Output.ModulePath,
variables.Get(SpecialVariables.Action.Azure.PowerShellModulePath, BuiltInAzurePowershellModulePath), variables);
SetOutputVariable(SpecialVariables.Action.Azure.Output.SubscriptionId, variables.Get(SpecialVariables.Action.Azure.SubscriptionId), variables);
SetOutputVariable(SpecialVariables.Action.Azure.Output.SubscriptionName, variables.Get(SpecialVariables.Account.Name), variables);
using (new TemporaryFile(CreateAzureCertificate(workingDirectory, variables)))
using (var contextScriptFile = new TemporaryFile(CreateContextScriptFile(workingDirectory)))
{
return scriptEngine.Execute(contextScriptFile.FilePath, variables, commandLineRunner);
}
}
public static string PrepareBootstrapFile(string targetScriptFile, CalamariVariableDictionary variables)
{
var parent = Path.GetDirectoryName(Path.GetFullPath(targetScriptFile));
var name = Path.GetFileName(targetScriptFile);
var bootstrapFile = Path.Combine(parent, "Bootstrap." + name);
var builder = new StringBuilder(BootstrapScriptTemplate);
builder.Replace("{{TargetScriptFile}}", targetScriptFile.Replace("'", "''"));
builder.Replace("{{VariableDeclarations}}", DeclareVariables(variables));
using (var writer = new StreamWriter(bootstrapFile, false, new UTF8Encoding(true)))
{
writer.WriteLine(builder.ToString());
writer.Flush();
}
File.SetAttributes(bootstrapFile, FileAttributes.Hidden);
return bootstrapFile;
}
public override int Execute(string[] commandLineArguments)
{
Options.Parse(commandLineArguments);
Guard.NotNullOrWhiteSpace(retentionPolicySet, "No retention-policy-set was specified. Please pass --retentionPolicySet \"Environments-2/projects-161/Step-Package B/machines-65/<default>\"");
if (days <=0 && releases <= 0)
throw new CommandException("A value must be provided for either --days or --releases");
var variables = new CalamariVariableDictionary();
variables.EnrichWithEnvironmentVariables();
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var deploymentJournal = new DeploymentJournal(fileSystem, new SystemSemaphore(), variables);
var clock = new SystemClock();
var retentionPolicy = new RetentionPolicy(fileSystem, deploymentJournal, clock);
retentionPolicy.ApplyRetentionPolicy(retentionPolicySet, days, releases);
return 0;
}