Coverage for lib/ansible/executor/playbook

57 ↛ 58line 57 didn't jump to line 58, because the condition on line 57 was never true if options.listhosts or options.listtasks or options.listtags or options.syntax:

self._tqm = None

else:

self._tqm = TaskQueueManager(inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=self.passwords)

# Note: We run this here to cache whether the default ansible ssh

# executable supports control persist. Sometime in the future we may

# need to enhance this to check that ansible_ssh_executable specified

# in inventory is also cached. We can't do this caching at the point

# where it is used (in task_executor) because that is post-fork and

# therefore would be discarded after every task.

check_for_controlpersist(C.ANSIBLE_SSH_EXECUTABLE)

def run(self):

'''

Run the given playbook, based on the settings in the play which

may limit the runs to serialized groups, etc.

'''

result = 0

entrylist = []

entry = {}

try:

for playbook_path in self._playbooks:

pb = Playbook.load(playbook_path, variable_manager=self._variable_manager, loader=self._loader)

# FIXME: move out of inventory self._inventory.set_playbook_basedir(os.path.realpath(os.path.dirname(playbook_path)))

84 ↛ 85line 84 didn't jump to line 85, because the condition on line 84 was never true if self._tqm is None: # we are doing a listing

entry = {'playbook': playbook_path}

entry['plays'] = []

else:

# make sure the tqm has callbacks loaded

self._tqm.load_callbacks()

self._tqm.send_callback('v2_playbook_on_start', pb)

i = 1

plays = pb.get_plays()

display.vv(u'%d plays in %s' % (len(plays), to_text(playbook_path)))

for play in plays:

97 ↛ 98line 97 didn't jump to line 98, because the condition on line 97 was never true if play._included_path is not None:

self._loader.set_basedir(play._included_path)

else:

self._loader.set_basedir(pb._basedir)

# clear any filters which may have been applied to the inventory

self._inventory.remove_restriction()

# Create a temporary copy of the play here, so we can run post_validate

# on it without the templating changes affecting the original object.

# Doing this before vars_prompt to allow for using variables in prompt.

all_vars = self._variable_manager.get_vars(play=play)

templar = Templar(loader=self._loader, variables=all_vars)

new_play = play.copy()

new_play.post_validate(templar)

113 ↛ 114line 113 didn't jump to line 114, because the condition on line 113 was never true if play.vars_prompt:

for var in new_play.vars_prompt:

vname = var['name']

prompt = var.get("prompt", vname)

default = var.get("default", None)

private = boolean(var.get("private", True))

confirm = boolean(var.get("confirm", False))

encrypt = var.get("encrypt", None)

salt_size = var.get("salt_size", None)

salt = var.get("salt", None)

if vname not in self._variable_manager.extra_vars:

if self._tqm:

self._tqm.send_callback('v2_playbook_on_vars_prompt', vname, private, prompt, encrypt, confirm, salt_size, salt, default)

play.vars[vname] = display.do_var_prompt(vname, private, prompt, encrypt, confirm, salt_size, salt, default)

else: # we are either in --list-<option> or syntax check

play.vars[vname] = default

# Post validating again in case variables were entered in the prompt.

all_vars = self._variable_manager.get_vars(play=play)

templar = Templar(loader=self._loader, variables=all_vars)

new_play.post_validate(templar)

136 ↛ 137line 136 didn't jump to line 137, because the condition on line 136 was never true if self._options.syntax:

continue

139 ↛ 141line 139 didn't jump to line 141, because the condition on line 139 was never true if self._tqm is None:

# we are just doing a listing

entry['plays'].append(new_play)

else:

self._tqm._unreachable_hosts.update(self._unreachable_hosts)

previously_failed = len(self._tqm._failed_hosts)

previously_unreachable = len(self._tqm._unreachable_hosts)

break_play = False

# we are actually running plays

batches = self._get_serialized_batches(new_play)

152 ↛ 153line 152 didn't jump to line 153, because the condition on line 152 was never true if len(batches) == 0:

self._tqm.send_callback('v2_playbook_on_play_start', new_play)

self._tqm.send_callback('v2_playbook_on_no_hosts_matched')

for batch in batches:

# restrict the inventory to the hosts in the serialized batch

self._inventory.restrict_to_hosts(batch)

# and run it...

result = self._tqm.run(play=play)

# break the play if the result equals the special return code

162 ↛ 163line 162 didn't jump to line 163, because the condition on line 162 was never true if result & self._tqm.RUN_FAILED_BREAK_PLAY != 0:

result = self._tqm.RUN_FAILED_HOSTS

break_play = True

# check the number of failures here, to see if they're above the maximum

# failure percentage allowed, or if any errors are fatal. If either of those

# conditions are met, we break out, otherwise we only break out if the entire

# batch failed

failed_hosts_count = len(self._tqm._failed_hosts) + len(self._tqm._unreachable_hosts) - \

(previously_failed + previously_unreachable)

173 ↛ 174line 173 didn't jump to line 174, because the condition on line 173 was never true if len(batch) == failed_hosts_count:

