Source code for heat.engine.hot.parameters

#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

from heat.common import exception
from heat.common.i18n import _
from heat.engine import constraints as constr
from heat.engine import parameters


PARAM_CONSTRAINTS = (
    DESCRIPTION, LENGTH, RANGE, MODULO, ALLOWED_VALUES, ALLOWED_PATTERN,
    CUSTOM_CONSTRAINT,
) = (
    'description', 'length', 'range', 'modulo', 'allowed_values',
    'allowed_pattern', 'custom_constraint',
)

RANGE_KEYS = (MIN, MAX) = ('min', 'max')

MODULO_KEYS = (STEP, OFFSET) = ('step', 'offset')


[docs]class HOTParamSchema(parameters.Schema): """HOT parameter schema.""" KEYS = ( TYPE, DESCRIPTION, DEFAULT, SCHEMA, CONSTRAINTS, HIDDEN, LABEL, IMMUTABLE ) = ( 'type', 'description', 'default', 'schema', 'constraints', 'hidden', 'label', 'immutable' ) # For Parameters the type name for Schema.LIST is comma_delimited_list # and the type name for Schema.MAP is json TYPES = ( STRING, NUMBER, LIST, MAP, BOOLEAN, ) = ( 'string', 'number', 'comma_delimited_list', 'json', 'boolean', ) PARAMETER_KEYS = KEYS @classmethod def _constraint_from_def(cls, constraint): desc = constraint.get(DESCRIPTION) if RANGE in constraint: cdef = constraint.get(RANGE) cls._check_dict(cdef, RANGE_KEYS, 'range constraint') return constr.Range(parameters.Schema.get_num(MIN, cdef), parameters.Schema.get_num(MAX, cdef), desc) elif LENGTH in constraint: cdef = constraint.get(LENGTH) cls._check_dict(cdef, RANGE_KEYS, 'length constraint') return constr.Length(parameters.Schema.get_num(MIN, cdef), parameters.Schema.get_num(MAX, cdef), desc) elif ALLOWED_VALUES in constraint: cdef = constraint.get(ALLOWED_VALUES) return constr.AllowedValues(cdef, desc) elif ALLOWED_PATTERN in constraint: cdef = constraint.get(ALLOWED_PATTERN) return constr.AllowedPattern(cdef, desc) elif CUSTOM_CONSTRAINT in constraint: cdef = constraint.get(CUSTOM_CONSTRAINT) return constr.CustomConstraint(cdef, desc) else: raise exception.InvalidSchemaError( message=_("No constraint expressed")) @classmethod
[docs] def from_dict(cls, param_name, schema_dict): """Return a Parameter Schema object from a legacy schema dictionary. :param param_name: name of the parameter owning the schema; used for more verbose logging :type param_name: str """ cls._validate_dict(param_name, schema_dict) def constraints(): constraints = schema_dict.get(cls.CONSTRAINTS) if constraints is None: return if not isinstance(constraints, list): raise exception.InvalidSchemaError( message=_("Invalid parameter constraints for parameter " "%s, expected a list") % param_name) for constraint in constraints: cls._check_dict(constraint, PARAM_CONSTRAINTS, 'parameter constraints') yield cls._constraint_from_def(constraint) # make update_allowed true by default on TemplateResources # as the template should deal with this. return cls(schema_dict[cls.TYPE], description=schema_dict.get(HOTParamSchema.DESCRIPTION), default=schema_dict.get(HOTParamSchema.DEFAULT), constraints=list(constraints()), hidden=schema_dict.get(HOTParamSchema.HIDDEN, False), label=schema_dict.get(HOTParamSchema.LABEL), immutable=schema_dict.get(HOTParamSchema.IMMUTABLE, False))
[docs]class HOTParamSchema20170224(HOTParamSchema): @classmethod def _constraint_from_def(cls, constraint): desc = constraint.get(DESCRIPTION) if MODULO in constraint: cdef = constraint.get(MODULO) cls._check_dict(cdef, MODULO_KEYS, 'modulo constraint') return constr.Modulo(parameters.Schema.get_num(STEP, cdef), parameters.Schema.get_num(OFFSET, cdef), desc) else: return super(HOTParamSchema20170224, cls)._constraint_from_def( constraint)
[docs]class HOTParameters(parameters.Parameters): PSEUDO_PARAMETERS = ( PARAM_STACK_ID, PARAM_STACK_NAME, PARAM_REGION, PARAM_PROJECT_ID ) = ( 'OS::stack_id', 'OS::stack_name', 'OS::region', 'OS::project_id' )
[docs] def set_stack_id(self, stack_identifier): """Set the StackId pseudo parameter value.""" if stack_identifier is not None: self.params[self.PARAM_STACK_ID].schema.set_default( stack_identifier.stack_id) return True return False
def _pseudo_parameters(self, stack_identifier): stack_id = getattr(stack_identifier, 'stack_id', '') stack_name = getattr(stack_identifier, 'stack_name', '') tenant = getattr(stack_identifier, 'tenant', '') yield parameters.Parameter( self.PARAM_STACK_ID, parameters.Schema(parameters.Schema.STRING, _('Stack ID'), default=str(stack_id))) yield parameters.Parameter( self.PARAM_PROJECT_ID, parameters.Schema(parameters.Schema.STRING, _('Project ID'), default=str(tenant))) if stack_name: yield parameters.Parameter( self.PARAM_STACK_NAME, parameters.Schema(parameters.Schema.STRING, _('Stack Name'), default=stack_name))