Ejemplo n.º 1
0
 def properties(self):
     props = []
     properties = self.node_type.get_value(PROPERTIES, self.node_template)
     requiredprop = []
     for p in self.node_type.properties_def:
         if p.required:
             requiredprop.append(p.name)
     if properties:
         #make sure it's not missing any property required by a node type
         missingprop = []
         for r in requiredprop:
             if r not in properties.keys():
                 missingprop.append(r)
         if missingprop:
             raise ValueError(_("Node template %(tpl)s is missing "
                                "one or more required properties %(prop)s")
                              % {'tpl': self.name, 'prop': missingprop})
         for name, value in properties.items():
             for p in self.node_type.properties_def:
                 if p.name == name:
                     prop = Property(name, value, p.schema)
                     props.append(prop)
     else:
         if requiredprop:
             raise ValueError(_("Node template %(tpl)s is missing"
                                "one or more required properties %(prop)s")
                              % {'tpl': self.name, 'prop': requiredprop})
     return props
Ejemplo n.º 2
0
 def _get_capability_property(self,
                              node_template,
                              capability_name,
                              property_name):
     """Gets a node template capability property."""
     caps = node_template.get_capabilities()
     if caps and capability_name in caps.keys():
         cap = caps[capability_name]
         property = None
         props = cap.get_properties()
         if props and property_name in props.keys():
             property = props[property_name].value
         if not property:
             raise KeyError(_(
                 "Property '{0}' not found in capability '{1}' of node"
                 " template '{2}' referenced from node template"
                 " '{3}'.").format(property_name,
                                   capability_name,
                                   node_template.name,
                                   self.context.name))
         return property
     msg = _("Requirement/Capability '{0}' referenced from '{1}' node "
             "template not found in '{2}' node template.").format(
                 capability_name,
                 self.context.name,
                 node_template.name)
     raise KeyError(msg)
Ejemplo n.º 3
0
 def validate_scalar_unit(self):
     regex = re.compile('([0-9.]+)\s*(\w+)')
     try:
         result = regex.match(str(self.value)).groups()
         validateutils.str_to_num(result[0])
     except Exception:
         raise ValueError(_('"%s" is not a valid scalar-unit')
                          % self.value)
     if result[1].upper() in self.SCALAR_UNIT_DICT.keys():
         return self.value
     raise ValueError(_('"%s" is not a valid scalar-unit') % self.value)
Ejemplo n.º 4
0
    def __init__(self, property_name, property_type, constraint):
        super(InRange, self).__init__(property_name, property_type, constraint)
        if not isinstance(self.constraint_value, collections.Sequence) or (len(constraint[self.IN_RANGE]) != 2):
            raise InvalidSchemaError(message=_("in_range must be a list."))

        for value in self.constraint_value:
            if not isinstance(value, self.valid_types):
                raise InvalidSchemaError(_("in_range value must " "be comparable."))

        self.min = self.constraint_value[0]
        self.max = self.constraint_value[1]
Ejemplo n.º 5
0
    def __init__(self, property_name, property_type, constraint):
        super(InRange, self).__init__(property_name, property_type, constraint)
        if(not isinstance(self.constraint_value, collections.Sequence) or
           (len(constraint[self.IN_RANGE]) != 2)):
            raise InvalidSchemaError(message=_('in_range must be a list.'))

        for value in self.constraint_value:
            if not isinstance(value, self.valid_types):
                raise InvalidSchemaError(_('in_range value must '
                                           'be comparable.'))

        self.min = self.constraint_value[0]
        self.max = self.constraint_value[1]
Ejemplo n.º 6
0
    def __new__(cls, property_name, property_type, constraint):
        if cls is not Constraint:
            return super(Constraint, cls).__new__(cls)

        if not isinstance(constraint, collections.Mapping) or len(constraint) != 1:
            raise InvalidSchemaError(message=_("Invalid constraint schema."))

        for type in constraint.keys():
            ConstraintClass = get_constraint_class(type)
            if not ConstraintClass:
                msg = _('Invalid constraint type "%s".') % type
                raise InvalidSchemaError(message=msg)

        return ConstraintClass(property_name, property_type, constraint)
