コード例 #1
0
    def test_explicit_relationship_proprety(self):

        tosca_node_template = '''
          node_templates:

            client_node:
              type: tosca.nodes.Compute
              requirements:
                - local_storage:
                    node: my_storage
                    relationship:
                      type: AttachesTo
                      properties:
                        location: /mnt/disk

            my_storage:
              type: tosca.nodes.BlockStorage
              properties:
                size: 1 GB
        '''

        expected_properties = ['location']

        nodetemplates = yamlparser.\
            simple_parse(tosca_node_template)['node_templates']
        tpl = NodeTemplate('client_node', nodetemplates, [])

        self.assertIsNone(tpl.validate())
        rel_tpls = []
        for relationship, trgt in tpl.relationships.items():
            rel_tpls.extend(trgt.get_relationship_template())
        self.assertEqual(expected_properties,
                         sorted(rel_tpls[0].get_properties().keys()))
コード例 #2
0
    def test_proprety_inheritance(self):
        from toscaparser.nodetemplate import NodeTemplate

        tosca_custom_def = '''
          tosca.nodes.SoftwareComponent.MySoftware:
            derived_from: SoftwareComponent
            properties:
              install_path:
                required: false
                type: string
                default: /opt/mysoftware
        '''

        tosca_node_template = '''
          node_templates:
            mysoftware_instance:
              type: tosca.nodes.SoftwareComponent.MySoftware
              properties:
                component_version: 3.1
        '''

        expected_properties = ['component_version',
                               'install_path']

        nodetemplates = yamlparser.\
            simple_parse(tosca_node_template)['node_templates']
        custom_def = yamlparser.simple_parse(tosca_custom_def)
        name = list(nodetemplates.keys())[0]
        tpl = NodeTemplate(name, nodetemplates, custom_def)
        self.assertIsNone(tpl.validate())
        self.assertEqual(expected_properties,
                         sorted(tpl.get_properties().keys()))
コード例 #3
0
    def test_constraint_for_scalar_unit(self):
        tpl_snippet = '''
        server:
          type: tosca.my.nodes.Compute
          properties:
            cpu_frequency: 0.05 GHz
            disk_size: 500 MB
            mem_size: 1 MB
        '''
        nodetemplates = yamlparser.simple_parse(tpl_snippet)
        nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
        props = nodetemplate.get_properties()
        if 'cpu_frequency' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['cpu_frequency'].validate)
            self.assertEqual(_('The value "0.05 GHz" of property '
                               '"cpu_frequency" must be greater than or equal '
                               'to "0.1 GHz".'), error.__str__())
        if 'disk_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['disk_size'].validate)
            self.assertEqual(_('The value "500 MB" of property "disk_size" '
                               'must be greater than or equal to "1 GB".'),
                             error.__str__())

        if 'mem_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['mem_size'].validate)
            self.assertEqual(_('The value "1 MB" of property "mem_size" is '
                               'out of range "(min:1 MiB, max:1 GiB)".'),
                             error.__str__())
コード例 #4
0
def node_type_2_node_template(node_type, all_custom_def):
    node_template_dict = {}
    type_name = next(iter(node_type))
    node_type_array = type_name.split(".")
    name = node_type_array[len(node_type_array) - 1].lower()
    node_template_dict[name] = node_type[next(iter(node_type))].copy()
    node_template_dict[name]['type'] = type_name

    for name_to_remove in node_type_key_names_to_remove:
        if name_to_remove in node_template_dict[name]:
            node_template_dict[name].pop(name_to_remove)

    if 'type' in node_type[next(iter(node_type))]:
        node_type[next(iter(node_type))].pop('type')

    node_template = NodeTemplate(name, node_template_dict, node_type)
    # For some reason the tosca.nodes.ARTICONF.docker.Orchestrator doesn't  have all definitions so we need to add them
    # manually. We get 'toscaparser.common.exception.InvalidTypeError: Type "tosca.nodes.ARTICONF.docker.Orchestrator"
    # is not a valid type.'
    if len(node_template.custom_def) < len(all_custom_def):
        for def_key in all_custom_def:
            if isinstance(def_key, dict):
                node_template.custom_def.update(def_key)
            else:
                node_template.custom_def[def_key] = all_custom_def[def_key]

    return node_template
