mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-04-27 21:01:27 -07:00
8c08d03989
* Add tests for check_mode at play and task level These test inheritance of check_mode from the various levels (command line, as a play attribute and as a task attribute) so they will be useful for checking that the change to fieldattribute inheritance with defaults works * Add a sentinel object The Sentinel object can be used in place of None when we need to mark an entry as being special (usually used to mark something as not having been set) * Start of using a Sentinel object instead of None. * Handle edge cases around use of Sentinel * _get_parent_attribute needs to deal in Sentinel not None * No need to special case any_errors_fatal in task.py any longer * Handle more edge cases around Sentinel * Use Sentinel instead of None in TaskInclude * Update code to clarify the vars we are copying are class attrs * Add changelog fragment * Use a default of Sentinel for delegate_to, this also allows 'delegate_to: ~' now to unset inherited delegate_to * Explain Sentinel stripping in _extend_value * Fix ModuleArgsParser tests to compare with Sentinel * Fixes for tasks inside of roles inheriting from play * Remove incorrect note. ci_complete * Remove commented code
421 lines
16 KiB
Python
421 lines
16 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.playbook.attribute import FieldAttribute
|
|
from ansible.playbook.base import Base
|
|
from ansible.playbook.become import Become
|
|
from ansible.playbook.conditional import Conditional
|
|
from ansible.playbook.helpers import load_list_of_tasks
|
|
from ansible.playbook.role import Role
|
|
from ansible.playbook.taggable import Taggable
|
|
from ansible.utils.sentinel import Sentinel
|
|
|
|
|
|
class Block(Base, Become, Conditional, Taggable):
|
|
|
|
# main block fields containing the task lists
|
|
_block = FieldAttribute(isa='list', default=list, inherit=False)
|
|
_rescue = FieldAttribute(isa='list', default=list, inherit=False)
|
|
_always = FieldAttribute(isa='list', default=list, inherit=False)
|
|
|
|
# other fields
|
|
_delegate_to = FieldAttribute(isa='string')
|
|
_delegate_facts = FieldAttribute(isa='bool')
|
|
|
|
# for future consideration? this would be functionally
|
|
# similar to the 'else' clause for exceptions
|
|
# _otherwise = FieldAttribute(isa='list')
|
|
|
|
def __init__(self, play=None, parent_block=None, role=None, task_include=None, use_handlers=False, implicit=False):
|
|
self._play = play
|
|
self._role = role
|
|
self._parent = None
|
|
self._dep_chain = None
|
|
self._use_handlers = use_handlers
|
|
self._implicit = implicit
|
|
|
|
# end of role flag
|
|
self._eor = False
|
|
|
|
if task_include:
|
|
self._parent = task_include
|
|
elif parent_block:
|
|
self._parent = parent_block
|
|
|
|
super(Block, self).__init__()
|
|
|
|
def __repr__(self):
|
|
return "BLOCK(uuid=%s)(id=%s)(parent=%s)" % (self._uuid, id(self), self._parent)
|
|
|
|
def __eq__(self, other):
|
|
'''object comparison based on _uuid'''
|
|
return self._uuid == other._uuid
|
|
|
|
def __ne__(self, other):
|
|
'''object comparison based on _uuid'''
|
|
return self._uuid != other._uuid
|
|
|
|
def get_vars(self):
|
|
'''
|
|
Blocks do not store variables directly, however they may be a member
|
|
of a role or task include which does, so return those if present.
|
|
'''
|
|
|
|
all_vars = self.vars.copy()
|
|
|
|
if self._parent:
|
|
all_vars.update(self._parent.get_vars())
|
|
|
|
return all_vars
|
|
|
|
@staticmethod
|
|
def load(data, play=None, parent_block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
|
|
implicit = not Block.is_block(data)
|
|
b = Block(play=play, parent_block=parent_block, role=role, task_include=task_include, use_handlers=use_handlers, implicit=implicit)
|
|
return b.load_data(data, variable_manager=variable_manager, loader=loader)
|
|
|
|
@staticmethod
|
|
def is_block(ds):
|
|
is_block = False
|
|
if isinstance(ds, dict):
|
|
for attr in ('block', 'rescue', 'always'):
|
|
if attr in ds:
|
|
is_block = True
|
|
break
|
|
return is_block
|
|
|
|
def preprocess_data(self, ds):
|
|
'''
|
|
If a simple task is given, an implicit block for that single task
|
|
is created, which goes in the main portion of the block
|
|
'''
|
|
|
|
if not Block.is_block(ds):
|
|
if isinstance(ds, list):
|
|
return super(Block, self).preprocess_data(dict(block=ds))
|
|
else:
|
|
return super(Block, self).preprocess_data(dict(block=[ds]))
|
|
|
|
return super(Block, self).preprocess_data(ds)
|
|
|
|
def _load_block(self, attr, ds):
|
|
try:
|
|
return load_list_of_tasks(
|
|
ds,
|
|
play=self._play,
|
|
block=self,
|
|
role=self._role,
|
|
task_include=None,
|
|
variable_manager=self._variable_manager,
|
|
loader=self._loader,
|
|
use_handlers=self._use_handlers,
|
|
)
|
|
except AssertionError as e:
|
|
raise AnsibleParserError("A malformed block was encountered while loading a block", obj=self._ds, orig_exc=e)
|
|
|
|
def _load_rescue(self, attr, ds):
|
|
try:
|
|
return load_list_of_tasks(
|
|
ds,
|
|
play=self._play,
|
|
block=self,
|
|
role=self._role,
|
|
task_include=None,
|
|
variable_manager=self._variable_manager,
|
|
loader=self._loader,
|
|
use_handlers=self._use_handlers,
|
|
)
|
|
except AssertionError as e:
|
|
raise AnsibleParserError("A malformed block was encountered while loading rescue.", obj=self._ds, orig_exc=e)
|
|
|
|
def _load_always(self, attr, ds):
|
|
try:
|
|
return load_list_of_tasks(
|
|
ds,
|
|
play=self._play,
|
|
block=self,
|
|
role=self._role,
|
|
task_include=None,
|
|
variable_manager=self._variable_manager,
|
|
loader=self._loader,
|
|
use_handlers=self._use_handlers,
|
|
)
|
|
except AssertionError as e:
|
|
raise AnsibleParserError("A malformed block was encountered while loading always", obj=self._ds, orig_exc=e)
|
|
|
|
def _validate_always(self, attr, name, value):
|
|
if value and not self.block:
|
|
raise AnsibleParserError("'%s' keyword cannot be used without 'block'" % name, obj=self._ds)
|
|
|
|
_validate_rescue = _validate_always
|
|
|
|
def get_dep_chain(self):
|
|
if self._dep_chain is None:
|
|
if self._parent:
|
|
return self._parent.get_dep_chain()
|
|
else:
|
|
return None
|
|
else:
|
|
return self._dep_chain[:]
|
|
|
|
def copy(self, exclude_parent=False, exclude_tasks=False):
|
|
def _dupe_task_list(task_list, new_block):
|
|
new_task_list = []
|
|
for task in task_list:
|
|
new_task = task.copy(exclude_parent=True)
|
|
if task._parent:
|
|
new_task._parent = task._parent.copy(exclude_tasks=True)
|
|
if task._parent == new_block:
|
|
# If task._parent is the same as new_block, just replace it
|
|
new_task._parent = new_block
|
|
else:
|
|
# task may not be a direct child of new_block, search for the correct place to insert new_block
|
|
cur_obj = new_task._parent
|
|
while cur_obj._parent and cur_obj._parent != new_block:
|
|
cur_obj = cur_obj._parent
|
|
|
|
cur_obj._parent = new_block
|
|
else:
|
|
new_task._parent = new_block
|
|
new_task_list.append(new_task)
|
|
return new_task_list
|
|
|
|
new_me = super(Block, self).copy()
|
|
new_me._play = self._play
|
|
new_me._use_handlers = self._use_handlers
|
|
new_me._eor = self._eor
|
|
|
|
if self._dep_chain is not None:
|
|
new_me._dep_chain = self._dep_chain[:]
|
|
|
|
new_me._parent = None
|
|
if self._parent and not exclude_parent:
|
|
new_me._parent = self._parent.copy(exclude_tasks=True)
|
|
|
|
if not exclude_tasks:
|
|
new_me.block = _dupe_task_list(self.block or [], new_me)
|
|
new_me.rescue = _dupe_task_list(self.rescue or [], new_me)
|
|
new_me.always = _dupe_task_list(self.always or [], new_me)
|
|
|
|
new_me._role = None
|
|
if self._role:
|
|
new_me._role = self._role
|
|
|
|
new_me.validate()
|
|
return new_me
|
|
|
|
def serialize(self):
|
|
'''
|
|
Override of the default serialize method, since when we're serializing
|
|
a task we don't want to include the attribute list of tasks.
|
|
'''
|
|
|
|
data = dict()
|
|
for attr in self._valid_attrs:
|
|
if attr not in ('block', 'rescue', 'always'):
|
|
data[attr] = getattr(self, attr)
|
|
|
|
data['dep_chain'] = self.get_dep_chain()
|
|
data['eor'] = self._eor
|
|
|
|
if self._role is not None:
|
|
data['role'] = self._role.serialize()
|
|
if self._parent is not None:
|
|
data['parent'] = self._parent.copy(exclude_tasks=True).serialize()
|
|
data['parent_type'] = self._parent.__class__.__name__
|
|
|
|
return data
|
|
|
|
def deserialize(self, data):
|
|
'''
|
|
Override of the default deserialize method, to match the above overridden
|
|
serialize method
|
|
'''
|
|
|
|
# import is here to avoid import loops
|
|
from ansible.playbook.task_include import TaskInclude
|
|
from ansible.playbook.handler_task_include import HandlerTaskInclude
|
|
|
|
# we don't want the full set of attributes (the task lists), as that
|
|
# would lead to a serialize/deserialize loop
|
|
for attr in self._valid_attrs:
|
|
if attr in data and attr not in ('block', 'rescue', 'always'):
|
|
setattr(self, attr, data.get(attr))
|
|
|
|
self._dep_chain = data.get('dep_chain', None)
|
|
self._eor = data.get('eor', False)
|
|
|
|
# if there was a serialized role, unpack it too
|
|
role_data = data.get('role')
|
|
if role_data:
|
|
r = Role()
|
|
r.deserialize(role_data)
|
|
self._role = r
|
|
|
|
parent_data = data.get('parent')
|
|
if parent_data:
|
|
parent_type = data.get('parent_type')
|
|
if parent_type == 'Block':
|
|
p = Block()
|
|
elif parent_type == 'TaskInclude':
|
|
p = TaskInclude()
|
|
elif parent_type == 'HandlerTaskInclude':
|
|
p = HandlerTaskInclude()
|
|
p.deserialize(parent_data)
|
|
self._parent = p
|
|
self._dep_chain = self._parent.get_dep_chain()
|
|
|
|
def set_loader(self, loader):
|
|
self._loader = loader
|
|
if self._parent:
|
|
self._parent.set_loader(loader)
|
|
elif self._role:
|
|
self._role.set_loader(loader)
|
|
|
|
dep_chain = self.get_dep_chain()
|
|
if dep_chain:
|
|
for dep in dep_chain:
|
|
dep.set_loader(loader)
|
|
|
|
def _get_parent_attribute(self, attr, extend=False, prepend=False):
|
|
'''
|
|
Generic logic to get the attribute or parent attribute for a block value.
|
|
'''
|
|
|
|
extend = self._valid_attrs[attr].extend
|
|
prepend = self._valid_attrs[attr].prepend
|
|
try:
|
|
value = self._attributes[attr]
|
|
# If parent is static, we can grab attrs from the parent
|
|
# otherwise, defer to the grandparent
|
|
if getattr(self._parent, 'statically_loaded', True):
|
|
_parent = self._parent
|
|
else:
|
|
_parent = self._parent._parent
|
|
|
|
if _parent and (value is Sentinel or extend):
|
|
try:
|
|
if getattr(_parent, 'statically_loaded', True):
|
|
if hasattr(_parent, '_get_parent_attribute'):
|
|
parent_value = _parent._get_parent_attribute(attr)
|
|
else:
|
|
parent_value = _parent._attributes.get(attr, Sentinel)
|
|
if extend:
|
|
value = self._extend_value(value, parent_value, prepend)
|
|
else:
|
|
value = parent_value
|
|
except AttributeError:
|
|
pass
|
|
if self._role and (value is Sentinel or extend):
|
|
try:
|
|
parent_value = self._role._attributes.get(attr, Sentinel)
|
|
if extend:
|
|
value = self._extend_value(value, parent_value, prepend)
|
|
else:
|
|
value = parent_value
|
|
|
|
dep_chain = self.get_dep_chain()
|
|
if dep_chain and (value is Sentinel or extend):
|
|
dep_chain.reverse()
|
|
for dep in dep_chain:
|
|
dep_value = dep._attributes.get(attr, Sentinel)
|
|
if extend:
|
|
value = self._extend_value(value, dep_value, prepend)
|
|
else:
|
|
value = dep_value
|
|
|
|
if value is not Sentinel and not extend:
|
|
break
|
|
except AttributeError:
|
|
pass
|
|
if self._play and (value is Sentinel or extend):
|
|
try:
|
|
play_value = self._play._attributes.get(attr, Sentinel)
|
|
if play_value is not Sentinel:
|
|
if extend:
|
|
value = self._extend_value(value, play_value, prepend)
|
|
else:
|
|
value = play_value
|
|
except AttributeError:
|
|
pass
|
|
except KeyError:
|
|
pass
|
|
|
|
return value
|
|
|
|
def filter_tagged_tasks(self, play_context, all_vars):
|
|
'''
|
|
Creates a new block, with task lists filtered based on the tags contained
|
|
within the play_context object.
|
|
'''
|
|
|
|
def evaluate_and_append_task(target):
|
|
tmp_list = []
|
|
for task in target:
|
|
if isinstance(task, Block):
|
|
tmp_list.append(evaluate_block(task))
|
|
elif (task.action == 'meta' or
|
|
(task.action == 'include' and task.evaluate_tags([], play_context.skip_tags, all_vars=all_vars)) or
|
|
task.evaluate_tags(play_context.only_tags, play_context.skip_tags, all_vars=all_vars)):
|
|
tmp_list.append(task)
|
|
return tmp_list
|
|
|
|
def evaluate_block(block):
|
|
new_block = self.copy(exclude_tasks=True)
|
|
new_block.block = evaluate_and_append_task(block.block)
|
|
new_block.rescue = evaluate_and_append_task(block.rescue)
|
|
new_block.always = evaluate_and_append_task(block.always)
|
|
return new_block
|
|
|
|
return evaluate_block(self)
|
|
|
|
def has_tasks(self):
|
|
return len(self.block) > 0 or len(self.rescue) > 0 or len(self.always) > 0
|
|
|
|
def get_include_params(self):
|
|
if self._parent:
|
|
return self._parent.get_include_params()
|
|
else:
|
|
return dict()
|
|
|
|
def all_parents_static(self):
|
|
'''
|
|
Determine if all of the parents of this block were statically loaded
|
|
or not. Since Task/TaskInclude objects may be in the chain, they simply
|
|
call their parents all_parents_static() method. Only Block objects in
|
|
the chain check the statically_loaded value of the parent.
|
|
'''
|
|
from ansible.playbook.task_include import TaskInclude
|
|
if self._parent:
|
|
if isinstance(self._parent, TaskInclude) and not self._parent.statically_loaded:
|
|
return False
|
|
return self._parent.all_parents_static()
|
|
|
|
return True
|
|
|
|
def get_first_parent_include(self):
|
|
from ansible.playbook.task_include import TaskInclude
|
|
if self._parent:
|
|
if isinstance(self._parent, TaskInclude):
|
|
return self._parent
|
|
return self._parent.get_first_parent_include()
|
|
return None
|