def run_playbook(self, hosts, playbook_path):
"""
run ansible palybook
"""
global tasklist
tasklist = {}
for host in hosts:
tasklist[host] = {}
tasklist[host]['ok'] = []
tasklist[host]['failed'] = []
tasklist[host]['skppied'] = []
self.results_callback = PlayBookResultCallback(tasklist)
try:
executor = PlaybookExecutor(
playbooks=[playbook_path],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords)
executor._tqm._stdout_callback = self.results_callback
executor.run()
except Exception as e:
print(e)
return False
def ansible_task(playbooks):
Options = namedtuple('Options', \
['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'listhosts', 'listtasks', 'listtags', 'syntax'])
options = Options(
connection = 'ssh',
module_path = '/opt/ansible/modules',
forks = 100,
become = True,
become_method = 'sudo',
become_user = '******',
check = False,
listhosts = None,
listtasks = None,
listtags = None,
syntax = None
)
loader = DataLoader()
variable_manager = VariableManager()
inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list='/opt/ansible/inventory')
variable_manager.set_inventory(inventory)
pb = PlaybookExecutor(playbooks=[playbooks], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None)
pb.run()
stats = pb._tqm._stats
ips = stats.processed.keys()
return [ {ip : stats.summarize(ip)} for ip in ips ]
def __init__(self, **kwargs):
super(Ansible_playbook, self).__init__(**kwargs)
self.task_file = kwargs.get('task_file', None)
self.sudo = kwargs.get('sudo', False)
self.sudo_user = kwargs.get('sudo_user', False)
self.sudo_password = kwargs.get('sudo_password', False)
# check if parameters have been provided
if self._is_parameters_ok():
variable_manager = VariableManager()
loader = DataLoader()
options = self._get_options()
passwords = {'become_pass': self.sudo_password}
inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list="localhost")
variable_manager.set_inventory(inventory)
playbooks = [self.task_file]
executor = PlaybookExecutor(
playbooks=playbooks,
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
executor.run()
def run_playbook(self, host_list, role_name, role_uuid, temp_param):
"""
run ansible palybook
"""
try:
self.callback = ResultsCollector()
filenames = [BASE_DIR + '/handlers/ansible/v1_0/sudoers.yml']
logger.info('ymal file path:%s'% filenames)
template_file = TEMPLATE_DIR
if not os.path.exists(template_file):
logger.error('%s 路径不存在 '%template_file)
sys.exit()
extra_vars = {}
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
logger.info('playbook 额外参数:%s'%self.variable_manager.extra_vars)
# actually run it
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 = self.callback
executor.run()
except Exception as e:
logger.error("run_playbook:%s"%e)
def playbook_api(self,yml_fp):
loader = DataLoader()
variable_manager = VariableManager()
inventory = Inventory(
loader=loader,
variable_manager=variable_manager,
host_list=self.ansible_host_list
)
variable_manager.set_inventory(inventory)
playbooks = ["%s" % yml_fp]
pbex = PlaybookExecutor(
playbooks=playbooks,
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=self.options,
passwords=self.passwords
)
callback = AnsiCallBack()
pbex._tqm._stdout_callback = callback
pbex.run()
return self.evaluate_results(callback)
class PlayBook(object):
def __init__(self, playbook, inventory="inventory.py", extra_vars=None):
basedir = os.path.abspath(os.path.dirname(__file__))
self.playbook = os.path.join(basedir, playbook)
self.options = Options(
inventory=inventory,
sudo=False, su=False, sudo_user=None, su_user=None,
listtags=False, listtasks=False, listhosts=False,
syntax=False, check=False,
ask_pass=False,ask_su_pass=False,ask_sudo_pass=False,ask_vault_pass=False,
connection='smart', timeout=10, remote_user=None, private_key_file=None,
ssh_common_args=None, ssh_extra_args=None,
sftp_extra_args=None, scp_extra_args=None,
module_path=None, forks=5,
become=False, become_method='sudo', become_user=None,
verbosity=0)
self.loader = DataLoader()
self.variable_manager = VariableManager()
self.variable_manager.extra_vars = extra_vars
self.inventory = Inventory(loader=self.loader,
variable_manager=self.variable_manager,
host_list=inventory)
self.pbex = PlaybookExecutor(playbooks=[self.playbook],
inventory=self.inventory,
loader=self.loader,
variable_manager=self.variable_manager,
options=self.options,
passwords={'become_pass': None})
def run(self):
self.pbex.run()
stats = self.pbex._tqm._stats
self.pbex._tqm.send_callback('human_log')
return stats
def _run_playbook(self, playbook):
self.options = options = self.Options(**self.options_args)
vm = self.variable_manager
vm.extra_vars = load_extra_vars(loader=self.loader, options=options)
pbe = PlaybookExecutor(
playbooks=[playbook],
inventory=self.inventory,
variable_manager=vm,
loader=self.loader,
options=options,
passwords=dict(),
)
pbe.run()
return vm.get_vars(self.loader)
def run(self):
executor = PlaybookExecutor(
playbooks=[self.playbook_path],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords
)
if executor._tqm:
executor._tqm._stdout_callback = self.results_callback
executor.run()
executor._tqm.cleanup()
return self.results_callback.output
def run(self):
executor = PlaybookExecutor(
playbooks=[self.playbook_path],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
passwords={"conn_pass": self.passwords}
)
context.CLIARGS = ImmutableDict(self.options)
if executor._tqm:
executor._tqm._stdout_callback = self.results_callback
executor.run()
executor._tqm.cleanup()
return self.results_callback.output
def pbexe(userid,serial,host,module,apppath,yaml,url=None):
variable_manager = VariableManager()
loader = DataLoader()
hostfile = '/ansible/hosts'
inventory = Inventory(loader=loader, variable_manager=variable_manager,host_list='/ansible/hosts')
playbook_path = yaml
if not os.path.exists(playbook_path):
print playbook_path
print '[INFO] The playbook does not exist'
sys.exit()
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'])
options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, 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=True, become_method=None, become_user='******', verbosity=None, check=False)
variable_manager.extra_vars = {
'host': host,
'module': module,
'tomcat_root': apppath,
'url': url
} # This can accomodate various other command line arguments.`
passwords = {}
cb = CallbackModule(serial)
# cb = default.CallbackModule()
pbex = PlaybookExecutor( playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords)
pbex._tqm._stdout_callback = cb
results = pbex.run()
return results
def run(self,mission_id,role_name,exe_group):
'''
create play with tasks actually run it
'''
tqm = None
try:
retry_path = '/etc/ansible/main.yml'
inventory_path = [retry_path]
self.results_callback = ResultCallback()
extra_vars = {}
extra_vars['host_list'] = exe_group
extra_vars['role_name'] = role_name
extra_vars['run_id'] = mission_id
self.variable_manager.extra_vars = extra_vars
pbex = PlaybookExecutor(
playbooks=inventory_path,
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords,
)
pbex._tqm._stdout_callback = self.results_callback
result = pbex.run()
finally:
if tqm is not None:
tqm.cleanup()
def pbexe(sid,war,mode):
variable_manager = VariableManager()
loader = DataLoader()
# inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=[])
inventory = Inventory(loader=loader, variable_manager=variable_manager)
playbook_path = '/etc/ansible/yml/'+sid+'.yml'
if not os.path.exists(playbook_path):
print playbook_path
print '[INFO] The playbook does not exist'
sys.exit()
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'])
options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, 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=True, become_method=None, become_user='******', verbosity=None, check=False)
variable_manager.extra_vars = {'war': war,'mode': mode} # This can accomodate various other command line arguments.`
passwords = {}
#cb = ResultCallback()
# cb = default.CallbackModule()
pbex = PlaybookExecutor(playbooks=[playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords)
# pbex._tqm._stdout_callback = cb
op=sys.stdout
filename='/var/log/ansible/'+time.strftime('%Y%m%d%H%M%S')+'.log'
opf=open(filename,'w')
sys.stdout=opf
results = pbex.run()
sys.stdout=op
opf.close
print open(filename,'r').read()
return filename
def runPlaybook(self):
sys.stdout = open('Output-pythonAnsible','w')
variable_manager = VariableManager()
loader = DataLoader()
inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=self.host_list)
#self.playbook_path
#playbook_path = '/home/davis/Documents/Network-automation/cisco_xe.yml'
if not os.path.exists(self.playbook_path):
print '[INFO] The playbook does not exist'
sys.exit()
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'])
options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, 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=True, become_method=None, become_user='******', verbosity=None, check=False)
#variable_manager.extra_vars = {'hosts': 'mywebserver'} # This can accomodate various other command line arguments.`
passwords = {}
pbex = PlaybookExecutor(playbooks=[self.playbook_path], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords)
results = pbex.run()
print "Output ::-",results
return results
def run_playbook():
playbooks = ['/Users/CYu/Code/Python/python-demo/demo_ansible/playbook.yml'] # 这里是一个列表, 因此可以运行多个playbook
variable_manager.extra_vars = {"ansible_ssh_user": "******", "ansible_ssh_pass": "******"} # 增加外部变量
pb = PlaybookExecutor(playbooks=playbooks, inventory=inventory, variable_manager=variable_manager, loader=loader,
options=options, passwords=None)
result = pb.run()
print result
def test_init(self):
"""
Initialises and runs sample echo playbook for testing
"""
path = os.path.realpath(__file__).split("/")[0:-1]
path = "/".join(path)
playbook_path = path+'/playbooks/test_playbook.yml'
options = self.Options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
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=True,
become_method=None,
become_user='******',
verbosity=3,
check=False)
self.variable_manager.extra_vars = {'hosts': 'mywebserver'}
passwords = {}
pbex = PlaybookExecutor(playbooks=[playbook_path],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=options,
passwords=passwords)
results = pbex.run()
assert_equal(results, 0)
def run_playbook(playbook_path, cluster):
playbook_file = '{playbook_path}/provision/site.yml'.format(
playbook_path=playbook_path,
)
loader = DataLoader()
variable_manager = VariableManager()
inventory = Inventory(
loader=loader,
variable_manager=variable_manager,
host_list=get_host_list(playbook_path, cluster),
)
file_handle, private_key_file = mkstemp(dir=playbook_path)
with open(private_key_file, 'w') as key_file:
key_file.write(cluster.sshKey)
options = Options(
inventory=inventory,
remote_user=cluster.username,
private_key_file=private_key_file,
)
executor = PlaybookExecutor(
playbooks=[playbook_file],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords={
'become_pass': '******',
},
)
return executor.run()
def run(self, log):
if not self.playbook:
code = 999
simple = 'playbook must exist'
return code, simple, None
if log:
log_file.append(log)
if not os.path.exists(self.playbook):
code = 1000
results = 'not exists playbook: ' + self.playbook
return code, results, None
pbex = PlaybookExecutor(playbooks=[self.playbook],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords)
try:
code = pbex.run()
except AnsibleParserError:
code = 1001
results = 'syntax problems in ' + self.playbook
return code, results, None
stats = pbex._tqm._stats
hosts = sorted(stats.processed.keys())
results = [{h: stats.summarize(h)} for h in hosts]
if not results:
code = 1002
results = 'no host executed in ' + self.playbook
return code, results, None
complex = '\n'.join(log_add)
return code, results, complex
def run_playbook(self, filenames, fork=5):
'''
:param filenames is list ,
:param fork is interge, default 5
'''
display = LogDisplay(logname=self.job_id)
callback = CALLBACKMODULE[CALLBACK](display=display)
# actually run it
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 = callback
executor.run()
return display.get_log_json()
class PlayBook(object):
def __init__(self, inventory='/etc/ansible/hosts', extra_vars=None, private_key_file=None):
"""
:param playbook: playbook.yml
:param inventory: inventory file or script
:type param extra_vars: dict
:param private_key_file: ssh private key
"""
self.pbex = None
self.options = Options(private_key_file=private_key_file, connection='smart', forks=10, timeout=10,
verbosity=0, check=False,
listtasks=False, listhosts=False, syntax=False,
subset=None, module_path=None, become=None, become_user=None, become_method='sudo')
# initialize needed objects
self.loader = DataLoader()
self.variable_manager = VariableManager()
self.variable_manager.extra_vars = extra_vars
self.variable_manager.options_vars = {'ansible_check_mode': self.options.check}
self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=inventory)
self.variable_manager.set_inventory(self.inventory)
# Limits inventory results to a subset of inventory that matches a given pattern
self.inventory._subset = self.options.subset
def run_playbook(self, playbook):
self.pbex = PlaybookExecutor(playbooks=[playbook], inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader, options=self.options,
passwords={'conn_pass': None, 'become_pass': None})
self.pbex._tqm._stdout_callback = ResultCallback()
return self.pbex.run()
def run_play(self, play):
pass
def run_playbook(self, host_list, playbook_path,extra_vars=None):
"""
run ansible palybook
"""
try:
if self.redisKey:self.callback = PlayBookResultsCollectorToSave(self.redisKey,self.logId)
else:self.callback = PlayBookResultsCollector()
if extra_vars:self.variable_manager.extra_vars = extra_vars
executor = PlaybookExecutor(
playbooks=[playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader,
options=self.options, passwords=self.passwords,
)
executor._tqm._stdout_callback = self.callback
executor.run()
except Exception as e:
return False
def run(self):
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', 'diff'])
options = Options(listtags=False, listtasks=False, listhosts=False,
syntax=False, 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=True, become_method=None,
become_user='******', verbosity=None, check=False, diff=False)
#OPTION_FLAGS = ('connection', 'remote_user', 'private_key_file', 'verbosity', 'force_handlers', 'step', 'start_at_task', 'diff',
# 'ssh_common_args', 'docker_extra_args', 'sftp_extra_args', 'scp_extra_args', 'ssh_extra_args')
passwords = {}
pbex = PlaybookExecutor(playbooks=[self.playbook],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=options,
passwords=passwords)
result = pbex.run()
return result
def run(self, playbooks, limit=''):
"""
param: `playbooks`: type string or list, example: ['/etc/ansible/test.yml'], '/etc/ansible/test1.yml, /etc/ansible/test2.yml'
param: `limit`: eq --limit ''
"""
self._prepare_run()
results = 0
if isinstance(playbooks, basestring):
if ',' in playbooks:
playbooks = [pl.strip() for pl in playbooks.split(',') if os.path.exists(pl)]
else:
playbooks = [playbooks.strip()]
# --limit
if limit:
self.inventory.subset(limit)
try:
# create the playbook executor, which manages running the plays via a task queue manager
pbex = PlaybookExecutor(playbooks=playbooks, inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader, options=self.options, passwords=self.passwords)
results = pbex.run()
except Exception, ex:
results = str(ex)
def call_ansible(yaml_file, become=False, tag=None):
"""Call Ansible with a playbook."""
variable_manager = VariableManager()
loader = DataLoader()
inventory = Inventory(loader, variable_manager)
variable_manager.set_inventory(inventory)
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',
'tags'])
options = Options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
connection='',
module_path='',
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=become,
become_method='sudo',
become_user='******',
verbosity=2,
check=False,
tags=tag)
pbex = PlaybookExecutor(playbooks=[yaml_file],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords={})
logger.debug("Calling Ansible with yaml file: {}".format(yaml_file))
result = pbex.run()
if result:
logger.error("An error occured whilst executing the Ansible Playbook.")
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()
def run(self, playbook,
hosts,
extra_vars={},
log='',
with_output=False,
use_root=False):
self.result['playbook'] = playbook
if not os.path.exists(playbook):
result = {
'errno': -3,
'msg': 'not exists playbook: ' + playbook
}
else:
AT = Ansi_Template()
hosts, host_file = AT.make_host_template(hosts, use_root)
extra_vars['ansible_hosts'] = ':'.join(hosts)
inventory = InventoryManager(loader=self.loader, sources=[host_file])
variable_manager = VariableManager(loader=self.loader, inventory=inventory)
variable_manager.extra_vars = extra_vars
pbex = PlaybookExecutor(playbooks=[playbook],
inventory=inventory,
variable_manager=variable_manager,
loader=self.loader,
options=self.options,
passwords={})
new_display = New_Display(log_file=log, debug=self.debug)
results_callback = ResultCallback(new_display=new_display)
pbex._tqm._stdout_callback = results_callback
try:
errno = pbex.run()
result = results_callback.tasks
result['errno'] = errno
except AnsibleParserError as e:
msg = 'syntax problems: {0}'.format(str(e))
result = {
'errno': -2,
'msg': msg
}
self.write_log(log, msg)
print('syntax problems: {0}'.format(str(e)))
if with_output:
result['output'] = '\n'.join(new_display.log_add)
if result['errno'] != -2 and not result['summary']:
msg = 'no host executed'
result = {
'errno': -1,
'msg': msg
}
self.write_log(log, msg)
os.unlink(host_file)
self.result.update(result)
if self.result['errno'] != 0:
self.result['msg'] = '无法配置完成，请联系管理员！'
return self.result
def run_need_data(self):
if not self.playbook:
code = 999
simple = 'playbook must exist'
return code, simple, None
if not os.path.exists(self.playbook):
code = 1000
complex = {'playbook': self.playbook,
'msg': self.playbook + ' playbook does not exist', 'flag': False}
simple = 'playbook does not exist about ' + self.playbook
return code, simple, complex
pbex = PlaybookExecutor(playbooks=[self.playbook],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords)
results_callback = ResultCallback()
pbex._tqm._stdout_callback = results_callback
try:
code = pbex.run()
except AnsibleParserError:
code = 1001
simple = {'playbook': self.playbook,
'msg': 'syntax problems in ' + self.playbook, 'flag': False,
'msg_list': {'status': 'unknown', 'msg': 'syntax problems'}}
complex = 'syntax problems in ' + self.playbook
return code, simple, complex
if results_callback.no_hosts:
code = 1002
complex = 'no hosts matched in ' + self.playbook
simple = {'executed': False, 'flag': False, 'playbook': self.playbook,
'msg': 'no_hosts', 'msg_list': {'status': 'unknown', 'msg': 'no_hosts'}}
return code, simple, complex
else:
msg_list = results_callback.msg_list
ok = results_callback.ok
fail = results_callback.fail
unreachable = results_callback.unreachable
ok_all = list(ok.keys())
fail_all = list(fail.keys())
unreachable_hosts = list(unreachable.keys())
fail_hosts = list(set(fail_all) - set(unreachable_hosts))
ok_hosts = list(set(ok_all) - set(unreachable_hosts) - set(fail_hosts))
if code != 0:
complex = {'playbook': results_callback.playbook, 'ok': ok,
'fail': fail, 'unreachable': unreachable, 'flag': False}
simple = {'executed': True, 'flag': False, 'playbook': self.playbook, 'msg_list': msg_list,
'msg': {'playbook': self.playbook, 'ok_hosts': ok_hosts, 'fail': fail_hosts, 'unreachable': unreachable_hosts}}
return code, simple, complex
else:
complex = {'playbook': results_callback.playbook, 'ok': ok,
'fail': fail, 'unreachable': unreachable, 'flag': True}
simple = {'executed': True, 'flag': True, 'playbook': self.playbook, 'msg_list': msg_list,
'msg': {'playbook': self.playbook, 'ok_hosts': ok_hosts, 'fail': fail_hosts, 'unreachable': unreachable_hosts}}
return code, simple, complex
class PlayBook(object):
def __init__(self, playbook, inventory="inventory.py", extra_vars=None):
self.playbook = "%s/%s" % (os.path.dirname(__file__), playbook)
self.options = Options(inventory, extra_vars)
self.loader = DataLoader()
self.variable_manager = VariableManager()
self.variable_manager.set_inventory(self.options.inventory)
self.inventory = Inventory(loader=self.loader,
variable_manager=self.variable_manager,
host_list=self.options.inventory)
self.pbex = PlaybookExecutor(playbooks=[self.playbook],
inventory=self.inventory,
loader=self.loader,
variable_manager=self.variable_manager,
options=self.options,
passwords={'become_pass': None})
def run(self):
self.pbex.run()
stats = self.pbex._tqm._stats
self.pbex._tqm.send_callback('human_log')
return stats
def run_playbook(self, host_list, playbook_path,extra_vars=dict()):
"""
run ansible palybook
"""
try:
if self.redisKey or self.logId:self.callback = PlayBookResultsCollectorToSave(self.redisKey,self.logId)
else:self.callback = PlayBookResultsCollector()
extra_vars['host'] = ','.join(host_list)
self.variable_manager.extra_vars = extra_vars
executor = PlaybookExecutor(
playbooks=[playbook_path], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader,
options=self.options, passwords=self.passwords,
)
executor._tqm._stdout_callback = self.callback
constants.HOST_KEY_CHECKING = False #关闭第一次使用ansible连接客户端是输入命令
constants.DEPRECATION_WARNINGS = False
executor.run()
except Exception as err:
print err
if self.redisKey:DsRedis.OpsAnsibleModel.lpush(self.redisKey,data=err)
if self.logId:AnsibleSaveResult.Model.insert(self.logId, err)
return False
def main(argv=sys.argv[1:]):
#
# initialize needed objects
#
variable_manager = VariableManager()
loader = DataLoader()
# https://pymotw.com/2/collections/namedtuple.html
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'])
options = Options(listtags=False, listtasks=False, listhosts=False,
syntax=False, connection='local', 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=True, become_method=None,
become_user='******', verbosity=None, check=False)
passwords = {}
inventory = Inventory(loader=loader, variable_manager=variable_manager,
host_list='./ls_hosts')
variable_manager.set_inventory(inventory)
playbook_path = './ls.yml'
if not os.path.exists(playbook_path):
print '[INFO] The playbook does not exist'
sys.exit()
# This can accomodate various other command line arguments.`
# variable_manager.extra_vars = {'hosts': 'mywebserver'}
pbex = PlaybookExecutor(playbooks=[playbook_path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
# cb = ResultAccumulator()
# pbex._tqm._stdout_callback = cb
results = pbex.run()
if results != 0:
print "ERROR"
def run_playbook(self, playbook):
options = self.Options(**self.options_args)
vm = self.variable_manager
vm.extra_vars = load_extra_vars(loader=self.loader, options=options)
pbe = PlaybookExecutor(
playbooks=[playbook],
inventory=self.inventory,
variable_manager=vm,
loader=self.loader,
options=options,
passwords=dict(conn_pass='******'),
)
res = pbe.run()
self._run_vars = vm.get_vars(self.loader)
return res
def run(self):
super(PlaybookCLI, self).run()
# Note: slightly wrong, this is written so that implicit localhost
# Manage passwords
sshpass = None
becomepass = None
vault_pass = None
passwords = {}
# don't deal with privilege escalation or passwords when we don't need to
if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax:
self.normalize_become_options()
(sshpass, becomepass) = self.ask_passwords()
passwords = {'conn_pass': sshpass, 'become_pass': becomepass}
if self.options.vault_password_file:
# read vault_pass from a file
vault_pass = CLI.read_vault_password_file(
self.options.vault_password_file)
elif self.options.ask_vault_pass:
vault_pass = self.ask_vault_passwords(ask_vault_pass=True,
ask_new_vault_pass=False,
confirm_new=False)[0]
loader = DataLoader(vault_password=vault_pass)
# FIXME: this should be moved inside the playbook executor code
only_tags = self.options.tags.split(",")
skip_tags = self.options.skip_tags
if self.options.skip_tags is not None:
skip_tags = self.options.skip_tags.split(",")
# initial error check, to make sure all specified playbooks are accessible
# before we start running anything through the playbook executor
for playbook in self.args:
if not os.path.exists(playbook):
raise AnsibleError("the playbook: %s could not be found" %
playbook)
if not (os.path.isfile(playbook)
or stat.S_ISFIFO(os.stat(playbook).st_mode)):
raise AnsibleError(
"the playbook: %s does not appear to be a file" % playbook)
# create the variable manager, which will be shared throughout
# the code, ensuring a consistent view of global variables
variable_manager = VariableManager()
variable_manager.extra_vars = load_extra_vars(loader=loader,
options=self.options)
# create the inventory, and filter it based on the subset specified (if any)
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=self.options.inventory)
variable_manager.set_inventory(inventory)
# (which is not returned in list_hosts()) is taken into account for
# warning if inventory is empty. But it can't be taken into account for
# checking if limit doesn't match any hosts. Instead we don't worry about
# limit if only implicit localhost was in inventory to start with.
#
# Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts())
no_hosts = False
if len(inventory.list_hosts()) == 0:
# Empty inventory
self.display.warning(
"provided hosts list is empty, only localhost is available")
no_hosts = True
inventory.subset(self.options.subset)
if len(inventory.list_hosts()) == 0 and no_hosts is False:
# Invalid limit
raise AnsibleError("Specified --limit does not match any hosts")
# create the playbook executor, which manages running the plays via a task queue manager
pbex = PlaybookExecutor(playbooks=self.args,
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
display=self.display,
options=self.options,
passwords=passwords)
results = pbex.run()
if isinstance(results, list):
for p in results:
self.display.display('\nplaybook: %s\n' % p['playbook'])
for play in p['plays']:
if self.options.listhosts:
self.display.display("\n %s (%s): host count=%d" %
(play['name'], play['pattern'],
len(play['hosts'])))
for host in play['hosts']:
self.display.display(" %s" % host)
if self.options.listtasks: #TODO: do we want to display block info?
self.display.display("\n %s" % (play['name']))
for task in play['tasks']:
self.display.display(" %s" % task)
if self.options.listtags: #TODO: fix once we figure out block handling above
self.display.display("\n %s: tags count=%d" %
(play['name'], len(play['tags'])))
for tag in play['tags']:
self.display.display(" %s" % tag)
return 0
else:
return results
def ansible_playbook(playbook, verbose=2, settings=None,
inventory="local_hosts"):
"""Wraps the 'ansible-playbook' CLI.
:param playbook: the playbook to invoke
:param verbose: Ansible verbosity level
:param settings: dict with Ansible variables.
:param inventory: the inventory file to use, default: local_hosts
"""
settings = settings or {}
display = Display(verbosity=verbose)
import __main__ as main
setattr(main, "display", display)
if not playbook:
# TODO: remove all IRexceptions and change to regular Python exceptions
raise exceptions.IRFileNotFoundException
LOG.info("Executing Playbook: %s" % playbook)
loader = DataLoader()
# ------------------ Mocking ansible-playbook cli input ------------------
# These values were extracted from ansible-playbook runtime.
# todo(yfried): decide which options are hardcoded and which should be
# exposed to user
hacked_options = {'subset': None, 'ask_pass': False, 'listtags': None,
'become_user': '******', 'sudo': False,
'private_key_file': None,
'syntax': None, 'skip_tags': None, 'diff': False,
'sftp_extra_args': '', 'check': False,
'force_handlers': False,
'remote_user': None, 'become_method': 'sudo',
'vault_password_file': None, 'listtasks': None,
'output_file': None, 'ask_su_pass': False,
'new_vault_password_file': None,
'listhosts': None, 'ssh_extra_args': '',
'tags': 'all', 'become_ask_pass': False,
'start_at_task': None,
'flush_cache': None, 'step': None, 'module_path': None,
'su_user': None, 'ask_sudo_pass': False,
'su': False,
'scp_extra_args': '', 'connection': 'smart',
'ask_vault_pass': False, 'timeout': 30, 'become': False,
'sudo_user': None, 'ssh_common_args': ''}
module_path = CONF.get('defaults', 'modules')
path_to_playbook = path.join(CONF.get('defaults', 'playbooks'), playbook)
hacked_options.update(
module_path=module_path,
verbosity=verbose,
forks=ansible.constants.DEFAULT_FORKS,
remote_user=ansible.constants.DEFAULT_REMOTE_USER,
private_key_file=ansible.constants.DEFAULT_PRIVATE_KEY_FILE,
)
options = namedtuple('Options', hacked_options.keys())(**hacked_options)
passwords = dict(vault_pass='******')
variable_manager = VariableManager()
variable_manager.extra_vars = settings
inventory = Inventory(loader=loader, variable_manager=variable_manager,
host_list=inventory)
variable_manager.set_inventory(inventory)
pbex = PlaybookExecutor(playbooks=[path_to_playbook], inventory=inventory,
variable_manager=variable_manager, loader=loader,
options=options, passwords=passwords)
results = pbex.run()
if results:
raise exceptions.IRPlaybookFailedException(playbook)
def run_playbook(hosts, playbook, tags=[], private_key_file=private_key_file):
# initialize needed objects
loader = DataLoader()
options = Options(connection='ssh',
private_key_file=private_key_file,
module_path='',
forks=100,
become=True,
become_method='sudo',
become_user='******',
check=False,
tags=tags)
passwords = dict(vault_pass='')
results_callback = ResultCallback()
host_file = NamedTemporaryFile(delete=False)
host_file.write(b'[servers]\n')
for i, h in enumerate(hosts):
print(i, " : ", h)
host_file.write(bytes('{0} num={1}\n'.format(h, i), encoding='utf8'))
host_file.close()
# set inventory
inventory = InventoryManager(loader=loader, sources=host_file.name)
variable_manager = VariableManager(loader=loader, inventory=inventory)
# setup playbook executor, before the run
pbex = PlaybookExecutor(playbooks=[playbook],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
pbex._tqm._stdout_callback = results_callback
# run playbook and get stats
result = pbex.run()
stats = pbex._tqm._stats
outputs = {
0: 'deployment successful',
1: 'error occurred during deployment',
2: 'one or more hosts failed',
4: 'one or more hosts unreachable',
255: 'unknown error occurred during deployment'
}
run_success = True
hosts = sorted(stats.processed.keys())
for h in hosts:
t = stats.summarize(h)
if t['unreachable'] > 0 or t['failures'] > 0:
run_success = False
os.remove(host_file.name)
try:
out = outputs[result]
except KeyError:
out = 'unrecognised error code'
return result, out
def run_ansible(playbooks, inventory_path, extra_vars={}, tags=None, on_error_continue=False):
variable_manager = VariableManager()
loader = DataLoader()
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=inventory_path)
variable_manager.set_inventory(inventory)
if extra_vars:
variable_manager.extra_vars = extra_vars
passwords = {}
# NOTE(msimonin): The ansible api is "low level" in the
# sense that we are redefining here all the default values
# that are usually enforce by ansible called from the cli
Options = namedtuple('Options', ['listtags', 'listtasks',
'listhosts', 'syntax',
'connection', 'module_path',
'forks', 'private_key_file',
'ssh_common_args',
'ssh_extra_args',
'sftp_extra_args',
'scp_extra_args', 'become',
'become_method', 'become_user',
'remote_user', 'verbosity',
'check', 'tags', 'pipelining'])
options = Options(listtags=False, listtasks=False,
listhosts=False, syntax=False, connection='ssh',
module_path=None, forks=100,
private_key_file=None, ssh_common_args=None,
ssh_extra_args=None, sftp_extra_args=None,
scp_extra_args=None, become=None,
become_method='sudo', become_user='******',
remote_user=None, verbosity=2, check=False,
tags=tags, pipelining=True)
for path in playbooks:
logging.info("Running playbook %s with vars:\n%s" % (path, extra_vars))
pbex = PlaybookExecutor(
playbooks=[path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords
)
code = pbex.run()
stats = pbex._tqm._stats
hosts = stats.processed.keys()
result = [{h: stats.summarize(h)} for h in hosts]
results = {'code': code, 'result': result, 'playbook': path}
print(results)
failed_hosts = []
unreachable_hosts = []
for h in hosts:
t = stats.summarize(h)
if t['failures'] > 0:
failed_hosts.append(h)
if t['unreachable'] > 0:
unreachable_hosts.append(h)
if len(failed_hosts) > 0:
logging.error("Failed hosts: %s" % failed_hosts)
if not on_error_continue:
raise EnosFailedHostsError(failed_hosts)
if len(unreachable_hosts) > 0:
logging.error("Unreachable hosts: %s" % unreachable_hosts)
if not on_error_continue:
raise EnosUnreachableHostsError(unreachable_hosts)
def apply_playbook(playbook_path,
hosts_inv,
host_user,
ssh_priv_key_file_path,
variables=None,
proxy_setting=None):
"""
Executes an Ansible playbook to the given host
:param playbook_path: the (relative) path to the Ansible playbook
:param hosts_inv: a list of hostnames/ip addresses to which to apply the Ansible playbook
:param host_user: A user for the host instances (must be a password-less sudo user if playbook has "sudo: yes"
:param ssh_priv_key_file_path: the file location of the ssh key
:param variables: a dictionary containing any substitution variables needed by the Jinga 2 templates
:param proxy_setting: string containing host:port of the proxy server in use
:return: the results
"""
if not os.path.isfile(playbook_path):
raise Exception('Requested playbook not found - ' + playbook_path)
if not os.path.isfile(ssh_priv_key_file_path):
raise Exception('Requested private SSH key not found - ' +
ssh_priv_key_file_path)
import ansible.constants
ansible.constants.HOST_KEY_CHECKING = False
variable_manager = VariableManager()
if variables:
variable_manager.extra_vars = variables
loader = DataLoader()
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=hosts_inv)
variable_manager.set_inventory(inventory)
loader = DataLoader()
ssh_common_args = None
ssh_extra_args = None
ssh_connection = 'ssh'
proxy_command = None
if proxy_setting:
tokens = re.split(':', proxy_setting)
# TODO - Need to configure the proxy settings to avoid adding entries into the host's ~/.ssh/config file
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', 'transport', 'proxy_command'
])
ansible_opts = options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
connection=ssh_connection,
module_path=None,
forks=100,
remote_user=host_user,
private_key_file=ssh_priv_key_file_path,
ssh_common_args=ssh_common_args,
ssh_extra_args=ssh_extra_args,
sftp_extra_args=None,
scp_extra_args=None,
become=None,
become_method=None,
become_user='******',
verbosity=1111,
check=False,
host_key_checking=True,
transport='paramiko',
proxy_command=proxy_command)
logger.debug('Setting up Ansible Playbook Executor')
executor = PlaybookExecutor(playbooks=[playbook_path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=ansible_opts,
passwords=None)
logger.debug('Executing Ansible Playbook - ' + playbook_path)
retval = executor.run()
if retval != 0:
logger.error('Playbook application failed [' + playbook_path +
'] with return value of - ' + str(retval))
raise Exception('Playbook not applied - ' + playbook_path)
return retval
def run_playbook(self, playbook_yml, group=None, script=None):
"""
运行 playbook
"""
playbook = None
try:
with open(playbook_yml) as f:
playbook_content = f.read()
check, variable = check_ansible_variable(playbook_content)
if check:
data = '<code style="color: #FF0000">playbook 中包含非法 ansible 变量: [{}]，禁止运行</code>'.format(
variable)
data2 = '\033[01;31mplaybook 中包含非法 ansible 变量: [{}]，禁止运行\r\n\r\n\033[0m'.format(
variable)
delay = round(time.time() - self.results_callback.start_time,
6)
self.results_callback.res.append(
json.dumps([delay, 'o', data2]))
message = dict()
message['status'] = 0
message['message'] = data
message = json.dumps(message)
async_to_sync(channel_layer.group_send)(group, {
"type": "send.message",
"text": message,
})
else:
playbook = PlaybookExecutor(
playbooks=[playbook_yml],
inventory=self.dynamic_inventory,
variable_manager=self.variable_manager,
loader=self.loader,
passwords=self.passwords,
)
playbook._tqm._stdout_callback = self.results_callback
playbook.run()
except Exception as err:
data = '<code style="color: #FF0000">{}</code>'.format(str(err))
data2 = '\033[01;31m{}\r\n\r\n\033[0m'.format(
str(err).strip().replace('\n', '\r\n'))
delay = round(time.time() - self.results_callback.start_time, 6)
self.results_callback.res.append(json.dumps([delay, 'o', data2]))
message = dict()
message['status'] = 0
message['message'] = data
message = json.dumps(message)
async_to_sync(channel_layer.group_send)(group, {
"type": "send.message",
"text": message,
})
finally:
if group:
message = dict()
message['status'] = 0
message['message'] = '执行完毕...'
message = json.dumps(message)
async_to_sync(channel_layer.group_send)(group, {
"type": "close.channel",
"text": message,
})
if self.results_callback.res:
save_res(self.results_callback.res_file,
self.results_callback.res)
batchcmd_log(
user=self.results_callback.user,
hosts=self.results_callback.hosts,
cmd=self.results_callback.playbook,
detail=self.results_callback.res_file,
address=self.results_callback.client,
useragent=self.results_callback.user_agent,
start_time=self.results_callback.start_time_django,
type=4,
script=script,
)
if playbook._tqm is not None:
playbook._tqm.cleanup()
def run_script(playbook_path,
channel,
inventory_sources=None,
extra_arguments={}):
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', 'diff'
])
options = Options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
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=False,
become_method=None,
become_user=None,
verbosity=True,
check=False,
diff=False)
if not os.path.exists(playbook_path):
print '[INFO] The playbook does not exist'
sys.exit()
loader = DataLoader()
variable_manager = VariableManager()
inventory = Inventory(loader, variable_manager)
variable_manager.extra_vars = extra_arguments # This can accomodate various other command line arguments.`
passwords = {}
pbex = PlaybookExecutor(playbooks=[playbook_path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
pbex.run()
stats = pbex._tqm._stats
hosts = sorted(stats.processed.keys())
run_success = True
for h in hosts:
t = stats.summarize(h)
if t['unreachable'] > 0 or t['failures'] > 0:
run_success = False
send_message(channel, '```{}```'.format(str(t)))
pbex._tqm.send_callback('notify_jira', channel)
pbex._tqm.send_callback('notify_slack', channel)
if run_success:
send_message(channel,
'```Execution is completed. Please check the result```')
become=False,
become_method=None,
become_user=None,
remote_user=None,
verbosity=None,
check=False)
playbook_path = 'test.yml' # modify here, change playbook
variable_manager.extra_vars = {
"args": "pong",
} # modify here, This can accomodate various other command line arguments.`
if not os.path.exists(playbook_path):
print '[INFO] The playbook does not exist'
sys.exit()
passwords = {}
pbex = PlaybookExecutor(playbooks=[playbook_path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
code = pbex.run()
stats = pbex._tqm._stats
hosts = sorted(stats.processed.keys())
result = [{h: stats.summarize(h)} for h in hosts]
results = {'code': code, 'result': result, 'playbook': playbook_path}
print(results)
class PlaybookRunner(object):
"""
The plabybook API.
"""
def __init__(
self,
hosts=None, # a list or dynamic-hosts,
# default is /etc/ansible/hosts
playbook_path=None, # * a playbook file
forks=C.DEFAULT_FORKS,
listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
module_path=None,
remote_user='******',
timeout=C.DEFAULT_TIMEOUT,
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,
extra_vars=None,
connection_type="ssh",
passwords=None,
private_key_file=None,
check=False):
C.RETRY_FILES_ENABLED = False
self.callbackmodule = CallbackModule()
if playbook_path is None or not os.path.exists(playbook_path):
raise AnsibleError("Not Found the playbook file: %s." %
playbook_path)
self.playbook_path = playbook_path
self.inventory = MyInventory(host_list=hosts)
self.loader = DataLoader()
self.variable_manager = VariableManager(self.loader, self.inventory)
self.passwords = passwords or {}
self.options = Options(listtags=listtags,
listtasks=listtasks,
listhosts=listhosts,
syntax=syntax,
timeout=timeout,
connection=connection_type,
module_path=module_path,
forks=forks,
remote_user=remote_user,
private_key_file=private_key_file,
ssh_common_args=ssh_common_args or "",
ssh_extra_args=ssh_extra_args or "",
sftp_extra_args=sftp_extra_args,
scp_extra_args=scp_extra_args,
become=become,
become_method=become_method,
become_user=become_user,
verbosity=verbosity,
extra_vars=extra_vars or [],
check=check,
diff=False)
self.variable_manager.extra_vars = load_extra_vars(
loader=self.loader, options=self.options)
self.variable_manager.options_vars = load_options_vars(
self.options, "")
self.variable_manager.set_inventory(self.inventory)
self.runner = PlaybookExecutor(playbooks=[self.playbook_path],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords)
if self.runner._tqm:
self.runner._tqm._stdout_callback = self.callbackmodule
def run(self):
if not self.inventory.list_hosts("all"):
raise AnsibleError("Inventory is empty.")
self.runner.run()
return self.callbackmodule.output
def run(self):
super(PlaybookCLI, self).run()
# Note: slightly wrong, this is written so that implicit localhost
# manages passwords
sshpass = None
becomepass = None
passwords = {}
# initial error check, to make sure all specified playbooks are accessible
# before we start running anything through the playbook executor
for playbook in context.CLIARGS['args']:
if not os.path.exists(playbook):
raise AnsibleError("the playbook: %s could not be found" %
playbook)
if not (os.path.isfile(playbook)
or stat.S_ISFIFO(os.stat(playbook).st_mode)):
raise AnsibleError(
"the playbook: %s does not appear to be a file" % playbook)
# don't deal with privilege escalation or passwords when we don't need to
if not (context.CLIARGS['listhosts'] or context.CLIARGS['listtasks']
or context.CLIARGS['listtags'] or context.CLIARGS['syntax']):
(sshpass, becomepass) = self.ask_passwords()
passwords = {'conn_pass': sshpass, 'become_pass': becomepass}
loader, inventory, variable_manager = self._play_prereqs()
# (which is not returned in list_hosts()) is taken into account for
# warning if inventory is empty. But it can't be taken into account for
# checking if limit doesn't match any hosts. Instead we don't worry about
# limit if only implicit localhost was in inventory to start with.
#
# Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts())
hosts = self.get_host_list(inventory, context.CLIARGS['subset'])
# flush fact cache if requested
if context.CLIARGS['flush_cache']:
self._flush_cache(inventory, variable_manager)
# create the playbook executor, which manages running the plays via a task queue manager
pbex = PlaybookExecutor(playbooks=context.CLIARGS['args'],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
passwords=passwords)
results = pbex.run()
if isinstance(results, list):
for p in results:
display.display('\nplaybook: %s' % p['playbook'])
for idx, play in enumerate(p['plays']):
if play._included_path is not None:
loader.set_basedir(play._included_path)
else:
pb_dir = os.path.realpath(
os.path.dirname(p['playbook']))
loader.set_basedir(pb_dir)
msg = "\n play #%d (%s): %s" % (idx + 1, ','.join(
play.hosts), play.name)
mytags = set(play.tags)
msg += '\tTAGS: [%s]' % (','.join(mytags))
if context.CLIARGS['listhosts']:
playhosts = set(inventory.get_hosts(play.hosts))
msg += "\n pattern: %s\n hosts (%d):" % (
play.hosts, len(playhosts))
for host in playhosts:
msg += "\n %s" % host
display.display(msg)
all_tags = set()
if context.CLIARGS['listtags'] or context.CLIARGS[
'listtasks']:
taskmsg = ''
if context.CLIARGS['listtasks']:
taskmsg = ' tasks:\n'
def _process_block(b):
taskmsg = ''
for task in b.block:
if isinstance(task, Block):
taskmsg += _process_block(task)
else:
if task.action == 'meta':
continue
all_tags.update(task.tags)
if context.CLIARGS['listtasks']:
cur_tags = list(
mytags.union(set(task.tags)))
cur_tags.sort()
if task.name:
taskmsg += " %s" % task.get_name(
)
else:
taskmsg += " %s" % task.action
taskmsg += "\tTAGS: [%s]\n" % ', '.join(
cur_tags)
return taskmsg
all_vars = variable_manager.get_vars(play=play)
play_context = PlayContext(play=play)
for block in play.compile():
block = block.filter_tagged_tasks(
play_context, all_vars)
if not block.has_tasks():
continue
taskmsg += _process_block(block)
if context.CLIARGS['listtags']:
cur_tags = list(mytags.union(all_tags))
cur_tags.sort()
taskmsg += " TASK TAGS: [%s]\n" % ', '.join(
cur_tags)
display.display(taskmsg)
return 0
else:
return results
class PlayBookRunner(object):
"""
用于执行AnsiblePlaybook的接口.简化Playbook对象的使用.
"""
Options = namedtuple('Options', [
'listtags', 'listtasks', 'listhosts', 'syntax', 'connection',
'module_path', 'forks', 'remote_user', 'private_key_file', 'timeout',
'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args',
'scp_extra_args', 'become', 'become_method', 'become_user',
'verbosity', 'check', 'extra_vars'])
def __init__(self,
hosts=None,
playbook_path=None,
forks=C.DEFAULT_FORKS,
listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
module_path=None,
remote_user='******',
timeout=C.DEFAULT_TIMEOUT,
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,
extra_vars=None,
connection_type="ssh",
passwords=None,
private_key_file=None,
check=False):
C.RETRY_FILES_ENABLED = False
self.callbackmodule = PlaybookResultCallBack()
if playbook_path is None or not os.path.exists(playbook_path):
raise AnsibleError(
"Not Found the playbook file: %s." % playbook_path)
self.playbook_path = playbook_path
self.loader = DataLoader()
self.variable_manager = VariableManager()
self.passwords = passwords or {}
self.inventory = JMSInventory(hosts)
self.options = self.Options(
listtags=listtags,
listtasks=listtasks,
listhosts=listhosts,
syntax=syntax,
timeout=timeout,
connection=connection_type,
module_path=module_path,
forks=forks,
remote_user=remote_user,
private_key_file=private_key_file,
ssh_common_args=ssh_common_args or "",
ssh_extra_args=ssh_extra_args or "",
sftp_extra_args=sftp_extra_args,
scp_extra_args=scp_extra_args,
become=become,
become_method=become_method,
become_user=become_user,
verbosity=verbosity,
extra_vars=extra_vars or [],
check=check
)
self.variable_manager.extra_vars = load_extra_vars(loader=self.loader,
options=self.options)
self.variable_manager.options_vars = load_options_vars(self.options)
self.variable_manager.set_inventory(self.inventory)
# 初始化playbook的executor
self.runner = PlaybookExecutor(
playbooks=[self.playbook_path],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords)
if self.runner._tqm:
self.runner._tqm._stdout_callback = self.callbackmodule
def run(self):
if not self.inventory.list_hosts('all'):
raise AnsibleError('Inventory is empty')
self.runner.run()
self.runner._tqm.cleanup()
return self.callbackmodule.output
'''
try:
playbook_path = 'test.yml' # modify here, change playbook
#self.variable_manager.extra_vars=extra_vars
if not os.path.exists(playbook_path):
sys.exit('[INFO] The playbook does not exist')
passwords = {}
executor = PlaybookExecutor(
playbooks=[playbook_path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords,
)
# executor._tqm._stdout_callback = self.results_callback
# code = executor.run()
# stats = executor._tqm._stats
# hosts = sorted(stats)
code = executor.run()
stats = executor._tqm._stats
hosts = sorted(stats.processed.keys())
result = [{h: stats.summarize(h)} for h in hosts]
results = {'code': code, 'result': result, 'playbook': playbook_path}
except Exception as e:
msg = traceback.format_exc()
sys.exit(msg)
def execute_playbook(self, playbook_info):
output = None
try:
loader = DataLoader()
inventory = InventoryManager(loader=loader, sources=['localhost'])
variable_manager = VariableManager(loader=loader,
inventory=inventory)
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', 'diff'
])
options = Options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
connection='ssh',
module_path=None,
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,
diff=False)
variable_manager.extra_vars = playbook_info['extra_vars']
pbex = PlaybookExecutor(playbooks=[playbook_info['uri']],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=None)
ret_val = pbex.run()
if ret_val != 0:
msg = MsgBundle.getMessage(
MsgBundle.PLAYBOOK_RETURN_WITH_ERROR)
raise Exception(msg)
output = self.get_plugin_output(pbex)
if output is None or output.get('status') is None:
msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_OUTPUT_MISSING)
raise Exception(msg)
if output.get('status').lower() == "failure":
msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_STATUS_FAILED)
raise Exception(msg)
return output
except Exception as exp:
msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_EXECUTE_ERROR,
playbook_uri=playbook_info['uri'],
execution_id=playbook_info['extra_vars']
['playbook_input']['job_execution_id'],
exc_msg=repr(exp))
if exp.message:
msg = msg + "\n" + exp.message
JM_LOGGER.error(msg)
# after handling exception, write an END
# to stop listening to the file if created
unique_pb_id = playbook_info['extra_vars']['playbook_input'][
'unique_pb_id']
exec_id = playbook_info['extra_vars']['playbook_input'][
'job_execution_id']
line_in_file = ""
if output != None:
line_in_file = unique_pb_id + 'PLAYBOOK_OUTPUT##'\
+ json.dumps(output) + 'PLAYBOOK_OUTPUT##'\
+ '\n'
with open("/tmp/" + exec_id, "a") as f:
f.write(line_in_file + unique_pb_id + 'END' + '\n')
sys.exit(msg)
"diff": False,
"inventory": ["./hosts"],
"listhosts": None,
"subset": "server_a",
"extra_vars": ["targetHost=server_b", "sourseHost=server_a"],
"ask_vault_pass": False,
"vault_password_files": [],
"vault_ids": [],
"forks": 5,
"module_path": None,
"listtasks": None,
"listtags": None,
"step": None,
"start_at_task": None,
})
context._init_global_context(options)
loader, inventory, variable_manager = CLI._play_prereqs()
CLI.get_host_list(inventory, context.CLIARGS["subset"])
pbex = PlaybookExecutor(playbooks=["./playbooks/roles/common/tasks/main.yml"],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
passwords=dict(conn_pass="******",
become_pass="******"))
result_callback = ResultCallback()
pbex._tqm._stdout_callback = result_callback
result_id = pbex.run()
result = result_callback.getResult()
def run_need_data(self):
if not os.path.exists(self.playbook):
code = 1000
complex = {
'playbook': self.playbook,
'msg': self.playbook + ' playbook does not exist',
'flag': False
}
simple = 'playbook does not exist about ' + self.playbook
return code, simple, complex
pbex = PlaybookExecutor(playbooks=[self.playbook],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options,
passwords=self.passwords)
results_callback = ResultCallback()
pbex._tqm._stdout_callback = results_callback
try:
code = pbex.run()
except AnsibleParserError:
code = 1001
complex = {
'playbook': self.playbook,
'msg': 'syntax problems in ' + self.playbook,
'flag': False
}
simple = 'syntax problems in ' + self.playbook
return code, simple, complex
if results_callback.no_hosts:
code = 1002
complex = 'no hosts matched in ' + self.playbook
simple = {
'executed': False,
'flag': False,
'playbook': self.playbook,
'msg': 'no_hosts'
}
return code, simple, complex
else:
ok = json.loads(results_callback.ok)
fail = json.loads(results_callback.fail)
unreachable = json.loads(results_callback.unreachable)
if code != 0:
complex = {
'playbook': results_callback.playbook,
'ok': ok,
'fail': fail,
'unreachable': unreachable,
'flag': False
}
simple = {
'executed': True,
'flag': False,
'playbook': self.playbook,
'msg': {
'playbook': self.playbook,
'ok_hosts': ok.keys(),
'fail': fail.keys(),
'unreachable': unreachable.keys()
}
}
return code, simple, complex
else:
complex = {
'playbook': results_callback.playbook,
'ok': ok,
'fail': fail,
'unreachable': unreachable,
'flag': True
}
simple = {
'executed': True,
'flag': True,
'playbook': self.playbook,
'msg': {
'playbook': self.playbook,
'ok_hosts': ok.keys(),
'fail': fail.keys(),
'unreachable': unreachable.keys()
}
}
return code, simple, complex
def ansiblex_deploy(vars1="1",
vars2="2",
vars3="3",
vars4="4",
vars5="5",
vars6="6",
vars7="7",
vars8="8",
vars9="9",
vars10="10",
vars11="11",
vars12="12",
vars13="13",
vars14="14",
vars15="15",
vars16="16"):
one_var = vars1
two_var = vars2
three_var = vars3
four_var = vars4
five_var = vars5
six_var = vars6
seven_var = vars7
eight_var = vars8
nine_var = vars9
ten_var = vars10
eleven_var = vars11
twelve_var = vars12
thirteen_var = vars13
fourteen_var = vars14
fifteen_var = vars15
sixteen_var = vars16
variable_manager = VariableManager()
loader = DataLoader()
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=one_var)
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'
])
options = Options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
connection='ssh',
module_path=None,
forks=30,
remote_user='******',
private_key_file=None,
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 = {
'three_var': three_var,
'four_var': four_var,
'five_var': five_var,
'six_var': six_var,
'seven_var': seven_var,
'eight_var': eight_var,
'nine_var': nine_var,
'ten_var': ten_var,
'eleven_var': eleven_var,
'twelve_var': twelve_var,
'thirteen_var': thirteen_var,
'fourteen_var': fourteen_var,
'fifteen_var': fifteen_var,
'sixteen_var': sixteen_var
}
passwords = {}
pbex = PlaybookExecutor(playbooks=[two_var],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
callback = CallbackModule()
pbex._tqm._stdout_callback = callback
return_code = pbex.run()
results = callback.results
return results
"failed": t['failures']
}
callback = PlayBookResultsCollector()
#PlaybookExecutor 执行playbook
passwords = dict()
playbook = PlaybookExecutor(
playbooks=['f1.yml'],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords,
)
playbook._tqm._stdout_callback = callback
playbook.run()
results_raw = {
'skipped': {},
'failed': {},
'ok': {},
"status": {},
'unreachable': {},
"changed": {}
}
for host, result in callback.task_ok.items():
results_raw['ok'][host] = result
print results_raw
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 runner_playbook(self, playbooks, inventory):
"""
运行playbook
:param playbooks: playbook的路径
:param inventory:
:return:
"""
if isinstance(playbooks, str):
playbooks = [playbooks]
Options = namedtuple(
"Options",
[
"connection",
"module_path",
"forks",
"private_key_file",
"become",
"become_method",
"become_user",
"check",
"diff",
"listhosts",
"listtasks",
"listtags",
"syntax",
"verbosity",
],
)
options = Options(
connection="smart",
module_path=None,
forks=10,
private_key_file=self.private_key_file, # 你的私钥
become=True,
become_method="sudo",
become_user="******",
check=False,
diff=False,
listhosts=None,
listtasks=None,
listtags=None,
syntax=None,
verbosity=1, # >= 4 时展示详细调试信息
)
loader = DataLoader()
passwords = dict(vault_pass="******")
inventory_obj = InventoryManager(loader=loader, sources=inventory)
variable_manager = VariableManager(loader=loader, inventory=inventory_obj)
executor = PlaybookExecutor(
playbooks=playbooks,
inventory=inventory_obj,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords,
)
if self.results_callback:
executor._tqm._callback_plugins.append(self.results_callback)
executor._tqm._gather_facts = False
result_code = executor.run()
result_raw = {"success": {}, "failed": {}, "unreachable": {}}
for host, result in self.results_callback.host_ok.items():
result_raw['success'][host] = json.dumps(result._result)
for host, result in self.results_callback.host_failed.items():
result_raw['failed'][host] = result._result['msg']
for host, result in self.results_callback.host_unreachable.items():
result_raw['unreachable'][host] = result._result['msg']
# result_code 等于0代表任务全部运行成功
return result_code, result_raw
def run(self):
super(PlaybookCLI, self).run()
# Note: slightly wrong, this is written so that implicit localhost
# Manage passwords
sshpass = None
becomepass = None
b_vault_pass = None
passwords = {}
# initial error check, to make sure all specified playbooks are accessible
# before we start running anything through the playbook executor
for playbook in self.args:
if not os.path.exists(playbook):
raise AnsibleError("the playbook: %s could not be found" %
playbook)
if not (os.path.isfile(playbook)
or stat.S_ISFIFO(os.stat(playbook).st_mode)):
raise AnsibleError(
"the playbook: %s does not appear to be a file" % playbook)
# don't deal with privilege escalation or passwords when we don't need to
if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax:
self.normalize_become_options()
(sshpass, becomepass) = self.ask_passwords()
passwords = {'conn_pass': sshpass, 'become_pass': becomepass}
loader = DataLoader()
if self.options.vault_password_file:
# read vault_pass from a file
b_vault_pass = CLI.read_vault_password_file(
self.options.vault_password_file, loader=loader)
loader.set_vault_password(b_vault_pass)
elif self.options.ask_vault_pass:
b_vault_pass = self.ask_vault_passwords()
loader.set_vault_password(b_vault_pass)
# create the variable manager, which will be shared throughout
# the code, ensuring a consistent view of global variables
variable_manager = VariableManager()
variable_manager.extra_vars = load_extra_vars(loader=loader,
options=self.options)
variable_manager.options_vars = load_options_vars(self.options)
# create the inventory, and filter it based on the subset specified (if any)
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=self.options.inventory)
variable_manager.set_inventory(inventory)
# (which is not returned in list_hosts()) is taken into account for
# warning if inventory is empty. But it can't be taken into account for
# checking if limit doesn't match any hosts. Instead we don't worry about
# limit if only implicit localhost was in inventory to start with.
#
# Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts())
no_hosts = False
if len(inventory.list_hosts()) == 0:
# Empty inventory
display.warning(
"provided hosts list is empty, only localhost is available")
no_hosts = True
inventory.subset(self.options.subset)
if len(inventory.list_hosts()) == 0 and no_hosts is False:
# Invalid limit
raise AnsibleError("Specified --limit does not match any hosts")
# flush fact cache if requested
if self.options.flush_cache:
self._flush_cache(inventory, variable_manager)
# create the playbook executor, which manages running the plays via a task queue manager
pbex = PlaybookExecutor(playbooks=self.args,
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=self.options,
passwords=passwords)
results = pbex.run()
if isinstance(results, list):
for p in results:
display.display('\nplaybook: %s' % p['playbook'])
for idx, play in enumerate(p['plays']):
if play._included_path is not None:
loader.set_basedir(play._included_path)
else:
pb_dir = os.path.realpath(
os.path.dirname(p['playbook']))
loader.set_basedir(pb_dir)
msg = "\n play #%d (%s): %s" % (idx + 1, ','.join(
play.hosts), play.name)
mytags = set(play.tags)
msg += '\tTAGS: [%s]' % (','.join(mytags))
if self.options.listhosts:
playhosts = set(inventory.get_hosts(play.hosts))
msg += "\n pattern: %s\n hosts (%d):" % (
play.hosts, len(playhosts))
for host in playhosts:
msg += "\n %s" % host
display.display(msg)
all_tags = set()
if self.options.listtags or self.options.listtasks:
taskmsg = ''
if self.options.listtasks:
taskmsg = ' tasks:\n'
def _process_block(b):
taskmsg = ''
for task in b.block:
if isinstance(task, Block):
taskmsg += _process_block(task)
else:
if task.action == 'meta':
continue
all_tags.update(task.tags)
if self.options.listtasks:
cur_tags = list(
mytags.union(set(task.tags)))
cur_tags.sort()
if task.name:
taskmsg += " %s" % task.get_name(
)
else:
taskmsg += " %s" % task.action
taskmsg += "\tTAGS: [%s]\n" % ', '.join(
cur_tags)
return taskmsg
all_vars = variable_manager.get_vars(loader=loader,
play=play)
play_context = PlayContext(play=play,
options=self.options)
for block in play.compile():
block = block.filter_tagged_tasks(
play_context, all_vars)
if not block.has_tasks():
continue
taskmsg += _process_block(block)
if self.options.listtags:
cur_tags = list(mytags.union(all_tags))
cur_tags.sort()
taskmsg += " TASK TAGS: [%s]\n" % ', '.join(
cur_tags)
display.display(taskmsg)
return 0
else:
return results
def install_dns_playbook():
content = request.get_json(force=True)
tagsexc = content['tagsexc']
ipmanage = content['ipmanage']
keyfile = content['fileprivatekey']
play = content['play']
passwd = content['passwd']
user = content['user']
inventory = content['inventory']
logging.info('runnig ansible-playbook ' + tagsexc + ' ' + ipmanage)
file = open(inventory, 'w')
file.write('[hostexec]\n')
file.write(ipmanage)
file.close()
loader = DataLoader()
if passwd:
context.CLIARGS = ImmutableDict(
tags={tagsexc},
listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
connection='ssh',
module_path=None,
forks=10,
remote_user=user,
private_key_file=None,
ssh_common_args=None,
ssh_extra_args=None,
sftp_extra_args=None,
scp_extra_args=None,
become=True,
become_method='sudo',
become_user='******',
verbosity=True,
check=False,
start_at_task=None,
extra_vars={
'ansible_ssh_user='******'',
'ansible_ssh_pass='******'',
'ansible_become_pass='******''
})
else:
context.CLIARGS = ImmutableDict(
tags={tagsexc},
listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
connection='ssh',
module_path=None,
forks=10,
remote_user=user,
private_key_file=None,
ssh_common_args=None,
ssh_extra_args=None,
sftp_extra_args=None,
scp_extra_args=None,
become=True,
become_method='sudo',
become_user='******',
verbosity=True,
check=False,
start_at_task=None,
extra_vars={
'ansible_ssh_user='******'',
'ansible_ssh_private_key_file=' + keyfile + ''
})
inventory = InventoryManager(loader=loader, sources=(inventory))
variable_manager = VariableManager(
loader=loader,
inventory=inventory,
version_info=CLI.version_info(gitinfo=False))
pbex = PlaybookExecutor(playbooks=[play],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
passwords={})
results = pbex.run()
db.session.commit()
return jsonify({'status': results})
def run(self):
super(PlaybookCLI, self).run()
# Note: slightly wrong, this is written so that implicit localhost
# Manage passwords
sshpass = None
becomepass = None
vault_pass = None
passwords = {}
# don't deal with privilege escalation or passwords when we don't need to
if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax:
self.normalize_become_options()
(sshpass, becomepass) = self.ask_passwords()
passwords = {'conn_pass': sshpass, 'become_pass': becomepass}
if self.options.vault_password_file:
# read vault_pass from a file
vault_pass = CLI.read_vault_password_file(
self.options.vault_password_file)
elif self.options.ask_vault_pass:
vault_pass = self.ask_vault_passwords(ask_vault_pass=True,
ask_new_vault_pass=False,
confirm_new=False)[0]
loader = DataLoader(vault_password=vault_pass)
# initial error check, to make sure all specified playbooks are accessible
# before we start running anything through the playbook executor
for playbook in self.args:
if not os.path.exists(playbook):
raise AnsibleError("the playbook: %s could not be found" %
playbook)
if not (os.path.isfile(playbook)
or stat.S_ISFIFO(os.stat(playbook).st_mode)):
raise AnsibleError(
"the playbook: %s does not appear to be a file" % playbook)
# create the variable manager, which will be shared throughout
# the code, ensuring a consistent view of global variables
variable_manager = VariableManager()
variable_manager.extra_vars = load_extra_vars(loader=loader,
options=self.options)
# create the inventory, and filter it based on the subset specified (if any)
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=self.options.inventory)
variable_manager.set_inventory(inventory)
# (which is not returned in list_hosts()) is taken into account for
# warning if inventory is empty. But it can't be taken into account for
# checking if limit doesn't match any hosts. Instead we don't worry about
# limit if only implicit localhost was in inventory to start with.
#
# Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts())
no_hosts = False
if len(inventory.list_hosts()) == 0:
# Empty inventory
self.display.warning(
"provided hosts list is empty, only localhost is available")
no_hosts = True
inventory.subset(self.options.subset)
if len(inventory.list_hosts()) == 0 and no_hosts is False:
# Invalid limit
raise AnsibleError("Specified --limit does not match any hosts")
# create the playbook executor, which manages running the plays via a task queue manager
pbex = PlaybookExecutor(playbooks=self.args,
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
display=self.display,
options=self.options,
passwords=passwords)
results = pbex.run()
if isinstance(results, list):
for p in results:
self.display.display('\nplaybook: %s' % p['playbook'])
i = 1
for play in p['plays']:
if play.name:
playname = play.name
else:
playname = '#' + str(i)
msg = "\n PLAY: %s" % (playname)
mytags = set()
if self.options.listtags and play.tags:
mytags = mytags.union(set(play.tags))
msg += ' TAGS: [%s]' % (','.join(mytags))
if self.options.listhosts:
playhosts = set(inventory.get_hosts(play.hosts))
msg += "\n pattern: %s\n hosts (%d):" % (
play.hosts, len(playhosts))
for host in playhosts:
msg += "\n %s" % host
self.display.display(msg)
if self.options.listtags or self.options.listtasks:
taskmsg = ' tasks:'
for block in play.compile():
if not block.has_tasks():
continue
j = 1
for task in block.block:
taskmsg += "\n %s" % task
if self.options.listtags and task.tags:
taskmsg += " TAGS: [%s]" % ','.join(
mytags.union(set(task.tags)))
j = j + 1
self.display.display(taskmsg)
i = i + 1
return 0
else:
return results
options = Options(connection='smart',
remote_user=None,
ask_pass=None,
sudo_user=None,
forks=5,
sudo=None,
ask_sudo_pass=False,
verbosity=5,
module_path=None,
become=None,
become_method=None,
become_user=None,
check=False,
diff=False,
listhosts=None,
listtasks=None,
listtags=None,
syntax=None)
loader = DataLoader()
passwords = dict()
inventory = InventoryManager(loader=loader, sources=['myansible/hosts'])
variable_manager = VariableManager(loader=loader, inventory=inventory)
playbook = PlaybookExecutor(playbooks=['myansible/lamp.yml'],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
result = playbook.run()
print(result)
def run_playbook(self, playbook_info):
try:
# create job log to capture the start of the playbook
device_id = playbook_info['extra_vars']['playbook_input']
['device_id']
if device_id is None:
device_id = ""
msg = "Starting to execute the playbook %s for device " \
"%s with input %s and params %s " % \
(playbook_info['uri'], device_id,
json.dumps(playbook_info['extra_vars']['playbook_input']
['input']),
json.dumps(playbook_info['extra_vars']['playbook_input']
['params']))
self._logger.debug(msg)
if not os.path.exists(playbook_info['uri']):
raise JobException(
"Playbook %s does not "
"exist" % playbook_info['uri'], self._execution_id)
loader = DataLoader()
inventory = InventoryManager(loader=loader, sources=['localhost'])
variable_manager = VariableManager(loader=loader,
inventory=inventory)
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', 'diff'
])
options = Options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
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=None,
verbosity=None,
check=False,
diff=False)
variable_manager.extra_vars = playbook_info['extra_vars']
passwords = dict(vault_pass='******')
pbex = PlaybookExecutor(playbooks=[playbook_info['uri']],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
pbex.run()
self._logger.debug("Completed executing the playbook %s. "
"Collecting output." % playbook_info['uri'])
output = self.get_plugin_output(pbex)
self._logger.debug("Output for playbook %s : "
"%s" %
(playbook_info['uri'], json.dumps(output)))
# create job log to capture completion of the playbook execution
msg = "Completed to execute the playbook %s for" \
" device %s" % (playbook_info['uri'],
playbook_info['extra_vars']['playbook_input']
['device_id'])
self._logger.debug(msg)
return output
except Exception as e:
msg = "Error while executing the playbook %s : %s" % \
(playbook_info['uri'], repr(e))
raise JobException(msg, self._execution_id)
def exec_playbook(self,playbooks):
pbex = PlaybookExecutor(playbooks=playbooks,inventory=self.inventory,
variable_manager=self.variable_manager,loader=self.loader,
options=self.options,passwords=self.passwords)
results=pbex.run()
def _run_playbook_executor(self):
pbex = PlaybookExecutor(**self._pbex_args)
if pbex.run() != 0:
raise AnsibleExecutionFailure
def run_ansible(playbooks,
inventory_path=None,
roles=None,
extra_vars=None,
tags=None,
on_error_continue=False,
basedir='.'):
"""Run Ansible.
Args:
playbooks (list): list of paths to the playbooks to run
inventory_path (str): path to the hosts file (inventory)
extra_var (dict): extra vars to pass
tags (list): list of tags to run
on_error_continue(bool): Don't throw any exception in case a host is
unreachable or the playbooks run with errors
Raises:
:py:class:`enoslib.errors.EnosFailedHostsError`: if a task returns an
error on a host and ``on_error_continue==False``
:py:class:`enoslib.errors.EnosUnreachableHostsError`: if a host is
unreachable (through ssh) and ``on_error_continue==False``
"""
inventory, variable_manager, loader, options = _load_defaults(
inventory_path=inventory_path,
roles=roles,
extra_vars=extra_vars,
tags=tags,
basedir=basedir)
passwords = {}
for path in playbooks:
logger.info("Running playbook %s with vars:\n%s" % (path, extra_vars))
pbex = PlaybookExecutor(playbooks=[path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
code = pbex.run()
stats = pbex._tqm._stats
hosts = stats.processed.keys()
result = [{h: stats.summarize(h)} for h in hosts]
results = {"code": code, "result": result, "playbook": path}
print(results)
failed_hosts = []
unreachable_hosts = []
for h in hosts:
t = stats.summarize(h)
if t["failures"] > 0:
failed_hosts.append(h)
if t["unreachable"] > 0:
unreachable_hosts.append(h)
if len(failed_hosts) > 0:
logger.error("Failed hosts: %s" % failed_hosts)
if not on_error_continue:
raise EnosFailedHostsError(failed_hosts)
if len(unreachable_hosts) > 0:
logger.error("Unreachable hosts: %s" % unreachable_hosts)
if not on_error_continue:
raise EnosUnreachableHostsError(unreachable_hosts)
loader = DataLoader()
loader.set_vault_secrets([('default', VaultSecret(_bytes=to_bytes('123456')))])
context.CLIARGS = ImmutableDict(tags={},
listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
module_path=None,
forks=100,
private_key_file=None,
start_at_task=None)
inventory = InventoryManager(loader=loader,
sources=[code_path + '/ansible/inventory'])
variable_manager = VariableManager(
loader=loader,
inventory=inventory,
version_info=CLI.version_info(gitinfo=False))
variable_manager._extra_vars = {'firstvar': False}
pbex = PlaybookExecutor(playbooks=[code_path + '/ansible/variables.yml'],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
passwords={})
results = pbex.run()
print(results)
def launch_ansible_playbook(list_ip, playbook, extra_variable=None):
"""
Applies an Ansible playbook
:param list_ip: the ips
:param playbook: the playboos to be applied
:param extra_variable: dict of the playbook variables to be applied
"""
host_list = list_ip
if not os.path.isfile(playbook):
raise Exception('Requested playbook is not found - ' + playbook)
if not playbook:
logger.warn('Unable to find playbook - ' + playbook)
loader = DataLoader()
inventory = InventoryManager(loader=loader, sources=','.join(host_list))
variable_manager = VariableManager(loader=loader, inventory=inventory)
if extra_variable is not None:
variable_manager.extra_vars = extra_variable
logger.info(extra_variable)
else:
logger.info('NO EXTRA VARS')
options = namedtuple('Options', [
'listtags', 'listtasks', 'listhosts', 'syntax', 'connection',
'module_path', 'forks', 'remote_user', 'private_key_file',
'ssh_common_args', 'ssh_extra_args', 'become', 'become_method',
'become_user', 'verbosity', 'check', 'sftp_extra_args',
'scp_extra_args', 'diff'
])
ansible_opts = options(listtags=None,
listtasks=None,
listhosts=None,
syntax=False,
connection='ssh',
module_path=None,
forks=100,
remote_user=None,
private_key_file=None,
ssh_common_args=None,
ssh_extra_args=None,
become=True,
become_method='sudo',
become_user=None,
verbosity=11111,
check=False,
sftp_extra_args=None,
scp_extra_args=None,
diff=False)
logger.debug('Setting up Ansible Playbook Executor for playbook - ' +
playbook)
executor = PlaybookExecutor(playbooks=[playbook],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=ansible_opts,
passwords=None)
logger.debug('Executing Ansible Playbook - ' + playbook)
ret = executor.run()
return ret
def ansiblex_domain(vars1="1",
vars2="2",
vars3="3",
vars4="4",
vars5="5",
vars6="6",
vars7="7",
vars8="8"):
one_var = vars1
two_var = vars2
three_var = vars3
four_var = vars4
five_var = vars5
six_var = vars6
seven_var = vars7
eight_var = vars8
variable_manager = VariableManager()
loader = DataLoader()
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=one_var)
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'
])
options = Options(listtags=False,
listtasks=False,
listhosts=False,
syntax=False,
connection='ssh',
module_path=None,
forks=30,
remote_user='******',
private_key_file=None,
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 = {
'three_var': three_var,
'four_var': four_var,
'five_var': five_var,
'six_var': six_var,
'seven_var': seven_var,
'eight_var': eight_var
}
passwords = {}
pbex = PlaybookExecutor(playbooks=[two_var],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
results = pbex.run()
return results
