def run_playbook(self, hosts, playbook_path): """ run ansible palybook """ global tasklist tasklist = {} for host in hosts: tasklist[host] = {} tasklist[host]['ok'] = [] tasklist[host]['failed'] = [] tasklist[host]['skppied'] = [] self.results_callback = PlayBookResultCallback(tasklist) try: executor = PlaybookExecutor( playbooks=[playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) executor._tqm._stdout_callback = self.results_callback executor.run() except Exception as e: print(e) return False
def ansible_task(playbooks): Options = namedtuple('Options', \ ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax']) options = Options( connection = 'ssh', module_path = '/opt/ansible/modules', forks = 100, become = True, become_method = 'sudo', become_user = '******', check = False, listhosts = None, listtasks = None, listtags = None, syntax = None ) loader = DataLoader() variable_manager = VariableManager() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='/opt/ansible/inventory') variable_manager.set_inventory(inventory) pb = PlaybookExecutor(playbooks=[playbooks], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None) pb.run() stats = pb._tqm._stats ips = stats.processed.keys() return [ {ip : stats.summarize(ip)} for ip in ips ]
def __init__(self, **kwargs): super(Ansible_playbook, self).__init__(**kwargs) self.task_file = kwargs.get('task_file', None) self.sudo = kwargs.get('sudo', False) self.sudo_user = kwargs.get('sudo_user', False) self.sudo_password = kwargs.get('sudo_password', False) # check if parameters have been provided if self._is_parameters_ok(): variable_manager = VariableManager() loader = DataLoader() options = self._get_options() passwords = {'become_pass': self.sudo_password} inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list="localhost") variable_manager.set_inventory(inventory) playbooks = [self.task_file] executor = PlaybookExecutor( playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) executor.run()
def run_playbook(self, host_list, role_name, role_uuid, temp_param): """ run ansible palybook """ try: self.callback = ResultsCollector() filenames = [BASE_DIR + '/handlers/ansible/v1_0/sudoers.yml'] logger.info('ymal file path:%s'% filenames) template_file = TEMPLATE_DIR if not os.path.exists(template_file): logger.error('%s 路径不存在 '%template_file) sys.exit() extra_vars = {} host_list_str = ','.join([item for item in host_list]) extra_vars['host_list'] = host_list_str extra_vars['username'] = role_name extra_vars['template_dir'] = template_file extra_vars['command_list'] = temp_param.get('cmdList') extra_vars['role_uuid'] = 'role-%s'%role_uuid self.variable_manager.extra_vars = extra_vars logger.info('playbook 额外参数:%s'%self.variable_manager.extra_vars) # actually run it executor = PlaybookExecutor( playbooks=filenames, inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) executor._tqm._stdout_callback = self.callback executor.run() except Exception as e: logger.error("run_playbook:%s"%e)
def playbook_api(self,yml_fp): loader = DataLoader() variable_manager = VariableManager() inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list=self.ansible_host_list ) variable_manager.set_inventory(inventory) playbooks = ["%s" % yml_fp] pbex = PlaybookExecutor( playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader, options=self.options, passwords=self.passwords ) callback = AnsiCallBack() pbex._tqm._stdout_callback = callback pbex.run() return self.evaluate_results(callback)
class PlayBook(object): def __init__(self, playbook, inventory="inventory.py", extra_vars=None): basedir = os.path.abspath(os.path.dirname(__file__)) self.playbook = os.path.join(basedir, playbook) self.options = Options( inventory=inventory, sudo=False, su=False, sudo_user=None, su_user=None, listtags=False, listtasks=False, listhosts=False, syntax=False, check=False, ask_pass=False,ask_su_pass=False,ask_sudo_pass=False,ask_vault_pass=False, connection='smart', timeout=10, remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, module_path=None, forks=5, become=False, become_method='sudo', become_user=None, verbosity=0) self.loader = DataLoader() self.variable_manager = VariableManager() self.variable_manager.extra_vars = extra_vars self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=inventory) self.pbex = PlaybookExecutor(playbooks=[self.playbook], inventory=self.inventory, loader=self.loader, variable_manager=self.variable_manager, options=self.options, passwords={'become_pass': None}) def run(self): self.pbex.run() stats = self.pbex._tqm._stats self.pbex._tqm.send_callback('human_log') return stats
def _run_playbook(self, playbook): self.options = options = self.Options(**self.options_args) vm = self.variable_manager vm.extra_vars = load_extra_vars(loader=self.loader, options=options) pbe = PlaybookExecutor( playbooks=[playbook], inventory=self.inventory, variable_manager=vm, loader=self.loader, options=options, passwords=dict(), ) pbe.run() return vm.get_vars(self.loader)
def run(self): executor = PlaybookExecutor( playbooks=[self.playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords ) if executor._tqm: executor._tqm._stdout_callback = self.results_callback executor.run() executor._tqm.cleanup() return self.results_callback.output
def run(self): executor = PlaybookExecutor( playbooks=[self.playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, passwords={"conn_pass": self.passwords} ) context.CLIARGS = ImmutableDict(self.options) if executor._tqm: executor._tqm._stdout_callback = self.results_callback executor.run() executor._tqm.cleanup() return self.results_callback.output
def pbexe(userid,serial,host,module,apppath,yaml,url=None): variable_manager = VariableManager() loader = DataLoader() hostfile = '/ansible/hosts' inventory = Inventory(loader=loader, variable_manager=variable_manager,host_list='/ansible/hosts') playbook_path = yaml if not os.path.exists(playbook_path): print playbook_path print '[INFO] The playbook does not exist' sys.exit() Options = namedtuple('Options', ['listtags', 'listtasks', 'listhosts', 'syntax', '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']) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_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=None, become_user='******', verbosity=None, check=False) variable_manager.extra_vars = { 'host': host, 'module': module, 'tomcat_root': apppath, 'url': url } # This can accomodate various other command line arguments.` passwords = {} cb = CallbackModule(serial) # cb = default.CallbackModule() pbex = PlaybookExecutor( playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) pbex._tqm._stdout_callback = cb results = pbex.run() return results
def run(self,mission_id,role_name,exe_group): ''' create play with tasks actually run it ''' tqm = None try: retry_path = '/etc/ansible/main.yml' inventory_path = [retry_path] self.results_callback = ResultCallback() extra_vars = {} extra_vars['host_list'] = exe_group extra_vars['role_name'] = role_name extra_vars['run_id'] = mission_id self.variable_manager.extra_vars = extra_vars pbex = PlaybookExecutor( playbooks=inventory_path, inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) pbex._tqm._stdout_callback = self.results_callback result = pbex.run() finally: if tqm is not None: tqm.cleanup()
def pbexe(sid,war,mode): variable_manager = VariableManager() loader = DataLoader() # inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[]) inventory = Inventory(loader=loader, variable_manager=variable_manager) playbook_path = '/etc/ansible/yml/'+sid+'.yml' if not os.path.exists(playbook_path): print playbook_path print '[INFO] The playbook does not exist' sys.exit() Options = namedtuple('Options', ['listtags', 'listtasks', 'listhosts', 'syntax', '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']) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_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=None, become_user='******', verbosity=None, check=False) variable_manager.extra_vars = {'war': war,'mode': mode} # This can accomodate various other command line arguments.` passwords = {} #cb = ResultCallback() # cb = default.CallbackModule() pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) # pbex._tqm._stdout_callback = cb op=sys.stdout filename='/var/log/ansible/'+time.strftime('%Y%m%d%H%M%S')+'.log' opf=open(filename,'w') sys.stdout=opf results = pbex.run() sys.stdout=op opf.close print open(filename,'r').read() return filename
def runPlaybook(self): sys.stdout = open('Output-pythonAnsible','w') variable_manager = VariableManager() loader = DataLoader() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=self.host_list) #self.playbook_path #playbook_path = '/home/davis/Documents/Network-automation/cisco_xe.yml' if not os.path.exists(self.playbook_path): print '[INFO] The playbook does not exist' sys.exit() Options = namedtuple('Options', ['listtags', 'listtasks', 'listhosts', 'syntax', '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']) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_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=None, become_user='******', verbosity=None, check=False) #variable_manager.extra_vars = {'hosts': 'mywebserver'} # This can accomodate various other command line arguments.` passwords = {} pbex = PlaybookExecutor(playbooks=[self.playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) results = pbex.run() print "Output ::-",results return results
def run_playbook(): playbooks = ['/Users/CYu/Code/Python/python-demo/demo_ansible/playbook.yml'] # 这里是一个列表, 因此可以运行多个playbook variable_manager.extra_vars = {"ansible_ssh_user": "******", "ansible_ssh_pass": "******"} # 增加外部变量 pb = PlaybookExecutor(playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None) result = pb.run() print result
def test_init(self): """ Initialises and runs sample echo playbook for testing """ path = os.path.realpath(__file__).split("/")[0:-1] path = "/".join(path) playbook_path = path+'/playbooks/test_playbook.yml' options = self.Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_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=None, become_user='******', verbosity=3, check=False) self.variable_manager.extra_vars = {'hosts': 'mywebserver'} passwords = {} pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=options, passwords=passwords) results = pbex.run() assert_equal(results, 0)
def run_playbook(playbook_path, cluster): playbook_file = '{playbook_path}/provision/site.yml'.format( playbook_path=playbook_path, ) loader = DataLoader() variable_manager = VariableManager() inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list=get_host_list(playbook_path, cluster), ) file_handle, private_key_file = mkstemp(dir=playbook_path) with open(private_key_file, 'w') as key_file: key_file.write(cluster.sshKey) options = Options( inventory=inventory, remote_user=cluster.username, private_key_file=private_key_file, ) executor = PlaybookExecutor( playbooks=[playbook_file], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords={ 'become_pass': '******', }, ) return executor.run()
def run(self, log): if not self.playbook: code = 999 simple = 'playbook must exist' return code, simple, None if log: log_file.append(log) if not os.path.exists(self.playbook): code = 1000 results = 'not exists playbook: ' + self.playbook return code, results, None pbex = PlaybookExecutor(playbooks=[self.playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) try: code = pbex.run() except AnsibleParserError: code = 1001 results = 'syntax problems in ' + self.playbook return code, results, None stats = pbex._tqm._stats hosts = sorted(stats.processed.keys()) results = [{h: stats.summarize(h)} for h in hosts] if not results: code = 1002 results = 'no host executed in ' + self.playbook return code, results, None complex = '\n'.join(log_add) return code, results, complex
def run_playbook(self, filenames, fork=5): ''' :param filenames is list , :param fork is interge, default 5 ''' display = LogDisplay(logname=self.job_id) callback = CALLBACKMODULE[CALLBACK](display=display) # actually run it executor = PlaybookExecutor( playbooks=filenames, inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) executor._tqm._stdout_callback = callback executor.run() return display.get_log_json()
class PlayBook(object): def __init__(self, inventory='/etc/ansible/hosts', extra_vars=None, private_key_file=None): """ :param playbook: playbook.yml :param inventory: inventory file or script :type param extra_vars: dict :param private_key_file: ssh private key """ self.pbex = None self.options = Options(private_key_file=private_key_file, connection='smart', forks=10, timeout=10, verbosity=0, check=False, listtasks=False, listhosts=False, syntax=False, subset=None, module_path=None, become=None, become_user=None, become_method='sudo') # initialize needed objects self.loader = DataLoader() self.variable_manager = VariableManager() self.variable_manager.extra_vars = extra_vars self.variable_manager.options_vars = {'ansible_check_mode': self.options.check} self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=inventory) self.variable_manager.set_inventory(self.inventory) # Limits inventory results to a subset of inventory that matches a given pattern self.inventory._subset = self.options.subset def run_playbook(self, playbook): self.pbex = PlaybookExecutor(playbooks=[playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords={'conn_pass': None, 'become_pass': None}) self.pbex._tqm._stdout_callback = ResultCallback() return self.pbex.run() def run_play(self, play): pass
def run_playbook(self, host_list, playbook_path,extra_vars=None): """ run ansible palybook """ try: if self.redisKey:self.callback = PlayBookResultsCollectorToSave(self.redisKey,self.logId) else:self.callback = PlayBookResultsCollector() if extra_vars:self.variable_manager.extra_vars = extra_vars executor = PlaybookExecutor( playbooks=[playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) executor._tqm._stdout_callback = self.callback executor.run() except Exception as e: return False
def run(self): Options = namedtuple('Options', ['listtags', 'listtasks', 'listhosts', 'syntax', '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', 'diff']) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_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=None, become_user='******', verbosity=None, check=False, diff=False) #OPTION_FLAGS = ('connection', 'remote_user', 'private_key_file', 'verbosity', 'force_handlers', 'step', 'start_at_task', 'diff', # 'ssh_common_args', 'docker_extra_args', 'sftp_extra_args', 'scp_extra_args', 'ssh_extra_args') passwords = {} pbex = PlaybookExecutor(playbooks=[self.playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=options, passwords=passwords) result = pbex.run() return result
def run(self, playbooks, limit=''): """ param: `playbooks`: type string or list, example: ['/etc/ansible/test.yml'], '/etc/ansible/test1.yml, /etc/ansible/test2.yml' param: `limit`: eq --limit '' """ self._prepare_run() results = 0 if isinstance(playbooks, basestring): if ',' in playbooks: playbooks = [pl.strip() for pl in playbooks.split(',') if os.path.exists(pl)] else: playbooks = [playbooks.strip()] # --limit if limit: self.inventory.subset(limit) try: # create the playbook executor, which manages running the plays via a task queue manager pbex = PlaybookExecutor(playbooks=playbooks, inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) results = pbex.run() except Exception, ex: results = str(ex)
def call_ansible(yaml_file, become=False, tag=None): """Call Ansible with a playbook.""" variable_manager = VariableManager() loader = DataLoader() inventory = Inventory(loader, variable_manager) variable_manager.set_inventory(inventory) Options = namedtuple('Options', ['listtags', 'listtasks', 'listhosts', 'syntax', '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', 'tags']) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='', module_path='', forks=100, remote_user='', private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=become, become_method='sudo', become_user='******', verbosity=2, check=False, tags=tag) pbex = PlaybookExecutor(playbooks=[yaml_file], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords={}) logger.debug("Calling Ansible with yaml file: {}".format(yaml_file)) result = pbex.run() if result: logger.error("An error occured whilst executing the Ansible Playbook.")
def playbook(**kwargs): group_vars = kwargs['group_vars'] groups = kwargs['groups'] host_list = kwargs['host_list'] playbook_basedir = os.sep.join([ANSIBLE_PLAYBOOK_PATH, kwargs['playbook_basedir']]) playbooks = [] for pb in kwargs['playbooks']: playbooks.append(os.sep.join([playbook_basedir, pb])) job_id = kwargs['job_id'] loader = DataLoader() vars = VariableManager() # 指定inventory为一个目录,设置所有主机,包含group和host invertory = Inventory(loader, vars, host_list=host_list) invertory.set_playbook_basedir(playbook_basedir) for group_name, hosts in groups.items(): t_group = Group(group_name) for host in hosts: t_host = Host(host) t_group.add_host(t_host) invertory.add_group(t_group) vars.set_inventory(invertory) display = LogDisplay(logname=job_id) callback = CALLBACKMODULE[CALLBACK](display=display) 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', 'listhosts', 'listtags', 'listtasks', 'syntax']) 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, listhosts=None, listtags=None, listtasks=None, syntax=None) passwords = dict() pb_executor = PlaybookExecutor(playbooks, invertory, vars, loader, options, passwords) pb_executor._tqm._stdout_callback = callback pb_executor.run() return display.get_log_json()
def run(self, playbook, hosts, extra_vars={}, log='', with_output=False, use_root=False): self.result['playbook'] = playbook if not os.path.exists(playbook): result = { 'errno': -3, 'msg': 'not exists playbook: ' + playbook } else: AT = Ansi_Template() hosts, host_file = AT.make_host_template(hosts, use_root) extra_vars['ansible_hosts'] = ':'.join(hosts) inventory = InventoryManager(loader=self.loader, sources=[host_file]) variable_manager = VariableManager(loader=self.loader, inventory=inventory) variable_manager.extra_vars = extra_vars pbex = PlaybookExecutor(playbooks=[playbook], inventory=inventory, variable_manager=variable_manager, loader=self.loader, options=self.options, passwords={}) new_display = New_Display(log_file=log, debug=self.debug) results_callback = ResultCallback(new_display=new_display) pbex._tqm._stdout_callback = results_callback try: errno = pbex.run() result = results_callback.tasks result['errno'] = errno except AnsibleParserError as e: msg = 'syntax problems: {0}'.format(str(e)) result = { 'errno': -2, 'msg': msg } self.write_log(log, msg) print('syntax problems: {0}'.format(str(e))) if with_output: result['output'] = '\n'.join(new_display.log_add) if result['errno'] != -2 and not result['summary']: msg = 'no host executed' result = { 'errno': -1, 'msg': msg } self.write_log(log, msg) os.unlink(host_file) self.result.update(result) if self.result['errno'] != 0: self.result['msg'] = '无法配置完成,请联系管理员!' return self.result
def run_need_data(self): if not self.playbook: code = 999 simple = 'playbook must exist' return code, simple, None if not os.path.exists(self.playbook): code = 1000 complex = {'playbook': self.playbook, 'msg': self.playbook + ' playbook does not exist', 'flag': False} simple = 'playbook does not exist about ' + self.playbook return code, simple, complex pbex = PlaybookExecutor(playbooks=[self.playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) results_callback = ResultCallback() pbex._tqm._stdout_callback = results_callback try: code = pbex.run() except AnsibleParserError: code = 1001 simple = {'playbook': self.playbook, 'msg': 'syntax problems in ' + self.playbook, 'flag': False, 'msg_list': {'status': 'unknown', 'msg': 'syntax problems'}} complex = 'syntax problems in ' + self.playbook return code, simple, complex if results_callback.no_hosts: code = 1002 complex = 'no hosts matched in ' + self.playbook simple = {'executed': False, 'flag': False, 'playbook': self.playbook, 'msg': 'no_hosts', 'msg_list': {'status': 'unknown', 'msg': 'no_hosts'}} return code, simple, complex else: msg_list = results_callback.msg_list ok = results_callback.ok fail = results_callback.fail unreachable = results_callback.unreachable ok_all = list(ok.keys()) fail_all = list(fail.keys()) unreachable_hosts = list(unreachable.keys()) fail_hosts = list(set(fail_all) - set(unreachable_hosts)) ok_hosts = list(set(ok_all) - set(unreachable_hosts) - set(fail_hosts)) if code != 0: complex = {'playbook': results_callback.playbook, 'ok': ok, 'fail': fail, 'unreachable': unreachable, 'flag': False} simple = {'executed': True, 'flag': False, 'playbook': self.playbook, 'msg_list': msg_list, 'msg': {'playbook': self.playbook, 'ok_hosts': ok_hosts, 'fail': fail_hosts, 'unreachable': unreachable_hosts}} return code, simple, complex else: complex = {'playbook': results_callback.playbook, 'ok': ok, 'fail': fail, 'unreachable': unreachable, 'flag': True} simple = {'executed': True, 'flag': True, 'playbook': self.playbook, 'msg_list': msg_list, 'msg': {'playbook': self.playbook, 'ok_hosts': ok_hosts, 'fail': fail_hosts, 'unreachable': unreachable_hosts}} return code, simple, complex
class PlayBook(object): def __init__(self, playbook, inventory="inventory.py", extra_vars=None): self.playbook = "%s/%s" % (os.path.dirname(__file__), playbook) self.options = Options(inventory, extra_vars) self.loader = DataLoader() self.variable_manager = VariableManager() self.variable_manager.set_inventory(self.options.inventory) self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.options.inventory) self.pbex = PlaybookExecutor(playbooks=[self.playbook], inventory=self.inventory, loader=self.loader, variable_manager=self.variable_manager, options=self.options, passwords={'become_pass': None}) def run(self): self.pbex.run() stats = self.pbex._tqm._stats self.pbex._tqm.send_callback('human_log') return stats
def run_playbook(self, host_list, playbook_path,extra_vars=dict()): """ run ansible palybook """ try: if self.redisKey or self.logId:self.callback = PlayBookResultsCollectorToSave(self.redisKey,self.logId) else:self.callback = PlayBookResultsCollector() extra_vars['host'] = ','.join(host_list) self.variable_manager.extra_vars = extra_vars executor = PlaybookExecutor( playbooks=[playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, ) executor._tqm._stdout_callback = self.callback constants.HOST_KEY_CHECKING = False #关闭第一次使用ansible连接客户端是输入命令 constants.DEPRECATION_WARNINGS = False executor.run() except Exception as err: print err if self.redisKey:DsRedis.OpsAnsibleModel.lpush(self.redisKey,data=err) if self.logId:AnsibleSaveResult.Model.insert(self.logId, err) return False
def main(argv=sys.argv[1:]): # # initialize needed objects # variable_manager = VariableManager() loader = DataLoader() # https://pymotw.com/2/collections/namedtuple.html Options = namedtuple('Options', ['listtags', 'listtasks', 'listhosts', 'syntax', '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']) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='local', module_path=None, forks=100, remote_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=None, become_user='******', verbosity=None, check=False) passwords = {} inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='./ls_hosts') variable_manager.set_inventory(inventory) playbook_path = './ls.yml' if not os.path.exists(playbook_path): print '[INFO] The playbook does not exist' sys.exit() # This can accomodate various other command line arguments.` # variable_manager.extra_vars = {'hosts': 'mywebserver'} pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) # cb = ResultAccumulator() # pbex._tqm._stdout_callback = cb results = pbex.run() if results != 0: print "ERROR"
def run_playbook(self, playbook): options = self.Options(**self.options_args) vm = self.variable_manager vm.extra_vars = load_extra_vars(loader=self.loader, options=options) pbe = PlaybookExecutor( playbooks=[playbook], inventory=self.inventory, variable_manager=vm, loader=self.loader, options=options, passwords=dict(conn_pass='******'), ) res = pbe.run() self._run_vars = vm.get_vars(self.loader) return res
def run(self): super(PlaybookCLI, self).run() # Note: slightly wrong, this is written so that implicit localhost # Manage passwords sshpass = None becomepass = None vault_pass = None passwords = {} # don't deal with privilege escalation or passwords when we don't need to if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax: self.normalize_become_options() (sshpass, becomepass) = self.ask_passwords() passwords = {'conn_pass': sshpass, 'become_pass': becomepass} if self.options.vault_password_file: # read vault_pass from a file vault_pass = CLI.read_vault_password_file( self.options.vault_password_file) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords(ask_vault_pass=True, ask_new_vault_pass=False, confirm_new=False)[0] loader = DataLoader(vault_password=vault_pass) # FIXME: this should be moved inside the playbook executor code only_tags = self.options.tags.split(",") skip_tags = self.options.skip_tags if self.options.skip_tags is not None: skip_tags = self.options.skip_tags.split(",") # initial error check, to make sure all specified playbooks are accessible # before we start running anything through the playbook executor for playbook in self.args: if not os.path.exists(playbook): raise AnsibleError("the playbook: %s could not be found" % playbook) if not (os.path.isfile(playbook) or stat.S_ISFIFO(os.stat(playbook).st_mode)): raise AnsibleError( "the playbook: %s does not appear to be a file" % playbook) # create the variable manager, which will be shared throughout # the code, ensuring a consistent view of global variables variable_manager = VariableManager() variable_manager.extra_vars = load_extra_vars(loader=loader, options=self.options) # create the inventory, and filter it based on the subset specified (if any) inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=self.options.inventory) variable_manager.set_inventory(inventory) # (which is not returned in list_hosts()) is taken into account for # warning if inventory is empty. But it can't be taken into account for # checking if limit doesn't match any hosts. Instead we don't worry about # limit if only implicit localhost was in inventory to start with. # # Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts()) no_hosts = False if len(inventory.list_hosts()) == 0: # Empty inventory self.display.warning( "provided hosts list is empty, only localhost is available") no_hosts = True inventory.subset(self.options.subset) if len(inventory.list_hosts()) == 0 and no_hosts is False: # Invalid limit raise AnsibleError("Specified --limit does not match any hosts") # create the playbook executor, which manages running the plays via a task queue manager pbex = PlaybookExecutor(playbooks=self.args, inventory=inventory, variable_manager=variable_manager, loader=loader, display=self.display, options=self.options, passwords=passwords) results = pbex.run() if isinstance(results, list): for p in results: self.display.display('\nplaybook: %s\n' % p['playbook']) for play in p['plays']: if self.options.listhosts: self.display.display("\n %s (%s): host count=%d" % (play['name'], play['pattern'], len(play['hosts']))) for host in play['hosts']: self.display.display(" %s" % host) if self.options.listtasks: #TODO: do we want to display block info? self.display.display("\n %s" % (play['name'])) for task in play['tasks']: self.display.display(" %s" % task) if self.options.listtags: #TODO: fix once we figure out block handling above self.display.display("\n %s: tags count=%d" % (play['name'], len(play['tags']))) for tag in play['tags']: self.display.display(" %s" % tag) return 0 else: return results
def ansible_playbook(playbook, verbose=2, settings=None, inventory="local_hosts"): """Wraps the 'ansible-playbook' CLI. :param playbook: the playbook to invoke :param verbose: Ansible verbosity level :param settings: dict with Ansible variables. :param inventory: the inventory file to use, default: local_hosts """ settings = settings or {} display = Display(verbosity=verbose) import __main__ as main setattr(main, "display", display) if not playbook: # TODO: remove all IRexceptions and change to regular Python exceptions raise exceptions.IRFileNotFoundException LOG.info("Executing Playbook: %s" % playbook) loader = DataLoader() # ------------------ Mocking ansible-playbook cli input ------------------ # These values were extracted from ansible-playbook runtime. # todo(yfried): decide which options are hardcoded and which should be # exposed to user hacked_options = {'subset': None, 'ask_pass': False, 'listtags': None, 'become_user': '******', 'sudo': False, 'private_key_file': None, 'syntax': None, 'skip_tags': None, 'diff': False, 'sftp_extra_args': '', 'check': False, 'force_handlers': False, 'remote_user': None, 'become_method': 'sudo', 'vault_password_file': None, 'listtasks': None, 'output_file': None, 'ask_su_pass': False, 'new_vault_password_file': None, 'listhosts': None, 'ssh_extra_args': '', 'tags': 'all', 'become_ask_pass': False, 'start_at_task': None, 'flush_cache': None, 'step': None, 'module_path': None, 'su_user': None, 'ask_sudo_pass': False, 'su': False, 'scp_extra_args': '', 'connection': 'smart', 'ask_vault_pass': False, 'timeout': 30, 'become': False, 'sudo_user': None, 'ssh_common_args': ''} module_path = CONF.get('defaults', 'modules') path_to_playbook = path.join(CONF.get('defaults', 'playbooks'), playbook) hacked_options.update( module_path=module_path, verbosity=verbose, forks=ansible.constants.DEFAULT_FORKS, remote_user=ansible.constants.DEFAULT_REMOTE_USER, private_key_file=ansible.constants.DEFAULT_PRIVATE_KEY_FILE, ) options = namedtuple('Options', hacked_options.keys())(**hacked_options) passwords = dict(vault_pass='******') variable_manager = VariableManager() variable_manager.extra_vars = settings inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=inventory) variable_manager.set_inventory(inventory) pbex = PlaybookExecutor(playbooks=[path_to_playbook], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) results = pbex.run() if results: raise exceptions.IRPlaybookFailedException(playbook)
def run_playbook(hosts, playbook, tags=[], private_key_file=private_key_file): # initialize needed objects loader = DataLoader() options = Options(connection='ssh', private_key_file=private_key_file, module_path='', forks=100, become=True, become_method='sudo', become_user='******', check=False, tags=tags) passwords = dict(vault_pass='') results_callback = ResultCallback() host_file = NamedTemporaryFile(delete=False) host_file.write(b'[servers]\n') for i, h in enumerate(hosts): print(i, " : ", h) host_file.write(bytes('{0} num={1}\n'.format(h, i), encoding='utf8')) host_file.close() # set inventory inventory = InventoryManager(loader=loader, sources=host_file.name) variable_manager = VariableManager(loader=loader, inventory=inventory) # setup playbook executor, before the run pbex = PlaybookExecutor(playbooks=[playbook], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) pbex._tqm._stdout_callback = results_callback # run playbook and get stats result = pbex.run() stats = pbex._tqm._stats outputs = { 0: 'deployment successful', 1: 'error occurred during deployment', 2: 'one or more hosts failed', 4: 'one or more hosts unreachable', 255: 'unknown error occurred during deployment' } run_success = True hosts = sorted(stats.processed.keys()) for h in hosts: t = stats.summarize(h) if t['unreachable'] > 0 or t['failures'] > 0: run_success = False os.remove(host_file.name) try: out = outputs[result] except KeyError: out = 'unrecognised error code' return result, out
def run_ansible(playbooks, inventory_path, extra_vars={}, tags=None, on_error_continue=False): variable_manager = VariableManager() loader = DataLoader() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=inventory_path) variable_manager.set_inventory(inventory) if extra_vars: variable_manager.extra_vars = extra_vars passwords = {} # NOTE(msimonin): The ansible api is "low level" in the # sense that we are redefining here all the default values # that are usually enforce by ansible called from the cli Options = namedtuple('Options', ['listtags', 'listtasks', 'listhosts', 'syntax', 'connection', 'module_path', 'forks', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'remote_user', 'verbosity', 'check', 'tags', 'pipelining']) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method='sudo', become_user='******', remote_user=None, verbosity=2, check=False, tags=tags, pipelining=True) for path in playbooks: logging.info("Running playbook %s with vars:\n%s" % (path, extra_vars)) pbex = PlaybookExecutor( playbooks=[path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords ) code = pbex.run() stats = pbex._tqm._stats hosts = stats.processed.keys() result = [{h: stats.summarize(h)} for h in hosts] results = {'code': code, 'result': result, 'playbook': path} print(results) failed_hosts = [] unreachable_hosts = [] for h in hosts: t = stats.summarize(h) if t['failures'] > 0: failed_hosts.append(h) if t['unreachable'] > 0: unreachable_hosts.append(h) if len(failed_hosts) > 0: logging.error("Failed hosts: %s" % failed_hosts) if not on_error_continue: raise EnosFailedHostsError(failed_hosts) if len(unreachable_hosts) > 0: logging.error("Unreachable hosts: %s" % unreachable_hosts) if not on_error_continue: raise EnosUnreachableHostsError(unreachable_hosts)
def apply_playbook(playbook_path, hosts_inv, host_user, ssh_priv_key_file_path, variables=None, proxy_setting=None): """ Executes an Ansible playbook to the given host :param playbook_path: the (relative) path to the Ansible playbook :param hosts_inv: a list of hostnames/ip addresses to which to apply the Ansible playbook :param host_user: A user for the host instances (must be a password-less sudo user if playbook has "sudo: yes" :param ssh_priv_key_file_path: the file location of the ssh key :param variables: a dictionary containing any substitution variables needed by the Jinga 2 templates :param proxy_setting: string containing host:port of the proxy server in use :return: the results """ if not os.path.isfile(playbook_path): raise Exception('Requested playbook not found - ' + playbook_path) if not os.path.isfile(ssh_priv_key_file_path): raise Exception('Requested private SSH key not found - ' + ssh_priv_key_file_path) import ansible.constants ansible.constants.HOST_KEY_CHECKING = False variable_manager = VariableManager() if variables: variable_manager.extra_vars = variables loader = DataLoader() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=hosts_inv) variable_manager.set_inventory(inventory) loader = DataLoader() ssh_common_args = None ssh_extra_args = None ssh_connection = 'ssh' proxy_command = None if proxy_setting: tokens = re.split(':', proxy_setting) # TODO - Need to configure the proxy settings to avoid adding entries into the host's ~/.ssh/config file options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', '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', 'host_key_checking', 'transport', 'proxy_command' ]) ansible_opts = options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection=ssh_connection, module_path=None, forks=100, remote_user=host_user, private_key_file=ssh_priv_key_file_path, ssh_common_args=ssh_common_args, ssh_extra_args=ssh_extra_args, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user='******', verbosity=1111, check=False, host_key_checking=True, transport='paramiko', proxy_command=proxy_command) logger.debug('Setting up Ansible Playbook Executor') executor = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=ansible_opts, passwords=None) logger.debug('Executing Ansible Playbook - ' + playbook_path) retval = executor.run() if retval != 0: logger.error('Playbook application failed [' + playbook_path + '] with return value of - ' + str(retval)) raise Exception('Playbook not applied - ' + playbook_path) return retval
def run_playbook(self, playbook_yml, group=None, script=None): """ 运行 playbook """ playbook = None try: with open(playbook_yml) as f: playbook_content = f.read() check, variable = check_ansible_variable(playbook_content) if check: data = '<code style="color: #FF0000">playbook 中包含非法 ansible 变量: [{}],禁止运行</code>'.format( variable) data2 = '\033[01;31mplaybook 中包含非法 ansible 变量: [{}],禁止运行\r\n\r\n\033[0m'.format( variable) delay = round(time.time() - self.results_callback.start_time, 6) self.results_callback.res.append( json.dumps([delay, 'o', data2])) message = dict() message['status'] = 0 message['message'] = data message = json.dumps(message) async_to_sync(channel_layer.group_send)(group, { "type": "send.message", "text": message, }) else: playbook = PlaybookExecutor( playbooks=[playbook_yml], inventory=self.dynamic_inventory, variable_manager=self.variable_manager, loader=self.loader, passwords=self.passwords, ) playbook._tqm._stdout_callback = self.results_callback playbook.run() except Exception as err: data = '<code style="color: #FF0000">{}</code>'.format(str(err)) data2 = '\033[01;31m{}\r\n\r\n\033[0m'.format( str(err).strip().replace('\n', '\r\n')) delay = round(time.time() - self.results_callback.start_time, 6) self.results_callback.res.append(json.dumps([delay, 'o', data2])) message = dict() message['status'] = 0 message['message'] = data message = json.dumps(message) async_to_sync(channel_layer.group_send)(group, { "type": "send.message", "text": message, }) finally: if group: message = dict() message['status'] = 0 message['message'] = '执行完毕...' message = json.dumps(message) async_to_sync(channel_layer.group_send)(group, { "type": "close.channel", "text": message, }) if self.results_callback.res: save_res(self.results_callback.res_file, self.results_callback.res) batchcmd_log( user=self.results_callback.user, hosts=self.results_callback.hosts, cmd=self.results_callback.playbook, detail=self.results_callback.res_file, address=self.results_callback.client, useragent=self.results_callback.user_agent, start_time=self.results_callback.start_time_django, type=4, script=script, ) if playbook._tqm is not None: playbook._tqm.cleanup()
def run_script(playbook_path, channel, inventory_sources=None, extra_arguments={}): Options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', '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', 'diff' ]) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_user='******', private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=False, become_method=None, become_user=None, verbosity=True, check=False, diff=False) if not os.path.exists(playbook_path): print '[INFO] The playbook does not exist' sys.exit() loader = DataLoader() variable_manager = VariableManager() inventory = Inventory(loader, variable_manager) variable_manager.extra_vars = extra_arguments # This can accomodate various other command line arguments.` passwords = {} pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) pbex.run() stats = pbex._tqm._stats hosts = sorted(stats.processed.keys()) run_success = True for h in hosts: t = stats.summarize(h) if t['unreachable'] > 0 or t['failures'] > 0: run_success = False send_message(channel, '```{}```'.format(str(t))) pbex._tqm.send_callback('notify_jira', channel) pbex._tqm.send_callback('notify_slack', channel) if run_success: send_message(channel, '```Execution is completed. Please check the result```')
become=False, become_method=None, become_user=None, remote_user=None, verbosity=None, check=False) playbook_path = 'test.yml' # modify here, change playbook variable_manager.extra_vars = { "args": "pong", } # modify here, This can accomodate various other command line arguments.` if not os.path.exists(playbook_path): print '[INFO] The playbook does not exist' sys.exit() passwords = {} pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) code = pbex.run() stats = pbex._tqm._stats hosts = sorted(stats.processed.keys()) result = [{h: stats.summarize(h)} for h in hosts] results = {'code': code, 'result': result, 'playbook': playbook_path} print(results)
class PlaybookRunner(object): """ The plabybook API. """ def __init__( self, hosts=None, # a list or dynamic-hosts, # default is /etc/ansible/hosts playbook_path=None, # * a playbook file forks=C.DEFAULT_FORKS, listtags=False, listtasks=False, listhosts=False, syntax=False, module_path=None, remote_user='******', timeout=C.DEFAULT_TIMEOUT, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=True, become_method=None, become_user="******", verbosity=None, extra_vars=None, connection_type="ssh", passwords=None, private_key_file=None, check=False): C.RETRY_FILES_ENABLED = False self.callbackmodule = CallbackModule() if playbook_path is None or not os.path.exists(playbook_path): raise AnsibleError("Not Found the playbook file: %s." % playbook_path) self.playbook_path = playbook_path self.inventory = MyInventory(host_list=hosts) self.loader = DataLoader() self.variable_manager = VariableManager(self.loader, self.inventory) self.passwords = passwords or {} self.options = Options(listtags=listtags, listtasks=listtasks, listhosts=listhosts, syntax=syntax, timeout=timeout, connection=connection_type, module_path=module_path, forks=forks, remote_user=remote_user, private_key_file=private_key_file, ssh_common_args=ssh_common_args or "", ssh_extra_args=ssh_extra_args or "", sftp_extra_args=sftp_extra_args, scp_extra_args=scp_extra_args, become=become, become_method=become_method, become_user=become_user, verbosity=verbosity, extra_vars=extra_vars or [], check=check, diff=False) self.variable_manager.extra_vars = load_extra_vars( loader=self.loader, options=self.options) self.variable_manager.options_vars = load_options_vars( self.options, "") self.variable_manager.set_inventory(self.inventory) self.runner = PlaybookExecutor(playbooks=[self.playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) if self.runner._tqm: self.runner._tqm._stdout_callback = self.callbackmodule def run(self): if not self.inventory.list_hosts("all"): raise AnsibleError("Inventory is empty.") self.runner.run() return self.callbackmodule.output
def run(self): super(PlaybookCLI, self).run() # Note: slightly wrong, this is written so that implicit localhost # manages passwords sshpass = None becomepass = None passwords = {} # initial error check, to make sure all specified playbooks are accessible # before we start running anything through the playbook executor for playbook in context.CLIARGS['args']: if not os.path.exists(playbook): raise AnsibleError("the playbook: %s could not be found" % playbook) if not (os.path.isfile(playbook) or stat.S_ISFIFO(os.stat(playbook).st_mode)): raise AnsibleError( "the playbook: %s does not appear to be a file" % playbook) # don't deal with privilege escalation or passwords when we don't need to if not (context.CLIARGS['listhosts'] or context.CLIARGS['listtasks'] or context.CLIARGS['listtags'] or context.CLIARGS['syntax']): (sshpass, becomepass) = self.ask_passwords() passwords = {'conn_pass': sshpass, 'become_pass': becomepass} loader, inventory, variable_manager = self._play_prereqs() # (which is not returned in list_hosts()) is taken into account for # warning if inventory is empty. But it can't be taken into account for # checking if limit doesn't match any hosts. Instead we don't worry about # limit if only implicit localhost was in inventory to start with. # # Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts()) hosts = self.get_host_list(inventory, context.CLIARGS['subset']) # flush fact cache if requested if context.CLIARGS['flush_cache']: self._flush_cache(inventory, variable_manager) # create the playbook executor, which manages running the plays via a task queue manager pbex = PlaybookExecutor(playbooks=context.CLIARGS['args'], inventory=inventory, variable_manager=variable_manager, loader=loader, passwords=passwords) results = pbex.run() if isinstance(results, list): for p in results: display.display('\nplaybook: %s' % p['playbook']) for idx, play in enumerate(p['plays']): if play._included_path is not None: loader.set_basedir(play._included_path) else: pb_dir = os.path.realpath( os.path.dirname(p['playbook'])) loader.set_basedir(pb_dir) msg = "\n play #%d (%s): %s" % (idx + 1, ','.join( play.hosts), play.name) mytags = set(play.tags) msg += '\tTAGS: [%s]' % (','.join(mytags)) if context.CLIARGS['listhosts']: playhosts = set(inventory.get_hosts(play.hosts)) msg += "\n pattern: %s\n hosts (%d):" % ( play.hosts, len(playhosts)) for host in playhosts: msg += "\n %s" % host display.display(msg) all_tags = set() if context.CLIARGS['listtags'] or context.CLIARGS[ 'listtasks']: taskmsg = '' if context.CLIARGS['listtasks']: taskmsg = ' tasks:\n' def _process_block(b): taskmsg = '' for task in b.block: if isinstance(task, Block): taskmsg += _process_block(task) else: if task.action == 'meta': continue all_tags.update(task.tags) if context.CLIARGS['listtasks']: cur_tags = list( mytags.union(set(task.tags))) cur_tags.sort() if task.name: taskmsg += " %s" % task.get_name( ) else: taskmsg += " %s" % task.action taskmsg += "\tTAGS: [%s]\n" % ', '.join( cur_tags) return taskmsg all_vars = variable_manager.get_vars(play=play) play_context = PlayContext(play=play) for block in play.compile(): block = block.filter_tagged_tasks( play_context, all_vars) if not block.has_tasks(): continue taskmsg += _process_block(block) if context.CLIARGS['listtags']: cur_tags = list(mytags.union(all_tags)) cur_tags.sort() taskmsg += " TASK TAGS: [%s]\n" % ', '.join( cur_tags) display.display(taskmsg) return 0 else: return results
class PlayBookRunner(object): """ 用于执行AnsiblePlaybook的接口.简化Playbook对象的使用. """ Options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', 'connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'timeout', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check', 'extra_vars']) def __init__(self, hosts=None, playbook_path=None, forks=C.DEFAULT_FORKS, listtags=False, listtasks=False, listhosts=False, syntax=False, module_path=None, remote_user='******', timeout=C.DEFAULT_TIMEOUT, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=True, become_method=None, become_user="******", verbosity=None, extra_vars=None, connection_type="ssh", passwords=None, private_key_file=None, check=False): C.RETRY_FILES_ENABLED = False self.callbackmodule = PlaybookResultCallBack() if playbook_path is None or not os.path.exists(playbook_path): raise AnsibleError( "Not Found the playbook file: %s." % playbook_path) self.playbook_path = playbook_path self.loader = DataLoader() self.variable_manager = VariableManager() self.passwords = passwords or {} self.inventory = JMSInventory(hosts) self.options = self.Options( listtags=listtags, listtasks=listtasks, listhosts=listhosts, syntax=syntax, timeout=timeout, connection=connection_type, module_path=module_path, forks=forks, remote_user=remote_user, private_key_file=private_key_file, ssh_common_args=ssh_common_args or "", ssh_extra_args=ssh_extra_args or "", sftp_extra_args=sftp_extra_args, scp_extra_args=scp_extra_args, become=become, become_method=become_method, become_user=become_user, verbosity=verbosity, extra_vars=extra_vars or [], check=check ) self.variable_manager.extra_vars = load_extra_vars(loader=self.loader, options=self.options) self.variable_manager.options_vars = load_options_vars(self.options) self.variable_manager.set_inventory(self.inventory) # 初始化playbook的executor self.runner = PlaybookExecutor( playbooks=[self.playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) if self.runner._tqm: self.runner._tqm._stdout_callback = self.callbackmodule def run(self): if not self.inventory.list_hosts('all'): raise AnsibleError('Inventory is empty') self.runner.run() self.runner._tqm.cleanup() return self.callbackmodule.output
''' try: playbook_path = 'test.yml' # modify here, change playbook #self.variable_manager.extra_vars=extra_vars if not os.path.exists(playbook_path): sys.exit('[INFO] The playbook does not exist') passwords = {} executor = PlaybookExecutor( playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) # executor._tqm._stdout_callback = self.results_callback # code = executor.run() # stats = executor._tqm._stats # hosts = sorted(stats) code = executor.run() stats = executor._tqm._stats hosts = sorted(stats.processed.keys()) result = [{h: stats.summarize(h)} for h in hosts] results = {'code': code, 'result': result, 'playbook': playbook_path} except Exception as e: msg = traceback.format_exc() sys.exit(msg)
def execute_playbook(self, playbook_info): output = None try: loader = DataLoader() inventory = InventoryManager(loader=loader, sources=['localhost']) variable_manager = VariableManager(loader=loader, inventory=inventory) Options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', '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', 'diff' ]) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, 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, diff=False) variable_manager.extra_vars = playbook_info['extra_vars'] pbex = PlaybookExecutor(playbooks=[playbook_info['uri']], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None) ret_val = pbex.run() if ret_val != 0: msg = MsgBundle.getMessage( MsgBundle.PLAYBOOK_RETURN_WITH_ERROR) raise Exception(msg) output = self.get_plugin_output(pbex) if output is None or output.get('status') is None: msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_OUTPUT_MISSING) raise Exception(msg) if output.get('status').lower() == "failure": msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_STATUS_FAILED) raise Exception(msg) return output except Exception as exp: msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_EXECUTE_ERROR, playbook_uri=playbook_info['uri'], execution_id=playbook_info['extra_vars'] ['playbook_input']['job_execution_id'], exc_msg=repr(exp)) if exp.message: msg = msg + "\n" + exp.message JM_LOGGER.error(msg) # after handling exception, write an END # to stop listening to the file if created unique_pb_id = playbook_info['extra_vars']['playbook_input'][ 'unique_pb_id'] exec_id = playbook_info['extra_vars']['playbook_input'][ 'job_execution_id'] line_in_file = "" if output != None: line_in_file = unique_pb_id + 'PLAYBOOK_OUTPUT##'\ + json.dumps(output) + 'PLAYBOOK_OUTPUT##'\ + '\n' with open("/tmp/" + exec_id, "a") as f: f.write(line_in_file + unique_pb_id + 'END' + '\n') sys.exit(msg)
"diff": False, "inventory": ["./hosts"], "listhosts": None, "subset": "server_a", "extra_vars": ["targetHost=server_b", "sourseHost=server_a"], "ask_vault_pass": False, "vault_password_files": [], "vault_ids": [], "forks": 5, "module_path": None, "listtasks": None, "listtags": None, "step": None, "start_at_task": None, }) context._init_global_context(options) loader, inventory, variable_manager = CLI._play_prereqs() CLI.get_host_list(inventory, context.CLIARGS["subset"]) pbex = PlaybookExecutor(playbooks=["./playbooks/roles/common/tasks/main.yml"], inventory=inventory, variable_manager=variable_manager, loader=loader, passwords=dict(conn_pass="******", become_pass="******")) result_callback = ResultCallback() pbex._tqm._stdout_callback = result_callback result_id = pbex.run() result = result_callback.getResult()
def run_need_data(self): if not os.path.exists(self.playbook): code = 1000 complex = { 'playbook': self.playbook, 'msg': self.playbook + ' playbook does not exist', 'flag': False } simple = 'playbook does not exist about ' + self.playbook return code, simple, complex pbex = PlaybookExecutor(playbooks=[self.playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) results_callback = ResultCallback() pbex._tqm._stdout_callback = results_callback try: code = pbex.run() except AnsibleParserError: code = 1001 complex = { 'playbook': self.playbook, 'msg': 'syntax problems in ' + self.playbook, 'flag': False } simple = 'syntax problems in ' + self.playbook return code, simple, complex if results_callback.no_hosts: code = 1002 complex = 'no hosts matched in ' + self.playbook simple = { 'executed': False, 'flag': False, 'playbook': self.playbook, 'msg': 'no_hosts' } return code, simple, complex else: ok = json.loads(results_callback.ok) fail = json.loads(results_callback.fail) unreachable = json.loads(results_callback.unreachable) if code != 0: complex = { 'playbook': results_callback.playbook, 'ok': ok, 'fail': fail, 'unreachable': unreachable, 'flag': False } simple = { 'executed': True, 'flag': False, 'playbook': self.playbook, 'msg': { 'playbook': self.playbook, 'ok_hosts': ok.keys(), 'fail': fail.keys(), 'unreachable': unreachable.keys() } } return code, simple, complex else: complex = { 'playbook': results_callback.playbook, 'ok': ok, 'fail': fail, 'unreachable': unreachable, 'flag': True } simple = { 'executed': True, 'flag': True, 'playbook': self.playbook, 'msg': { 'playbook': self.playbook, 'ok_hosts': ok.keys(), 'fail': fail.keys(), 'unreachable': unreachable.keys() } } return code, simple, complex
def ansiblex_deploy(vars1="1", vars2="2", vars3="3", vars4="4", vars5="5", vars6="6", vars7="7", vars8="8", vars9="9", vars10="10", vars11="11", vars12="12", vars13="13", vars14="14", vars15="15", vars16="16"): one_var = vars1 two_var = vars2 three_var = vars3 four_var = vars4 five_var = vars5 six_var = vars6 seven_var = vars7 eight_var = vars8 nine_var = vars9 ten_var = vars10 eleven_var = vars11 twelve_var = vars12 thirteen_var = vars13 fourteen_var = vars14 fifteen_var = vars15 sixteen_var = vars16 variable_manager = VariableManager() loader = DataLoader() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=one_var) Options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', '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' ]) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=30, remote_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=None, become_user='******', verbosity=None, check=False) variable_manager.extra_vars = { 'three_var': three_var, 'four_var': four_var, 'five_var': five_var, 'six_var': six_var, 'seven_var': seven_var, 'eight_var': eight_var, 'nine_var': nine_var, 'ten_var': ten_var, 'eleven_var': eleven_var, 'twelve_var': twelve_var, 'thirteen_var': thirteen_var, 'fourteen_var': fourteen_var, 'fifteen_var': fifteen_var, 'sixteen_var': sixteen_var } passwords = {} pbex = PlaybookExecutor(playbooks=[two_var], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) callback = CallbackModule() pbex._tqm._stdout_callback = callback return_code = pbex.run() results = callback.results return results
"failed": t['failures'] } callback = PlayBookResultsCollector() #PlaybookExecutor 执行playbook passwords = dict() playbook = PlaybookExecutor( playbooks=['f1.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) playbook._tqm._stdout_callback = callback playbook.run() results_raw = { 'skipped': {}, 'failed': {}, 'ok': {}, "status": {}, 'unreachable': {}, "changed": {} } for host, result in callback.task_ok.items(): results_raw['ok'][host] = result print results_raw
def deploy(self): templatedb = {} if self._templatename: with open('/var/www/webvirtmgr/ansiblefunc/playbook/template', 'r') as template: lines = template.readlines() for line in lines: templatedb[line.split(',')[0]] = line.split(',')[1] with open( '/var/www/webvirtmgr/ansiblefunc/playbook/deploy_templ.yml', 'r') as source: lines = source.readlines() with open( '/var/www/webvirtmgr/ansiblefunc/playbook/deploy.yml.do', 'w') as dest: for line in lines: dest.write( line.replace('!host!', self._supervisorip)) else: with open('/var/www/webvirtmgr/ansiblefunc/playbook/deploy.yml', 'r') as source: lines = source.readlines() with open( '/var/www/webvirtmgr/ansiblefunc/playbook/deploy.yml.do', 'w') as dest: for line in lines: dest.write(line.replace('!host!', self._supervisorip)) variable_manager = VariableManager() loader = DataLoader() supervisor = host.Host(name=self._supervisorip, port=None) variable_manager.set_host_variable(supervisor, 'vmname', self._vmname) variable_manager.set_host_variable(supervisor, 'rootpass', self._rootpass) variable_manager.set_host_variable(supervisor, 'memory', self._memory) variable_manager.set_host_variable(supervisor, 'cpu', self._cpu) variable_manager.set_host_variable(supervisor, 'rootimage', self._rootimage) variable_manager.set_host_variable(supervisor, 'network', self._network) variable_manager.set_host_variable(supervisor, 'inittype', self._inittype) variable_manager.set_host_variable(supervisor, 'images', self._images) if not self._templatename: variable_manager.set_host_variable(supervisor, 'installedpackage', self._installedpackage) else: variable_manager.set_host_variable( supervisor, 'template', templatedb[self._templatename].strip()) inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list='/var/www/webvirtmgr/ansiblefunc/playbook/hosts') if not os.path.exists(self._playbook): print 'playbook not found' sys.exit() options_tuple = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', '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' ]) options = options_tuple(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_user='******', private_key_file=self._keyfile, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=True, become_method=None, become_user='******', verbosity=None, check=False) variable_manager.extra_vars = {'hosts': self._supervisorip} pbex = PlaybookExecutor(playbooks=[self._playbook], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords={}) results = pbex.run() print results
def runner_playbook(self, playbooks, inventory): """ 运行playbook :param playbooks: playbook的路径 :param inventory: :return: """ if isinstance(playbooks, str): playbooks = [playbooks] Options = namedtuple( "Options", [ "connection", "module_path", "forks", "private_key_file", "become", "become_method", "become_user", "check", "diff", "listhosts", "listtasks", "listtags", "syntax", "verbosity", ], ) options = Options( connection="smart", module_path=None, forks=10, private_key_file=self.private_key_file, # 你的私钥 become=True, become_method="sudo", become_user="******", check=False, diff=False, listhosts=None, listtasks=None, listtags=None, syntax=None, verbosity=1, # >= 4 时展示详细调试信息 ) loader = DataLoader() passwords = dict(vault_pass="******") inventory_obj = InventoryManager(loader=loader, sources=inventory) variable_manager = VariableManager(loader=loader, inventory=inventory_obj) executor = PlaybookExecutor( playbooks=playbooks, inventory=inventory_obj, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) if self.results_callback: executor._tqm._callback_plugins.append(self.results_callback) executor._tqm._gather_facts = False result_code = executor.run() result_raw = {"success": {}, "failed": {}, "unreachable": {}} for host, result in self.results_callback.host_ok.items(): result_raw['success'][host] = json.dumps(result._result) for host, result in self.results_callback.host_failed.items(): result_raw['failed'][host] = result._result['msg'] for host, result in self.results_callback.host_unreachable.items(): result_raw['unreachable'][host] = result._result['msg'] # result_code 等于0代表任务全部运行成功 return result_code, result_raw
def run(self): super(PlaybookCLI, self).run() # Note: slightly wrong, this is written so that implicit localhost # Manage passwords sshpass = None becomepass = None b_vault_pass = None passwords = {} # initial error check, to make sure all specified playbooks are accessible # before we start running anything through the playbook executor for playbook in self.args: if not os.path.exists(playbook): raise AnsibleError("the playbook: %s could not be found" % playbook) if not (os.path.isfile(playbook) or stat.S_ISFIFO(os.stat(playbook).st_mode)): raise AnsibleError( "the playbook: %s does not appear to be a file" % playbook) # don't deal with privilege escalation or passwords when we don't need to if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax: self.normalize_become_options() (sshpass, becomepass) = self.ask_passwords() passwords = {'conn_pass': sshpass, 'become_pass': becomepass} loader = DataLoader() if self.options.vault_password_file: # read vault_pass from a file b_vault_pass = CLI.read_vault_password_file( self.options.vault_password_file, loader=loader) loader.set_vault_password(b_vault_pass) elif self.options.ask_vault_pass: b_vault_pass = self.ask_vault_passwords() loader.set_vault_password(b_vault_pass) # create the variable manager, which will be shared throughout # the code, ensuring a consistent view of global variables variable_manager = VariableManager() variable_manager.extra_vars = load_extra_vars(loader=loader, options=self.options) variable_manager.options_vars = load_options_vars(self.options) # create the inventory, and filter it based on the subset specified (if any) inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=self.options.inventory) variable_manager.set_inventory(inventory) # (which is not returned in list_hosts()) is taken into account for # warning if inventory is empty. But it can't be taken into account for # checking if limit doesn't match any hosts. Instead we don't worry about # limit if only implicit localhost was in inventory to start with. # # Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts()) no_hosts = False if len(inventory.list_hosts()) == 0: # Empty inventory display.warning( "provided hosts list is empty, only localhost is available") no_hosts = True inventory.subset(self.options.subset) if len(inventory.list_hosts()) == 0 and no_hosts is False: # Invalid limit raise AnsibleError("Specified --limit does not match any hosts") # flush fact cache if requested if self.options.flush_cache: self._flush_cache(inventory, variable_manager) # create the playbook executor, which manages running the plays via a task queue manager pbex = PlaybookExecutor(playbooks=self.args, inventory=inventory, variable_manager=variable_manager, loader=loader, options=self.options, passwords=passwords) results = pbex.run() if isinstance(results, list): for p in results: display.display('\nplaybook: %s' % p['playbook']) for idx, play in enumerate(p['plays']): if play._included_path is not None: loader.set_basedir(play._included_path) else: pb_dir = os.path.realpath( os.path.dirname(p['playbook'])) loader.set_basedir(pb_dir) msg = "\n play #%d (%s): %s" % (idx + 1, ','.join( play.hosts), play.name) mytags = set(play.tags) msg += '\tTAGS: [%s]' % (','.join(mytags)) if self.options.listhosts: playhosts = set(inventory.get_hosts(play.hosts)) msg += "\n pattern: %s\n hosts (%d):" % ( play.hosts, len(playhosts)) for host in playhosts: msg += "\n %s" % host display.display(msg) all_tags = set() if self.options.listtags or self.options.listtasks: taskmsg = '' if self.options.listtasks: taskmsg = ' tasks:\n' def _process_block(b): taskmsg = '' for task in b.block: if isinstance(task, Block): taskmsg += _process_block(task) else: if task.action == 'meta': continue all_tags.update(task.tags) if self.options.listtasks: cur_tags = list( mytags.union(set(task.tags))) cur_tags.sort() if task.name: taskmsg += " %s" % task.get_name( ) else: taskmsg += " %s" % task.action taskmsg += "\tTAGS: [%s]\n" % ', '.join( cur_tags) return taskmsg all_vars = variable_manager.get_vars(loader=loader, play=play) play_context = PlayContext(play=play, options=self.options) for block in play.compile(): block = block.filter_tagged_tasks( play_context, all_vars) if not block.has_tasks(): continue taskmsg += _process_block(block) if self.options.listtags: cur_tags = list(mytags.union(all_tags)) cur_tags.sort() taskmsg += " TASK TAGS: [%s]\n" % ', '.join( cur_tags) display.display(taskmsg) return 0 else: return results
def install_dns_playbook(): content = request.get_json(force=True) tagsexc = content['tagsexc'] ipmanage = content['ipmanage'] keyfile = content['fileprivatekey'] play = content['play'] passwd = content['passwd'] user = content['user'] inventory = content['inventory'] logging.info('runnig ansible-playbook ' + tagsexc + ' ' + ipmanage) file = open(inventory, 'w') file.write('[hostexec]\n') file.write(ipmanage) file.close() loader = DataLoader() if passwd: context.CLIARGS = ImmutableDict( tags={tagsexc}, listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=10, 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=True, check=False, start_at_task=None, extra_vars={ 'ansible_ssh_user='******'', 'ansible_ssh_pass='******'', 'ansible_become_pass='******'' }) else: context.CLIARGS = ImmutableDict( tags={tagsexc}, listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=10, 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=True, check=False, start_at_task=None, extra_vars={ 'ansible_ssh_user='******'', 'ansible_ssh_private_key_file=' + keyfile + '' }) inventory = InventoryManager(loader=loader, sources=(inventory)) variable_manager = VariableManager( loader=loader, inventory=inventory, version_info=CLI.version_info(gitinfo=False)) pbex = PlaybookExecutor(playbooks=[play], inventory=inventory, variable_manager=variable_manager, loader=loader, passwords={}) results = pbex.run() db.session.commit() return jsonify({'status': results})
def run(self): super(PlaybookCLI, self).run() # Note: slightly wrong, this is written so that implicit localhost # Manage passwords sshpass = None becomepass = None vault_pass = None passwords = {} # don't deal with privilege escalation or passwords when we don't need to if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax: self.normalize_become_options() (sshpass, becomepass) = self.ask_passwords() passwords = {'conn_pass': sshpass, 'become_pass': becomepass} if self.options.vault_password_file: # read vault_pass from a file vault_pass = CLI.read_vault_password_file( self.options.vault_password_file) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords(ask_vault_pass=True, ask_new_vault_pass=False, confirm_new=False)[0] loader = DataLoader(vault_password=vault_pass) # initial error check, to make sure all specified playbooks are accessible # before we start running anything through the playbook executor for playbook in self.args: if not os.path.exists(playbook): raise AnsibleError("the playbook: %s could not be found" % playbook) if not (os.path.isfile(playbook) or stat.S_ISFIFO(os.stat(playbook).st_mode)): raise AnsibleError( "the playbook: %s does not appear to be a file" % playbook) # create the variable manager, which will be shared throughout # the code, ensuring a consistent view of global variables variable_manager = VariableManager() variable_manager.extra_vars = load_extra_vars(loader=loader, options=self.options) # create the inventory, and filter it based on the subset specified (if any) inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=self.options.inventory) variable_manager.set_inventory(inventory) # (which is not returned in list_hosts()) is taken into account for # warning if inventory is empty. But it can't be taken into account for # checking if limit doesn't match any hosts. Instead we don't worry about # limit if only implicit localhost was in inventory to start with. # # Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts()) no_hosts = False if len(inventory.list_hosts()) == 0: # Empty inventory self.display.warning( "provided hosts list is empty, only localhost is available") no_hosts = True inventory.subset(self.options.subset) if len(inventory.list_hosts()) == 0 and no_hosts is False: # Invalid limit raise AnsibleError("Specified --limit does not match any hosts") # create the playbook executor, which manages running the plays via a task queue manager pbex = PlaybookExecutor(playbooks=self.args, inventory=inventory, variable_manager=variable_manager, loader=loader, display=self.display, options=self.options, passwords=passwords) results = pbex.run() if isinstance(results, list): for p in results: self.display.display('\nplaybook: %s' % p['playbook']) i = 1 for play in p['plays']: if play.name: playname = play.name else: playname = '#' + str(i) msg = "\n PLAY: %s" % (playname) mytags = set() if self.options.listtags and play.tags: mytags = mytags.union(set(play.tags)) msg += ' TAGS: [%s]' % (','.join(mytags)) if self.options.listhosts: playhosts = set(inventory.get_hosts(play.hosts)) msg += "\n pattern: %s\n hosts (%d):" % ( play.hosts, len(playhosts)) for host in playhosts: msg += "\n %s" % host self.display.display(msg) if self.options.listtags or self.options.listtasks: taskmsg = ' tasks:' for block in play.compile(): if not block.has_tasks(): continue j = 1 for task in block.block: taskmsg += "\n %s" % task if self.options.listtags and task.tags: taskmsg += " TAGS: [%s]" % ','.join( mytags.union(set(task.tags))) j = j + 1 self.display.display(taskmsg) i = i + 1 return 0 else: return results
options = Options(connection='smart', remote_user=None, ask_pass=None, sudo_user=None, forks=5, sudo=None, ask_sudo_pass=False, verbosity=5, module_path=None, become=None, become_method=None, become_user=None, check=False, diff=False, listhosts=None, listtasks=None, listtags=None, syntax=None) loader = DataLoader() passwords = dict() inventory = InventoryManager(loader=loader, sources=['myansible/hosts']) variable_manager = VariableManager(loader=loader, inventory=inventory) playbook = PlaybookExecutor(playbooks=['myansible/lamp.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) result = playbook.run() print(result)
def run_playbook(self, playbook_info): try: # create job log to capture the start of the playbook device_id = playbook_info['extra_vars']['playbook_input'] ['device_id'] if device_id is None: device_id = "" msg = "Starting to execute the playbook %s for device " \ "%s with input %s and params %s " % \ (playbook_info['uri'], device_id, json.dumps(playbook_info['extra_vars']['playbook_input'] ['input']), json.dumps(playbook_info['extra_vars']['playbook_input'] ['params'])) self._logger.debug(msg) if not os.path.exists(playbook_info['uri']): raise JobException( "Playbook %s does not " "exist" % playbook_info['uri'], self._execution_id) loader = DataLoader() inventory = InventoryManager(loader=loader, sources=['localhost']) variable_manager = VariableManager(loader=loader, inventory=inventory) Options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', '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', 'diff' ]) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_user='******', 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, diff=False) variable_manager.extra_vars = playbook_info['extra_vars'] passwords = dict(vault_pass='******') pbex = PlaybookExecutor(playbooks=[playbook_info['uri']], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) pbex.run() self._logger.debug("Completed executing the playbook %s. " "Collecting output." % playbook_info['uri']) output = self.get_plugin_output(pbex) self._logger.debug("Output for playbook %s : " "%s" % (playbook_info['uri'], json.dumps(output))) # create job log to capture completion of the playbook execution msg = "Completed to execute the playbook %s for" \ " device %s" % (playbook_info['uri'], playbook_info['extra_vars']['playbook_input'] ['device_id']) self._logger.debug(msg) return output except Exception as e: msg = "Error while executing the playbook %s : %s" % \ (playbook_info['uri'], repr(e)) raise JobException(msg, self._execution_id)
def exec_playbook(self,playbooks): pbex = PlaybookExecutor(playbooks=playbooks,inventory=self.inventory, variable_manager=self.variable_manager,loader=self.loader, options=self.options,passwords=self.passwords) results=pbex.run()
def _run_playbook_executor(self): pbex = PlaybookExecutor(**self._pbex_args) if pbex.run() != 0: raise AnsibleExecutionFailure
def run_ansible(playbooks, inventory_path=None, roles=None, extra_vars=None, tags=None, on_error_continue=False, basedir='.'): """Run Ansible. Args: playbooks (list): list of paths to the playbooks to run inventory_path (str): path to the hosts file (inventory) extra_var (dict): extra vars to pass tags (list): list of tags to run on_error_continue(bool): Don't throw any exception in case a host is unreachable or the playbooks run with errors Raises: :py:class:`enoslib.errors.EnosFailedHostsError`: if a task returns an error on a host and ``on_error_continue==False`` :py:class:`enoslib.errors.EnosUnreachableHostsError`: if a host is unreachable (through ssh) and ``on_error_continue==False`` """ inventory, variable_manager, loader, options = _load_defaults( inventory_path=inventory_path, roles=roles, extra_vars=extra_vars, tags=tags, basedir=basedir) passwords = {} for path in playbooks: logger.info("Running playbook %s with vars:\n%s" % (path, extra_vars)) pbex = PlaybookExecutor(playbooks=[path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) code = pbex.run() stats = pbex._tqm._stats hosts = stats.processed.keys() result = [{h: stats.summarize(h)} for h in hosts] results = {"code": code, "result": result, "playbook": path} print(results) failed_hosts = [] unreachable_hosts = [] for h in hosts: t = stats.summarize(h) if t["failures"] > 0: failed_hosts.append(h) if t["unreachable"] > 0: unreachable_hosts.append(h) if len(failed_hosts) > 0: logger.error("Failed hosts: %s" % failed_hosts) if not on_error_continue: raise EnosFailedHostsError(failed_hosts) if len(unreachable_hosts) > 0: logger.error("Unreachable hosts: %s" % unreachable_hosts) if not on_error_continue: raise EnosUnreachableHostsError(unreachable_hosts)
loader = DataLoader() loader.set_vault_secrets([('default', VaultSecret(_bytes=to_bytes('123456')))]) context.CLIARGS = ImmutableDict(tags={}, listtags=False, listtasks=False, listhosts=False, syntax=False, module_path=None, forks=100, private_key_file=None, start_at_task=None) inventory = InventoryManager(loader=loader, sources=[code_path + '/ansible/inventory']) variable_manager = VariableManager( loader=loader, inventory=inventory, version_info=CLI.version_info(gitinfo=False)) variable_manager._extra_vars = {'firstvar': False} pbex = PlaybookExecutor(playbooks=[code_path + '/ansible/variables.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, passwords={}) results = pbex.run() print(results)
def launch_ansible_playbook(list_ip, playbook, extra_variable=None): """ Applies an Ansible playbook :param list_ip: the ips :param playbook: the playboos to be applied :param extra_variable: dict of the playbook variables to be applied """ host_list = list_ip if not os.path.isfile(playbook): raise Exception('Requested playbook is not found - ' + playbook) if not playbook: logger.warn('Unable to find playbook - ' + playbook) loader = DataLoader() inventory = InventoryManager(loader=loader, sources=','.join(host_list)) variable_manager = VariableManager(loader=loader, inventory=inventory) if extra_variable is not None: variable_manager.extra_vars = extra_variable logger.info(extra_variable) else: logger.info('NO EXTRA VARS') options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', 'connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check', 'sftp_extra_args', 'scp_extra_args', 'diff' ]) ansible_opts = options(listtags=None, listtasks=None, listhosts=None, syntax=False, connection='ssh', module_path=None, forks=100, remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, become=True, become_method='sudo', become_user=None, verbosity=11111, check=False, sftp_extra_args=None, scp_extra_args=None, diff=False) logger.debug('Setting up Ansible Playbook Executor for playbook - ' + playbook) executor = PlaybookExecutor(playbooks=[playbook], inventory=inventory, variable_manager=variable_manager, loader=loader, options=ansible_opts, passwords=None) logger.debug('Executing Ansible Playbook - ' + playbook) ret = executor.run() return ret
def ansiblex_domain(vars1="1", vars2="2", vars3="3", vars4="4", vars5="5", vars6="6", vars7="7", vars8="8"): one_var = vars1 two_var = vars2 three_var = vars3 four_var = vars4 five_var = vars5 six_var = vars6 seven_var = vars7 eight_var = vars8 variable_manager = VariableManager() loader = DataLoader() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=one_var) Options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', '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' ]) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=30, remote_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=None, become_user='******', verbosity=None, check=False) variable_manager.extra_vars = { 'three_var': three_var, 'four_var': four_var, 'five_var': five_var, 'six_var': six_var, 'seven_var': seven_var, 'eight_var': eight_var } passwords = {} pbex = PlaybookExecutor(playbooks=[two_var], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) results = pbex.run() return results