def ansible_adhoc(ips): logger.info("ansible需要采集%d个IP" % (len(ips))) inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=ips) # 根据 inventory 加载对应变量 variable_manager.set_inventory(inventory) # 增加外部变量 variable_manager.extra_vars = {"ansible_ssh_user": ansible_username, "ansible_ssh_pass": ansible_password} play_source = {"name": "Ansible Ad-Hoc", "hosts": ips, "gather_facts": "no", "tasks": [{"action": {"module": "setup", "args": ""}}]} play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, stdout_callback=resultcallback, run_tree=False, ) tqm.run(play) return ansible_facts_info finally: if tqm is not None: tqm.cleanup()
def run(self, host_list, module_name, module_args,): """ run module from andible ad-hoc. module_name: ansible module_name module_args: ansible module args """ # create play with tasks play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))] ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # actually run it tqm = None self.callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) tqm._stdout_callback = self.callback result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def run(self, play_data): """ paly_data = dict( name="Ansible Ad-Hoc", hosts=pattern, gather_facts=True, tasks=[dict(action=dict(module='service', args={'name': 'vsftpd', 'state': 'restarted'}), async=async, poll=poll)] ) """ self._prepare_run() play = Play().load(play_data, variable_manager=self.variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.cb, run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS, run_tree=False, ) result = tqm.run(play) return result finally: if tqm: tqm.cleanup()
def run(self): # create play with tasks play_source = dict( name = "Ansible Play", hosts = self.host_list, #hosts = 'localhost', gather_facts = 'no', tasks = [ dict(action=dict(module='shell', args='ls')), #dict(action=dict(module='shell', args='ls'), register='shell_out'), #dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) ] ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # actually run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.results_callback, # Use our custom callback instead of the ``default`` callback plugin ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def my_runner(host_list,module_name,module_args): variable_manager.extra_vars={} # 增加外部变量 # 构建pb, 这里很有意思, 新版本运行ad-hoc或playbook都需要构建这样的pb, 只是最后调用play的类不一样 # :param name: 任务名,类似playbook中tasks中的name # :param hosts: playbook中的hosts # :param tasks: playbook中的tasks, 其实这就是playbook的语法, 因为tasks的值是个列表,因此可以写入多个task play_source = {"name":"Ansible Ad-Hoc","hosts":host_list,"gather_facts":"no","tasks":[{"action":{"module":module_name,"args":module_args}}]} play = Play().load(play_source,variable_manager=variable_manager,loader=loader) tqm = None # results_callback = call_json.CallbackModule() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, stdout_callback='minimal', # stdout_callback=results_callback, # Use our custom callback instead of the ``default`` callback plugin ) savedStdout = sys.stdout with open(File_PATH,'w+') as file: sys.stdout = file #标准输出重定向至文件 result = tqm.run(play) sys.stdout = savedStdout return result finally: if tqm is not None: tqm.cleanup()
def run_model(self, host_list, module_name, module_args): """ run module from andible ad-hoc. module_name: ansible module_name module_args: ansible module args """ play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))] ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None if self.redisKey or self.logId:self.callback = ModelResultsCollectorToSave(self.redisKey,self.logId) else:self.callback = ModelResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False #关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) except Exception as err: if self.redisKey:DsRedis.OpsAnsibleModel.lpush(self.redisKey,data=err) if self.logId:AnsibleSaveResult.Model.insert(self.logId, err) finally: if tqm is not None: tqm.cleanup()
def run_module(self, hosts, module_name, module_args): # create play with tasks play_source = dict( name="Ansible Play", hosts=hosts, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))]) play = Play().load( play_source, variable_manager=self.variable_manager, loader=self.loader) self.results_callback = ModuleResultCallback() # actually run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self. results_callback, # Use our custom callback instead of the ``default`` callback plugin ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def run_model(self, host_list, module_name, module_args): """ run module from andible ad-hoc. module_name: ansible module_name module_args: ansible module args """ play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))] ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None if self.redisKey:self.callback = ModelResultsCollectorToSave(self.redisKey,self.logId) else:self.callback = ModelResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) tqm._stdout_callback = self.callback tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def run_adhoc(): variable_manager.extra_vars = { "ansible_ssh_user": "******", "ansible_ssh_pass": "******" } # 增加外部变量 # 构建pb, 这里很有意思, 新版本运行ad-hoc或playbook都需要构建这样的pb, 只是最后调用play的类不一样 # :param name: 任务名,类似playbook中tasks中的name # :param hosts: playbook中的hosts # :param tasks: playbook中的tasks, 其实这就是playbook的语法, 因为tasks的值是个列表,因此可以写入多个task play_source = { "name": "Ansible Ad-Hoc", "hosts": "localhost", "gather_facts": "no", "tasks": [ {"action": {"module": "shell", "args": "w"}} ] } play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, stdout_callback='minimal', run_tree=False, ) result = tqm.run(play) print result finally: if tqm is not None: tqm.cleanup()
def run_module(self, hosts='localhost', rules=[{'module': 'setup'}]): ''' rules=[ {'module': 'shell', 'args': 'echo "ok"', 'register': 'echo_ok'}, {'module': 'debug', 'args': {'msg': '{{echo_ok.stdout}}'}} ] ''' tasks = [] for rule in rules: if 'register' in rule: register = rule.pop('register') tasks.append(dict(dict(action=rule), register=register)) play_source = dict( name = "Ansible Play", hosts = hosts, gather_facts = 'no', tasks = tasks ) results_callback = ResultCallback() play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) qm = None 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(play) return results_callback finally: if tqm is not None: tqm.cleanup()
def test_strategy_base_run_handlers(self, mock_worker): def fake_run(*args): return mock_worker.side_effect = fake_run mock_play_context = MagicMock() mock_handler_task = MagicMock(Handler) mock_handler_task.action = 'foo' mock_handler_task.get_name.return_value = "test handler" mock_handler_task.has_triggered.return_value = False mock_handler = MagicMock() mock_handler.block = [mock_handler_task] mock_handler.flag_for_host.return_value = False mock_play = MagicMock() mock_play.handlers = [mock_handler] mock_host = MagicMock(Host) mock_host.name = "test01" mock_host.has_hostkey = True mock_inventory = MagicMock() mock_inventory.get_hosts.return_value = [mock_host] mock_var_mgr = MagicMock() mock_var_mgr.get_vars.return_value = dict() mock_iterator = MagicMock mock_iterator._play = mock_play fake_loader = DictDataLoader() mock_options = MagicMock() mock_options.module_path = None tqm = TaskQueueManager( inventory=mock_inventory, variable_manager=mock_var_mgr, loader=fake_loader, options=mock_options, passwords=None, ) tqm._initialize_processes(3) tqm._initialize_notified_handlers(mock_play) tqm.hostvars = dict() try: strategy_base = StrategyBase(tqm=tqm) strategy_base._inventory = mock_inventory strategy_base._notified_handlers = {mock_handler_task: [mock_host]} task_result = TaskResult(Host('host01'), Handler(), dict(changed=False)) tqm._final_q.put(('host_task_ok', task_result)) result = strategy_base.run_handlers(iterator=mock_iterator, play_context=mock_play_context) finally: tqm.cleanup()
def main(): host_list = ['localhost', 'www.example.com', 'www.google.com'] Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check']) # initialize needed objects variable_manager = VariableManager() loader = DataLoader() options = Options(connection='smart', module_path='/usr/share/ansible', forks=100, remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user=None, verbosity=None, check=False) passwords = dict() # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory) # create play with tasks play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module='command', args=dict(cmd='/usr/bin/uptime')))] ) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it tqm = None callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) tqm._stdout_callback = callback result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() print("UP ***********") for host, result in callback.host_ok.items(): print('{} >>> {}'.format(host, result._result['stdout'])) print("FAILED *******") for host, result in callback.host_failed.items(): print('{} >>> {}'.format(host, result._result['msg'])) print("DOWN *********") for host, result in callback.host_unreachable.items(): print('{} >>> {}'.format(host, result._result['msg']))
def run(self, host_list, module_name, module_args,): """ run module from andible ad-hoc. module_name: ansible module_name module_args: ansible module args """ self.results_raw = {'success':{}, 'failed':{}, 'unreachable':{}} Options = namedtuple('Options', ['connection','module_path', 'forks', 'timeout', 'remote_user', 'ask_pass', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'ask_value_pass', 'verbosity', 'check']) options = Options(connection='smart', module_path='/usr/share/ansible', forks=100, timeout=10, remote_user='******', ask_pass=False, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user='******',ask_value_pass=False, verbosity=None, check=False) passwords = dict(sshpass=None, becomepass=None) # create play with tasks play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))] ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # actually run it tqm = None callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=options, passwords=passwords, ) tqm._stdout_callback = callback result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() for host, result in callback.host_ok.items(): self.results_raw['success'][host] = result._result.get('stdout') + result._result.get('stderr') for host, result in callback.host_failed.items(): self.results_raw['failed'][host] = result._result.get('stdout') + result._result.get('stderr') for host, result in callback.host_unreachable.items(): self.results_raw['unreachable'][host]= result._result['msg'] logger.info(self.results_raw) return self.results_raw
def main(args): # Options definition # Custom tuple to store playbook options Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check']) # Object initialization variable_manager = VariableManager() loader = DataLoader() options = Options(connection='ssh',module_path='library', forks=100, become=None, become_method=None, become_user=None, check=False) passwords = {} # Dinamyc inventory inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=args) # Inventory assignation variable_manager.set_inventory(inventory) # Play creation with tasks play_source = dict( name="Ansible Play", hosts=args, gather_facts='no', tasks=[ dict(action=dict(module='shell', args='hostname -f'), register='shell_out'), dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) ] ) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # Running it tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback='default' ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def main(argv=sys.argv[1:]): Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check']) # initialize needed objects variable_manager = VariableManager() loader = DataLoader() options = Options(connection='local', module_path='/path/to/mymodules', forks=100, become=None, become_method=None, become_user=None, check=False) passwords = dict(vault_pass='******') # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='localhost') variable_manager.set_inventory(inventory) # create play with tasks play_source = dict(name="Ansible Play", hosts='localhost', gather_facts='no', tasks=[ dict(action=dict(module='shell', args='uname -a'), register='shell_out'), dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) ] ) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it tqm = None try: tqm = TaskQueueManager(inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback='default', ) result = tqm.run(play) print result finally: if tqm is not None: tqm.cleanup()
def test_base(self): test_inv_dir = 'test/inventory' for inv in os.listdir(test_inv_dir): print "Processing ", inv res = dynlxc.main(os.path.join(test_inv_dir, inv), '') variable_manager = VariableManager() loader = DataLoader() self.mock_rv.communicate.return_value = [ json.dumps(res), 'mocked_err'] try: inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list='inventory/dynlxc.py' ) except Exception as err: raise Exception("Inventory file {0} processing result '{1}' " "failed with {2}".format(inv, res, err)) variable_manager.set_inventory(inventory) play_source = dict(name="Ansible Play", hosts='localhost', gather_facts='no') playbook = os.path.abspath(os.path.join(test_inv_dir, '../playbooks', inv)) if os.path.isfile(playbook): with open(playbook) as fh: real_playbook = yaml.load(fh)[0] play_source.update(real_playbook) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=self.options, passwords=None, stdout_callback='default', ) result = tqm.run(play) assert result == 0, ("Ansible playbook exitcode " "different from 0") finally: if tqm is not None: tqm.cleanup()
def run(self): tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.callback, ) for name, play in self.plays.items(): result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def run( self, tasks, pattern, play_name='Ansible Ad-hoc', gather_facts='no',): """ :param gather_facts: :param tasks: [{'action': {'module': 'shell', 'args': 'ls'}, ...}, ] :param pattern: all, *, or others :param play_name: The play name :return: """ self.check_pattern(pattern) results_callback = self.results_callback_class() cleaned_tasks = self.clean_tasks(tasks) play_source = dict( name=play_name, hosts=pattern, gather_facts=gather_facts, tasks=cleaned_tasks ) play = Play().load( play_source, variable_manager=self.variable_manager, loader=self.loader, ) tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, stdout_callback=results_callback, passwords=self.options.passwords, ) try: tqm.run(play) return results_callback except Exception as e: raise AnsibleError(e) finally: tqm.cleanup() self.loader.cleanup_all_tmp_files()
def main(host_list,module,args): Options = namedtuple('Options', ['connection','module_path', 'forks', 'remote_user', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check']) # initialize needed objects variable_manager = VariableManager() loader = DataLoader() options = Options(connection='smart', module_path='xxx', forks=50, remote_user='******', ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user=None, verbosity=None, check=False) passwords = dict(sshpass=None, becomepass=None) # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory) # create play with tasks play_source = dict( name = "Ansible Play", hosts = host_list, gather_facts = 'no', tasks = [ dict(action=dict(module=module, args=args)) ] ) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it tqm = None callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) tqm._stdout_callback = callback tqm.run(play) return callback.results[0]['tasks'][0]['hosts'] finally: if tqm is not None: tqm.cleanup()
def run(play): tqm = None results = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback='default', ) results = tqm.run(play) finally: if tqm is not None: tqm.cleanup() return tqm, results
def execute_tasks(play_name, tasks, hosts, host_list=os.path.join(DIRNAME, 'ansible_hosts.py'), callback="default"): # NOTICE: Here is a trick. The host we acquired must in the host list # everytime. However I can't get the host list in advance. So I add the # hosts into the host list eveytime if it doesn't exist. if hosts not in ansible_hosts.hosts["all"]["hosts"]: ansible_hosts.hosts["all"]["hosts"].append(hosts) # initialize needed objects variable_manager = VariableManager() loader = DataLoader() # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory) # create play with tasks play_source = dict( name=play_name, hosts=hosts, gather_facts='no', tasks=tasks) 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=None, module_path=None, forks=10, become=None, become_method=None, become_user=None, check=False) passwords = dict() # actually run it tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=callback) return tqm.run(play) finally: if tqm is not None: tqm.cleanup() pass
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
def run(self): tqm = None try: tqm = TaskQueueManager(inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords={}, stdout_callback=self.stdout_callback) self.consumer.send("Start => \r\n") for p in self.play: result = tqm.run(p) # self.delete_key() self.consumer.send('执行完毕\r\n') finally: self.consumer.close() if tqm is not None: tqm.cleanup()
def Arunner(self, ansible_host_path, module, args): inventory = InventoryManager(loader=self.loader, sources=[ansible_host_path]) # 加载之前的变量 variable_manager = VariableManager(loader=self.loader, inventory=inventory) play_source = dict( name="Ansible Play", hosts="all", # all表示匹配清单所有机器,看源码发现的 gather_facts="no", tasks=[ dict(action=dict(module=module, args=args), register='shell_out'), ]) play = Play().load(play_source, variable_manager=variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=self.loader, options=self.ops, passwords=self.passwords, stdout_callback=self.callback, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) # 重构输出 result_raw = {'success': {}, 'failed': {}, 'unreachable': {}} for host, result in self.callback.host_ok.items(): result_raw["success"][host] = result for host, result in self.callback.host_unreachable.items(): result_raw['failed'][host] = result for host, result in self.callback.host_failed.items(): result_raw['unreachable'][host] = result return json.dumps(result_raw, indent=4)
def play_vars(ctx): # create inventory, use path to host config file as source or hosts in a comma # separated string inventory = InventoryManager(loader=loader, sources="inventory") # variable manager takes care of merging all the different sources to give you # a unified view of variables available in each context variable_manager = VariableManager(loader=loader, inventory=inventory) # create data structure that represents our play, including tasks, this is basically # what our YAML loader does internally. play_source = dict(name="Ansible Play", hosts="all", gather_facts="no", tasks=[]) loader.set_vault_secrets([("default", VaultSecret(_bytes=to_bytes("TBD"))) ]) # Create play object, playbook objects use .load instead of init or new methods, # this will also automatically create the task objects from the info provided # in play_source play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, passwords=dict(), # Use our custom callback instead of the ``default`` callback # plugin, which prints to stdout stdout_callback=results_callback, ) # most interesting data for a play is actually # sent to the callback's methods tqm.run(play) finally: # we always need to cleanup child procs and the structures we use to # communicate with them if tqm is not None: tqm.cleanup() # Remove ansible tmpdir shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) ctx.hostvars = variable_manager.get_vars()["hostvars"]
def run(self): # actually run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=dict(), ) tqm._stdout_callback = self.call_back result = tqm.run(self.play) self._summary = self.call_back.summary self._results = self.call_back.results return result finally: if tqm is not None: tqm.cleanup()
def run_playbook(self, playbook): '''Run an ansible playbook using the ansible python api.''' play = self._get_play_(playbook) tqm = None self.results_callback = ResultCallback() try: tqm = TaskQueueManager(inventory=self._inventory, variable_manager=self._variable_manager, loader=self._loader, passwords=dict(), stdout_callback=self.results_callback) tqm.run(play) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) return self.results_callback.result_playbook_run
def exec_shell(self,hostlist=[],command=None): source = {'hosts': hostlist, 'gather_facts': 'no', 'tasks': [ {'action': {'module': 'shell', 'args': command}, 'register': 'shell_out'}]} play = Play().load(source, variable_manager=self.variable_manager, loader=self.loader) try: taskqm = TaskQueueManager( inventory = self.inventory, variable_manager = self.variable_manager, loader = self.loader, options = self.options, passwords = self.passwords, # stdout_callback = self.result_callback, ) taskqm.run(play) except: raise finally: if taskqm is not None: taskqm.cleanup()
def adhoc_cmd(sources=None, hosts=None, module=None, args=None): Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff' ]) options = Options(connection='smart', module_path=['/to/mymodules'], forks=10, become=None, become_method=None, become_user=None, check=False, diff=False) loader = DataLoader() passwords = dict() inventory = InventoryManager(loader=loader, sources=sources) variable_manager = VariableManager(loader=loader, inventory=inventory) play_source = dict( name="My Ansible Task Test", hosts=hosts, gather_facts='no', tasks=[ dict(action=dict(module=module, args=args), register='shell_out'), # dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) ]) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def ansible_get_info(host_path): Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check']) variable_manager = VariableManager() loader = DataLoader() options = Options(connection='ssh', module_path='/Library/Python/2.7/site-packages/ansible', forks=100, become=None, become_method=None, become_user=None, check=False) passwords = dict(vault_pass='******') results_callback = ResultCallback() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_path) # inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=['172.16.0.50', '172.16.0.190']) # variable_manager.extra_vars={"ansible_ssh_user":"******" , "ansible_ssh_pass":"******"} variable_manager.set_inventory(inventory) play_source = dict( name="Ansible Play", hosts='all', gather_facts='no', tasks=[ dict(action=dict(module='setup'), register='shell_out') ] ) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=results_callback, ) tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def run(self): # create play with tasks # play_source = dict( # name = "Ansible Play", # hosts = 'localhost', # gather_facts = 'no', # tasks = [ # dict(action=dict(module='shell', args='ls'), register='shell_out'), # dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) # ] # ) from ansible.playbook import Playbook pb = Playbook.load(self.playbook_path, variable_manager=self.variable_manager, loader=self.loader) # pbex = PlaybookExecutor(playbooks=[self.playbook_path], # inventory=self.inventory, # variable_manager=self.variable_manager, # loader=self.loader, # options=self.options, # passwords=self.passwords) # play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) plays = pb.get_plays() print("plays_type", type(plays)) for play in plays: print("play type:", type(play)) print("play :", dir(play)) # actually run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self. results_callback, # Use our custom callback instead of the ``default`` callback plugin ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def _run_play(self, play_src): self.options = options = self.Options(**self.options_args) vm = self.variable_manager vm.extra_vars = load_extra_vars(loader=self.loader, options=options) play = Play().load(play_src, loader=self.loader, variable_manager=vm) tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=vm, loader=self.loader, options=options, passwords=dict(), stdout_callback='default') tqm.run(play) return vm.get_vars(self.loader) finally: if tqm is not None: tqm.cleanup()
def run(self, play): tqm = None rc = ResultCallback() try: tqm = TaskQueueManager(inventory=self._inventory, variable_manager=self._variable_manager, loader=self._loader, passwords=dict(), stdout_callback=rc) tqm.run(play) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) if rc.failed_playbook_run: raise AnsibleRunError('Unable to run playbook.', rc.result_playbook_run[-1]) return rc.result_playbook_run
def ansible_run(self, host_list, task_list): context._init_global_context(self.ops) play_source = dict(name="Ansible Play", hosts=host_list, gather_facts='no', tasks=task_list) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, # options=self.ops, passwords=self.passwords, stdout_callback=self.results_callback, run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS, run_tree=False, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() # shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) results_raw = {} results_raw['success'] = {} results_raw['failed'] = {} results_raw['unreachable'] = {} for host, result in self.results_callback.host_ok.items(): results_raw['success'][host] = json.dumps(result._result) for host, result in self.results_callback.host_failed.items(): results_raw['failed'][host] = result._result['msg'] for host, result in self.results_callback.host_unreachable.items(): results_raw['unreachable'][host] = result._result['msg'] return results_raw
def run(self, host_list, module_name, module_args=None): """ 从 andible ad-hoc 运行模块. module_name: ansible 模块名称 (-m) module_args: ansible 模块参数 (-a) """ # 创建任务 play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[ dict(action=dict(module=module_name, args=module_args)) # dict(action=dict(module='shell', args="id"), register='shell_out'), # dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')), async=0, poll=15) ]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # 实际运行 # TaskQueueManager 是创建进程池, 负责输出结果和多进程间数据结构或者队列的共享协作 tqm = None # 结果回调类实例化 self.callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.callback, ) tqm.run(play) finally: if tqm is not None: tqm.cleanup() if self.loader: self.loader.cleanup_all_tmp_files() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def run_module(self, host_list, module_name, module_args, deploy=False, send_msg=True): """ run module from ansible ad-hoc. """ self.callback = DeployResultsCollector( self.sock, send_msg=send_msg) if deploy else ModuleResultsCollector(self.sock) play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # actually run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.callback, ) C.HOST_KEY_CHECKING = False # 关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) except Exception as e: ansible_logger.error('执行{}失败,原因: {}'.format(module_name, e)) finally: if tqm is not None: tqm.cleanup()
def run(self, host_list, task_list): play_source = dict(name="Ansible Task", hosts=host_list, gather_facts='no', tasks=task_list) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.ops, passwords=self.passwords, stdout_callback=self.results_callback, run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS, run_tree=False, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() os.remove(self.hostsFile.name) shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) results_raw = {} results_raw['success'] = {} results_raw['failed'] = {} results_raw['unreachable'] = {} for host, result in self.results_callback.host_ok.items(): results_raw['success'][host] = result._result["stdout_lines"] for host, result in self.results_callback.host_failed.items(): results_raw['failed'][host] = result._result["stdout_lines"] for host, result in self.results_callback.host_unreachable.items(): results_raw['unreachable'][host] = "Failed to connect to the host" print json.dumps(results_raw)
def run(self, tasks, pattern, play_name='Ansible Ad-hoc', gather_facts='no'): """ :param tasks: [{'action': {'module': 'shell', 'args': 'ls'}, ...}, ] :param pattern: all, *, or others :param play_name: The play name :return: """ self.check_pattern(pattern) results_callback = self.results_callback_class() cleaned_tasks = self.clean_tasks(tasks) play_source = dict(name=play_name, hosts=pattern, gather_facts=gather_facts, tasks=cleaned_tasks) play = Play().load( play_source, variable_manager=self.variable_manager, loader=self.loader, ) tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, stdout_callback=results_callback, passwords=self.options.passwords, ) try: tqm.run(play) return results_callback except Exception as e: raise AnsibleError(e) finally: tqm.cleanup() self.loader.cleanup_all_tmp_files()
def run(self, playbook): pb = Playbook.load(playbook, variable_manager=self.variable_manager, loader=self.loader) # only support one playbook.yml play = pb.get_plays()[0] tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords={'conn_pass': None, 'become_pass': None}, stdout_callback=self.callback, ) return tqm.run(play), self.callback.result finally: if tqm is not None: tqm.cleanup()
def run(self, module_name, module_args, extra_vars={}): """ run module from andible ad-hoc. :arg string module_name: ansible module_name :arg string module_args: ansible module args """ run_host_list = [x.name for x in self.inventory.get_hosts()] # create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally. play_source = dict( name="Ansible Play", hosts=run_host_list, gather_facts='no', tasks=[ dict(action=dict(module=module_name, args=module_args)), ]) self.variable_manager.extra_vars = extra_vars play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # Run it - instantiate task queue manager, which takes care of forking and setting up all objects to iterate over host list and tasks tqm = None #self.callback = ResultCallback() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self. callback, # Use our custom callback instead of the ``default`` callback plugin, which prints to stdout ) result = tqm.run( play ) # most interesting data for a play is actually sent to the callback's methods finally: # we always need to cleanup child procs and the structres we use to communicate with them if tqm is not None: tqm.cleanup() # Remove ansible tmpdir shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def run(self, tasks, pattern, play_name='Ansible Ad-hoc', gather_facts='no'): """ :param tasks: [{'action': {'module': 'shell', 'args': 'ls'}, ...}, ] :param pattern: all, *, or others :param play_name: The play name :param gather_facts: :return: """ self.check_pattern(pattern) self.results_callback = self.get_result_callback() cleaned_tasks = self.clean_tasks(tasks) context.CLIARGS = ImmutableDict(self.options) play_source = dict(name=play_name, hosts=pattern, gather_facts=gather_facts, tasks=cleaned_tasks) play = Play().load( play_source, variable_manager=self.variable_manager, loader=self.loader, ) tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, stdout_callback=self.results_callback, passwords={"conn_pass": self.options.get("password", "")}) try: tqm.run(play) return self.results_callback except Exception as e: raise AnsibleError(e) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def run_model(self, host_list, module_name, module_args): """ ansible group1 -m shell -a 'ls /tmp' """ print(" in run model") self.callback = ADhocCallback() play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback="minimal", ) print(tqm) print(dir(play)) print(play.get_tasks()) print(play.get_name()) print(play.get_vars()) print(play.get_roles()) try: tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False # 关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) self.results_raw = self.callback.result_row print("[2] %s" % self.results_raw) # debug 2 except Exception as err: print(err) finally: if tqm is not None: tqm.cleanup()
def test_strategy_base_queue_task(self, mock_worker): def fake_run(self): return mock_worker.run.side_effect = fake_run fake_loader = DictDataLoader() mock_var_manager = MagicMock() mock_host = MagicMock() mock_host.get_vars.return_value = dict() mock_host.has_hostkey = True mock_inventory = MagicMock() mock_inventory.get.return_value = mock_host mock_options = MagicMock() mock_options.module_path = None tqm = TaskQueueManager( inventory=mock_inventory, variable_manager=mock_var_manager, loader=fake_loader, options=mock_options, passwords=None, ) tqm._initialize_processes(3) tqm.hostvars = dict() mock_task = MagicMock() mock_task._uuid = 'abcd' try: strategy_base = StrategyBase(tqm=tqm) strategy_base._queue_task(host=mock_host, task=mock_task, task_vars=dict(), play_context=MagicMock()) self.assertEqual(strategy_base._cur_worker, 1) self.assertEqual(strategy_base._pending_results, 1) strategy_base._queue_task(host=mock_host, task=mock_task, task_vars=dict(), play_context=MagicMock()) self.assertEqual(strategy_base._cur_worker, 2) self.assertEqual(strategy_base._pending_results, 2) strategy_base._queue_task(host=mock_host, task=mock_task, task_vars=dict(), play_context=MagicMock()) self.assertEqual(strategy_base._cur_worker, 0) self.assertEqual(strategy_base._pending_results, 3) finally: tqm.cleanup()
def run_model(self, host_list, module_name, module_args): """ run module from ansible ad-hoc. :param host_list: :param module_name: ansible module name :param module_args: ansible module args :return: """ play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None if self.redisKey or self.logId: self.callback = ModelResultsCollectorToSave( self.redisKey, self.logId) else: self.callback = ModelResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False tqm.run(play) except Exception as err: logger.error(msg="run model failed: {err}".format(err=str(err))) if self.redisKey: DsRedis.OpsAnsibleModel.lpush(self.redisKey, data=err) if self.logId: AnsibleSaveResult.Model.insert(self.logId, err) finally: if tqm is not None: tqm.cleanup()
def module_run(self, task_lst): """ task_lst is a list for dict, Just like : [ { 'module': 'your_self_module', 'args': 'args=sssss' }, { 'module': 'shell', 'args': 'ifconfig' } ] :param task_lst: :return None: """ tasks = _parse_task(task_lst) play_source = dict(name="Ansible Play", hosts=self.hosts, gather_facts='no', tasks=tasks) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # actually run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.result_callback, # Use our custom callback instead of the ``default`` callback plugin ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def order_run(host, action): """ run an ansible order :param host: string :param action: dict :return: return an object ResultCallback """ variable_manager = VariableManager() loader = DataLoader() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='/etc/ansible/hosts') passwords = {} play_source = dict(name="Ansible Play", hosts=host, gather_facts='no', tasks=[dict(action=action)]) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None callback = ResultCallback() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=callback, run_additional_callbacks=constants.DEFAULT_LOAD_CALLBACK_PLUGINS, run_tree=False, ) tqm.run(play) finally: if tqm is not None: tqm.cleanup() return callback
def run(self, tasks, pattern, play_name='Ansible Ad-hoc', gather_facts='no'): """ :param tasks: [{'action': {'module': 'shell', 'args': 'ls'}, ...}, ] :param pattern: all, *, or others :param play_name: The play name :param gather_facts: :return: """ self.check_pattern(pattern) self.results_callback = self.get_result_callback() cleaned_tasks = self.clean_tasks(tasks) context.CLIARGS = ImmutableDict(self.options) play_source = dict( name=play_name, hosts=pattern, gather_facts=gather_facts, tasks=cleaned_tasks ) play = Play().load( play_source, variable_manager=self.variable_manager, loader=self.loader, ) tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, stdout_callback=self.results_callback, passwords={"conn_pass": self.options.get("password", "")} ) try: tqm.run(play) return self.results_callback except Exception as e: raise AnsibleError(e) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def run(self, args, gether_facts="no", module="shell", task_time=0): """ 参数说明: task_time -- 执行异步任务时等待的秒数,这个需要大于 0 ,等于 0 的时候不支持异步(默认值)。这个值应该等于执行任务实际耗时时间为好 """ if self.iswin: module = 'raw' play_source = dict( name="Ad-hoc", hosts=self.host_lists, gather_facts=gether_facts, tasks=[ # 这里每个 task 就是这个列表中的一个元素,格式是嵌套的字典 # 也可以作为参数传递过来,这里就简单化了。 { "action": { "module": module, "args": args }, "async": task_time, "poll": 0 } ]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager(inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, passwords=self.passwords, stdout_callback=self.results_callback) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def run_module(self, module_name, module_args, hosts='all'): """ 运行 module """ play_source = dict( name='Ansible Run Module', hosts=hosts, gather_facts='no', tasks=[ {'action': {'module': module_name, 'args': module_args}}, ] ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager( inventory=self.dynamic_inventory, variable_manager=self.variable_manager, loader=self.loader, passwords=self.passwords, stdout_callback=self.results_callback, ) tqm.run(play) # self.result_row = self.results_callback.result_row except Exception: print(traceback.format_exc()) finally: # try: # message = dict() # message['status'] = 0 # message['message'] = '执行关闭' # message = json.dumps(message) # async_to_sync(channel_layer.group_send)(self.group, { # "type": "send.message", # "text": message, # }) # except: # pass if tqm is not None: tqm.cleanup() # 这个临时目录会在 ~/.ansible/tmp/ 目录下 shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def run_adhoc(host_list, module_name, module_args): loader = DataLoader() # 用来加载解析yaml文件或JSON内容,并且支持vault的解密 variable_manager = VariableManager( ) # 管理变量的类,包括主机,组,扩展等变量,之前版本是在 inventory 中的 inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory) # 根据 inventory 加载对应变量 # 构建pb, 这里很有意思, 新版本运行ad-hoc或playbook都需要构建这样的pb, 只是最后调用play的类不一样 # :param name: 任务名,类似playbook中tasks中的name # :param hosts: playbook中的hosts # :param tasks: playbook中的tasks, 其实这就是playbook的语法, 因为tasks的值是个列表,因此可以写入多个task play_source = { "name": "Ansible Ad-Hoc", "hosts": "pool-ip", "gather_facts": "no", "tasks": [{ "action": { "module": module_name, "args": module_args } }] } play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, stdout_callback='minimal', run_tree=False, ) result = tqm.run(play) return result finally: if tqm is not None: tqm.cleanup()
def shell_run(self): play = Play().load(self.play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None 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(play) finally: if tqm is not None: tqm.cleanup() return results_callback.host_ok
def execute_play(self, play_source): play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords={}, stdout_callback=self.default_results_callback) result = tqm.run(play) print('executed playbook, terminated with code %d.' % result) finally: if tqm is not None: tqm.cleanup()
def run(self, callback=None): self.variable_manager.set_inventory(self.inventory) play = Play().load(self.create_play_tasks(), variable_manager=self.variable_manager, loader=self.loader) tqm = None if not callback: callback = ResultsCollector() try: tqm = TaskQueueManager(inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=callback) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() return result, callback
def run(self): tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords={}, stdout_callback=self.stdout_callback ) for p in self.play: result = tqm.run(p) self.delete_key() self.push_mission.status = settings.OPS_PUSH_MISSION_SUCCESS self.consumer.send("OK") finally: self.consumer.close() if tqm is not None: tqm.cleanup()
def exec_ansible(module,args,host): Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff']) # initialize needed objects loader = DataLoader() options = Options(connection='ssh', module_path='/usr/local/python3/lib/python3.6/site-packages/', forks=100, become=None, become_method=None, become_user=None, check=False,diff=False) passwords = dict(vault_pass='******') results_callback = ResultCallback() # create inventory and pass to var manager inventory = InventoryManager(loader=loader, sources=['/tmp/hosts']) variable_manager = VariableManager(loader=loader, inventory=inventory) # create play with tasks play_source = dict( name = "Ansible Play", hosts = host, gather_facts = 'no', tasks = [ dict(action=dict(module=module, args=args), register='shell_out'), ] ) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) stdout_callback = results_callback tqm = None global exec_result try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=results_callback, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() return exec_result
def run(self, hosts, module, args): play_source = dict( name="ansible run", hosts=hosts, gather_facts='no', tasks=[ dict( action=dict( module=module, args=args), register='shell_out'), dict( action=dict( module='debug', args=dict( msg='{{shell_out.stdout}}'))) ] ) play = Play().load( play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.results_callback, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() try: return(info) except: pass
def _execute_play(play_source, inventory, var_mgr, loader, options, callback): # pylint: disable=too-many-arguments """ Execute the playbook """ play = Play().load(play_source, variable_manager=var_mgr, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=var_mgr, loader=loader, options=options, passwords=None, stdout_callback=callback, ) _ = tqm.run(play) except Exception as exc: raise TaskExecutionException(str(exc)) finally: if tqm is not None: tqm.cleanup()
def run(self, callback=None): self.variable_manager.set_inventory(self.inventory) play = Play().load(self.create_play_tasks(), variable_manager=self.variable_manager, loader=self.loader) tqm = None if not callback: callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=callback ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() return result, callback
def ansible_play(self): # run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.results_callback, # stdout_callback='default', ) result = tqm.run(self.play) finally: if tqm is not None: tqm.cleanup() #self.inventory.clear_pattern_cache() if result != 0: raise ValueError('SSH Command Failed, resturn: %s' % result) return self.return_results
def run_play(self, host_list, module_name, module_args): """ run play :param host_list is list, :param module_name is string :param module_args is string """ play = None # create play with tasks play_source = dict( name="Ansible Play", hosts=host_list, gather_facts='no', tasks=[dict(action=dict(module=module_name, args=module_args))] ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # actually run it tqm = None display = LogDisplay(logname=self.job_id) callback = CALLBACKMODULE[CALLBACK](display=display) if module_name == 'backup': # 对于备份模块,特殊处理,必须使用minimal,才能获取到文件名属性 callback = minimal_callback(display=display) try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) tqm._stdout_callback = callback tqm.run(play) finally: if tqm is not None: tqm.cleanup() return display.get_log_json()