コード例 #5
0
    def test_constraint_for_scalar_unit(self):
        tpl_snippet = '''
        server:
          type: tosca.my.nodes.Compute
          properties:
            cpu_frequency: 0.05 GHz
            disk_size: 500 MB
            mem_size: 1 MB
        '''
        nodetemplates = yamlparser.simple_parse(tpl_snippet)
        nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
        props = nodetemplate.get_properties()
        if 'cpu_frequency' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['cpu_frequency'].validate)
            self.assertEqual(
                _('The value "0.05 GHz" of property '
                  '"cpu_frequency" must be greater than or equal '
                  'to "0.1 GHz".'), error.__str__())
        if 'disk_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['disk_size'].validate)
            self.assertEqual(
                _('The value "500 MB" of property "disk_size" '
                  'must be greater than or equal to "1 GB".'), error.__str__())

        if 'mem_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['mem_size'].validate)
            self.assertEqual(
                _('The value "1 MB" of property "mem_size" is '
                  'out of range "(min:1 MiB, max:1 GiB)".'), error.__str__())
コード例 #6
0
ファイル: test_properties.py プロジェクト: semk/tosca-parser
    def test_proprety_inheritance(self):
        from toscaparser.nodetemplate import NodeTemplate

        tosca_custom_def = '''
          tosca.nodes.SoftwareComponent.MySoftware:
            derived_from: SoftwareComponent
            properties:
              install_path:
                required: false
                type: string
                default: /opt/mysoftware
        '''

        tosca_node_template = '''
          node_templates:
            mysoftware_instance:
              type: tosca.nodes.SoftwareComponent.MySoftware
              properties:
                component_version: 3.1
        '''

        expected_properties = ['component_version',
                               'install_path']

        nodetemplates = yamlparser.\
            simple_parse(tosca_node_template)['node_templates']
        custom_def = yamlparser.simple_parse(tosca_custom_def)
        name = list(nodetemplates.keys())[0]
        tpl = NodeTemplate(name, nodetemplates, custom_def)
        self.assertIsNone(tpl.validate())
        self.assertEqual(expected_properties,
                         sorted(tpl.get_properties().keys()))
コード例 #7
0
    def test_constraint_for_scalar_unit(self):
        tpl_snippet = '''
        server:
          type: tosca.my.nodes.Compute
          properties:
            cpu_frequency: 0.05 GHz
            disk_size: 500 MB
            mem_size: 1 MB
        '''
        nodetemplates = yamlparser.simple_parse(tpl_snippet)
        nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
        props = nodetemplate.get_properties()
        if 'cpu_frequency' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['cpu_frequency'].validate)
            self.assertEqual('cpu_frequency: 0.05 GHz must be greater or '
                             'equal to "0.1 GHz".', error.__str__())
        if 'disk_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['disk_size'].validate)
            self.assertEqual('disk_size: 500 MB must be greater or '
                             'equal to "1 GB".', error.__str__())

        if 'mem_size' in props.keys():
            error = self.assertRaises(exception.ValidationError,
                                      props['mem_size'].validate)
            self.assertEqual('mem_size: 1 MB is out of range '
                             '(min:1 MiB, '
                             'max:1 GiB).', error.__str__())
コード例 #8
0
    def test_explicit_relationship_proprety(self):

        tosca_node_template = '''
          node_templates:

            client_node:
              type: tosca.nodes.Compute
              requirements:
                - local_storage:
                    node: my_storage
                    relationship:
                      type: AttachesTo
                      properties:
                        location: /mnt/disk

            my_storage:
              type: tosca.nodes.BlockStorage
              properties:
                size: 1 GB
        '''

        expected_properties = ['location']

        nodetemplates = yamlparser.\
            simple_parse(tosca_node_template)['node_templates']
        tpl = NodeTemplate('client_node', nodetemplates, [])

        self.assertIsNone(tpl.validate())
        rel_tpls = []
        for relationship, trgt in tpl.relationships.items():
            rel_tpls.extend(trgt.get_relationship_template())
        self.assertEqual(expected_properties,
                         sorted(rel_tpls[0].get_properties().keys()))
