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()
