public override int Execute(string[] commandLineArguments) { Options.Parse(commandLineArguments); Guard.NotNullOrWhiteSpace(packageFile, "No package file was specified. Please pass --package YourPackage.nupkg"); if (!File.Exists(packageFile)) throw new CommandException("Could not find package file: " + packageFile); if (variablesFile != null && !File.Exists(variablesFile)) throw new CommandException("Could not find variables file: " + variablesFile); Log.Info("Deploying package: " + packageFile); if (variablesFile != null) Log.Info("Using variables from: " + variablesFile); var variables = new VariableDictionary(variablesFile); var fileSystem = new WindowsPhysicalFileSystem(); var embeddedResources = new ExecutingAssemblyEmbeddedResources(); var scriptEngine = new CombinedScriptEngine(); var commandLineRunner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables))); var azurePackageUploader = new AzurePackageUploader(); var certificateStore = new CalamariCertificateStore(); var cloudCredentialsFactory = new SubscriptionCloudCredentialsFactory(certificateStore); var cloudServiceConfigurationRetriever = new AzureCloudServiceConfigurationRetriever(); var substituter = new FileSubstituter(); var configurationTransformer = new ConfigurationTransformer(variables.GetFlag(SpecialVariables.Package.IgnoreConfigTransformationErrors), variables.GetFlag(SpecialVariables.Package.SuppressConfigTransformationLogging)); var replacer = new ConfigurationVariablesReplacer(); var conventions = new List<IConvention> { new ContributeEnvironmentVariablesConvention(), new LogVariablesConvention(), new ExtractPackageToStagingDirectoryConvention(new LightweightPackageExtractor(), fileSystem), new FindCloudServicePackageConvention(fileSystem), new EnsureCloudServicePackageIsCtpFormatConvention(fileSystem), new ExtractAzureCloudServicePackageConvention(fileSystem), new ChooseCloudServiceConfigurationFileConvention(fileSystem), new ConfiguredScriptConvention(DeploymentStages.PreDeploy, scriptEngine, fileSystem, commandLineRunner), new PackagedScriptConvention(DeploymentStages.PreDeploy, fileSystem, scriptEngine, commandLineRunner), new ConfigureAzureCloudServiceConvention(fileSystem, cloudCredentialsFactory, cloudServiceConfigurationRetriever), new SubstituteInFilesConvention(fileSystem, substituter), new ConfigurationTransformsConvention(fileSystem, configurationTransformer), new ConfigurationVariablesConvention(fileSystem, replacer), new PackagedScriptConvention(DeploymentStages.Deploy, fileSystem, scriptEngine, commandLineRunner), new ConfiguredScriptConvention(DeploymentStages.Deploy, scriptEngine, fileSystem, commandLineRunner), new RePackageCloudServiceConvention(fileSystem), new UploadAzureCloudServicePackageConvention(fileSystem, azurePackageUploader, cloudCredentialsFactory), new DeployAzureCloudServicePackageConvention(fileSystem, embeddedResources, scriptEngine, commandLineRunner), new PackagedScriptConvention(DeploymentStages.PostDeploy, fileSystem, scriptEngine, commandLineRunner), new ConfiguredScriptConvention(DeploymentStages.PostDeploy, scriptEngine, fileSystem, commandLineRunner), }; var deployment = new RunningDeployment(packageFile, variables); var conventionRunner = new ConventionProcessor(deployment, conventions); conventionRunner.RunConventions(); return 0; }
public void PerformSubstitution(string sourceFile, VariableDictionary variables, string targetFile) { var source = File.ReadAllText(sourceFile); var result = variables.Evaluate(source); File.WriteAllText(targetFile, result); }
public OctopusConfigurationProviderTests() { Options = new OctopusConfigurationProviderOptions(); VariableDictionaryProvider = new Mock<IVariableDictionaryProvider>(); VariableDictionary = new VariableDictionary(); VariableDictionaryProvider.Setup(value => value.Get(Options)).Returns(VariableDictionary); }
public CalamariVariableDictionary(string storageFilePath, string sensitiveFilePath, string sensitiveFilePassword) { var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem(); if (!string.IsNullOrEmpty(storageFilePath)) { if (!fileSystem.FileExists(storageFilePath)) throw new CommandException("Could not find variables file: " + storageFilePath); var nonSensitiveVariables = new VariableDictionary(storageFilePath); nonSensitiveVariables.GetNames().ForEach(name => Set(name, nonSensitiveVariables.GetRaw(name))); } if (!string.IsNullOrEmpty(sensitiveFilePath)) { var rawVariables = string.IsNullOrWhiteSpace(sensitiveFilePassword) ? fileSystem.ReadFile(sensitiveFilePath) : Decrypt(fileSystem.ReadAllBytes(sensitiveFilePath), sensitiveFilePassword); try { var sensitiveVariables = JsonConvert.DeserializeObject<Dictionary<string, string>>(rawVariables); foreach (var variable in sensitiveVariables) { SetSensitive(variable.Key, variable.Value); } } catch (JsonReaderException) { throw new CommandException("Unable to parse sensitive-variables as valid JSON."); } } }
public void SetUp() { variables = new VariableDictionary(); variables.Set(SpecialVariables.OriginalPackageDirectoryPath, stagingDirectory); fileSystem = Substitute.For<ICalamariFileSystem>(); deployment = new RunningDeployment(packageFilePath, variables); }
public void Deploy() { OctopusTestAzureSubscription.IgnoreIfCertificateNotInstalled(); var nugetPackageFile = PackageBuilder.BuildSamplePackage("Octopus.Sample.AzureCloudService", "1.0.0"); var variablesFile = Path.GetTempFileName(); var variables = new VariableDictionary(); OctopusTestAzureSubscription.PopulateVariables(variables); OctopusTestCloudService.PopulateVariables(variables); variables.Set(SpecialVariables.Action.Azure.Slot, "Staging"); variables.Set(SpecialVariables.Action.Azure.SwapIfPossible, false.ToString()); variables.Set(SpecialVariables.Action.Azure.UseCurrentInstanceCount, false.ToString()); variables.Set(SpecialVariables.Action.Name, "AzureCloudService"); variables.Set(SpecialVariables.Release.Number, "1.0.0"); // Disable cspkg extraction variables.Set(SpecialVariables.Action.Azure.CloudServicePackageExtractionDisabled, true.ToString()); fileSystem = new WindowsPhysicalFileSystem(); stagingDirectory = Path.GetTempPath(); variables.Set(SpecialVariables.Action.Azure.PackageExtractionPath, stagingDirectory); variables.Save(variablesFile); result = Invoke( Calamari() .Action("deploy-azure-cloud-service") .Argument("package", nugetPackageFile) .Argument("variables", variablesFile)); }
public void PerformSubstitution(string sourceFile, VariableDictionary variables, string targetFile) { var source = fileSystem.ReadFile(sourceFile); var encoding = GetEncoding(sourceFile, variables); var result = variables.Evaluate(source); fileSystem.OverwriteFile(targetFile, result, encoding); }
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); var variables = new VariableDictionary(); variables.Set(SpecialVariables.Action.Azure.CloudServicePackagePath, packageFile); variables.Set(SpecialVariables.OriginalPackageDirectoryPath, !string.IsNullOrWhiteSpace(destinationDirectory) ? destinationDirectory : Path.GetDirectoryName(packageFile)); var fileSystem = new WindowsPhysicalFileSystem(); var conventions = new List<IConvention> { new EnsureCloudServicePackageIsCtpFormatConvention(fileSystem), new ExtractAzureCloudServicePackageConvention(fileSystem), }; var deployment = new RunningDeployment(packageFile, variables); var conventionRunner = new ConventionProcessor(deployment, conventions); conventionRunner.RunConventions(); return 0; }
static void AddVariables(VariableDictionary variableDictionary, IDictionary<string, string> items) { foreach (var variableName in items.Keys) { variableDictionary.Set(variableName, items[variableName]); } }
protected CalamariResult Invoke(CommandLine command, VariableDictionary variables) { var capture = new CaptureCommandOutput(); var runner = new CommandLineRunner(new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables), capture)); var result = runner.Execute(command.Build()); return new CalamariResult(result.ExitCode, capture); }
static void UpdateConfigurationSettings(XContainer configurationFile, VariableDictionary variables) { Log.Verbose("Updating configuration settings..."); var foundSettings = false; WithConfigurationSettings(configurationFile, (roleName, settingName, settingValueAttribute) => { var setting = variables.Get(roleName + "/" + settingName) ?? variables.Get(roleName + "\\" + settingName) ?? variables.Get(settingName) ?? (variables.GetNames().Contains(settingName) ? "" : null); if (setting != null) { foundSettings = true; Log.Info("Updating setting for role {0}: {1} = {2}", roleName, settingName, setting); settingValueAttribute.Value = setting; } }); if (!foundSettings) { Log.Info("No settings that match provided variables were found."); } }
public void SetUp() { fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem(); // Ensure tenticle directory exists tentacleDirectory = Path.Combine(Path.GetTempPath(), "CalamariTestTentacle"); var tentacleHiddenDirectory = Path.Combine(tentacleDirectory, ".tentacle"); fileSystem.EnsureDirectoryExists(tentacleDirectory); fileSystem.EnsureDirectoryExists(tentacleHiddenDirectory); fileSystem.PurgeDirectory(tentacleHiddenDirectory, FailureOptions.ThrowOnFailure); Environment.SetEnvironmentVariable("TentacleJournal", Path.Combine(tentacleHiddenDirectory, "DeploymentJournal.xml" )); variables = new VariableDictionary(); variables.EnrichWithEnvironmentVariables(); deploymentJournal = new DeploymentJournal(fileSystem, new SystemSemaphore(), variables); packagesDirectory = Path.Combine(Path.GetTempPath(), "CalamariTestPackages"); fileSystem.EnsureDirectoryExists(packagesDirectory); stagingDirectory = Path.Combine(Path.GetTempPath(), "CalamariTestStaging"); fileSystem.EnsureDirectoryExists(stagingDirectory); // Create some artificats const string retentionPolicySet1 = "retentionPolicySet1"; CreateDeployment(Path.Combine(packagesDirectory, "Acme.1.0.0.nupkg"), Path.Combine(stagingDirectory, "Acme.1.0.0"), new DateTimeOffset(new DateTime(2015, 01, 26), new TimeSpan(10, 0,0)), retentionPolicySet1); CreateDeployment(Path.Combine(packagesDirectory, "Acme.1.1.0.nupkg"), Path.Combine(stagingDirectory, "Acme.1.1.0"), new DateTimeOffset(new DateTime(2015, 02, 01), new TimeSpan(10, 0,0)), retentionPolicySet1); CreateDeployment(Path.Combine(packagesDirectory, "Acme.1.2.0.nupkg"), Path.Combine(stagingDirectory, "Acme.1.2.0"), new DateTimeOffset(new DateTime(2015, 02, 10), new TimeSpan(10, 0,0)), retentionPolicySet1); }
static IEnumerable<string> ReplaceAppSettingOrConnectionString(XNode document, string xpath, string keyAttributeName, string keyAttributeValue, string valueAttributeName, VariableDictionary variables) { var changes = new List<string>(); var settings = ( from element in document.XPathSelectElements(xpath) let keyAttribute = element.Attribute(keyAttributeName) where keyAttribute != null where string.Equals(keyAttribute.Value, keyAttributeValue, StringComparison.InvariantCultureIgnoreCase) select element).ToList(); if (settings.Count == 0) return changes; var value = variables.Get(keyAttributeValue) ?? string.Empty; foreach (var setting in settings) { changes.Add(string.Format("Setting '{0}' = '{1}'", keyAttributeValue, value)); var valueAttribute = setting.Attribute(valueAttributeName); if (valueAttribute == null) { setting.Add(new XAttribute(valueAttributeName, value)); } else { valueAttribute.SetValue(value); } } return changes; }
void SetOutputVariable(string name, string value, VariableDictionary variables) { if (variables.Get(name) != value) { Log.SetOutputVariable(name, value, variables); } }
private static string BuildPath(string site, VariableDictionary variables) { var relativePath = (variables.Get(SpecialVariables.Action.Azure.PhysicalPath) ?? "").TrimStart('\\'); return relativePath != "" ? site + "\\" + relativePath : site; }
private string GetInitialExtractionDirectory(VariableDictionary variables) { var root = GetApplicationDirectoryPath(variables); root = AppendEnvironmentNameIfProvided(variables, root); fileSystem.EnsureDirectoryExists(root); fileSystem.EnsureDiskHasEnoughFreeSpace(root); return root; }
public void SetUp() { fileSystem = Substitute.For<ICalamariFileSystem>(); variables = new VariableDictionary(); variables.Set(SpecialVariables.OriginalPackageDirectoryPath, StagingDirectory); deployment = new RunningDeployment(StagingDirectory, variables); convention = new ChooseCloudServiceConfigurationFileConvention(fileSystem); }
public static void SetOutputVariable(string name, string value, VariableDictionary variables) { Info(String.Format("##octopus[setVariable name=\"{0}\" value=\"{1}\"]", ConvertServiceMessageValue(name), ConvertServiceMessageValue(value))); if (variables != null) variables.SetOutputVariable(name, value); }
private VariableDictionary AddEnvironmentVariables() { var variables = new VariableDictionary(); var convention = new ContributeEnvironmentVariablesConvention(); convention.Install(new RunningDeployment("C:\\Package.nupkg", variables)); Assert.That(variables.GetNames().Count, Is.GreaterThan(3)); Assert.That(variables.GetRaw(SpecialVariables.Tentacle.Agent.InstanceName), Is.EqualTo("#{env:TentacleInstanceName}")); return variables; }
public void SetUp() { variables = new VariableDictionary(); fileSystem = Substitute.For<ICalamariFileSystem>(); iis = Substitute.For<IInternetInformationServer>(); deployment = new RunningDeployment("C:\\packages", variables) { StagingDirectory = stagingDirectory }; }
string PerformTest(string sampleFile, VariableDictionary variables) { var temp = Path.GetTempFileName(); using (new TemporaryFile(temp)) { var substituter = new FileSubstituter(); substituter.PerformSubstitution(sampleFile, variables, temp); return File.ReadAllText(temp); } }
public void DoesNotAddXmlHeader() { var variables = new VariableDictionary(); variables.Set("WelcomeMessage", "Hello world"); variables.Set("LogFile", "C:\\Log.txt"); variables.Set("DatabaseConnection", null); var text = PerformTest(GetFixtureResouce("Samples", "NoHeader.config"), variables); Assert.That(text, Is.StringStarting("<configuration")); }
public static void PopulateVariables(VariableDictionary variables) { var certificate = GetCertificate(); variables.Set(SpecialVariables.Account.Name, "OctopusAzureTestAccount"); variables.Set(SpecialVariables.Account.AccountType, "AzureSubscription"); variables.Set(SpecialVariables.Action.Azure.CertificateBytes, Convert.ToBase64String(certificate.Export(X509ContentType.Pfx))); variables.Set(SpecialVariables.Action.Azure.CertificateThumbprint, CertificateThumbprint); variables.Set(SpecialVariables.Action.Azure.SubscriptionId, AzureSubscriptionId); }
public void ShouldKeepExistingValues() { var variables = new VariableDictionary(); variables.Set("MyMessage", "Hello world!"); variables.Set("EmailSettings:SmtpPort", "24"); variables.Set("EmailSettings:DefaultRecipients:Cc", "*****@*****.**"); var generated = Generate(variables, existingFile: "appsettings.existing-expected.json"); AssertJsonEquivalent(generated, "appsettings.existing-expected.json"); }
public void SetUp() { fileSystem = Substitute.For<ICalamariFileSystem>(); substituter = Substitute.For<IFileSubstituter>(); variables = new VariableDictionary(); deployment = new RunningDeployment(TestEnvironment.ConstructRootedPath("packages"), variables) { StagingDirectory = StagingDirectory }; }
string AppendEnvironmentNameIfProvided(VariableDictionary variables, string root) { var environment = variables.Get(SpecialVariables.Environment.Name); if (!string.IsNullOrWhiteSpace(environment)) { environment = fileSystem.RemoveInvalidFileNameChars(environment); root = Path.Combine(root, environment); } return root; }
public void ShouldIgnoreOctopusPrefix() { var variables = new VariableDictionary(); variables.Set("MyMessage", "Hello world"); variables.Set("IThinkOctopusIsGreat", "Yes, I do"); variables.Set("OctopusRocks", "This is ignored"); variables.Set("Octopus.Rocks", "So is this"); var generated = Generate(variables); AssertJsonEquivalent(generated, "appsettings.ignore-octopus.json"); }
public void SetUp() { extractor = Substitute.For<IPackageExtractor>(); extractor.GetMetadata(PackageLocation).Returns(new PackageMetadata { Id = "Acme.Web", Version = "1.0.0" }); fileSystem = Substitute.For<ICalamariFileSystem>(); fileSystem.RemoveInvalidFileNameChars(Arg.Any<string>()).Returns(c => c.Arg<string>().Replace("!", "")); variables = new VariableDictionary(); convention = new ExtractPackageToApplicationDirectoryConvention(extractor, fileSystem, new SystemSemaphore()); }
private int InvokeScript(VariableDictionary variables) { if (!File.Exists(scriptFile)) throw new CommandException("Could not find script file: " + scriptFile); var scriptEngine = new CombinedScriptEngine(); var runner = new CommandLineRunner( new SplitCommandOutput(new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables))); var result = scriptEngine.Execute(scriptFile, variables, runner); return result.ExitCode; }
protected CalamariResult Invoke(CommandLine command, VariableDictionary variables = null) { var capture = new CaptureCommandOutput(); var runner = new CommandLineRunner( new SplitCommandOutput( new ConsoleCommandOutput(), new ServiceMessageCommandOutput(variables ?? new VariableDictionary()), capture)); var result = runner.Execute(command.Build()); return(new CalamariResult(result.ExitCode, capture)); }
/// <summary> /// Initializes a new instance of the <see cref="ModelOptionsBase"/> class. /// </summary> protected ModelOptionsBase(VariableDictionary variables, string prefix) : base(variables, prefix) { // null so shared option is used this.Namespace = null; this.Directory = null; this.Generate = false; this.Include = new SelectionOptions(); this.Exclude = new SelectionOptions(); }
public void ShouldSetVariables() { var variables = new VariableDictionary(); var output = Invoke(Calamari() .Action("run-script") .Argument("script", MapSamplePath("Scripts\\CanSetVariable.ps1")), variables); output.AssertZero(); output.AssertOutput("##octopus[setVariable name='VGVzdEE=' value='V29ybGQh']"); Assert.AreEqual("World!", variables.Get("TestA")); }
public void DoesNotAddXmlHeader() { var variables = new VariableDictionary(); variables.Set("WelcomeMessage", "Hello world"); variables.Set("LogFile", "C:\\Log.txt"); variables.Set("DatabaseConnection", null); var text = PerformTest("Samples\\NoHeader.config", variables); Assert.That(text, Is.StringStarting("<configuration")); }
private static void ApplyPreserveAppDataDeploymentRule(DeploymentSyncOptions syncOptions, VariableDictionary variables) { // If PreserveAppData variable set, then create SkipDelete rules for App_Data directory 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 ShouldSaveAsString() { var variables = new VariableDictionary(); variables.Set("Name", "Web01"); variables.Set("Port", "10933"); variables.SaveAsString().Should().Be("{" + Environment.NewLine + " \"Name\": \"Web01\"," + Environment.NewLine + " \"Port\": \"10933\"" + Environment.NewLine + "}"); }
public void VariablesThatResolveToUnresolvableReturnError(string variable, string pattern, string expectedResult, string testName) { var variables = new VariableDictionary { ["Test"] = variable }; string err; variables.Evaluate(pattern, out err).Should().Be(expectedResult); err.Should().Be($"The following tokens were unable to be evaluated: '{expectedResult}'"); }
static void WriteScriptModules(VariableDictionary variables, string parentDirectory, StringBuilder output) { foreach (var variableName in variables.GetNames().Where(SpecialVariables.IsLibraryScriptModule)) { var name = "Library_" + new string(SpecialVariables.GetLibraryScriptModuleName(variableName).Where(char.IsLetterOrDigit).ToArray()) + "_" + DateTime.Now.Ticks; var moduleFileName = $"{name}.psm1"; var moduleFilePath = Path.Combine(parentDirectory, moduleFileName); CalamariFileSystem.OverwriteFile(moduleFilePath, variables.Get(variableName), Encoding.UTF8); output.AppendLine($"Import-ScriptModule '{SpecialVariables.GetLibraryScriptModuleName(variableName)}' '{moduleFilePath}'"); output.AppendLine(); } }
public void InfiniteLoop() { var dictionary = new VariableDictionary(); dictionary.Set("Database.Name", "{Project.Name}"); dictionary.Set("Project.Name", "{Database.Name}"); dictionary.Set("Project.Namespace", "{Database.Name}.Core"); var result = dictionary.Get("Project.Namespace"); result.Should().Be(".Core"); }
/// <summary> /// Initializes a new instance of the <see cref="DatabaseOptions"/> class. /// </summary> /// <param name="variables">The shared variables dictionary.</param> /// <param name="prefix">The variable key prefix.</param> public DatabaseOptions(VariableDictionary variables, string prefix) : base(variables, AppendPrefix(prefix, "Database")) { Provider = DatabaseProviders.SqlServer; TableNaming = TableNaming.Singular; Name = "{Database.ModelDatabaseName}"; Tables = new List <string>(); Schemas = new List <string>(); Exclude = new List <MatchOptions>(); }
public void NoInstructions() { var variables = new VariableDictionary { { SpecialVariables.Execution.Manifest, "[]" } }; var result = ExecuteCommand(variables); result.AssertFailure(); result.AssertErrorOutput("The execution manifest must have at least one instruction."); }
/// <summary> /// Initializes a new instance of the <see cref="BaseModelOptions"/> class. /// </summary> protected BaseModelOptions(VariableDictionary variables, string prefix) : base(variables, prefix) { // null so shared option is used Namespace = null; Directory = null; Generate = false; Include = new SelectionOptions(); Exclude = new SelectionOptions(); }
public void SetTwoValues(object value1, object value2) { var sut = new VariableDictionary(); sut["alpha"] = value1; sut["beta"] = value2; sut.Count.Should().Be(2); sut.IsSet("alpha").Should().BeTrue(); sut.IsSet("beta").Should().BeTrue(); sut["alpha"].Should().Be(value1); sut["beta"].Should().Be(value2); }
public void ShouldKeepExistingValues() { var variables = new VariableDictionary(); variables.Set("MyMessage", "Hello world!"); variables.Set("EmailSettings:SmtpPort", "24"); variables.Set("EmailSettings:DefaultRecipients:Cc", "*****@*****.**"); var generated = Generate(variables, existingFile: "appsettings.existing-expected.json"); AssertJsonEquivalent(generated, "appsettings.existing-expected.json"); }
string PerformTest(string sampleFile, VariableDictionary variables) { var temp = Path.GetTempFileName(); File.Copy(sampleFile, temp, true); using (new TemporaryFile(temp)) { configurationVariablesReplacer.ModifyConfigurationFile(temp, variables); return(File.ReadAllText(temp)); } }
/// <summary> /// Initializes a new instance of the <see cref="ProfileOptions"/> class. /// </summary> public ProfileOptions(ProfileInfo profile) { Variables = new VariableDictionary(); Options = new OptionsOptions(profile, Variables, null); Project = new ProjectOptions(Variables, null); Database = new DatabaseOptions(Variables, null); Data = new DataOptions(Variables, null); Model = new ModelOptions(Variables, null); Script = new ScriptOptions(Variables, null); }
public void ShouldSetVariables() { var variables = new VariableDictionary(); var output = Invoke(Calamari() .Action("run-script") .Argument("script", GetFixtureResouce("Scripts", "CanSetVariable.ps1")), variables); output.AssertSuccess(); output.AssertOutput("##octopus[setVariable name='VGVzdEE=' value='V29ybGQh']"); Assert.AreEqual("World!", variables.Get("TestA")); }
static string AppendTenantNameIfProvided(ICalamariFileSystem fileSystem, VariableDictionary variables, string root) { var tenant = variables.Get(SpecialVariables.Deployment.Tenant.Name); if (!string.IsNullOrWhiteSpace(tenant)) { tenant = fileSystem.RemoveInvalidFileNameChars(tenant); root = Path.Combine(root, tenant); } return(root); }
protected string Evaluate(string template, IDictionary <string, string> variables, bool haltOnError = true) { var dictionary = new VariableDictionary(); foreach (var pair in variables) { dictionary[pair.Key] = pair.Value; } string error; return(dictionary.Evaluate(template, out error, haltOnError)); }
private static string DeclareVariables(VariableDictionary variables) { var output = new StringBuilder(); WriteScriptModules(variables, output); output.AppendLine(); WriteVariableDictionary(variables, output); output.AppendLine(); WriteLocalVariables(variables, output); return(output.ToString()); }
public static void LogVariables(this VariableDictionary variables) { if (variables.GetFlag(SpecialVariables.PrintVariables)) { Log.Verbose("The following variables are available:" + Environment.NewLine + variables.ToString(IsPrintable, true)); } if (variables.GetFlag(SpecialVariables.PrintEvaluatedVariables)) { Log.Verbose("The following evaluated variables are available:" + Environment.NewLine + variables.ToString(IsPrintable, false)); } }
public void ShouldRevertToExistingEncodingIfInvalid() { var filePath = GetFixtureResouce("Samples", "UTF16LE.ini"); var variables = new VariableDictionary(); variables[SpecialVariables.Package.SubstituteInFilesOutputEncoding] = "utf-666"; var encoding = (Encoding)PerformTest(filePath, variables).Encoding; Assert.AreEqual(Encoding.Unicode, FileSystem.GetFileEncoding(filePath)); Assert.AreEqual(Encoding.Unicode, encoding); }
string AppendEnvironmentNameIfProvided(VariableDictionary variables, string root) { var environment = variables.Get(SpecialVariables.Environment.Name); if (!string.IsNullOrWhiteSpace(environment)) { environment = fileSystem.RemoveInvalidFileNameChars(environment); root = Path.Combine(root, environment); } return(root); }
public void ShouldSetActionIndexedOutputVariables() { var variables = new VariableDictionary(); variables.Set(SpecialVariables.Action.Name, "run-script"); var output = Invoke(Calamari() .Action("run-script") .Argument("script", GetFixtureResouce("Scripts", "CanSetVariable.ps1")), variables); Assert.AreEqual("World!", variables.Get("Octopus.Action[run-script].Output.TestA")); }
IEnumerable <string> ExecuteAndReturnLogOutput(Action <VariableDictionary> populateVariables, string folderName, params Type[] commandTypes) { void Copy(string sourcePath, string destinationPath) { foreach (var dirPath in Directory.EnumerateDirectories(sourcePath, "*", SearchOption.AllDirectories)) { Directory.CreateDirectory(dirPath.Replace(sourcePath, destinationPath)); } foreach (var newPath in Directory.EnumerateFiles(sourcePath, "*.*", SearchOption.AllDirectories)) { File.Copy(newPath, newPath.Replace(sourcePath, destinationPath), true); } } using (var currentDirectory = TemporaryDirectory.Create()) { var variablesFile = Path.GetTempFileName(); var variables = new VariableDictionary(); variables.Set(TerraformSpecialVariables.Calamari.TerraformCliPath, Path.GetDirectoryName(customTerraformExecutable)); variables.Set(SpecialVariables.OriginalPackageDirectoryPath, currentDirectory.DirectoryPath); variables.Set(TerraformSpecialVariables.Action.Terraform.CustomTerraformExecutable, customTerraformExecutable); populateVariables(variables); var terraformFiles = TestEnvironment.GetTestPath("Terraform", folderName); Copy(terraformFiles, currentDirectory.DirectoryPath); variables.Save(variablesFile); using (new TemporaryFile(variablesFile)) { foreach (var commandType in commandTypes) { var sb = new StringBuilder(); Log.StdOut = new IndentedTextWriter(new StringWriter(sb)); var command = (ICommand)Activator.CreateInstance(commandType); var result = command.Execute(new[] { "--variables", $"{variablesFile}" }); result.Should().Be(0); var output = sb.ToString(); Console.WriteLine(output); yield return(output); } } } }
public CalamariVariableDictionary(string storageFilePath, string sensitiveFilePath, string sensitiveFilePassword, string outputVariablesFilePath = null, string outputVariablesFilePassword = null) { var fileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem(); if (!string.IsNullOrEmpty(storageFilePath)) { if (!fileSystem.FileExists(storageFilePath)) { throw new CommandException("Could not find variables file: " + storageFilePath); } var nonSensitiveVariables = new VariableDictionary(storageFilePath); nonSensitiveVariables.GetNames().ForEach(name => Set(name, nonSensitiveVariables.GetRaw(name))); } if (!string.IsNullOrEmpty(sensitiveFilePath)) { var rawVariables = string.IsNullOrWhiteSpace(sensitiveFilePassword) ? fileSystem.ReadFile(sensitiveFilePath) : Decrypt(fileSystem.ReadAllBytes(sensitiveFilePath), sensitiveFilePassword); try { var sensitiveVariables = JsonConvert.DeserializeObject <Dictionary <string, string> >(rawVariables); foreach (var variable in sensitiveVariables) { SetSensitive(variable.Key, variable.Value); } } catch (JsonReaderException) { throw new CommandException("Unable to parse sensitive-variables as valid JSON."); } } if (!string.IsNullOrEmpty(outputVariablesFilePath)) { var rawVariables = DecryptWithMachineKey(fileSystem.ReadFile(outputVariablesFilePath), outputVariablesFilePassword); try { var outputVariables = JsonConvert.DeserializeObject <Dictionary <string, string> >(rawVariables); foreach (var variable in outputVariables) { Set(variable.Key, variable.Value); } } catch (JsonReaderException e) { throw new CommandException("Unable to parse output variables as valid JSON."); } } }
public void NestedEvaluation() { var dictionary = new VariableDictionary(); dictionary.Set("Database.Name", "Tester"); dictionary.Set("Project.Name", "{Database.Name}"); dictionary.Set("Project.Namespace", "{Database.Name}.Core"); dictionary.Set("Entity.Namespace", "{Project.Namespace}.Data"); var result = dictionary.Get("Entity.Namespace"); result.Should().Be("Tester.Core.Data"); }
CalamariResult ExecuteCommand(VariableDictionary variables, string extensions = "") { using (var variablesFile = new TemporaryFile(Path.GetTempFileName())) { variables.Save(variablesFile.FilePath); return(Invoke(Calamari() .Action("execute-manifest") .Argument("variables", variablesFile.FilePath) .Argument("sensitiveVariablesPassword", "GB8KdBqYRlgAON9ISUPdnQ==") .Argument("extensions", extensions))); } }
public void ShouldSubstitute() { var variables = new VariableDictionary(); variables["ServerEndpoints[FOREXUAT01].Name"] = "forexuat01.local"; variables["ServerEndpoints[FOREXUAT01].Port"] = "1566"; variables["ServerEndpoints[FOREXUAT02].Name"] = "forexuat02.local"; variables["ServerEndpoints[FOREXUAT02].Port"] = "1566"; var text = PerformTest(GetFixtureResouce("Samples", "Servers.json"), variables).Text; Assert.That(Regex.Replace(text, "\\s+", ""), Is.EqualTo(@"{""Servers"":[{""Name"":""forexuat01.local"",""Port"":1566},{""Name"":""forexuat02.local"",""Port"":1566}]}")); }
public void AddsVariables(string appSettingsKey, string configurationKey, string value) { VariableDictionary.Set(appSettingsKey, value); var appSettingsKeyDelimiter = string.Empty; var provider = new OctopusConfigurationProvider(Options, VariableDictionaryProvider.Object, appSettingsKeyDelimiter); provider.Load(); string configurationValue; Assert.True(provider.TryGet(configurationKey, out configurationValue)); Assert.Equal(value, configurationValue); }
// The template and parameter files are relative paths, and may be located either inside or outside of the package. string ResolveAndSubstituteFile(string relativeFilePath, bool inPackage, VariableDictionary variables) { var absolutePath = inPackage ? Path.Combine(variables.Get(SpecialVariables.OriginalPackageDirectoryPath), variables.Evaluate(relativeFilePath)) : Path.Combine(Environment.CurrentDirectory, relativeFilePath); if (!File.Exists(absolutePath)) { throw new CommandException($"Could not resolve '{relativeFilePath}' to physical file"); } return(variables.Evaluate(fileSystem.ReadFile(absolutePath))); }