コード例 #9
0
 def _tosca_floatingip_test(self, tpl_snippet, expectedprops, name=None):
     nodetemplates = (toscaparser.utils.yamlparser.
                      simple_parse(tpl_snippet)['node_templates'])
     if not name:
         name = list(nodetemplates.keys())[0]
     nodetemplate = NodeTemplate(name, nodetemplates, custom_def=[])
     nodetemplate.validate()
     tosca_floatingip = ToscaFloatingIP(nodetemplate)
     tosca_floatingip.handle_properties()
     self.assertEqual(expectedprops, tosca_floatingip.properties)
コード例 #10
0
 def _nodetemplates(self):
     nodetemplates = []
     tpls = self._tpl_nodetemplates()
     for name in tpls:
         tpl = NodeTemplate(name, tpls, self.custom_defs,
                            self.relationship_templates,
                            self.rel_types)
         tpl.validate(self)
         nodetemplates.append(tpl)
     return nodetemplates
コード例 #11
0
 def _tosca_floatingip_test(self, tpl_snippet, expectedprops, name=None):
     nodetemplates = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet)
                      ['node_templates'])
     if not name:
         name = list(nodetemplates.keys())[0]
     nodetemplate = NodeTemplate(name, nodetemplates, custom_def=[])
     nodetemplate.validate()
     tosca_floatingip = ToscaFloatingIP(nodetemplate)
     tosca_floatingip.handle_properties()
     self.assertEqual(expectedprops, tosca_floatingip.properties)
コード例 #12
0
    def _tosca_compute_test(self, tpl_snippet, expectedprops):
        nodetemplates = (toscaparser.utils.yamlparser.
                         simple_parse(tpl_snippet)['node_templates'])
        name = list(nodetemplates.keys())[0]
        nodetemplate = NodeTemplate(name, nodetemplates)
        nodetemplate.validate()
        toscacompute = ToscaCompute(nodetemplate)
        toscacompute.handle_properties()

        self.assertEqual(expectedprops, toscacompute.properties)
コード例 #13
0
    def _tosca_compute_test(self, tpl_snippet, expectedprops):
        nodetemplates = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet)
                         ['node_templates'])
        name = list(nodetemplates.keys())[0]
        nodetemplate = NodeTemplate(name, nodetemplates)
        nodetemplate.validate()
        toscacompute = ToscaCompute(nodetemplate)
        toscacompute.handle_properties()

        self.assertEqual(expectedprops, toscacompute.properties)
コード例 #14
0
 def test_scenario_scalar_unit_positive(self):
     tpl = self.tpl_snippet
     nodetemplates = yamlparser.simple_parse(tpl)
     nodetemplate = NodeTemplate('server', nodetemplates)
     props = nodetemplate.get_capability('host').get_properties()
     prop_name = self.property
     if props and prop_name in props.keys():
         prop = props[prop_name]
         self.assertIsNone(prop.validate())
         resolved = prop.value
     self.assertEqual(resolved, self.expected)
コード例 #15
0
 def test_scenario_scalar_unit_positive(self):
     tpl = self.tpl_snippet
     nodetemplates = yamlparser.simple_parse(tpl)
     nodetemplate = NodeTemplate('server', nodetemplates)
     props = nodetemplate.get_capability('host').get_properties()
     prop_name = self.property
     if props and prop_name in props.keys():
         prop = props[prop_name]
         self.assertIsNone(prop.validate())
         resolved = prop.value
     self.assertEqual(resolved, self.expected)
