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)); } }
public void DoTransforms(string currentDirectory) { var explicitTransforms = GetExplicitTransforms(); var automaticTransforms = GetAutomaticTransforms(); var sourceExtensions = GetSourceExtensions(explicitTransforms); var allTransforms = explicitTransforms.Concat(automaticTransforms).ToList(); var transformDefinitionsApplied = new List <XmlConfigTransformDefinition>(); var duplicateTransformDefinitions = new List <XmlConfigTransformDefinition>(); var transformFilesApplied = new HashSet <Tuple <string, string> >(); var diagnosticLoggingEnabled = variables.GetFlag(KnownVariables.Package.EnableDiagnosticsConfigTransformationLogging); if (diagnosticLoggingEnabled) { log.Verbose($"Recursively searching for transformation files that match {string.Join(" or ", sourceExtensions)} in folder '{currentDirectory}'"); } foreach (var configFile in MatchingFiles(currentDirectory, sourceExtensions)) { if (diagnosticLoggingEnabled) { log.Verbose($"Found config file '{configFile}'"); } ApplyTransformations(configFile, allTransforms, transformFilesApplied, transformDefinitionsApplied, duplicateTransformDefinitions, diagnosticLoggingEnabled, currentDirectory); } LogFailedTransforms(explicitTransforms, automaticTransforms, transformDefinitionsApplied, duplicateTransformDefinitions, diagnosticLoggingEnabled); variables.SetStrings(KnownVariables.AppliedXmlConfigTransforms, transformFilesApplied.Select(t => t.Item1), "|"); }
public static ConfigurationTransformer FromVariables(IVariables variables, ILog log = null) { var treatConfigTransformationWarningsAsErrors = variables.GetFlag(SpecialVariables.Package.TreatConfigTransformationWarningsAsErrors, true); var ignoreConfigTransformErrors = variables.GetFlag(SpecialVariables.Package.IgnoreConfigTransformationErrors); var suppressConfigTransformLogging = variables.GetFlag(SpecialVariables.Package.SuppressConfigTransformationLogging); var transformLoggingOptions = TransformLoggingOptions.None; if (treatConfigTransformationWarningsAsErrors) { transformLoggingOptions |= TransformLoggingOptions.LogWarningsAsErrors; } if (ignoreConfigTransformErrors) { transformLoggingOptions |= TransformLoggingOptions.LogExceptionsAsWarnings; transformLoggingOptions |= TransformLoggingOptions.LogWarningsAsInfo; transformLoggingOptions &= ~TransformLoggingOptions.LogWarningsAsErrors; } if (suppressConfigTransformLogging) { transformLoggingOptions |= TransformLoggingOptions.DoNotLogVerbose; } return(new ConfigurationTransformer(transformLoggingOptions, log)); }
private static DeploymentSyncOptions DeploymentSyncOptions(IVariables variables) { var syncOptions = new DeploymentSyncOptions { WhatIf = false, UseChecksum = variables.GetFlag(SpecialVariables.Action.Azure.UseChecksum), DoNotDelete = !variables.GetFlag(SpecialVariables.Action.Azure.RemoveAdditionalFiles), }; ApplyAppOfflineDeploymentRule(syncOptions, variables); ApplyPreserveAppDataDeploymentRule(syncOptions, variables); ApplyPreservePathsDeploymentRule(syncOptions, variables); return(syncOptions); }
static Dictionary <string, string> GoogleCloudEnvironmentVariables(IVariables variables) { // See https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/provider_reference#full-reference var googleCloudEnvironmentVariables = new Dictionary <string, string>(); var useVmServiceAccount = variables.GetFlag("Octopus.Action.GoogleCloud.UseVMServiceAccount"); var account = variables.Get("Octopus.Action.GoogleCloudAccount.Variable")?.Trim(); var keyFile = variables.Get($"{account}.JsonKey")?.Trim() ?? variables.Get("Octopus.Action.GoogleCloudAccount.JsonKey")?.Trim(); if (!useVmServiceAccount && !string.IsNullOrEmpty(keyFile)) { var bytes = Convert.FromBase64String(keyFile); var json = Encoding.UTF8.GetString(bytes); googleCloudEnvironmentVariables.Add("GOOGLE_CLOUD_KEYFILE_JSON", json); Log.Verbose($"A JSON key has been set to GOOGLE_CLOUD_KEYFILE_JSON environment variable"); } var impersonateServiceAccount = variables.GetFlag("Octopus.Action.GoogleCloud.ImpersonateServiceAccount"); if (impersonateServiceAccount) { var serviceAccountEmails = variables.Get("Octopus.Action.GoogleCloud.ServiceAccountEmails") ?? string.Empty; googleCloudEnvironmentVariables.Add("GOOGLE_IMPERSONATE_SERVICE_ACCOUNT", serviceAccountEmails); Log.Verbose($"{serviceAccountEmails} has been set to GOOGLE_IMPERSONATE_SERVICE_ACCOUNT environment variable"); } var project = variables.Get("Octopus.Action.GoogleCloud.Project")?.Trim(); var region = variables.Get("Octopus.Action.GoogleCloud.Region")?.Trim(); var zone = variables.Get("Octopus.Action.GoogleCloud.Zone")?.Trim(); if (!string.IsNullOrEmpty(project)) { googleCloudEnvironmentVariables.Add("GOOGLE_PROJECT", project); Log.Verbose($"{project} has been set to GOOGLE_PROJECT environment variable"); } if (!string.IsNullOrEmpty(region)) { googleCloudEnvironmentVariables.Add("GOOGLE_REGION", region); Log.Verbose($"{region} has been set to GOOGLE_REGION environment variable"); } if (!string.IsNullOrEmpty(zone)) { googleCloudEnvironmentVariables.Add("GOOGLE_ZONE", zone); Log.Verbose($"{zone} has been set to GOOGLE_ZONE environment variable"); } return(googleCloudEnvironmentVariables); }
public void ReplaceVariables(string currentDirectory, List <string> targets) { var onlyPerformJsonReplacement = variables.GetFlag(ActionVariables.StructuredConfigurationFallbackFlag); foreach (var target in targets) { if (fileSystem.DirectoryExists(target)) { log.Warn($"Skipping structured variable replacement on '{target}' because it is a directory."); continue; } var matchingFiles = MatchingFiles(currentDirectory, target); if (!matchingFiles.Any()) { log.Warn($"No files were found that match the replacement target pattern '{target}'"); continue; } foreach (var filePath in matchingFiles) { var replacersToTry = GetReplacersToTryForFile(filePath, onlyPerformJsonReplacement).ToArray(); log.Verbose($"The registered replacers we will try, in order, are: " + string.Join(",", replacersToTry.Select(r => r.GetType().Name))); DoReplacement(filePath, variables, replacersToTry); } } }
string[] GetFilesToSubstitute(IVariables variables) { var isEnableNoMatchWarningSet = variables.IsSet(PackageVariables.EnableNoMatchWarning); var additionalFileSubstitutions = GetAdditionalFileSubstitutions(variables); if (!isEnableNoMatchWarningSet) { var hasAdditionalSubstitutions = !string.IsNullOrEmpty(additionalFileSubstitutions); variables.AddFlag(PackageVariables.EnableNoMatchWarning, hasAdditionalSubstitutions); } var result = new List <string>(); var runAutomaticFileSubstitution = variables.GetFlag(TerraformSpecialVariables.Action.Terraform.RunAutomaticFileSubstitution, true); if (runAutomaticFileSubstitution) { result.AddRange(new[] { "**/*.tf", "**/*.tf.json", "**/*.tfvars", "**/*.tfvars.json" }); } var additionalFileSubstitution = additionalFileSubstitutions; if (!string.IsNullOrWhiteSpace(additionalFileSubstitution)) { result.AddRange(additionalFileSubstitution.Split(new[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries)); } return(result.ToArray()); }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); var configurationTransformer = ConfigurationTransformer.FromVariables(variables); var transformFileLocator = new TransformFileLocator(fileSystem); var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors)); var jsonVariableReplacer = new JsonConfigurationVariableReplacer(); ValidateArguments(); WriteVariableScriptToFile(); var conventions = new List <IConvention> { new StageScriptPackagesConvention(packageFile, fileSystem, new CombinedPackageExtractor(log)), // Substitute the script source file new DelegateInstallConvention(d => substituteInFiles.Substitute(d, ScriptFileTargetFactory(d).ToList())), // Substitute any user-specified files new DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)), new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator), new ConfigurationVariablesConvention(fileSystem, replacer), new JsonConfigurationVariablesConvention(jsonVariableReplacer, fileSystem), new ExecuteScriptConvention(scriptEngine, commandLineRunner) }; var deployment = new RunningDeployment(packageFile, variables); var conventionRunner = new ConventionProcessor(deployment, conventions); conventionRunner.RunConventions(); var exitCode = variables.GetInt32(SpecialVariables.Action.Script.ExitCode); deploymentJournalWriter.AddJournalEntry(deployment, exitCode == 0, packageFile); return(exitCode.Value); }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); Guard.NotNullOrWhiteSpace(pathToPackage, "No package file was specified. Please pass --package YourPackage.nupkg"); if (!File.Exists(pathToPackage)) { throw new CommandException("Could not find package file: " + pathToPackage); } Log.Info("Deploying package: " + pathToPackage); var account = new AzureAccount(variables); var fileSystem = new WindowsPhysicalFileSystem(); var embeddedResources = new AssemblyEmbeddedResources(); var azurePackageUploader = new AzurePackageUploader(log); var certificateStore = new CalamariCertificateStore(); var cloudCredentialsFactory = new SubscriptionCloudCredentialsFactory(certificateStore); var cloudServiceConfigurationRetriever = new AzureCloudServiceConfigurationRetriever(); var configurationTransformer = ConfigurationTransformer.FromVariables(variables); var transformFileLocator = new TransformFileLocator(fileSystem); var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors)); var jsonVariablesReplacer = new JsonConfigurationVariableReplacer(); var conventions = new List <IConvention> { new SwapAzureDeploymentConvention(fileSystem, embeddedResources, scriptEngine, commandLineRunner), new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)), new FindCloudServicePackageConvention(fileSystem), new EnsureCloudServicePackageIsCtpFormatConvention(fileSystem), new ExtractAzureCloudServicePackageConvention(log, fileSystem), new ChooseCloudServiceConfigurationFileConvention(fileSystem), new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner), new PackagedScriptConvention(log, DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner), new ConfigureAzureCloudServiceConvention(account, fileSystem, cloudCredentialsFactory, cloudServiceConfigurationRetriever, certificateStore), new DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)), new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator), new ConfigurationVariablesConvention(fileSystem, replacer), new JsonConfigurationVariablesConvention(jsonVariablesReplacer, fileSystem), new PackagedScriptConvention(log, DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new RePackageCloudServiceConvention(fileSystem), new UploadAzureCloudServicePackageConvention(fileSystem, azurePackageUploader, cloudCredentialsFactory), new DeployAzureCloudServicePackageConvention(fileSystem, embeddedResources, scriptEngine, commandLineRunner), 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); }
void ImportCertificate() { var certificateVariable = GetMandatoryVariable(variables, SpecialVariables.Action.Certificate.CertificateVariable); var pfxBytes = Convert.FromBase64String(GetMandatoryVariable(variables, $"{certificateVariable}.{CertificateVariables.Properties.Pfx}")); var password = variables.Get($"{certificateVariable}.{CertificateVariables.Properties.Password}"); var thumbprint = variables.Get($"{certificateVariable}.{CertificateVariables.Properties.Thumbprint}"); var storeName = GetMandatoryVariable(variables, SpecialVariables.Action.Certificate.StoreName); var privateKeyExportable = variables.GetFlag(SpecialVariables.Action.Certificate.PrivateKeyExportable, false); // Either a store-location (LocalMachine or CurrentUser) or a user can be supplied StoreLocation storeLocation; var locationSpecified = Enum.TryParse(variables.Get(SpecialVariables.Action.Certificate.StoreLocation), out storeLocation); ValidateStore(locationSpecified ? (StoreLocation?)storeLocation : null, storeName); try { if (locationSpecified) { Log.Info( $"Importing certificate '{variables.Get($"{certificateVariable}.{CertificateVariables.Properties.Subject}")}' with thumbprint '{thumbprint}' into store '{storeLocation}\\{storeName}'"); WindowsX509CertificateStore.ImportCertificateToStore(pfxBytes, password, storeLocation, storeName, privateKeyExportable); if (storeLocation == StoreLocation.LocalMachine) { // Set private-key access var privateKeyAccessRules = GetPrivateKeyAccessRules(variables); if (privateKeyAccessRules.Any()) { WindowsX509CertificateStore.AddPrivateKeyAccessRules(thumbprint, storeLocation, storeName, privateKeyAccessRules); } } } else // Import into a specific user's store { var storeUser = variables.Get(SpecialVariables.Action.Certificate.StoreUser); if (string.IsNullOrWhiteSpace(storeUser)) { throw new CommandException( $"Either '{SpecialVariables.Action.Certificate.StoreLocation}' or '{SpecialVariables.Action.Certificate.StoreUser}' must be supplied"); } Log.Info( $"Importing certificate '{variables.Get($"{certificateVariable}.{CertificateVariables.Properties.Subject}")}' with thumbprint '{thumbprint}' into store '{storeName}' for user '{storeUser}'"); WindowsX509CertificateStore.ImportCertificateToStore(pfxBytes, password, storeUser, storeName, privateKeyExportable); } } catch (Exception) { Log.Error("There was an error importing the certificate into the store"); throw; } }
void UpdateConfigurationWithCurrentInstanceCount(XContainer localConfigurationFile, string configurationFileName, IVariables variables) { if (!variables.GetFlag(SpecialVariables.Action.Azure.UseCurrentInstanceCount)) { return; } var serviceName = variables.Get(SpecialVariables.Action.Azure.CloudServiceName); var slot = (DeploymentSlot)Enum.Parse(typeof(DeploymentSlot), variables.Get(SpecialVariables.Action.Azure.Slot)); var remoteConfigurationFile = configurationRetriever.GetConfiguration( certificateStore, account, serviceName, slot); if (remoteConfigurationFile == null) { Log.Info("There is no current deployment of service '{0}' in slot '{1}', so existing instance counts will not be imported.", serviceName, slot); return; } var rolesByCount = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); Log.Verbose("Local instance counts (from " + Path.GetFileName(configurationFileName) + "): "); WithInstanceCounts(localConfigurationFile, (roleName, attribute) => { Log.Verbose(" - " + roleName + " = " + attribute.Value); string value; if (rolesByCount.TryGetValue(roleName, out value)) { attribute.SetValue(value); } }); Log.Verbose("Remote instance counts: "); WithInstanceCounts(remoteConfigurationFile, (roleName, attribute) => { rolesByCount[roleName] = attribute.Value; Log.Verbose(" - " + roleName + " = " + attribute.Value); }); Log.Verbose("Replacing local instance count settings with remote settings: "); WithInstanceCounts(localConfigurationFile, (roleName, attribute) => { string value; if (!rolesByCount.TryGetValue(roleName, out value)) { return; } attribute.SetValue(value); Log.Verbose(" - " + roleName + " = " + attribute.Value); }); }
public void Dispose() { var attachLogFile = variables.GetFlag(TerraformSpecialVariables.Action.Terraform.AttachLogFile); if (attachLogFile) { var crashLogPath = Path.Combine(deployment.CurrentDirectory, "crash.log"); if (fileSystem.FileExists(logPath)) { log.NewOctopusArtifact(fileSystem.GetFullPath(logPath), fileSystem.GetFileName(logPath), fileSystem.GetFileSize(logPath)); } //When terraform crashes, the information would be contained in the crash.log file. We should attach this since //we don't want to blow that information away in case it provides something relevant https://www.terraform.io/docs/internals/debugging.html#interpreting-a-crash-log if (fileSystem.FileExists(crashLogPath)) { log.NewOctopusArtifact(fileSystem.GetFullPath(crashLogPath), fileSystem.GetFileName(crashLogPath), fileSystem.GetFileSize(crashLogPath)); } } }
private static void ApplyPreserveAppDataDeploymentRule(DeploymentSyncOptions syncOptions, IVariables variables) { // If PreserveAppData variable set, then create SkipDelete rules for App_Data directory // ReSharper disable once InvertIf if (variables.GetFlag(SpecialVariables.Action.Azure.PreserveAppData)) { syncOptions.Rules.Add(new DeploymentSkipRule("SkipDeleteDataFiles", "Delete", "filePath", "\\\\App_Data\\\\.*", null)); syncOptions.Rules.Add(new DeploymentSkipRule("SkipDeleteDataDir", "Delete", "dirPath", "\\\\App_Data(\\\\.*|$)", null)); } }
public void SubstituteBasedSettingsInSuppliedVariables(RunningDeployment deployment) { var substituteInFilesEnabled = variables.GetFlag(PackageVariables.SubstituteInFilesEnabled); if (!substituteInFilesEnabled) { return; } var filesToTarget = variables.GetPaths(PackageVariables.SubstituteInFilesTargets); Substitute(deployment, filesToTarget); }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); var runner = new CommandLineRunner(ConsoleLog.Instance, variables); Log.VerboseFormat("Executing '{0}'", scriptFile); var result = scriptEngine.Execute(new Script(scriptFile, ""), variables, runner); if (result.ExitCode == 0 && result.HasErrors && variables.GetFlag(SpecialVariables.Action.FailScriptOnErrorOutput, false)) { return(-1); } return(result.ExitCode); }
private static void ApplyAppOfflineDeploymentRule(DeploymentSyncOptions syncOptions, IVariables variables) { // ReSharper disable once InvertIf if (variables.GetFlag(SpecialVariables.Action.Azure.AppOffline)) { var rules = Microsoft.Web.Deployment.DeploymentSyncOptions.GetAvailableRules(); if (rules.TryGetValue("AppOffline", out var rule)) { syncOptions.Rules.Add(rule); } else { Log.Verbose("Azure Deployment API does not support `AppOffline` deployment rule."); } } }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); Guard.NotNullOrWhiteSpace(pathToPackage, "No package file was specified. Please pass --package YourPackage.nupkg"); if (!File.Exists(pathToPackage)) { throw new CommandException("Could not find package file: " + pathToPackage); } Log.Info("Deploying package: " + pathToPackage); var fileSystem = new WindowsPhysicalFileSystem(); var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors)); var jsonReplacer = new JsonConfigurationVariableReplacer(); var configurationTransformer = ConfigurationTransformer.FromVariables(variables); var transformFileLocator = new TransformFileLocator(fileSystem); 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 DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)), new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator), new ConfigurationVariablesConvention(fileSystem, replacer), new JsonConfigurationVariablesConvention(jsonReplacer, fileSystem), new PackagedScriptConvention(log, DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new AzureWebAppConvention(log), new LogAzureWebAppDetails(log), 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); }
string[] GetFilesToSubstitute() { var result = new List <string>(); var runAutomaticFileSubstitution = variables.GetFlag(TerraformSpecialVariables.Action.Terraform.RunAutomaticFileSubstitution, true); if (runAutomaticFileSubstitution) { result.AddRange(new[] { "**/*.tf", "**/*.tf.json", "**/*.tfvars", "**/*.tfvars.json" }); } var additionalFileSubstitution = GetAdditionalFileSubstitutions(); if (!string.IsNullOrWhiteSpace(additionalFileSubstitution)) { result.AddRange(additionalFileSubstitution.Split(new[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries)); } return(result.ToArray()); }
public void EnsureDiskHasEnoughFreeSpace(string directoryPath) { if (CalamariEnvironment.IsRunningOnMono && CalamariEnvironment.IsRunningOnMac) { //After upgrading to macOS 10.15.2, and mono 5.14.0, drive.TotalFreeSpace and drive.AvailableFreeSpace both started returning 0. //see https://github.com/mono/mono/issues/17151, which was fixed in mono 6.4.xx //If we upgrade mono past 5.14.x, scriptcs stops working. //Rock and a hard place. Log.Verbose("Unable to determine disk free space under Mono on macOS. Assuming there's enough."); return; } if (variables.GetFlag(skipFreeDiskSpaceCheckVariable)) { Log.Verbose($"{skipFreeDiskSpaceCheckVariable} is enabled. The check to ensure that the drive containing the directory '{directoryPath}' on machine '{Environment.MachineName}' has enough free space will be skipped."); return; } ulong requiredSpaceInBytes = 500L * 1024 * 1024; var freeSpaceOverrideInMegaBytes = variables.GetInt32(freeDiskSpaceOverrideInMegaBytesVariable); if (freeSpaceOverrideInMegaBytes.HasValue) { requiredSpaceInBytes = (ulong)freeSpaceOverrideInMegaBytes * 1024 * 1024; Log.Verbose($"{freeDiskSpaceOverrideInMegaBytesVariable} has been specified. We will check and ensure that the drive containing the directory '{directoryPath}' on machine '{Environment.MachineName}' has {((ulong) requiredSpaceInBytes).ToFileSizeString()} free disk space."); } var success = fileSystem.GetDiskFreeSpace(directoryPath, out ulong totalNumberOfFreeBytes); if (!success) { return; } if (totalNumberOfFreeBytes < requiredSpaceInBytes) { throw new CommandException($"The drive containing the directory '{directoryPath}' on machine '{Environment.MachineName}' does not have enough free disk space available for this operation to proceed. The disk only has {totalNumberOfFreeBytes.ToFileSizeString()} available; please free up at least {requiredSpaceInBytes.ToFileSizeString()}."); } }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); var contents = variables.Get(SpecialVariables.Execution.Manifest); if (contents == null) { throw new CommandException("Execution manifest not found in variables."); } var instructions = JsonConvert.DeserializeObject <Instruction[]>(contents, JsonSerialization.GetDefaultSerializerSettings()); if (instructions.Length == 0) { throw new CommandException("The execution manifest must have at least one instruction."); } foreach (var instruction in instructions) { var tool = executionTools.First(x => x.Metadata.Tool == instruction.Launcher); var result = tool.Value.Execute(instruction.LauncherInstructionsRaw); if (result != 0) { return(result); } if (variables.GetFlag(KnownVariables.Action.SkipRemainingConventions)) { break; } } return(0); }
public void DoTransforms(string currentDirectory) { var appliedAsTransforms = variables.GetStrings(KnownVariables.AppliedXmlConfigTransforms, '|'); log.Verbose("Looking for appSettings, applicationSettings, and connectionStrings in any .config files"); if (variables.GetFlag(KnownVariables.Package.IgnoreVariableReplacementErrors)) { log.Info("Variable replacement errors are suppressed because the variable Octopus.Action.Package.IgnoreVariableReplacementErrors has been set."); } foreach (var configurationFile in MatchingFiles(currentDirectory)) { if (appliedAsTransforms.Contains(configurationFile)) { log.VerboseFormat("File '{0}' was interpreted as an XML configuration transform; variable substitution won't be attempted.", configurationFile); continue; } replacer.ModifyConfigurationFile(configurationFile, variables); } }
public void Substitute(string currentDirectory, IList <string> filesToTarget, bool warnIfFileNotFound = true) { foreach (var target in filesToTarget) { var matchingFiles = MatchingFiles(currentDirectory, target); if (!matchingFiles.Any()) { if (warnIfFileNotFound && variables.GetFlag(PackageVariables.EnableNoMatchWarning, true)) { log.WarnFormat("No files were found in {0} that match the substitution target pattern '{1}'", currentDirectory, target); } continue; } foreach (var file in matchingFiles) { substituter.PerformSubstitution(file, variables); } } }
string BuildParams(NodeInstructions instructions, string sensitiveVariablesFilePath) { var parameters = new List <string>(); var debugMode = variables.GetFlag(DebugVariableName, false); if (debugMode) { parameters.Add("--inspect-brk"); } var pathToBootstrapperFolder = variables.Get(instructions.BootstrapperPathVariable); var pathToBootstrapper = Path.Combine(pathToBootstrapperFolder, "bootstrapper.js"); parameters.Add(pathToBootstrapper); parameters.Add(instructions.BootstrapperInvocationCommand); var pathToStepPackage = variables.Get(instructions.TargetPathVariable); parameters.Add(pathToStepPackage); parameters.Add(sensitiveVariablesFilePath); parameters.Add(options.InputVariables.SensitiveVariablesPassword); parameters.Add(AesEncryption.SaltRaw); if (string.Equals(instructions.BootstrapperInvocationCommand, "Execute", StringComparison.OrdinalIgnoreCase)) { parameters.Add(instructions.InputsVariable); parameters.Add(instructions.DeploymentTargetInputsVariable); } else if (string.Equals(instructions.BootstrapperInvocationCommand, "Discover", StringComparison.OrdinalIgnoreCase)) { parameters.Add(instructions.TargetDiscoveryContextVariable); } else { throw new CommandException($"Unknown bootstrapper invocation command: '{instructions.BootstrapperInvocationCommand}'"); } return(string.Join(" ", parameters.Select(p => $"\"{p}\""))); }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); Guard.NotNullOrWhiteSpace(archiveFile, "No archive file was specified. Please pass --archive YourPackage.jar"); JavaRuntime.VerifyExists(); if (!File.Exists(archiveFile)) { throw new CommandException("Could not find archive file: " + archiveFile); } Log.Info("Deploying: " + archiveFile); var semaphore = SemaphoreFactory.Get(); var journal = new DeploymentJournal(fileSystem, semaphore, variables); var allFileFormatReplacers = FileFormatVariableReplacers.BuildAllReplacers(fileSystem, log); var structuredConfigVariablesService = new StructuredConfigVariablesService(allFileFormatReplacers, fileSystem, log); var jarTools = new JarTool(commandLineRunner, log, variables); var packageExtractor = new JarPackageExtractor(jarTools); var embeddedResources = new AssemblyEmbeddedResources(); var javaRunner = new JavaRunner(commandLineRunner, variables); var featureClasses = new List <IFeature> { new TomcatFeature(javaRunner), new WildflyFeature(javaRunner) }; var deployExploded = variables.GetFlag(SpecialVariables.Action.Java.DeployExploded); var conventions = new List <IConvention> { new AlreadyInstalledConvention(log, journal), // If we are deploying the package exploded then extract directly to the application directory. // Else, if we are going to re-pack, then we extract initially to a temporary directory deployExploded ? (IInstallConvention) new DelegateInstallConvention(d => extractPackage.ExtractToApplicationDirectory(archiveFile, packageExtractor)) : new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(archiveFile, packageExtractor)), new FeatureConvention(DeploymentStages.BeforePreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new ConfiguredScriptConvention(new PreDeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)), new PackagedScriptConvention(new PreDeployPackagedScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)), new FeatureConvention(DeploymentStages.AfterPreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new SubstituteInFilesConvention(new SubstituteInFilesBehaviour(substituteInFiles)), new StructuredConfigurationVariablesConvention(new StructuredConfigurationVariablesBehaviour(structuredConfigVariablesService)), new RePackArchiveConvention(log, fileSystem, jarTools), new CopyPackageToCustomInstallationDirectoryConvention(fileSystem), new FeatureConvention(DeploymentStages.BeforeDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new PackagedScriptConvention(new DeployPackagedScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)), new ConfiguredScriptConvention(new DeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)), new FeatureConvention(DeploymentStages.AfterDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new FeatureConvention(DeploymentStages.BeforePostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new PackagedScriptConvention(new PostDeployPackagedScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)), new ConfiguredScriptConvention(new PostDeployConfiguredScriptBehaviour(log, fileSystem, scriptEngine, commandLineRunner)), new FeatureConvention(DeploymentStages.AfterPostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new RollbackScriptConvention(log, DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner), new FeatureRollbackConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner, embeddedResources) }; var deployment = new RunningDeployment(archiveFile, variables); var conventionRunner = new ConventionProcessor(deployment, conventions, log); try { conventionRunner.RunConventions(); if (!deployment.SkipJournal) { journal.AddJournalEntry(new JournalEntry(deployment, true)); } } catch (Exception) { if (!deployment.SkipJournal) { journal.AddJournalEntry(new JournalEntry(deployment, false)); } throw; } return(0); }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); Guard.NotNullOrWhiteSpace(pathToPackage, "No package file was specified. Please pass --package YourPackage.nupkg"); if (!File.Exists(pathToPackage)) { throw new CommandException("Could not find package file: " + pathToPackage); } Log.Info("Deploying package: " + pathToPackage); var featureClasses = new List <IFeature>(); var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors)); var generator = new JsonConfigurationVariableReplacer(); var configurationTransformer = ConfigurationTransformer.FromVariables(variables); var transformFileLocator = new TransformFileLocator(fileSystem); var embeddedResources = new AssemblyEmbeddedResources(); #if IIS_SUPPORT var iis = new InternetInformationServer(); featureClasses.AddRange(new IFeature[] { new IisWebSiteBeforeDeployFeature(), new IisWebSiteAfterPostDeployFeature() }); #endif if (!CalamariEnvironment.IsRunningOnWindows) { featureClasses.Add(new NginxFeature(NginxServer.AutoDetect(), fileSystem)); } var semaphore = SemaphoreFactory.Get(); var journal = new DeploymentJournal(fileSystem, semaphore, variables); var conventions = new List <IConvention> { new AlreadyInstalledConvention(log, journal), new DelegateInstallConvention(d => extractPackage.ExtractToApplicationDirectory(pathToPackage)), new FeatureConvention(DeploymentStages.BeforePreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner), new PackagedScriptConvention(log, DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner), new FeatureConvention(DeploymentStages.AfterPreDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)), new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator), new ConfigurationVariablesConvention(fileSystem, replacer), new JsonConfigurationVariablesConvention(generator, fileSystem), new CopyPackageToCustomInstallationDirectoryConvention(fileSystem), new FeatureConvention(DeploymentStages.BeforeDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new PackagedScriptConvention(log, DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new FeatureConvention(DeploymentStages.AfterDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), #if IIS_SUPPORT new LegacyIisWebSiteConvention(fileSystem, iis), #endif new FeatureConvention(DeploymentStages.BeforePostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new PackagedScriptConvention(log, DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner), new ConfiguredScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner), new FeatureConvention(DeploymentStages.AfterPostDeploy, featureClasses, fileSystem, scriptEngine, commandLineRunner, embeddedResources), new RollbackScriptConvention(log, DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner), new FeatureRollbackConvention(DeploymentStages.DeployFailed, fileSystem, scriptEngine, commandLineRunner, embeddedResources) }; var deployment = new RunningDeployment(pathToPackage, variables); var conventionRunner = new ConventionProcessor(deployment, conventions); try { conventionRunner.RunConventions(); if (!deployment.SkipJournal) { journal.AddJournalEntry(new JournalEntry(deployment, true)); } } catch (Exception) { if (!deployment.SkipJournal) { journal.AddJournalEntry(new JournalEntry(deployment, false)); } throw; } return(0); }
public ConfigurationVariablesReplacer(IVariables variables, ILog log) { this.log = log; ignoreVariableReplacementErrors = variables.GetFlag(KnownVariables.Package.IgnoreVariableReplacementErrors); }
public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); if (!ServiceFabricHelper.IsServiceFabricSdkKeyInRegistry()) { throw new CommandException("Could not find the Azure Service Fabric SDK on this server. This SDK is required before running Service Fabric commands."); } Guard.NotNullOrWhiteSpace(pathToPackage, "No package file was specified. Please pass --package YourPackage.nupkg"); if (!File.Exists(pathToPackage)) { throw new CommandException("Could not find package file: " + pathToPackage); } Log.Info("Deploying package: " + pathToPackage); var fileSystem = new WindowsPhysicalFileSystem(); var embeddedResources = new AssemblyEmbeddedResources(); var replacer = new ConfigurationVariablesReplacer(variables.GetFlag(SpecialVariables.Package.IgnoreVariableReplacementErrors)); var jsonReplacer = new JsonConfigurationVariableReplacer(); var configurationTransformer = ConfigurationTransformer.FromVariables(variables); var transformFileLocator = new TransformFileLocator(fileSystem); var conventions = new List <IConvention> { new DelegateInstallConvention(d => extractPackage.ExtractToStagingDirectory(pathToPackage)), // PreDeploy stage new ConfiguredScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner), new PackagedScriptConvention(log, DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner), // Standard variable and transform replacements new DelegateInstallConvention(d => substituteInFiles.SubstituteBasedSettingsInSuppliedVariables(d)), new ConfigurationTransformsConvention(fileSystem, configurationTransformer, transformFileLocator), new ConfigurationVariablesConvention(fileSystem, replacer), new JsonConfigurationVariablesConvention(jsonReplacer, fileSystem), // Deploy stage new PackagedScriptConvention(log, DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new ConfiguredScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), // Variable replacement new SubstituteVariablesInAzureServiceFabricPackageConvention(fileSystem, fileSubstituter), // Main Service Fabric deployment script execution new EnsureCertificateInstalledInStoreConvention(certificateStore, SpecialVariables.Action.ServiceFabric.ClientCertVariable, SpecialVariables.Action.ServiceFabric.CertificateStoreLocation, SpecialVariables.Action.ServiceFabric.CertificateStoreName), new DeployAzureServiceFabricAppConvention(log, fileSystem, embeddedResources, scriptEngine, commandLineRunner), // PostDeploy stage 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); }