Use a custom runner if ansible 2 is used

Author: vrutkovs

ansible_runner.py

@@ -0,0 +1,87 @@
+from collections import namedtuple
+from ansible.parsing.dataloader import DataLoader
+from ansible.vars import VariableManager
+from ansible.playbook.play import Play
+from ansible.inventory import Inventory
+from ansible.executor.task_queue_manager import TaskQueueManager
+from ansible.plugins.callback import CallbackBase
+import logging
+
+
+class ResultCallback(CallbackBase):
+    result = {}
+
+    def v2_runner_on_ok(self, result, **kwargs):
+        self.result = {'contacted': {result._host: result._result}}
+
+    def v2_runner_on_failed(self, result, **kwargs):
+        self.result = {'contacted': {result._host: result._result}}
+
+    def v2_runner_on_unreachable(self, result, **kwargs):
+        self.result = {'dark': result._host, 'result': result._result}
+
+
+class Runner(object):
+    def __init__(self, inventory_file, module_name, module_args):
+        loader = DataLoader()
+        variable_manager = VariableManager()
+
+        inventory = Inventory(loader=loader,
+                              variable_manager=variable_manager,
+                              host_list=inventory_file)
+        variable_manager.set_inventory(inventory)
+
+        hosts = [x.name for x in inventory.get_hosts()]
+
+        play_source = {
+            "name": "Ansible Play",
+            "hosts": hosts,
+            "gather_facts": "no",
+            "tasks": [{
+                "action": {
+                    "module": module_name,
+                    "args": module_args
+                }
+            }]
+        }
+        logging.info(play_source)
+        play = Play().load(play_source,
+                           variable_manager=variable_manager,
+                           loader=loader)
+
+        Options = namedtuple('Options', ['connection', 'module_path', 'forks',
+                                         'become', 'become_method',
+                                         'become_user', 'check'])
+        options = Options(connection='local',
+                          module_path='',
+                          forks=100,
+                          become=None,
+                          become_method=None,
+                          become_user=None,
+                          check=False)
+
+        self.inventory = inventory
+        self.variable_manager = variable_manager
+        self.loader = loader
+        self.play = play
+        self.options = options
+        self.passwords = {"vault_pass": 'secret'}
+
+    def run(self):
+        result = {}
+        results_callback = ResultCallback()
+        try:
+            tqm = TaskQueueManager(
+                inventory=self.inventory,
+                variable_manager=self.variable_manager,
+                loader=self.loader,
+                options=self.options,
+                passwords=self.passwords,
+                stdout_callback=results_callback
+            )
+            tqm.run(self.play)
+        finally:
+            result = results_callback.result
+            if tqm is not None:
+                tqm.cleanup()
+        return result

common_environment.py

@@ -1,13 +1,14 @@
 # Some useful functions for your environment.py
 import tempfile
 import shutil
-import ansible.runner
 import logging
 import re
 import os
 import glob
 import stat
 
+from ansible_runner import Runner
+
 
 def sample_before_all(context):
     docker_setup(context)
@@ -31,22 +32,18 @@ def docker_setup(context):
 
     # Read ansible inventory from config
     ansible_cfg = None
-    inventory = None
 
     logging.info("Reading ansible config")
     try:
         ansible_cfg = context.config.userdata['ANSIBLE']
     except KeyError:
         raise Exception("-D ANSIBLE missing")
 
-    inventory = ansible.inventory.Inventory(ansible_cfg)
-    logging.info("Ansible inventory is set\n")
-
     def open_file(path):
         context.temp_dir = tempfile.mkdtemp()
-        ret = ansible.runner.Runner(
+        ret = Runner(
             module_name='fetch',
-            inventory=inventory,
+            inventory_file=ansible_cfg,
             module_args='src={0} dest={1}'.format(
                 path, context.temp_dir)).run()
         for _, value in ret['contacted'].iteritems():
@@ -61,19 +58,21 @@ def open_file(path):
     def run(command):
         if '{{' in command:
             command = command.replace("{{", "{{ '{{").replace("}}", "}}' }}")
+        if '=' in command:
+            command = command.replace('=', '\=')
         logging.info("Running '%s'", command)
-        context.result = ansible.runner.Runner(
+        context.result = Runner(
             module_name="shell",
-            inventory=inventory,
+            inventory_file=ansible_cfg,
             module_args="{0} chdir={1}".format(command, context.remote_dir)
         ).run()
+
         # dark means not responding
-        if context.result['dark']:
+        if 'dark' in context.result:
             print(context.result)
-        if not context.result['contacted']:
-            print("no contacted hosts")
         for host, values in context.result['contacted'].iteritems():
-            logging.info("On {0} returned {1}".format(host, values['rc']))
+            retvalue = values.get('rc')
+            logging.info("On {0} returned {1}".format(host, retvalue))
 
             if 'cmd' in values:
                 logging.info("cmd: {0}".format(values['cmd']))
@@ -88,7 +87,7 @@ def run(command):
                 logging.info('stdout:%s', values['stdout'])
                 result = values['stdout']
 
-            if values['rc'] != 0:
+            if 'failed' in values:
                 assert False
             return result
     context.run = run
@@ -99,25 +98,25 @@ def copy_dockerfile():
             dockerfile = context.config.userdata['DOCKERFILE']
             dockerfile_dir = os.path.dirname(dockerfile)
             # create remote directory
-            ansible.runner.Runner(
+            Runner(
+                inventory_file=ansible_cfg,
                 module_name='file',
-                inventory=inventory,
                 module_args='dest={0} state=directory'.format(context.remote_dir)
                 ).run()
             # copy dockerfile
-            ansible.runner.Runner(
+            Runner(
+                inventory_file=ansible_cfg,
                 module_name='copy',
-                inventory=inventory,
                 module_args='src={0} dest={1}'.format(dockerfile, context.remote_dir)
                 ).run()
             # copy files from dockerfile
             f_in = open(dockerfile)
             for path in re.findall('(?:ADD|COPY) ([^ ]+) ', f_in.read()):
                 for glob_path in glob.glob(os.path.join(dockerfile_dir, path)):
                     # TODO Is there a nicer way to keep permissions?
-                    ansible.runner.Runner(
+                    Runner(
+                        inventory_file=ansible_cfg,
                         module_name='copy',
-                        inventory=inventory,
                         module_args='src={0} dest={1} directory_mode mode={2}'.format(
                             glob_path, context.remote_dir,
                             oct(stat.S_IMODE(os.stat(glob_path).st_mode)))