def _run(self): self.start = datetime.now() self.save() # initial jobs for host in Inventory(ANSIBLE_INVENTORY).list_hosts(self.inventory): self.job_set.add(Job(host=host, cmd=self.cmd, start=datetime.now())) self.save() runner = Runner(module_name='shell', module_args=self.cmd, pattern=self.inventory, sudo=self.sudo, forks=ANSIBLE_FORKS, host_list=ANSIBLE_INVENTORY) _, poller = runner.run_async(time_limit=WORKER_TIMEOUT) now = time.time() while True: if poller.completed or time.time( ) - now > WORKER_TIMEOUT: # TIMEOUT break results = poller.poll() results = results.get('contacted') if results: for host, result in results.items(): job = self.job_set.get(host=host) job.end = result.get('end') job.rc = result.get('rc') job.stdout = result.get('stdout') job.stderr = result.get('stderr') job.save() time.sleep(1) jobs_timeout = filter(lambda job: job.rc is None, self.job_set.all()) # rc is None jobs_failed = filter(lambda job: job.rc, self.job_set.all()) # rc > 0 for job in jobs_timeout: job.rc = 1 job.stderr = 'JOB TIMEOUT' # marked as 'TIMEOUT' job.save() self.rc = (jobs_timeout or jobs_failed) and 1 or 0 self.end = datetime.now() self.use = datetime.now() self.save() self.done()
def _run(self): self.start = datetime.now() self.save() # initial jobs for host in Inventory(ANSIBLE_INVENTORY).list_hosts(self.inventory): self.job_set.add(Job(host = host, cmd = self.cmd, start = datetime.now())) self.save() runner = Runner(module_name = 'shell', module_args = self.cmd, pattern = self.inventory, sudo = self.sudo, forks = ANSIBLE_FORKS, host_list = ANSIBLE_INVENTORY) _, poller = runner.run_async(time_limit = WORKER_TIMEOUT) now = time.time() while True: if poller.completed or time.time() - now > WORKER_TIMEOUT: # TIMEOUT break results = poller.poll() results = results.get('contacted') if results: for host, result in results.items(): job = self.job_set.get(host = host) job.end = result.get('end') job.rc = result.get('rc') job.stdout = result.get('stdout') job.stderr = result.get('stderr') job.save() time.sleep(1) jobs_timeout = filter(lambda job: job.rc is None, self.job_set.all()) # rc is None jobs_failed = filter(lambda job: job.rc, self.job_set.all()) # rc > 0 for job in jobs_timeout: job.rc = 1 job.stderr = 'JOB TIMEOUT' # marked as 'TIMEOUT' job.save() self.rc = (jobs_timeout or jobs_failed) and 1 or 0 self.end = datetime.now() self.save() self.done()
def run(self, module_name='shell', module_args='', timeout=10, forks=70, pattern='*', become=False, become_method='sudo', become_user='******', become_pass=''): """ run module from andible ad-hoc. module_name: ansible module_name module_args: ansible module args """ hoc = Runner(module_name=module_name, module_args=module_args, timeout=timeout, inventory=self.inventory, pattern=pattern, forks=forks, become=become, become_method=become_method, become_user=become_user, become_pass=become_pass ) if module_name == 'copy': self.results_raw = hoc.run() else: self.results_raw = hoc.run_async(30)[1].poll() #logger.debug(self.results_raw) return self.results
def run(self, options, args): ''' use Runner lib to do SSH things ''' pattern = args[0] sshpass = becomepass = vault_pass = become_method = None # Never ask for an SSH password when we run with local connection if options.connection == "local": options.ask_pass = False else: options.ask_pass = options.ask_pass or C.DEFAULT_ASK_PASS options.ask_vault_pass = options.ask_vault_pass or C.DEFAULT_ASK_VAULT_PASS # become utils.normalize_become_options(options) prompt_method = utils.choose_pass_prompt(options) (sshpass, becomepass, vault_pass) = utils.ask_passwords(ask_pass=options.ask_pass, become_ask_pass=options.become_ask_pass, ask_vault_pass=options.ask_vault_pass, become_method=prompt_method) # read vault_pass from a file if not options.ask_vault_pass and options.vault_password_file: vault_pass = utils.read_vault_file(options.vault_password_file) extra_vars = utils.parse_extra_vars(options.extra_vars, vault_pass) inventory_manager = inventory.Inventory(options.inventory, vault_password=vault_pass) if options.subset: inventory_manager.subset(options.subset) hosts = inventory_manager.list_hosts(pattern) if len(hosts) == 0: callbacks.display("No hosts matched", stderr=True) sys.exit(0) if options.listhosts: for host in hosts: callbacks.display(' %s' % host) sys.exit(0) if options.module_name in ['command','shell'] and not options.module_args: callbacks.display("No argument passed to %s module" % options.module_name, color='red', stderr=True) sys.exit(1) if options.tree: utils.prepare_writeable_dir(options.tree) runner = Runner( module_name=options.module_name, module_path=options.module_path, module_args=options.module_args, remote_user=options.remote_user, remote_pass=sshpass, inventory=inventory_manager, timeout=options.timeout, private_key_file=options.private_key_file, forks=options.forks, pattern=pattern, callbacks=self.callbacks, transport=options.connection, subset=options.subset, check=options.check, diff=options.check, vault_pass=vault_pass, become=options.become, become_method=options.become_method, become_pass=becomepass, become_user=options.become_user, extra_vars=extra_vars, ) import pdb pdb.set_trace() if options.seconds: callbacks.display("background launch...\n\n", color='cyan') results, poller = runner.run_async(options.seconds) results = self.poll_while_needed(poller, options) else: results = runner.run() return (runner, results)
def __call__(self, *args, **kwargs): ''' Adhoc execution wrapper :param args: module arguments :param kwargs: kwargs[run_async]: Running async kwargs[time_limit]: related to async kwargs[forks]: amount of parallel processes kwargs[remote_user]: costume remote user login kwargs[remote_pass]: costume remote user password kwargs[remote_port]: costume remote port kwargs[transport]: support "ssh, paramiko, local" kwargs[become_user]: connect as sudo user kwargs[become_method]: set to ‘sudo’/’su’/’pbrun’/’pfexec’/’doas’ :return: Future object in case of async, result dict in case of sync ''' # Assemble module argument string module_args = list() if args: module_args += list(args) module_args = ' '.join(module_args) # pop async parameters async = kwargs.pop('run_async', False) time_limit = kwargs.pop('time_limit', 60) # Build module runner object options = dict( inventory=self.inventory_manager, pattern=self.pattern, callbacks=AnsibleRunnerCallback(), module_name=self.module_name, module_args=module_args, complex_args=kwargs, forks=kwargs.pop('forks', C.DEFAULT_FORKS), remote_user=kwargs.pop('remote_user', C.DEFAULT_REMOTE_USER), remote_pass=kwargs.pop('remote_pass', C.DEFAULT_REMOTE_PASS), remote_port=kwargs.pop('remote_port', None), transport=kwargs.pop('connection', C.DEFAULT_TRANSPORT), ) if 'become_user' in kwargs: # Handle >= 1.9.0 options if has_ansible_become: options.update(dict( become=True, become_method=kwargs.pop('become_method', C.DEFAULT_BECOME_METHOD), become_user=kwargs.pop('become_user', C.DEFAULT_BECOME_USER) )) else: options.update(dict( sudo=True, sudo_user=kwargs.pop('become_user', C.DEFAULT_BECOME_USER)) ) runner = Runner(**options) # Run the module if async: res, poll = runner.run_async(time_limit=time_limit) return _ExtendedPoll(res, poll) else: return _ExtendedPoll(runner.run(), None).poll()