def ssh_to_host(hostname, remote_command=None): """ Compose cmd string of ssh and execute Uses Ansible to parse inventory file, gets ssh connection options :param hostname: str. Hostname from inventory """ workspace_manager = CoreServices.workspace_manager() workspace = workspace_manager.get_active_workspace() if workspace is None: raise exceptions.IRNoActiveWorkspaceFound() inventory_file = workspace.inventory from ansible.parsing.dataloader import DataLoader from ansible.inventory.manager import InventoryManager invent = InventoryManager(DataLoader(), sources=inventory_file) host = invent.get_host(hostname) if host is None: raise exceptions.IRSshException( "Host {} is not in inventory {}".format(hostname, inventory_file)) if _get_magic_var(host, "connection") == "local": raise exceptions.IRSshException("Only ssh transport acceptable.") cmd = " ".join(["ssh {priv_key} {comm_args}", "{extra_args} -p {port} -t {user}@{host}"]) cmd_fields = {} cmd_fields["user"] = _get_magic_var(host, "remote_user", default="root") cmd_fields["port"] = _get_magic_var(host, "port", default=22) cmd_fields["host"] = _get_magic_var(host, "remote_addr") priv_key = _get_magic_var(host, "private_key_file") # NOTE(yfried): # ssh client needs key to be in the directory you're running one from # ('ssh -i id_rsa ...') or to be provided by absolute path. # assume paths are relative to inventory file. abspath = os.path.join(os.path.abspath(os.path.dirname(inventory_file)), priv_key) priv_key = abspath if os.path.exists(abspath) else priv_key cmd_fields["priv_key"] = "-i {}".format(priv_key if priv_key else "") cmd_fields["comm_args"] = _get_magic_var(host, "ssh_common_args") cmd_fields["extra_args"] = _get_magic_var(host, "ssh_extra_args") LOG.debug("Establishing ssh connection to {}".format(cmd_fields["host"])) compiled_cmd = cmd.format(**cmd_fields) if remote_command is not None: compiled_cmd = " ".join( [compiled_cmd, '"{}"'.format(remote_command)]) result = os.WEXITSTATUS(os.system(compiled_cmd)) LOG.debug("Connection to {} closed".format(cmd_fields["host"])) return result
def get_ansible_host_ip(): loader = DataLoader() inventory = InventoryManager(loader=loader, sources='hosts') variable_manager = VariableManager(loader=loader, inventory=inventory) hostnames = [] for host in inventory.get_hosts(): hostnames.append(variable_manager.get_vars(host=host)) ip = ' '.join([str(i['ansible_host']) for i in hostnames]) return str(ip)
def test_flush_cache(self): cli = PlaybookCLI(args=["ansible-playbook", "--flush-cache", "foobar.yml"]) cli.parse() self.assertTrue(cli.options.flush_cache) variable_manager = VariableManager() fake_loader = DictDataLoader({'foobar.yml': ""}) inventory = InventoryManager(loader=fake_loader, sources='testhost,') variable_manager.set_host_facts(inventory.get_host('testhost'), {'canary': True}) self.assertTrue('testhost' in variable_manager._fact_cache) cli._flush_cache(inventory, variable_manager) self.assertFalse('testhost' in variable_manager._fact_cache)
def __init__(self, playbook): self.loader = DataLoader() self.inventory = InventoryManager(loader=self.loader, sources=None) self.variable_manager = VariableManager(self.loader,self.inventory) self.playbook = playbook self.sender_group = 'sender' self.inventory.add_group(self.sender_group) self.receiver_group = 'receiver' self.inventory.add_group(self.receiver_group) self.master_group = 'master' self.inventory.add_group(self.master_group)
def __init__(self): self.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', 'diff']) self.options = self.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) self.loader = DataLoader() self.inventory = InventoryManager(loader=self.loader, sources=['/opt/myops/myansible/hosts']) self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) self.callback = ModelResultsCollector() self.passwords = dict()
]) options = Options(connection='smart', module_path=[], forks=10, become=None, become_method=None, become_user=None, check=False, diff=False) loader = DataLoader() passwords = {} results_callback = ResultCallback() inventory = InventoryManager(loader=loader, sources='hosts') # 剧本的位置 variable_manager = VariableManager(loader=loader, inventory=inventory) # ansible all -i etc/hosts -m setup play_source = { 'name': "collect server info", 'hosts': 'all', # 在哪些主机上执行 'gather_facts': 'no', 'tasks': [ # 执行的任务列表 { 'name': 'fact', # 任务名称 'setup': '' # 执行任务模块 } ] }
class MyInventory(): ''' resource = [{'hostid': '1231', 'hostname': 'h1', 'hostip': '1.1.1.1'}, {'hostid': '2345', 'hostname': 'h2', 'hostip': '2.2.2.2'}, ] resource = {'groupname1': { 'hosts': [ {'hostid': '1231', 'hostname': 'h1', 'hostip': '1.1.1.1'}, {'hostid': '2231', 'hostname': 'h2', 'hostip': '1.1.1.2'}, ], 'groupvars': {"k1":"v1"} }, 'groupname2': {'hosts': [], 'groupvars': {}}, } ''' # edit ori code ansible/inventory/manage.pay line215 try if C.InventoryManager_PARSE_NOSOURCE:pass constants.InventoryManager_PARSE_NOSOURCE = True def __init__(self, resource): self.resource = resource self.loader = DataLoader() # self.inventory=InventoryManager(loader=self.loader,sources=['/etc/ansible/hosts']) self.inventory = InventoryManager(loader=self.loader) self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) self._parse(self.resource) def _parse(self, resource): if isinstance(resource, list): self._addGroupHosts(self.resource) elif isinstance(resource, dict): # logging.info('parsing resuorce: %s'%(self.resource)) for groupname, hosts_and_groupvars in self.resource.items(): print("[1] groupname: %s |hostsandvars: %s" % (groupname, hosts_and_groupvars)) # debug [1] self._addGroupHosts(hosts_and_groupvars.get('hosts'), groupname, hosts_and_groupvars.get('groupvars')) else: logging.error('resource error ,need dict or list') def _addGroupHosts(self, hosts, groupname='default', groupvars=None): self.inventory.add_group(group=groupname) group = Group(groupname) if groupvars: for k, v in groupvars.items(): group.set_variable(k, v) # hosts=[{'hostid':'123','hostname':'h1','hostip':'192.168.188.20'} for host in hosts: hostid = host.get('hostid') hostname = host.get('hostname') hostip = host.get('hostip') username = host.get('username') password = host.get('password') port = host.get('port', 22) sshkey = host.get('sshkey') if hostname: self.inventory.add_host( host=hostname, group=groupname ) # by default, indentify by hostname and need hostobj = self.inventory.get_host( hostname=hostname) # add host= , get hostname= self.variable_manager.set_host_variable( host=hostobj, varname='ansible_ssh_host', value=hostip) self.variable_manager.set_host_variable( host=hostobj, varname='ansible_ssh_port', value=port) self.variable_manager.set_host_variable( host=hostobj, varname='ansible_ssh_user', value=username) self.variable_manager.set_host_variable( host=hostobj, varname='ansible_ssh_pass', value=password) self.variable_manager.set_host_variable( host=hostobj, varname='ansible_ssh_private_key_file', value=sshkey) # TODO: other vars such as become-method-user-pass #hostobj.set_variable('ansible_ssh_port',port) for k, v in host.items(): if k not in [ 'hostip', 'port', 'username', 'password', 'sshkey' ]: hostobj.set_variable(k, v) else: logging.warning('resource error:cant get hostname from | %s' % resource) def testcase(self): print(self.inventory.get_groups_dict()) host = self.inventory.get_host(hostname='h1') print(self.variable_manager.get_vars(host=host))
def __init__(self, hosts, extra_vars=None, timeout=None): 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', 'playbook_path', 'passwords', 'diff', 'gathering', 'remote_tmp', ]) self.hosts = hosts self._validate() self.hosts_file = None self.timeout = 100 if not timeout else timeout self.options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, timeout=self.timeout, connection='ssh', module_path='', forks=10, remote_user='******', private_key_file='/root/.ssh/id_rsa', ssh_common_args="", ssh_extra_args="", sftp_extra_args="", scp_extra_args="", become=None, become_method=None, become_user=None, verbosity=None, extra_vars=[], check=False, playbook_path='', passwords=None, diff=False, gathering='implicit', remote_tmp='/tmp/.ansible') self.loader = DataLoader() self.inventory = InventoryManager(loader=self.loader, sources=[','.join(self.hosts) + ',']) self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) if extra_vars: self.variable_manager.extra_vars = extra_vars logger.info(self.options)
become_method=None, become_user=None, check=False, diff=False, forks=2) # initialize needed objects loader = DataLoader( ) # Takes care of finding and reading yaml, json and ini files passwords = dict(vault_pass='******') # Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets results_callback = ResultCallback() # create inventory, use path to host config file as source or hosts in a comma separated string inventory = InventoryManager(loader=loader, sources=['10.20.40.20']) # variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context variable_manager = VariableManager(loader=loader, inventory=inventory) # Create play object, playbook objects use .load instead of init or new methods, # this will also automatically create the task objects from the info provided in play_source playbook = PlaybookExecutor( playbooks=['/Users/lei/ops/github/cmdb/ansible_api/test1.yaml'], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) playbook.run()
def __execute_module(self, module_name=None, module_args=None, persist_files=False, delete_remote_tmp=None, wrap_async=False, run_on_ca_host=False, ignore_changed=False, ignore_failed=False): if run_on_ca_host: host = InventoryManager(DataLoader(), context.CLIARGS['inventory']).get_host( self._var("ca_host")) task = self._task.copy() task_data = self._var("ca_host_options") task_data.update({ 'name': "mgssl ca_host task: {0}".format(module_name), 'action': module_name, 'args': module_args, 'delegate_to': self._var("ca_host") }) task.load_data(task_data) task_vars = self._task_vars.copy() task_vars.update(self._task.get_variable_manager().get_vars( host=host, task=task)) executor_result = TaskExecutor(host, task, task_vars, self._play_context, None, self._loader, self._shared_loader_obj, None) # Dirty fix for mitogen compatibility # Mitogen somehow puts a task global connection binding object in each connection that gets created # during the lifetime of a task. That usually happens on the beginning of a task, but here, we create # a new task executor within a task and that also creates a new connection for local running tasks. # After execution the connections get closed, but the close function also closes and removes the parent # tasks binding object. Now all future connections will fail. # # Solution: Overwrite the close method and only call the necessary close methods except the one that closes # the binding object if self._is_mitogen: get_connection_method = executor_result._get_connection def get_connection(cvars, templar): c = get_connection_method(cvars, templar) c.close = lambda: (c._put_connection(), None) return c executor_result._get_connection = get_connection ret = executor_result.run() # Reset the close method if self._is_mitogen: executor_result._get_connection = get_connection_method else: if self._shared_loader_obj.action_loader.has_plugin( module_name, None): task = self._task.copy() task.load_data({ 'action': module_name, 'args': module_args, }) handler = self._shared_loader_obj.action_loader.get( module_name, task=task, connection=self._connection, play_context=self._play_context. set_task_and_variable_override(task, {}, self._templar), loader=self._loader, templar=self._templar, shared_loader_obj=self._shared_loader_obj, collection_list=None) ret = handler.run(None, self._task_vars) else: ret = self._execute_module(module_name, module_args, None, self._task_vars, persist_files, delete_remote_tmp, wrap_async) self._check_result(module_name, run_on_ca_host, ret, ignore_changed, ignore_failed) return ret
class AnsibleTest(object): def __init__(self): self.loader = None self.inventory = None self.vars_manager = None self.play = None self.role = None def load(self, inventory_dir, inventory_name, playbook_dir, playbook_name, play_name, role_name): self.loader = DataLoader() self.loader.set_basedir(playbook_dir) self.inventory = InventoryManager(loader=self.loader, sources=os.path.join( inventory_dir, inventory_name)) self.vars_manager = VariableManager(loader=self.loader, inventory=self.inventory) self.play = self.get_play_by_name(playbook_name, play_name) self.role = self.get_role_by_name(self.play, role_name) def get_play_by_name(self, playbook_name, play_name): playbook = Playbook.load(os.path.join(self.loader.get_basedir(), playbook_name), variable_manager=self.vars_manager, loader=self.loader) plays = playbook.get_plays() play = None for p in plays: if p.get_name() == play_name: play = p break if play is None: raise Exception("no play with name %s found in plays: %s" % (play_name, plays)) return play def get_role_by_name(self, play, role_name): roles = play.get_roles() for r in roles: if r.get_name() == role_name: return r raise Exception("no role with name %s found in roles: %s" % (role_name, roles)) def read_role_template(self, template_name): path = os.path.join(self.role._role_path, "templates", template_name) with open(path, 'r') as f: return f.read() def get_host_vars(self, host_name): all_vars = self.vars_manager.get_vars( play=self.play, host=self.inventory.get_host(host_name)) host_vars = HostVars( inventory=self.inventory, variable_manager=self.vars_manager, loader=self.loader, ) all_vars.update(dict(hostvars=host_vars)) return all_vars
def main(args): host_list = [] for inv in args.get("INVENTORY"): if not os.path.exists(inv): logger.error("Inventory file(s) not exist.") sys.exit(1) if os.path.isdir(inv): host_list.append(inv + "/*") else: host_list.append(inv) logger.debug(host_list) subprocess.call("cat %s > %s" % (" ".join(host_list), tmp_path), shell=True) header_path = args.get("--header") if os.path.exists(header_path): header = open(header_path, "r").read() else: header = None logger.warn("No custom header file found.") indent = " " * int(args.get("--indent")) logger.debug(header) output = "" + header if header else "" loader = DataLoader() inventory = InventoryManager(loader=loader, sources=tmp_path) variable_manager = VariableManager(loader=loader, inventory=inventory) for host in inventory.get_hosts(): host_all_vars = host.get_vars() for group in host.get_groups(): host_all_vars.update(group.get_vars()) output += "Host %s\n" % host.get_name() output += "%sHostname %s\n" % (indent, host_all_vars["ansible_host"]) custom_user = False for user in ("ansible_ssh_user", "ansible_user"): if user in host_all_vars: output += "%sUser %s\n" % (indent, host_all_vars[user]) custom_user = True if not custom_user: output += "%sUser root\n" % indent for port in ("ansible_ssh_port", "ansible_port"): if port in host_all_vars: output += "%sPort %d\n" % (indent, host_all_vars[port]) ssh_key = "ansible_ssh_private_key_file" if ssh_key in host_all_vars: output += "%sIdentityFile %s\n" % (indent, host_all_vars[ssh_key]) output += "\n" if args.get("--output"): with open(args.get("--output"), "w") as f: f.writelines(output) else: print(output)
class NetworkTest(object): def __init__(self, playbook): self.loader = DataLoader() self.inventory = InventoryManager(loader=self.loader, sources=None) self.variable_manager = VariableManager(self.loader,self.inventory) self.playbook = playbook self.sender_group = 'sender' self.inventory.add_group(self.sender_group) self.receiver_group = 'receiver' self.inventory.add_group(self.receiver_group) self.master_group = 'master' self.inventory.add_group(self.master_group) def set_inventory_vars(self, inv_vars): self.variable_manager.extra_vars = inv_vars def add_sender(self, sender): sender_host = sender self.inventory.add_host(sender_host, self.sender_group) def add_receiver(self, receiver): receiver_host = receiver self.inventory.add_host(receiver_host, self.receiver_group) def add_master(self, master): master_host = master self.inventory.add_host(master_host, self.master_group) 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 test_variable_manager_precedence(self): # FIXME: this needs to be redone as dataloader is not the automatic source of data anymore return # pylint: disable=unreachable ''' Tests complex variations and combinations of get_vars() with different objects to modify the context under which variables are merged. ''' # FIXME: BCS makethiswork # return True mock_inventory = MagicMock() inventory1_filedata = """ [group2:children] group1 [group1] host1 host_var=host_var_from_inventory_host1 [group1:vars] group_var = group_var_from_inventory_group1 [group2:vars] group_var = group_var_from_inventory_group2 """ fake_loader = DictDataLoader({ # inventory1 '/etc/ansible/inventory1': inventory1_filedata, # role defaults_only1 '/etc/ansible/roles/defaults_only1/defaults/main.yml': """ default_var: "default_var_from_defaults_only1" host_var: "host_var_from_defaults_only1" group_var: "group_var_from_defaults_only1" group_var_all: "group_var_all_from_defaults_only1" extra_var: "extra_var_from_defaults_only1" """, '/etc/ansible/roles/defaults_only1/tasks/main.yml': """ - debug: msg="here i am" """, # role defaults_only2 '/etc/ansible/roles/defaults_only2/defaults/main.yml': """ default_var: "default_var_from_defaults_only2" host_var: "host_var_from_defaults_only2" group_var: "group_var_from_defaults_only2" group_var_all: "group_var_all_from_defaults_only2" extra_var: "extra_var_from_defaults_only2" """, }) inv1 = InventoryManager(loader=fake_loader, sources=['/etc/ansible/inventory1']) v = VariableManager(inventory=mock_inventory, loader=fake_loader) v._fact_cache = defaultdict(dict) play1 = Play.load(dict( hosts=['all'], roles=['defaults_only1', 'defaults_only2'], ), loader=fake_loader, variable_manager=v) # first we assert that the defaults as viewed as a whole are the merged results # of the defaults from each role, with the last role defined "winning" when # there is a variable naming conflict res = v.get_vars(play=play1) self.assertEqual(res['default_var'], 'default_var_from_defaults_only2') # next, we assert that when vars are viewed from the context of a task within a # role, that task will see its own role defaults before any other role's blocks = play1.compile() task = blocks[1].block[0] res = v.get_vars(play=play1, task=task) self.assertEqual(res['default_var'], 'default_var_from_defaults_only1') # next we assert the precedence of inventory variables v.set_inventory(inv1) h1 = inv1.get_host('host1') res = v.get_vars(play=play1, host=h1) self.assertEqual(res['group_var'], 'group_var_from_inventory_group1') self.assertEqual(res['host_var'], 'host_var_from_inventory_host1') # next we test with group_vars/ files loaded fake_loader.push("/etc/ansible/group_vars/all", """ group_var_all: group_var_all_from_group_vars_all """) fake_loader.push("/etc/ansible/group_vars/group1", """ group_var: group_var_from_group_vars_group1 """) fake_loader.push("/etc/ansible/group_vars/group3", """ # this is a dummy, which should not be used anywhere group_var: group_var_from_group_vars_group3 """) fake_loader.push("/etc/ansible/host_vars/host1", """ host_var: host_var_from_host_vars_host1 """) fake_loader.push("group_vars/group1", """ playbook_group_var: playbook_group_var """) fake_loader.push("host_vars/host1", """ playbook_host_var: playbook_host_var """) res = v.get_vars(play=play1, host=h1) # self.assertEqual(res['group_var'], 'group_var_from_group_vars_group1') # self.assertEqual(res['group_var_all'], 'group_var_all_from_group_vars_all') # self.assertEqual(res['playbook_group_var'], 'playbook_group_var') # self.assertEqual(res['host_var'], 'host_var_from_host_vars_host1') # self.assertEqual(res['playbook_host_var'], 'playbook_host_var') # add in the fact cache v._fact_cache['host1'] = dict(fact_cache_var="fact_cache_var_from_fact_cache") res = v.get_vars(play=play1, host=h1) self.assertEqual(res['fact_cache_var'], 'fact_cache_var_from_fact_cache')
def main(): my_dir = os.path.dirname(sys.argv[0]) zhmc_module_dir = os.path.join(my_dir, 'zhmc_ansible_modules') zhmc_playbooks_dir = os.path.join(my_dir, 'playbooks') inventory_file = '/etc/ansible/hosts' options = Options(connection='local', module_path=[zhmc_module_dir], forks=100, become=None, become_method=None, become_user=None, check=False, diff=False) passwords = dict(vault_pass=None) results_callback = ResultCallback() loader = DataLoader() inventory = InventoryManager(loader=loader, sources=[inventory_file]) variable_manager = VariableManager(loader=loader, inventory=inventory) # The playbook source play_source = dict( name="Get facts for a Z partition", hosts='localhost', gather_facts='no', vars_files=[ os.path.join(zhmc_playbooks_dir, 'vars.yml'), os.path.join(zhmc_playbooks_dir, 'vault.yml'), ], tasks=[ dict( name="Get partition facts", action=dict( module='zhmc_partition', args=dict( hmc_host="{{hmc_host}}", hmc_auth="{{hmc_auth}}", cpc_name="{{cpc_name}}", name="{{partition_name}}", state='facts', ), ), register='part1_result', ), dict(action=dict( module='debug', args=dict(msg="Gathered facts for partition " "'{{part1_result.partition.name}}': " "status='{{part1_result.partition.status}}'", ), ), ), ], ) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=results_callback, ) try: rc = tqm.run(play) except AnsibleError as exc: print("Error: AnsibleError: %s" % exc) return 2 if rc == TaskQueueManager.RUN_OK: return 0 elif rc & TaskQueueManager.RUN_FAILED_HOSTS: status_list = results_callback.status_failed assert len(status_list) == 1 status = status_list[0] host_name = status['host_name'] task_name = status['task_name'] result = status['result'] try: msg = result['msg'] except Exception: print("Internal error: Unexpected format of result: %r" % result) return 2 print("Error: Task '%s' failed on host '%s': %s" % (task_name, host_name, msg)) return 1 elif rc & TaskQueueManager.RUN_UNREACHABLE_HOSTS: status_list = results_callback.status_unreachable assert len(status_list) == 1 status = status_list[0] host_name = status['host_name'] task_name = status['task_name'] result = status['result'] try: msg = result['msg'] except Exception: print("Internal error: Unexpected format of result: %r" % result) return 2 print("Error: Task '%s' failed because host '%s' is unreachable: " "%s" % (task_name, host_name, msg)) return 1 else: print("Internal error: Unexpected rc=%s: %s" % (rc, rc_msg(rc))) return 2 finally: if tqm is not None: tqm.cleanup() return 0
#!/usr/bin/env python from collections import namedtuple from ansible.parsing.dataloader import DataLoader from ansible.vars.manager import VariableManager from ansible.inventory.manager import InventoryManager from ansible.executor.playbook_executor import PlaybookExecutor #inventory = Inventory(loader=loader, variable_manager=variable_manager,host_list='/home/felixc/ansible/hosts') loader = DataLoader() inventory = InventoryManager(loader=loader, sources=['./hostslist']) variable_manager = VariableManager(loader=loader, inventory=inventory) passwords = dict(vault_pass='******') 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', '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,
class AnsibleApi(object): def __init__(self, hostinfo, taskinfo=None): self.resultinfo = [] self.taskinfo = taskinfo self.hostinfo = hostinfo self.host_list = [i.get("host", None) for i in self.hostinfo] self.sources = ",".join(self.host_list) if len(self.host_list) == 1: self.sources += "," self.passwords = dict() self.callback = None self.__initializeData() def __initializeData(self): Options = namedtuple("Options", [ "connection", "module_path", "forks", "remote_user", "private_key_file", "ssh_common_args", "ssh_extra_args", "sftp_extra_args", "scp_extra_args", "become", "become_method", "become_user", "verbosity", "check", "diff" ]) self.options = Options( connection='smart', module_path=['/usr/share/ansible'], forks=100, remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method="sudo", become_user=None, verbosity=None, check=False, diff=False, ) self.loader = DataLoader() # 设置本次调用的host_list self.inventory = InventoryManager(loader=self.loader, sources=self.sources) # 加载之前的变量 self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) self.__set_hostinfo() def __set_hostinfo(self): # 设置调用主机认证信息 for host in self.hostinfo: self.inventory.add_host(host.get("host"), port=host.get("port")) hostname = self.inventory.get_host(hostname=host.get("host")) self.variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_pass', value=host.get('password')) self.variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_user', value=host.get('user')) self.variable_manager.set_host_variable(host=hostname, varname='ansible_ssh_port', value=host.get('port')) if host.get("sudo_pass"): self.variable_manager.set_host_variable( host=hostname, varname="ansible_become_user", value=host.get("sudo_user")) self.variable_manager.set_host_variable( host=hostname, varname="ansible_become_pass", value=host.get("sudo_pass")) self.variable_manager.set_host_variable( host=hostname, varname="ansible_become", value=True) if not host.get('password') or host.get('password') == "None": self.variable_manager.set_host_variable( host=hostname, varname="ansible_ssh_private_key_file", value=host.get("ansible_ssh_private_key_file")) def run_model(self): for task in self.taskinfo: play_source = dict(name="andible_api_play", hosts=self.host_list, gather_facts="no", tasks=[ dict(action=dict(module=task.get("module"), args=task.get("args"))) ]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = None self.callback = ModelResultsCollector() try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback="minimal", ) tqm._stdout_callback = self.callback result = tqm.run(play) except Exception as err: import traceback print(traceback.print_exc()) finally: if tqm is not None: tqm.cleanup() @property def get_model_result(self): for host, result in self.callback.host_ok.items(): self.resultinfo.append( {host: { "message": result._result, "code": 0 }}) for host, result in self.callback.host_unreachable.items(): self.resultinfo.append( {host: { "message": result._result, "code": -1 }}) for host, result in self.callback.host_failed.items(): self.resultinfo.append( {host: { "message": result._result, "code": 1 }}) return self.resultinfo def run_playbook(self, PlayBookPath): try: self.callback = PlayBookResultsCollector() pbex = PlaybookExecutor(playbooks=[PlayBookPath], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, option=self.options, passwords=self.passwords) pbex._tqm._stdout_callback = self.callback pbex.run() except Exception as err: import traceback print(traceback.print_exc()) return False def get_playbook_result(self): for host, result in self.callback.host_ok.items(): self.resultinfo.append( {host: { "message": result._result, "code": 0 }}) for host, result in self.callback.host_unreachable.items(): self.resultinfo.append( {host: { "message": result._result, "code": -1 }}) for host, result in self.callback.host_failed.items(): self.resultinfo.append( {host: { "message": result._result, "code": 1 }}) for host, result in self.callback.task_status.items(): self.resultinfo.append( {host: { "message": result._result, "code": 2 }}) for host, result in self.callback.task_skipped.items(): self.resultinfo.append( {host: { "message": result._result, "code": 3 }}) return self.resultinfo
def __init__(self, filename): self._loader = DataLoader() self._inventory = InventoryManager(loader=self._loader, sources=filename)
def give_inventory_and_data_loader( ) -> Tuple[InventoryManager, dataloader.DataLoader, VariableManager]: data_loader = dataloader.DataLoader() # create the inventory, and filter it based on the subset specified (if any) inventory = InventoryManager(loader=data_loader, sources="localhost") # inventory.add_host("spire_server",group="all") # inventory.add_host("spire_agent",group="all") inventory.add_group("all") inventory.add_group("ungrouped") inventory.add_host("localhost", group="ungrouped") inventory.add_host("spire_server", group="ungrouped") inventory.add_host("spire_agent", group="ungrouped") # create the variable manager, which will be shared throughout # the code, ensuring a consistent view of global variables var_manager = VariableManager(loader=data_loader, inventory=inventory, version_info=None) var_manager.set_host_variable("spire_server", "ansible_connection", "local") var_manager.set_host_variable("spire_agent", "ansible_connection", "local") var_manager.set_host_variable("spire_server", "ansible_host", "localhost") var_manager.set_host_variable("spire_agent", "ansible_host", "localhost") python_path = sys.executable var_manager.set_host_variable("spire_server", "ansible_python_interpreter", python_path) var_manager.set_host_variable("spire_agent", "ansible_python_interpreter", python_path) var_manager.set_host_variable("localhost", "ansible_python_interpreter", python_path) # spire_agent_host_vars = variable_manager.get_vars(host=inventory.get_host("localhost")) return inventory, data_loader, var_manager
become_method=None, become_user=None, check=False, diff=False) # initialize needed objects loader = DataLoader( ) # Takes care of finding and reading yaml, json and ini files passwords = dict() # Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets # results_callback = ResultCallback() # create inventory, use path to host config file as source or hosts in a comma separated string # inventory = InventoryManager(loader=loader, sources='localhost,') inventory = InventoryManager(loader=loader, sources=['/root/myansi/hosts']) # variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context variable_manager = VariableManager(loader=loader, inventory=inventory) # create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally. play_source = dict( name="Ansible Play", hosts='webservers', gather_facts='no', tasks=[ # dict(action=dict(module='shell', args='ls'), register='shell_out'), dict(action=dict(module='yum', args='name=vsftpd state=latest'), register='shell_out'), # dict(action=dict(module='shell', args='id zhangsan'), register='shell_out'), # dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')))
def __init__(self, hostnames, action, playbook, private_key_file, run_data, internal_data, location, become_pass, request_id, started_at, config, dbsession, tr, verbosity=5): self.logger = app.logger self.logger.debug('initializing ansible runbook executor') self.action = action self.config = config self.dbsession = dbsession self.transition_request = tr self.location = location self.run_data = run_data self.internal_data = internal_data self.run_variables = {} self.run_variables.update(self.run_data) self.run_variables.update(self.location) self.run_variables.update(self.internal_data) self.logger.debug(str(self.location)) self.logger.debug(str(self.run_data)) self.logger.debug(str(self.run_variables)) self.request_id = request_id self.started_at = started_at self.finished_at = None self.resInstance = {} # NEW 2.9 # handles options now context.CLIARGS = ImmutableDict( connection='ssh', module_path=['/var/alm_ansible_rm/library'], forks=20, become=None, become_method='sudo', become_user='******', check=False, diff=False, ansible_python_interpreter='/usr/bin/python3', host_key_checking=False, vault_password_file='/etc/ansible/tslvault.txt', private_key_file=private_key_file, listhosts=None, listtasks=None, listtags=None, syntax=None, start_at_task=None) # Gets data from YAML/JSON files self.loader = DataLoader() self.loader.set_vault_secrets([ ('default', VaultSecret(_bytes=to_bytes('TSLDem0'))) ]) # create temporary inventory file self.hosts = NamedTemporaryFile(delete=False) self.hosts.write(b'[run_hosts]\n') self.hosts.write( b'localhost ansible_connection=local ansible_python_interpreter="/usr/bin/env python3" host_key_checking=False' ) self.hosts.close() # set Inventory self.inventory = InventoryManager(loader=self.loader, sources=self.hosts.name) # All the variables from all the various places self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) # MOD 2.9 - has been renamed, not sure this is the proposed way to treat extra_vars, but it works self.variable_manager._extra_vars = self.run_variables # Become Pass Needed if not logging in as user root passwords = {'become_pass': become_pass} # Setup playbook executor, but don't run until run() called self.pbex = playbook_executor.PlaybookExecutor( playbooks=[playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, passwords=passwords) if (self.transition_request) and (isinstance(self.transition_request, TransitionRequest)): # log only if transition request, not for netowrk/image scans) self.logger.debug('transition request ' + str(self.transition_request)) self.log_request_status('PENDING', 'playbook initialized', '', '') self.logger.debug('ansible runbook executor instantiated for ' + str(playbook)) self.callback = OutputCallback(self.action, self.logger) self.pbex._tqm._stdout_callback = self.callback
def v2_runner_on_ok(self, result, *args, **kwargs): """Print a json representation of the result. Also, store the result in an instance attribute for retrieval later """ host = result._host self.host_ok[host.get_name()] = result print(json.dumps({host.name: result._result}, indent=4)) def v2_runner_on_failed(self, result, *args, **kwargs): host = result._host self.host_failed[host.get_name()] = result print("aaaa") results_callback = ResultCallback() context.CLIARGS = ImmutableDict(tags={}, 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='Sudo', become_user='******', verbosity=True, check=False, start_at_task=None, stdout_callback=results_callback) inventory = InventoryManager(loader=loader, sources=('10.0.0.27,')) variable_manager = VariableManager(loader=loader, inventory=inventory, version_info=CLI.version_info(gitinfo=False)) pbex = PlaybookExecutor(playbooks=['./static/ansible/ls.yml'], inventory=inventory, variable_manager=variable_manager, loader=loader, passwords={}) results = pbex.run() print(results)
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=20, check=False) loader = DataLoader() passwords = dict(vault_pass='******') inventory = InventoryManager(loader=loader, sources='/etc/ansible/hosts') variable_manager = VariableManager(loader=loader, inventory=inventory) play_source = dict( name='Ansible Play', hosts='pool', gather_facts='no', tasks=[ dict(action=dict(module='shell', args='systemctl status indy-node'), register='shell_out'), dict(action=dict(module='debug', args=dict( msg='{{shell_out.stdout}}'))) ]) play = Play().load(play_source,
def adhoc(sources, hosts, module, args): # Options是在执行ansible临时命令时,提供的选项,需要了解的选项有 # connection是连接方式,local表示在本机执行,ssh表示ssh执行,smart表示自动选择 # forks指的是一次同时向多少台主机发送指令 Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff' ]) options = Options(connection='ssh', module_path=['/to/mymodules'], forks=10, become=None, become_method=None, become_user=None, check=False, diff=False) # DataLoader用于解析json/ini/yaml等文件,将其转换成python的数据类型 loader = DataLoader() # 设置密码 passwords = dict(vault_pass='******') # 主机清单文件,表示方式有两种 # 一种是将各个主机用冒号分隔,成为一个字符串 # 另外一种方式是使用主机路径列表 # inventory = InventoryManager(loader=loader, sources='localhost,') inventory = InventoryManager(loader=loader, sources=sources) # 变量管理 variable_manager = VariableManager(loader=loader, inventory=inventory) # 创建play源 play_source = dict( name="Ansible Play", hosts=hosts, # 在哪台主机上执行任务 gather_facts='no', tasks=[ dict(action=dict(module=module, args=args), register='shell_out'), # dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) ]) # 创建play对象 play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # 通过任务队列管理器执行play tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def execude(self): # since API is constructed for CLI it expects certain options to always be set, named tuple 'fakes' the args parsing options object Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff', 'private_key_file', ]) options = Options( connection='smart', module_path=['/to/mymodules'], forks=10, become=None, become_method=None, become_user='******', check=False, diff=False, private_key_file='~/.ssh/id_rsa', ) # initialize needed objects loader = DataLoader( ) # Takes care of finding and reading yaml, json and ini files passwords = dict(vault_pass='******') # Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets results_callback = ResultCallback() # create inventory, use path to host config file as source or hosts in a comma separated string inventory = InventoryManager(loader=loader, sources='/etc/ansible/hosts') # inventory.add_host(host='172.20.51.22',port=22,group='test') # variable manager takes care of merging all the different sources to give you a unified view of variables available in each context variable_manager = VariableManager(loader=loader, inventory=inventory) # create data structure that represents our play, including tasks, this is basically what our YAML loader does internally. play_source = dict( name="Ansible Play", hosts=self.hosts, gather_facts='no', tasks=[ dict( action=dict(module='shell', args='ps -ef | grep VSM'), register='shell_out', ), # dict(action=dict(module='setup', ), register='shell_out'), # dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) ]) play = Play().load( play_source, variable_manager=variable_manager, loader=loader, ) tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None, stdout_callback=results_callback, # Use our custom callback instead of the ``default`` callback plugin, which prints to stdout ) # atest = tqm # atest.run(play) rs = tqm.run( play, ) # most interesting data for a play is actually sent to the callback's methods print('---') print() # if tqm._stdout_callback.consquence: # for key in tqm._stdout_callback.consquence['172.20.51.22']['stderr']: # print(key,) except BaseException: print(str(BaseException)) finally: # we always need to cleanup child procs and the structures we use to communicate with them if tqm is not None: tqm.cleanup() # Remove ansible tmpdir shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
class MyInventory(): """ this is IOPS ansible inventory object. """ def __init__(self, resource, loader, variable_manager): self.resource = resource self.loader = DataLoader() self.inventory = InventoryManager( loader=self.loader, sources=[settings.FD_ANSIBLE_HOSTS_FILE]) # self.variable_manager.set_inventory(self.inventory) self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) self.dynamic_inventory() def add_dynamic_group(self, hosts, groupname, groupvars=None): """ add hosts to a group """ self.inventory.add_group(groupname) my_group = Group(name=groupname) # if group variables exists, add them to group if groupvars: for key, value in groupvars.items(): my_group.set_variable(key, value) # add hosts to group for host in hosts: #print (host) # set connection variables hostname = host.get("hostname") hostip = host.get('ip', hostname) hostport = host.get("port") username = host.get("username") password = host.get("password") ssh_key = host.get("ssh_key") my_host = Host(name=hostname, port=hostport) print(my_host) self.variable_manager.set_host_variable(host=my_host, varname='ansible_ssh_host', value=hostip) self.variable_manager.set_host_variable(host=my_host, varname='ansible_ssh_pass', value=password) self.variable_manager.set_host_variable(host=my_host, varname='ansible_ssh_port', value=hostport) self.variable_manager.set_host_variable(host=my_host, varname='ansible_ssh_user', value=username) self.variable_manager.set_host_variable( host=my_host, varname='ansible_ssh_private_key_file', value=ssh_key) # my_host.set_variable('ansible_ssh_pass', password) # my_host.set_variable('ansible_ssh_private_key_file', ssh_key) # set other variables for key, value in host.items(): if key not in ["hostname", "port", "username", "password"]: self.variable_manager.set_host_variable(host=my_host, varname=key, value=value) # add to group self.inventory.add_host(host=hostname, group=groupname, port=hostport) ghost = Host(name="192.168.8.119") def dynamic_inventory(self): """ add hosts to inventory. """ if isinstance(self.resource, list): self.add_dynamic_group(self.resource, 'default_group') elif isinstance(self.resource, dict): for groupname, hosts_and_vars in self.resource.items(): self.add_dynamic_group(hosts_and_vars.get("hosts"), groupname, hosts_and_vars.get("vars"))
class ResultCallback(CallbackBase): def v2_runner_on_ok(self, result, **kwargs): print(json.dumps({result._host.name: result._result})) if __name__ == '__main__': Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff']) options = Options(connection='smart', module_path=[], forks=6, become=None, become_method=None, become_user=None, check=False, diff=False) loader = DataLoader() passwords = {} callback = ResultCallback() inventory = InventoryManager(loader=loader, sources='hosts.py') variable_manager = VariableManager(loader=loader, inventory=inventory) source = { 'hosts' : 'mytest', 'gather_facts' : 'False', 'tasks' : [ { 'name' : 'shell', 'shell' : 'ls /', 'register' : 'result', }, { 'debug' : { 'msg' : ' {{ result.stdout }}',
def inventory_manager(self): return InventoryManager(loader=self._ansible_inventory_data_loader, sources=self.paths.inventory_ini)
check=False, diff=False) # initialize needed objects #ansible会用到各种各样的文件, 如 json, yaml, ini等, 这些文件的内容需要转成python的数据类型,DataLoader自动进行转换 loader = DataLoader( ) # Takes care of finding and reading yaml, json and ini files #各种密码 ,如果有利用ansible-vault 加密,尝试使用vault_pass 所指定的密码来解密 passwords = dict(vault_pass='******') # Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets # results_callback = ResultCallback() # create inventory, use path to host config file as source or hosts in a comma separated string #inventory = InventoryManager(loader=loader, sources='localhost,') inventory = InventoryManager(loader=loader, sources=["/root/myansible/hosts"]) # variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context #变量管理器 variable_manager = VariableManager(loader=loader, inventory=inventory) # create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally. play_source = dict( name="Ansible Play", hosts='webservers', gather_facts='no', tasks=[ dict(action=dict(module='shell', args='ls'), register='shell_out'), dict(action=dict(module='debug', args=dict( msg='{{shell_out.stdout}}')))
module_path='/usr/local/lib/python2.7/dist-packages/ansible', forks=100, become=None, become_method=None, become_user=None, check=False, diff=False) passwords = dict(vault_pass='******') # Instantiate our ResultCallback for handling results as they come in results_callback = ResultCallback() results_callback.nodeid = 'my_id_node' list = get_template() # create inventory and pass to var manager inventory = InventoryManager(loader=loader, sources=['my_inventory.txt']) variable_manager = VariableManager(loader=loader, inventory=inventory) # create play with tasks play_source = loader.load_from_file( '/mnt/extra-addons/bibind/create_site_ovh.yml')[0] play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it tqm = None try: tqm = TaskQueueManager( inventory=inventory,
from ansible.executor.task_queue_manager import TaskQueueManager from ansible.plugins.callback import CallbackBase from ansible import context from ansible.module_utils.common.collections import ImmutableDict ############################### # InventoryManager 类 ############################### # 读取资产清单信息 loader = DataLoader() """ sources 可以是绝对和相对路径 """ inventory_manager = InventoryManager(loader=loader, sources=['my_hots.txt']) ############################### # VariableManager 类 ############################### variable_manager = VariableManager(loader=loader, inventory=inventory_manager) # 方法2 context.CLIARGS = ImmutableDict(connection='smart', module_path=None, verbosity=5, forks=10, become=None, become_method=None, become_user=None, check=False,
def main(): # Set default base_dir = '.' discovered_devices = {} inventory_file = None username = None password = None # Reading options try: opts, args = getopt.getopt(sys.argv[1:], 'di:u:p:') except getopt.GetoptError as err: logging.error(err) usage() sys.exit(255) for opt, arg in opts: if opt == '-d': logging.basicConfig(level=logging.DEBUG) elif opt == '-i': inventory_file = arg elif opt == '-u': username = arg elif opt == '-p': password = arg else: logging.error('unhandled option ({})'.format(opt)) usage() sys.exit(255) # Checking options and environment if not os.path.isdir(base_dir): logging.error('base directory does not exist ({})'.format(base_dir)) sys.exit(255) if not inventory_file: logging.error('inventory file not specified'.format(base_dir)) sys.exit(255) if not os.path.isfile(inventory_file): logging.error( 'inventory file does not exist ({})'.format(inventory_file)) sys.exit(255) if not username or not password: logging.error('username and/or password not set'.format(base_dir)) sys.exit(255) # Loading Ansible inventory ansible_loader = DataLoader() try: ansible_inventory = InventoryManager(loader=ansible_loader, sources=inventory_file) except: logging.error('cannot read inventory file ({})'.format(inventory_file)) sys.exit(255) variable_manager = VariableManager(loader=ansible_loader, inventory=ansible_inventory) # Discover each host for host in ansible_inventory.get_hosts(): try: os.makedirs('devices/{}'.format(host), exist_ok=True) except: logging.error('cannot create directory (devices/{})'.format(host)) facts = getFacts(username=host.vars['snmp_username'], password=host.vars['snmp_password'], host=host.vars['ansible_host']) cdp_neighbors = getCDPNeighbors(username=host.vars['snmp_username'], password=host.vars['snmp_password'], host=host.vars['ansible_host']) try: facts_output = open('devices/{}/facts.json'.format(host), 'w+') facts_output.write(json.dumps(facts)) facts_output.close() except: logging.error( 'cannot write facts (devices/{}/facts.json)'.format(host)) continue try: cdp_neighbors_output = open( 'devices/{}/cdp_neighbors.json'.format(host), 'w+') cdp_neighbors_output.write(json.dumps(cdp_neighbors)) cdp_neighbors_output.close() except: logging.error( 'cannot write facts (devices/{}/cdp_neighbors.json)'.format( host)) continue
def __init__(self, module=None): self.module = module self.tasks = [] self.results = dict(tasks_run=[], tasks_failed=[], tasks_unreachable=[], tasks_result=dict()) # counter # self._JS = 0 self.config = Config() _options = namedtuple( 'Options', [ 'connection', # connection types: smart,ssh,paramiko... 'module_path', # remote python module path 'forks', # forks numbers 'become', # True or False 'become_method', # sudo or other 'become_user', # who sudo 'check', # TODO: unknown 'diff', # TODO: unknown 'remote_user', # remote user name 'ssh_common_args', # add ssh args 'private_key_file', # where private key 'verbosity', # more information show 'host_key_checking', # next version support for close host checking 'listhosts', # support PlaybookExecutor 'listtasks', # support PlaybookExecutor 'listtags', # support PlaybookExecutor 'syntax', # support PlaybookExecutor ]) # defaults args _defaults = dict( connection='smart', module_path=None, forks=100, become=True, become_method='sudo', become_user='******', check=False, diff=False, remote_user='******', ssh_common_args=None, private_key_file=None, verbosity=4, host_key_checking=False, ) # load from config file for i, j in self.config.items(): _defaults[i] = j self.options = _options( connection=_defaults['connection'], remote_user=_defaults['remote_user'], module_path=_defaults['module_path'], forks=_defaults['forks'], become=_defaults['become'], become_method=_defaults['become_method'], become_user=_defaults['become_user'], check=_defaults['check'], diff=_defaults['diff'], ssh_common_args=_defaults['ssh_common_args'], private_key_file=_defaults['private_key_file'], verbosity=_defaults['verbosity'], host_key_checking=_defaults['host_key_checking'], listhosts=None, listtasks=None, listtags=None, syntax=None, ) self.loader = DataLoader() self.inventory = InventoryManager(loader=self.loader, sources=LC['HOSTS_FILES']) self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) self.play_source = dict(name='', hosts='', gather_facts='no', tasks=self.tasks) self.results_callback = ResultCallback(self.results)
become=None, become_method=None, become_user=None, check=False, diff=False) # 初始化所需对象 loader = DataLoader() # 负责查找和读取yaml、json和ini文件 passwords = dict(vault_pass='******') # 实例化resultcallback,以便在结果传入时处理它们。 # Ansible希望这是其主要的展示渠道之一。 results_callback = ResultCallback() # 创建清单,使用作为源的主机配置文件路径,或使用逗号分隔的字符串作为主机 inventory = InventoryManager(loader=loader, sources='localhost,') # 变量管理器负责合并所有不同的源,以便为您提供每个上下文中可用变量的统一视图。 variable_manager = VariableManager(loader=loader, inventory=inventory) # 创建代表我们的游戏(包括任务)的数据结构,这基本上是我们的yaml加载程序在内部所做的。 play_source = dict( name="Ansible Play", hosts='localhost', gather_facts='no', tasks=[ dict(action=dict(module='shell', args='ls'), register='shell_out'), dict(action=dict(module='debug', args=dict( msg='{{shell_out.stdout}}'))) ]) # 创建play object,playbook objects使用。
def _run_ansible(self, args): """Actually build an run an ansible play and return the results""" zclass = args.pop('zbx_class') # The leadup to the TaskQueueManager() call below is # copy pasted from Ansible's example: # https://docs.ansible.com/ansible/developing_api.html#python-api-2-0 # pylint: disable=invalid-name Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff' ]) loader = DataLoader() options = Options(connection='local', module_path=None, forks=1, become=None, become_method=None, become_user=None, check=False, diff=False) passwords = dict(vault_pass='******') results_callback = ResultsCallback() inventory = InventoryManager(loader=loader) variable_manager = VariableManager(loader=loader, inventory=inventory) play_source = dict(name="Ansible Play", hosts=self.pattern, gather_facts='no', tasks=[ dict(action=dict(module=zclass, args=args)), ]) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) tqm = None try: tqm = TaskQueueManager(inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=results_callback) return_code = tqm.run(play) finally: if tqm is not None: tqm.cleanup() # Remove ansible tmpdir shutil.rmtree(C.DEFAULT_LOCAL_TMP, True) if return_code != 0: raise ResultsException( "Ansible module run failed, no results given.") if results_callback.result.is_unreachable(): message = "Ansible module run failed: module output:\n%s" % \ json.dumps(results_callback.raw_result, indent=4) raise ResultsException(message) if results_callback.result.is_failed(): raise ResultsException(results_callback.raw_result) return results_callback.raw_result
def ansible_adhoc(module, args, host): class ResultCallback(CallbackBase): def v2_runner_on_ok(self, result, **kwargs): host = result._host self.data = {host.name: result._result} return self.data Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff' ]) # initialize needed objects loader = DataLoader() options = Options( connection='smart', module_path= '/ops-data/zp/haha/mysite-11/lib/python3.6/site-packages/ansible', forks=100, become=None, become_method=None, become_user=None, check=False, diff=False) passwords = dict(vault_pass='******') # Instantiate our ResultCallback for handling results as they come in results_callback = ResultCallback() # create inventory and pass to var manager inventory = InventoryManager(loader=loader, sources=['/etc/ansible/hosts']) variable_manager = VariableManager(loader=loader, inventory=inventory) # create play with tasks play_source = dict(name="Ansible Play", hosts=host, gather_facts='no', tasks=[ dict(action=dict(module=module, args=args), register='shell_out') ]) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=results_callback, ) result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() return results_callback.data
class AnsibleApi(object): def __init__(self): self.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', 'diff']) self.options = self.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) self.loader = DataLoader() self.inventory = InventoryManager(loader=self.loader, sources=['/opt/myops/myansible/hosts']) self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) self.callback = ModelResultsCollector() self.passwords = dict() def display_hosts(self): groups = self.inventory.get_groups_dict() groups = json.dumps(groups, sort_keys=False, indent=4) return groups def runansible(self,host_list, task_list): play_source = dict( name = "Ansible Play", hosts = host_list, gather_facts = 'no', tasks = task_list ) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=self.callback, ) result = tqm.run(play) result_raw = {'success':{},'failed':{},'unreachable':{}} for host,result in self.callback.host_ok.items(): result_raw['success'][host] = result._result for host,result in self.callback.host_failed.items(): result_raw['failed'][host] = result._result for host,result in self.callback.host_unreachable.items(): result_raw['unreachable'][host] = result._result js = json.dumps(result_raw, sort_keys=False, indent=4) return js