def test_task_executor_run(self):
fake_loader = DictDataLoader({})
mock_host = MagicMock()
mock_task = MagicMock()
mock_task._role._role_path = '/path/to/role/foo'
mock_play_context = MagicMock()
mock_shared_loader = MagicMock()
mock_queue = MagicMock()
new_stdin = None
job_vars = dict()
te = TaskExecutor(
host=mock_host,
task=mock_task,
job_vars=job_vars,
play_context=mock_play_context,
new_stdin=new_stdin,
loader=fake_loader,
shared_loader_obj=mock_shared_loader,
rslt_q=mock_queue,
)
te._get_loop_items = MagicMock(return_value=None)
te._execute = MagicMock(return_value=dict())
res = te.run()
te._get_loop_items = MagicMock(return_value=[])
res = te.run()
te._get_loop_items = MagicMock(return_value=['a', 'b', 'c'])
te._run_loop = MagicMock(return_value=[
dict(item='a', changed=True),
dict(item='b', failed=True),
dict(item='c')
])
res = te.run()
te._get_loop_items = MagicMock(side_effect=AnsibleError(""))
res = te.run()
self.assertIn("failed", res)
def test_task_executor_run(self):
fake_loader = DictDataLoader({})
mock_host = MagicMock()
mock_task = MagicMock()
mock_task._role._role_path = '/path/to/role/foo'
mock_play_context = MagicMock()
mock_shared_loader = MagicMock()
mock_queue = MagicMock()
new_stdin = None
job_vars = dict()
te = TaskExecutor(
host = mock_host,
task = mock_task,
job_vars = job_vars,
play_context = mock_play_context,
new_stdin = new_stdin,
loader = fake_loader,
shared_loader_obj = mock_shared_loader,
rslt_q = mock_queue,
)
te._get_loop_items = MagicMock(return_value=None)
te._execute = MagicMock(return_value=dict())
res = te.run()
te._get_loop_items = MagicMock(return_value=[])
res = te.run()
te._get_loop_items = MagicMock(return_value=['a','b','c'])
te._run_loop = MagicMock(return_value=[dict(item='a', changed=True), dict(item='b', failed=True), dict(item='c')])
res = te.run()
te._get_loop_items = MagicMock(side_effect=AnsibleError(""))
res = te.run()
self.assertIn("failed", res)
def test_task_executor_run(self):
fake_loader = DictDataLoader({})
mock_host = MagicMock()
mock_task = MagicMock()
mock_task._role._role_path = "/path/to/role/foo"
mock_conn_info = MagicMock()
mock_shared_loader = MagicMock()
new_stdin = None
job_vars = dict()
te = TaskExecutor(
host=mock_host,
task=mock_task,
job_vars=job_vars,
connection_info=mock_conn_info,
new_stdin=new_stdin,
loader=fake_loader,
shared_loader_obj=mock_shared_loader,
)
te._get_loop_items = MagicMock(return_value=None)
te._execute = MagicMock(return_value=dict())
res = te.run()
te._get_loop_items = MagicMock(return_value=[])
res = te.run()
te._get_loop_items = MagicMock(return_value=["a", "b", "c"])
te._run_loop = MagicMock(
return_value=[dict(item="a", changed=True), dict(item="b", failed=True), dict(item="c")]
)
res = te.run()
te._get_loop_items = MagicMock(side_effect=AnsibleError(""))
res = te.run()
self.assertIn("failed", res)
def test_task_executor_run_clean_res(self):
te = TaskExecutor(None, MagicMock(), None, None, None, None, None,
None)
te._get_loop_items = MagicMock(return_value=[1])
te._run_loop = MagicMock(
return_value=[{
'unsafe_bytes': AnsibleUnsafeBytes(b'{{ $bar }}'),
'unsafe_text': AnsibleUnsafeText(u'{{ $bar }}'),
'bytes': b'bytes',
'text': u'text',
'int': 1,
}])
res = te.run()
data = res['results'][0]
self.assertIsInstance(data['unsafe_bytes'], AnsibleUnsafeText)
self.assertIsInstance(data['unsafe_text'], AnsibleUnsafeText)
self.assertIsInstance(data['bytes'], text_type)
self.assertIsInstance(data['text'], text_type)
self.assertIsInstance(data['int'], int)
def __execute_module(self,
module_name=None,
module_args=None,
persist_files=False,
delete_remote_tmp=None,
wrap_async=False,
run_on_ca_host=False,
ignore_changed=False,
ignore_failed=False):
if run_on_ca_host:
host = InventoryManager(DataLoader(),
context.CLIARGS['inventory']).get_host(
self._var("ca_host"))
task = self._task.copy()
task_data = self._var("ca_host_options")
task_data.update({
'name':
"mgssl ca_host task: {0}".format(module_name),
'action':
module_name,
'args':
module_args,
'delegate_to':
self._var("ca_host")
})
task.load_data(task_data)
task_vars = self._task_vars.copy()
task_vars.update(self._task.get_variable_manager().get_vars(
host=host, task=task))
executor_result = TaskExecutor(host, task, task_vars,
self._play_context, None,
self._loader,
self._shared_loader_obj, None)
# Dirty fix for mitogen compatibility
# Mitogen somehow puts a task global connection binding object in each connection that gets created
# during the lifetime of a task. That usually happens on the beginning of a task, but here, we create
# a new task executor within a task and that also creates a new connection for local running tasks.
# After execution the connections get closed, but the close function also closes and removes the parent
# tasks binding object. Now all future connections will fail.
#
# Solution: Overwrite the close method and only call the necessary close methods except the one that closes
# the binding object
if self._is_mitogen:
get_connection_method = executor_result._get_connection
def get_connection(cvars, templar):
c = get_connection_method(cvars, templar)
c.close = lambda: (c._put_connection(), None)
return c
executor_result._get_connection = get_connection
ret = executor_result.run()
# Reset the close method
if self._is_mitogen:
executor_result._get_connection = get_connection_method
else:
if self._shared_loader_obj.action_loader.has_plugin(
module_name, None):
task = self._task.copy()
task.load_data({
'action': module_name,
'args': module_args,
})
handler = self._shared_loader_obj.action_loader.get(
module_name,
task=task,
connection=self._connection,
play_context=self._play_context.
set_task_and_variable_override(task, {}, self._templar),
loader=self._loader,
templar=self._templar,
shared_loader_obj=self._shared_loader_obj,
collection_list=None)
ret = handler.run(None, self._task_vars)
else:
ret = self._execute_module(module_name, module_args, None,
self._task_vars, persist_files,
delete_remote_tmp, wrap_async)
self._check_result(module_name, run_on_ca_host, ret, ignore_changed,
ignore_failed)
return ret
