/// <summary>
/// One of these fields must be present for a k8s step
/// </summary>
public bool IsEnabled(ScriptSyntax syntax)
{
return((!string.IsNullOrEmpty(variables.Get(SpecialVariables.ClusterUrl, "")) ||
!string.IsNullOrEmpty(variables.Get(SpecialVariables.AksClusterName, "")) ||
!string.IsNullOrEmpty(variables.Get(SpecialVariables.EksClusterName, ""))) &&
syntax == ScriptSyntaxHelper.GetPreferredScriptSyntaxForEnvironment());
}
public void Install(RunningDeployment deployment)
{
ScriptSyntax syntax = ScriptSyntaxHelper.GetPreferredScriptSyntaxForEnvironment();
var cmd = BuildHelmCommand(deployment, syntax);
var fileName = SyntaxSpecificFileName(deployment, syntax);
using (new TemporaryFile(fileName))
{
fileSystem.OverwriteFile(fileName, cmd);
var result = scriptEngine.Execute(new Script(fileName), deployment.Variables, commandLineRunner);
if (result.ExitCode != 0)
{
throw new CommandException(string.Format(
"Helm Upgrade returned non-zero exit code: {0}. Deployment terminated.", result.ExitCode));
}
if (result.HasErrors &&
deployment.Variables.GetFlag(Deployment.SpecialVariables.Action.FailScriptOnErrorOutput, false))
{
throw new CommandException(
$"Helm Upgrade returned zero exit code but had error output. Deployment terminated.");
}
}
}
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));
}
}
string GetFetchScript(string workingDirectory, ScriptSyntax syntax)
{
AssemblyEmbeddedResources embeddedResources = new AssemblyEmbeddedResources();
string contextFile;
switch (syntax)
{
case ScriptSyntax.Bash:
contextFile = "helmFetch.sh";
break;
case ScriptSyntax.PowerShell:
contextFile = "HelmFetch.ps1";
break;
default:
throw new InvalidOperationException("No kubernetes context wrapper exists for " + syntax);
}
var k8sContextScriptFile = Path.Combine(workingDirectory, $"Octopus.{contextFile}");
var contextScript = embeddedResources.GetEmbeddedResourceText(Assembly.GetExecutingAssembly(), $"Calamari.Integration.Packages.Download.Scripts.{contextFile}");
fileSystem.OverwriteFile(k8sContextScriptFile, contextScript);
return(k8sContextScriptFile);
}
public static string FileExtension(this ScriptSyntax scriptSyntax)
{
return(typeof(ScriptSyntax).GetField(scriptSyntax.ToString())
.GetCustomAttributes(typeof(FileExtensionAttribute), false)
.Select(attr => ((FileExtensionAttribute)attr).Extension)
.FirstOrDefault());
}
/// <summary>
/// Script wrappers form a chain, with one wrapper calling the next, much like
/// a linked list. The last wrapper to be called is the TerminalScriptWrapper,
/// which simply executes a ScriptEngine without any additional processing.
/// In this way TerminalScriptWrapper is what actually executes the script
/// that is to be run, with all other wrappers contributing to the script
/// context.
/// </summary>
/// <param name="scriptSyntax">The type of the script being run</param>
/// <param name="variables"></param>
/// <returns>
/// The start of the wrapper chain. Because each IScriptWrapper is expected to call its NextWrapper,
/// calling ExecuteScript() on the start of the chain will result in every part of the chain being
/// executed, down to the final TerminalScriptWrapper.
/// </returns>
IScriptWrapper BuildWrapperChain(ScriptSyntax scriptSyntax, IVariables variables) =>
// get the type of script
scriptWrapperHooks
.Where(hook => hook.IsEnabled(scriptSyntax))
/*
* Sort the list in descending order of priority to ensure that
* authentication script wrappers are called before any tool
* script wrapper that might rely on the auth having being performed
*/
.OrderByDescending(hook => hook.Priority)
.Aggregate(
// The last wrapper is always the TerminalScriptWrapper
new TerminalScriptWrapper(GetScriptExecutor(scriptSyntax), variables),
(IScriptWrapper current, IScriptWrapper next) =>
{
// the next wrapper is pointed to the current one
next.NextWrapper = current;
/*
* The next wrapper is carried across to the next aggregate call,
* or is returned as the result of the aggregate call. This means
* the last item in the list is the return value.
*/
return(next);
});
void SetExecutable(RunningDeployment deployment, StringBuilder sb, ScriptSyntax syntax)
{
var helmExecutable = deployment.Variables.Get(SpecialVariables.Helm.CustomHelmExecutable);
if (!string.IsNullOrWhiteSpace(helmExecutable))
{
if (deployment.Variables.GetIndexes(Deployment.SpecialVariables.Packages.PackageCollection)
.Contains(SpecialVariables.Helm.Packages.CustomHelmExePackageKey) && !Path.IsPathRooted(helmExecutable))
{
helmExecutable = Path.Combine(SpecialVariables.Helm.Packages.CustomHelmExePackageKey, helmExecutable);
Log.Info(
$"Using custom helm executable at {helmExecutable} from inside package. Full path at {Path.GetFullPath(helmExecutable)}");
}
else
{
Log.Info($"Using custom helm executable at {helmExecutable}");
}
// With PowerShell we need to invoke custom executables
sb.Append(syntax == ScriptSyntax.PowerShell ? ". " : $"chmod +x \"{helmExecutable}\"\n");
sb.Append($"\"{helmExecutable}\"");
}
else
{
sb.Append("helm");
}
}
string BuildHelmCommand(RunningDeployment deployment, ScriptSyntax syntax)
{
var releaseName = GetReleaseName(deployment.Variables);
var packagePath = GetChartLocation(deployment);
var customHelmExecutable = CustomHelmExecutableFullPath(deployment.Variables, deployment.CurrentDirectory);
var helmVersion = GetVersion(deployment.Variables);
CheckHelmToolVersion(customHelmExecutable, helmVersion);
var sb = new StringBuilder();
SetExecutable(sb, syntax, customHelmExecutable);
sb.Append($" upgrade --install");
SetNamespaceParameter(deployment, sb);
SetResetValuesParameter(deployment, sb);
if (helmVersion == HelmVersion.V2)
{
SetTillerTimeoutParameter(deployment, sb);
SetTillerNamespaceParameter(deployment, sb);
}
SetTimeoutParameter(deployment, sb);
SetValuesParameters(deployment, sb);
SetAdditionalArguments(deployment, sb);
sb.Append($" \"{releaseName}\" \"{packagePath}\"");
log.Verbose(sb.ToString());
return(sb.ToString());
}
/// <summary>
/// One of these fields must be present for a k8s step
/// </summary>
public bool IsEnabled(ScriptSyntax syntax)
{
var hasClusterUrl = !string.IsNullOrEmpty(variables.Get(SpecialVariables.ClusterUrl));
var hasClusterName = !string.IsNullOrEmpty(variables.Get(SpecialVariables.AksClusterName)) || !string.IsNullOrEmpty(variables.Get(SpecialVariables.EksClusterName)) || !string.IsNullOrEmpty(variables.Get(SpecialVariables.GkeClusterName));
return(hasClusterUrl || hasClusterName);
}
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string> environmentVars)
{
WasCalled = true;
return(NextWrapper.ExecuteScript(script, scriptSyntax, commandLineRunner, environmentVars));
}
public bool IsEnabled(ScriptSyntax syntax)
{
if (String.IsNullOrEmpty(variables.Get(ScriptFunctionsVariables.Registration)))
{
return(false);
}
return(codeGenFunctionsRegistry.SupportedScriptSyntax.Contains(syntax));
}
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
CalamariVariableDictionary variables,
ICommandLineRunner commandLineRunner,
StringDictionary environmentVars)
{
WasCalled = true;
return(NextWrapper.ExecuteScript(script, scriptSyntax, variables, commandLineRunner, environmentVars));
}
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
CalamariVariableDictionary variables,
ICommandLineRunner commandLineRunner,
StringDictionary 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}.{SpecialVariables.Certificate.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, variables, commandLineRunner, environmentVars));
}
}
public void ShouldBeEnabled(string connectionEndpoint, ScriptSyntax syntax, bool expected)
{
var variables = new CalamariVariables();
variables.Add(SpecialVariables.Action.ServiceFabric.ConnectionEndpoint, connectionEndpoint);
var target = new AzureServiceFabricPowerShellContext(variables);
var actual = target.IsEnabled(syntax);
actual.Should().Be(expected);
}
string CreateContextScriptFile(string workingDirectory, ScriptSyntax scriptSyntax)
{
var registrations = variables.Get(ScriptFunctionsVariables.Registration);
var results = JsonConvert.DeserializeObject <IList <ScriptFunctionRegistration> >(registrations);
var azureContextScriptFile = Path.Combine(workingDirectory, $"Octopus.FunctionAppenderContext.{scriptSyntax.FileExtension()}");
var contextScript = codeGenFunctionsRegistry.GetCodeGenerator(scriptSyntax).Generate(results);
fileSystem.OverwriteFile(azureContextScriptFile, contextScript);
return(azureContextScriptFile);
}
public void ShouldBeEnabled(string accountType, string connectionEndpoint, ScriptSyntax syntax, bool expected)
{
var variables = new CalamariVariableDictionary
{
{ SpecialVariables.Account.AccountType, accountType },
{ SpecialVariables.Action.ServiceFabric.ConnectionEndpoint, connectionEndpoint }
};
var target = new AzurePowerShellContext(variables);
var actual = target.IsEnabled(syntax);
actual.Should().Be(expected);
}
public static bool TryParse(TokenStack tokens, out Script script)
{
var scriptSyntax = new ScriptSyntax();
if (scriptSyntax.TryParse(tokens, out GraphNode scriptNode))
{
script = (Script)scriptNode;
return(true);
}
script = null;
return(false);
}
void SetExecutable(StringBuilder sb, ScriptSyntax syntax, string customHelmExecutable)
{
if (customHelmExecutable != null)
{
// With PowerShell we need to invoke custom executables
sb.Append(syntax == ScriptSyntax.PowerShell ? ". " : $"chmod +x \"{customHelmExecutable}\"\n");
sb.Append($"\"{customHelmExecutable}\"");
}
else
{
sb.Append("helm");
}
}
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string> environmentVars)
{
var awsEnvironmentVars = AwsEnvironmentGeneration.Create(log, variables).GetAwaiter().GetResult().EnvironmentVars;
awsEnvironmentVars.AddRange(environmentVars);
return(NextWrapper.ExecuteScript(
script, scriptSyntax,
commandLineRunner,
awsEnvironmentVars));
}
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));
}
}
}
/// <summary>
/// Script wrappers form a chain, with one wrapper calling the next, much like
/// a linked list. The last wrapper to be called is the TerminalScriptWrapper,
/// which simply executes a ScriptEngine without any additional processing.
/// In this way TerminalScriptWrapper is what actually executes the script
/// that is to be run, with all other wrappers contributing to the script
/// context.
/// </summary>
/// <param name="scriptSyntax">The type of the script being run</param>
/// <returns>
/// The start of the wrapper chain. Because each IScriptWrapper is expected to call its NextWrapper,
/// calling ExecuteScript() on the start of the chain will result in every part of the chain being
/// executed, down to the final TerminalScriptWrapper.
/// </returns>
IScriptWrapper BuildWrapperChain(ScriptSyntax scriptSyntax) =>
// get the type of script
scriptWrapperHooks
.Where(hook => hook.Enabled)
.Aggregate(
// The last wrapper is always the TerminalScriptWrapper
new TerminalScriptWrapper(ScriptEngineRegistry.Instance.ScriptEngines[scriptSyntax]),
(IScriptWrapper current, IScriptWrapper next) =>
{
// the next wrapper is pointed to the current one
next.NextWrapper = current;
// the next wrapper is carried across to the next aggregate call
return(next);
});
public CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
CalamariVariableDictionary variables,
ICommandLineRunner commandLineRunner,
StringDictionary environmentVars)
{
var awsEnvironmentVars = AwsEnvironmentGeneration.Create(variables).GetAwaiter().GetResult().EnvironmentVars;
return(NextWrapper.ExecuteScript(
script, scriptSyntax,
variables,
commandLineRunner,
environmentVars.MergeDictionaries(awsEnvironmentVars)));
}
public SetupKubectlAuthentication(IVariables variables,
ILog log,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string> environmentVars,
string workingDirectory)
{
this.variables = variables;
this.log = log;
this.scriptSyntax = scriptSyntax;
this.commandLineRunner = commandLineRunner;
this.environmentVars = environmentVars;
this.workingDirectory = workingDirectory;
}
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 CommandResult ExecuteScript(Script script,
ScriptSyntax scriptSyntax,
ICommandLineRunner commandLineRunner,
Dictionary <string, string> environmentVars)
{
var workingDirectory = Path.GetDirectoryName(script.File);
if (environmentVars == null)
{
environmentVars = new Dictionary <string, string>();
}
var setupKubectlAuthentication = new SetupKubectlAuthentication(variables,
log,
scriptSyntax,
commandLineRunner,
environmentVars,
workingDirectory);
var accountType = variables.Get("Octopus.Account.AccountType");
try
{
var result = setupKubectlAuthentication.Execute(accountType);
if (result.ExitCode != 0)
{
return(result);
}
}
catch (CommandLineException)
{
return(new CommandResult(String.Empty, 1));
}
if (scriptSyntax == ScriptSyntax.PowerShell && accountType == "AzureServicePrincipal")
{
variables.Set("OctopusKubernetesTargetScript", $"{script.File}");
variables.Set("OctopusKubernetesTargetScriptParameters", script.Parameters);
using (var contextScriptFile = new TemporaryFile(CreateContextScriptFile(workingDirectory)))
{
return(NextWrapper.ExecuteScript(new Script(contextScriptFile.FilePath), scriptSyntax, commandLineRunner, environmentVars));
}
}
return(NextWrapper.ExecuteScript(script, scriptSyntax, commandLineRunner, environmentVars));
}
public static string GetExtension(this ScriptSyntax syntax)
{
switch (syntax)
{
case ScriptSyntax.PowerShell:
return("ps1");
case ScriptSyntax.Bash:
return("sh");
case ScriptSyntax.CSharp:
return("csx");
case ScriptSyntax.FSharp:
return("fsx");
default:
throw new ArgumentOutOfRangeException("syntax");
}
}
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));
}
}
}
string BuildHelmCommand(RunningDeployment deployment, ScriptSyntax syntax)
{
var releaseName = GetReleaseName(deployment.Variables);
var packagePath = GetChartLocation(deployment);
var sb = new StringBuilder();
SetExecutable(deployment, sb, syntax);
sb.Append($" upgrade --install");
SetNamespaceParameter(deployment, sb);
SetResetValuesParameter(deployment, sb);
SetTillerTimeoutParameter(deployment, sb);
SetTillerNamespaceParameter(deployment, sb);
SetTimeoutParameter(deployment, sb);
SetValuesParameters(deployment, sb);
SetAdditionalArguments(deployment, sb);
sb.Append($" \"{releaseName}\" \"{packagePath}\"");
Log.Verbose(sb.ToString());
return(sb.ToString());
}
IScriptExecutor GetScriptExecutor(ScriptSyntax scriptSyntax)
{
switch (scriptSyntax)
{
case ScriptSyntax.PowerShell:
return(new PowerShellScriptExecutor());
case ScriptSyntax.CSharp:
return(new ScriptCSScriptExecutor());
case ScriptSyntax.Bash:
return(new BashScriptExecutor());
case ScriptSyntax.FSharp:
return(new FSharpExecutor());
case ScriptSyntax.Python:
return(new PythonScriptExecutor());
default:
throw new NotSupportedException($"{scriptSyntax} script are not supported for execution");
}
}
string CreateContextScriptFile(string workingDirectory, ScriptSyntax syntax)
{
string contextFile;
switch (syntax)
{
case ScriptSyntax.Bash:
contextFile = "KubectlBashContext.sh";
break;
case ScriptSyntax.PowerShell:
contextFile = "KubectlPowershellContext.ps1";
break;
default:
throw new InvalidOperationException("No kubernetes context wrapper exists for " + syntax);
}
var k8sContextScriptFile = Path.Combine(workingDirectory, $"Octopus.{contextFile}");
var contextScript = embeddedResources.GetEmbeddedResourceText(Assembly.GetExecutingAssembly(), $"Calamari.Kubernetes.Scripts.{contextFile}");
fileSystem.OverwriteFile(k8sContextScriptFile, contextScript);
return(k8sContextScriptFile);
}
public static InlineScriptAction InlineScript(ScriptSyntax syntax, string scriptBody)
{
return new InlineScriptAction(syntax, scriptBody);
}
public InlineScriptAction(ScriptSyntax syntax, string scriptBody)
{
this.scriptBody = scriptBody;
Syntax = syntax;
}
ScriptSyntaxMeta(ScriptSyntax scriptSyntax, string extension, string name)
{
ScriptSyntax = scriptSyntax;
Extension = extension;
Name = name;
}
