def run_adhoc(self, host_list, module_name, module_args): play_source = dict( name="adhoc", 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) self.callback = ResultCallback() 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) except Exception as err: raise Exception(err) finally: if tqm is not None: tqm.cleanup()
def run(self): """ 运行ansible任务. """ # create play with tasks play_source = dict(name="Ansible Play", hosts=self.ip_list, gather_facts='no', tasks=[ dict(action=dict(module=self.module_name, args=self.module_args)) ]) 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='default', ) tqm._stdout_callback = self.callback result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() return result
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 """ play_source = dict( name="Ansible Ad-hoc Command", 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 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='default', ) tqm._stdout_callback = self.callback result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def run_module(self, host_list, module_name, module_args): """ :param host_list: ßß :param module_name: ansible 模块名称 (-m) :param module_args: ansible 模块参数 (-a) :return: """ self.callback = ModuleResultsCollector() play_source = dict( name="Ansible Ad-hoc", hosts=host_list, gather_facts=self.gather_facts, tasks=[dict(action=dict(module=module_name, args=module_args))]) play = Play().load(play_source, loader=self.loader, variable_manager=self.variable_manager) 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) tqm._stdout_callback = self.callback C.HOST_KEY_CHECKING = False # 关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) except Exception as err: print err finally: if tqm is not None: tqm.cleanup() if self.loader: self.loader.cleanup_all_tmp_files()
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(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): """ run a tasksqueue manager """ self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.hosts) self.variable_manager.set_inventory(self.inventory) tqm = None self.callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.password, ) tqm._stdout_callback = self.callback self.result = tqm.run(play) 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 = AnsibleTaskResultCallback() 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_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 self.callback = ModelResultsCollector() import traceback try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback="minimal", ) tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False tqm.run(play) except Exception as err: print(traceback.print_exc()) finally: if tqm is not None: tqm.cleanup()
def ping(host_list): C.HOST_KEY_CHECKING = False loader = DataLoader() options = Options(connection='smart',forks=5,remote_user='******',ssh_common_args='-C -o ControlPersist=30s') passwords = dict() sources = host_list[0] + ',' inventory = InventoryManager(loader=loader,sources=sources) variable_manager = VariableManager(loader=loader,inventory=inventory) play_source = dict( name = 'Test Ping', hosts = host_list, gather_facts = 'no', tasks = [dict(action=dict(module='ping',args=''))] ) play = Play().load(play_source,variable_manager=variable_manager,loader=loader) tqm = None callback = ResultCollector() try: tqm = TaskQueueManager( inventory = inventory, variable_manager = variable_manager, loader = loader, options = options, passwords = passwords ) tqm._stdout_callback = callback res = tqm.run(play) finally: if tqm is not None: tqm.cleanup() return callback.result
def run_module(self, module_name, module_args, hosts=None): play_source = dict(name="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 self.callback = ResuCallbackModule() try: tqm = TaskQueueManager( inventory=self._inventory, variable_manager=self._variable_manager, loader=self._loader, passwords=self._passwords, ) tqm._stdout_callback = self.callback tqm.run(play) finally: if tqm is not None: tqm.cleanup() # 这个临时目录会在 ~/.ansible/tmp/ 目录下 shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def run_model(self, host_list, module_name, module_args): """ 执行andible ad-hoc模块 module_name: 模块名 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 = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None # 创建结果收集对象 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 result = tqm.run(play) finally: if tqm is not None: tqm.cleanup()
def run_model(self, host_list, module_name, module_args): self.callback = AdHoccallback(self.websocket, self.mysql) play_source = dict( name="Ansible Ad-hoc", hosts=host_list, gather_facts=self.gather_facts, tasks=[dict(action=dict(module=module_name, args=module_args))]) play = Play().load(play_source, loader=self.loader, variable_manager=self.variable_manager) 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) tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False #关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) except Exception as err: logger.error(msg="run model failed: {err}".format(err=str(err))) if self.websocket: self.websocket.send(str(err)) finally: if tqm is not None: tqm.cleanup() if self.loader: self.loader.cleanup_all_tmp_files()
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_model(self, host_list, module_name, module_args): """ ansible group1 -m shell -a 'ls /tmp' """ 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 = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback="minimal", ) tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False #关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) self.results_raw = self.callback.result_row except Exception as err: print(err) 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_model(self): for task in self.taskinfo: play_source = dict(name="andible_api_play", hosts=self.host_list, gather_facts="no", tasks=[ dict(action=dict(module=task.get("module"), args=task.get("args"))) ]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None self.callback = ModelResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback="minimal", ) tqm._stdout_callback = self.callback result = tqm.run(play) except Exception as err: import traceback print(traceback.print_exc()) finally: if tqm is not None: tqm.cleanup()
def run_modules(host, module, args, options): task_list = [ dict(action=dict(module='%s' % module, args='%s' % args)), ] play_source = dict(name="Ansible Ad-Hoc", hosts=host, gather_facts="no", tasks=task_list) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, run_tree=False, ) tqm._stdout_callback = callback tqm.run(play) return AnsibleReturn(callback).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: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: 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(self, hosts, 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=hosts, 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}}')))] 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() #self.callback = ResultCallback() 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_model(self, host_list, module_name, module_args): if self.redisKey or self.logId: self.callback = ModelResultsCollectorToSave( self.redisKey, self.logId) else: self.callback = ModelResultsCollector() play_source = dict( name="Ansible Ad-hoc", hosts=host_list, gather_facts=self.gather_facts, tasks=[dict(action=dict(module=module_name, args=module_args))]) play = Play().load(play_source, loader=self.loader, variable_manager=self.variable_manager) 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) tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False # 关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) except Exception as err: logger.error(msg=err) finally: if tqm is not None: tqm.cleanup() if self.loader: self.loader.cleanup_all_tmp_files()
def run(host, user, passwd, tasks): 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='none', forks=100, remote_user=user, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=True, become_method="sudo", become_user="******", verbosity=None, check=False) passwords = {'conn_pass': passwd, 'become_pass': ""} inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host) variable_manager.set_inventory(inventory) host_list = [] for h in host: host_list.append(h.split(":")[0]) play_source = dict(name="Ansible Play", hosts=host_list, gather_facts='no', tasks=tasks) print(play_source) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) 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) finally: if tqm is not None: tqm.cleanup() return callback.host_ok.items(), callback.host_failed.items( ), callback.host_unreachable.items()
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 run(self, workname, host_list, module_name, module_args, work_uuid, username, callback='mongo', describe=''): """ run module from andible ad-hoc. module_name: ansible module_name module_args: ansible module args """ play_source = dict( name=workname, 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) try: self.host_list = self.inventory.list_hosts(host_list) print("self.host_list", self.host_list) except Exception as e: self.host_list = [] if len(self.host_list) == 0: # self.logger.error(self.log_prefix + '准备工作失败,原因:没有匹配主机名') return False, '执行失败,没有匹配主机名' tqm = None # if self.redisKey:self.callback = ModelResultsCollectorToSave(self.redisKey,self.logId) # else:self.callback = ModelResultsCollector() # self.callback = ModelResultsCollector() if callback == 'mongo': self.callback = JsonCallback(work_uuid, workname, 'adhoc', self.options, describe, module_name=module_name, module_args=module_args, pattern=host_list, username=username) else: self.callback = ModelResultsCollector() import traceback try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback="minimal", ) tqm._stdout_callback = self.callback C.HOST_KEY_CHECKING = False # 关闭第一次使用ansible连接客户端是输入命令 tqm.run(play) print("tqm.run") except Exception as err: print(traceback.print_exc()) # 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_playbook(inventory_filename, playbook_filename): ''' Эта функция выполняет playbook и возвращает все результаты в виде словаря Параметры: * inventory_filename - имя инвентарного файла * playbook_filename - имя playbook ''' variable_manager = VariableManager() loader = DataLoader() Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check']) options = Options(connection='local', module_path='', forks=100, become=False, become_method='', become_user='', check=False) passwords = dict(vault_pass='******') inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=inventory_filename) variable_manager.set_inventory(inventory) with open(playbook_filename) as f: playbook_content = yaml.load(f) return_result_dict = odict() for play_src in playbook_content: play = Play().load(play_src, variable_manager=variable_manager, loader=loader) tqm = None callback = CallbackModule() 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() return_result_dict[play_src['name']] = callback.results[0] return return_result_dict
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 autocreate_publickey(host_list, password, jobid): C.HOST_KEY_CHECKING = False loader = DataLoader() options = Options(connection='smart', forks=5, ssh_common_args='-C -o ControlPersist=30s') passwords = dict() if len(host_list) <= 1: sources = host_list[0] + ',' else: sources = ','.join(host_list) inventory = InventoryManager(loader=loader, sources=sources) variable_manager = VariableManager(loader=loader, inventory=inventory) for host in host_list: host_info = Host(name=host, port=22) variable_manager.set_host_variable(host_info, 'ansible_ssh_user', 'root') variable_manager.set_host_variable(host_info, 'ansible_ssh_pass', password) play_source = dict( name='Generate Publickey', hosts=host_list, gather_facts='no', tasks=[ dict(action=dict( module='authorized_key', args=dict(user='******', key="{{ lookup('file','/root/.ssh/id_rsa.pub') }}"))) ]) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None callback = ResultsCollector(jobid) 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() return callback.result
def run(self): self.variable_manager.set_inventory(self.inventory) play = Play().load(self.create_play_tasks(), variable_manager=self.variable_manager, loader=self.loader) tqm = None callback = ResultsCollector() tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords ) tqm._stdout_callback = callback result = tqm.run(play) return result, callback
def run_ntcshow(username, password, hostname, cmd, driver): inventory = set_inventory(hostname) play_source = dict( name='BICS API', hosts=hostname, gather_facts='False', tasks=[ dict(action=dict( module='ntc_show_command', args=dict( connection='netmiko_ssh', platform=driver, command=cmd, template_dir= '/home/beta/ntc-ansible/ntc-templates/templates', host=hostname, username=username, password=password, secret=password, ))) ]) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, run_tree=False, ) tqm._stdout_callback = callback result = tqm.run(play) return callback finally: if tqm is not None: tqm.cleanup()
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_adhoc(ip, order): variable_manager.extra_vars = { "ansible_ssh_user": "******", "ansible_ssh_pass": "******" } play_source = { "name": "Ansible Ad-Hoc", "hosts": "%s" % ip, "gather_facts": "no", "tasks": [{ "action": { "module": "command", "args": "%s" % order } }] } # play_source = {"name":"Ansible Ad-Hoc","hosts":"192.168.2.160","gather_facts":"no","tasks":[{"action":{"module":"command","args":"python ~/store.py del"}}]} play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, #stdout_callback='minimal', #stdout_callback=results_callback, run_tree=False, ) tqm._stdout_callback = callback result = tqm.run(play) return callback finally: if tqm is not None: tqm.cleanup()
def run_ad_hoc(self, host, module_name, module_args): """ run module from andible ad-hoc. module_name: ansible module_name module_args: ansible module args """ self.callback = AdHocResultCallback(self.uuid, self.sock) # create play with tasks play_source = dict( name="Ansible ad-hoc", hosts=host, 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, ) tqm._stdout_callback = self.callback C.HOST_KEY_CHECKING = False tqm.run(play) except Exception as e: Task.objects.filter(id=self.task_id).update(error_msg=str(e), executed=True) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
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()
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()
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 """ print(host_list) 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() self.callback = ModelResultsCollector() import traceback try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback="minimal", ) tqm._stdout_callback = self.callback tqm.run(play) except Exception as err: print(traceback.print_exc()) # DsRedis.OpsAnsibleModel.lpush(self.redisKey,data=err) # if self.logId:AnsibleSaveResult.Model.insert(self.logId, err) finally: if tqm is not None: tqm.cleanup()