Ejemplo n.º 7
0
    def __init__(self, name, schema_dict):
        self.name = name
        if not isinstance(schema_dict, collections.Mapping):
            msg = _("Schema %(pname)s must be a dict.") % dict(pname=name)
            raise InvalidSchemaError(message=msg)

        try:
            schema_dict['type']
        except KeyError:
            msg = _("Schema %(pname)s must have type.") % dict(pname=name)
            raise InvalidSchemaError(message=msg)

        self.schema = schema_dict
        self._len = None
        self.constraints_list = []
Ejemplo n.º 8
0
    def __new__(cls, property_name, property_type, constraint):
        if cls is not Constraint:
            return super(Constraint, cls).__new__(cls)

        if(not isinstance(constraint, collections.Mapping) or
           len(constraint) != 1):
            raise InvalidSchemaError(message=_('Invalid constraint schema.'))

        for type in constraint.keys():
            ConstraintClass = get_constraint_class(type)
            if not ConstraintClass:
                msg = _('Invalid constraint type "%s".') % type
                raise InvalidSchemaError(message=msg)

        return ConstraintClass(property_name, property_type, constraint)
Ejemplo n.º 9
0
    def __init__(self, name, schema_dict):
        self.name = name
        if not isinstance(schema_dict, collections.Mapping):
            msg = _("Schema %(pname)s must be a dict.") % dict(pname=name)
            raise InvalidSchemaError(message=msg)

        try:
            schema_dict["type"]
        except KeyError:
            msg = _("Schema %(pname)s must have type.") % dict(pname=name)
            raise InvalidSchemaError(message=msg)

        self.schema = schema_dict
        self._len = None
        self.constraints_list = []
Ejemplo n.º 10
0
class TOSCAException(Exception):
    '''Base exception class for TOSCA

    To correctly use this class, inherit from it and define
    a 'msg_fmt' property.

    '''

    _FATAL_EXCEPTION_FORMAT_ERRORS = False

    message = _('An unknown exception occurred.')

    def __init__(self, **kwargs):
        try:
            self.message = self.msg_fmt % kwargs
        except KeyError:
            exc_info = sys.exc_info()
            log.exception(
                _('Exception in string format operation: %s') % exc_info[1])

            if TOSCAException._FATAL_EXCEPTION_FORMAT_ERRORS:
                raise exc_info[0]

    def __str__(self):
        return self.message

    @staticmethod
    def set_fatal_format_exception(flag):
        if isinstance(flag, bool):
            TOSCAException._FATAL_EXCEPTION_FORMAT_ERRORS = flag
Ejemplo n.º 11
0
 def _err_msg(self, value):
     return _("%(pname)s: %(pvalue)s is out of range " "(min:%(vmin)s, max:%(vmax)s).") % dict(
         pname=self.property_name,
         pvalue=self.value_msg,
         vmin=self.constraint_value_msg[0],
         vmax=self.constraint_value_msg[1],
     )
Ejemplo n.º 12
0
 def _err_msg(self, value):
     allowed = '[%s]' % ', '.join(str(a) for a in self.constraint_value)
     return (_('%(pname)s: %(pvalue)s is not an valid '
               'value "%(cvalue)s".') %
             dict(pname=self.property_name,
                  pvalue=value,
                  cvalue=allowed))
Ejemplo n.º 13
0
 def _err_msg(self, value):
     return (_('%(pname)s: %(pvalue)s is out of range '
               '(min:%(vmin)s, max:%(vmax)s).') %
             dict(pname=self.property_name,
                  pvalue=self.value_msg,
                  vmin=self.constraint_value_msg[0],
                  vmax=self.constraint_value_msg[1]))
Ejemplo n.º 14
0
def get_scalarunit_value(type, value, unit=None):
    if type in ScalarUnit.SCALAR_UNIT_TYPES:
        ScalarUnit_Class = get_scalarunit_class(type)
        return (ScalarUnit_Class(value).
                get_num_from_scalar_unit(unit))
    else:
        raise TypeError(_('"%s" is not a valid scalar-unit type') % type)
