public void JsonSupportsVariableInVariable() { var variables = new VariableDictionary { ["Prop"] = "Foo", ["Val"] = "Bar", ["Test"] = "{#{Prop}: \"#{Val}\"}", }; variables.Evaluate("#{Test[Foo]}").Should().Be("Bar"); variables.Evaluate("#{Test.Foo}").Should().Be("Bar"); variables.Evaluate("#{Test[#{Prop}]}").Should().Be("Bar"); }
public void IndexWithUnkownVariableDoesntFail() { var pattern = "#{Location[#{Continent}]}"; var variables = new VariableDictionary(); variables.Evaluate(pattern).Should().Be(pattern); variables.Set("Location[Europe]", "Madrid"); variables.Evaluate(pattern).Should().Be(pattern); variables.Set("Continent", "Europe"); variables.Evaluate(pattern).Should().Be("Madrid"); }
public void JsonDoesNotOverrideExisting() { var variables = new VariableDictionary { ["Test.Hello"] = "Go Away", ["Test"] = "{\"Hello\": \"World\", \"Foo\": \"Bar\", \"Donkey\" : {\"Kong\": 12}}", ["Test[Foo]"] = "Nope", ["Test.Donkey.Kong"] = "MARIO", }; variables.Evaluate("#{Test.Hello}").Should().Be("Go Away"); variables.Evaluate("#{Test[Foo]}").Should().Be("Nope"); variables.Evaluate("#{Test.Donkey.Kong}").Should().Be("MARIO"); }
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); }
private static void ProcessFile(TomlTable toml) { string templateFile = Command.TemplateFile.Replace('\\', Path.DirectorySeparatorChar); string resultFile = Command.ResultFile.Replace('\\', Path.DirectorySeparatorChar); if (!File.Exists(templateFile)) { Console.WriteLine($"Error: File {templateFile} does not exist"); Environment.Exit(1); } IList <Variable> vars = GetVariablesFromToml(toml, Command.Multifile, Command.ResultFile).ToList(); Dictionary <string, Variable> lookup = vars.ToDictionary(x => x.Key); if (Command.Verbose) { LogVars(vars, Command.VariableFile, true); } string template = File.ReadAllText(templateFile); HashSet <string> templateVars = ParseTemplate(template, templateFile); if (Command.Verbose) { LogVars(GetVariablesFromLookup(templateVars, lookup), templateFile, true); } ProcessUnusedVarsWarningsAndErrors(vars, templateVars, templateFile, lookup); VariableDictionary octoVars = SubstituteVaultValues(templateFile, vars); File.WriteAllText(resultFile, octoVars.Evaluate(template)); }
private async Task <int> OnExecute() { var octoVariables = new VariableDictionary(); var envVariables = Environment.GetEnvironmentVariables(); foreach (var key in envVariables.Keys) { octoVariables.Add(key.ToString(), envVariables[key]?.ToString()); } var content = await ReadInput(Input); var replaced = octoVariables.Evaluate(content, out var error); await WriteOutput(Output ?? Input, replaced); if (!string.IsNullOrEmpty(error)) { Console.Error.WriteLine(error); return(1); } 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 override void DoExecute(IGenerateDockerComposeFileContext input) { var variableDictionary = new VariableDictionary(); variableDictionary.Set("Project.Name", input.ProjectInstance.Name); variableDictionary.Set("Project.Id", $"{input.ProjectInstance.Id:N}"); variableDictionary.Set("Project.WorkingPath", Regex.Escape(input.WorkingPath)); foreach (var(key, value) in input.ProjectInstance.VariableDictionary) { variableDictionary.Set(key, value); } foreach (var(key, value) in input.Project.VariableDictionary) { variableDictionary.Set(key, value); } var templateFilePath = Path.Combine( input.ProjectInstance.SourceCodeLocation, input.Project.DockerComposeTemplateFileName); var template = File.ReadAllText(templateFilePath); var dockerCompose = variableDictionary.Evaluate(template, out var error); if (!string.IsNullOrEmpty(error)) { throw new FileGenerationFailed(error); } var environmentFileNamePath = Path.Combine(input.WorkingPath, "docker-compose.yml"); File.WriteAllText(environmentFileNamePath, dockerCompose); }
public void PerformSubstitution(string sourceFile, VariableDictionary variables, string targetFile) { var source = File.ReadAllText(sourceFile); var result = variables.Evaluate(source); File.WriteAllText(targetFile, result); }
public void JsonInvalidDoesNotReplace() { var variables = new VariableDictionary { ["Test"] = "{Name: NoComma}", }; variables.Evaluate("#{Test.Name}").Should().Be("#{Test.Name}"); }
public void SuccessfulJsonParsing(string json, string pattern, string expectedResult, string testName) { var variables = new VariableDictionary { ["Test"] = json }; variables.Evaluate(pattern).Should().Be(expectedResult); }
string GetInitialExtractionDirectory(VariableDictionary variables) { var root = variables.Get(SpecialVariables.Tentacle.Agent.ApplicationDirectoryPath) ?? variables.Evaluate("#{env:SystemDrive}\\Applications"); root = AppendEnvironmentNameIfProvided(variables, root); fileSystem.EnsureDirectoryExists(root); fileSystem.EnsureDiskHasEnoughFreeSpace(root); return(root); }
public void JsonEvaluatesConditionalsWithEscapes() { var variables = new VariableDictionary { ["Foo"] = "test text" }; var pattern = "{\"Bar\":\"#{if Foo == \\\"test text\\\"}Blaa#{/if}\"}"; variables.Evaluate(pattern).Should().Be("{\"Bar\":\"Blaa\"}"); }
public void JsonObjectSupportsIterator() { var variables = new VariableDictionary { ["Octopus.Sizes"] = "{\"Small\": \"11.5\", Large: 15.21}", }; var pattern = @"#{each size in Octopus.Sizes}#{size}:#{size.Value},#{/each}"; variables.Evaluate(pattern).Should().Be("Small:11.5,Large:15.21,"); }
public void JsonArraySafeguardedFromNullValues() { var variables = new VariableDictionary { ["Test"] = "{Blah: null}", }; var pattern = "Before:#{each number in Test.Blah}#{number}#{/each}:After"; variables.Evaluate(pattern).Should().Be("Before::After"); }
public void JsonArraySupportsIterator() { var variables = new VariableDictionary { ["Test"] = "[2,3,5,8]", }; var pattern = "#{each number in Test}#{number}#{if Octopus.Template.Each.Last == \"False\"}-#{/if}#{/each}"; variables.Evaluate(pattern).Should().Be("2-3-5-8"); }
public void NullJsonPropertyTreatedAsEmptyString() { var variables = new VariableDictionary { ["Foo"] = "{Bar: null}", }; var pattern = @"Alpha#{Foo.Bar}bet"; variables.Evaluate(pattern).Should().Be("Alphabet"); }
public void JsonObjectSupportsIteratorWithInnerSelection() { var variables = new VariableDictionary { ["Octopus.Sizes"] = "{\"X-Large\": {\"Error\": \"Not Stocked\"}}", }; var pattern = @"#{each size in Octopus.Sizes}#{size.Key} - #{size.Value.Error}#{/each}"; variables.Evaluate(pattern).Should().Be("X-Large - Not Stocked"); }
public void ShouldAddEnvironmentVariables() { 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.Evaluate("My OS is #{env:OS}"), Is.StringStarting("My OS is Windows")); Assert.That(variables.GetRaw(SpecialVariables.Tentacle.Agent.InstanceName), Is.EqualTo("#{env:TentacleInstanceName}")); }
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)); }
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}'"); }
// 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))); }
public void PerformSubstitution(string sourceFile, VariableDictionary variables, string targetFile) { var source = fileSystem.ReadFile(sourceFile); var encoding = GetEncoding(sourceFile, variables); string error; var result = variables.Evaluate(source, out error); if (!string.IsNullOrEmpty(error)) Log.VerboseFormat("Parsing file '{0}' with Octostache returned the following error: `{1}`", sourceFile, error); fileSystem.OverwriteFile(targetFile, result, encoding); }
public void PerformSubstitution(string sourceFile, VariableDictionary variables, string targetFile) { var source = fileSystem.ReadFile(sourceFile); var encoding = GetEncoding(sourceFile, variables); string error; var result = variables.Evaluate(source, out error); if (!string.IsNullOrEmpty(error)) { Log.VerboseFormat("Parsing file '{0}' with Octostache returned the following error: `{1}`", sourceFile, error); } fileSystem.OverwriteFile(targetFile, result, encoding); }
public void EncryptText() { var certificate = MakeCert(); if (certificate != null) { var variableDictionary = new VariableDictionary { //TODO: Verify this is how Octopus certificate variables create certificate base64 strings. #{CertificateVariable.Certificate} ["CertificateBase64String"] = Convert.ToBase64String(certificate.RawData), ["Data"] = "Test", ["EncryptedData"] = "#{Data | RSAEncrypt #{CertificateBase64String}}" }; var encryptedString = variableDictionary.Evaluate("#{EncryptedData}"); encryptedString.Should().NotBeNullOrWhiteSpace(); } }
internal static ICollection <PrivateKeyAccessRule> GetPrivateKeyAccessRules(VariableDictionary variables) { // The private-key access-rules are stored as escaped JSON. However, they may contain nested // variables (for example the user-name may be an Octopus variable) which may not be escaped, // causing JSON parsing to fail. // So, we get the raw text var raw = variables.GetRaw(SpecialVariables.Action.Certificate.PrivateKeyAccessRules); if (string.IsNullOrWhiteSpace(raw)) { return(new List <PrivateKeyAccessRule>()); } // Unescape it (we only care about backslashes) var unescaped = raw.Replace(@"\\", @"\"); // Perform variable-substitution and re-escape var escapedAndSubstituted = variables.Evaluate(unescaped).Replace(@"\", @"\\"); return(PrivateKeyAccessRule.FromJson(escapedAndSubstituted)); }
public void DocumentationIntroduction() { var variables = new VariableDictionary(); variables.Set("Server", "Web01"); variables.Set("Port", "10933"); variables.Set("Url", "http://#{Server | ToLower}:#{Port}"); variables.Set("Protocol", "#{Proto}"); var url = variables.Get("Url"); var raw = variables.GetRaw("Url"); var eval = variables.Evaluate("#{Url}/foo"); string error; variables.Get("Protocol", out error); Assert.AreEqual("http://web01:10933", url); Assert.AreEqual("http://#{Server | ToLower}:#{Port}", raw); Assert.AreEqual("http://web01:10933/foo", eval); Assert.IsNotNull(error); }
public void DocumentationIntroduction() { var variables = new VariableDictionary(); variables.Set("Server", "Web01"); variables.Set("Port", "10933"); variables.Set("Url", "http://#{Server | ToLower}:#{Port}"); variables.Set("Protocol", "#{Proto}"); var url = variables.Get("Url"); var raw = variables.GetRaw("Url"); var eval = variables.Evaluate("#{Url}/foo"); string error; variables.Get("Protocol", out error); url.Should().Be("http://web01:10933"); raw.Should().Be("http://#{Server | ToLower}:#{Port}"); eval.Should().Be("http://web01:10933/foo"); error.Should().NotBeNull(); }
private void LinuxEnvironmentVariableTest(VariableDictionary variables) { Assert.That(variables.Evaluate("My home starts at #{env:HOME}"), Is.StringStarting("My home starts at /home")); }
private void WindowsEnvironmentVariableTest(VariableDictionary variables) { Assert.That(variables.Evaluate("My OS is #{env:OS}"), Is.StringStarting("My OS is Windows")); }
private void WindowsEnvironmentVariableTest(VariableDictionary variables) { Assert.That(variables.Evaluate("My OS is #{env:OS}"), Is.StringStarting("My OS is Windows")); }
private void LinuxEnvironmentVariableTest(VariableDictionary variables) { Assert.That(variables.Evaluate("My home starts at #{env:HOME}"), Is.StringStarting("My home starts at /home")); }
public string ResolveAndSubstituteFile(ICalamariFileSystem fileSystem, string relativeFilePath, bool inPackage, VariableDictionary variables) { return(GetAbsolutePath(fileSystem, relativeFilePath, inPackage, variables) .Map(path => variables.Evaluate(fileSystem.ReadFile(path)))); }
public Maybe <ResolvedTemplatePath> MaybeResolve(string relativeFilePath, bool inPackage, VariableDictionary variables) { var absolutePath = relativeFilePath.ToMaybe().Select(path => inPackage ? Path.Combine(variables.Get(SpecialVariables.OriginalPackageDirectoryPath), variables.Evaluate(path)) : Path.Combine(Environment.CurrentDirectory, path)); return(absolutePath.SelectValueOr(x => !filesystem.FileExists(x) ? Maybe <ResolvedTemplatePath> .None : new ResolvedTemplatePath(x).AsSome(), Maybe <ResolvedTemplatePath> .None )); }