167 lines
6.5 KiB
Python
167 lines
6.5 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/>.
|
|
|
|
# Make coding more python3-ish
|
|
from __future__ import (absolute_import, division, print_function)
|
|
__metaclass__ = type
|
|
|
|
from ansible.errors import AnsibleParserError
|
|
from ansible.parsing.splitter import split_args, parse_kv
|
|
from ansible.parsing.yaml.objects import AnsibleBaseYAMLObject, AnsibleMapping
|
|
from ansible.playbook.attribute import Attribute, FieldAttribute
|
|
from ansible.playbook.base import Base
|
|
from ansible.playbook.helpers import load_list_of_blocks, compile_block_list
|
|
from ansible.plugins import lookup_loader
|
|
|
|
|
|
__all__ = ['TaskInclude']
|
|
|
|
|
|
class TaskInclude(Base):
|
|
|
|
'''
|
|
A class used to wrap the use of `include: /some/other/file.yml`
|
|
within a task list, which may return a list of Task objects and/or
|
|
more TaskInclude objects.
|
|
'''
|
|
|
|
# the description field is used mainly internally to
|
|
# show a nice reprsentation of this class, rather than
|
|
# simply using __class__.__name__
|
|
|
|
__desc__ = "task include statement"
|
|
|
|
|
|
#-----------------------------------------------------------------
|
|
# Attributes
|
|
|
|
_name = FieldAttribute(isa='string')
|
|
_include = FieldAttribute(isa='string')
|
|
_loop = FieldAttribute(isa='string', private=True)
|
|
_loop_args = FieldAttribute(isa='list', private=True)
|
|
_tags = FieldAttribute(isa='list', default=[])
|
|
_vars = FieldAttribute(isa='dict', default=dict())
|
|
_when = FieldAttribute(isa='list', default=[])
|
|
|
|
def __init__(self, block=None, role=None, task_include=None, use_handlers=False):
|
|
self._block = block
|
|
self._role = role
|
|
self._task_include = task_include
|
|
self._use_handlers = use_handlers
|
|
|
|
self._task_blocks = []
|
|
|
|
super(TaskInclude, self).__init__()
|
|
|
|
@staticmethod
|
|
def load(data, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
|
|
ti = TaskInclude(block=block, role=role, task_include=None, use_handlers=use_handlers)
|
|
return ti.load_data(data, variable_manager=variable_manager, loader=loader)
|
|
|
|
def munge(self, ds):
|
|
'''
|
|
Regorganizes the data for a TaskInclude datastructure to line
|
|
up with what we expect the proper attributes to be
|
|
'''
|
|
|
|
assert isinstance(ds, dict)
|
|
|
|
# the new, cleaned datastructure, which will have legacy
|
|
# items reduced to a standard structure
|
|
new_ds = AnsibleMapping()
|
|
if isinstance(ds, AnsibleBaseYAMLObject):
|
|
new_ds.copy_position_info(ds)
|
|
|
|
for (k,v) in ds.iteritems():
|
|
if k == 'include':
|
|
self._munge_include(ds, new_ds, k, v)
|
|
elif k.replace("with_", "") in lookup_loader:
|
|
self._munge_loop(ds, new_ds, k, v)
|
|
else:
|
|
# some basic error checking, to make sure vars are properly
|
|
# formatted and do not conflict with k=v parameters
|
|
# FIXME: we could merge these instead, but controlling the order
|
|
# in which they're encountered could be difficult
|
|
if k == 'vars':
|
|
if 'vars' in new_ds:
|
|
raise AnsibleParserError("include parameters cannot be mixed with 'vars' entries for include statements", obj=ds)
|
|
elif not isinstance(v, dict):
|
|
raise AnsibleParserError("vars for include statements must be specified as a dictionary", obj=ds)
|
|
new_ds[k] = v
|
|
|
|
return new_ds
|
|
|
|
def _munge_include(self, ds, new_ds, k, v):
|
|
'''
|
|
Splits the include line up into filename and parameters
|
|
'''
|
|
|
|
# The include line must include at least one item, which is the filename
|
|
# to include. Anything after that should be regarded as a parameter to the include
|
|
items = split_args(v)
|
|
if len(items) == 0:
|
|
raise AnsibleParserError("include statements must specify the file name to include", obj=ds)
|
|
else:
|
|
# FIXME/TODO: validate that items[0] is a file, which also
|
|
# exists and is readable
|
|
new_ds['include'] = items[0]
|
|
if len(items) > 1:
|
|
# rejoin the parameter portion of the arguments and
|
|
# then use parse_kv() to get a dict of params back
|
|
params = parse_kv(" ".join(items[1:]))
|
|
if 'vars' in new_ds:
|
|
# FIXME: see fixme above regarding merging vars
|
|
raise AnsibleParserError("include parameters cannot be mixed with 'vars' entries for include statements", obj=ds)
|
|
new_ds['vars'] = params
|
|
|
|
def _munge_loop(self, ds, new_ds, k, v):
|
|
''' take a lookup plugin name and store it correctly '''
|
|
|
|
loop_name = k.replace("with_", "")
|
|
if new_ds.get('loop') is not None:
|
|
raise AnsibleError("duplicate loop in task: %s" % loop_name)
|
|
new_ds['loop'] = loop_name
|
|
new_ds['loop_args'] = v
|
|
|
|
|
|
def _load_include(self, attr, ds):
|
|
''' loads the file name specified in the ds and returns a list of blocks '''
|
|
|
|
data = self._loader.load_from_file(ds)
|
|
if not isinstance(data, list):
|
|
raise AnsibleParsingError("included task files must contain a list of tasks", obj=ds)
|
|
|
|
self._task_blocks = load_list_of_blocks(
|
|
data,
|
|
parent_block=self._block,
|
|
task_include=self,
|
|
role=self._role,
|
|
use_handlers=self._use_handlers,
|
|
loader=self._loader
|
|
)
|
|
return ds
|
|
|
|
def compile(self):
|
|
'''
|
|
Returns the task list for the included tasks.
|
|
'''
|
|
|
|
task_list = []
|
|
task_list.extend(compile_block_list(self._task_blocks))
|
|
return task_list
|
|
|