Ejemplo n.º 15
0
    def _translate_inputs(self):
        hot_inputs = []
        hot_default = None
        for input in self.inputs:
            hot_input_type = TOSCA_TO_HOT_INPUT_TYPES[input.type]

            if input.name in self.parsed_params:
                DataEntity.validate_datatype(hot_input_type,
                                             self.parsed_params[input.name])
                hot_default = self.parsed_params[input.name]
            elif input.default is not None:
                hot_default = input.default
            else:
                raise Exception(
                    _("Need to specify a value "
                      "for input {0}").format(input.name))
            hot_constraints = []
            if input.constraints:
                for constraint in input.constraints:
                    constraint.validate(
                        int(hot_default) if hot_input_type ==
                        "number" else hot_default)
                    hc, hvalue = self._translate_constraints(
                        constraint.constraint_key, constraint.constraint_value)
                    hot_constraints.append({hc: hvalue})

            hot_inputs.append(
                HotParameter(name=input.name,
                             type=hot_input_type,
                             description=input.description,
                             default=hot_default,
                             constraints=hot_constraints))
        return hot_inputs
Ejemplo n.º 16
0
 def _err_msg(self, value):
     allowed = '[%s]' % ', '.join(str(a) for a in self.constraint_value)
     return (_('%(pname)s: %(pvalue)s is not an valid '
               'value "%(cvalue)s".') %
             dict(pname=self.property_name,
                  pvalue=value,
                  cvalue=allowed))
Ejemplo n.º 17
0
    def _translate_inputs(self):
        hot_inputs = []
        hot_default = None
        for input in self.inputs:
            hot_input_type = TOSCA_TO_HOT_INPUT_TYPES[input.type]

            if input.name in self.parsed_params:
                DataEntity.validate_datatype(hot_input_type,
                                             self.parsed_params[input.name])
                hot_default = self.parsed_params[input.name]
            elif input.default is not None:
                hot_default = input.default
            else:
                raise Exception(_("Need to specify a value "
                                  "for input {0}").format(input.name))
            hot_constraints = []
            if input.constraints:
                for constraint in input.constraints:
                    constraint.validate(
                        int(hot_default) if hot_input_type == "number"
                        else hot_default)
                    hc, hvalue = self._translate_constraints(
                        constraint.constraint_key, constraint.constraint_value)
                    hot_constraints.append({hc: hvalue})

            hot_inputs.append(HotParameter(name=input.name,
                                           type=hot_input_type,
                                           description=input.description,
                                           default=hot_default,
                                           constraints=hot_constraints))
        return hot_inputs
Ejemplo n.º 18
0
 def _find_node_template(self, node_template_name):
     if node_template_name == SELF:
         return self.context
     for node_template in self.tosca_tpl.nodetemplates:
         if node_template.name == node_template_name:
             return node_template
     raise KeyError(_(
         'No such node template: {0}.').format(node_template_name))
Ejemplo n.º 19
0
 def validate_scalar_unit_size(value):
     regex = re.compile('(\d*)\s*(\w*)')
     result = regex.match(str(value)).groups()
     if result[0] and ((not result[1]) or (result[1].upper() in
                                           Schema.SCALAR_UNIT_SIZE_DICT.
                                           keys())):
         return value
     raise ValueError(_('"%s" is not a valid scalar-unit') % value)
Ejemplo n.º 20
0
 def validate(self):
     if len(self.args) != 1:
         raise ValueError(_(
             'Expected one argument for get_input function but received: '
             '{0}.').format(self.args))
     inputs = [input.name for input in self.tosca_tpl.inputs]
     if self.args[0] not in inputs:
         raise UnknownInputError(input_name=self.args[0])
Ejemplo n.º 21
0
 def __init__(self, ntype):
     super(NodeType, self).__init__()
     if ntype not in list(self.TOSCA_DEF.keys()):
         raise ValueError(_('Node type %(ntype)s is not a valid type.')
                          % {'ntype': ntype})
     self.defs = self.TOSCA_DEF[ntype]
     self.type = ntype
     self.related = {}
Ejemplo n.º 22
0
 def validate(self):
     if len(self.args) < 2 or len(self.args) > 3:
         raise ValueError(_(
             'Expected arguments: [node-template-name, req-or-cap '
             '(optional), property name.'))
     if len(self.args) == 2:
         prop = self._find_property(self.args[1]).value
         if not isinstance(prop, Function):
             get_function(self.tosca_tpl, self.context, prop)
     elif len(self.args) == 3:
         get_function(self.tosca_tpl,
                      self.context,
                      self._find_req_or_cap_property(self.args[1],
                                                     self.args[2]))
     else:
         raise NotImplementedError(_(
             'Nested properties are not supported.'))
