def _provision_node(self, node_name, ip_address, playbook_name): # playbook_path = '/etc/ansible/install_git.yml' user = None password = None playbook_path = playbook_name host_name = ip_address # if not os.path.exists(playbook_path): # raise Exception('The playbook does not exist') variable_manager = VariableManager() loader = DataLoader() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[host_name]) variable_manager.set_inventory(inventory) options = Options(connection='smart', become_user=user) passwords = {} host = inventory.get_host(host_name) variable_manager.set_host_variable(host, 'connection', 'ssh') variable_manager.set_host_variable(host, 'ansible_ssh_user', 'root') variable_manager.set_host_variable(host, 'ansible_ssh_pass', 'root') pbex = PlaybookExecutor( playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) try: pbex.run() except Exception as ex: click.echo(ex.message)
def execute_playbook(playbook, host, *args, **kwargs): playbook = os.path.join(playbook_store_path,playbook) Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'remote_user', 'listhosts', 'listtasks', 'listtags', 'syntax', 'verbose']) #needed objects variable_manager = VariableManager() loader = DataLoader() options = Options(connection='ssh', module_path='./modules', forks=100, become=None, become_method=None, become_user=None, check=False, remote_user='******', listhosts=None, listtasks=None, listtags=None, syntax=None, verbose=None) passwords = dict(vault_pass='******') #Create inventory and pass to manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[host]) variable_manager.set_inventory(inventory) hostobj = inventory.get_host(host) for varname, value in kwargs.iteritems(): variable_manager.set_host_variable(hostobj, varname, value) #Should execute fine executor = PlaybookExecutor(playbooks=[ playbook ], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords) #Forcing our callback object into the executor executor._tqm._stdout_callback = "json" results = executor.run() pprint.pprint(results) report_tasks = executor._tqm._stdout_callback.results[0]['tasks'] report = executor._tqm._stdout_callback.results report_stats = executor._tqm._stats.summarize(host) results_output = get_output(report_tasks, host) return dict(stats = report_stats, results = results_output)
def _run_play(self, play_source, host_vars): host_list = play_source['hosts'] loader = dataloader.DataLoader() variable_manager = VariableManager() inventory_inst = inventory.Inventory(loader=loader, variable_manager=variable_manager, host_list=host_list) variable_manager.set_inventory(inventory_inst) for host, variables in host_vars.items(): host_inst = inventory_inst.get_host(host) for var_name, value in variables.items(): if value is not None: variable_manager.set_host_variable(host_inst, var_name, value) storage = [] callback = MyCallback(storage) tqm = task_queue_manager.TaskQueueManager( inventory=inventory_inst, variable_manager=variable_manager, loader=loader, options=self.options, passwords=self.passwords, stdout_callback=callback, ) # create play play_inst = play.Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it try: tqm.run(play_inst) finally: tqm.cleanup() return storage
def run(self): # insert node for ip in self.hosts: self._node_map[ip] = Service.new_node(self.task_id, ip) variable_manager = VariableManager() Logger.debug("start write ssh_key for task: {} global_id : {}".format( self.task_id, self.global_id)) key_files = [] group = Group(self.task_id) for h in self.hosts: # get ssh_key content key_content = _get_ssh_key(h) Logger.debug("read ssh_key for host: {} global_id: {}".format( h, self.global_id)) # write ssh private key key_path = _write_ssh_key(h, key_content) #key_path="./tmp/97" Logger.debug("write ssh_key for host: {} global_id: {}".format( h, self.global_id)) host_vars = dict(ansible_port=22, ansible_user=self.user, ansible_ssh_private_key_file="./" + key_path) Logger.debug("key_path: {} global_id: {}".format( key_path, self.global_id)) key_files.append(key_path) host = Host(h) host.vars = host_vars group.add_host(host) # add params to each host if self.params is not None and isinstance(self.params, dict): for h in group.hosts: for key in self.params.keys(): variable_manager.set_host_variable(h, key, self.params[key]) Logger.debug("success write ssh_key for task: {} global_id: {}".format( self.task_id, self.global_id)) # other options ssh_args = '-oControlMaster=auto -oControlPersist=60s -oStrictHostKeyChecking=no' options = _Options(connection='ssh', module_path='./ansible/library', forks=self.forks, timeout=10, remote_user=None, private_key_file=None, ssh_common_args=ssh_args, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user=None, verbosity=None, check=False) if self.tasktype == "ansible_task": Logger.debug( "ansible tasks set******************* global_id: {}".format( self.global_id)) play_source = dict(name=self.task_id, hosts=self.task_id, gather_facts='yes', tasks=self.tasks) else: Logger.debug( "ansible role set******************* global_id: {}".format( self.global_id)) play_source = dict(name=self.task_id, hosts=self.task_id, gather_facts='yes', roles=self.tasks) Logger.debug("start load play for task: {} global_id: {}".format( self.task_id, self.global_id)) # make playbook playbook = Play().load(play_source, variable_manager=variable_manager, loader=_Loader) inventory = Inventory(loader=_Loader, variable_manager=variable_manager) inventory.add_group(group) call_back = SyncCallbackModule(debug=True, step_callback=self._step_callback, global_id=self.global_id, source=self.source, tag_hosts=self.hosts) Logger.debug("success load play for task: {} global_id: {}".format( self.task_id, self.global_id)) # task queue tqm = TaskQueueManager(inventory=inventory, variable_manager=variable_manager, loader=_Loader, options=options, passwords=None, stdout_callback=call_back) try: back = tqm.run(playbook) Logger.info("back: {} global_id : {}".format( str(back), self.global_id)) if back != 0: raise Exception("playbook run failed") return back finally: if tqm is not None: tqm.cleanup() _rm_tmp_key(key_files)
if variables['openslides_instance_projector_logo'] is None: print("NONE LOGO!!") variables['openslides_instance_projector_logo'] = '' # check if instance if already created instance_path = path.join(options.instances_dir, variables['openslides_instance_id']) role = options.ansible_role is_add = role == 'openslides-add-instance' if path.exists(instance_path) and is_add and not options.force: raise Exception("instance already created") variables['openslides_instance_path'] = instance_path for key, value in variables.items(): variable_manager.set_host_variable(Host(name='localhost'), key, value) loader = DataLoader() playoptions = Options(connection='local', module_path='/path/to/mymodules', forks=100, become=None, become_method='sudo', become_user=None, check=False) passwords = dict(vault_pass='******') # Instantiate our ResultCallback for handling results as they come in results_callback = ResultCallback(path.join(options.instances_dir, 'ansible.{}.log.json'.format(variables['openslides_instance_id']))) # create inventory and pass to var manager inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='localhost') variable_manager.set_inventory(inventory)
def deploy(self): templatedb = {} if self._templatename: with open('/var/www/webvirtmgr/ansiblefunc/playbook/template', 'r') as template: lines = template.readlines() for line in lines: templatedb[line.split(',')[0]] = line.split(',')[1] with open( '/var/www/webvirtmgr/ansiblefunc/playbook/deploy_templ.yml', 'r') as source: lines = source.readlines() with open( '/var/www/webvirtmgr/ansiblefunc/playbook/deploy.yml.do', 'w') as dest: for line in lines: dest.write( line.replace('!host!', self._supervisorip)) else: with open('/var/www/webvirtmgr/ansiblefunc/playbook/deploy.yml', 'r') as source: lines = source.readlines() with open( '/var/www/webvirtmgr/ansiblefunc/playbook/deploy.yml.do', 'w') as dest: for line in lines: dest.write(line.replace('!host!', self._supervisorip)) variable_manager = VariableManager() loader = DataLoader() supervisor = host.Host(name=self._supervisorip, port=None) variable_manager.set_host_variable(supervisor, 'vmname', self._vmname) variable_manager.set_host_variable(supervisor, 'rootpass', self._rootpass) variable_manager.set_host_variable(supervisor, 'memory', self._memory) variable_manager.set_host_variable(supervisor, 'cpu', self._cpu) variable_manager.set_host_variable(supervisor, 'rootimage', self._rootimage) variable_manager.set_host_variable(supervisor, 'network', self._network) variable_manager.set_host_variable(supervisor, 'inittype', self._inittype) variable_manager.set_host_variable(supervisor, 'images', self._images) if not self._templatename: variable_manager.set_host_variable(supervisor, 'installedpackage', self._installedpackage) else: variable_manager.set_host_variable( supervisor, 'template', templatedb[self._templatename].strip()) inventory = Inventory( loader=loader, variable_manager=variable_manager, host_list='/var/www/webvirtmgr/ansiblefunc/playbook/hosts') if not os.path.exists(self._playbook): print 'playbook not found' sys.exit() options_tuple = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', 'connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check' ]) options = options_tuple(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_user='******', private_key_file=self._keyfile, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=True, become_method=None, become_user='******', verbosity=None, check=False) variable_manager.extra_vars = {'hosts': self._supervisorip} pbex = PlaybookExecutor(playbooks=[self._playbook], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords={}) results = pbex.run() print results
def _get_playbook_executor(self, variables, verbosity): Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax', 'diff' ]) # -v given to us enables ansibles non-debug output. # So -vv should become ansibles -v. __main__.display.verbosity = max(0, verbosity - 1) # make sure ansible does not output warnings for our paternoster pseudo-play __main__._real_warning = __main__.display.warning def display_warning(msg, *args, **kwargs): if not msg.startswith('Could not match supplied host pattern'): __main__._real_warning(msg, *args, **kwargs) __main__.display.warning = display_warning loader = DataLoader() if ANSIBLE_VERSION < LooseVersion('2.4.0'): from ansible.inventory import Inventory variable_manager = VariableManager() inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='localhost,') variable_manager.set_inventory(inventory) else: from ansible.inventory.manager import InventoryManager inventory = InventoryManager(loader=loader, sources='localhost,') variable_manager = VariableManager(loader=loader, inventory=inventory) # force ansible to use the current python executable. Otherwise # it can end up choosing a python3 one (named python) or a different # python 2 version variable_manager.set_host_variable(inventory.localhost, 'ansible_python_interpreter', sys.executable) for name, value in variables: variable_manager.set_host_variable(inventory.localhost, name, value) pexec = PlaybookExecutor( playbooks=[self._playbook], inventory=inventory, variable_manager=variable_manager, loader=loader, options=Options( connection='local', module_path=None, forks=1, listhosts=False, listtasks=False, listtags=False, syntax=False, become=None, become_method=None, become_user=None, check=False, diff=False, ), passwords={}, ) ansible.constants.RETRY_FILES_ENABLED = False if not verbosity: # ansible doesn't provide a proper API to overwrite this, # if you're using PlaybookExecutor instead of initializing # the TaskQueueManager (_tqm) yourself, like in the offical # example. pexec._tqm._stdout_callback = MinimalAnsibleCallback() return pexec
class Runner(object): """Ansible Playbook runner.""" def __init__(self, username, playbook, private_key_file, inventory_data, extra_vars, become_pass, verbosity=0, search_filter=None): """ Args: username: string, username of user running the playbook playbook: string, full playbook path eg. /tmp/my_pb.yml private_key_file: string, private key file inventory_data: dict, inventory data extra_vars: dict, Ansible extra vars, key = variable name become_pass: string, become password verbosity: integer, verbosity level search_filter: string, hosts/groups to match """ self.playbook = playbook self.username = username self.inventory_data = inventory_data self.extra_vars = extra_vars self.search_filter = search_filter self.options = Options() self.options.private_key_file = private_key_file self.options.verbosity = verbosity self.options.connection = 'ssh' # Need a connection type "smart" or "ssh" self.options.become = True self.options.become_method = 'sudo' self.options.become_user = '******' # Set global verbosity self.display = Display() self.display.verbosity = self.options.verbosity # Executor appears to have it's own verbosity object/setting as well playbook_executor.verbosity = self.options.verbosity # Become Pass Needed if not logging in as user root passwords = {'become_pass': become_pass} # Gets data from YAML/JSON files self.loader = DataLoader() # ORIGNAL on line 1 #self.loader.set_vault_password(os.environ['VAULT_PASS']) self.loader.set_vault_password('secret') # All the variables from all the various places self.variable_manager = VariableManager() # Set of hosts hosts = set() # Load group variable for group in self.inventory_data: if group != '_meta': for host in self.inventory_data[group]['hosts']: host_obj = Host(host) hosts.add(host) for var in self.inventory_data[group]['vars']: self.variable_manager.set_host_variable( host_obj, var, self.inventory_data[group]['vars'][var]) # Load host variables for host in self.inventory_data['_meta']['hostvars']: for var in self.inventory_data['_meta']['hostvars'][host]: host_obj = Host(host) self.variable_manager.set_host_variable( host_obj, var, self.inventory_data['_meta']['hostvars'][host][var]) self.variable_manager.extra_vars = self.extra_vars # Set inventory, using most of above objects self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=list(hosts)) self.variable_manager.set_inventory(self.inventory) # Setup playbook executor, but don't run until run() called self.pbex = playbook_executor.PlaybookExecutor( playbooks=[self.playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=passwords) def run(self): """Run playbook.""" # Results of PlaybookExecutor stats = None play_recap = {} try: self.pbex.run() stats = self.pbex._tqm._stats except AnsibleError as error: print 'Error', error self.pbex._tqm.send_callback('record_logs', username=self.username, success=False, extra_vars=self.extra_vars, playbook=self.playbook, search_filter=self.search_filter) raise AnsibleError finally: if stats: self.pbex._tqm.cleanup() # Test if success for record_logs run_success = True hosts = sorted(stats.processed.keys()) for host in hosts: play_recap = stats.summarize(host) if play_recap['unreachable'] > 0 or play_recap[ 'failures'] > 0: run_success = False # Dirty hack to send callback to save logs with data we want # Note that function "record_logs" is one I created and put into # the playbook callback file self.pbex._tqm.send_callback('record_logs', username=self.username, success=run_success, extra_vars=self.extra_vars, playbook=self.playbook, search_filter=self.search_filter) return play_recap