コード例 #16
0
    def test_custom_capability_type_definition(self):
        tpl_snippet = '''
        node_templates:
          test_app:
            type: tosca.nodes.WebApplication.TestApp
            capabilities:
              test_cap:
                properties:
                  test: 1
        '''
        # custom node type definition with custom capability type definition
        custom_def = '''
        tosca.nodes.WebApplication.TestApp:
          derived_from: tosca.nodes.WebApplication
          capabilities:
            test_cap:
               type: tosca.capabilities.TestCapability
        tosca.capabilities.TestCapability:
          derived_from: tosca.capabilities.Root
          properties:
            test:
              type: integer
              required: false
        '''
        expected_capabilities = ['app_endpoint', 'feature', 'test_cap']
        nodetemplates = (toscaparser.utils.yamlparser.
                         simple_parse(tpl_snippet))['node_templates']
        custom_def = (toscaparser.utils.yamlparser.
                      simple_parse(custom_def))
        name = list(nodetemplates.keys())[0]
        tpl = NodeTemplate(name, nodetemplates, custom_def)
        self.assertEqual(
            expected_capabilities,
            sorted(tpl.get_capabilities().keys()))

        # custom definition without valid capability type definition
        custom_def = '''
        tosca.nodes.WebApplication.TestApp:
          derived_from: tosca.nodes.WebApplication
          capabilities:
            test_cap:
               type: tosca.capabilities.TestCapability
        '''
        custom_def = (toscaparser.utils.yamlparser.
                      simple_parse(custom_def))
        tpl = NodeTemplate(name, nodetemplates, custom_def)
        err = self.assertRaises(
            exception.InvalidTypeError,
            lambda: NodeTemplate(name, nodetemplates,
                                 custom_def).get_capabilities_objects())
        self.assertEqual('Type "tosca.capabilities.TestCapability" is not '
                         'a valid type.', six.text_type(err))
コード例 #17
0
 def test_invalid_scalar_unit(self):
     tpl_snippet = '''
     server:
       type: tosca.my.nodes.Compute
       properties:
         cpu_frequency: 50.3.6 GHZ
         disk_size: MB
         mem_size: 1 QB
     '''
     nodetemplates = yamlparser.simple_parse(tpl_snippet)
     nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
     for p in nodetemplate.get_properties_objects():
         self.assertRaises(ValueError, p.validate)
コード例 #18
0
 def test_invalid_scalar_unit(self):
     tpl_snippet = '''
     server:
       type: tosca.my.nodes.Compute
       properties:
         cpu_frequency: 50.3.6 GHZ
         disk_size: MB
         mem_size: 1 QB
     '''
     nodetemplates = yamlparser.simple_parse(tpl_snippet)
     nodetemplate = NodeTemplate('server', nodetemplates, self.custom_def)
     for p in nodetemplate.get_properties_objects():
         self.assertRaises(ValueError, p.validate)
コード例 #19
0
 def _nodetemplates(self):
     nodetemplates = []
     tpls = self._tpl_nodetemplates()
     if tpls:
         for name in tpls:
             tpl = NodeTemplate(name, tpls, self.custom_defs,
                                self.relationship_templates, self.rel_types)
             if (tpl.type_definition
                     and (tpl.type in tpl.type_definition.TOSCA_DEF or
                          (tpl.type not in tpl.type_definition.TOSCA_DEF
                           and bool(tpl.custom_def)))):
                 tpl.validate(self)
                 nodetemplates.append(tpl)
     return nodetemplates
コード例 #20
0
 def _nodetemplates(self):
     nodetemplates = []
     tpls = self._tpl_nodetemplates()
     if tpls:
         for name in tpls:
             tpl = NodeTemplate(name, tpls, self.custom_defs,
                                self.relationship_templates,
                                self.rel_types)
             if (tpl.type_definition and
                 (tpl.type in tpl.type_definition.TOSCA_DEF or
                  (tpl.type not in tpl.type_definition.TOSCA_DEF and
                   bool(tpl.custom_def)))):
                 tpl.validate(self)
                 nodetemplates.append(tpl)
     return nodetemplates
コード例 #21
0
 def _tosca_scaling_test(self, tpl_snippet, expectedprops,
                         hot_template_parameters=None):
     nodetemplates = (toscaparser.utils.yamlparser.
                      simple_parse(tpl_snippet)['node_templates'])
     policies = (toscaparser.utils.yamlparser.
                 simple_parse(tpl_snippet)['policies'])
     name = list(nodetemplates.keys())[0]
     policy_name = list(policies[0].keys())[0]
     for policy in policies:
         tpl = policy[policy_name]
         targets = tpl["targets"]
         properties = tpl["properties"]
     try:
         nodetemplate = NodeTemplate(name, nodetemplates)
         toscacompute = ToscaCompute(nodetemplate)
         toscacompute.handle_properties()
         policy = Policy(policy_name, tpl, targets,
                         properties, "node_templates")
         toscascaling = ToscaAutoscaling(
             policy, hot_template_parameters=hot_template_parameters)
         parameters = toscascaling.handle_properties([toscacompute])
         if hot_template_parameters:
             substack_template = toscascaling.extract_substack_templates(
                 "output.yaml", HOT_TEMPLATE_VERSION)
             actual_nested_resource = yaml.load(
                 substack_template['SP1_res.yaml'])
             self.assertEqual(expectedprops,
                              actual_nested_resource)
         else:
             self.assertEqual(parameters[0].properties, expectedprops)
     except Exception:
         raise