Ejemplo n.º 23
0
    def validate_boolean(value):
        if isinstance(value, bool):
            return value

        if isinstance(value, str):
            normalised = value.lower()
            if normalised in ["true", "false"]:
                return normalised == "true"
        raise ValueError(_('"%s" is not a boolean') % value)
Ejemplo n.º 24
0
    def validate_boolean(value):
        if isinstance(value, bool):
            return value

        if isinstance(value, str):
            normalised = value.lower()
            if normalised in ['true', 'false']:
                return normalised == 'true'
        raise ValueError(_('"%s" is not a boolean') % value)
Ejemplo n.º 25
0
 def _find_property(self, property_name):
     node_tpl = self._find_node_template(self.args[0])
     props = node_tpl.get_properties()
     found = [props[property_name]] if property_name in props else []
     if len(found) == 0:
         raise KeyError(_(
             "Property: '{0}' not found in node template: {1}.").format(
                 property_name, node_tpl.name))
     return found[0]
Ejemplo n.º 26
0
    def __init__(self, **kwargs):
        try:
            self.message = self.msg_fmt % kwargs
        except KeyError:
            exc_info = sys.exc_info()
            log.exception(_('Exception in string format operation: %s')
                          % exc_info[1])

            if TOSCAException._FATAL_EXCEPTION_FORMAT_ERRORS:
                raise exc_info[0]
Ejemplo n.º 27
0
    def __init__(self, **kwargs):
        try:
            self.message = self.msg_fmt % kwargs
        except KeyError:
            exc_info = sys.exc_info()
            log.exception(
                _('Exception in string format operation: %s') % exc_info[1])

            if TOSCAException._FATAL_EXCEPTION_FORMAT_ERRORS:
                raise exc_info[0]
Ejemplo n.º 28
0
def parse_parameters(parameter_list):
    parsed_inputs = {}
    if parameter_list.startswith('--parameters'):
        inputs = parameter_list.split('--parameters=')[1].\
            replace('"', '').split(';')
        for param in inputs:
            keyvalue = param.split('=')
            parsed_inputs[keyvalue[0]] = keyvalue[1]
    else:
        raise ValueError(_("%(param) is not a valid parameter.")
                         % parameter_list)
    return parsed_inputs
Ejemplo n.º 29
0
 def handle_hosting(self):
     # handle hosting server for the OS:HEAT::SoftwareDeployment
     # from the TOSCA nodetemplate, traverse the relationship chain
     # down to the server
     if self.type == "OS::Heat::SoftwareDeployment":
         # skip if already have hosting
         # If type is NodeTemplate, look up corresponding HotResrouce
         host_server = self.properties.get("server")
         if host_server is None or not host_server["get_resource"]:
             raise Exception(_("Internal Error: expecting host " "in software deployment"))
         elif isinstance(host_server["get_resource"], NodeTemplate):
             self.properties["server"]["get_resource"] = host_server["get_resource"].name
Ejemplo n.º 30
0
def main():
    if len(sys.argv) < 3:
        msg = _("The program requires minimum two arguments. "
                "Please refer to the usage documentation.")
        raise ValueError(msg)
    if "--template-file=" not in sys.argv[1]:
        msg = _("The program expects --template-file as first argument. "
                "Please refer to the usage documentation.")
        raise ValueError(msg)
    if "--template-type=" not in sys.argv[2]:
        msg = _("The program expects --template-type as second argument. "
                "Please refer to the usage documentation.")
        raise ValueError(msg)
    path = sys.argv[1].split('--template-file=')[1]
    # e.g. --template_file=translator/toscalib/tests/data/tosca_helloworld.yaml
    template_type = sys.argv[2].split('--template-type=')[1]
    # e.g. --template_type=tosca
    supported_types = ['tosca']
    if not template_type:
        raise ValueError(_("Template type is needed. For example, 'tosca'"))
    elif template_type not in supported_types:
        raise ValueError(_("%(value)s is not a valid template type.")
                         % {'value': template_type})
    parsed_params = {}
    if len(sys.argv) > 3:
        parsed_params = parse_parameters(sys.argv[3])
    if os.path.isfile(path):
        heat_tpl = translate(template_type, path, parsed_params)
        if heat_tpl:
            write_output(heat_tpl)
    else:
        raise ValueError(_("%(path)s is not a valid file.") % {'path': path})
