def _set_plan_inputs(plan, inputs=None):
inputs = inputs if inputs else {}
# Verify inputs satisfied
missing_inputs = []
for input_name, input_def in plan['inputs'].iteritems():
if input_name in inputs:
try:
str(json.dumps(inputs[input_name], ensure_ascii=False))
except UnicodeEncodeError:
raise exceptions.DSLParsingInputTypeException(
exceptions.ERROR_INVALID_CHARS,
'Illegal characters in input: {0}. '
'Only valid ascii chars are supported.'.format(input_name))
else:
if 'default' in input_def and input_def['default'] is not None:
inputs[input_name] = input_def['default']
else:
missing_inputs.append(input_name)
if missing_inputs:
raise exceptions.MissingRequiredInputError(
"Required inputs {0} were not specified - expected "
"inputs: {1}".format(missing_inputs, plan['inputs'].keys()))
# Verify all inputs appear in plan
not_expected = [
input_name for input_name in inputs.keys()
if input_name not in plan['inputs']
]
if not_expected:
raise exceptions.UnknownInputError("Unknown inputs {0} specified - "
"expected inputs: {1}".format(
not_expected,
plan['inputs'].keys()))
plan['inputs'] = inputs
def get_input(self, input_name):
try:
return self._plan.inputs[input_name]
except KeyError:
raise exceptions.UnknownInputError(
"get_input function references an "
"unknown input '{0}'.".format(input_name))
def _set_plan_inputs(plan, inputs=None):
inputs = inputs if inputs else {}
# Verify inputs satisfied
missing_inputs = []
for input_name, input_def in plan['inputs'].iteritems():
if input_name not in inputs:
if 'default' in input_def and input_def['default'] is not None:
inputs[input_name] = input_def['default']
else:
missing_inputs.append(input_name)
if missing_inputs:
raise exceptions.MissingRequiredInputError(
"Required inputs {0} were not specified - expected "
"inputs: {1}".format(missing_inputs, plan['inputs'].keys()))
# Verify all inputs appear in plan
not_expected = [
input_name for input_name in inputs.keys()
if input_name not in plan['inputs']
]
if not_expected:
raise exceptions.UnknownInputError("Unknown inputs {0} specified - "
"expected inputs: {1}".format(
not_expected,
plan['inputs'].keys()))
plan['inputs'] = inputs
def evaluate(self, plan):
if isinstance(self.input_value, list):
return self._get_input_attribute(plan.inputs[self.input_value[0]])
if self.input_value not in plan.inputs:
raise exceptions.UnknownInputError(
"get_input function references an "
"unknown input '{0}'.".format(self.input_value))
return plan.inputs[self.input_value]
def validate(self, plan):
input_value = self.input_value[0] \
if isinstance(self.input_value, list) else self.input_value
if is_function(input_value):
return
if input_value not in plan.inputs:
raise exceptions.UnknownInputError(
"get_input function references an "
"unknown input '{0}'.".format(input_value))
def test_unknown_input_raises_unknown_input_error(self):
deployment_id = 'dep'
self._deploy_base(deployment_id, 'no_output.yaml')
with patch('dsl_parser.tasks.prepare_deployment_plan') \
as prepare_deployment_mock:
prepare_deployment_mock.side_effect = \
parser_exceptions.UnknownInputError()
response = self._update(deployment_id, 'no_output.yaml')
self.assertEquals(400, response.status_code)
self.assertEquals('unknown_deployment_input_error',
response.json['error_code'])
def _set_plan_inputs(plan, inputs=None):
inputs = inputs if inputs else {}
# Verify inputs satisfied
for input_name, input_def in plan['inputs'].iteritems():
if input_name not in inputs:
if 'default' in input_def and input_def['default'] is not None:
inputs[input_name] = input_def['default']
else:
raise exceptions.MissingRequiredInputError(
"Required input '{0}' was not specified - expected "
"inputs: {1}".format(input_name, plan['inputs'].keys()))
# Verify all inputs appear in plan
for input_name in inputs.keys():
if input_name not in plan['inputs']:
raise exceptions.UnknownInputError(
"Unknown input '{0}' specified - "
"expected inputs: {1}".format(input_name,
plan['inputs'].keys()))
plan['inputs'] = inputs
def _set_plan_inputs(plan, inputs=None):
inputs = inputs if inputs else {}
# Verify inputs satisfied
missing_inputs = []
for input_name, input_def in plan[INPUTS].items():
input_is_missing = False
if input_name in inputs:
try:
str(json.dumps(inputs[input_name], ensure_ascii=False))
except UnicodeEncodeError:
raise exceptions.DSLParsingInputTypeException(
exceptions.ERROR_INVALID_CHARS,
'Illegal characters in input: {0}. '
'Only valid ascii chars are supported.'.format(input_name))
else:
if DEFAULT in input_def and input_def[DEFAULT] is not None:
inputs[input_name] = input_def[DEFAULT]
else:
missing_inputs.append(input_name)
input_is_missing = True
# Verify inputs comply with the given constraints and also the
# data_type, if mentioned
input_constraints = constraints.extract_constraints(input_def)
if not input_is_missing:
constraints.validate_input_value(
input_name, input_constraints, inputs[input_name])
try:
utils.parse_value(
value=inputs[input_name],
type_name=input_def.get(TYPE, None),
data_types=plan.get(DATA_TYPES, {}),
undefined_property_error_message="Undefined property "
"{1} in value of "
"input {0}.",
missing_property_error_message="Value of input {0} "
"is missing property "
"{1}.",
node_name=input_name,
path=[],
raise_on_missing_property=True)
except exceptions.DSLParsingLogicException as e:
raise exceptions.DSLParsingException(
exceptions.ERROR_INPUT_VIOLATES_DATA_TYPE_SCHEMA,
str(e))
if missing_inputs:
raise exceptions.MissingRequiredInputError(
"Required inputs {0} were not specified - expected "
"inputs: {1}".format(missing_inputs, list(plan[INPUTS]))
)
# Verify all inputs appear in plan
not_expected = [input_name for input_name in inputs
if input_name not in plan[INPUTS]]
if not_expected:
raise exceptions.UnknownInputError(
"Unknown inputs {0} specified - "
"expected inputs: {1}".format(not_expected,
list(plan[INPUTS])))
plan[INPUTS] = inputs
def validate(self, plan):
if self.input_name not in plan.inputs:
raise exceptions.UnknownInputError(
"get_input function references an "
"unknown input '{0}'.".format(self.input_name))
def _set_plan_inputs(plan, inputs, auto_correct_types, values_getter):
inputs = inputs if inputs else {}
# Verify inputs satisfied
missing_inputs = []
for input_name, input_def in plan[INPUTS].items():
input_is_missing = skip_input_validation = False
if input_name in inputs:
try:
str(json.dumps(inputs[input_name], ensure_ascii=False))
except UnicodeEncodeError:
raise exceptions.DSLParsingInputTypeException(
exceptions.ERROR_INVALID_CHARS,
'Illegal characters in input: {0}. '
'Only valid ascii chars are supported.'.format(input_name))
elif DEFAULT in input_def and input_def[DEFAULT] is not None:
inputs[input_name] = input_def[DEFAULT]
else:
# Try to get some defaults from the data_type maybe or in other
# words just try to parse the value before validating it.
try:
parsed_value = utils.parse_value(
{},
type_name=input_def.get(TYPE, None),
data_types=plan.get(DATA_TYPES, {}),
undefined_property_error_message="Undefined property "
"{1} in value of "
"input {0}.",
missing_property_error_message="Value of input {0} "
"is missing property "
"{1}.",
node_name=input_name,
path=[],
raise_on_missing_property=True)
except exceptions.DSLParsingException:
parsed_value = None
finally:
if parsed_value:
inputs[input_name] = parsed_value
elif input_def.get('required', True):
missing_inputs.append(input_name)
input_is_missing = True
else:
skip_input_validation = True
inputs[input_name] = None
if skip_input_validation:
continue
# Verify inputs comply with the given constraints and also the
# data_type, if mentioned
input_constraints = constraints.extract_constraints(input_def)
if not input_is_missing:
if auto_correct_types:
inputs[input_name] = utils.cast_to_type(
inputs[input_name], input_def.get(TYPE, None))
constraints.validate_input_value(input_name, input_constraints,
inputs[input_name],
input_def.get(TYPE),
input_def.get(ITEM_TYPE),
values_getter)
inputs_complete = inputs[input_name]
try:
inputs_complete = utils.parse_value(
value=inputs[input_name],
type_name=input_def.get(TYPE, None),
data_types=plan.get(DATA_TYPES, {}),
undefined_property_error_message="Undefined property "
"{1} in value of "
"input {0}.",
missing_property_error_message="Value of input {0} "
"is missing property "
"{1}.",
node_name=input_name,
path=[],
raise_on_missing_property=True)
except exceptions.DSLParsingLogicException as e:
raise exceptions.DSLParsingException(
exceptions.ERROR_INPUT_VIOLATES_DATA_TYPE_SCHEMA, str(e))
inputs[input_name] = inputs_complete
if missing_inputs:
raise exceptions.MissingRequiredInputError(
"Required inputs {0} were not specified - expected "
"inputs: {1}".format(missing_inputs, list(plan[INPUTS])))
# Verify all inputs appear in plan
not_expected = [
input_name for input_name in inputs if input_name not in plan[INPUTS]
]
if not_expected:
raise exceptions.UnknownInputError("Unknown inputs {0} specified - "
"expected inputs: {1}".format(
not_expected,
list(plan[INPUTS])))
plan[INPUTS] = inputs
