def listfunction(llist): """This function does all the work and lists groups or hosts""" variable_manager = VariableManager() loader = DataLoader() if not os.path.isfile(inventory_file): print "%s is not a file - halting. Consider using the '--inventory $path/to/ansible_inventory file' parameter" % inventory_file sys.exit(1) else: inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=inventory_file) if chosen_group and single: def traverse(agroup, hostset): """Recursive depth-first traversal""" for child in agroup.child_groups: traverse(child, hostset) if len(agroup.hosts) > 0: hostset.add(agroup.hosts[0].name.encode('utf8')) single_hosts = set() traverse(inventory.groups[chosen_group], single_hosts) return {chosen_group:list(single_hosts)} if chosen_group: thegroup = inventory.groups[chosen_group] newhosts = [] for h in thegroup.get_hosts(): newhosts.append(h.name.encode('utf8')) return {chosen_group:newhosts} else: all_groups = {} for g in inventory.groups: newhosts = [] for h in inventory.get_group(g).get_hosts(): newhosts.append(h.name.encode('utf8')) all_groups[g] = newhosts return all_groups
class InventoryWrapper: def __init__(self, host_list): self.loader = DataLoader() # this code is a bit ugly, because Ansible 2.4 switched the order # of the object and the pattern (InventoryManager is a argument to # VariableManager, and vice-versa on version <2.3) if ANSIBLE_24: self.im = InventoryManager(loader=self.loader, sources=[host_list, ]) self.vm = VariableManager(loader=self.loader, inventory=self.im) else: self.vm = VariableManager() self.im = Inventory(self.loader, self.vm, host_list) def get_loader(self): return self.loader def get_variable_manager(self): return VariableManagerWrapper(self.vm) def get_groups(self): if ANSIBLE_24: return self.im.groups return self.im.get_groups() def get_hosts(self, group): if ANSIBLE_24: return self.im.get_hosts(pattern=group) return self.im.get_hosts(group) def get_host(self, host): return self.im.get_host(host) def refresh_inventory(self): return self.im.refresh_inventory()
def __init__(self, ctrl, vault_password=None): from ploy_ansible import get_playbooks_directory kwargs = dict(host_list=[]) if vault_password is not None: kwargs['vault_password'] = vault_password BaseInventory.__init__(self, **kwargs) self.ctrl = ctrl self.set_playbook_basedir(get_playbooks_directory(ctrl.config)) groups = {} groups['all'] = self.get_group('all') seen = set() for instance in self.ctrl.instances.values(): if instance.uid in seen: continue seen.add(instance.uid) h = Host(instance.uid) add_to = ['all', '%ss' % instance.sectiongroupname] if hasattr(instance, 'master'): master = instance.master if instance == getattr(master, 'instance', None): add_to.append('masters') else: add_to.append('%s-instances' % master.id) for group in add_to: g = groups.get(group) if g is None: g = self.get_group(group) if g is None: g = Group(group) self.add_group(g) groups[group] = g g.add_host(h) self._vars_plugins = [x for x in utils.plugins.vars_loader.all(self)]
def run_ansible_in_python(task): stats = callbacks.AggregateStats() ## everything between this comment ## and the "end" should hopefully not be necessary ## after Ansible 1.4.6 or 1.5 is released, since there ## will be an implicit sys.executable interpreter for the localhost ## host. This will almost certainly need tweaking anyway for dynamic inventory ## in ec2. I'm not sure yet how this would work. localhost = Host('localhost') localhost.set_variable('ansible_python_interpreter', sys.executable) all_group = Group('all') all_group.add_host(localhost) inventory = Inventory(None) inventory.add_group(all_group) os.putenv('EC2_INI_PATH', 'lib/glue/ec2-external.ini') ec2_inventory = InventoryScript(filename='lib/glue/ec2.py') inventory.parser = ec2_inventory [inventory.add_group(group) for group in ec2_inventory.groups.values()] ## end pb = playbook.PlayBook(playbook=task.inputs[0].abspath(), inventory=inventory, stats=stats, callbacks=callbacks.PlaybookCallbacks(verbose=3), runner_callbacks=callbacks.PlaybookRunnerCallbacks(stats, verbose=3) ) pb.run()
class Inventory(object): def __init__(self, inventory_path): """ The Inventory class provides methods to extract information from the specified ansible inventory file. :param inventory_path: The path to the inventory file :type inventory_path: String """ from ansible.inventory import Inventory as AnsibleInventory from ansible.parsing.dataloader import DataLoader from ansible.vars import VariableManager self._inventory = AnsibleInventory(loader=DataLoader(), variable_manager=VariableManager(), host_list=inventory_path) def get_ansible_inventory(self): return self._inventory def get_hosts(self, pattern='all'): return self._inventory.get_hosts(pattern) def get_groups(self): return self._inventory.get_groups()
def run_installer(user_list, package_list, sudo_password): """ Runs the playbook `installer.yml` with the supplied parameters """ # Create the inventory controller = Host(name="localhost") controller.set_variable("users", user_list) controller.set_variable("apt_packages", package_list) local_inventory = Inventory([]) local_inventory.get_group("all").add_host(controller) # Boilerplate for callbacks setup utils.VERBOSITY = 0 # Output callbacks setup output_callbacks = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY) # API callbacks setup stats = callbacks.AggregateStats() api_callbacks = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY) provision_playbook = PlayBook( playbook="installer.yml", stats=stats, callbacks=output_callbacks, runner_callbacks=api_callbacks, inventory=local_inventory, transport="local", become_pass=sudo_password, ) playbook_result = provision_playbook.run() return playbook_result
def __init__(self, aws): BaseInventory.__init__( self, host_list=[]) self.aws = aws ansible_config = aws.config.get('global', {}).get('ansible', {}) if 'playbooks-directory' in ansible_config: self.set_playbook_basedir(ansible_config['playbooks-directory']) groups = {} groups['all'] = self.get_group('all') for instance in self.aws.instances.values(): h = Host(instance.id) add_to = ['all', '%ss' % instance.sectiongroupname] if hasattr(instance, 'master'): master = instance.master if instance == getattr(master, 'instance', None): add_to.append('masters') else: add_to.append('%s-instances' % master.id) for group in add_to: g = groups.get(group) if g is None: g = self.get_group(group) if g is None: g = Group(group) self.add_group(g) groups[group] = g g.add_host(h) self._vars_plugins = [] self._vars_plugins.append(VarsModule(self))
class NetworkTest(object): def __init__(self, playbook): self.inventory = Inventory(host_list=[]) self.playbook = playbook self.stac_nodes_group = Group(name='stac_nodes') self.inventory.add_group(self.stac_nodes_group) self.inv_vars = dict() def set_inventory_vars(self, inv_vars): self.inv_vars.update(inv_vars) def add_stac_node(self, node): stac_node = Host(name=node) self.stac_nodes_group.add_host(stac_node) def run(self): stats = AggregateStats() playbook_cb = PlaybookCallbacks(verbose=utils.VERBOSITY) runner_cb = PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY) pb = playbook.PlayBook(playbook=self.playbook, stats=stats, callbacks=playbook_cb, runner_callbacks=runner_cb, inventory=self.inventory, extra_vars=self.inv_vars, check=False) pr = pb.run() print json.dumps(pr, sort_keys=True, indent=4, separators=(',', ': '))
def get_ip(): tag = "tag_Name_" + request.args.get('host') env = request.args.get('env') eip = request.args.get('eip').capitalize() if 'eip' in request.url else False inventory_file = ec2_inventory_path + env + "/ec2.py" if env not in envs: return make_response(json.dumps({'error': env + ' Environment not found'}),400) inv = Inventory(inventory_file) if len(inv.get_hosts(tag)) == 0: msg = "No Host match for {} in {}".format(request.args.get('host'), env) return make_response(json.dumps({'error': msg}),400) if eip == False: #print "Checking IP of {} for Env: {}".format(tag,env) ipaddr = ','.join([ ip.name for ip in inv.get_hosts(tag)]) else: #print "Checking EIP of {} for Env: {}".format(tag,env) data = ansible.runner.Runner( module_name='debug', pattern=tag, inventory = inv, transport = 'local', module_args="var=hostvars['{{ inventory_hostname }}']['ec2_ip_address']" ).run() element = data['contacted'].keys() ipaddr = ','.join([ ''.join(data['contacted'][e]['var'].values()) for e in element]) if len(ipaddr) == 0: msg = "No EIP Found for {} in {}".format(request.args.get('host'), env) return make_response(json.dumps({'error': msg}),400) return ipaddr
def add_group(self, group): if isinstance(group, basestring): group = Group(group) try: self.log.debug('add inventory group: %s' % group.name) AnsibleInventory.add_group(self, group) except AnsibleError, emsg: raise InventoryError(emsg)
class Runner(object): def __init__(self, playbook, display, hosts=None, options={}, passwords={}, vault_pass=None): self.options = Options() for k, v in options.iteritems(): setattr(self.options, k, v) self.display = display self.display.verbosity = self.options.verbosity # executor has its own verbosity setting playbook_executor.verbosity = self.options.verbosity # gets data from YAML/JSON files self.loader = DataLoader() if vault_pass is not None: self.loader.set_vault_password(vault_pass) elif 'VAULT_PASS' in os.environ: self.loader.set_vault_password(os.environ['VAULT_PASS']) # all the variables from all the various places self.variable_manager = VariableManager() if self.options.python_interpreter is not None: self.variable_manager.extra_vars = { 'ansible_python_interpreter': self.options.python_interpreter } # set inventory, using most of above objects self.inventory = Inventory( loader=self.loader, variable_manager=self.variable_manager, host_list=hosts) if len(self.inventory.list_hosts()) == 0: self.display.error("Provided hosts list is empty.") sys.exit(1) self.inventory.subset(self.options.subset) if len(self.inventory.list_hosts()) == 0: self.display.error("Specified limit does not match any hosts.") sys.exit(1) self.variable_manager.set_inventory(self.inventory) # 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, options=self.options, passwords=passwords) def run(self): # run playbook and get stats self.pbex.run() stats = self.pbex._tqm._stats return stats
def test_leading_range(self): i = Inventory(os.path.join(self.test_dir, "inventory", "test_leading_range")) hosts = i.list_hosts("test") expected_hosts = ["1.host", "2.host", "A.host", "B.host"] assert sorted(hosts) == sorted(expected_hosts) hosts2 = i.list_hosts("test2") expected_hosts2 = ["1.host", "2.host", "3.host"] assert sorted(hosts2) == sorted(expected_hosts2)
def test_leading_range(self): i = Inventory(os.path.join(self.test_dir, 'inventory','test_leading_range')) hosts = i.list_hosts('test') expected_hosts=['1.host','2.host','A.host','B.host'] assert sorted(hosts) == sorted(expected_hosts) hosts2 = i.list_hosts('test2') expected_hosts2=['1.host','2.host','3.host'] assert sorted(hosts2) == sorted(expected_hosts2)
class MyInventory(Inventory): """ this is my ansible inventory object. """ def __init__(self): self.inventory = Inventory(my_inventory) #self.gen_inventory() def my_add_group(self, hosts, groupname, groupvars=None): """ add hosts to a group """ my_group = Group(name=groupname) # if group variables exists, add them to group if groupvars: for key, value in groupvars.iteritems(): my_group.set_variable(key, value) # add hosts to group for host in hosts: # 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) my_host.set_variable('ansible_ssh_host', hostip) my_host.set_variable('ansible_ssh_port', hostport) my_host.set_variable('ansible_ssh_user', username) 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.iteritems(): if key not in ["hostname", "port", "username", "password"]: my_host.set_variable(key, value) # add to group my_group.add_host(my_host) self.inventory.add_group(my_group) def gen_inventory(self): """ add hosts to inventory. """ if isinstance(self.resource, list): self.my_add_group(self.resource, 'default_group') elif isinstance(self.resource, dict): for groupname, hosts_and_vars in self.resource.iteritems(): self.my_add_group( hosts_and_vars.get("hosts"), groupname, hosts_and_vars.get("vars"))
def build_inventory(loader, variable_manager, group_names, playbook_basedir): inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=['localhost']) # because we just pass in a "host list" which isn't a real inventory file, # we explicitly have to add all of the desired groups to the inventory. By # default an "all" group is created whenever a new inventory is created for group_name in group_names: if not inventory.get_group(group_name): inventory.add_group(Group(group_name)) # because we are explicitly adding groups, we also need to make sure that a # playbook basedir is set so that `group_vars` can be loaded from the # correct directory. inventory.set_playbook_basedir(playbook_basedir) inventory_hosts = inventory.get_hosts() # for each group specified, ensure that the inventory's host (localhost) is # explicitly in the group. for group_name in group_names: group = inventory.get_group(group_name) if group.get_hosts(): continue for host in inventory.get_hosts(): group.add_host(host) return inventory
def render_GET(self, request): i = Inventory() inv = [] try: hosts = i.get_hosts() groups = i.get_groups() except: return self.error_page(request) inv.extend([{"name": x.name, "type":"host"} for x in sorted(hosts)]) inv.extend([{"name": x.name, "type":"group"} for x in sorted(groups)]) return jsonify(request, inv)
def __init__(self, host_list): self.loader = DataLoader() # this code is a bit ugly, because Ansible 2.4 switched the order # of the object and the pattern (InventoryManager is a argument to # VariableManager, and vice-versa on version <2.3) if ANSIBLE_24: self.im = InventoryManager(loader=self.loader, sources=[host_list, ]) self.vm = VariableManager(loader=self.loader, inventory=self.im) else: self.vm = VariableManager() self.im = Inventory(self.loader, self.vm, host_list)
def pytest_generate_tests(self, metafunc): log.debug("pytest_generate_tests() called") if 'ansible_host' in metafunc.fixturenames: # assert required --ansible-* parameters were used self.assert_required_ansible_parameters() # TODO: this doesn't support function/cls fixture overrides try: inventory_manager = Inventory(self.config.getvalue('ansible_inventory')) except ansible.errors.AnsibleError, e: raise pytest.UsageError(e) pattern = self.config.getvalue('ansible_host_pattern') metafunc.parametrize("ansible_host", inventory_manager.list_hosts(pattern))
class MyInventory(Inventory): def __init__(self, resource): """ resource的数据格式是一个列表字典,比如 { "group1": { "hosts": [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...], "vars": {"var1": value1, "var2": value2, ...} } } 如果你只传入1个列表,这默认该列表内的所有主机属于my_group组,比如 [{"hostname": "10.10.10.10", "port": "22", "username": "******", "password": "******"}, ...] """ self.resource = resource self.inventory = Inventory(host_list=[]) self.gen_inventory() def my_add_group(self, hosts, groupname, groupvars=None): my_group = Group(name=groupname) if groupvars: for key, value in groupvars.iteritems(): my_group.set_variable(key, value) for host in hosts: hostname = host.get('hostname') hostip = host.get('ip', hostname) hostport = host.get('port', 22) username = host.get('username', 'root') password = host.get('password') ssh_key = host.get("ssh_key") my_host = Host(name=hostname, port=hostport) my_host.set_variable('ansible_ssh_host', hostip) my_host.set_variable('ansible_ssh_port', hostport) my_host.set_variable('ansible_ssh_user', username) my_host.set_variable('ansible_ssh_pass', password) my_host.set_variable('ansible_ssh_private_key_file', ssh_key) for key, value in host.iteritems(): if key not in ['hostname', 'port', 'username', 'password']: my_host.set_variable(key, value) my_group.add_host(my_host) self.inventory.add_group(my_group) def gen_inventory(self): if isinstance(self.resource, list): self.my_add_group(self.resource, 'default_group') elif isinstance(self.resource, dict): for groupname, hosts_and_vars in self.resource.iteritems(): self.my_add_group(hosts_and_vars.get('hosts'), groupname, hosts_and_vars.get('vars'))
def notifyCanary(): inven = Inventory(host_list=path["hosts"]); groups = inven.get_groups(); for group in groups: # print group.get_variables() if group.name == "canary": hosts = inven.get_hosts(group.name) for host in hosts: host_ip = host.get_variables()['ansible_ssh_host'] url = 'http://'+proxy_server+':'+proxy_port+"/canary" payload = {'host': host_ip} headers = {'content-type': 'application/json'} response = requests.post(url, data=payload, headers=headers)
def configure_hosts(self, reservation_obj, playbook): inven = Inventory(host_list=reservation_obj.keys()) for host in inven.get_hosts(): for key, value in reservation_obj[host.name].items(): host.set_variable(key, value) stats = callbacks.AggregateStats() playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY) runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY) pb = PlayBook(inventory=inven, playbook=playbook, stats=stats, callbacks=playbook_cb, runner_callbacks=runner_cb) pb.run()
def run(self): results = None super(InventoryCLI, self).run() # Initialize needed objects if getattr(self, '_play_prereqs', False): self.loader, self.inventory, self.vm = self._play_prereqs(self.options) else: # fallback to pre 2.4 way of initialzing from ansible.vars import VariableManager from ansible.inventory import Inventory self._new_api = False self.loader = DataLoader() self.vm = VariableManager() # use vault if needed if self.options.vault_password_file: vault_pass = CLI.read_vault_password_file(self.options.vault_password_file, loader=self.loader) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords() else: vault_pass = None if vault_pass: self.loader.set_vault_password(vault_pass) # actually get inventory and vars self.inventory = Inventory(loader=self.loader, variable_manager=self.vm, host_list=self.options.inventory) self.vm.set_inventory(self.inventory) if self.options.host: hosts = self.inventory.get_hosts(self.options.host) if len(hosts) != 1: raise AnsibleOptionsError("You must pass a single valid host to --hosts parameter") myvars = self._get_host_variables(host=hosts[0]) self._remove_internal(myvars) # FIXME: should we template first? results = self.dump(myvars) elif self.options.graph: results = self.inventory_graph() elif self.options.list: top = self._get_group('all') if self.options.yaml: results = self.yaml_inventory(top) else: results = self.json_inventory(top) results = self.dump(results) if results: # FIXME: pager? display.display(results) exit(0) exit(1)
def __init__(self, playbook): self.inventory = Inventory(host_list=[]) self.playbook = playbook self.stac_nodes_group = Group(name='stac_nodes') self.inventory.add_group(self.stac_nodes_group) self.inv_vars = dict()
def get_variables(self, hostname, **kwargs): result = BaseInventory.get_variables(self, hostname, **kwargs) if hasattr(self, 'get_host_variables'): result = utils.combine_vars( result, self.get_host_variables( hostname, vault_password=self._vault_password)) return PloyInventoryDict(result)
def find_host_in_inventory(base, host_name): loader = DataLoader() var_manager = VariableManager() host_vars = None host_info = [] for i in get_inventory_files(base): try: inv = Inventory(host_list='%s/%s' %(base, i), loader=loader, variable_manager=var_manager) host_vars = inv.get_vars(host_name) except AnsibleError as err: # print '%s in inventory %s' %(err, i) inv.host_list = None inv.refresh_inventory() continue if host_vars: ssh_host = host_vars.get('ansible_ssh_host', None) ssh_user = host_vars.get('ansible_ssh_user', None) ssh_key = host_vars.get('ansible_ssh_private_key_file', None) ssh_port = host_vars.get('ansible_ssh_port', 22) else: raise Exception('Host %s is not present in any inventory %s' %(host_name, ' '.join(get_inventory_files(base)))) if not ssh_host or not ssh_user: raise Exception('ansible_ssh_host and ansible_ssh_user required.') host_info.append(str('%s@%s' %(ssh_user, ssh_host))) if ssh_key: ssh_key = os.path.expanduser(ssh_key) if not os.path.isabs(ssh_key): ssh_key = os.path.abspath(ssh_key) if os.path.exists(ssh_key): host_info += ['-i', str(ssh_key)] else: print ("SSH key %s doesn't exists please check path." %(ssh_key)) if ssh_port: if not int(ssh_port) == min(max(int(ssh_port), 0), 65535): raise Exception('Incorrect port number given') host_info += ['-p', str(ssh_port)] return host_info
def run(experimentid, playbook_path, host_list=C.DEFAULT_HOST_LIST): # print self.file_name # print self.path # print self.file.read() 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', 'listhosts', 'listtasks', 'listtags', 'syntax', 'host_key_checking']) variable_manager = VariableManager() loader = DataLoader() options = Options(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='******', verbosity=None, check=False, listhosts=None, listtasks=None, listtags=None, syntax=None, host_key_checking=False) passwords = dict(vault_pass='******') # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) #print host_list #print inventory.split_host_pattern(host_list) #inventory.parse_inventory(host_list) #print inventory.host_list #print inventory.get_hosts() variable_manager.set_inventory(inventory) # create the playbook executor, which manages running the plays via a task queue manager # playbook_path = self.file_name pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) # pbex._tqm._callback_plugins.append(C.DEFAULT_STDOUT_CALLBACK) # pbex._tqm._callback_plugins.append('default') # pbex._tqm._callback_plugins.append('default') # pbex._tqm._callback_plugins.append('default') pbex._tqm._callback_plugins.append(AnsibleCallbackModule(experimentid)) # pbex._tqm._callback_plugins.append(TreeCallbackModule()) pbex._playbooks results = pbex.run() # dont forget to clear host cache after finish, otherwise will raise exception when host_list changes in the new round inventory.clear_pattern_cache()
def run(self, terms, variables=None, **kwargs): host_list = [] for term in terms: patterns = Inventory.order_patterns(Inventory.split_host_pattern(term)) for p in patterns: that = self.get_hosts(variables, p) if p.startswith("!"): host_list = [ h for h in host_list if h not in that] elif p.startswith("&"): host_list = [ h for h in host_list if h in that ] else: host_list.extend(that) # return unique list return list(set(host_list))
def __init__(self, inventory_file, module_name, module_args): loader = DataLoader() variable_manager = VariableManager() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=inventory_file) variable_manager.set_inventory(inventory) hosts = [x.name for x in inventory.get_hosts()] play_source = { "name": "Ansible Play", "hosts": hosts, "gather_facts": "no", "tasks": [{ "action": { "module": module_name, "args": module_args } }] } logging.info(play_source) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check']) options = Options(connection='local', module_path='', forks=100, become=None, become_method=None, become_user=None, check=False) self.inventory = inventory self.variable_manager = variable_manager self.loader = loader self.play = play self.options = options self.passwords = {"vault_pass": '******'}
def playbook(**kwargs): group_vars = kwargs['group_vars'] groups = kwargs['groups'] host_list = kwargs['host_list'] playbook_basedir = os.sep.join([ANSIBLE_PLAYBOOK_PATH, kwargs['playbook_basedir']]) playbooks = [] for pb in kwargs['playbooks']: playbooks.append(os.sep.join([playbook_basedir, pb])) job_id = kwargs['job_id'] loader = DataLoader() vars = VariableManager() # 指定inventory为一个目录,设置所有主机,包含group和host invertory = Inventory(loader, vars, host_list=host_list) invertory.set_playbook_basedir(playbook_basedir) for group_name, hosts in groups.items(): t_group = Group(group_name) for host in hosts: t_host = Host(host) t_group.add_host(t_host) invertory.add_group(t_group) vars.set_inventory(invertory) display = LogDisplay(logname=job_id) callback = CALLBACKMODULE[CALLBACK](display=display) Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'timeout', 'remote_user', 'ask_pass', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'ask_value_pass', 'verbosity', 'check', 'listhosts', 'listtags', 'listtasks', 'syntax']) options = Options(connection='smart', module_path='/usr/share/ansible', forks=100, timeout=10, remote_user='******', ask_pass=False, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user='******', ask_value_pass=False, verbosity=None, check=False, listhosts=None, listtags=None, listtasks=None, syntax=None) passwords = dict() pb_executor = PlaybookExecutor(playbooks, invertory, vars, loader, options, passwords) pb_executor._tqm._stdout_callback = callback pb_executor.run() return display.get_log_json()
class MyInventory(Inventory): """inventory""" def __init__(self, resource, loader, variable_manager): self.resource = resource self.inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list=[]) self.dynamic_inventory() def add_dynamic_group(self, hosts, groupname, groupvars=None): """dynamic inventory group""" my_group = Group(name=groupname) if groupvars: for key, value in groupvars.items(): my_group.set_variable(key, value) for host in hosts: # 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) my_host.set_variable('ansible_ssh_host', hostip) my_host.set_variable('ansible_ssh_port', hostport) my_host.set_variable('ansible_ssh_user', username) my_host.set_variable('ansible_ssh_pass', password) my_host.set_variable('ansible_ssh_private_key_file', ssh_key) for key, value in host.items(): if key not in ["hostname", "port", "username", "password"]: my_host.set_variable(key, value) my_group.add_host(my_host) self.inventory.add_group(my_group) def dynamic_inventory(self): 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"))
def simple_inventory(self): return Inventory(self.inventory_file)
def test_simple_string_ipv6_port(self): inventory = Inventory('[FE80:EF45::12:1]:2222,192.168.1.1') hosts = inventory.list_hosts() self.assertEqual(sorted(hosts), sorted(['FE80:EF45::12:1', '192.168.1.1']))
def testinvalid_entry(self): Inventory('1234')
def test_incorrect_format(self): Inventory( os.path.join(self.test_dir, 'inventory', 'test_incorrect_format'))
def test_no_src(self): inventory = Inventory('127.0.0.1,') self.assertEqual(inventory.src(), None)
class ConsoleCLI(CLI, cmd.Cmd): modules = [] def __init__(self, args): super(ConsoleCLI, self).__init__(args) self.intro = 'Welcome to the ansible console.\nType help or ? to list commands.\n' self.groups = [] self.hosts = [] self.pattern = None self.variable_manager = None self.loader = None self.passwords = dict() self.modules = None cmd.Cmd.__init__(self) def parse(self): self.parser = CLI.base_parser( usage='%prog <host-pattern> [options]', runas_opts=True, inventory_opts=True, connect_opts=True, check_opts=True, vault_opts=True, fork_opts=True, module_opts=True, ) # options unique to shell self.parser.add_option( '--step', dest='step', action='store_true', help="one-step-at-a-time: confirm each task before running") self.parser.set_defaults(cwd='*') super(ConsoleCLI, self).parse() display.verbosity = self.options.verbosity self.validate_conflicts(runas_opts=True, vault_opts=True, fork_opts=True) def get_names(self): return dir(self) def cmdloop(self): try: cmd.Cmd.cmdloop(self) except KeyboardInterrupt: self.do_exit(self) def set_prompt(self): login_user = self.options.remote_user or getpass.getuser() self.selected = self.inventory.list_hosts(self.options.cwd) prompt = "%s@%s (%d)[f:%s]" % (login_user, self.options.cwd, len(self.selected), self.options.forks) if self.options.become and self.options.become_user in [None, 'root']: prompt += "# " color = C.COLOR_ERROR else: prompt += "$ " color = C.COLOR_HIGHLIGHT self.prompt = stringc(prompt, color) def list_modules(self): modules = set() if self.options.module_path is not None: for i in self.options.module_path.split(os.pathsep): module_loader.add_directory(i) module_paths = module_loader._get_paths() for path in module_paths: if path is not None: modules.update(self._find_modules_in_path(path)) return modules def _find_modules_in_path(self, path): if os.path.isdir(path): for module in os.listdir(path): if module.startswith('.'): continue elif os.path.isdir(module): self._find_modules_in_path(module) elif module.startswith('__'): continue elif any(module.endswith(x) for x in C.BLACKLIST_EXTS): continue elif module in C.IGNORE_FILES: continue elif module.startswith('_'): fullpath = '/'.join([path, module]) if os.path.islink(fullpath): # avoids aliases continue module = module.replace('_', '', 1) module = os.path.splitext(module)[0] # removes the extension yield module def default(self, arg, forceshell=False): """ actually runs modules """ if arg.startswith("#"): return False if not self.options.cwd: display.error("No host found") return False if arg.split()[0] in self.modules: module = arg.split()[0] module_args = ' '.join(arg.split()[1:]) else: module = 'shell' module_args = arg if forceshell is True: module = 'shell' module_args = arg self.options.module_name = module result = None try: check_raw = self.options.module_name in ('command', 'shell', 'script', 'raw') play_ds = dict( name="Ansible Shell", hosts=self.options.cwd, gather_facts='no', tasks=[ dict(action=dict(module=module, args=parse_kv(module_args, check_raw=check_raw))) ]) play = Play().load(play_ds, variable_manager=self.variable_manager, loader=self.loader) except Exception as e: display.error(u"Unable to build command: %s" % to_text(e)) return False try: cb = 'minimal' # FIXME: make callbacks configurable # now create a task queue manager to execute the play self._tqm = None try: self._tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=cb, run_additional_callbacks=C.DEFAULT_LOAD_CALLBACK_PLUGINS, run_tree=False, ) result = self._tqm.run(play) finally: if self._tqm: self._tqm.cleanup() if self.loader: self.loader.cleanup_all_tmp_files() if result is None: display.error("No hosts found") return False except KeyboardInterrupt: display.error('User interrupted execution') return False except Exception as e: display.error(to_text(e)) # FIXME: add traceback in very very verbose mode return False def emptyline(self): return def do_shell(self, arg): """ You can run shell commands through the shell module. eg.: shell ps uax | grep java | wc -l shell killall python shell halt -n You can use the ! to force the shell module. eg.: !ps aux | grep java | wc -l """ self.default(arg, True) def do_forks(self, arg): """Set the number of forks""" if not arg: display.display('Usage: forks <number>') return self.options.forks = int(arg) self.set_prompt() do_serial = do_forks def do_verbosity(self, arg): """Set verbosity level""" if not arg: display.display('Usage: verbosity <number>') else: display.verbosity = int(arg) display.v('verbosity level set to %s' % arg) def do_cd(self, arg): """ Change active host/group. You can use hosts patterns as well eg.: cd webservers cd webservers:dbservers cd webservers:!phoenix cd webservers:&staging cd webservers:dbservers:&staging:!phoenix """ if not arg: self.options.cwd = '*' elif arg == '..': try: self.options.cwd = self.inventory.groups_for_host( self.options.cwd)[1].name except Exception: self.options.cwd = '' elif arg in '/*': self.options.cwd = 'all' elif self.inventory.get_hosts(arg): self.options.cwd = arg else: display.display("no host matched") self.set_prompt() def do_list(self, arg): """List the hosts in the current group""" if arg == 'groups': for group in self.groups: display.display(group) else: for host in self.selected: display.display(host.name) def do_become(self, arg): """Toggle whether plays run with become""" if arg: self.options.become = C.mk_boolean(arg) display.v("become changed to %s" % self.options.become) self.set_prompt() else: display.display("Please specify become value, e.g. `become yes`") def do_remote_user(self, arg): """Given a username, set the remote user plays are run by""" if arg: self.options.remote_user = arg self.set_prompt() else: display.display( "Please specify a remote user, e.g. `remote_user root`") def do_become_user(self, arg): """Given a username, set the user that plays are run by when using become""" if arg: self.options.become_user = arg else: display.display( "Please specify a user, e.g. `become_user jenkins`") display.v("Current user is %s" % self.options.become_user) self.set_prompt() def do_become_method(self, arg): """Given a become_method, set the privilege escalation method when using become""" if arg: self.options.become_method = arg display.v("become_method changed to %s" % self.options.become_method) else: display.display( "Please specify a become_method, e.g. `become_method su`") def do_check(self, arg): """Toggle whether plays run with check mode""" if arg: self.options.check = C.mk_boolean(arg) display.v("check mode changed to %s" % self.options.check) else: display.display( "Please specify check mode value, e.g. `check yes`") def do_diff(self, arg): """Toggle whether plays run with diff""" if arg: self.options.diff = C.mk_boolean(arg) display.v("diff mode changed to %s" % self.options.diff) else: display.display("Please specify a diff value , e.g. `diff yes`") def do_exit(self, args): """Exits from the console""" sys.stdout.write('\n') return -1 do_EOF = do_exit def helpdefault(self, module_name): if module_name in self.modules: in_path = module_loader.find_plugin(module_name) if in_path: oc, a, _, _ = plugin_docs.get_docstring(in_path) if oc: display.display(oc['short_description']) display.display('Parameters:') for opt in oc['options'].keys(): display.display(' ' + stringc(opt, C.COLOR_HIGHLIGHT) + ' ' + oc['options'][opt]['description'][0]) else: display.error('No documentation found for %s.' % module_name) else: display.error( '%s is not a valid command, use ? to list all valid commands.' % module_name) def complete_cd(self, text, line, begidx, endidx): mline = line.partition(' ')[2] offs = len(mline) - len(text) if self.options.cwd in ('all', '*', '\\'): completions = self.hosts + self.groups else: completions = [ x.name for x in self.inventory.list_hosts(self.options.cwd) ] return [ to_native(s)[offs:] for s in completions if to_native(s).startswith(to_native(mline)) ] def completedefault(self, text, line, begidx, endidx): if line.split()[0] in self.modules: mline = line.split(' ')[-1] offs = len(mline) - len(text) completions = self.module_args(line.split()[0]) return [s[offs:] + '=' for s in completions if s.startswith(mline)] def module_args(self, module_name): in_path = module_loader.find_plugin(module_name) oc, a, _, _ = plugin_docs.get_docstring(in_path) return list(oc['options'].keys()) def run(self): super(ConsoleCLI, self).run() sshpass = None becomepass = None vault_pass = None # hosts if len(self.args) != 1: self.pattern = 'all' else: self.pattern = self.args[0] self.options.cwd = self.pattern # dynamically add modules as commands self.modules = self.list_modules() for module in self.modules: setattr( self, 'do_' + module, lambda arg, module=module: self.default(module + ' ' + arg)) setattr(self, 'help_' + module, lambda module=module: self.helpdefault(module)) self.normalize_become_options() (sshpass, becomepass) = self.ask_passwords() self.passwords = {'conn_pass': sshpass, 'become_pass': becomepass} self.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=self.loader) self.loader.set_vault_password(vault_pass) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords() self.loader.set_vault_password(vault_pass) self.variable_manager = VariableManager() self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.options.inventory) self.variable_manager.set_inventory(self.inventory) no_hosts = False if len(self.inventory.list_hosts()) == 0: # Empty inventory no_hosts = True display.warning( "provided hosts list is empty, only localhost is available") self.inventory.subset(self.options.subset) hosts = self.inventory.list_hosts(self.pattern) if len(hosts) == 0 and not no_hosts: raise AnsibleError( "Specified hosts and/or --limit does not match any hosts") self.groups = self.inventory.list_groups() self.hosts = [x.name for x in hosts] # This hack is to work around readline issues on a mac: # http://stackoverflow.com/a/7116997/541202 if 'libedit' in readline.__doc__: readline.parse_and_bind("bind ^I rl_complete") else: readline.parse_and_bind("tab: complete") histfile = os.path.join(os.path.expanduser("~"), ".ansible-console_history") try: readline.read_history_file(histfile) except IOError: pass atexit.register(readline.write_history_file, histfile) self.set_prompt() self.cmdloop()
class AnsibleTask(object): def __init__(self, targetHost, user, password, os, port): 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' ]) self.options = Options( listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path='/usr/lib/python2.7/site-packages/ansible/modules', 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=False, become_method=None, become_user=None, verbosity=0, check=False) # initialize needed objects self.variable_manager = VariableManager() # self.options = Options( # listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', # module_path='/usr/lib/python2.7/site-packages/ansible/modules', 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=None, check=False # ) self.passwords = {} self.loader = DataLoader() hosts = '''{host} ansible_ssh_user="******" ansible_ssh_pass="******" ansible_ssh_port={port}'''.format( host=targetHost, user=user, password=password, port=port) if os == "windows": hosts = hosts + """ ansible_connection="winrm" ansible_winrm_server_cert_validation=ignore""" # create inventory and pass to var manager self.hostsFile = NamedTemporaryFile(delete=False) # self.hostsFile.write() self.hostsFile.write("""[run_hosts] %s """ % hosts) self.hostsFile.close() self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.hostsFile.name) self.variable_manager.set_inventory(self.inventory) def ansiblePlay(self, module, args): # create play with tasks # args = "ls /" play_source = dict(name="Ansible Play", hosts='all', gather_facts='no', tasks=[ dict(action=dict(module=module, args=args), register='shell_out'), ]) print "Ansible:" print play_source play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # run it results_callback = ResultCallback() tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback=results_callback, ) result = tqm.run(play) if results_callback.error_msg: results_callback.result = { 'msg': "地址或用户名错误,主机连接失败", 'flag': False } else: if results_callback.result == None: data = {'msg': "执行命令有问题或执行不成功", 'flag': False} return data else: results_callback.result["flag"] = True return results_callback.result except AnsibleParserError: code = 1001 results = {'msg': "地址或用户名错误,主机连接失败", 'flag': False} return code, results finally: if tqm is not None: tqm.cleanup() os.remove(self.hostsFile.name) self.inventory.clear_pattern_cache()
def process_playbooks(playbooks_to_run, bitbucket_user, target_ip, hostname, ansible_ssh_pass): playbooks = set(playbooks_to_run) bitbucket = "https://" + bitbucket_user + "@stash.veritas.com/scm/iac/" ansible_user = "******" directory = "/home/" + getpass.getuser() + '/runPlaybooks' + str(os.getpid()) inventory = "jenkins.inv" run_command = "ansible-playbook -i " + inventory + " local.yml" pull_command = "ansible-galaxy install -r requirements.yml" clone_command = "git clone " pattern_mint = "playbook-mint" prog = re.compile(pattern_mint) create a folder to run multiple playbooks try: os.system("mkdir " + directory) os.chdir(directory) except Exception as e: raise Exception("Failed to create diretory: %s" % str(e)) sys.exit() # pull playbooks try: for play in playbooks: clone_playbook = bitbucket + play + ".git" os.system(clone_command + clone_playbook) except Exception as e: raise Exception("Failed to clone playbooks: %s" % str(e)) sys.exit() # pull roles for playbooks try: for play in playbooks: os.chdir(play) print("in dir: " + play) os.system(pull_command) os.chdir(directory) except Exception as e: raise Exception("Failed to pull roles: %s" % str(e)) sys.exit() # invertory and run playbooks Options = namedtuple('Options', ['connection', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'module_path']) 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 = ansible_ssh_pass #dict(vault_pass='******') inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=target_ip)#'localhost') variable_manager.set_inventory(inventory) playbooks = playbooks_to_run #["./test.yaml"] executor = PlaybookExecutor( playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) executor.run()
def exec_playbook(file_name): exec_result = {'success': [], 'failed': [], 'unreachable': []} host_list = ['localhost', 'www.example.com', 'www.google.com'] Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check' ]) # initialize needed objects variable_manager = VariableManager() loader = DataLoader() options = Options(connection='smart', module_path='/usr/share/ansible', forks=100, remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user=None, verbosity=None, check=False) passwords = dict() # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory) # create play with tasks playbook = Playbook(loader).load(file_name, variable_manager=variable_manager, loader=loader) plays = playbook.get_plays() # actually run it tqm = None callback = ResultsCollector() try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, ) tqm._stdout_callback = callback for play in plays: result = tqm.run(play) finally: if tqm is not None: tqm.cleanup() print "UP ***********" for host, result in callback.host_ok.items(): exec_result['success'].append(dict(host=host, result=result._result)) print "FAILED *******" for host, result in callback.host_failed.items(): exec_result['failed'].append(dict(host=host, msg=result._result['msg'])) print "DOWN *********" for host, result in callback.host_unreachable.items(): exec_result['unreachable'].append( dict(host=host, msg=result._result['msg'])) return exec_result
def dir_inventory(self): return Inventory(self.inventory_dir)
def complex_inventory(self): return Inventory(self.complex_inventory_file)
def script_inventory(self): return Inventory(self.inventory_script)
def test_combined_range(self): i = Inventory( os.path.join(self.test_dir, 'inventory', 'test_combined_range')) hosts = i.list_hosts('test') expected_hosts = ['host1A', 'host2A', 'host1B', 'host2B'] assert sorted(hosts) == sorted(expected_hosts)
def exec_ansible(module, args, host, redisKey): class ResultCallback(CallbackBase): def v2_runner_on_ok(self, result, **kwargs): host = result._host self.data = json.dumps({host.name: result._result}, indent=4) print(self.data) Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check' ]) # initialize needed objects variable_manager = VariableManager() loader = DataLoader() #module_path参数指定本地ansible模块包的路径 options = Options( connection='smart', module_path='/usr/local/lib/python3.5/site-packages/ansible/modules/', forks=100, become=None, become_method=None, become_user='******', check=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 #host_list指定本地ansible的hosts文件 inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='/etc/ansible/hosts') variable_manager.set_inventory(inventory) # create play with tasks play_source = dict( name="Ansible Play", #hosts可以指定inventory中的一组主机,也可指定单台主机 hosts=host, gather_facts='no', #task执行列表,如果想一次执行多个任务,可以在列表中添加任务 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) except Exception as err: if redisKey: DsRedis.OpsAnsibleModel.lpush(redisKey, data=err) finally: if tqm is not None: tqm.cleanup msg = json.loads(results_callback.data) new_msg = {} for k in msg: v = msg[k] if 'stdout' in v: v = v['stdout'] new_msg[k] = v new_msg = str(new_msg).replace('\\r\\n', '\<br \>') #new_msg=str(msg).replace('\\r\\n','\<br \/\>') DsRedis.OpsAnsibleModel.lpush(redisKey, data=new_msg) #DsRedis.OpsAnsibleModel.lpush(redisKey, data=msg) return msg
def run(self): super(ConsoleCLI, self).run() sshpass = None becomepass = None vault_pass = None # hosts if len(self.args) != 1: self.pattern = 'all' else: self.pattern = self.args[0] self.options.cwd = self.pattern # dynamically add modules as commands self.modules = self.list_modules() for module in self.modules: setattr( self, 'do_' + module, lambda arg, module=module: self.default(module + ' ' + arg)) setattr(self, 'help_' + module, lambda module=module: self.helpdefault(module)) self.normalize_become_options() (sshpass, becomepass) = self.ask_passwords() self.passwords = {'conn_pass': sshpass, 'become_pass': becomepass} self.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=self.loader) self.loader.set_vault_password(vault_pass) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords() self.loader.set_vault_password(vault_pass) self.variable_manager = VariableManager() self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.options.inventory) self.variable_manager.set_inventory(self.inventory) no_hosts = False if len(self.inventory.list_hosts()) == 0: # Empty inventory no_hosts = True display.warning( "provided hosts list is empty, only localhost is available") self.inventory.subset(self.options.subset) hosts = self.inventory.list_hosts(self.pattern) if len(hosts) == 0 and not no_hosts: raise AnsibleError( "Specified hosts and/or --limit does not match any hosts") self.groups = self.inventory.list_groups() self.hosts = [x.name for x in hosts] # This hack is to work around readline issues on a mac: # http://stackoverflow.com/a/7116997/541202 if 'libedit' in readline.__doc__: readline.parse_and_bind("bind ^I rl_complete") else: readline.parse_and_bind("tab: complete") histfile = os.path.join(os.path.expanduser("~"), ".ansible-console_history") try: readline.read_history_file(histfile) except IOError: pass atexit.register(readline.write_history_file, histfile) self.set_prompt() self.cmdloop()
class TestInventory(unittest.TestCase): patterns = { 'a': ['a'], 'a, b': ['a', 'b'], 'a , b': ['a', 'b'], ' a,b ,c[1:2] ': ['a', 'b', 'c[1:2]'], '9a01:7f8:191:7701::9': ['9a01:7f8:191:7701::9'], '9a01:7f8:191:7701::9,9a01:7f8:191:7701::9': ['9a01:7f8:191:7701::9', '9a01:7f8:191:7701::9'], '9a01:7f8:191:7701::9,9a01:7f8:191:7701::9,foo': ['9a01:7f8:191:7701::9', '9a01:7f8:191:7701::9', 'foo'], 'foo[1:2]': ['foo[1:2]'], 'a::b': ['a::b'], 'a:b': ['a', 'b'], ' a : b ': ['a', 'b'], 'foo:bar:baz[1:2]': ['foo', 'bar', 'baz[1:2]'], } pattern_lists = [[['a'], ['a']], [['a', 'b'], ['a', 'b']], [['a, b'], ['a', 'b']], [['9a01:7f8:191:7701::9', '9a01:7f8:191:7701::9,foo'], ['9a01:7f8:191:7701::9', '9a01:7f8:191:7701::9', 'foo']]] # pattern_string: [ ('base_pattern', (a,b)), ['x','y','z'] ] # a,b are the bounds of the subscript; x..z are the results of the subscript # when applied to string.ascii_letters. subscripts = { 'a': [('a', None), list(string.ascii_letters)], 'a[0]': [('a', (0, None)), ['a']], 'a[1]': [('a', (1, None)), ['b']], 'a[2:3]': [('a', (2, 3)), ['c', 'd']], 'a[-1]': [('a', (-1, None)), ['Z']], 'a[-2]': [('a', (-2, None)), ['Y']], 'a[48:]': [('a', (48, -1)), ['W', 'X', 'Y', 'Z']], 'a[49:]': [('a', (49, -1)), ['X', 'Y', 'Z']], 'a[1:]': [('a', (1, -1)), list(string.ascii_letters[1:])], } ranges_to_expand = { 'a[1:2]': ['a1', 'a2'], 'a[1:10:2]': ['a1', 'a3', 'a5', 'a7', 'a9'], 'a[a:b]': ['aa', 'ab'], 'a[a:i:3]': ['aa', 'ad', 'ag'], 'a[a:b][c:d]': ['aac', 'aad', 'abc', 'abd'], 'a[0:1][2:3]': ['a02', 'a03', 'a12', 'a13'], 'a[a:b][2:3]': ['aa2', 'aa3', 'ab2', 'ab3'], } def setUp(self): v = VariableManager() fake_loader = DictDataLoader({}) self.i = Inventory(loader=fake_loader, variable_manager=v, host_list='') def test_split_patterns(self): for p in self.patterns: r = self.patterns[p] self.assertEqual(r, self.i.split_host_pattern(p)) for p, r in self.pattern_lists: self.assertEqual(r, self.i.split_host_pattern(p)) def test_ranges(self): for s in self.subscripts: r = self.subscripts[s] self.assertEqual(r[0], self.i._split_subscript(s)) self.assertEqual( r[1], self.i._apply_subscript(list(string.ascii_letters), r[0][1])) def test_expand_hostname_range(self): for e in self.ranges_to_expand: r = self.ranges_to_expand[e] self.assertEqual(r, expand_hostname_range(e))
def test_get_hosts(self): inventory = Inventory('127.0.0.1,192.168.1.1') hosts = inventory.get_hosts('!10.0.0.1') hosts_all = inventory.get_hosts('all') self.assertEqual(sorted(hosts), sorted(hosts_all))
def test_alpha_end_before_beg(self): Inventory( os.path.join(self.test_dir, 'inventory', 'test_alpha_end_before_beg'))
def test_simple_string_ipv4(self): inventory = Inventory('127.0.0.1,192.168.1.1') hosts = inventory.list_hosts() self.assertEqual(sorted(hosts), sorted(['127.0.0.1', '192.168.1.1']))
#initialize needed objects variable_manager = VariableManager() loader = DataLoader() options = Options(connection='local', module_path='', forks=100, become=True, become_method='sudo', become_user='******', check=False) passwords = dict(vault_pass='******') #create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='/etc/ansible/hosts') variable_manager.set_inventory(inventory) #create play with tasks play_src = dict( name="server list", hosts="192.168.10.238", gather_facts="no", become="true", tasks=[ dict(name="show facts about all servers", action=dict(module="os_server_facts", auth=dict(auth_url="http://192.168.10.238:5000/v2.0", username="******", password="******",
def test_missing_end(self): Inventory(os.path.join(self.test_dir, 'inventory', 'test_missing_end'))
def __init__(self, resource, loader, variable_manager): self.resource = resource # 创建主机配置清单对象 self.inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[]) self.dynamic_inventory()
def test_invalid_range(self): Inventory( os.path.join(self.test_dir, 'inventory', 'test_incorrect_range'))
def run_playbook(self, playbook_file, playbook_variables=None, option_overrides=None): """ Run a playbook from file with the variables provided. :param playbook_file: the location of the playbook :param playbook_variables: extra variables for the playbook """ # on the first run, the playbook that initializes the # inventory will not have yet run, so we should ensure # that the directory for it exists, at the least, so # ansible doesn't complain if not exists(self.host_list): mkdir(self.host_list) variable_manager = VariableManager() data_loader = DataLoader() inventory = Inventory(loader=data_loader, variable_manager=variable_manager, host_list=self.host_list) variable_manager.set_inventory(inventory) variable_manager.extra_vars = playbook_variables # until Ansible's display logic is less hack-ey we need # to mutate their global in __main__ options = self.generate_playbook_options(playbook_file) display.verbosity = options.verbosity # we want to log everything so we can parse output # nicely later from files and don't miss output due # to the pretty printer, if it's on from ..oct import __file__ as root_dir callback_loader.add_directory( join(dirname(root_dir), 'ansible', 'oct', 'callback_plugins')) constants.DEFAULT_CALLBACK_WHITELIST = [ 'log_results', 'generate_junit' ] environ['ANSIBLE_LOG_ROOT_PATH'] = self.log_directory if options.verbosity == 1: # if the user has not asked for verbose output # we will use our pretty printer for progress # on the TTY constants.DEFAULT_STDOUT_CALLBACK = 'pretty_progress' # we really don't want output in std{err,out} # that we didn't put there, but some code in # Ansible calls directly to the Display, not # through a callback, so we need to ensure # that those raw calls don't go to stdout display.display = partial(display.display, log_only=True) else: # if the user asks for verbose output, we want # to give them nicer output than the default # plugin, anyway constants.DEFAULT_STDOUT_CALLBACK = 'default_with_output_lists' if option_overrides: for key in option_overrides: if hasattr(options, key): setattr(options, key, option_overrides[key]) result = PlaybookExecutor(playbooks=[playbook_file], inventory=inventory, variable_manager=variable_manager, loader=data_loader, options=options, passwords=None).run() if result != TaskQueueManager.RUN_OK: # TODO: this seems bad, but can we discover the thread here to join() it? sleep(0.2) raise ClickException('Playbook execution failed with code ' + str(result))
def test_simple_string_ipv6_vars(self): inventory = Inventory('[FE80:EF45::12:1]:2222,192.168.1.1') var = inventory.get_variables('FE80:EF45::12:1') self.assertEqual(var['ansible_ssh_port'], 2222)
class AnsibleTask(object): def __init__(self, targetHost): 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' ]) # initialize needed objects self.variable_manager = VariableManager() self.options = Options( listtags=False, listtasks=False, listhosts=False, syntax=False, connection='smart', module_path='/usr/lib/python2.7/site-packages/ansible/modules', 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=None, check=False) self.passwords = dict(vault_pass='******') self.loader = DataLoader() # create inventory and pass to var manager self.hostsFile = NamedTemporaryFile(delete=False) self.hostsFile.write(targetHost) self.hostsFile.close() self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.hostsFile.name) self.variable_manager.set_inventory(self.inventory) def ansiblePlay(self, action): # create play with tasks args = "ls /" play_source = dict( name="Ansible Play", hosts='all', gather_facts='no', tasks=[ dict(action=dict(module='shell', args=args), register='shell_out'), dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))) ]) play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader) # run it tqm = None try: tqm = TaskQueueManager( inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=self.passwords, stdout_callback='default', ) result = tqm.run(play) finally: # print result if tqm is not None: tqm.cleanup() os.remove(self.hostsFile.name) self.inventory.clear_pattern_cache() return result
class MyInventory(Inventory): """ this is my ansible inventory object. """ def __init__(self, resource, loader, variable_manager): """ resource的数据格式是一个列表字典,比如 { "group1": { "hosts": [{"hostname": "10.0.0.0", "port": "22", "username": "******", "password": "******"}, ...], "vars": {"var1": value1, "var2": value2, ...} } } 如果你只传入1个列表,这默认该列表内的所有主机属于my_group组,比如 [{"hostname": "10.0.0.0", "port": "22", "username": "******", "password": "******"}, ...] """ self.resource = resource self.inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[]) self.dynamic_inventory() def add_dynamic_group(self, hosts, groupname, groupvars=None): """ add hosts to a group """ my_group = Group(name=groupname) # if group variables exists, add them to group if groupvars: for key, value in groupvars.iteritems(): my_group.set_variable(key, value) # add hosts to group for host in hosts: # 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) my_host.set_variable('ansible_ssh_host', hostip) my_host.set_variable('ansible_ssh_port', hostport) my_host.set_variable('ansible_ssh_user', username) 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.iteritems(): if key not in ["hostname", "port", "username", "password"]: my_host.set_variable(key, value) # add to group my_group.add_host(my_host) self.inventory.add_group(my_group) 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.iteritems(): self.add_dynamic_group(hosts_and_vars.get("hosts"), groupname, hosts_and_vars.get("vars"))
def empty_inventory(self): return Inventory(None)
def large_range_inventory(self): return Inventory(self.large_range_inventory_file)
become_user=None, check=True, remote_user=None, private_key_file=None, ssh_common_args=None, sftp_extra_args=None, scp_extra_args=None, ssh_extra_args=None, verbosity=3)) passwords = dict(vault_pass='') aws_region = 'us-west-2' # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='localhost') variable_manager.set_inventory(inventory) def run(play): tqm = None results = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback='default',