Ejemplo n.º 31
0
 def _find_node_template_containing_attribute(self):
     if self.node_template_name == HOST:
         # Currently this is the only way to tell whether the function
         # is used within the outputs section of the TOSCA template.
         if isinstance(self.context, list):
             raise ValueError(_(
                 "get_attribute HOST keyword is not allowed within the "
                 "outputs section of the TOSCA template"))
         node_tpl = self._find_host_containing_attribute()
         if not node_tpl:
             raise ValueError(_(
                 "get_attribute HOST keyword is used in '{0}' node "
                 "template but {1} was not found "
                 "in relationship chain").format(self.context.name,
                                                 HOSTED_ON))
     else:
         node_tpl = self._find_node_template(self.args[0])
     if not self._attribute_exists_in_type(node_tpl.type_definition):
         raise KeyError(_(
             "Attribute '{0}' not found in node template: {1}.").format(
                 self.attribute_name, node_tpl.name))
     return node_tpl
Ejemplo n.º 32
0
 def __init__(self, property_name, property_type, constraint):
     self.property_name = property_name
     self.property_type = property_type
     self.constraint_value = constraint[self.constraint_key]
     self.constraint_value_msg = self.constraint_value
     if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
         self.constraint_value = self._get_scalarunit_constraint_value()
     # check if constraint is valid for property type
     if property_type not in self.valid_prop_types:
         msg = _('Constraint type "%(ctype)s" is not valid '
                 'for data type "%(dtype)s".') % dict(
                     ctype=self.constraint_key,
                     dtype=property_type)
         raise InvalidSchemaError(message=msg)
Ejemplo n.º 33
0
 def handle_hosting(self):
     # handle hosting server for the OS:HEAT::SoftwareDeployment
     # from the TOSCA nodetemplate, traverse the relationship chain
     # down to the server
     if self.type == 'OS::Heat::SoftwareDeployment':
         # skip if already have hosting
         # If type is NodeTemplate, look up corresponding HotResrouce
         host_server = self.properties.get('server')
         if host_server is None or not host_server['get_resource']:
             raise Exception(
                 _("Internal Error: expecting host "
                   "in software deployment"))
         elif isinstance(host_server['get_resource'], NodeTemplate):
             self.properties['server']['get_resource'] = \
                 host_server['get_resource'].name
 def _tosca_compute_test(self, tpl_snippet, expectedprops):
     nodetemplates = (translator.toscalib.utils.yamlparser.
                      simple_parse(tpl_snippet)['node_templates'])
     name = list(nodetemplates.keys())[0]
     try:
         nodetemplate = NodeTemplate(name, nodetemplates)
         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
Ejemplo n.º 35
0
 def __init__(self, property_name, property_type, constraint):
     self.property_name = property_name
     self.property_type = property_type
     self.constraint_value = constraint[self.constraint_key]
     self.constraint_value_msg = self.constraint_value
     if self.property_type == Schema.SCALAR_UNIT_SIZE:
         if isinstance(self.constraint_value, list):
             self.constraint_value = [Constraint.get_num_from_scalar_unit_size(v) for v in self.constraint_value]
         else:
             self.constraint_value = Constraint.get_num_from_scalar_unit_size(self.constraint_value)
     # check if constraint is valid for property type
     if property_type not in self.valid_prop_types:
         msg = _('Constraint type "%(ctype)s" is not valid ' 'for data type "%(dtype)s".') % dict(
             ctype=self.constraint_key, dtype=property_type
         )
         raise InvalidSchemaError(message=msg)
Ejemplo n.º 36
0
    def get_num_from_scalar_unit(self, unit=None):
        if unit:
            if unit.upper() not in self.SCALAR_UNIT_DICT.keys():
                raise ValueError(_('input unit "%s" is not a valid unit')
                                 % unit)
        else:
            unit = self.SCALAR_UNIT_DEFAULT
        self.validate_scalar_unit()

        regex = re.compile('([0-9.]+)\s*(\w+)')
        result = regex.match(str(self.value)).groups()
        converted = (float(validateutils.str_to_num(result[0]))
                     * self.SCALAR_UNIT_DICT[result[1].upper()]
                     / self.SCALAR_UNIT_DICT[unit.upper()])
        if converted - int(converted) < 0.0000000000001:
            converted = int(converted)
        return converted
