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()
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 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()
class ShellExecAdapter(object):
def __init__(self, hostnames, remote_user, private_key_file,
run_data, become_pass, shell, verbosity=0):
self.run_data = run_data
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
# Become Pass Needed if not logging in as user root
passwords = {'become_pass': become_pass}
# Gets data from YAML/JSON files
self.loader = DataLoader()
# self.loader.set_vault_password(os.environ['VAULT_PASS'])
# All the variables from all the various places
self.variable_manager = VariableManager()
self.variable_manager.extra_vars = self.run_data
# Parse hosts, I haven't found a good way to
# pass hosts in without using a parsed template
self.hosts = NamedTemporaryFile(delete=False)
hostsString = '\n'.join(hostnames)
self.hosts.write("""[run_hosts]\n%s""" % hostsString)
self.hosts.close()
# This was my attempt to pass in hosts directly.
#
# Also Note: In py2.7, "isinstance(foo, str)" is valid for
# latin chars only. Luckily, hostnames are
# ascii-only, which overlaps latin charset
# if isinstance(hostnames, str):
# hostnames = {"customers": {"hosts": [hostnames]}}
# Set inventory, using most of above objects
self.inventory = Inventory(
loader=self.loader,
variable_manager=self.variable_manager,
host_list=self.hosts.name)
self.variable_manager.set_inventory(self.inventory)
play_source = dict(
name="shell task",
remote_user=remote_user,
hosts='all',
gather_facts='no',
tasks=[
dict(shell=shell, args=dict(chdir='/tmp/'),
register='shell_out', no_log=True)])
# tasks=[
# dict(shell=shell, args=dict(chdir='/tmp/'),
# register='shell_out'),
# dict(action=dict(module='debug',
# args=dict(msg='{{shell_out.stdout}}')))])
self.play = Play().load(
play_source, variable_manager=self.variable_manager,
loader=self.loader)
self.tqm = TaskQueueManager(
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=passwords,
stdout_callback='default')
def run(self):
# Results of PlaybookExecutor
state = self.tqm.run(self.play)
hostvars = self.tqm.hostvars
stats = self.tqm._stats
hosts = sorted(stats.processed.keys())
# run_success = True
stats_sum = dict()
results = dict()
for host in hosts:
t = stats.summarize(host)
stats_sum[host] = t
hostvar = hostvars.__getitem__(host)
results[host] = hostvar['shell_out']
# self.tqm.send_callback(
# 'walker2ansibleLog',
# walker_id=self.run_data['walker_id'],
# user_id=self.run_data['user_id'],
# run_success=run_success
# )
if self.tqm is not None:
self.tqm.cleanup()
os.remove(self.hosts.name)
self.inventory.clear_pattern_cache()
return [state, stats_sum, results]
class AnsibleTask(object):
def __init__(self, targetHost,user,password_d,ansible_cfg=None):
self.targetHost=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','host_key_checking','ask_pass'
]
)
# initialize needed objects
if ansible_cfg == None:
os.environ["ANSIBLE_CONFIG"] = ANSABLE_CNF
else:
os.environ["ANSIBLE_CONFIG"] = ansible_cfg
self.variable_manager = VariableManager()
self.options = Options(
listtags=False, listtasks=False, listhosts=False, syntax=False, connection='smart',
module_path='/usr/local/lib/python2.7/site-packages/ansible/modules/', forks=100,
remote_user=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=user,
verbosity=None, check=False,host_key_checking=False,ask_pass = False
)
self.passwords = dict(sshpass=password_d,conn_pass=password_d)
self.loader = DataLoader()
# create inventory and pass to var manager
self.hostsFile = NamedTemporaryFile(delete=False)
for i in targetHost:
self.hostsFile.write(i+'\n')
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):
play_source = dict(
name = "Ansible Play",
hosts = 'all',
gather_facts = 'no',
tasks = [
dict(action=dict(module=module, args=args), register='shell_out'),
]
)
play = Play().load(play_source, variable_manager=self.variable_manager, loader=self.loader)
# run it
tqm = None
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)
run_data=results_callback.run_data
if tqm is not None:
tqm.cleanup()
os.remove(self.hostsFile.name)
self.inventory.clear_pattern_cache()
return run_data
def run_playbook(self,filename):
"""
run ansible palybook
"""
return_data=0
executor=None
try:
filenames = [filename]
extra_vars = {} # 额外的参数 sudoers.yml以及模板中的参数，它对应ansible-playbook test.yml --extra-vars "host='aa' name='cc' "
# host_list_str = ','.join([item for item in host_list])
# extra_vars['host_list'] = host_list_str
# extra_vars['username'] = role_name
# extra_vars['template_dir'] = template_file
# extra_vars['command_list'] = temp_param.get('cmdList')
# extra_vars['role_uuid'] = 'role-%s'%role_uuid
self.variable_manager.extra_vars = extra_vars
executor = PlaybookExecutor(
playbooks=filenames, inventory=self.inventory, variable_manager=self.variable_manager,
loader=self.loader,
options=self.options, passwords=self.passwords,
)
executor._tqm._stdout_callback = results_callback
executor.run()
return_data=results_callback.run_data
if executor is not None:
executor.cleanup()
os.remove(self.hostsFile.name)
self.inventory.clear_pattern_cache()
return return_data
except Exception as e:
# logger.error("run_playbook:%s"%e)
Cmdb_log.error("playbook failure {0}{1}".format(filename,traceback.format_exc()))
return return_data
