| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE file distributed with |
| # this work for additional information regarding copyright ownership. |
| # The ASF licenses this file to You 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. |
| |
| """ |
| Instantiation of :class:`~aria.modeling.models.Operation` models. |
| """ |
| |
| # TODO: this module will eventually be moved to a new "aria.instantiation" package |
| |
| from ...utils.type import full_type_name |
| from ...utils.formatting import safe_repr |
| from ...utils.collections import OrderedDict |
| from ...parser import validation |
| from ...parser.consumption import ConsumptionContext |
| from ...modeling.functions import Function |
| |
| |
| def configure_operation(operation): |
| host = None |
| interface = operation.interface |
| if interface.node is not None: |
| host = interface.node.host |
| elif interface.relationship is not None: |
| if operation.relationship_edge is True: |
| host = interface.relationship.target_node.host |
| else: # either False or None (None meaning that edge was not specified) |
| host = interface.relationship.source_node.host |
| |
| _configure_common(operation) |
| if host is None: |
| _configure_local(operation) |
| else: |
| _configure_remote(operation) |
| |
| # Any remaining un-handled configuration parameters will become extra arguments, available as |
| # kwargs in either "run_script_locally" or "run_script_with_ssh" |
| for key, value in operation.configurations.iteritems(): |
| if key not in ('process', 'ssh'): |
| operation.arguments[key] = value.instantiate(None) |
| |
| |
| def _configure_common(operation): |
| """ |
| Local and remote operations. |
| """ |
| |
| from ...modeling.models import Argument |
| operation.arguments['script_path'] = Argument.wrap('script_path', operation.implementation, |
| 'Relative path to the executable file.') |
| operation.arguments['process'] = Argument.wrap('process', _get_process(operation), |
| 'Sub-process configuration.') |
| |
| |
| def _configure_local(operation): |
| """ |
| Local operation. |
| """ |
| |
| from . import operations |
| operation.function = '{0}.{1}'.format(operations.__name__, |
| operations.run_script_locally.__name__) |
| |
| |
| def _configure_remote(operation): |
| """ |
| Remote SSH operation via Fabric. |
| """ |
| |
| from ...modeling.models import Argument |
| from . import operations |
| |
| ssh = _get_ssh(operation) |
| |
| # Defaults |
| # TODO: find a way to configure these generally in the service template |
| default_user = '' |
| default_password = '' |
| if 'user' not in ssh: |
| ssh['user'] = default_user |
| if ('password' not in ssh) and ('key' not in ssh) and ('key_filename' not in ssh): |
| ssh['password'] = default_password |
| |
| operation.arguments['use_sudo'] = Argument.wrap('use_sudo', ssh.get('use_sudo', False), |
| 'Whether to execute with sudo.') |
| |
| operation.arguments['hide_output'] = Argument.wrap('hide_output', ssh.get('hide_output', []), |
| 'Hide output of these Fabric groups.') |
| |
| fabric_env = {} |
| if 'warn_only' in ssh: |
| fabric_env['warn_only'] = ssh['warn_only'] |
| fabric_env['user'] = ssh.get('user') |
| fabric_env['password'] = ssh.get('password') |
| fabric_env['key'] = ssh.get('key') |
| fabric_env['key_filename'] = ssh.get('key_filename') |
| if 'address' in ssh: |
| fabric_env['host_string'] = ssh['address'] |
| |
| # Make sure we have a user |
| if fabric_env.get('user') is None: |
| context = ConsumptionContext.get_thread_local() |
| context.validation.report('must configure "ssh.user" for "{0}"' |
| .format(operation.implementation), |
| level=validation.Issue.BETWEEN_TYPES) |
| |
| # Make sure we have an authentication value |
| if (fabric_env.get('password') is None) and \ |
| (fabric_env.get('key') is None) and \ |
| (fabric_env.get('key_filename') is None): |
| context = ConsumptionContext.get_thread_local() |
| context.validation.report('must configure "ssh.password", "ssh.key", or "ssh.key_filename" ' |
| 'for "{0}"' |
| .format(operation.implementation), |
| level=validation.Issue.BETWEEN_TYPES) |
| |
| operation.arguments['fabric_env'] = Argument.wrap('fabric_env', fabric_env, |
| 'Fabric configuration.') |
| |
| operation.function = '{0}.{1}'.format(operations.__name__, |
| operations.run_script_with_ssh.__name__) |
| |
| |
| def _get_process(operation): |
| value = (operation.configurations.get('process')._value |
| if 'process' in operation.configurations |
| else None) |
| if value is None: |
| return {} |
| _validate_type(value, dict, 'process') |
| value = OrderedDict(value) |
| for k, v in value.iteritems(): |
| if k == 'eval_python': |
| value[k] = _coerce_bool(v, 'process.eval_python') |
| elif k == 'cwd': |
| _validate_type(v, basestring, 'process.cwd') |
| elif k == 'command_prefix': |
| _validate_type(v, basestring, 'process.command_prefix') |
| elif k == 'args': |
| value[k] = _dict_to_list_of_strings(v, 'process.args') |
| elif k == 'env': |
| _validate_type(v, dict, 'process.env') |
| else: |
| context = ConsumptionContext.get_thread_local() |
| context.validation.report('unsupported configuration parameter: "process.{0}"' |
| .format(k), |
| level=validation.Issue.BETWEEN_TYPES) |
| return value |
| |
| |
| def _get_ssh(operation): |
| value = (operation.configurations.get('ssh')._value |
| if 'ssh' in operation.configurations |
| else None) |
| if value is None: |
| return {} |
| _validate_type(value, dict, 'ssh') |
| value = OrderedDict(value) |
| for k, v in value.iteritems(): |
| if k == 'use_sudo': |
| value[k] = _coerce_bool(v, 'ssh.use_sudo') |
| elif k == 'hide_output': |
| value[k] = _dict_to_list_of_strings(v, 'ssh.hide_output') |
| elif k == 'warn_only': |
| value[k] = _coerce_bool(v, 'ssh.warn_only') |
| elif k == 'user': |
| _validate_type(v, basestring, 'ssh.user') |
| elif k == 'password': |
| _validate_type(v, basestring, 'ssh.password') |
| elif k == 'key': |
| _validate_type(v, basestring, 'ssh.key') |
| elif k == 'key_filename': |
| _validate_type(v, basestring, 'ssh.key_filename') |
| elif k == 'address': |
| _validate_type(v, basestring, 'ssh.address') |
| else: |
| context = ConsumptionContext.get_thread_local() |
| context.validation.report('unsupported configuration parameter: "ssh.{0}"'.format(k), |
| level=validation.Issue.BETWEEN_TYPES) |
| return value |
| |
| |
| def _validate_type(value, the_type, name): |
| if isinstance(value, Function): |
| return |
| if not isinstance(value, the_type): |
| context = ConsumptionContext.get_thread_local() |
| context.validation.report('"{0}" configuration is not a {1}: {2}' |
| .format(name, full_type_name(the_type), safe_repr(value)), |
| level=validation.Issue.BETWEEN_TYPES) |
| |
| |
| def _coerce_bool(value, name): |
| if value is None: |
| return None |
| if isinstance(value, bool): |
| return value |
| _validate_type(value, basestring, name) |
| if value == 'true': |
| return True |
| elif value == 'false': |
| return False |
| else: |
| context = ConsumptionContext.get_thread_local() |
| context.validation.report('"{0}" configuration is not "true" or "false": {1}' |
| .format(name, safe_repr(value)), |
| level=validation.Issue.BETWEEN_TYPES) |
| |
| |
| def _dict_to_list_of_strings(the_dict, name): |
| _validate_type(the_dict, dict, name) |
| value = [] |
| for k in sorted(the_dict): |
| v = the_dict[k] |
| _validate_type(v, basestring, '{0}.{1}'.format(name, k)) |
| value.append(v) |
| return value |