Ejemplo n.º 37
0
 def _tosca_compute_test(self, tpl_snippet, expectedprops):
     nodetemplates = (translator.toscalib.utils.yamlparser.simple_parse(
         tpl_snippet)['node_templates'])
     name = list(nodetemplates.keys())[0]
     try:
         nodetemplate = NodeTemplate(name, nodetemplates)
         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
Ejemplo n.º 38
0
 def get_num_from_scalar_unit_size(value, unit=None):
     if unit:
         if unit.upper() not in Schema.SCALAR_UNIT_SIZE_DICT.keys():
             raise ValueError(_('input unit "%s" is not a valid unit')
                              % unit)
     else:
         unit = Schema.SCALAR_UNIT_SIZE_DEFAULT
     Constraint.validate_scalar_unit_size(value)
     regex = re.compile('(\d*)\s*(\w*)')
     result = regex.match(str(value)).groups()
     if not result[1]:
         converted = (Constraint.str_to_num(result[0]))
     if result[1].upper() in Schema.SCALAR_UNIT_SIZE_DICT.keys():
         converted = int(Constraint.str_to_num(result[0])
                         * Schema.SCALAR_UNIT_SIZE_DICT[result[1].upper()]
                         * math.pow(Schema.SCALAR_UNIT_SIZE_DICT
                                    [unit.upper()], -1))
     return converted
Ejemplo n.º 39
0
 def get_num_from_scalar_unit_size(value, unit=None):
     if unit:
         if unit.upper() not in Schema.SCALAR_UNIT_SIZE_DICT.keys():
             raise ValueError(_('input unit "%s" is not a valid unit') % unit)
     else:
         unit = Schema.SCALAR_UNIT_SIZE_DEFAULT
     Constraint.validate_scalar_unit_size(value)
     regex = re.compile("(\d*)\s*(\w*)")
     result = regex.match(str(value)).groups()
     if not result[1]:
         converted = Constraint.str_to_num(result[0])
     if result[1].upper() in Schema.SCALAR_UNIT_SIZE_DICT.keys():
         converted = int(
             Constraint.str_to_num(result[0])
             * Schema.SCALAR_UNIT_SIZE_DICT[result[1].upper()]
             * math.pow(Schema.SCALAR_UNIT_SIZE_DICT[unit.upper()], -1)
         )
     return converted
Ejemplo n.º 40
0
 def __init__(self, property_name, property_type, constraint):
     self.property_name = property_name
     self.property_type = property_type
     self.constraint_value = constraint[self.constraint_key]
     self.constraint_value_msg = self.constraint_value
     if self.property_type == Schema.SCALAR_UNIT_SIZE:
         if isinstance(self.constraint_value, list):
             self.constraint_value = [Constraint.
                                      get_num_from_scalar_unit_size(v)
                                      for v in self.constraint_value]
         else:
             self.constraint_value = (Constraint.
                                      get_num_from_scalar_unit_size
                                      (self.constraint_value))
     # check if constraint is valid for property type
     if property_type not in self.valid_prop_types:
         msg = _('Constraint type "%(ctype)s" is not valid '
                 'for data type "%(dtype)s".') % dict(
                     ctype=self.constraint_key,
                     dtype=property_type)
         raise InvalidSchemaError(message=msg)
Ejemplo n.º 41
0
    def _get_explicit_relationship(self, req, value):
        """Handle explicit relationship

        For example,
        - req:
            node: DBMS
            relationship: tosca.relationships.HostedOn
        """
        explicit_relation = {}
        node = value.get('node')
        if node:
            #TODO(spzala) implement look up once Glance meta data is available
            #to find a matching TOSCA node using the TOSCA types
            msg = _('Lookup by TOSCA types are not supported. '
                    'Requirement for %s can not be full-filled.') % self.name
            if (node in list(self.type_definition.TOSCA_DEF.keys())
                    or node in self.custom_def):
                raise NotImplementedError(msg)
            related_tpl = NodeTemplate(node, self.templates, self.custom_def)
            relationship = value.get('relationship')
            if relationship:
                found_relationship_tpl = False
                #apply available relationship templates if found
                for tpl in self.available_rel_tpls:
                    if tpl.name == relationship:
                        rtype = RelationshipType(tpl.type)
                        explicit_relation[rtype] = related_tpl
                        self.relationship_tpl.append(tpl)
                        found_relationship_tpl = True
                #create relationship template object.
                if not found_relationship_tpl:
                    if isinstance(relationship, dict):
                        relationship = relationship.get('type')
                    for rtype in self.type_definition.relationship.keys():
                        if rtype.type == relationship:
                            explicit_relation[rtype] = related_tpl
                            related_tpl._add_relationship_template(
                                req, rtype.type)
        return explicit_relation