コード例 #22
0
 def _get_nodetemplate(self, tpl_snippet, custom_def_snippet=None):
     nodetemplates = yamlparser.\
         simple_parse(tpl_snippet)['node_templates']
     custom_def = yamlparser.simple_parse(custom_def_snippet)
     name = list(nodetemplates.keys())[0]
     tpl = NodeTemplate(name, nodetemplates, custom_def)
     return tpl
コード例 #23
0
    def _tosca_policy_test(self, tpl_snippet, expectedprops):
        nodetemplates = (toscaparser.utils.yamlparser.
                         simple_parse(tpl_snippet)['node_templates'])
        policies = (toscaparser.utils.yamlparser.
                    simple_parse(tpl_snippet)['policies'])
        name = list(nodetemplates.keys())[0]
        policy_name = list(policies[0].keys())[0]
        for policy in policies:
            tpl = policy[policy_name]
            targets = tpl["targets"]
        try:
            nodetemplate = NodeTemplate(name, nodetemplates)
            toscacompute = ToscaCompute(nodetemplate)
            toscacompute.handle_properties()

            # adding a property to test that
            # ToscaPolicies.handle_properties does not overwrite this.
            toscacompute.properties['scheduler_hints'] = {
                'target_cell': 'cell0'}

            policy = Policy(policy_name, tpl, targets,
                            "node_templates")
            toscapolicy = ToscaPolicies(policy)
            nodetemplate = [toscacompute]
            toscapolicy.handle_properties(nodetemplate)

            self.assertEqual(toscacompute.properties, expectedprops)
        except Exception:
            raise
コード例 #24
0
 def _tosca_compute_test(self, tpl_snippet, expectedprops):
     nodetemplates = (toscaparser.utils.yamlparser.
                      simple_parse(tpl_snippet)['node_templates'])
     name = list(nodetemplates.keys())[0]
     try:
         nodetemplate = NodeTemplate(name, nodetemplates)
         nodetemplate.validate()
         toscacompute = ToscaCompute(nodetemplate)
         toscacompute.handle_properties()
         if not self._compare_properties(toscacompute.properties,
                                         expectedprops):
             raise Exception(_("Hot Properties are not"
                               " same as expected properties"))
     except Exception:
         # for time being rethrowing. Will be handled future based
         # on new development in Glance and Graffiti
         raise
コード例 #25
0
 def _tosca_compute_test(self, tpl_snippet, expectedprops):
     nodetemplates = (toscaparser.utils.yamlparser.
                      simple_parse(tpl_snippet)['node_templates'])
     name = list(nodetemplates.keys())[0]
     try:
         nodetemplate = NodeTemplate(name, nodetemplates)
         nodetemplate.validate()
         toscacompute = ToscaCompute(nodetemplate)
         toscacompute.handle_properties()
         if not self._compare_properties(toscacompute.properties,
                                         expectedprops):
             raise Exception(_("Hot Properties are not"
                               " same as expected properties"))
     except Exception:
         # for time being rethrowing. Will be handled future based
         # on new development in Glance and Graffiti
         raise
コード例 #26
0
    def add_template(self, name, tpl):
        # if name in self.node_templates:
        #     exception.ExceptionCollector.appendException(
        #           exception.ValidationError(message=
        #               'Node template already defined "%s"' % name))
        #     return None

        self.tpl.setdefault(NODE_TEMPLATES, {})[name] = tpl
        node = NodeTemplate(
            name,
            self,
            self.custom_defs,
            self.relationship_templates)
        node.validate(self)
        node.relationships # this will update the relationship_tpl of the target node
        self.node_templates[name] = node
        return node
コード例 #27
0
 def _single_node_template_content_test(self, tpl_snippet):
     nodetemplates = (toscaparser.utils.yamlparser.simple_ordered_parse(
         tpl_snippet))['node_templates']
     name = list(nodetemplates.keys())[0]
     nodetemplate = NodeTemplate(name, nodetemplates, self._custom_types())
     nodetemplate.validate()
     nodetemplate.requirements
     nodetemplate.get_capabilities_objects()
     nodetemplate.get_properties_objects()
     nodetemplate.interfaces