break_play = True

break

# update the previous counts so they don't accumulate incorrectly

# over multiple serial batches

previously_failed += len(self._tqm._failed_hosts) - previously_failed

previously_unreachable += len(self._tqm._unreachable_hosts) - previously_unreachable

# save the unreachable hosts from this batch

self._unreachable_hosts.update(self._tqm._unreachable_hosts)

185 ↛ 186line 185 didn't jump to line 186, because the condition on line 185 was never true if break_play:

break

i = i + 1 # per play

190 ↛ 191line 190 didn't jump to line 191, because the condition on line 190 was never true if entry:

entrylist.append(entry) # per playbook

# send the stats callback for this playbook

194 ↛ 215line 194 didn't jump to line 215, because the condition on line 194 was never false if self._tqm is not None:

195 ↛ 212line 195 didn't jump to line 212, because the condition on line 195 was never false if C.RETRY_FILES_ENABLED:

retries = set(self._tqm._failed_hosts.keys())

retries.update(self._tqm._unreachable_hosts.keys())

retries = sorted(retries)

199 ↛ 200line 199 didn't jump to line 200, because the condition on line 199 was never true if len(retries) > 0:

if C.RETRY_FILES_SAVE_PATH:

basedir = C.RETRY_FILES_SAVE_PATH

elif playbook_path:

basedir = os.path.dirname(os.path.abspath(playbook_path))

else:

basedir = '~/'

(retry_name, _) = os.path.splitext(os.path.basename(playbook_path))

filename = os.path.join(basedir, "%s.retry" % retry_name)

if self._generate_retry_inventory(filename, retries):

display.display("\tto retry, use: --limit @%s\n" % filename)

self._tqm.send_callback('v2_playbook_on_stats', self._tqm._stats)

# if the last result wasn't zero, break out of the playbook file name loop

215 ↛ 216line 215 didn't jump to line 216, because the condition on line 215 was never true if result != 0:

break

218 ↛ 219line 218 didn't jump to line 219, because the condition on line 218 was never true if entrylist:

return entrylist

finally:

222 ↛ 224line 222 didn't jump to line 224, because the condition on line 222 was never false if self._tqm is not None:

self._tqm.cleanup()

224 ↛ exit, 224 ↛ 2272 missed branches: 1) line 224 didn't return from function 'run', because the return on line 219 wasn't executed, 2) line 224 didn't jump to line 227, because the condition on line 224 was never false if self._loader:

225 ↛ exitline 225 didn't return from function 'run', because the return on line 219 wasn't executed self._loader.cleanup_all_tmp_files()

227 ↛ 228line 227 didn't jump to line 228, because the condition on line 227 was never true if self._options.syntax:

display.display("No issues encountered")

return result

def _get_serialized_batches(self, play):

'''

Returns a list of hosts, subdivided into batches based on

the serial size specified in the play.

'''

# make sure we have a unique list of hosts

all_hosts = self._inventory.get_hosts(play.hosts)

all_hosts_len = len(all_hosts)

# the serial value can be listed as a scalar or a list of

# scalars, so we make sure it's a list here

serial_batch_list = play.serial

246 ↛ 249line 246 didn't jump to line 249, because the condition on line 246 was never false if len(serial_batch_list) == 0:

serial_batch_list = [-1]

cur_item = 0

serialized_batches = []

252 ↛ 277line 252 didn't jump to line 277, because the condition on line 252 was never false while len(all_hosts) > 0:

# get the serial value from current item in the list

serial = pct_to_int(serial_batch_list[cur_item], all_hosts_len)

# if the serial count was not specified or is invalid, default to

# a list of all hosts, otherwise grab a chunk of the hosts equal

# to the current serial item size

259 ↛ 263line 259 didn't jump to line 263, because the condition on line 259 was never false if serial <= 0:

serialized_batches.append(all_hosts)

break

else:

play_hosts = []

for x in range(serial):

if len(all_hosts) > 0:

play_hosts.append(all_hosts.pop(0))

serialized_batches.append(play_hosts)

# increment the current batch list item number, and if we've hit

# the end keep using the last element until we've consumed all of

# the hosts in the inventory

cur_item += 1

if cur_item > len(serial_batch_list) - 1:

cur_item = len(serial_batch_list) - 1

return serialized_batches

def _generate_retry_inventory(self, retry_path, replay_hosts):

'''

Called when a playbook run fails. It generates an inventory which allows

re-running on ONLY the failed hosts. This may duplicate some variable

information in group_vars/host_vars but that is ok, and expected.

'''

try:

makedirs_safe(os.path.dirname(retry_path))

with open(retry_path, 'w') as fd:

for x in replay_hosts:

fd.write("%s\n" % x)

except Exception as e:

display.warning("Could not create retry file '%s'.\n\t%s" % (retry_path, to_native(e)))

return False

return True

Coverage for lib/ansible/executor/playbook_executor.py : 54%

162 statements 98 run 64 missing 0 excluded 24 partial