public CommandResult ExecuteScript(Script script, ScriptSyntax scriptSyntax, ICommandLineRunner commandLineRunner, Dictionary <string, string>?environmentVars)
{
if (NextWrapper == null)
{
throw new InvalidOperationException("NextWrapper has not been set.");
}
var workingDirectory = Path.GetDirectoryName(script.File);
if (workingDirectory == null)
{
throw new InvalidOperationException("Working directory has not been set correctly.");
}
variables.Set("OctopusFunctionAppenderTargetScript", $"{script.File}");
variables.Set("OctopusFunctionAppenderTargetScriptParameters", script.Parameters);
var copyScriptFile = variables.Get(ScriptFunctionsVariables.CopyScriptWrapper);
var scriptFile = CreateContextScriptFile(workingDirectory, scriptSyntax);
if (!String.IsNullOrEmpty(copyScriptFile))
{
var destinationFile = copyScriptFile;
if (!Path.IsPathRooted(copyScriptFile))
{
destinationFile = Path.Combine(workingDirectory, copyScriptFile);
}
File.Copy(scriptFile, destinationFile, true);
}
using (var contextScriptFile = new TemporaryFile(scriptFile))
{
return(NextWrapper.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
}
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);
}
variables.Set(SpecialVariables.Action.Azure.CloudServicePackagePath, packageFile);
variables.Set(KnownVariables.OriginalPackageDirectoryPath, !string.IsNullOrWhiteSpace(destinationDirectory) ? destinationDirectory : Path.GetDirectoryName(packageFile));
var fileSystem = new WindowsPhysicalFileSystem();
var conventions = new List <IConvention>
{
new EnsureCloudServicePackageIsCtpFormatConvention(fileSystem),
new ExtractAzureCloudServicePackageConvention(log, fileSystem),
};
var deployment = new RunningDeployment(packageFile, variables);
var conventionRunner = new ConventionProcessor(deployment, conventions);
conventionRunner.RunConventions();
return(0);
}
public static void SetOutputVariable(this IVariables variables, string name, string?value)
{
variables.Set(name, value);
// And set the output-variables.
// Assuming we are running in a step named 'DeployWeb' and are setting a variable named 'Foo'
// then we will set Octopus.Action[DeployWeb].Output.Foo
var actionName = variables.Get(ActionVariables.Name);
if (string.IsNullOrWhiteSpace(actionName))
{
return;
}
var actionScopedVariable = ActionVariables.GetOutputVariableName(actionName, name);
variables.Set(actionScopedVariable, value);
// And if we are on a machine named 'Web01'
// Then we will set Octopus.Action[DeployWeb].Output[Web01].Foo
var machineName = variables.Get(MachineVariables.Name);
if (string.IsNullOrWhiteSpace(machineName))
{
return;
}
var machineIndexedVariableName = ActionVariables.GetMachineIndexedOutputVariableName(actionName, machineName, name);
variables.Set(machineIndexedVariableName, value);
}
void WriteVariableScriptToFile()
{
if (!TryGetScriptFromVariables(out var scriptBody, out var relativeScriptFile, out var scriptSyntax) &&
!WasProvided(variables.Get(ScriptVariables.ScriptFileName)))
{
throw new CommandException($"Could not determine script to run. Please provide either a `{ScriptVariables.ScriptBody}` variable, " +
$"or a `{ScriptVariables.ScriptFileName}` variable.");
}
if (WasProvided(scriptBody))
{
var scriptFile = Path.GetFullPath(relativeScriptFile);
//Set the name of the script we are about to create to the variables collection for replacement later on
variables.Set(ScriptVariables.ScriptFileName, relativeScriptFile);
// If the script body was supplied via a variable, then we write it out to a file.
// This will be deleted with the working directory.
// Bash files need SheBang as first few characters. This does not play well with BOM characters
var scriptBytes = scriptSyntax == ScriptSyntax.Bash
? scriptBody.EncodeInUtf8NoBom()
: scriptBody.EncodeInUtf8Bom();
File.WriteAllBytes(scriptFile, scriptBytes);
}
}
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string> environmentVars)
{
// We only execute this hook if the connection endpoint has been set
if (!IsEnabled(scriptSyntax))
{
throw new InvalidOperationException(
"This script wrapper hook is not enabled, and should not have been run");
}
if (!ServiceFabricHelper.IsServiceFabricSdkKeyInRegistry())
{
throw new Exception("Could not find the Azure Service Fabric SDK on this server. This SDK is required before running Service Fabric commands.");
}
var workingDirectory = Path.GetDirectoryName(script.File);
variables.Set("OctopusFabricTargetScript", script.File);
variables.Set("OctopusFabricTargetScriptParameters", script.Parameters);
// Azure PS modules are required for looking up Azure environments (needed for AAD url lookup in Service Fabric world).
SetAzureModulesLoadingMethod(variables);
// Read thumbprint from our client cert variable (if applicable).
var securityMode = variables.Get(SpecialVariables.Action.ServiceFabric.SecurityMode);
var clientCertThumbprint = string.Empty;
if (securityMode == AzureServiceFabricSecurityMode.SecureClientCertificate.ToString())
{
var certificateVariable = GetMandatoryVariable(variables, SpecialVariables.Action.ServiceFabric.ClientCertVariable);
clientCertThumbprint = variables.Get($"{certificateVariable}.{CertificateVariables.Properties.Thumbprint}");
}
// Set output variables for our script to access.
SetOutputVariable("OctopusFabricConnectionEndpoint", variables.Get(SpecialVariables.Action.ServiceFabric.ConnectionEndpoint), variables);
SetOutputVariable("OctopusFabricSecurityMode", variables.Get(SpecialVariables.Action.ServiceFabric.SecurityMode), variables);
SetOutputVariable("OctopusFabricServerCertThumbprint", variables.Get(SpecialVariables.Action.ServiceFabric.ServerCertThumbprint), variables);
SetOutputVariable("OctopusFabricClientCertThumbprint", clientCertThumbprint, variables);
SetOutputVariable("OctopusFabricCertificateFindType", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateFindType, "FindByThumbprint"), variables);
SetOutputVariable("OctopusFabricCertificateFindValueOverride", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateFindValueOverride), variables);
SetOutputVariable("OctopusFabricCertificateStoreLocation", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateStoreLocation, "LocalMachine"), variables);
SetOutputVariable("OctopusFabricCertificateStoreName", variables.Get(SpecialVariables.Action.ServiceFabric.CertificateStoreName, "MY"), variables);
SetOutputVariable("OctopusFabricAadCredentialType", variables.Get(SpecialVariables.Action.ServiceFabric.AadCredentialType), variables);
SetOutputVariable("OctopusFabricAadClientCredentialSecret", variables.Get(SpecialVariables.Action.ServiceFabric.AadClientCredentialSecret), variables);
SetOutputVariable("OctopusFabricAadUserCredentialUsername", variables.Get(SpecialVariables.Action.ServiceFabric.AadUserCredentialUsername), variables);
SetOutputVariable("OctopusFabricAadUserCredentialPassword", variables.Get(SpecialVariables.Action.ServiceFabric.AadUserCredentialPassword), variables);
using (new TemporaryFile(Path.Combine(workingDirectory, "AzureProfile.json")))
using (var contextScriptFile = new TemporaryFile(CreateContextScriptFile(workingDirectory)))
{
return(NextWrapper.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
}
public void CanTransformConfigInJar()
{
const string configFile = "config.properties";
variables.Set(PackageVariables.SubstituteInFilesEnabled, true.ToString());
variables.Set(PackageVariables.SubstituteInFilesTargets, configFile);
DeployPackage(TestEnvironment.GetTestPath("Java", "Fixtures", "Deployment", "Packages", "HelloWorld.0.0.1.jar"));
Assert.AreEqual(0, returnCode);
log.StandardOut.Should().Contain($"Performing variable substitution on '{Path.Combine(Environment.CurrentDirectory, "staging", configFile)}'");
}
public void ShouldSkipIfInstalled()
{
variables.Set(SpecialVariables.Package.SkipIfAlreadyInstalled, true.ToString());
previous = new JournalEntry("123", "tenant", "env", "proj", "rp01", DateTime.Now, "C:\\App", "C:\\MyApp", true,
new List <DeployedPackage> {
new DeployedPackage("pkg", "0.0.9", "C:\\PackageOld.nupkg")
});
RunConvention();
Assert.That(variables.Get(KnownVariables.Action.SkipJournal), Is.EqualTo("true"));
}
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string> environmentVars)
{
// Only run this hook if we have an azure account
if (!IsEnabled(scriptSyntax))
{
throw new InvalidOperationException(
"This script wrapper hook is not enabled, and should not have been run");
}
var workingDirectory = Path.GetDirectoryName(script.File);
variables.Set("OctopusAzureTargetScript", $"{script.File}");
variables.Set("OctopusAzureTargetScriptParameters", script.Parameters);
SetOutputVariable(SpecialVariables.Action.Azure.Output.SubscriptionId, variables.Get(SpecialVariables.Action.Azure.SubscriptionId), variables);
SetOutputVariable("OctopusAzureStorageAccountName", variables.Get(SpecialVariables.Action.Azure.StorageAccountName), variables);
var azureEnvironment = variables.Get(SpecialVariables.Action.Azure.Environment, DefaultAzureEnvironment);
if (azureEnvironment != DefaultAzureEnvironment)
{
Log.Info("Using Azure Environment override - {0}", azureEnvironment);
}
SetOutputVariable("OctopusAzureEnvironment", azureEnvironment, variables);
SetOutputVariable("OctopusAzureExtensionsDirectory",
variables.Get(SpecialVariables.Action.Azure.ExtensionsDirectory), variables);
using (new TemporaryFile(Path.Combine(workingDirectory, "AzureProfile.json")))
using (var contextScriptFile = new TemporaryFile(CreateContextScriptFile(workingDirectory, scriptSyntax)))
{
if (variables.Get(SpecialVariables.Account.AccountType) == "AzureServicePrincipal")
{
SetOutputVariable("OctopusUseServicePrincipal", true.ToString(), variables);
SetOutputVariable("OctopusAzureADTenantId", variables.Get(SpecialVariables.Action.Azure.TenantId), variables);
SetOutputVariable("OctopusAzureADClientId", variables.Get(SpecialVariables.Action.Azure.ClientId), variables);
variables.Set("OctopusAzureADPassword", variables.Get(SpecialVariables.Action.Azure.Password));
return(NextWrapper.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
//otherwise use management certificate
SetOutputVariable("OctopusUseServicePrincipal", false.ToString(), variables);
using (new TemporaryFile(CreateAzureCertificate(workingDirectory, variables)))
{
return(NextWrapper.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
}
}
public void Setup()
{
variables = new CalamariVariables();
variables.Set(KnownVariables.Calamari.EnablePackageRetention, bool.TrueString);
variables.Set(TentacleVariables.Agent.TentacleHome, "SomeDirectory");
journalRepository = new InMemoryJournalRepository();
packageJournal = new PackageJournal(
journalRepository,
Substitute.For <ILog>(),
Substitute.For <ICalamariFileSystem>(),
Substitute.For <IRetentionAlgorithm>(),
Substitute.For <ISemaphoreFactory>()
);
}
private string CreateAzureCertificate(string workingDirectory, IVariables variables)
{
var certificateFilePath = Path.Combine(workingDirectory, CertificateFileName);
var certificatePassword = GenerateCertificatePassword();
var azureCertificate = certificateStore.GetOrAdd(
variables.Get(SpecialVariables.Action.Azure.CertificateThumbprint),
Convert.FromBase64String(variables.Get(SpecialVariables.Action.Azure.CertificateBytes)),
StoreName.My);
variables.Set("OctopusAzureCertificateFileName", certificateFilePath);
variables.Set("OctopusAzureCertificatePassword", certificatePassword);
fileSystem.WriteAllBytes(certificateFilePath, azureCertificate.Export(X509ContentType.Pfx, certificatePassword));
return(certificateFilePath);
}
public void SetUp()
{
fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
configurationTransformer = Substitute.For <IConfigurationTransformer>();
transformFileLocator = new TransformFileLocator(fileSystem);
var deployDirectory = BuildConfigPath(null);
variables = new CalamariVariables();
variables.Set(SpecialVariables.Package.EnabledFeatures, SpecialVariables.Features.ConfigurationTransforms);
variables.Set(KnownVariables.OriginalPackageDirectoryPath, deployDirectory);
deployment = new RunningDeployment(deployDirectory, variables);
logs = new InMemoryLog();
}
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 CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string> environmentVars)
{
var workingDirectory = Path.GetDirectoryName(script.File);
variables.Set("OctopusKubernetesTargetScript", $"{script.File}");
variables.Set("OctopusKubernetesTargetScriptParameters", script.Parameters);
variables.Set("Octopus.Action.Kubernetes.KubectlConfig", Path.Combine(workingDirectory, "kubectl-octo.yml"));
using (var contextScriptFile = new TemporaryFile(CreateContextScriptFile(workingDirectory, scriptSyntax)))
{
return(NextWrapper.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
}
public void SetUp()
{
variables = new CalamariVariables();
variables.Set(KnownVariables.OriginalPackageDirectoryPath, stagingDirectory);
fileSystem = Substitute.For <ICalamariFileSystem>();
deployment = new RunningDeployment(packageFilePath, variables);
}
void Extract(PathToPackage pathToPackage, string targetPath, IPackageExtractor customPackageExtractor)
{
try
{
if (string.IsNullOrWhiteSpace(pathToPackage))
{
log.Verbose("No package path defined. Skipping package extraction.");
return;
}
log.Verbose("Extracting package to: " + targetPath);
var extractorToUse = customPackageExtractor ?? combinedPackageExtractor;
var filesExtracted = extractorToUse.Extract(pathToPackage, targetPath);
log.Verbose("Extracted " + filesExtracted + " files");
variables.Set(KnownVariables.OriginalPackageDirectoryPath, targetPath);
log.SetOutputVariable(PackageVariables.Output.InstallationDirectoryPath, targetPath, variables);
log.SetOutputVariable(PackageVariables.Output.DeprecatedInstallationDirectoryPath, targetPath, variables);
log.SetOutputVariable(PackageVariables.Output.ExtractedFileCount, filesExtracted.ToString(), variables);
}
catch (UnauthorizedAccessException)
{
LogAccessDenied();
throw;
}
catch (Exception ex) when(ex.Message.ContainsIgnoreCase("Access is denied"))
{
LogAccessDenied();
throw;
}
}
public void ShouldUpdatePath()
{
const string websiteName = "AcmeOnline";
variables.Set(SpecialVariables.Package.UpdateIisWebsite, true.ToString());
variables.Set(SpecialVariables.Package.UpdateIisWebsiteName, websiteName);
fileSystem.FileExists(Path.Combine(stagingDirectory, "Web.config")).Returns(true);
iis.OverwriteHomeDirectory(websiteName, stagingDirectory, false).Returns(true);
CreateConvention().Install(deployment);
iis.Received().OverwriteHomeDirectory(websiteName, stagingDirectory, false);
}
public static IVariables CopyFromDictionary(this IVariables v, IDictionary dict, bool mustOverride = true)
{
foreach (DictionaryEntry kvp in Environment.GetEnvironmentVariables())
{
v.Set(kvp.Key.ToString(), kvp.Value);
}
return(v);
}
public void ShouldRunScriptAtAppropriateStage()
{
const string stage = DeploymentStages.PostDeploy;
const string scriptBody = "lorem ipsum blah blah blah";
var scriptName = ConfiguredScriptConvention.GetScriptName(stage, ScriptSyntax.PowerShell);
var scriptPath = Path.Combine(stagingDirectory, scriptName);
var script = new Script(scriptPath);
variables.Set(scriptName, scriptBody);
var convention = CreateConvention(stage);
scriptEngine.Execute(Arg.Any <Script>(), variables, commandLineRunner).Returns(new CommandResult("", 0));
convention.Install(deployment);
fileSystem.Received().WriteAllBytes(scriptPath, Arg.Any <byte[]>());
scriptEngine.Received().Execute(Arg.Is <Script>(s => s.File == scriptPath), variables, commandLineRunner);
}
private Action <RunningChangeSet> ApplyVariables(IVariables variables)
{
return(result =>
{
SetOutputVariable(variables, "ChangesetId", result.ChangeSet.Value);
SetOutputVariable(variables, "StackId", result.Stack.Value);
variables.Set(AwsSpecialVariables.CloudFormation.Changesets.Arn, result.ChangeSet.Value);
});
}
public void ShouldCreateScriptFileIfNotExists()
{
const string deployStage = "BeforePostDeploy";
const string feature = "doTheThing";
var scriptPath = Path.Combine(stagingDirectory, FeatureConvention.GetScriptName(feature, deployStage, "ps1"));
variables.Set(SpecialVariables.Package.EnabledFeatures, feature);
Arrange(new List <string> {
feature
}, deployStage);
fileSystem.FileExists(scriptPath).Returns(false);
var convention = CreateConvention(deployStage);
scriptEngine.Execute(Arg.Is <Script>(s => s.File == scriptPath), variables, commandLineRunner).Returns(new CommandResult("", 0));
convention.Install(deployment);
fileSystem.Received().OverwriteFile(scriptPath, scriptContents);
}
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string>?environmentVars)
{
var workingDirectory = Path.GetDirectoryName(script.File) !;
variables.Set("OctopusAzureTargetScript", script.File);
variables.Set("OctopusAzureTargetScriptParameters", script.Parameters);
SetOutputVariable("OctopusAzureSubscriptionId", variables.Get(SpecialVariables.Action.Azure.SubscriptionId) !);
SetOutputVariable("OctopusAzureStorageAccountName", variables.Get(SpecialVariables.Action.Azure.StorageAccountName) !);
var azureEnvironment = variables.Get(SpecialVariables.Action.Azure.Environment, DefaultAzureEnvironment) !;
if (azureEnvironment != DefaultAzureEnvironment)
{
log.InfoFormat("Using Azure Environment override - {0}", azureEnvironment);
}
SetOutputVariable("OctopusAzureEnvironment", azureEnvironment);
SetOutputVariable("OctopusAzureExtensionsDirectory", variables.Get(SpecialVariables.Action.Azure.ExtensionsDirectory) !);
using (new TemporaryFile(Path.Combine(workingDirectory, "AzureProfile.json")))
using (var contextScriptFile = new TemporaryFile(CreateContextScriptFile(workingDirectory, scriptSyntax)))
{
if (variables.Get(SpecialVariables.Account.AccountType) == "AzureServicePrincipal")
{
SetOutputVariable("OctopusUseServicePrincipal", bool.TrueString);
SetOutputVariable("OctopusAzureADTenantId", variables.Get(SpecialVariables.Action.Azure.TenantId) !);
SetOutputVariable("OctopusAzureADClientId", variables.Get(SpecialVariables.Action.Azure.ClientId) !);
variables.Set("OctopusAzureADPassword", variables.Get(SpecialVariables.Action.Azure.Password));
return(NextWrapper !.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
//otherwise use management certificate
SetOutputVariable("OctopusUseServicePrincipal", false.ToString());
using (new TemporaryFile(CreateAzureCertificate(workingDirectory)))
{
return(NextWrapper !.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
}
}
public void SetUp()
{
log = Substitute.For <ILog>();
log.When(x => x.SetOutputVariable(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IVariables>()))
.Do(x => outputVars.Add(x.ArgAt <string>(0), x.ArgAt <string>(1)));
calamariFileSystem = Substitute.For <ICalamariFileSystem>();
commandLineRunner = Substitute.For <ICommandLineRunner>();
variables = new CalamariVariables();
variables.Set(TerraformSpecialVariables.Action.Terraform.PlanJsonOutput, "True");
runningDeployment = Substitute.For <RunningDeployment>(variables);
}
public void DeployTemplate(string resourceName, string templateFilePath, IVariables variables)
{
var variablesFile = Path.GetTempFileName();
variables.Set("Octopus.Action.AwsAccount.Variable", "AWSAccount");
variables.Set("AWSAccount.AccessKey", ExternalVariables.Get(ExternalVariable.AwsAcessKey));
variables.Set("AWSAccount.SecretKey", ExternalVariables.Get(ExternalVariable.AwsSecretKey));
variables.Set("Octopus.Action.Aws.Region", region);
variables.Save(variablesFile);
using (var templateFile = new TemporaryFile(templateFilePath))
using (new TemporaryFile(variablesFile))
{
var log = new InMemoryLog();
var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
var command = new DeployCloudFormationCommand(
log,
variables,
fileSystem,
new ExtractPackage(new CombinedPackageExtractor(log, variables, new CommandLineRunner(log, variables)), fileSystem, variables, log),
new StructuredConfigVariablesService(new PrioritisedList <IFileFormatVariableReplacer>
{
new JsonFormatVariableReplacer(fileSystem, log),
new XmlFormatVariableReplacer(fileSystem, log),
new YamlFormatVariableReplacer(fileSystem, log),
new PropertiesFormatVariableReplacer(fileSystem, log),
}, variables, fileSystem, log)
);
var result = command.Execute(new[]
{
"--template", $"{templateFile.FilePath}",
"--variables", $"{variablesFile}",
"--stackName", resourceName,
"--waitForCompletion", "true"
});
result.Should().Be(0);
}
}
void ParseServiceMessage(ServiceMessage message)
{
switch (message.Name)
{
case ServiceMessageNames.SetVariable.Name:
var variableName = message.GetValue(ServiceMessageNames.SetVariable.NameAttribute);
var variableValue = message.GetValue(ServiceMessageNames.SetVariable.ValueAttribute);
if (!string.IsNullOrWhiteSpace(variableName))
{
outputVariables.Set(variableName, variableValue);
}
break;
case ServiceMessageNames.CalamariFoundPackage.Name:
CalamariFoundPackage = true;
break;
case ServiceMessageNames.FoundPackage.Name:
var foundPackageId = message.GetValue(ServiceMessageNames.FoundPackage.IdAttribute);
var foundPackageVersion = message.GetValue(ServiceMessageNames.FoundPackage.VersionAttribute);
var foundPackageVersionFormat = message.GetValue(ServiceMessageNames.FoundPackage.VersionFormat);
var foundPackageHash = message.GetValue(ServiceMessageNames.FoundPackage.HashAttribute);
var foundPackageRemotePath = message.GetValue(ServiceMessageNames.FoundPackage.RemotePathAttribute);
var fileExtension = message.GetValue(ServiceMessageNames.FoundPackage.FileExtensionAttribute);
if (foundPackageId != null && foundPackageVersion != null)
{
FoundPackage = new FoundPackage(foundPackageId,
foundPackageVersion,
foundPackageVersionFormat,
foundPackageRemotePath,
foundPackageHash,
fileExtension);
}
break;
case ServiceMessageNames.PackageDeltaVerification.Name:
var pdvHash = message.GetValue(ServiceMessageNames.PackageDeltaVerification.HashAttribute);
var pdvSize = message.GetValue(ServiceMessageNames.PackageDeltaVerification.SizeAttribute);
var pdvRemotePath =
message.GetValue(ServiceMessageNames.PackageDeltaVerification.RemotePathAttribute);
DeltaError = message.GetValue(ServiceMessageNames.PackageDeltaVerification.Error);
if (pdvRemotePath != null && pdvHash != null)
{
DeltaVerification = new DeltaPackage(pdvRemotePath, pdvHash, long.Parse(pdvSize));
}
break;
}
}
public virtual void SetUp()
{
fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
log = new InMemoryLog();
// Ensure staging directory exists and is empty
applicationDirectory = Path.Combine(Path.GetTempPath(), "CalamariTestStaging");
fileSystem.EnsureDirectoryExists(applicationDirectory);
fileSystem.PurgeDirectory(applicationDirectory, FailureOptions.ThrowOnFailure);
Environment.SetEnvironmentVariable("TentacleJournal", Path.Combine(applicationDirectory, "DeploymentJournal.xml"));
variables = new VariablesFactory(fileSystem).Create(new CommonOptions("test"));
variables.Set(TentacleVariables.Agent.ApplicationDirectoryPath, applicationDirectory);
}
public void SetUp()
{
fileSystem = Substitute.For <ICalamariFileSystem>();
scriptEngine = Substitute.For <IScriptEngine>();
commandLineRunner = Substitute.For <ICommandLineRunner>();
scriptEngine.GetSupportedTypes().Returns(new[] { ScriptSyntax.PowerShell });
variables = new CalamariVariables();
variables.Set(KnownVariables.Package.EnabledFeatures, KnownVariables.Features.CustomScripts);
deployment = new RunningDeployment("C:\\packages", variables)
{
StagingDirectory = stagingDirectory
};
}
public void SetUp()
{
fileSystem = Substitute.For <ICalamariFileSystem>();
embeddedResources = Substitute.For <ICalamariEmbeddedResources>();
scriptEngine = Substitute.For <IScriptEngine>();
commandLineRunner = Substitute.For <ICommandLineRunner>();
scriptEngine.GetSupportedTypes().Returns(new[] { ScriptSyntax.PowerShell });
variables = new CalamariVariables();
variables.Set(SpecialVariables.Package.EnabledFeatures, "Octopus.Features.blah");
deployment = new RunningDeployment("C:\\packages", variables)
{
StagingDirectory = stagingDirectory
};
}
internal static void PreviousSuccessful(IVariables variables, IDeploymentJournal journal, string policySet)
{
var previous = journal.GetLatestSuccessfulInstallation(policySet);
if (previous == null)
{
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.OriginalInstalledPath, "");
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.CustomInstallationDirectory, "");
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.PackageFilePath, "");
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.PackageVersion, "");
}
else
{
var previousPackage = previous.Packages.FirstOrDefault();
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.OriginalInstalledPath, previous.ExtractedTo);
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.CustomInstallationDirectory, previous.CustomInstallationDirectory);
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.PackageFilePath, previousPackage?.DeployedFrom ?? "");
variables.Set(TentacleVariables.PreviousSuccessfulInstallation.PackageVersion, previousPackage?.PackageVersion ?? "");
}
}
protected override int ExecuteInternal(NodeInstructions instructions)
{
using (var variableFile = new TemporaryFile(Path.GetTempFileName()))
{
var jsonInputs = variables.GetRaw(instructions.InputsVariable) ?? string.Empty;
variables.Set(instructions.InputsVariable, InputSubstitution.SubstituteAndEscapeAllVariablesInJson(jsonInputs, variables, log));
var variablesAsJson = variables.CloneAndEvaluate().SaveAsString();
File.WriteAllBytes(variableFile.FilePath, new AesEncryption(options.InputVariables.SensitiveVariablesPassword).Encrypt(variablesAsJson));
var pathToNode = variables.Get(instructions.NodePathVariable);
var nodeExecutablePath = BuildNodePath(pathToNode);
var parameters = BuildParams(instructions, variableFile.FilePath);
var runningDeployment = new RunningDeployment(variables);
var commandLineInvocation = new CommandLineInvocation(nodeExecutablePath, parameters)
{
WorkingDirectory = runningDeployment.CurrentDirectory,
OutputToLog = true,
EnvironmentVars = ProxyEnvironmentVariablesGenerator.GenerateProxyEnvironmentVariables().ToDictionary(e => e.Key, e => e.Value)
};
var commandResult = commandLineRunner.Execute(commandLineInvocation);
return(commandResult.ExitCode);
}
}
public void ShouldApplyReleaseTransformIfAutomaticallyRunConfigurationTransformationFilesFlagIsSet()
{
variables.Set(SpecialVariables.Package.AutomaticallyRunConfigurationTransformationFiles, true.ToString());
CreateConvention().Install(deployment);
AssertTransformRun("bar.config", "bar.Release.config");
}