コード例 #28
0
 def _nodetemplates(self):
     nodetemplates = {}
     tpls = self._tpl_nodetemplates()
     if tpls:
         for name in tpls:
             tpl = NodeTemplate(
                 name,
                 self,
                 self.custom_defs,
                 self.relationship_templates
             )
             # why these tests? defeats validation
             # if (tpl.type_definition and
             #     (tpl.type in tpl.type_definition.TOSCA_DEF or
             #      (tpl.type not in tpl.type_definition.TOSCA_DEF and
             #       bool(tpl.custom_def)))):
             tpl.validate(self)
             nodetemplates[name] = tpl
     return nodetemplates
コード例 #29
0
def _get_nodetemplate(tpl_snippet, name, custom_def_snippet=None):
    tpl = toscaparser.utils.yamlparser.simple_parse(tpl_snippet)
    nodetemplates = tpl['node_templates']
    custom_def = []
    if custom_def_snippet:
        custom_def = toscaparser.utils.yamlparser.simple_parse(
            custom_def_snippet)
    topology = TopologyTemplate(tpl, custom_def)
    if not name:
        name = list(nodetemplates.keys())[0]
    return NodeTemplate(name, topology, custom_def)
コード例 #30
0
ファイル: tosca_helper.py プロジェクト: QCDIS/tosca-sure
def node_dict_2_node_template(node_name, node_dict, all_custom_def):
    node_dict = {node_name: node_dict}
    # node_type = node_dict[node_name]['type']

    # for name_to_remove in node_type_key_names_to_remove:
    #     if name_to_remove in node_dict[node_name][node_name]:
    #         node_dict[node_name].pop(name_to_remove)

    node_template = NodeTemplate(node_name, node_templates=copy.deepcopy(node_dict), custom_def=all_custom_def)
    # For some reason the tosca.nodes.ARTICONF.Orchestrator doesn't  have all definitions so we need to add them
    # manually. We get 'toscaparser.common.exception.InvalidTypeError: Type "tosca.nodes.ARTICONF.Orchestrator"
    # is not a valid type.'
    if len(node_template.custom_def) < len(all_custom_def):
        for def_key in all_custom_def:
            if isinstance(def_key, dict):
                node_template.custom_def.update(def_key)
            else:
                node_template.custom_def[def_key] = all_custom_def[def_key]

    return node_template
コード例 #31
0
def build_node_fact(node_tpl: NodeTemplate) -> str:
    def build_node_property(prop: Property) -> str:
        if type(prop.value) in [int, float]:
            prop_val_str = str(prop.value)
        elif type(prop.value) is str:
            prop_val_str = '"' + prop.value + '"' # TODO: escaping
        elif type(prop.value) is bool:
            prop_val_str = "true" if prop.value else "false"
        elif type(prop.value) is GetInput:
            prop_val_str = f"get_input({prop.value.args[0]})"
        else:
            raise ValueError(f"Property type {type(prop.value)} not handled.")
        return f"property({prop.name}, {prop_val_str})"
    properties = "[" \
        + ", ".join([build_node_property(prop) for prop in node_tpl.get_properties_objects()]) \
        + "]"
    
    def build_node_capability(cap: Capability):
        properties = "[" \
            + ", ".join([build_node_property(prop) for prop in cap.get_properties_objects()]) \
            + "]"
        return f"capability({cap.name}, {properties})"
    capabilities = "[" \
        + ", ".join([build_node_capability(cap) for cap in node_tpl.get_capabilities_objects()]) \
        + "]"

    def build_node_requirement(req):
        req_name = list(req)[0]
        return f"requirement({req_name}, {req[req_name]})"
    requirements = "[" \
        + ", ".join([build_node_requirement(req) for req in node_tpl.requirements]) \
        + "]"

    return textwrap.dedent(f"""
    node(
        {node_tpl.name},
        '{node_tpl.type}',
        {properties},
        {capabilities},
        {requirements}
    )""")
