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
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, 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 __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(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 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 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, 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 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 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 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 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)
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_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 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 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 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(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
def test_playbook_executor__get_serialized_batches(self): fake_loader = DictDataLoader({ 'no_serial.yml': ''' - hosts: all gather_facts: no tasks: - debug: var=inventory_hostname ''', 'serial_int.yml': ''' - hosts: all gather_facts: no serial: 2 tasks: - debug: var=inventory_hostname ''', 'serial_pct.yml': ''' - hosts: all gather_facts: no serial: 20% tasks: - debug: var=inventory_hostname ''', }) mock_inventory = MagicMock() mock_var_manager = MagicMock() # fake out options to use the syntax CLI switch, which will ensure # the PlaybookExecutor doesn't create a TaskQueueManager mock_options = MagicMock() mock_options.syntax.value = True pbe = PlaybookExecutor( playbooks=['no_serial.yml', 'serial_int.yml', 'serial_pct.yml'], inventory=mock_inventory, variable_manager=mock_var_manager, loader=fake_loader, options=mock_options, passwords=[], ) playbook = Playbook.load(pbe._playbooks[0], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] mock_inventory.get_hosts.return_value = ['host0','host1','host2','host3','host4','host5','host6','host7','host8','host9'] self.assertEqual(pbe._get_serialized_batches(play), [['host0','host1','host2','host3','host4','host5','host6','host7','host8','host9']]) playbook = Playbook.load(pbe._playbooks[1], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] mock_inventory.get_hosts.return_value = ['host0','host1','host2','host3','host4','host5','host6','host7','host8','host9'] self.assertEqual(pbe._get_serialized_batches(play), [['host0','host1'],['host2','host3'],['host4','host5'],['host6','host7'],['host8','host9']]) playbook = Playbook.load(pbe._playbooks[2], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] mock_inventory.get_hosts.return_value = ['host0','host1','host2','host3','host4','host5','host6','host7','host8','host9'] self.assertEqual(pbe._get_serialized_batches(play), [['host0','host1'],['host2','host3'],['host4','host5'],['host6','host7'],['host8','host9']])
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): 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, 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 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_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_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, 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_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_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 __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): 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
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() output = self.get_plugin_output(pbex) if ret_val != 0: msg = MsgBundle.getMessage( MsgBundle.PLAYBOOK_RETURN_WITH_ERROR) raise Exception(msg) 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'] self._job_file_write.write_to_file(exec_id, unique_pb_id, JobFileWrite.PLAYBOOK_OUTPUT, json.dumps(output)) with open("/tmp/" + exec_id, "a") as f: f.write(unique_pb_id + 'END' + PLAYBOOK_EOL_PATTERN) sys.exit(msg)
def execute_playbook(self, playbook_info): 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='******', 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 e: 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(e)) if e.message: msg = msg + "\n" + e.message JM_LOGGER.error(msg) sys.exit(msg)
become=True, become_method='sudo', become_user='******', verbosity=4, check=False, diff=False, start_at_task=None) """ context.CLIARGS = ImmutableDict(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='local', forks=100, private_key_file=None, become=True, become_method='sudo', become_user='******', check=False, diff=False) callback = ResultCallback1() try: executor = PlaybookExecutor( playbooks=[git_playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, passwords=passwords) #executor._tqm._stdout_callback = callback print('------------------->',inventory.get_hosts()) executor.run() print("UP ***********") for host, result in callback.host_failed.items(): print('{0} >>> {1}'.format(host, result._result.keys())) for key in result._result.keys(): print("Key: {0} Val : {1}".format(key, result._result[key])) print('<-----------------------------Execution completed------------------------>')
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 b_playbook_dirs = [] 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) b_playbook_dir = os.path.dirname(os.path.abspath(to_bytes(playbook, errors='surrogate_or_strict'))) # load plugins from all playbooks in case they add callbacks/inventory/etc add_all_plugin_dirs(b_playbook_dir) b_playbook_dirs.append(b_playbook_dir) set_collection_playbook_paths(b_playbook_dirs) # 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} # create base objects 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()) CLI.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, stdout_callback=self.callback) 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) for block in play.compile(): block = block.filter_tagged_tasks(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
verbosity=5, forks=10, become=None, become_method=None, become_user=None, check=False, diff=False, syntax=None, start_at_task=None, gather_facts='no', ) passwords = dict() play_book = PlaybookExecutor(playbooks=['testplaybook.yml'], inventory=inventory_manager, variable_manager=variable_manager, loader=loader, passwords=passwords) # Create a callback plugin so we can capture the output class ResultsCollectorJSONCallback(CallbackBase): """A sample callback plugin used for performing an action as results come in. If you want to collect all results into a single object for processing at the end of the execution, look into utilizing the ``json`` callback plugin or writing your own custom callback plugin. """ def __init__(self, *args, **kwargs): super(ResultsCollectorJSONCallback, self).__init__(*args, **kwargs) self.host_ok = {}
scp_extra_args=None, ssh_extra_args=None) # 定义默认的密码连接,主机未定义密码的时候才生效,conn_pass指连接远端的密码,become_pass指提升权限的密码 passwords = dict(conn_pass='******', become_pass='******') # create inventory and pass to var manager # 创建inventory、并带进去参数 inventory = InventoryManager(loader=loader, variable_manager=variable_manager, host_list='/root/ansible/playbooks/hosts') # 把inventory传递给variable_manager管理 variable_manager.set_inventory(inventory) # 多个yaml文件则以列表形式 playbook_path = ['/root/ansible/playbooks/mysql.yml', '/root/ansible/playbooks/test_result.yml'] for playbook in playbook_path: if not os.path.exists(playbook): print('[INFO] The [%s] playbook does not exist') % playbook sys.exit() playbook = PlaybookExecutor(playbooks=playbook_path, inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) # 执行playbook result = playbook.run() print('执行结果: %s') % (result)
class ContrailAnsiblePlayBook(multiprocessing.Process): def validate_provision_params(self, inv, defaults): keys_to_check = [ "ansible_playbook", "docker_insecure_registries", "docker_registry_insecure" ] params = inv.get("[all:vars]", None) if params == None: return ("[all:vars] not defined") for x in keys_to_check: if not x in params.keys(): if x == "docker_insecure_registries": params['docker_insecure_registries'] = \ defaults.docker_insecure_registries elif x == 'docker_registry_insecure': params['docker_registry_insecure'] = \ defaults.docker_registry_insecure elif x == 'ansible_playbook': params['ansible_playbook'] = \ defaults.ansible_playbook else: return ("%s not defined in inventory" % x) for k, v in vars(defaults).iteritems(): if not k in params.keys(): params[k] = v pbook = params['ansible_playbook'] try: with open(pbook) as file: pass except IOError as e: return ("Playbook not found : %s" % pbook) return STATUS_VALID def __init__(self, json_entity, args): super(ContrailAnsiblePlayBook, self).__init__() lb = [] agent = [] inv_file = None self.hosts_in_inv = json_entity[0]["hosts_in_inv"] cluster_id = json_entity[0]["cluster_id"] parameters = json_entity[0]["parameters"] inventory = parameters["inventory"] self.current_status = self.validate_provision_params(inventory, args) self.pbook_path = inventory["[all:vars]"]["ansible_playbook"] pbook_dir = os.path.dirname(self.pbook_path) inv_dir = pbook_dir + '/inventory/' inv_file = inv_dir + cluster_id + ".inv" create_inv_file(inv_file, inventory) self.var_mgr = VariableManager() self.ldr = DataLoader() self.args = args self.inventory = Inventory(loader=self.ldr, variable_manager=self.var_mgr, host_list=inv_file) self.var_mgr.set_inventory(self.inventory) Options = namedtuple('Options', [ 'connection', 'forks', 'module_path', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'verbosity' ]) self.options = Options(connection='ssh', forks=100, module_path=None, become=True, become_method='sudo', become_user='******', check=False, listhosts=None, listtasks=None, listtags=None, syntax=None, verbosity=None) self.pws = {} self.pb_executor = PlaybookExecutor(playbooks=[self.pbook_path], inventory=self.inventory, variable_manager=self.var_mgr, loader=self.ldr, options=self.options, passwords=self.pws) try: self._sm_logger = ServerMgrlogger() except: f = open("/var/log/contrail-server-manager/debug.log", "a") f.write("Ansible Callback Init - ServerMgrlogger init failed\n") f.close() def update_status(self): for h in self.hosts_in_inv: status_resp = {"server_id": h, "state": self.current_status} send_REST_request(self.args.ansible_srvr_ip, SM_STATUS_PORT, "ansible_status", urllib.urlencode(status_resp), method='PUT', urlencode=True) def run(self): #import pdb; pdb.set_trace() stats = None if self.current_status == STATUS_VALID: self.current_status = STATUS_IN_PROGRESS self.update_status() try: rv = self.pb_executor.run() except Exception as e: self._sm_logger.log(self._sm_logger.ERROR, e) self.current_status = STATUS_FAILED self.update_status() return None stats = self.pb_executor._tqm._stats if rv == 0: self.current_status = STATUS_SUCCESS else: self.current_status = STATUS_FAILED # No need to update_status here. Per node status gets sent from # sm_ansible_callback.py else: self.update_status() return stats
if len(host_list) == 1: sources += ',' #inventory1 = InventoryManager(loader=loader,sources=host_list) inventoryManager2 = InventoryManager(loader=loader, sources="1.1.1.1.1, 12.2.4.5") #inventoryManager2.add_host('12.12.111.420') variable_manager = VariableManager(loader=loader, inventory=inventoryManager2) passwords = {} # context.CLIARGS = ImmutableDict(connection='local', module_path=['/to/mymodules'], forks=10, become=None, # become_method=None, become_user=None, check=False, diff=False, syntax=False) context.CLIARGS = ImmutableDict(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='local', 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=True, become_method='sudo', become_user='******', verbosity=None, check=False, diff=False) playbook = PlaybookExecutor(playbooks=[playbook_path], inventory=inventoryManager2, variable_manager=variable_manager, loader=loader, passwords=passwords) res = playbook.run() print(res) print('The End')
def push(request): request.COOKIES["username"] and request.session["username"] cookie_name = request.COOKIES["username"] if request.method == "POST" and request.POST: ipstr = request.POST["ip"] userstr = request.POST["user"] iplist = json.loads(ipstr) userlist = json.loads(userstr) pubList = [] #定义一个存放公钥的空列表 userid_list = [] #定义一个存放用户id的空列表 for user in userlist: #遍历前端勾选的用户列表 RsaDb = Rsa.objects.filter(user=user) #过滤出勾选的用户的数据 for rsaobj in RsaDb: pubList.append(rsaobj.rsa_pub) #把勾选用户的公钥添加到pubList中 userid_list.append(int(rsaobj.id)) #把勾选用户的id添加到userid_list中 ipid_list = [] #定义一个存放主机id的空列表 for ip in iplist: #遍历前端勾选的ip地址列表 HostDb = Hardware.objects.filter(ip=ip) #过滤出勾选的ip的数据 for hostobj in HostDb: ipid_list.append(int(hostobj.id)) #把勾选的主机id添加到ipid_list中 # 把用户id,主机id写入数据库的权限表,权限表为:user_id,host_id for uid in userid_list: for pid in ipid_list: if not UserPermission.objects.filter(user_id=uid, host_id=pid): up = UserPermission() up.user_id = uid up.host_id = pid up.save() try: #调用ansible接口执行playbook,实现密钥的推送功能 loader = DataLoader() #用来加载解析yaml文件或JSON内容,并且支持vault的解密 variable_manager = VariableManager( ) #管理变量的类,包括主机,组,扩展等变量,之前版本是在 inventory中的 inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list=iplist) #根据inventory加载对应变量,这里host_list可以是文件也可以是IP列表 variable_manager.set_inventory(inventory) passwords = dict( conn_pass='') #设置密码,必须是dict类型。如果ansible主机对服务器有密钥认证,则不需要密码 Options = namedtuple('Options', [ 'connection', 'remote_user', 'ask_sudo_pass', 'verbosity', 'ack_pass', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'sudo_user', 'sudo' ]) #初始化需要的对象 options = Options(connection='smart', remote_user='******', ack_pass=None, sudo_user='******', forks=50, sudo='yes', ask_sudo_pass=False, verbosity=5, module_path=None, become=True, become_method='sudo', become_user='******', check=None, listhosts=None, listtasks=None, listtags=None, syntax=None) extra_vars = { } #额外的参数,key.yml以及模板中的参数,对应ansible-playbook key.yml --extra-vars pub=xxx state=present/absent extra_vars["pub_list"] = pubList extra_vars["state"] = "present" variable_manager.extra_vars = extra_vars #playbooks填写yml文件路径,可以写多个,是个列表 playbook = PlaybookExecutor(playbooks=['/home/ansible/key.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) playbook.run() #执行 state = "授权成功" except: state = "推送失败,请检查程序" else: state = "test" return JsonResponse({"state": state})
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
def invoke_ansible_playbook(module_path, e_vars, playbook_path="site.yml", console=True): """ Invokes playbook """ loader = DataLoader() variable_manager = VariableManager() variable_manager.extra_vars = e_vars inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=['localhost']) passwords = {} utils.VERBOSITY = 4 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=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=False, become_method=None, become_user='******', verbosity=utils.VERBOSITY, check=False) pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) if not console: cb = PlaybookCallback() pbex._tqm._stdout_callback = cb return_code = pbex.run() results = cb.results else: results = pbex.run() return results
def _get_playbook_executor(self, variables, verbosity): Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'diff' ]) # -v given to us enables ansibles non-debug output. # So -vv should become ansibles -v. __main__.display.verbosity = max(0, verbosity - 1) # make sure ansible does not output warnings for our paternoster pseudo-play __main__._real_warning = __main__.display.warning def display_warning(msg, *args, **kwargs): if not msg.startswith('Could not match supplied host pattern'): __main__._real_warning(msg, *args, **kwargs) __main__.display.warning = display_warning loader = DataLoader() if ANSIBLE_VERSION < LooseVersion('2.4.0'): from ansible.inventory import Inventory variable_manager = VariableManager() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='localhost,') variable_manager.set_inventory(inventory) else: from ansible.inventory.manager import InventoryManager inventory = InventoryManager(loader=loader, sources='localhost,') variable_manager = VariableManager(loader=loader, inventory=inventory) # force ansible to use the current python executable. Otherwise # it can end up choosing a python3 one (named python) or a different # python 2 version variable_manager.set_host_variable(inventory.localhost, 'ansible_python_interpreter', sys.executable) for name, value in variables: variable_manager.set_host_variable(inventory.localhost, name, value) pexec = PlaybookExecutor( playbooks=[self._playbook], inventory=inventory, variable_manager=variable_manager, loader=loader, options=Options( connection='local', module_path=None, forks=1, listhosts=False, listtasks=False, listtags=False, syntax=False, become=None, become_method=None, become_user=None, check=False, diff=False, ), passwords={}, ) ansible.constants.RETRY_FILES_ENABLED = False if not verbosity: # ansible doesn't provide a proper API to overwrite this, # if you're using PlaybookExecutor instead of initializing # the TaskQueueManager (_tqm) yourself, like in the offical # example. pexec._tqm._stdout_callback = MinimalAnsibleCallback() return pexec
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 = read_vault_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) extra_vars = {} for extra_vars_opt in self.options.extra_vars: extra_vars_opt = to_unicode(extra_vars_opt, errors='strict') if extra_vars_opt.startswith(u"@"): # Argument is a YAML file (JSON is a subset of YAML) data = loader.load_from_file(extra_vars_opt[1:]) elif extra_vars_opt and extra_vars_opt[0] in u'[{': # Arguments as YAML data = loader.load(extra_vars_opt) else: # Arguments as Key-value data = parse_kv(extra_vars_opt) extra_vars = combine_vars(extra_vars, data) # 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 = extra_vars # 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 _invoke_playbook(self, playbook='up', console=True): """ Uses the Ansible API code to invoke the specified linchpin playbook :param playbook: Which ansible playbook to run (default: 'up') :param console: Whether to display the ansible console (default: True) """ pb_path = '{0}/{1}'.format( self.lp_path, self.ctx.get_evar('playbooks_folder', 'provision')) module_path = '{0}/{1}/'.format( pb_path, self.get_cfg('lp', 'module_folder', 'library')) playbook_path = '{0}/{1}'.format( pb_path, self.get_cfg('playbooks', playbook, 'site.yml')) loader = DataLoader() variable_manager = VariableManager() variable_manager.extra_vars = self.get_evar() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[]) passwords = {} # utils.VERBOSITY = 4 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=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=False, become_method='sudo', become_user='******', verbosity=0, check=False) pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) if not console: results = {} return_code = 0 cb = PlaybookCallback() with suppress_stdout(): pbex._tqm._stdout_callback = cb return_code = pbex.run() results = cb.results return return_code, results else: # the console only returns a return_code return_code = pbex.run() return return_code, None
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)
def default(self): verbose = self.app.pargs.verbose init(autoreset=True) if len(self.app.pargs.extra_arguments) == 0: self.app.args.print_help() print(Fore.RED + 'Error! You must specify a playbook file to run') sys.exit(1) if str(self.app.pargs.become_method).upper() not in [ 'SUDO', 'SU', 'PBRUN', 'PFEXEC', 'DOAS', 'DZDO', 'KSU', 'RUNAS' ]: print( Fore.RED + 'Error! Become method must be one of sudo, su, pbrun, pfexec, doas, dzdo, ksu or runas.' ) sys.exit(1) #if len(self.app.pargs.extra_arguments) > 0: playbook_path = self.app.pargs.extra_arguments[0] if len( self.app.pargs.extra_arguments) > 0 else "site.yml" if not os.path.isfile(playbook_path): print(Fore.RED + 'Error! The playbook file does not exist') sys.exit(1) inventory_path = self.app.pargs.inventory if not os.path.isfile(inventory_path): print(Fore.RED + 'Error! The inventory file does not exist.') sys.exit(1) # Most of the code from here down is straight copy & paste from ansible source code, # with a few tweaks/hacks to clean up variables that we don't want to emit in the generated # YAML. loader = DataLoader() pb_cli = PlaybookCLI(sys.argv[1:]) pb_cli.parse() # !!!!! WARNING: THESE WILL BE INCLUDED IN THE GENERATED YAML FILE !!!!! (ssh_pass, become_pass) = pb_cli.ask_passwords() passwords = {'conn_pass': ssh_pass, 'become_pass': become_pass} vault_pass = None if self.app.pargs.ask_vault_pass: vault_pass = pb_cli.ask_vault_passwords() else: vault_pass = pb_cli.read_vault_password_file( self.app.pargs.vault_password_file, loader) if vault_pass is not None: loader.set_vault_password(vault_pass) # create the inventory, and filter it based on the subset specified (if any) host_list = self.app.pargs.inventory if self.app.pargs.inventory else constants.DEFAULT_HOST_LIST # FIXME: This should parse any arguments provided via -e or --extra-vars. Currently it seems # to parse the argument value wrongly and returns # '_raw_params': '<last character in variable>'. This prevents the ability to use # --extra-vars when executing plays. variable_manager = VariableManager() options = Options( verbosity=self.app.pargs.verbose, inventory=self.app.pargs.inventory, subset=self.app.pargs.limit, extra_vars=[self.app.pargs.extra_vars], forks=self.app.pargs.forks, ask_vault_pass=self.app.pargs.ask_vault_pass, vault_password_files=self.app.pargs.vault_password_file, tags=self.app.pargs.tags, skip_tags=self.app.pargs.skip_tags, become=self.app.pargs.become, become_method=self.app.pargs.become_method, become_user=self.app.pargs.become_user, become_ask_pass=self.app.pargs.ask_become_pass, ask_pass=self.app.pargs.ask_pass, private_key_file=self.app.pargs.private_key, remote_user=self.app.pargs.user, connection=self.app.pargs.connection, timeout=self.app.pargs.timeout, ssh_common_args=self.app.pargs.ssh_common_args, sftp_extra_args=self.app.pargs.sftp_extra_args, ssh_extra_args=self.app.pargs.ssh_extra_args, scp_extra_args=self.app.pargs.scp_extra_args, flush_cache=self.app.pargs.flush_cache, module_path=self.app.pargs.module_path) inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.extra_vars = load_extra_vars(loader=loader, options=options) #variable_manager.options_vars = load_options_vars(options) if self.app.pargs.flush_cache: inventory.refresh_inventory() no_hosts = False if len(inventory.list_hosts()) == 0: print( Fore.YELLOW + "Warning! Provided hosts list is empty, only localhost is available." ) no_hosts = True # FIXME: Limit is currently ignored. inventory.subset(self.app.pargs.limit) if len(inventory.list_hosts()) == 0 and no_hosts is False: # Invalid limit print(Fore.RED + "Error! Specified --limit does not match any hosts.") sys.exit(1) play_data = loader.load_from_file(playbook_path) host_list = inventory.get_hosts( pattern=self.app.pargs.limit ) if self.app.pargs.limit else inventory.get_hosts() playbook = Playbook(loader=loader).load( playbook_path, variable_manager=variable_manager, loader=loader) pbex = PlaybookExecutor(playbooks=playbook.get_plays(), inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) # Ansible variables matching these strings will be excluded from the generated yaml content. ignored_elements = [ 'ansible_playbook_python', 'ansible_version', 'group_names', 'inventory_hostname', 'inventory_hostname_short', 'omit', 'playbook_dir', 'role_names' ] json_data = {} for host in host_list: host_vars = host.get_vars() host_name = host_vars[ 'ansible_host'] if 'ansible_host' in host_vars.keys( ) else host.get_name() for play in playbook.get_plays(): loader.set_vault_password(vault_pass) all_vars = variable_manager.get_vars(loader=loader, play=play, host=host) json_data[host_name] = all_vars['vars'] json_data[host_name]['ansible_groups'] = all_vars[ 'group_names'] json_data[host_name]['ansible_roles'] = all_vars['role_names'] for elem in ignored_elements: del json_data['{}'.format(host)][elem] json_data[host_name][ 'ansible_become_user'] = self.app.pargs.become_user if passwords['become_pass'] is not None: json_data[host_name]['ansible_become_pass'] = passwords[ 'become_pass'] json_data[host_name]['ansible_become'] = self.app.pargs.become json_data[host_name][ 'ansible_become_method'] = self.app.pargs.become_method if self.app.pargs.ssh_extra_args: json_data[host_name][ 'ansible_ssh_extra_args'] = self.app.pargs.ssh_extra_args if self.app.pargs.scp_extra_args: json_data[host_name][ 'ansible_scp_extra_args'] = self.app.pargs.scp_extra_args if self.app.pargs.sftp_extra_args: json_data[host_name][ 'ansible_sftp_extra_args'] = self.app.pargs.sftp_extra_args if self.app.pargs.ssh_common_args: json_data[host_name][ 'ansible_ssh_common_args'] = self.app.pargs.ssh_common_args json_data[host_name][ 'ansible_connection_timeout'] = self.app.pargs.timeout json_data[host_name][ 'ansible_connection_method'] = self.app.pargs.connection if self.app.pargs.private_key: json_data[host_name][ 'ansible_private_key'] = self.app.pargs.private_key json_data[host_name][ 'ansible_ask_pass'] = self.app.pargs.ask_pass if self.app.pargs.limit: json_data[host_name][ 'ansible_limit'] = self.app.pargs.limit # FIXME: Extra vars needs to be processed by Ansible instead of dumping them # here as a "dumb" string. if self.app.pargs.extra_vars: json_data[host_name][ 'ansible_extra_vars'] = self.app.pargs.extra_vars for key, value in json_data[host_name].iteritems(): if type(value) is AnsibleVaultEncryptedUnicode: json_data[host_name][key] = str(value) # Convert the processed python dictionary to a valid json string json_obj = json.dumps(json_data) # Take the json string, and convert it to a valid yaml string yml = YAML(typ="safe", pure=True) yml.default_flow_style = False yml_obj = yml.load(json_obj) if self.app.pargs.output is None: yml.dump(yml_obj, sys.stdout) else: with open(self.app.pargs.output, 'w') as outfile: yml.dump(yml_obj, outfile) print(Fore.GREEN + "Ansible variable dictionary written to {}".format( self.app.pargs.output)) sys.exit(1)
def run_playbooks(playbook, tags=[], context=None, options=None): """ @param playbook: The playbook(s) to be run. @type playbook: str or iterable @param tags: Run only plays tagged with these (or) @type tags: list @param context: The nose context where the playbook(s) will be executed @type context: instance """ cfgifc = ContextHelper().get_config() LOG.debug('In run_playbooks(%s)...', playbook) # Really not liking how variables are called constants and how there are N # ways of assigning them. C.DEFAULT_ROLES_PATH = [os.path.expanduser('~/.ansible/roles'), os.path.join(HERE, 'roles')] C.RETRY_FILES_ENABLED = False C.DEFAULT_HASH_BEHAVIOUR = 'merge' C.ANSIBLE_PIPELINING = True action_loader.add_directory(os.path.join(HERE, 'action_plugins')) lookup_loader.add_directory(os.path.join(HERE, 'lookup_plugins')) loader = DataLoader() inventory = InventoryManager(loader=loader, sources='/dev/null') variable_manager = VariableManager(loader, inventory) o = OptionsStrict(connection='smart', forks=10, become=None, become_method=None, become_user=None, check=False, listhosts=False, listtasks=False, listtags=False, syntax=False, module_path=[os.path.join(HERE, 'library')], diff=False, # tags=tags, verbosity=1, timeout=1, ) if options.logger_level: display.logger_level = options.pop('logger_level') if options: o.update(options) passwords = dict(vault_pass='******') display.verbosity = o.verbosity inventory.add_group('all') a = inventory.groups['all'] a.set_variable(VAR_F5TEST_CONFIG, cfgifc.api) a.set_variable('f5test_itemd', {}) if context: tmp = nose_selector(context) address = test_address(context) a.set_variable('f5test_module', tmp.replace(':', '.')) # ITE compatibility: templates can refer to metadata values (e.g. TCID) if hasattr(context, ITE_METADATA): a.set_variable('f5test_itemd', getattr(context, ITE_METADATA)) if address[1]: name = address[1].rsplit('.')[-1] a.set_variable('f5test_module_name', name) a.set_variable('playbook_name', os.path.splitext(os.path.basename(playbook))[0]) for device in cfgifc.get_devices(KIND_ANY): prev = a name = '' for sub_kind in device.kind.bits: name += sub_kind inventory.add_group(name) prev.add_child_group(inventory.groups[name]) prev = inventory.groups[name] name += '.' fingerprint = cfgifc.get_session().get_fingerprint(hash=True) for tag in tags: a.set_variable(tag, True) session = cfgifc.get_session() a.set_variable('f5test_session', OptionsStrict(name=session.name, name_md5=session.name_md5)) a.set_variable('f5test_respools', session.get_respool_handler().pools) a.set_variable('f5test_utils', JinjaUtils()) a.set_variable('f5test_ranges', session.get_respool_handler().ranges) a.set_variable('machine_fingerprint', fingerprint) # Colon must mean something for Ansible if device.alias != 'localhost': inventory.add_host(device.alias, str(device.kind).replace(':', '.')) h = inventory.get_host(device.alias) h.set_variable('f5test_device', device) h.set_variable('f5test_kind', device.kind) h.set_variable('f5test_mgmt_address', device.get_address()) h.set_variable('f5test_port_https', device.ports['https']) h.set_variable('f5test_username', device.get_admin_creds().username) h.set_variable('f5test_password', device.get_admin_creds().password) h.set_variable('ansible_host', device.get_discover_address()) h.set_variable('ansible_ssh_port', device.ports['ssh']) h.set_variable('ansible_user', device.get_root_creds().username) h.set_variable('ansible_ssh_pass', device.get_root_creds().password) for spec, v in device.specs.get(HOST_VARS, {}).items(): h.set_variable(spec, v) for group in device.groups: inventory.add_group(group) g = inventory.groups[group] a.add_child_group(g) g.add_host(h) names = [playbook] if isinstance(playbook, str) else playbook for g, v in cfgifc.api.get(GROUP_VARS, {}).items(): group = inventory.groups.get(g) if group: group.vars.update(v) # Look for playbooks relative to caller's base directory frame = inspect.stack()[1] module = inspect.getmodule(frame[0]) here = os.path.dirname(os.path.abspath(module.__file__)) playbooks = [x if os.path.isabs(x) else os.path.join(here, FIXTURES_DIR, x) for x in names] executor = PlaybookExecutor( playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader, options=o, passwords=passwords) options = OptionsStrict(rc=-1, failed=[]) cb = MyCallback(options=options) executor._tqm._callback_plugins.append(cb) try: options.rc = executor.run() finally: shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) # p.vips.sync() return options
def run(self): super(PlaybookCLI, self).run() # Note: slightly wrong, this is written so that implicit localhost # Manage passwords sshpass = None becomepass = None passwords = {} if self.options.role_file: args = ["install"] if self.options.ignore_errors: args.append("--ignore-errors") force = "" if self.options.force: args.append("--force") if self.options.roles_path: args.extend(["--roles-path", self.options.roles_path]) if self.options.no_deps: args.append("--no-deps") args.extend(["--role-file", self.options.role_file]) gc = GalaxyCLI(args=args) gc.parse() gc.run() # 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, inventory, variable_manager = self._play_prereqs(self.options) # (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(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 test_get_serialized_batches(self): fake_loader = DictDataLoader({ 'no_serial.yml': ''' - hosts: all gather_facts: no tasks: - debug: var=inventory_hostname ''', 'serial_int.yml': ''' - hosts: all gather_facts: no serial: 2 tasks: - debug: var=inventory_hostname ''', 'serial_pct.yml': ''' - hosts: all gather_facts: no serial: 20% tasks: - debug: var=inventory_hostname ''', 'serial_list.yml': ''' - hosts: all gather_facts: no serial: [1, 2, 3] tasks: - debug: var=inventory_hostname ''', 'serial_list_mixed.yml': ''' - hosts: all gather_facts: no serial: [1, "20%", -1] tasks: - debug: var=inventory_hostname ''', }) mock_inventory = MagicMock() mock_var_manager = MagicMock() # fake out options to use the syntax CLI switch, which will ensure # the PlaybookExecutor doesn't create a TaskQueueManager mock_options = MagicMock() mock_options.syntax.value = True templar = Templar(loader=fake_loader) pbe = PlaybookExecutor( playbooks=[ 'no_serial.yml', 'serial_int.yml', 'serial_pct.yml', 'serial_list.yml', 'serial_list_mixed.yml' ], inventory=mock_inventory, variable_manager=mock_var_manager, loader=fake_loader, options=mock_options, passwords=[], ) playbook = Playbook.load(pbe._playbooks[0], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] play.post_validate(templar) mock_inventory.get_hosts.return_value = [ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9' ] self.assertEqual(pbe._get_serialized_batches(play), [[ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9' ]]) playbook = Playbook.load(pbe._playbooks[1], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] play.post_validate(templar) mock_inventory.get_hosts.return_value = [ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9' ] self.assertEqual( pbe._get_serialized_batches(play), [['host0', 'host1'], ['host2', 'host3'], ['host4', 'host5'], ['host6', 'host7'], ['host8', 'host9']]) playbook = Playbook.load(pbe._playbooks[2], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] play.post_validate(templar) mock_inventory.get_hosts.return_value = [ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9' ] self.assertEqual( pbe._get_serialized_batches(play), [['host0', 'host1'], ['host2', 'host3'], ['host4', 'host5'], ['host6', 'host7'], ['host8', 'host9']]) playbook = Playbook.load(pbe._playbooks[3], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] play.post_validate(templar) mock_inventory.get_hosts.return_value = [ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9' ] self.assertEqual( pbe._get_serialized_batches(play), [['host0'], ['host1', 'host2'], ['host3', 'host4', 'host5'], ['host6', 'host7', 'host8'], ['host9']]) playbook = Playbook.load(pbe._playbooks[4], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] play.post_validate(templar) mock_inventory.get_hosts.return_value = [ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9' ] self.assertEqual( pbe._get_serialized_batches(play), [['host0'], ['host1', 'host2'], ['host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9']]) # Test when serial percent is under 1.0 playbook = Playbook.load(pbe._playbooks[2], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] play.post_validate(templar) mock_inventory.get_hosts.return_value = ['host0', 'host1', 'host2'] self.assertEqual(pbe._get_serialized_batches(play), [['host0'], ['host1'], ['host2']]) # Test when there is a remainder for serial as a percent playbook = Playbook.load(pbe._playbooks[2], variable_manager=mock_var_manager, loader=fake_loader) play = playbook.get_plays()[0] play.post_validate(templar) mock_inventory.get_hosts.return_value = [ 'host0', 'host1', 'host2', 'host3', 'host4', 'host5', 'host6', 'host7', 'host8', 'host9', 'host10' ] self.assertEqual( pbe._get_serialized_batches(play), [['host0', 'host1'], ['host2', 'host3'], ['host4', 'host5'], ['host6', 'host7'], ['host8', 'host9'], ['host10']])
class AnsibleRunner(object): def __init__(self, vault_pass='', connection='local', module_path='', forks=100, become=None, become_method=None, become_user=None, remote_user=None, check=False, listhosts=None, listtasks=None, listtags=None, syntax=None, private_key_file=None): """ 初始化ansible信息,主要是提供playbook_executor类使用的 options, variable_manager, loader, passwords """ Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'remote_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'private_key_file' ]) self.options = Options(connection=connection, module_path=module_path, forks=forks, become=become, become_method=become_method, become_user=become_user, remote_user=remote_user, check=check, listhosts=listhosts, listtasks=listtasks, listtags=listtags, syntax=syntax, private_key_file=private_key_file) self.variable_manager = VariableManager() self.loader = DataLoader() self.passwords = dict(vault_pass=vault_pass) def init_inventory(self, host_list='localhost'): """ 初始化inventory host_list接受json数据传递给inv_api的inv_file """ host_list = inv_file(host_list) self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=host_list) os.remove(host_list) self.variable_manager.set_inventory(self.inventory) def init_playbook(self, playbooks): """ 使用playbook exexutor来直接执行playbook文件 playbooks需要转换成list,否则无法被迭代,playbooks是一个文件或者路径 """ self.pbex = PlaybookExecutor(playbooks=[playbooks], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords) def run_it(self): result = self.pbex.run() return result
def run(self): super(PlaybookDocutizer, self).run() 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)): raise AnsibleError("the playbook: %s does not appear to be a file" % playbook) self._shared_loader_obj = SharedPluginLoaderObj() self._loader, self._inventory, self._variable_manager = self._play_prereqs(self.options) pbex = PlaybookExecutor(playbooks=self.args, inventory=self._inventory, variable_manager=self._variable_manager, loader=self._loader, options=self.options, passwords={}) results = pbex.run() if isinstance(results, list): for p in results: plays = [] for idx, play in enumerate(p['plays']): display.display('Processing play %d: %s' % (idx+1, play.name)) if play._included_path is not None: self._loader.set_basedir(play._included_path) else: pb_dir = os.path.realpath(os.path.dirname(p['playbook'])) self._loader.set_basedir(pb_dir) hosts = CLI.get_host_list(self._inventory, self.options.subset) # TODO(iwalker): do we really need a host? can this just run with localhost? if len(hosts) == 0: raise AnsibleError('No hosts were specified') # NOTE(iwalker): can loop through all hosts and evaluate the tasks, but since we are not doing any # conditional evaluation, we'll just pick the first host and use that. host = hosts[0] display.v('Processing against host: %s' % (host.get_name())) self._all_vars = self._variable_manager.get_vars(play=play, host=host) play_context = PlayContext(play=play, options=self.options) processed_blocks = [] for block in play.compile(): block = block.filter_tagged_tasks(play_context, self._all_vars) if not block.has_tasks(): continue processed_blocks.append(self._process_block(block)) tasks = [] for block in processed_blocks: if len(block) == 0: continue for task in block: tasks.append(task) processed_handlers = [] for block in play.compile_roles_handlers(): processed_handlers.extend(self._process_block(block)) play_info = { 'filename': p['playbook'], 'hosts': hosts, 'name': play.name, 'roles': play.roles, 'tasks': tasks, 'handlers': processed_handlers, 'become': play.become, 'remote_user': play.remote_user, } plays.append(play_info) env = AnsibleEnvironment(trim_blocks=True, extensions=['jinja2.ext.loopcontrols'], loader=FileSystemLoader(self.options.template_path)) display.display('Rendering template containing %d plays' % (len(plays))) template = env.get_template(self.options.template_master) output = template.render(plays=plays, options=self.options) display.display('Saving output to %s' % (self.options.output)) with codecs.open(self.options.output, mode='w', encoding='utf-8') as f: f.write(output)
Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff', "listhosts","listtasks","listtags", "syntax"]) options = Options(connection='smart', module_path=None, forks=10, become=None, become_method=None, become_user=None, check=False, diff=False, listhosts=None,listtasks=None,listtags=None, syntax=None) # PlaybookExecutor 类 passwords = dict() play_book = PlaybookExecutor( playbooks=["fbook1.yaml"], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords ) play_book.run() """ $ python ansible_api_k2.py PLAY [192.168.193.139,192.168.193.140] **************************************************************************************************************************************************************************************** TASK [Gathering Facts] ********************************************************************************************************************************************************************************************************
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 = {} # 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 vault_pass = CLI.read_vault_password_file( self.options.vault_password_file, loader=loader) loader.set_vault_password(vault_pass) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords() loader.set_vault_password(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: for host in inventory.list_hosts(): variable_manager.clear_facts(host) # 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']): 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 deleteData(request): request.COOKIES["username"] and request.session["username"] cookie_name = request.COOKIES["username"] if request.method == "GET" and request.GET: try: # if request.GET["user"]: user = request.GET["user"] sql = "select u.id,p.ip from Rsa_rsa as u,Hardware_hardware as p,Rsa_userpermission as up where up.user_id = u.id and up.host_id = p.id and u.user = '******';" % user ip_data = UserPermission.objects.raw(sql) ip_list = [] #定义一个用户来存放ip地址的list,因为可能一个用户对应多个ip地址,所以ip作为一个list来保存 for data in ip_data: ip_list.append(str(data.ip)) #得到用户对应的ip地址的list user_obj = Rsa.objects.filter(user=user) for data in user_obj: id = int(data.id) pub = data.rsa_pub # user_obj.delete() up_obj = UserPermission.objects.filter(user_id=id) up_obj.delete() try: #调用ansible接口执行playbook,实现密钥的删除功能 loader = DataLoader() #用来加载解析yaml文件或JSON内容,并且支持vault的解密 variable_manager = VariableManager( ) #管理变量的类,包括主机,组,扩展等变量,之前版本是在 inventory中的 inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list=ip_list ) #根据inventory加载对应变量,这里host_list可以是文件也可以是IP列表 variable_manager.set_inventory(inventory) passwords = dict( conn_pass='') #设置密码,必须是dict类型。如果ansible主机对服务器有密钥认证,则不需要密码 Options = namedtuple('Options', [ 'connection', 'remote_user', 'ask_sudo_pass', 'verbosity', 'ack_pass', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'sudo_user', 'sudo' ]) #初始化需要的对象 options = Options(connection='smart', remote_user='******', ack_pass=None, sudo_user='******', forks=50, sudo='yes', ask_sudo_pass=False, verbosity=5, module_path=None, become=True, become_method='sudo', become_user='******', check=None, listhosts=None, listtasks=None, listtags=None, syntax=None) extra_vars = { } #额外的参数,key.yml以及模板中的参数,对应ansible-playbook key.yml --extra-vars pub=xxx state=present/absent extra_vars["pub_list"] = pub extra_vars["state"] = "absent" #状态设置为移除 variable_manager.extra_vars = extra_vars #playbooks填写yml文件路径,可以写多个,是个列表 playbook = PlaybookExecutor( playbooks=['/home/ansible/key.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) playbook.run() #执行 state = "删除成功" except: state = "删除失败,请检查程序日志" return HttpResponseRedirect("/Rsa/userlist_dis") except: # else: # if request.GET["ip"]: ip = str(request.GET["ip"]) sql = "select u.id,u.user,p.ip from Rsa_rsa as u,Hardware_hardware as p,Rsa_userpermission as up where up.user_id = u.id and up.host_id = p.id and p.ip = '%s';" % ip user_data = UserPermission.objects.raw(sql) user_list = [ ] #定义一个用户来存放用户名的list,因为可能一个ip地址对应多个用户,所以用户名作为一个list来保存 for data in user_data: user_list.append(data.user) #得到IP地址对应的用户名的list host_obj = Hardware.objects.filter(ip=ip) for data in host_obj: id = int(data.id) #得到IP地址的id pub_list = [] for user in user_list: user_obj = Rsa.objects.filter(user=user) for data in user_obj: pub_list.append(data.rsa_pub) # host_obj.delete() up_obj = UserPermission.objects.filter(host_id=id) up_obj.delete() try: #调用ansible接口执行playbook,实现密钥的删除功能 ip_list = [ ] #inventory中的host_list必须接受的是一个list,so我们把这个IP放到一个list中 ip_list.append(ip) loader = DataLoader() #用来加载解析yaml文件或JSON内容,并且支持vault的解密 variable_manager = VariableManager( ) #管理变量的类,包括主机,组,扩展等变量,之前版本是在 inventory中的 inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list=ip_list ) #根据inventory加载对应变量,这里host_list可以是文件也可以是IP列表 variable_manager.set_inventory(inventory) passwords = dict( conn_pass='') #设置密码,必须是dict类型。如果ansible主机对服务器有密钥认证,则不需要密码 Options = namedtuple('Options', [ 'connection', 'remote_user', 'ask_sudo_pass', 'verbosity', 'ack_pass', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'sudo_user', 'sudo' ]) #初始化需要的对象 options = Options(connection='smart', remote_user='******', ack_pass=None, sudo_user='******', forks=50, sudo='yes', ask_sudo_pass=False, verbosity=5, module_path=None, become=True, become_method='sudo', become_user='******', check=None, listhosts=None, listtasks=None, listtags=None, syntax=None) extra_vars = { } #额外的参数,key.yml以及模板中的参数,对应ansible-playbook key.yml --extra-vars pub=xxx state=present/absent extra_vars["pub_list"] = pub_list extra_vars["state"] = "absent" #状态设置为移除 variable_manager.extra_vars = extra_vars #playbooks填写yml文件路径,可以写多个,是个列表 playbook = PlaybookExecutor( playbooks=['/home/ansible/key.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) playbook.run() #执行 state = "删除成功" except: state = "删除失败,请检查程序日志" return HttpResponseRedirect("/Rsa/hostlist_dis")
]) variable_manager = VariableManager() loader = DataLoader() options = Options(connection='local', forks=100, become=None, become_method=None, become_user=None, check=False, listhosts=False, listtasks=False, listtags=False, syntax=False, module_path="") passwords = dict(vault_pass='******') inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='localhost') variable_manager.set_inventory(inventory) playbooks = ["./test.yaml"] executor = PlaybookExecutor(playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) executor.run()
def playbook_all(self, playbook_name, tags_set, extra_vars_dict, keyfile_path): ret = -1 playbook_path = self._preinstall_playbook_path_builder(playbook_name) r_print.debug(playbook_path) inventry_path = '{work_dir}/.inventry'.format( work_dir=rdbox.config.get("ansible", "work_dir")) try: loader = DataLoader() self._create_inventry_file_from_k8s(inventry_path) inventory = InventoryManager(loader=loader, sources=inventry_path) variable_manager = VariableManager(loader=loader, inventory=inventory) variable_manager.extra_vars = extra_vars_dict if not os.path.exists(playbook_path): raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), playbook_path) 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', 'tags' ]) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='smart', module_path=None, forks=5, remote_user=None, private_key_file=keyfile_path, 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, diff=False, tags=tags_set) passwords = {} pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) # redirect bak_stdout = sys.stdout bak_stderr = sys.stderr sys.stdout = StdLoggerWriter(r_print.debug) sys.stderr = StdLoggerWriter(r_print.info) ret = pbex.run() except Exception: sys.stdout = bak_stdout sys.stderr = bak_stderr import traceback r_print.error(traceback.format_exc()) ret = -1 finally: sys.stdout = bak_stdout sys.stderr = bak_stderr # Cleanup try: self._remove_file(inventry_path) except Exception: # No problem pass return ret
'connection', 'remote_user', 'ask_sudo_pass', 'verbosity', 'ack_pass', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'sudo_user', 'sudo', 'diff' ]) options = Options(connection='smart', remote_user=None, ack_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) playbook = PlaybookExecutor(playbooks=['/etc/ansible/web.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) playbook.run()
self.task_status[h] = { 'ok': t['ok'], 'changed': t['changed'], 'unreachable': t['unreachable'], 'skipped': t['skipped'], 'failed': t['failed'] } callback = PlayBookResultsCollector() 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() #print callback.host_ok.items() result_raw = { 'ok': {}, 'failed': {}, 'unreachable': {}, 'skipped': {}, 'status': {} }