Ejemplo n.º 42
0
    def _get_explicit_relationship(self, req, value):
        """Handle explicit relationship

        For example,
        - req:
            node: DBMS
            relationship: tosca.relationships.HostedOn
        """
        explicit_relation = {}
        node = value.get('node')
        if node:
            #TODO(spzala) implement look up once Glance meta data is available
            #to find a matching TOSCA node using the TOSCA types
            msg = _('Lookup by TOSCA types are not supported. '
                    'Requirement for %s can not be full-filled.') % self.name
            if (node in list(self.type_definition.TOSCA_DEF.keys())
               or node in self.custom_def):
                    raise NotImplementedError(msg)
            related_tpl = NodeTemplate(node, self.templates, self.custom_def)
            relationship = value.get('relationship')
            if relationship:
                found_relationship_tpl = False
                #apply available relationship templates if found
                for tpl in self.available_rel_tpls:
                    if tpl.name == relationship:
                        rtype = RelationshipType(tpl.type)
                        explicit_relation[rtype] = related_tpl
                        self.relationship_tpl.append(tpl)
                        found_relationship_tpl = True
                #create relationship template object.
                if not found_relationship_tpl:
                    if isinstance(relationship, dict):
                        relationship = relationship.get('type')
                    for rtype in self.type_definition.relationship.keys():
                        if rtype.type == relationship:
                            explicit_relation[rtype] = related_tpl
                            related_tpl._add_relationship_template(req,
                                                                   rtype.type)
        return explicit_relation
Ejemplo n.º 43
0
class InvalidSchemaError(TOSCAException):
    msg_fmt = _("%(message)s")
Ejemplo n.º 44
0
 def get_hot_attribute(self, attribute, args):
     # this is a place holder and should be implemented by the subclass
     # if translation is needed for the particular attribute
     raise Exception(
         _("No translation in TOSCA type {0} for attribute "
           "{1}").format(self.nodetemplate.type, attribute))
Ejemplo n.º 45
0
 def get_hot_attribute(self, attribute, args):
     # this is a place holder and should be implemented by the subclass
     # if translation is needed for the particular attribute
     raise Exception(
         _("No translation in TOSCA type {0} for attribute " "{1}").format(self.nodetemplate.type, attribute)
     )
Ejemplo n.º 46
0
class TypeMismatchError(TOSCAException):
    msg_fmt = _('%(what)s must be of type: "%(type)s".')
Ejemplo n.º 47
0
class InvalidTypeError(TOSCAException):
    msg_fmt = _('Type "%(what)s" is not a valid type.')
Ejemplo n.º 48
0
class ValidationError(TOSCAException):
    msg_fmt = _("%(message)s")
Ejemplo n.º 49
0
class UnknownInputError(TOSCAException):
    msg_fmt = _('Unknown input: %(input_name)s')
Ejemplo n.º 50
0
 def validate(self):
     if len(self.args) != 2:
         raise ValueError(_(
             'Illegal arguments for {0} function. Expected arguments: '
             'node-template-name, attribute-name').format(GET_ATTRIBUTE))
     self._find_node_template_containing_attribute()
Ejemplo n.º 51
0
class InvalidPropertyValueError(TOSCAException):
    msg_fmt = _('Value of property "%(what)s" is invalid.')
Ejemplo n.º 52
0
class InvalidTemplateVersion(TOSCAException):
    msg_fmt = _('The template version "%(what)s" is invalid. '
                'The valid versions are: "%(valid_versions)s"')
Ejemplo n.º 53
0
 def _err_msg(self, value):
     return _('%(pname)s: "%(pvalue)s" does not match ' 'pattern "%(cvalue)s".') % dict(
         pname=self.property_name, pvalue=value, cvalue=self.constraint_value
     )