Coverage for lib/ansible/playbook/play.py: 58%

105 ↛ 110line 105 didn't jump to line 110, because the condition on line 105 was never false if ('name' not in data or data['name'] is None) and 'hosts' in data:

106 ↛ 107line 106 didn't jump to line 107, because the condition on line 106 was never true if isinstance(data['hosts'], list):

data['name'] = ','.join(data['hosts'])

else:

data['name'] = data['hosts']

p = Play()

return p.load_data(data, variable_manager=variable_manager, loader=loader)

def preprocess_data(self, ds):

'''

Adjusts play datastructure to cleanup old/legacy items

'''

118 ↛ 119line 118 didn't jump to line 119, because the condition on line 118 was never true if not isinstance(ds, dict):

raise AnsibleAssertionError('while preprocessing data (%s), ds should be a dict but was a %s' % (ds, type(ds)))

# The use of 'user' in the Play datastructure was deprecated to

# line up with the same change for Tasks, due to the fact that

# 'user' conflicted with the user module.

124 ↛ 127line 124 didn't jump to line 127, because the condition on line 124 was never true if 'user' in ds:

# this should never happen, but error out with a helpful message

# to the user if it does...

if 'remote_user' in ds:

raise AnsibleParserError("both 'user' and 'remote_user' are set for %s. "

"The use of 'user' is deprecated, and should be removed" % self.get_name(), obj=ds)

ds['remote_user'] = ds['user']

del ds['user']

return super(Play, self).preprocess_data(ds)

def _load_tasks(self, attr, ds):

'''

Loads a list of blocks from a list which may be mixed tasks/blocks.

Bare tasks outside of a block are given an implicit block.

'''

try:

return load_list_of_blocks(ds=ds, play=self, variable_manager=self._variable_manager, loader=self._loader)

except AssertionError as e:

raise AnsibleParserError("A malformed block was encountered while loading tasks", obj=self._ds, orig_exc=e)

def _load_pre_tasks(self, attr, ds):

'''

Loads a list of blocks from a list which may be mixed tasks/blocks.

Bare tasks outside of a block are given an implicit block.

'''

try:

return load_list_of_blocks(ds=ds, play=self, variable_manager=self._variable_manager, loader=self._loader)

except AssertionError as e:

raise AnsibleParserError("A malformed block was encountered while loading pre_tasks", obj=self._ds, orig_exc=e)

def _load_post_tasks(self, attr, ds):

'''

Loads a list of blocks from a list which may be mixed tasks/blocks.

Bare tasks outside of a block are given an implicit block.

'''

try:

return load_list_of_blocks(ds=ds, play=self, variable_manager=self._variable_manager, loader=self._loader)

except AssertionError as e:

raise AnsibleParserError("A malformed block was encountered while loading post_tasks", obj=self._ds, orig_exc=e)

def _load_handlers(self, attr, ds):

'''

Loads a list of blocks from a list which may be mixed handlers/blocks.

Bare handlers outside of a block are given an implicit block.

'''

try:

return load_list_of_blocks(ds=ds, play=self, use_handlers=True, variable_manager=self._variable_manager, loader=self._loader)

except AssertionError as e:

raise AnsibleParserError("A malformed block was encountered while loading handlers", obj=self._ds, orig_exc=e)

def _load_roles(self, attr, ds):

'''

Loads and returns a list of RoleInclude objects from the datastructure

list of role definitions and creates the Role from those objects

'''

182 ↛ 183line 182 didn't jump to line 183, because the condition on line 182 was never true if ds is None:

ds = []

try:

role_includes = load_list_of_roles(ds, play=self, variable_manager=self._variable_manager, loader=self._loader)

except AssertionError as e:

raise AnsibleParserError("A malformed role declaration was encountered.", obj=self._ds, orig_exc=e)

roles = []

for ri in role_includes:

roles.append(Role.load(ri, play=self))

return roles

def _load_vars_prompt(self, attr, ds):

new_ds = preprocess_vars(ds)

vars_prompts = []

if new_ds is not None:

for prompt_data in new_ds:

if 'name' not in prompt_data:

display.deprecated("Using the 'short form' for vars_prompt has been deprecated", version="2.7")

for vname, prompt in prompt_data.items():

vars_prompts.append(dict(

name=vname,

prompt=prompt,

default=None,

private=None,

confirm=None,

encrypt=None,

salt_size=None,

salt=None,

))

else:

vars_prompts.append(prompt_data)

return vars_prompts

def _compile_roles(self):

'''

Handles the role compilation step, returning a flat list of tasks

with the lowest level dependencies first. For example, if a role R

has a dependency D1, which also has a dependency D2, the tasks from

D2 are merged first, followed by D1, and lastly by the tasks from

the parent role R last. This is done for all roles in the Play.

'''

block_list = []

228 ↛ 232line 228 didn't jump to line 232, because the condition on line 228 was never false if len(self.roles) > 0:

for r in self.roles:

block_list.extend(r.compile(play=self))

return block_list

def compile_roles_handlers(self):

'''

Handles the role handler compilation step, returning a flat list of Handlers

This is done for all roles in the Play.

'''

block_list = []

242 ↛ 246line 242 didn't jump to line 246, because the condition on line 242 was never false if len(self.roles) > 0:

for r in self.roles:

block_list.extend(r.get_handler_blocks(play=self))

return block_list

def compile(self):

'''

Compiles and returns the task list for this play, compiled from the

roles (which are themselves compiled recursively) and/or the list of

tasks specified in the play.

'''

# create a block containing a single flush handlers meta

# task, so we can be sure to run handlers at certain points

# of the playbook execution

flush_block = Block.load(

data={'meta': 'flush_handlers'},

play=self,

variable_manager=self._variable_manager,

loader=self._loader

)

block_list = []

block_list.extend(self.pre_tasks)

block_list.append(flush_block)

block_list.extend(self._compile_roles())

block_list.extend(self.tasks)

block_list.append(flush_block)

block_list.extend(self.post_tasks)

block_list.append(flush_block)

return block_list

def get_vars(self):

return self.vars.copy()

def get_vars_files(self):

281 ↛ 282line 281 didn't jump to line 282, because the condition on line 281 was never true if self.vars_files is None:

return []

return self.vars_files

def get_handlers(self):

return self.handlers[:]

def get_roles(self):

return self.roles[:]

def get_tasks(self):

tasklist = []

for task in self.pre_tasks + self.tasks + self.post_tasks:

if isinstance(task, Block):

tasklist.append(task.block + task.rescue + task.always)

else:

tasklist.append(task)

return tasklist

def serialize(self):

data = super(Play, self).serialize()

roles = []

for role in self.get_roles():

roles.append(role.serialize())

data['roles'] = roles

data['included_path'] = self._included_path

return data

def deserialize(self, data):

super(Play, self).deserialize(data)

self._included_path = data.get('included_path', None)

if 'roles' in data:

role_data = data.get('roles', [])

roles = []

for role in role_data:

r = Role()

r.deserialize(role)

roles.append(r)

setattr(self, 'roles', roles)

del data['roles']

def copy(self):

new_me = super(Play, self).copy()

new_me.ROLE_CACHE = self.ROLE_CACHE.copy()

new_me._included_conditional = self._included_conditional

new_me._included_path = self._included_path

return new_me

Coverage for lib/ansible/playbook/play.py : 58%

173 statements 111 run 62 missing 0 excluded 8 partial