Add convert vls and cps logic

After parse the nsd package, add _get_all_vl
 and _get_all_cp function to convert the vls
 and cps info.

Change-Id: I6b0af61d8716b454e18c1092e226ab3ec167e3f3
Issue-ID: VFC-121
Signed-off-by: ying.yunlong <ying.yunlong@zte.com.cn>

2 files changed, 126 insertions, 20 deletions

diff --git a/lcm/pub/utils/toscaparser/basemodel.py b/lcm/pub/utils/toscaparser/basemodel.py
index e1f841ff..e624bd08 100644
--- a/lcm/pub/utils/toscaparser/basemodel.py
+++ b/lcm/pub/utils/toscaparser/basemodel.py
@@ -105,23 +105,6 @@ class BaseInfoModel(object):
         if 'metadata' in tosca.tpl:
             self.metadata = copy.deepcopy(tosca.tpl['metadata'])
 
-        def buildProperties(self, nodeTemplate, parsed_params):
-            properties = {}
-            isMappingParams = parsed_params and len(parsed_params) > 0
-            for k, item in nodeTemplate.get_properties().items():
-                properties[k] = item.value
-                if isinstance(item.value, GetInput):
-                    if item.value.result() and isMappingParams:
-                        properties[k] = DataEntityExt.validate_datatype(item.type, item.value.result())
-                    else:
-                        tmp = {}
-                        tmp[item.value.name] = item.value.input_name
-                        properties[k] = tmp
-            if 'attributes' in nodeTemplate.entity_tpl:
-                for k, item in nodeTemplate.entity_tpl['attributes'].items():
-                    properties[k] = str(item)
-            return properties
-
     def buildProperties(self, nodeTemplate, parsed_params):
         properties = {}
         isMappingParams = parsed_params and len(parsed_params) > 0
@@ -198,6 +181,13 @@ class BaseInfoModel(object):
     def isPnf(self, node):
         return node['nodeType'].upper().find('.PNF.') >= 0 or node['nodeType'].upper().endswith('.PNF')
 
+    def isCp(self, node):
+        return node['nodeType'].upper().find('.CP.') >= 0 or node['nodeType'].upper().endswith('.CP')
+
+    def isVl(self, node):
+        return node['nodeType'].upper().find('.VIRTUALLINK.') >= 0 or node['nodeType'].upper().find('.VL.') >= 0 or \
+               node['nodeType'].upper().endswith('.VIRTUALLINK') or node['nodeType'].upper().endswith('.VL')
+
     def get_requirement_node_name(self, req_value):
         return self.get_prop_from_obj(req_value, 'node')
 
@@ -211,6 +201,13 @@ class BaseInfoModel(object):
     def getNodeDependencys(self, node):
         return self.getRequirementByName(node, 'dependency')
 
+    def getVirtualLinks(self, node):
+        return self.getRequirementByName(node, 'virtualLink')
+
+    def getVirtualbindings(self, node):
+        return self.getRequirementByName(node, 'virtualbinding')
+
+
     def getRequirementByName(self, node, requirementName):
         requirements = []
         if 'requirements' in node:
@@ -229,3 +226,42 @@ class BaseInfoModel(object):
                         rets.append({"key_name":key, "vl_id":self.get_requirement_node_name(value)})
         return rets
 
+    def _verify_value(self, value, inputs, parsed_params):
+        if isinstance(value, str):
+            return self._verify_string(inputs, parsed_params, value)
+        if isinstance(value, list) or isinstance(value, dict):
+            return self._verify_object(value, inputs, parsed_params)
+        return value
+
+    def _verify_object(self, value, inputs, parsed_params):
+        s = self._verify_string(inputs, parsed_params, json.dumps(value))
+        return json.loads(s)
+
+    def _get_input_name(self, getInput):
+        input_name = getInput.split(':')[1]
+        input_name = input_name.strip()
+        return input_name.replace('"', '').replace('}', '')
+
+    def _verify_string(self, inputs, parsed_params, value):
+        getInputs = re.findall(r'{"get_input": "[a-zA-Z_0-9]+"}', value)
+        for getInput in getInputs:
+            input_name = self._get_input_name(getInput)
+            if parsed_params and input_name in parsed_params:
+                value = value.replace(getInput, json.dumps(parsed_params[input_name]))
+            else:
+                for input_def in inputs:
+                    if input_def.default and input_name == input_def.name:
+                        value = value.replace(getInput, json.dumps(input_def.default))
+        return value
+
+    def get_node_vl_id(self, node):
+        vl_ids = map(lambda x: self.get_requirement_node_name(x), self.getVirtualLinks(node))
+        if len(vl_ids) > 0:
+            return vl_ids[0]
+        return ""
+
+    def get_node_by_name(self, node_templates, name):
+        for node in node_templates:
+            if node['name'] == name:
+                return node
+        return None
\ No newline at end of file
diff --git a/lcm/pub/utils/toscaparser/nsdmodel.py b/lcm/pub/utils/toscaparser/nsdmodel.py
index 7d7dafad..ae902df6 100644
--- a/lcm/pub/utils/toscaparser/nsdmodel.py
+++ b/lcm/pub/utils/toscaparser/nsdmodel.py
@@ -19,8 +19,8 @@ class EtsiNsdInfoModel(BaseInfoModel):
 
         self.vnfs = self._get_all_vnf(nodeTemplates)
         self.pnfs = self._get_all_pnf(nodeTemplates)
