227 lines
9.0 KiB
Python
227 lines
9.0 KiB
Python
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
|
#
|
|
# This file is part of Ansible
|
|
#
|
|
# Ansible is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Ansible is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from playbook.base import Base
|
|
from playbook.conditional import Conditional
|
|
from errors import AnsibleError
|
|
from ansible import utils
|
|
|
|
class Task(Base):
|
|
|
|
# the list of valid keys for tasks
|
|
VALID_KEYS = [
|
|
'always_run',
|
|
'any_errors_fatal',
|
|
'async',
|
|
'connection',
|
|
'delay',
|
|
'delegate_to',
|
|
'environment',
|
|
'first_available_file',
|
|
'ignore_errors',
|
|
'include',
|
|
'local_action',
|
|
'meta',
|
|
'name',
|
|
'no_log',
|
|
'notify',
|
|
'poll',
|
|
'register',
|
|
'remote_user',
|
|
'retries',
|
|
'run_once',
|
|
'su',
|
|
'su_pass',
|
|
'su_user',
|
|
'sudo',
|
|
'sudo_pass',
|
|
'sudo_user',
|
|
'transport',
|
|
'until',
|
|
]
|
|
|
|
def __init__(self, block=None, role=None):
|
|
self._ds = None
|
|
self._block = block
|
|
self._role = role
|
|
self._reset()
|
|
super(Task, self).__init__()
|
|
|
|
def __repr__(self):
|
|
if self._role:
|
|
return "%s : %s" % (self._role.get_name(), self._name)
|
|
else:
|
|
return self._name
|
|
|
|
def _reset(self):
|
|
''' clears internal data structures '''
|
|
|
|
for k in self.VALID_KEYS:
|
|
setattr(self, '_%s' % k, None)
|
|
|
|
# attributes not set via the ds
|
|
self._action = None
|
|
self._module_name = None
|
|
self._parameters = None
|
|
self._lookup_plugin = None
|
|
self._lookup_terms = None
|
|
|
|
# special conditionals
|
|
self._changed_when = Conditional(self)
|
|
self._failed_when = Conditional(self)
|
|
self._when = Conditional(self)
|
|
|
|
def _load_parameters(data):
|
|
''' sets the parameters for this task, based on the type of the data '''
|
|
if isinstance(data, dict):
|
|
self._parameters = data
|
|
elif isinstance(data, basestring):
|
|
self._parameters = utils.parse_kv(data)
|
|
elif isinstance(data, None):
|
|
self._parameters = ''
|
|
else:
|
|
raise AnsibleError("invalid arguments specified, got '%s' (type=%s')" % (data, type(data)))
|
|
|
|
def load(self, ds):
|
|
''' parses and loads the task from the given datastructure '''
|
|
|
|
# reset everything internally
|
|
self._reset()
|
|
|
|
# 'action' and 'local_action' are mutually-exclusive options
|
|
if 'action' in ds and 'local_action' in ds:
|
|
raise AnsibleError("the 'action' and 'local_action' attributes can not be used together")
|
|
|
|
# iterate over each key/value in the datastructure to parse out its parameters.
|
|
args = None
|
|
for k,v in ds.iteritems():
|
|
if k in ('action', 'local_action'):
|
|
# task structure is:
|
|
# action: module_name k=v ...
|
|
# or
|
|
# local_action: module_name k=v ...
|
|
module_name, params = v.strip().split(' ', 1)
|
|
if module_name not in utils.plugins.module_finder:
|
|
raise AnsibleError("the specified module '%s' could not be found, check your module path" % module_name)
|
|
self._module_name = module_name
|
|
self._parameters = utils.parse_kv(params)
|
|
if k == 'local_action':
|
|
if 'delegate_to' in ds:
|
|
raise AnsibleError("delegate_to cannot be specified with local_action in task: %s" % ds.get('name', v))
|
|
self._delegate_to = '127.0.0.1'
|
|
if not 'transport' in ds and not 'connection' in ds:
|
|
self._transport = 'local'
|
|
elif k in utils.plugins.module_finder:
|
|
# task structure is:
|
|
# - module_name: k=v ...
|
|
if self._module_name:
|
|
raise AnsibleError("the module name (%s) was already specified, '%s' is a duplicate" % (self._module_name, k))
|
|
elif 'action' in ds:
|
|
raise AnsibleError("multiple actions specified in task: '%s' and '%s'" % (k, ds.get('name', ds['action'])))
|
|
self._module_name = k
|
|
if isinstance(v, dict) and 'args' in ds:
|
|
raise AnsibleError("can't combine args: and a dict for %s: in task %s" % (k, ds.get('name', "%s: %s" % (k, v))))
|
|
self._parameters = self._load_parameters(v)
|
|
elif k == 'args':
|
|
args = self._load_parameters(v)
|
|
elif k.startswith('with_'):
|
|
if isinstance(v, basestring):
|
|
param = v.strip()
|
|
if (param.startswith('{{') and param.find('}}') == len(ds[x]) - 2 and param.find('|') == -1):
|
|
utils.warning("It is unnecessary to use '{{' in loops, leave variables in loop expressions bare.")
|
|
plugin_name = k.replace("with_","")
|
|
if plugin_name in utils.plugins.lookup_loader:
|
|
self._lookup_plugin = plugin_name
|
|
self._lookup_terms = v
|
|
else:
|
|
raise errors.AnsibleError("cannot find lookup plugin named %s for usage in with_%s" % (plugin_name, plugin_name))
|
|
elif k.startswith('when_'):
|
|
utils.deprecated("The 'when_' conditional has been removed. Switch to using the regular unified 'when' statements as described on docs.ansible.com.","1.5", removed=True)
|
|
if self._when:
|
|
raise errors.AnsibleError("multiple when_* statements specified in task %s" % (ds.get('name', ds.get('action'))))
|
|
when_name = k.replace("when_","")
|
|
self._when = "%s %s" % (when_name, v)
|
|
elif k in ('changed_when', 'failed_when', 'when'):
|
|
# these are conditional objects, so we push the new conditional value
|
|
# into the object so that it can be evaluated later
|
|
getattr(self, '_%s' % k).push(v)
|
|
elif k == 'tags':
|
|
# all taggable datastructures in Ansible (tasks, roles, etc.) are
|
|
# based on the Base() class, which includes the _tags attribute
|
|
# (which is a Tag() class)
|
|
tags = v
|
|
if isinstance(v, basestring):
|
|
tags = v.split(',')
|
|
self._tags.push(tags)
|
|
elif k not in self.VALID_KEYS:
|
|
raise AnsibleError("%s is not a legal parameter in an Ansible task or handler" % k)
|
|
else:
|
|
setattr(self, '_%s' % k, v)
|
|
|
|
# if args were specified along with parameters, merge them now
|
|
# with the args taking lower precedence
|
|
if args:
|
|
self._parameters = utils.combine_vars(args, self._parameters)
|
|
|
|
# run validation
|
|
self._validate()
|
|
|
|
# finally, store the ds for later use/reference
|
|
self._ds = ds
|
|
|
|
def _validate(self):
|
|
'''
|
|
Validates internal datastructures and verifies mutually-exclusive
|
|
options are not in conflict.
|
|
'''
|
|
|
|
if not self._name:
|
|
# if no name: was specified, flatten the parameters back
|
|
# into a string and combine them with with module name
|
|
flat_params = " ".join(["%s=%s" % (k,v) for k,v in self._parameters.iteritems()])
|
|
self._name = "%s %s" % (self._module_name, flat_params)
|
|
|
|
# use builtin _ensure* methods to massage/set values on attributes
|
|
# anything not listed here will be defaulted to None by _reset()
|
|
self._ensure_int("_async", 0)
|
|
self._ensure_int("_poll", 10)
|
|
self._ensure_bool("_ignore_errors", False)
|
|
self._ensure_bool("_always_run", False)
|
|
self._ensure_list_of_strings("_notify", [])
|
|
|
|
# handle mutually incompatible options
|
|
if (self._sudo or self._sudo_user or self._sudo_pass) and (self._su or self._su_user or self._su_pass):
|
|
raise AnsibleError('sudo params ("sudo", "sudo_user", "sudo_pass") and su params ("su", "su_user", "su_pass") cannot be used together')
|
|
|
|
incompatibles = [ x for x in [ self._first_available_file, self._lookup_plugin ] if x is not None ]
|
|
if len(incompatibles) > 1:
|
|
raise AnsibleError("with_(plugin), and first_available_file are mutually incompatible in a single task")
|
|
|
|
@property
|
|
def name(self):
|
|
return self.__repr__()
|
|
|
|
def get_vars(self):
|
|
return dict()
|
|
|
|
def get_role(self):
|
|
return self.role
|
|
|
|
def get_block(self):
|
|
return self.block
|
|
|