public void LogVariables()
{
string ToString(bool useRawValue)
{
var text = new StringBuilder();
var namesToPrint = variables.GetNames().Where(name => !name.Contains("CustomScripts.")).OrderBy(name => name);
foreach (var name in namesToPrint)
{
var value = useRawValue ? variables.GetRaw(name) : variables.Get(name);
text.AppendLine($"[{name}] = '{value}'");
}
return(text.ToString());
}
if (variables.GetFlag(KnownVariables.PrintVariables))
{
log.Warn($"{KnownVariables.PrintVariables} is enabled. This should only be used for debugging problems with variables, and then disabled again for normal deployments.");
log.Verbose("The following variables are available:" + Environment.NewLine + ToString(true));
}
if (variables.GetFlag(KnownVariables.PrintEvaluatedVariables))
{
log.Warn($"{KnownVariables.PrintEvaluatedVariables} is enabled. This should only be used for debugging problems with variables, and then disabled again for normal deployments.");
log.Verbose("The following evaluated variables are available:" + Environment.NewLine + ToString(false));
}
}
protected override void Execute(SubstituteInFilesCommandInputs inputs)
{
var targetPath = variables.GetRaw(inputs.TargetPathVariable);
if (targetPath == null)
{
throw new CommandException($"Could not locate target path from variable {inputs.TargetPathVariable} for {nameof(SubstituteInFilesCommand)}");
}
substituteInFiles.Substitute(targetPath, inputs.FilesToTarget);
}
protected override void Execute(StructuredConfigVariablesCommandInputs inputs)
{
var targetPath = variables.GetRaw(inputs.TargetPathVariable);
if (targetPath == null)
{
throw new CommandException($"Could not locate target path from variable {inputs.TargetPathVariable} for {nameof(StructuredConfigVariablesCommand)}");
}
structuredConfigVariablesService.ReplaceVariables(targetPath);
}
bool TryGetScriptFromVariables(out string scriptBody, out string scriptFileName, out ScriptSyntax syntax)
{
scriptBody = variables.GetRaw(ScriptVariables.ScriptBody);
if (WasProvided(scriptBody))
{
var scriptSyntax = variables.Get(ScriptVariables.Syntax);
if (scriptSyntax == null)
{
syntax = scriptEngine.GetSupportedTypes().FirstOrDefault();
Log.Warn($"No script syntax provided. Defaulting to first known supported type {syntax}");
}
else if (!Enum.TryParse(scriptSyntax, out syntax))
{
throw new CommandException($"Unknown script syntax `{scriptSyntax}` provided");
}
scriptFileName = "Script." + syntax.FileExtension();
return(true);
}
// Try get any supported script body variable
foreach (var supportedSyntax in scriptEngine.GetSupportedTypes())
{
scriptBody = variables.GetRaw(SpecialVariables.Action.Script.ScriptBodyBySyntax(supportedSyntax));
if (scriptBody == null)
{
continue;
}
scriptFileName = "Script." + supportedSyntax.FileExtension();
syntax = supportedSyntax;
return(true);
}
scriptBody = null;
syntax = 0;
scriptFileName = null;
return(false);
}
internal static ICollection<PrivateKeyAccessRule> GetPrivateKeyAccessRules(IVariables variables)
{
// The private-key access-rules are stored as escaped JSON. However, they may contain nested
// variables (for example the user-name may be an Octopus variable) which may not be escaped,
// causing JSON parsing to fail.
// So, we get the raw text
var raw = variables.GetRaw(SpecialVariables.Certificate.PrivateKeyAccessRules);
if (string.IsNullOrWhiteSpace(raw))
return new List<PrivateKeyAccessRule>();
// Unescape it (we only care about backslashes)
var unescaped = raw.Replace(@"\\", @"\");
// Perform variable-substitution and re-escape
var escapedAndSubstituted = variables.Evaluate(unescaped).Replace(@"\", @"\\");
return PrivateKeyAccessRule.FromJson(escapedAndSubstituted);
}
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);
}
}