コード例 #32
0
 def _single_node_template_content_test(self, tpl_snippet):
     nodetemplates = (toscaparser.utils.yamlparser.
                      simple_ordered_parse(tpl_snippet))['node_templates']
     name = list(nodetemplates.keys())[0]
     nodetemplate = NodeTemplate(name, nodetemplates,
                                 self._custom_types())
     nodetemplate.validate()
     nodetemplate.requirements
     nodetemplate.get_capabilities_objects()
     nodetemplate.get_properties_objects()
     nodetemplate.interfaces
コード例 #33
0
 def _get_nodetemplate(self,
                       tpl_snippet,
                       custom_def_snippet=None,
                       name=None):
     tpl = yamlparser.simple_parse(tpl_snippet)
     nodetemplates = tpl['node_templates']
     custom_def = []
     if custom_def_snippet:
         custom_def = yamlparser.simple_parse(custom_def_snippet)
     if not name:
         name = list(nodetemplates.keys())[0]
     topology = TopologyTemplate(tpl, custom_def)
     tpl = NodeTemplate(name, topology, custom_def)
     return tpl
コード例 #34
0
    def test_custom_capability_type_definition(self):
        tpl_snippet = '''
        node_templates:
          test_app:
            type: tosca.nodes.WebApplication.TestApp
            capabilities:
              test_cap:
                properties:
                  test: 1
        '''
        # custom node type definition with custom capability type definition
        custom_def = '''
        tosca.nodes.WebApplication.TestApp:
          derived_from: tosca.nodes.WebApplication
          capabilities:
            test_cap:
               type: tosca.capabilities.TestCapability
        tosca.capabilities.TestCapability:
          derived_from: tosca.capabilities.Root
          properties:
            test:
              type: integer
              required: false
        '''
        expected_capabilities = ['app_endpoint', 'feature', 'test_cap']
        nodetemplates = (toscaparser.utils.yamlparser.
                         simple_parse(tpl_snippet))['node_templates']
        custom_def = (toscaparser.utils.yamlparser.
                      simple_parse(custom_def))
        name = list(nodetemplates.keys())[0]
        tpl = NodeTemplate(name, nodetemplates, custom_def)
        self.assertEqual(
            expected_capabilities,
            sorted(tpl.get_capabilities().keys()))

        # custom definition without valid capability type definition
        custom_def = '''
        tosca.nodes.WebApplication.TestApp:
          derived_from: tosca.nodes.WebApplication
          capabilities:
            test_cap:
               type: tosca.capabilities.TestCapability
        '''
        custom_def = (toscaparser.utils.yamlparser.
                      simple_parse(custom_def))
        tpl = NodeTemplate(name, nodetemplates, custom_def)
        err = self.assertRaises(
            exception.InvalidTypeError,
            lambda: NodeTemplate(name, nodetemplates,
                                 custom_def).get_capabilities_objects())
        self.assertEqual('Type "tosca.capabilities.TestCapability" is not '
                         'a valid type.', six.text_type(err))
コード例 #35
0
 def _tosca_scaling_test(self, tpl_snippet, expectedprops):
     nodetemplates = (toscaparser.utils.yamlparser.simple_parse(tpl_snippet)
                      ['node_templates'])
     policies = (
         toscaparser.utils.yamlparser.simple_parse(tpl_snippet)['policies'])
     name = list(nodetemplates.keys())[0]
     policy_name = list(policies[0].keys())[0]
     for policy in policies:
         tpl = policy[policy_name]
         targets = tpl["targets"]
         properties = tpl["properties"]
     try:
         nodetemplate = NodeTemplate(name, nodetemplates)
         toscacompute = ToscaCompute(nodetemplate)
         toscacompute.handle_properties()
         policy = Policy(policy_name, tpl, targets, properties,
                         "node_templates")
         toscascaling = ToscaAutoscaling(policy)
         parameters = toscascaling.handle_properties([toscacompute])
         self.assertEqual(parameters[0].properties, expectedprops)
     except Exception:
         raise
コード例 #36
0
 def _requirements_not_implemented(self, tpl_snippet, tpl_name):
     nodetemplates = (toscaparser.utils.yamlparser.
                      simple_parse(tpl_snippet))['node_templates']
     self.assertRaises(
         NotImplementedError,
         lambda: NodeTemplate(tpl_name, nodetemplates).relationships)