# (c) 2012-2014, Michael DeHaan # # 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 . # Make coding more python3-ish from __future__ import (absolute_import, division, print_function) __metaclass__ = type from ansible.errors import * from ansible.playbook.task import Task from ansible.utils.boolean import boolean __all__ = ['PlayIterator'] class HostState: def __init__(self, blocks): self._blocks = blocks[:] self.cur_block = 0 self.cur_regular_task = 0 self.cur_rescue_task = 0 self.cur_always_task = 0 self.cur_role = None self.run_state = PlayIterator.ITERATING_SETUP self.fail_state = PlayIterator.FAILED_NONE self.pending_setup = False def get_current_block(self): return self._blocks[self.cur_block] def copy(self): new_state = HostState(self._blocks) new_state.cur_block = self.cur_block new_state.cur_regular_task = self.cur_regular_task new_state.cur_rescue_task = self.cur_rescue_task new_state.cur_always_task = self.cur_always_task new_state.cur_role = self.cur_role new_state.run_state = self.run_state new_state.fail_state = self.fail_state new_state.pending_setup = self.pending_setup return new_state class PlayIterator: # the primary running states for the play iteration ITERATING_SETUP = 0 ITERATING_TASKS = 1 ITERATING_RESCUE = 2 ITERATING_ALWAYS = 3 ITERATING_COMPLETE = 4 # the failure states for the play iteration, which are powers # of 2 as they may be or'ed together in certain circumstances FAILED_NONE = 0 FAILED_SETUP = 1 FAILED_TASKS = 2 FAILED_RESCUE = 4 FAILED_ALWAYS = 8 def __init__(self, inventory, play): # FIXME: should we save the post_validated play from below here instead? self._play = play # post validate the play, as we need some fields to be finalized now # so that we can use them to setup the iterator properly all_vars = inventory._variable_manager.get_vars(loader=inventory._loader, play=play) new_play = play.copy() new_play.post_validate(all_vars, fail_on_undefined=False) self._blocks = new_play.compile() self._host_states = {} for host in inventory.get_hosts(new_play.hosts): self._host_states[host.name] = HostState(blocks=self._blocks) def get_host_state(self, host): try: return self._host_states[host.name].copy() except KeyError: raise AnsibleError("invalid host (%s) specified for playbook iteration" % host) def get_next_task_for_host(self, host, peek=False, lock_step=True): s = self.get_host_state(host) task = None if s.run_state == self.ITERATING_COMPLETE: return None else: while True: try: cur_block = s._blocks[s.cur_block] except IndexError: s.run_state = self.ITERATING_COMPLETE break if s.run_state == self.ITERATING_SETUP: s.run_state = self.ITERATING_TASKS if self._play._gather_facts == 'smart' and not host.gathered_facts or boolean(self._play._gather_facts): # mark the host as having gathered facts host.set_gathered_facts(True) task = Task() task.action = 'setup' task.set_loader(self._play._loader) elif s.run_state == self.ITERATING_TASKS: # clear the pending setup flag, since we're past that and it didn't fail if s.pending_setup: s.pending_setup = False if s.fail_state & self.FAILED_TASKS == self.FAILED_TASKS: s.run_state = self.ITERATING_RESCUE elif s.cur_regular_task >= len(cur_block.block): s.run_state = self.ITERATING_ALWAYS else: task = cur_block.block[s.cur_regular_task] s.cur_regular_task += 1 break elif s.run_state == self.ITERATING_RESCUE: if s.fail_state & self.FAILED_RESCUE == self.FAILED_RESCUE: s.run_state = self.ITERATING_ALWAYS elif s.cur_rescue_task >= len(cur_block.rescue): if len(cur_block.rescue) > 0: s.fail_state = self.FAILED_NONE s.run_state = self.ITERATING_ALWAYS else: task = cur_block.rescue[s.cur_rescue_task] s.cur_rescue_task += 1 break elif s.run_state == self.ITERATING_ALWAYS: if s.cur_always_task >= len(cur_block.always): if s.fail_state != self.FAILED_NONE: s.run_state = self.ITERATING_COMPLETE break else: s.cur_block += 1 s.cur_regular_task = 0 s.cur_rescue_task = 0 s.cur_always_task = 0 s.run_state = self.ITERATING_TASKS else: task= cur_block.always[s.cur_always_task] s.cur_always_task += 1 break if task and task._role: # if we had a current role, mark that role as completed if s.cur_role and task._role != s.cur_role and s.cur_role._had_task_run and not peek: s.cur_role._completed = True s.cur_role = task._role if not peek: self._host_states[host.name] = s return (s, task) def mark_host_failed(self, host): s = self.get_host_state(host) if s.pending_setup: s.fail_state |= self.FAILED_SETUP s.run_state = self.ITERATING_COMPLETE elif s.run_state == self.ITERATING_TASKS: s.fail_state |= self.FAILED_TASKS s.run_state = self.ITERATING_RESCUE elif s.run_state == self.ITERATING_RESCUE: s.fail_state |= self.FAILED_RESCUE s.run_state = self.ITERATING_ALWAYS elif s.run_state == self.ITERATING_ALWAYS: s.fail_state |= self.FAILED_ALWAYS s.run_state = self.ITERATING_COMPLETE self._host_states[host.name] = s def get_failed_hosts(self): return dict((host, True) for (host, state) in self._host_states.iteritems() if state.run_state == self.ITERATING_COMPLETE and state.failed_state != self.FAILED_NONE) def get_original_task(self, host, task): ''' Finds the task in the task list which matches the UUID of the given task. The executor engine serializes/deserializes objects as they are passed through the different processes, and not all data structures are preserved. This method allows us to find the original task passed into the executor engine. ''' for block in self._blocks: if block.block: for t in block.block: if t._uuid == task._uuid: return t if block.rescue: for t in block.rescue: if t._uuid == task._uuid: return t if block.always: for t in block.always: if t._uuid == task._uuid: return t return None def add_tasks(self, task_list): if self._run_state == self.ITERATING_TASKS: before = self._task_list[:self._cur_task_pos + self._tasks_added] after = self._task_list[self._cur_task_pos + self._tasks_added:] self._task_list = before + task_list + after elif self._run_state == self.ITERATING_RESCUE: before = self._cur_block.rescue[:self._cur_rescue_pos + self._tasks_added] after = self._cur_block.rescue[self._cur_rescue_pos + self._tasks_added:] self._cur_block.rescue = before + task_list + after elif self._run_state == self.ITERATING_ALWAYS: before = self._cur_block.always[:self._cur_always_pos + self._tasks_added] after = self._cur_block.always[self._cur_always_pos + self._tasks_added:] self._cur_block.always = before + task_list + after # set this internal flag now so we know if self._tasks_added += len(task_list)