public void ShouldDeployInParallel()
{
var extractionDirectories = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var errors = new List <Exception>();
using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage("Acme.Web", "1.0.0")))
{
var threads = Enumerable.Range(0, 4).Select(i => new Thread(new ThreadStart(delegate
{
try
{
CalamariResult result;
using (var variablesFile = new TemporaryFile(Path.GetTempFileName()))
{
variables.Save(variablesFile.FilePath);
result = Invoke(Calamari()
.Action("deploy-package")
.Argument("package", acmeWeb.FilePath)
.Argument("variables", variablesFile.FilePath));
}
result.AssertZero();
var extracted = result.GetOutputForLineContaining("Extracting package to: ");
result.AssertOutput("Extracted 7 files");
lock (extractionDirectories)
{
if (!extractionDirectories.Contains(extracted))
{
extractionDirectories.Add(extracted);
}
else
{
Assert.Fail("The same installation directory was used twice: " + extracted);
}
}
}
catch (Exception ex)
{
errors.Add(ex);
}
}))).ToList();
foreach (var thread in threads)
{
thread.Start();
}
foreach (var thread in threads)
{
thread.Join();
}
}
var allErrors = string.Join(Environment.NewLine, errors.Select(e => e.ToString()));
Assert.That(allErrors, Is.EqualTo(""), allErrors);
}
public void ShouldNotSubstituteVariablesInNonPackagedScript()
{
// Use a temp file for the script to avoid mutating the script file for other tests
var scriptFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N") + ".ps1");
File.WriteAllText(scriptFile, "Write-Host \"Hello #{Octopus.Environment.Name}!\"");
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Environment.Name", "Production");
variables.Save(variablesFile);
using (new TemporaryFile(scriptFile))
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", scriptFile)
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("Hello #{Octopus.Environment.Name}!");
AssertPSEdition(output);
}
}
public void ShouldCustomizePowerShellVersionIfRequested(string customPowerShellVersion, string expectedLogMessage)
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Action.PowerShell.CustomPowerShellVersion, customPowerShellVersion);
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
// Let's just use the Hello.ps1 script for something simples
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "Hello.ps1"))
.Argument("variables", variablesFile));
if (output.CapturedOutput.AllMessages
.Select(line => new string(line.ToCharArray().Where(c => c != '\u0000').ToArray()))
.Any(line => line.Contains(".NET Framework is not installed")))
{
Assert.Inconclusive("Version 2.0 of PowerShell is not supported on this machine");
}
output.AssertSuccess();
output.AssertOutput(expectedLogMessage);
output.AssertOutput("Hello!");
}
}
public void ShouldCallWithNoProfileWhenVariableSet(string executeWithoutProfile, bool calledWithNoProfile)
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
if (executeWithoutProfile != null)
{
variables.Set(SpecialVariables.Action.PowerShell.ExecuteWithoutProfile, executeWithoutProfile);
}
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "Profile.ps1"))
.Argument("variables", variablesFile));
output.AssertSuccess();
var allOutput = string.Join(Environment.NewLine, output.CapturedOutput.Infos);
// Need to check for "-NoProfile -NoLogo" not just "-NoProfile" because when
// run via Cake we end up with the outer Powershell call included in the
// output too, which has a -NoProfile flag.
Assert.That(allOutput.Contains("-NoProfile -NoLo") == calledWithNoProfile);
AssertPSEdition(output);
}
}
public void Deploy()
{
OctopusTestAzureSubscription.IgnoreIfCertificateNotInstalled();
var nugetPackageFile = PackageBuilder.BuildSamplePackage("Octopus.Sample.AzureCloudService", "1.0.0");
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
OctopusTestAzureSubscription.PopulateVariables(variables);
OctopusTestCloudService.PopulateVariables(variables);
variables.Set(SpecialVariables.Action.Azure.Slot, "Staging");
variables.Set(SpecialVariables.Action.Azure.SwapIfPossible, false.ToString());
variables.Set(SpecialVariables.Action.Azure.UseCurrentInstanceCount, false.ToString());
variables.Set(SpecialVariables.Action.Name, "AzureCloudService");
variables.Set(SpecialVariables.Release.Number, "1.0.0");
// Disable cspkg extraction
variables.Set(SpecialVariables.Action.Azure.CloudServicePackageExtractionDisabled, true.ToString());
fileSystem = new WindowsPhysicalFileSystem();
stagingDirectory = Path.GetTempPath();
variables.Set(SpecialVariables.Action.Azure.PackageExtractionPath, stagingDirectory);
variables.Save(variablesFile);
result = Invoke(
Calamari()
.Action("deploy-azure-cloud-service")
.Argument("package", nugetPackageFile)
.Argument("variables", variablesFile));
}
public void ShouldSubstituteVariablesInPackagedScripts()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Environment.Name", "Production");
variables.Set(SpecialVariables.Action.Script.ScriptFileName, "Deploy.ps1");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("package", GetFixtureResouce("Packages", "PackagedScript.1.0.0.zip"))
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("Extracting package");
output.AssertOutput("Performing variable substitution");
output.AssertOutput("OctopusParameter: Production");
output.AssertOutput("InlineVariable: Production");
output.AssertOutput("VariableSubstitution: Production");
AssertPSEdition(output);
}
}
void CreateInSensitiveVariableFile()
{
var firstInsensitiveVariableSet = new VariableDictionary(firstInsensitiveVariablesFileName);
firstInsensitiveVariableSet.Set("firstInsensitiveVariableName", "firstInsensitiveVariableValue");
firstInsensitiveVariableSet.Save();
}
public void Deploy()
{
OctopusTestAzureSubscription.IgnoreIfCertificateNotInstalled();
var nugetPackageFile = PackageBuilder.BuildSamplePackage("Octopus.Sample.AzureCloudService", "1.0.0");
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
OctopusTestAzureSubscription.PopulateVariables(variables);
OctopusTestCloudService.PopulateVariables(variables);
variables.Set(SpecialVariables.Action.Azure.Slot, "Staging");
variables.Set(SpecialVariables.Action.Azure.SwapIfPossible, false.ToString());
variables.Set(SpecialVariables.Action.Azure.UseCurrentInstanceCount, false.ToString());
variables.Set(SpecialVariables.Action.Name, "AzureCloudService");
variables.Set(SpecialVariables.Release.Number, "1.0.0");
// Disable cspkg extraction
variables.Set(SpecialVariables.Action.Azure.CloudServicePackageExtractionDisabled, true.ToString());
fileSystem = new WindowsPhysicalFileSystem();
stagingDirectory = Path.GetTempPath();
variables.Set(SpecialVariables.Action.Azure.PackageExtractionPath, stagingDirectory);
variables.Save(variablesFile);
result = Invoke(
Calamari()
.Action("deploy-azure-cloud-service")
.Argument("package", nugetPackageFile)
.Argument("variables", variablesFile));
}
public void ShouldSupportRoundTripping()
{
var temp = Path.GetTempFileName();
var parent = new VariableDictionary();
parent.Set("Name", "Web01");
parent.Set("Port", "10933");
parent.Set("Hello world", "This is a \"string\"!@#$");
parent.Save(temp);
var child = new VariableDictionary(temp);
child["Name"].Should().Be("Web01");
child["Port"].Should().Be("10933");
child["Hello world"].Should().Be("This is a \"string\"!@#$");
// Since this variable dictionary was loaded from disk, setting variables
// will automatically persist the change
child["SomeVariable"] = "Hello";
parent["SomeVariable"].Should().BeNull();
// If one process calls another (using the same variables file), the parent process should
// reload its variables once the child finishes.
parent.Reload();
parent["SomeVariable"].Should().Be("Hello");
File.Delete(temp);
}
private void CreateInSensitiveVariableFile()
{
var insensitiveVariables = new VariableDictionary(insensitiveVariablesFileName);
insensitiveVariables.Set("insensitiveVariableName", "insensitiveVariableValue");
insensitiveVariables.Save();
}
public void ShouldNotSubstituteVariablesByDefault()
{
// Use a temp file for the script because the file would have been mutated by other tests
var scriptFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N") + ".ps1");
File.WriteAllText(scriptFile, "Write-Host \"Hello #{Octopus.Environment.Name}!\"");
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Environment.Name", "Production");
variables.Save(variablesFile);
using (new TemporaryFile(scriptFile))
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", scriptFile)
.Argument("variables", variablesFile));
output.AssertZero();
output.AssertOutput("Hello #{Octopus.Environment.Name}!");
}
}
public void ShouldPrintVariables()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Variable1", "ABC");
variables.Set("Variable2", "DEF");
variables.Set("Variable3", "GHI");
variables.Set("Foo_bar", "Hello");
variables.Set("Host", "Never");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "PrintVariables.ps1"))
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("V1= ABC");
output.AssertOutput("V2= DEF");
output.AssertOutput("V3= GHI");
output.AssertOutput("FooBar= Hello"); // Legacy - '_' used to be removed
output.AssertOutput("Foo_Bar= Hello"); // Current - '_' is valid in PowerShell
}
}
IEnumerable <string> ExecuteAndReturnLogOutput(Action <VariableDictionary> populateVariables, string folderName, params Type[] commandTypes)
{
void Copy(string sourcePath, string destinationPath)
{
foreach (var dirPath in Directory.EnumerateDirectories(sourcePath, "*", SearchOption.AllDirectories))
{
Directory.CreateDirectory(dirPath.Replace(sourcePath, destinationPath));
}
foreach (var newPath in Directory.EnumerateFiles(sourcePath, "*.*", SearchOption.AllDirectories))
{
File.Copy(newPath, newPath.Replace(sourcePath, destinationPath), true);
}
}
using (var currentDirectory = TemporaryDirectory.Create())
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(TerraformSpecialVariables.Calamari.TerraformCliPath, Path.GetDirectoryName(customTerraformExecutable));
variables.Set(SpecialVariables.OriginalPackageDirectoryPath, currentDirectory.DirectoryPath);
variables.Set(TerraformSpecialVariables.Action.Terraform.CustomTerraformExecutable, customTerraformExecutable);
populateVariables(variables);
var terraformFiles = TestEnvironment.GetTestPath("Terraform", folderName);
Copy(terraformFiles, currentDirectory.DirectoryPath);
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
foreach (var commandType in commandTypes)
{
var sb = new StringBuilder();
Log.StdOut = new IndentedTextWriter(new StringWriter(sb));
var command = (ICommand)Activator.CreateInstance(commandType);
var result = command.Execute(new[] { "--variables", $"{variablesFile}" });
result.Should().Be(0);
var output = sb.ToString();
Console.WriteLine(output);
yield return(output);
}
}
}
}
CalamariResult DeployPackage(string packageName)
{
using (var variablesFile = new TemporaryFile(Path.GetTempFileName()))
using (var acmeWeb = new TemporaryFile(PackageBuilder.BuildSamplePackage(packageName, "1.0.0")))
{
variables.Save(variablesFile.FilePath);
return(Invoke(Calamari()
.Action("deploy-azure-web")
.Argument("package", acmeWeb.FilePath)
.Argument("variables", variablesFile.FilePath)));
}
}
CalamariResult ExecuteCommand(VariableDictionary variables, string extensions = "")
{
using (var variablesFile = new TemporaryFile(Path.GetTempFileName()))
{
variables.Save(variablesFile.FilePath);
return(Invoke(Calamari()
.Action("execute-manifest")
.Argument("variables", variablesFile.FilePath)
.Argument("sensitiveVariablesPassword", "GB8KdBqYRlgAON9ISUPdnQ==")
.Argument("extensions", extensions)));
}
}
private int InvokeScript(CalamariVariableDictionary variables, VariableDictionary outputVariables)
{
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), new ServiceMessageCommandOutput(outputVariables)));
var result = scriptEngine.Execute(scriptFile, variables, runner);
outputVariables.Save();
return result.ExitCode;
}
string Upload(string packageName, List <S3FileSelectionProperties> fileSelections)
{
var bucketKeyPrefix = $"calamaritest/{Guid.NewGuid():N}/";
fileSelections.ForEach(properties =>
{
if (properties is S3MultiFileSelectionProperties multiFileSelectionProperties)
{
multiFileSelectionProperties.BucketKeyPrefix = bucketKeyPrefix;
}
if (properties is S3SingleFileSelectionProperties singleFileSelectionProperties)
{
singleFileSelectionProperties.BucketKeyPrefix = bucketKeyPrefix;
}
});
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Action.AwsAccount.Variable", "AWSAccount");
variables.Set("AWSAccount.AccessKey", Environment.GetEnvironmentVariable("AWS_Calamari_Access"));
variables.Set("AWSAccount.SecretKey", Environment.GetEnvironmentVariable("AWS_Calamari_Secret"));
variables.Set("Octopus.Action.Aws.Region", RegionEndpoint.APSoutheast1.SystemName);
variables.Set(AwsSpecialVariables.S3.FileSelections,
JsonConvert.SerializeObject(fileSelections, GetEnrichedSerializerSettings()));
variables.Save(variablesFile);
var packageDirectory = TestEnvironment.GetTestPath("AWS", "S3", packageName);
using (var package =
new TemporaryFile(PackageBuilder.BuildSimpleZip(packageName, "1.0.0", packageDirectory)))
using (new TemporaryFile(variablesFile))
{
var command = new UploadAwsS3Command();
var result = command.Execute(new[] {
"--package", $"{package.FilePath}",
"--variables", $"{variablesFile}",
"--bucket", BucketName,
"--targetMode", S3TargetMode.FileSelections.ToString()
});
result.Should().Be(0);
}
return(bucketKeyPrefix);
}
public void ShouldIncludeSensitiveVariables()
{
const string encryptionPassword = "******";
var insensitiveVariables = new VariableDictionary(insensitiveVariablesFileName);
insensitiveVariables.Set("insensitiveVariableName", "insensitiveVariableValue");
insensitiveVariables.Save();
var sensitiveVariables = new Dictionary<string, string>
{
{"sensitiveVariableName", "sensitiveVariableValue"}
};
var salt = CreateEncryptedSensitiveVariablesFile(sensitiveVariablesFileName, encryptionPassword, sensitiveVariables);
var result = subject.IncludeSensitiveVariables(insensitiveVariablesFileName, encryptionPassword, salt);
Assert.AreEqual("sensitiveVariableValue", result.Get("sensitiveVariableName"));
Assert.AreEqual("insensitiveVariableValue", result.Get("insensitiveVariableName"));
}
public void ShoulPassOnStdInfoWithTreatScriptWarningsAsErrors()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Action.FailScriptOnErrorOutput", "True");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("variables", variablesFile)
.Argument("script", GetFixtureResouce("Scripts", "Hello.ps1")));
output.AssertSuccess();
output.AssertOutput("Hello!");
}
}
public void ShoulFailOnStdErrWithTreatScriptWarningsAsErrors()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Action.FailScriptOnErrorOutput", "True");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("sensitiveVariables", variablesFile)
.Argument("script", GetFixtureResouce("Scripts", "stderr.sh")));
output.AssertFailure();
output.AssertErrorOutput("hello");
}
}
public void ShouldSupportModulesInVariables()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Script.Module[Foo]", "function SayHello() { Write-Host \"Hello from module!\" }");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "UseModule.ps1"))
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("Hello from module!");
}
}
public void ShouldSetAzureSubscription()
{
// If the Azure test certificate is not installed, we cannot run, so ignore
OctopusTestAzureSubscription.IgnoreIfCertificateNotInstalled();
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Account.AccountType, "AzureSubscription");
variables.Set(SpecialVariables.Account.Name, "AzureTest");
variables.Save(variablesFile);
OctopusTestAzureSubscription.PopulateVariables(variables);
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("AzureSubscription.ps1"))
.Argument("variables", variablesFile));
output.AssertZero();
output.AssertOutput("Current subscription ID: " + OctopusTestAzureSubscription.AzureSubscriptionId);
}
protected CalamariResult TransferPackage()
{
var variables = new VariableDictionary
{
[SpecialVariables.Package.TransferPath] = CustomDirectory,
[SpecialVariables.Package.OriginalFileName] = Path.GetFileName(nupkgFile.FilePath),
[SpecialVariables.Tentacle.CurrentDeployment.PackageFilePath] = nupkgFile.FilePath,
[SpecialVariables.Action.Name] = "MyAction",
[SpecialVariables.Machine.Name] = "MyMachine"
};
using (var variablesFile = new TemporaryFile(Path.GetTempFileName()))
{
variables.Save(variablesFile.FilePath);
return(Invoke(Calamari()
.Action("transfer-package")
.Argument("variables", variablesFile.FilePath)));
}
}
public void ShouldCallHelloDirectValue()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Name", "direct value");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "Hello.fsx"))
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("Hello direct value");
}
}
public void ShouldNotCallWithNoProfileWhenVariableNotSet()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Action.PowerShell.ExecuteWithoutProfile, "true");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "Profile.ps1"))
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("-NoProfile");
}
}
public void ShouldSetAzureSubscription()
{
// If the Azure test certificate is not installed, we cannot run, so ignore
OctopusTestAzureSubscription.IgnoreIfCertificateNotInstalled();
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Account.AccountType, "AzureSubscription");
variables.Set(SpecialVariables.Account.Name, "AzureTest");
variables.Save(variablesFile);
OctopusTestAzureSubscription.PopulateVariables(variables);
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("AzureSubscription.ps1"))
.Argument("variables", variablesFile));
output.AssertZero();
output.AssertOutput("Current subscription ID: " + OctopusTestAzureSubscription.AzureSubscriptionId);
}
public void ShouldAllowPlatformSpecificScriptToExecute()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Action.Script.ScriptBodyBySyntax(ScriptSyntax.PowerShell), "Write-Host Hello Powershell");
variables.Set(SpecialVariables.Action.Script.ScriptBodyBySyntax(ScriptSyntax.CSharp), "Write-Host Hello CSharp");
variables.Set(SpecialVariables.Action.Script.ScriptBodyBySyntax(ScriptSyntax.Bash), "echo Hello Bash");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput(CalamariEnvironment.IsRunningOnWindows ? "Hello Powershell" : "Hello Bash");
}
}
public void ShouldFailIfAModuleHasASyntaxError()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Script.Module[Foo]", "function SayHello() { Write-Host \"Hello from module! }");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "UseModule.ps1"))
.Argument("variables", variablesFile));
output.AssertFailure();
output.AssertErrorOutput("ParserError", true);
output.AssertErrorOutput("is missing the terminator", true);
}
}
public void ShouldRunBashInsteadOfPowerShell()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Action.Script.ScriptBodyBySyntax(ScriptSyntax.PowerShell), "Write-Host Hello Powershell");
variables.Set(SpecialVariables.Action.Script.ScriptBodyBySyntax(ScriptSyntax.CSharp), "Write-Host Hello CSharp");
variables.Set(SpecialVariables.Action.Script.ScriptBodyBySyntax(ScriptSyntax.Bash), "echo Hello Bash");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("Hello Bash");
}
}
public void ShouldShowFriendlyErrorWithInvalidSyntaxInScriptModule()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Script.Module[Foo]", "function SayHello() { Write-Host \"Hello from module! }");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "UseModule.ps1"))
.Argument("variables", variablesFile));
output.AssertFailure();
output.AssertOutput("Failed to import Script Module 'Foo'");
output.AssertErrorOutput("Write-Host \"Hello from module!");
output.AssertErrorOutput("The string is missing the terminator: \".");
}
}
public void ShouldCallHello()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Name", "Paul");
variables.Set("Variable2", "DEF");
variables.Set("Variable3", "GHI");
variables.Set("Foo_bar", "Hello");
variables.Set("Host", "Never");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "hello.sh"))
.Argument("variables", variablesFile));
output.AssertZero();
output.AssertOutput("Hello Paul");
}
}
public void ShouldCustomizePowerShellVersionIfRequested(string customPowerShellVersion, string expectedLogMessage)
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Action.PowerShell.CustomPowerShellVersion, customPowerShellVersion);
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
// Let's just use the Hello.ps1 script for something simples
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "Hello.ps1"))
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput(expectedLogMessage);
output.AssertOutput("Hello!");
}
}
protected (CalamariResult result, VariableDictionary variables) RunScript(string scriptName,
Dictionary <string, string> additionalVariables = null,
Dictionary <string, string> additionalParameters = null,
string sensitiveVariablesPassword = null)
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set(SpecialVariables.Action.Script.ScriptFileName, scriptName);
variables.Set(SpecialVariables.Action.Script.ScriptBody, File.ReadAllText(GetFixtureResouce("Scripts", scriptName)));
variables.Set(SpecialVariables.Action.Script.Syntax, ScriptTypeExtensions.FileNameToScriptType(scriptName).ToString());
additionalVariables?.ToList().ForEach(v => variables[v.Key] = v.Value);
using (new TemporaryFile(variablesFile))
{
var cmdBase = Calamari()
.Action("run-script");
if (sensitiveVariablesPassword == null)
{
variables.Save(variablesFile);
cmdBase = cmdBase.Argument("variables", variablesFile);
}
else
{
variables.SaveEncrypted(sensitiveVariablesPassword, variablesFile);
cmdBase = cmdBase.Argument("sensitiveVariables", variablesFile)
.Argument("sensitiveVariablesPassword", sensitiveVariablesPassword);
}
cmdBase = (additionalParameters ?? new Dictionary <string, string>()).Aggregate(cmdBase, (cmd, param) => cmd.Argument(param.Key, param.Value));
var output = Invoke(cmdBase, variables);
return(output, variables);
}
}
public void ShouldCallHello()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Name", "Paul");
variables.Set("Variable2", "DEF");
variables.Set("Variable3", "GHI");
variables.Set("Foo_bar", "Hello");
variables.Set("Host", "Never");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "hello.sh"))
.Argument("variables", variablesFile));
output.AssertSuccess();
output.AssertOutput("Hello Paul");
}
}
public void ShouldCallWithNoProfileWhenVariableSet(string executeWithoutProfile, bool calledWithNoProfile)
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
if (executeWithoutProfile != null)
{
variables.Set(SpecialVariables.Action.PowerShell.ExecuteWithoutProfile, executeWithoutProfile);
}
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "Profile.ps1"))
.Argument("variables", variablesFile));
output.AssertSuccess();
var allOutput = string.Join(Environment.NewLine, output.CapturedOutput.Infos);
Assert.That(allOutput.Contains("-NoProfile") == calledWithNoProfile);
}
}
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 outputVariables = new VariableDictionary(outputVariablesFile);
variables.MergeWith(outputVariables);
var scriptCapability = new CombinedScriptEngine();
var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors));
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), new ServiceMessageCommandOutput(outputVariables)));
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 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),
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
try
{
conventionRunner.RunConventions();
outputVariables.Save();
if (!deployment.SkipJournal)
journal.AddJournalEntry(new JournalEntry(deployment, true));
}
catch (Exception)
{
if (!deployment.SkipJournal)
journal.AddJournalEntry(new JournalEntry(deployment, false));
throw;
}
return 0;
}
public void ShouldSupportModulesInVariables()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Octopus.Script.Module[Foo]", "function SayHello() { Write-Host \"Hello from module!\" }");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "UseModule.ps1"))
.Argument("variables", variablesFile));
output.AssertZero();
output.AssertOutput("Hello from module!");
}
}
public void ShouldPrintVariables()
{
var variablesFile = Path.GetTempFileName();
var variables = new VariableDictionary();
variables.Set("Variable1", "ABC");
variables.Set("Variable2", "DEF");
variables.Set("Variable3", "GHI");
variables.Set("Foo_bar", "Hello");
variables.Set("Host", "Never");
variables.Save(variablesFile);
using (new TemporaryFile(variablesFile))
{
var output = Invoke(Calamari()
.Action("run-script")
.Argument("script", GetFixtureResouce("Scripts", "PrintVariables.ps1"))
.Argument("variables", variablesFile));
output.AssertZero();
output.AssertOutput("V1= ABC");
output.AssertOutput("V2= DEF");
output.AssertOutput("V3= GHI");
output.AssertOutput("FooBar= Hello"); // Legacy - '_' used to be removed
output.AssertOutput("Foo_Bar= Hello"); // Current - '_' is valid in PowerShell
}
}
private void CreateSensitiveVariableFile()
{
var insensitiveVariables = new VariableDictionary(insensitiveVariablesFileName);
insensitiveVariables.Set("insensitiveVariableName", "insensitiveVariableValue");
insensitiveVariables.Save();
}