Merge pull request #22 from ecojan/himl/values-escaping

Support exclude key on interpolation for himl with escape cleaning

Author: ecojan

examples/complex/env=dev/region=us-east-1/cluster=cluster1/cluster.yaml

@@ -1,2 +1,21 @@
 cluster:
   name: cluster1
+  testkey: |-
+    # Set to true to log user information returned from LDAP
+      verbose_logging = true
+
+      [[servers]]
+      # Ldap server host
+      host = "someaddress"
+
+      # Default port is 389 or 636 if use_ssl = true
+      port = 389
+
+      start_tls = true
+
+  skipInterpolation_key: "{{`this is a {{ value }} that should not be interpolated`}}"
+  skipInterpolation_dict:
+    skipInterpolation_key: "{{`this is a {{ value }} that should not be interpolated`}}"
+  skipInterpolation_list:
+    - "{{`this is a {{ value }} that should not be interpolated`}}"
+

himl/config_generator.py

@@ -17,12 +17,13 @@
 import yaml
 from deepmerge import Merger
 
-from .interpolation import InterpolationResolver, InterpolationValidator, SecretResolver, DictIterator, replace_parent_working_directory
+from .interpolation import InterpolationResolver, EscapingResolver, InterpolationValidator, SecretResolver, DictIterator, replace_parent_working_directory
 from .python_compat import iteritems, primitive_types, PY3
 from .remote_state import S3TerraformRemoteStateRetriever
 
 logger = logging.getLogger(__name__)
 
+
 class ConfigProcessor(object):
 
     def process(self, cwd=None, path=None, filters=(), exclude_keys=(), enclosing_key=None, remove_enclosing_key=None, output_format="yaml",
@@ -82,6 +83,8 @@ def process(self, cwd=None, path=None, filters=(), exclude_keys=(), enclosing_ke
         else:
             data = generator.generated_data
 
+        generator.clean_escape_characters()
+
         formatted_data = generator.output_data(data, output_format)
 
         if print_data:
@@ -271,6 +274,13 @@ def resolve_secrets(self, default_aws_profile):
     def validate_interpolations(self):
         self.interpolation_validator.check_all_interpolations_resolved(self.generated_data)
 
+    def clean_escape_characters(self):
+        """
+        Method should clean the escaping characters {{` and `}} from all escaped values
+        """
+        resolver = EscapingResolver()
+        self.generated_data = resolver.resolve_escaping(self.generated_data)
+
     @staticmethod
     def should_use_block(value):
         """

himl/interpolation.py

@@ -16,7 +16,11 @@
 
 def is_interpolation(value):
     return isinstance(value, string_types) and '{{' in value and '}}' in value \
-                                           and '{{`' not in value and '`}}' not in value
+           and not is_escaped_interpolation(value)
+
+
+def is_escaped_interpolation(value):
+    return isinstance(value, string_types) and value.startswith('{{`') and value.endswith('`}}')
 
 
 def is_full_interpolation(value):
@@ -48,6 +52,19 @@ def resolve_interpolations(self, data):
         return data
 
 
+class EscapingResolver(object):
+
+    def resolve_escaping(self, data):
+        """
+        Should do one last check through all values to ensure the ones that were escaped are cleaned of the escape
+        sequence
+        """
+        from_dict_injector = DictEscapingResolver(data, FromDictInjector())
+        from_dict_injector.clean_escapes(data)
+
+        return data
+
+
 class SecretResolver(object):
 
     def resolve_secrets(self, data, default_aws_profile):
@@ -82,6 +99,21 @@ def loop_all_items(self, data, process_func):
         return data
 
 
+class AbstractEscapingResolver(DictIterator):
+
+    def clean_escapes(self, data):
+        return self.loop_all_items(data, self.clean_escape)
+
+    def clean_escape(self, line):
+        # Check if line is escaped
+        if not is_escaped_interpolation(line):
+            return line
+        return self.do_clean_escapes(line)
+
+    def do_clean_escapes(self, line):
+        pass
+
+
 class AbstractInterpolationResolver(DictIterator):
 
     def resolve_interpolations(self, data):
@@ -98,6 +130,18 @@ def do_resolve_interpolation(self, line):
         pass
 
 
+class DictEscapingResolver(AbstractEscapingResolver):
+    def __init__(self, data, from_dict_injector):
+        AbstractEscapingResolver.__init__(self)
+        self.data = data
+        self.from_dict_injector = from_dict_injector
+        self.full_blob_injector = FullBlobInjector()
+
+    def do_clean_escapes(self, line):
+        updated_line = self.from_dict_injector.resolve(line, self.data)
+        return self.full_blob_injector.clean(updated_line)
+
+
 class DictInterpolationResolver(AbstractInterpolationResolver):
     def __init__(self, data, from_dict_injector):
         AbstractInterpolationResolver.__init__(self)
@@ -179,6 +223,15 @@ def resolve(self, line, data):
 
         return resolved_value if is_valid_value else line
 
+    def clean(self, line):
+        if not is_escaped_interpolation(line):
+            return line
+
+        resolved_value = self.get_value_from_escaping(line)
+        is_valid_value = resolved_value is not None
+
+        return resolved_value if is_valid_value else line
+
     @staticmethod
     def get_inner_value(keys, data):
         for key in keys:
@@ -195,3 +248,10 @@ def get_keys_from_interpolation(line):
         line = line[2:-2]
 
         return line.split('.')
+
+    @staticmethod
+    def get_value_from_escaping(line):
+        # remove {{` and `}}
+        line = line[3:-3]
+
+        return line