-        # self.vls = self.get_all_vl(nodeTemplates)
-        # self.cps = self.get_all_cp(nodeTemplates)
+        self.vls = self.get_all_vl(nodeTemplates)
+        self.cps = self.get_all_cp(nodeTemplates)
         # self.routers = self.get_all_router(nodeTemplates)
         # self.fps = self._get_all_fp(nodeTemplates)
         # self.vnffgs = self._get_all_vnffg(tosca.topology_template.groups)
@@ -98,4 +98,74 @@ class EtsiNsdInfoModel(BaseInfoModel):
                             req_node_name = self.get_requirement_node_name(value)
                             if req_node_name != None and req_node_name == node['name']:
                                 cps.append(tmpnode)
-        return cps
\ No newline at end of file
+        return cps
+
+    def get_all_vl(self, nodeTemplates):
+        vls = []
+        for node in nodeTemplates:
+            if self.isVl(node):
+                vl = {}
+                vl['vl_id'] = node['name']
+                vl['description'] = node['description']
+                vl['properties'] = node['properties']
+                vl['route_external'] = False
+                vl['route_id'] = self._get_vl_route_id(node)
+                vls.append(vl)
+            if self._isExternalVL(node):
+                vl = {}
+                vl['vl_id'] = node['name']
+                vl['description'] = node['description']
+                vl['properties'] = node['properties']
+                vl['route_external'] = True
+                vls.append(vl)
+        return vls
+
+    def _get_vl_route_id(self, node):
+        route_ids = map(lambda x: self.get_requirement_node_name(x),
+                        self.getRequirementByName(node, 'virtual_route'))
+        if len(route_ids) > 0:
+            return route_ids[0]
+        return ""
+
+    def _isExternalVL(self, node):
+        return node['nodeType'].upper().find('.ROUTEEXTERNALVL') >= 0
+
+    def get_all_cp(self, nodeTemplates):
+        cps = []
+        for node in nodeTemplates:
+            if self.isCp(node):
+                cp = {}
+                cp['cp_id'] = node['name']
+                cp['cpd_id'] = node['name']
+                cp['description'] = node['description']
+                cp['properties'] = node['properties']
+                cp['vl_id'] = self.get_node_vl_id(node)
+                binding_node_ids = map(lambda x: self.get_requirement_node_name(x), self.getVirtualbindings(node))
+                #                 cp['vnf_id'] = self._filter_vnf_id(binding_node_ids, nodeTemplates)
+                cp['pnf_id'] = self._filter_pnf_id(binding_node_ids, nodeTemplates)
+                vls = self.buil_cp_vls(node)
+                if len(vls) > 1:
+                    cp['vls'] = vls
+                cps.append(cp)
+        return cps
+
+    def buil_cp_vls(self, node):
+        return map(lambda x: self._build_cp_vl(x), self.getVirtualLinks(node))
+
+    def _build_cp_vl(self, req):
+        cp_vl = {}
+        cp_vl['vl_id'] = self.get_prop_from_obj(req, 'node')
+        relationship = self.get_prop_from_obj(req, 'relationship')
+        if relationship != None:
+            properties = self.get_prop_from_obj(relationship, 'properties')
+            if properties != None and isinstance(properties, dict):
+                for key, value in properties.items():
+                    cp_vl[key] = value
+        return cp_vl
+
+    def _filter_pnf_id(self, node_ids, node_templates):
+        for node_id in node_ids:
+            node = self.get_node_by_name(node_templates, node_id)
+            if self.isPnf(node):
+                return node_id
+        return ""
\ No newline at end of file