Merged in feature/OPT-400 (pull request #149)

[OPT-400] to dev

Approved-by: Paco Cid

Author: daFont-iriusrisk

slp_base/tests/util/otm.py

@@ -1,5 +1,8 @@
+from typing import Union
+
 from deepdiff import DeepDiff
 
+from otm.otm.otm import OTM
 from slp_base.slp_base.otm_file_loader import OtmFileLoader
 from slp_base.slp_base.schema import Schema
 
@@ -13,15 +16,15 @@
 internet_name = 'Internet'
 
 
-def validate_and_diff_filename(actual_filename: str, expected_filename: str, excluded_regex):
-    expected = OtmFileLoader().load(expected_filename)
-    actual = OtmFileLoader().load(actual_filename)
-    return validate_and_diff(actual, expected, excluded_regex)
+def __load_otm (otm: Union[dict, str, OTM]):
+    if isinstance(otm, dict):
+        return otm
 
+    if isinstance(otm, OTM):
+        return otm.json()
 
-def validate_and_diff_otm(actual: dict, expected_filename: str, excluded_regex):
-    expected = OtmFileLoader().load(expected_filename)
-    return validate_and_diff(actual, expected, excluded_regex)
+    if isinstance(otm, str):
+        return OtmFileLoader().load(otm)
 
 
 def __compare_otm_files(expected: dict,
@@ -36,15 +39,18 @@ def __validate_otm_schema(otm) -> Schema:
     return schema
 
 
-def validate_and_diff(actual: dict, expected: dict, excluded_regex):
+def validate_and_diff(actual: Union[dict, str, OTM], expected: Union[dict, str, OTM], excluded_regex):
     """
     Utils for validating otm has a correct Schema
     and OTM contains expected data
     """
-    schema = __validate_otm_schema(actual)
+    actual_otm = __load_otm(actual)
+    expected_otm = __load_otm(expected)
+
+    schema = __validate_otm_schema(actual_otm)
     if not schema.valid:
         return {'schema_errors': schema.errors}
-    diff = __compare_otm_files(expected, actual, excluded_regex)
+    diff = __compare_otm_files(expected_otm, actual_otm, excluded_regex)
     if diff:
         return diff
     return {}

slp_cft/slp_cft/parse/cft_parser.py

@@ -5,6 +5,7 @@
 from slp_base.slp_base.errors import OtmBuildingError
 from slp_base.slp_base.provider_parser import ProviderParser
 from slp_base.slp_base.provider_type import IacType
+from slp_cft.slp_cft.parse.mapping.cft_path_ids_calculator import CloudformationPathIdsCalculator
 from slp_cft.slp_cft.parse.mapping.cft_sourcemodel import CloudformationSourceModel
 from slp_cft.slp_cft.parse.mapping.cft_transformer import CloudformationTransformer
 
@@ -29,6 +30,7 @@ def __init__(self, project_id: str, project_name: str, source, mapping: [str]):
     def build_otm(self) -> OTM:
         try:
             self.transformer.run(self.mapping)
+            self.__set_full_path_in_ids()
         except Exception as e:
             logger.error(f'{e}')
             detail = e.__class__.__name__
@@ -39,3 +41,23 @@ def build_otm(self) -> OTM:
 
     def __initialize_otm(self):
         return OtmBuilder(self.project_id, self.project_name, IacType.CLOUDFORMATION).build()
+
+    def __set_full_path_in_ids(self):
+        path_ids = CloudformationPathIdsCalculator(self.otm.components).calculate_path_ids()
+
+        self.__update_component_ids(path_ids)
+        self.__update_dataflow_ids(path_ids)
+
+    def __update_component_ids(self, path_ids: {}):
+        for component in self.otm.components:
+            if component.id in path_ids:
+                component.id = path_ids[component.id]
+            if component.parent in path_ids:
+                component.parent = path_ids[component.parent]
+
+    def __update_dataflow_ids(self, path_ids: {}):
+        for dataflow in self.otm.dataflows:
+            if dataflow.source_node in path_ids:
+                dataflow.source_node = path_ids[dataflow.source_node]
+            if dataflow.destination_node in path_ids:
+                dataflow.destination_node = path_ids[dataflow.destination_node]

slp_cft/slp_cft/parse/mapping/cft_component_id_generator.py

@@ -0,0 +1,51 @@
+import re
+
+VALID_ID_REGEX = r"(\w+)"
+
+
+def normalize_name(name: str):
+    return "_".join(re.findall(VALID_ID_REGEX, name.lower()))
+
+
+def is_altsource_resource(source: dict) -> bool:
+    return 'altsource' in source and source['altsource']
+
+
+def build_path_id(id_elements: []):
+    return ".".join(id_elements)
+
+
+class CloudformationComponentIdGenerator:
+
+    def __init__(self,
+                 name: str,
+                 parent_id: str,
+                 type: str = None,
+                 is_altsource: bool = False):
+        self.name = normalize_name(name)
+        self.parent_id = parent_id
+        self.type = type
+        self.is_altsource = is_altsource
+
+    @staticmethod
+    def from_component(component_source: dict, parent_id: str):
+        is_altsource = is_altsource_resource(component_source)
+
+        return CloudformationComponentIdGenerator(
+            name=component_source['_key'],
+            type=component_source['Type'],
+            parent_id=parent_id,
+            is_altsource=is_altsource
+        )
+
+    def generate_id(self):
+        if self.is_altsource:
+            return self.__generate_altsource_component_id()
+        else:
+            return self.__generate_regular_component_id()
+
+    def __generate_regular_component_id(self):
+        return build_path_id([self.parent_id, self.name])
+
+    def __generate_altsource_component_id(self):
+        return self.__generate_regular_component_id() + '-altsource'

slp_cft/slp_cft/parse/mapping/cft_path_ids_calculator.py

@@ -0,0 +1,39 @@
+from otm.otm.otm import Component
+from slp_cft.slp_cft.parse.mapping.cft_component_id_generator import CloudformationComponentIdGenerator
+
+
+class CloudformationPathIdsCalculator:
+
+    def __init__(self, components: [Component]):
+        self.components = components
+
+        self.path_ids = {}
+
+    def calculate_path_ids(self) -> {}:
+        for component in self.components:
+            if component.id not in self.path_ids:
+                self.__calculate_path_id(component)
+
+        return self.path_ids
+
+    def __calculate_path_id(self, component: {}) -> str:
+        path_id = self.__build_component_id(component, self.__get_parent_path_id(component))
+
+        self.path_ids[component.id] = path_id
+
+        return path_id
+
+    def __get_parent_path_id(self, component: Component) -> str:
+        if component.parent_type == 'trustZone':
+            return component.parent
+
+        if component.parent in self.path_ids:
+            return self.path_ids[component.parent]
+
+        return self.__calculate_path_id(self.__find_parent_component(component.parent))
+
+    def __find_parent_component(self, parent_id: str):
+        return next(filter(lambda x: x.id == parent_id, self.components), None)
+
+    def __build_component_id(self, component: {}, parent_id: str):
+        return CloudformationComponentIdGenerator.from_component(component.source, parent_id).generate_id()

slp_cft/slp_cft/parse/mapping/mappers/cft_component_mapper.py

@@ -135,8 +135,19 @@ def __get_alt_source_components(self, source_model) -> []:
                         component_tags, singleton_multiple_tags = self.__get_component_tags(source_model,
                                                                                             alt_source_object,
                                                                                             mapping_tags)
-                        component = {"id": str(uuid.uuid4()), "name": component_name,
-                                     "type": mapping_lookup["type"], "parent": self.id_map[self.DEFAULT_TRUSTZONE]}
+
+                        # if a new object is not created could be problems related with updating the same object with
+                        # the "altsource" property, as the jmespath search for altsource components returns the same
+                        # object as the original search of the component
+                        alt_source_object_copy = alt_source_object.copy()
+                        alt_source_object_copy["altsource"] = True
+
+                        component = {"id": str(uuid.uuid4()),
+                                     "name": component_name,
+                                     "type": mapping_lookup["type"],
+                                     "parent": self.id_map[self.DEFAULT_TRUSTZONE],
+                                     "source": alt_source_object_copy
+                                     }
 
                         component = self.set_optional_parameters_to_resource(component, mapping_tags,
                                                                              component_tags,