def __init__(self, inventory_files):
if not has_ansible:
raise Exception("Ansible is needed for this module")
self._dataloader = DataLoader()
self._inv_mgr = InventoryManager(loader=self._dataloader, sources=inventory_files)
self._var_mgr = VariableManager(loader=self._dataloader, inventory=self._inv_mgr)
def __init__(self, module=None):
self.module = module
self.tasks = []
self.results = dict(tasks_run=[],
tasks_failed=[],
tasks_unreachable=[],
tasks_result=dict())
# counter
# self._JS = 0
self.config = Config()
_options = namedtuple(
'Options',
[
'connection', # connection types: smart,ssh,paramiko...
'module_path', # remote python module path
'forks', # forks numbers
'become', # True or False
'become_method', # sudo or other
'become_user', # who sudo
'check', # TODO: unknown
'diff', # TODO: unknown
'remote_user', # remote user name
'ssh_common_args', # add ssh args
'private_key_file', # where private key
'verbosity', # more information show
'host_key_checking', # next version support for close host checking
'listhosts', # support PlaybookExecutor
'listtasks', # support PlaybookExecutor
'listtags', # support PlaybookExecutor
'syntax', # support PlaybookExecutor
])
# defaults args
_defaults = dict(
connection='smart',
module_path=None,
forks=100,
become=True,
become_method='sudo',
become_user='******',
check=False,
diff=False,
remote_user='******',
ssh_common_args=None,
private_key_file=None,
verbosity=4,
host_key_checking=False,
)
# load from config file
for i, j in self.config.items():
_defaults[i] = j
self.options = _options(
connection=_defaults['connection'],
remote_user=_defaults['remote_user'],
module_path=_defaults['module_path'],
forks=_defaults['forks'],
become=_defaults['become'],
become_method=_defaults['become_method'],
become_user=_defaults['become_user'],
check=_defaults['check'],
diff=_defaults['diff'],
ssh_common_args=_defaults['ssh_common_args'],
private_key_file=_defaults['private_key_file'],
verbosity=_defaults['verbosity'],
host_key_checking=_defaults['host_key_checking'],
listhosts=None,
listtasks=None,
listtags=None,
syntax=None,
)
self.loader = DataLoader()
self.inventory = InventoryManager(loader=self.loader,
sources=LC['HOSTS_FILES'])
self.variable_manager = VariableManager(loader=self.loader,
inventory=self.inventory)
self.play_source = dict(name='',
hosts='',
gather_facts='no',
tasks=self.tasks)
self.results_callback = ResultCallback(self.results)
errors.append((file, task.action, module))
break
print(task.action)
if '.' not in task.action:
errors.append((file, task.action, "no dot in namespace"))
except AnsibleParserError:
pass
except Exception:
pass
return errors
loader = DataLoader()
inventory = InventoryManager(loader=loader, sources='localhost,')
variable_manager = VariableManager(loader=loader, inventory=inventory)
url = ("https://raw.githubusercontent.com/"
"ansible/ansible/devel/lib/ansible/config/"
"ansible_builtin_runtime.yml")
response = urllib.request.urlopen(url)
data = response.read()
routing = yaml.load(data)['plugin_routing']
dirname = os.path.abspath(os.path.dirname(__file__))
search_folder = os.path.join(dirname, '../kubeinit/roles/')
to_fix = []
def execude(self):
# since API is constructed for CLI it expects certain options to always be set, named tuple 'fakes' the args parsing options object
Options = namedtuple('Options', [
'connection',
'module_path',
'forks',
'become',
'become_method',
'become_user',
'check',
'diff',
'private_key_file',
])
options = Options(
connection='smart',
module_path=['/to/mymodules'],
forks=10,
become=None,
become_method=None,
become_user='******',
check=False,
diff=False,
private_key_file='~/.ssh/id_rsa',
)
# initialize needed objects
loader = DataLoader(
) # Takes care of finding and reading yaml, json and ini files
passwords = dict(vault_pass='******')
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
results_callback = ResultCallback()
# create inventory, use path to host config file as source or hosts in a comma separated string
inventory = InventoryManager(loader=loader,
sources='/etc/ansible/hosts')
# inventory.add_host(host='172.20.51.22',port=22,group='test')
# variable manager takes care of merging all the different sources to give you a unified view of variables available in each context
variable_manager = VariableManager(loader=loader, inventory=inventory)
# create data structure that represents our play, including tasks, this is basically what our YAML loader does internally.
play_source = dict(
name="Ansible Play",
hosts=self.hosts,
gather_facts='no',
tasks=[
dict(
action=dict(module='shell', args='ps -ef | grep VSM'),
register='shell_out',
),
# dict(action=dict(module='setup', ), register='shell_out'),
# dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')))
])
play = Play().load(
play_source,
variable_manager=variable_manager,
loader=loader,
)
tqm = None
try:
tqm = TaskQueueManager(
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=None,
stdout_callback=results_callback,
# Use our custom callback instead of the ``default`` callback plugin, which prints to stdout
)
# atest = tqm
# atest.run(play)
rs = tqm.run(
play,
) # most interesting data for a play is actually sent to the callback's methods
print('---')
print()
# if tqm._stdout_callback.consquence:
# for key in tqm._stdout_callback.consquence['172.20.51.22']['stderr']:
# print(key,)
except BaseException:
print(str(BaseException))
finally:
# we always need to cleanup child procs and the structures we use to communicate with them
if tqm is not None:
tqm.cleanup()
# Remove ansible tmpdir
shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
check=False,
diff=False)
# initialize needed objects
#ansible会用到各种各样的文件， 如 json, yaml, ini等， 这些文件的内容需要转成python的数据类型，DataLoader自动进行转换
loader = DataLoader(
) # Takes care of finding and reading yaml, json and ini files
#各种密码 ,如果有利用ansible-vault 加密，尝试使用vault_pass 所指定的密码来解密
passwords = dict(vault_pass='******')
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
# results_callback = ResultCallback()
# create inventory, use path to host config file as source or hosts in a comma separated string
#inventory = InventoryManager(loader=loader, sources='localhost,')
inventory = InventoryManager(loader=loader, sources=["/root/myansible/hosts"])
# variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context
#变量管理器
variable_manager = VariableManager(loader=loader, inventory=inventory)
# create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally.
play_source = dict(
name="Ansible Play",
hosts='webservers',
gather_facts='no',
tasks=[
dict(action=dict(module='shell', args='ls'), register='shell_out'),
dict(action=dict(module='debug', args=dict(
msg='{{shell_out.stdout}}')))
def __init__(
self,
connection='local', # 连接方式 local 本地方式，smart ssh方式
remote_user=None, # 远程用户
ack_pass=None, # 提示输入密码
sudo=None,
sudo_user=None,
ask_sudo_pass=None,
module_path=None, # 模块路径，可以指定一个自定义模块的路径
become=None, # 是否提权
become_method=None, # 提权方式 默认 sudo 可以是 su
become_user=None, # 提权后，要成为的用户，并非登录用户
check=False,
diff=False,
listhosts=None,
listtasks=None,
listtags=None,
verbosity=3,
syntax=None,
start_at_task=None,
inventory=None):
# 函数文档注释
"""
初始化函数，定义的默认的选项值，
在初始化的时候可以传参，以便覆盖默认选项的值
"""
context.CLIARGS = ImmutableDict(
connection=connection,
remote_user=remote_user,
ack_pass=ack_pass,
sudo=sudo,
sudo_user=sudo_user,
ask_sudo_pass=ask_sudo_pass,
module_path=module_path,
become=become,
become_method=become_method,
become_user=become_user,
verbosity=verbosity,
listhosts=listhosts,
listtasks=listtasks,
listtags=listtags,
syntax=syntax,
start_at_task=start_at_task,
)
# 三元表达式，假如没有传递 inventory, 就使用 "localhost,"
self.inventory = inventory if inventory else "localhost,"
# 实例化数据解析器
self.loader = DataLoader()
# 实例化 资产配置对象
self.inv_obj = InventoryManager(loader=self.loader,
sources=self.inventory)
# 设置密码，可以为空字典，但必须有此参数
self.passwords = {}
# 实例化回调插件对象
self.results_callback = ResultCallback()
# 变量管理器
self.variable_manager = VariableManager(self.loader, self.inv_obj)
def __init__(self,
hostnames,
action,
playbook,
private_key_file,
run_data,
internal_data,
location,
become_pass,
request_id,
started_at,
config,
dbsession,
tr,
verbosity=5):
self.logger = app.logger
self.logger.debug('initializing ansible runbook executor')
self.action = action
self.config = config
self.dbsession = dbsession
self.transition_request = tr
self.location = location
self.run_data = run_data
self.internal_data = internal_data
self.run_variables = {}
self.run_variables.update(self.run_data)
self.run_variables.update(self.location)
self.run_variables.update(self.internal_data)
self.logger.debug(str(self.location))
self.logger.debug(str(self.run_data))
self.logger.debug(str(self.run_variables))
self.request_id = request_id
self.started_at = started_at
self.finished_at = None
self.resInstance = {}
# NEW 2.9
# handles options now
context.CLIARGS = ImmutableDict(
connection='ssh',
module_path=['/var/alm_ansible_rm/library'],
forks=20,
become=None,
become_method='sudo',
become_user='******',
check=False,
diff=False,
ansible_python_interpreter='/usr/bin/python3',
host_key_checking=False,
vault_password_file='/etc/ansible/tslvault.txt',
private_key_file=private_key_file,
listhosts=None,
listtasks=None,
listtags=None,
syntax=None,
start_at_task=None)
# Gets data from YAML/JSON files
self.loader = DataLoader()
self.loader.set_vault_secrets([
('default', VaultSecret(_bytes=to_bytes('TSLDem0')))
])
# create temporary inventory file
self.hosts = NamedTemporaryFile(delete=False)
self.hosts.write(b'[run_hosts]\n')
self.hosts.write(
b'localhost ansible_connection=local ansible_python_interpreter="/usr/bin/env python3" host_key_checking=False'
)
self.hosts.close()
# set Inventory
self.inventory = InventoryManager(loader=self.loader,
sources=self.hosts.name)
# All the variables from all the various places
self.variable_manager = VariableManager(loader=self.loader,
inventory=self.inventory)
# MOD 2.9 - has been renamed, not sure this is the proposed way to treat extra_vars, but it works
self.variable_manager._extra_vars = self.run_variables
# Become Pass Needed if not logging in as user root
passwords = {'become_pass': become_pass}
# Setup playbook executor, but don't run until run() called
self.pbex = playbook_executor.PlaybookExecutor(
playbooks=[playbook],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
passwords=passwords)
if (self.transition_request) and (isinstance(self.transition_request,
TransitionRequest)):
# log only if transition request, not for netowrk/image scans)
self.logger.debug('transition request ' +
str(self.transition_request))
self.log_request_status('PENDING', 'playbook initialized', '', '')
self.logger.debug('ansible runbook executor instantiated for ' +
str(playbook))
self.callback = OutputCallback(self.action, self.logger)
self.pbex._tqm._stdout_callback = self.callback
def CallbackBaseAdHoc(hosts,
actions,
name="Ansible Play",
source=settings.ANSIBLE_SOURCE):
'''
:param hosts: 主机列表
:param actions: 相关ad-hoc的指令，以字典形式 [dict(action=dict(module="shell", args="touch /tmp/bbb.txt", warn=False)),]
:param name: 任务名称
:param source ansible配置hosts文件
:return:
'''
logger = logging.getLogger("django")
dataLoader = DataLoader()
inventory = InventoryManager(loader=dataLoader, sources=source) #主机信息管理
variableManager = VariableManager(loader=dataLoader,
inventory=inventory) #变量管理
Options = namedtuple("Options", [
"connection", "remote_user", "ask_sudo_pass", "verbosity", "ack_pass",
"module_path", "forks", "become", "become_method", "become_user",
"check", "listhosts", "listtasks", "listtags", "syntax", "sudo_user",
"sudo", "diff"
])
options = Options(connection='ssh',
remote_user=None,
ack_pass=None,
sudo_user=None,
forks=settings.ANSIBLE_FORKS,
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)
play_source = dict(
name=name, # 任务名称
hosts=hosts, # 目标主机，可以填写具体主机也可以是主机组名称
gather_facts="no", # 是否收集主机配置信息
tasks=actions # tasks是具体执行的任务，列表形式，每个具体任务都是一个字典
)
play = Play().load(play_source,
variable_manager=variableManager,
loader=dataLoader)
passwords = dict() # 这个可以为空，因为在hosts文件中有配置或者密钥登陆
callback = AdHocCallbackBase()
tqm = TaskQueueManager(inventory=inventory,
variable_manager=variableManager,
loader=dataLoader,
options=options,
passwords=passwords,
stdout_callback=callback)
logger_info = {"hosts": hosts, "actions": actions, "passwords": passwords}
logger.info(str(logger_info))
tqm.run(play)
status_list = ['ok', 'failed', 'unreachable', 'skipped']
result_raw = {"failed": {}, "unreachable": {}, "ok": {}, "skipped": {}}
for status in status_list:
for host, result in getattr(callback, 'host_' + status).items():
result_raw[status][host] = result._result
result_raw[status][host]["task"] = name
logger.info(str(result_raw))
result_raw = get_result(result_raw)
return result_raw
def __init__(self,
playbooks,
ssh_user='******',
passwords='null',
project_name='all',
ack_pass=False,
forks=5,
ext_vars=None):
self.playbooks = playbooks
# self.host_list = host_list
self.ssh_user = ssh_user
self.passwords = dict(vault_pass=passwords)
self.project_name = project_name
self.ack_pass = ack_pass
self.forks = forks
self.connection = 'smart'
self.ext_vars = ext_vars
## 用来加载解析yaml文件或JSON内容,并且支持vault的解密
self.loader = DataLoader()
# 根据inventory加载对应变量
self.inventory = InventoryManager(loader=self.loader,
sources=['/etc/ansible/hosts'])
# 管理变量的类，包括主机，组，扩展等变量，之前版本是在 inventory中的
self.variable_manager = VariableManager(loader=self.loader,
inventory=self.inventory)
self.variable_manager.extra_vars = self.ext_vars
# print(self.variable_manager.get_vars())
# print(self.variable_manager.get_vars()) # 所有主机信息
self.variable_manager.set_inventory(self.inventory)
# 初始化需要的对象1
self.Options = namedtuple('Options', [
'connection', 'remote_user', 'ask_sudo_pass', 'verbosity',
'ack_pass', 'module_path', 'forks', 'become', 'become_method',
'become_user', 'check', 'listhosts', 'listtasks', 'listtags',
'syntax', 'sudo_user', 'sudo', 'diff'
])
# 初始化需要的对象2
self.options = self.Options(connection=self.connection,
remote_user=self.ssh_user,
ack_pass=self.ack_pass,
sudo_user=self.ssh_user,
forks=self.forks,
sudo='yes',
ask_sudo_pass=False,
verbosity=5,
module_path=None,
become=True,
become_method='sudo',
become_user='******',
check=None,
listhosts=None,
listtasks=None,
listtags=None,
syntax=None,
diff=False)
# 初始化console输出
self.callback = ResultCallback()
def ansible():
"""Run Ansible playbook"""
# initialize needed objects
loader = DataLoader()
# create inventory, use path to host config file as source or hosts in a comma separated string
inventory = InventoryManager(loader=loader, sources='hosts')
# variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context
variable_manager = VariableManager(loader=loader, inventory=inventory)
# variable_manager.extra_vars = {'ansible_user': '******', 'ansible_port': '5986', 'ansible_connection': 'local',
# 'ansible_password': '******'} # Here are the variables used in the playbook
passwords = dict(vault_pass='******')
# since API is constructed for CLI it expects certain options to always be set, named tuple 'fakes' the args parsing options object
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='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=None,
become_method=None,
become_user=None,
verbosity=None,
check=False,
diff=False)
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
results_callback = ResultCallback()
playbook_path = 'myplaybook.yml'
if not os.path.exists(playbook_path):
raise AnsibleFileNotFound("Playbook %s does not exist" % playbook_path)
pbex = PlaybookExecutor(playbooks=[playbook_path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
# Use our json callback instead of the ``default`` callback plugin, which prints to stdout
pbex._tqm._stdout_callback = results_callback
try:
results = pbex.run()
except AnsibleParserError as e:
raise AnsibleError(e)
# Return a json representation of the playbook run
return jsonify(
{'Playbook Results': [Task for Task in results_callback.results]})
# -*- coding: utf-8 -*-
#!/usr/bin/env python
__author__ = '*****@*****.**'
#核心类
from collections import namedtuple
from ansible.parsing.dataloader import DataLoader
from ansible.vars.manager import VariableManager
from ansible.inventory.manager import InventoryManager
from ansible.playbook.play import Play
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.plugins.callback import CallbackBase
#InventoryManager类
loader = DataLoader()
inventory = InventoryManager(loader=loader, sources=['imoocc_hosts'])
#VariableManager类
variable_manager = VariableManager(loader=loader, inventory=inventory)
#Options 执行选项
Options = namedtuple('Options', [
'connection', 'remote_user', 'ask_sudo_pass', 'verbosity', 'ack_pass',
'module_path', 'forks', 'become', 'become_method', 'become_user', 'check',
'listhosts', 'listtasks', 'listtags', 'syntax', 'sudo_user', 'sudo', 'diff'
])
options = Options(connection='smart',
remote_user=None,
ack_pass=None,
sudo_user=None,
forks=5,
sudo=None,
become_user=None,
check=False,
diff=False)
# initialize needed objects
loader = DataLoader(
) # Takes care of finding and reading yaml, json and ini files
# passwords = dict(vault_pass='******')
passwords = dict()
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
results_callback = ResultCallback()
# create inventory, use path to host config file as source or hosts in a comma separated string
sources = ['./hosts']
inventory = InventoryManager(loader=loader, sources=sources)
# inventory = InventoryManager(loader=loader)
# variable manager takes care of merging all the different sources to give you a unified view of variables available in each context
variable_manager = VariableManager(loader=loader, inventory=inventory)
# create data structure that represents our play, including tasks, this is basically what our YAML loader does internally.
databaseName = 'cgms_3'
play_source = dict(name="Create Unit Database",
hosts='192.168.163.160',
gather_facts='no',
tasks=[
dict(action=dict(module='mysql_db',
args=dict(login_host='192.168.163.160',
login_user='******',
login_password='******',
become_method=None,
become_user=None,
check=False,
diff=False,
remote_user='******')
# initialize needed objects
loader = DataLoader(
) # Takes care of finding and reading yaml, json and ini files
passwords = dict(vault_pass='******')
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
results_callback = ResultCallback()
# create inventory, use path to host config file as source or hosts in a comma separated string
inventory = InventoryManager(loader=loader, sources=['/tmp/hosts'])
#add_host = inventory.add_host(host='')
#print (inventory.get_host(hostname=''))
# variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context
variable_manager = VariableManager(loader=loader, inventory=inventory)
# create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally.
play_source = dict(
name="Ansible Play",
hosts='all',
gather_facts='no',
tasks=[
dict(action=dict(module='shell', args='data'),
register='shell_out',
name='ls'),
#dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')),name='debug')
def test_variable_manager_precedence(self):
# FIXME: this needs to be redone as dataloader is not the automatic source of data anymore
return
# pylint: disable=unreachable
'''
Tests complex variations and combinations of get_vars() with different
objects to modify the context under which variables are merged.
'''
# FIXME: BCS makethiswork
# return True
mock_inventory = MagicMock()
inventory1_filedata = """
[group2:children]
group1
[group1]
host1 host_var=host_var_from_inventory_host1
[group1:vars]
group_var = group_var_from_inventory_group1
[group2:vars]
group_var = group_var_from_inventory_group2
"""
fake_loader = DictDataLoader({
# inventory1
'/etc/ansible/inventory1':
inventory1_filedata,
# role defaults_only1
'/etc/ansible/roles/defaults_only1/defaults/main.yml':
"""
default_var: "default_var_from_defaults_only1"
host_var: "host_var_from_defaults_only1"
group_var: "group_var_from_defaults_only1"
group_var_all: "group_var_all_from_defaults_only1"
extra_var: "extra_var_from_defaults_only1"
""",
'/etc/ansible/roles/defaults_only1/tasks/main.yml':
"""
- debug: msg="here i am"
""",
# role defaults_only2
'/etc/ansible/roles/defaults_only2/defaults/main.yml':
"""
default_var: "default_var_from_defaults_only2"
host_var: "host_var_from_defaults_only2"
group_var: "group_var_from_defaults_only2"
group_var_all: "group_var_all_from_defaults_only2"
extra_var: "extra_var_from_defaults_only2"
""",
})
inv1 = InventoryManager(loader=fake_loader,
sources=['/etc/ansible/inventory1'])
v = VariableManager(inventory=mock_inventory, loader=fake_loader)
play1 = Play.load(dict(
hosts=['all'],
roles=['defaults_only1', 'defaults_only2'],
),
loader=fake_loader,
variable_manager=v)
# first we assert that the defaults as viewed as a whole are the merged results
# of the defaults from each role, with the last role defined "winning" when
# there is a variable naming conflict
res = v.get_vars(play=play1)
self.assertEqual(res['default_var'], 'default_var_from_defaults_only2')
# next, we assert that when vars are viewed from the context of a task within a
# role, that task will see its own role defaults before any other role's
blocks = play1.compile()
task = blocks[1].block[0]
res = v.get_vars(play=play1, task=task)
self.assertEqual(res['default_var'], 'default_var_from_defaults_only1')
# next we assert the precedence of inventory variables
v.set_inventory(inv1)
h1 = inv1.get_host('host1')
res = v.get_vars(play=play1, host=h1)
self.assertEqual(res['group_var'], 'group_var_from_inventory_group1')
self.assertEqual(res['host_var'], 'host_var_from_inventory_host1')
# next we test with group_vars/ files loaded
fake_loader.push(
"/etc/ansible/group_vars/all", """
group_var_all: group_var_all_from_group_vars_all
""")
fake_loader.push(
"/etc/ansible/group_vars/group1", """
group_var: group_var_from_group_vars_group1
""")
fake_loader.push(
"/etc/ansible/group_vars/group3", """
# this is a dummy, which should not be used anywhere
group_var: group_var_from_group_vars_group3
""")
fake_loader.push(
"/etc/ansible/host_vars/host1", """
host_var: host_var_from_host_vars_host1
""")
fake_loader.push(
"group_vars/group1", """
playbook_group_var: playbook_group_var
""")
fake_loader.push(
"host_vars/host1", """
playbook_host_var: playbook_host_var
""")
res = v.get_vars(play=play1, host=h1)
# self.assertEqual(res['group_var'], 'group_var_from_group_vars_group1')
# self.assertEqual(res['group_var_all'], 'group_var_all_from_group_vars_all')
# self.assertEqual(res['playbook_group_var'], 'playbook_group_var')
# self.assertEqual(res['host_var'], 'host_var_from_host_vars_host1')
# self.assertEqual(res['playbook_host_var'], 'playbook_host_var')
# add in the fact cache
v._fact_cache['host1'] = dict(
fact_cache_var="fact_cache_var_from_fact_cache")
res = v.get_vars(play=play1, host=h1)
self.assertEqual(res['fact_cache_var'],
'fact_cache_var_from_fact_cache')
def __init__(self, resource, loader, sources=None):
self.resource = resource
self.inventory = InventoryManager(loader=loader, sources=sources)
self.gen_inventory()
become=None,
become_method=None,
become_user=None,
check=False,
diff=False)
# initialize needed objects
loader = DataLoader(
) # Takes care of finding and reading yaml, json and ini files
passwords = dict(vault_pass='******')
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
results_callback = ResultCallback()
# create inventory, use path to host config file as source or hosts in a comma separated string
inventory = InventoryManager(loader=loader, sources=['192.168.77.154'])
# variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context
variable_manager = VariableManager(loader=loader, inventory=inventory)
# create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally.
play_source = dict(
name="Ansible Play",
hosts='localhost',
gather_facts='no',
tasks=[
dict(action=dict(module='shell', args='ls /root'),
register='shell_out'),
dict(action=dict(module='debug', args=dict(
msg='{{shell_out.stdout}}')))
])
def __init__(self,
playbook,
inventory,
run_data,
start_at_task,
step,
private_key_file,
become_pass,
verbosity=0):
self.run_data = run_data
self.options = Options()
self.options.listtags = False
self.options.listtasks = False
self.options.listhosts = False
self.options.syntax = False
self.options.check = False
self.options.diff = False
self.options.start_at_task = start_at_task
self.options.step = step
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 = False
self.options.become_method = 'sudo'
self.options.become_user = '******'
self.options.remote_user = '******'
# Set global verbosity
self.display = Display()
self.display.verbosity = self.options.verbosity
# Executor appears to have it's own
# verbosity object/setting as well
#playbook_executor.verbosity = self.options.verbosity
# Become Pass Needed if not logging in as user root
passwords = {'become_pass': become_pass}
# Gets data from YAML/JSON files
self.loader = DataLoader()
# self.loader.set_vault_password(os.environ['VAULT_PASS'])
# All the variables from all the various places
# Parse hosts, I haven't found a good way to
# pass hosts in without using a parsed template :(
# (Maybe you know how?)
# self.hosts = NamedTemporaryFile(delete=False)
# self.hosts.write("""[run_hosts]
# %s
# """ % hostnames)
# 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
inventory_dir = '/etc/ansible/inventory'
inventory_source = "%s/%s" % (inventory_dir, inventory)
self.inventory = InventoryManager(loader=self.loader,
sources=inventory_source)
self.variable_manager = VariableManager(loader=self.loader,
inventory=self.inventory)
if self.run_data:
self.variable_manager.extra_vars = self.run_data['extra_vars']
self.options.tags = self.run_data['tags']
# Playbook to run. Assumes it is
# local to this python file
pb_dir = '/etc/ansible/playbooks'
playbook = "%s/%s" % (pb_dir, playbook)
print(playbook)
# Setup playbook executor, but don't run until run() called
self.pbex = playbook_executor.PlaybookExecutor(
playbooks=[playbook],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.options.get_config(),
passwords=passwords)
def run_ansible(module_name, module_args, host_list, ansible_user="******"):
"""ansible api"""
# 负责查找和读取yaml、json和ini文件
loader = DataLoader()
# 初始化需要的对象
Options = namedtuple('Options', [
'connection', 'module_path', 'forks', 'become', 'become_method',
'private_key_file', 'become_user', 'remote_user', 'check', 'diff'
])
options = Options(connection='ssh',
module_path=None,
forks=5,
become=True,
become_method='sudo',
private_key_file="/root/.ssh/id_rsa",
become_user='******',
remote_user=ansible_user,
check=False,
diff=False)
passwords = dict(vault_pass='******')
# 实例化ResultCallback来处理结果
callback = ResultsCollector()
# 创建库存(inventory)并传递给VariableManager
inventory = InventoryManager(loader=loader, sources=['/etc/ansible/hosts'])
# 管理变量的类，包括主机，组，扩展等变量
variable_manager = VariableManager(loader=loader, inventory=inventory)
# 创建任务
host = ",".join(host_list)
play_source = dict(name="Ansible Play",
hosts=host,
gather_facts='no',
tasks=[
dict(action=dict(module=module_name,
args=module_args),
register='shell_out'),
])
play = Play().load(play_source,
variable_manager=variable_manager,
loader=loader)
# 开始执行
tqm = None
tqm = TaskQueueManager(
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords,
stdout_callback=callback,
)
result = tqm.run(play)
result_raw = {'success': {}, 'failed': {}, 'unreachable': {}}
for host, result in callback.host_ok.items():
result_raw['success'][host] = result._result
for host, result in callback.host_failed.items():
result_raw['failed'][host] = result._result
for host, result in callback.host_unreachable.items():
result_raw['unreachable'][host] = result._result
for host, result in callback.host_skipped.items():
result_raw['skipped'][host] = result._result
return json.dumps(result_raw, indent=4, ensure_ascii=False)
def __init__(self, filename):
self._loader = DataLoader()
self._inventory = InventoryManager(loader=self._loader,
sources=filename)
def __init__(self,
connection='ssh',
remote_user="******",
ack_pass=None,
sudo=None,
sudo_user=None,
ask_sudo_pass=None,
module_path=None,
become=None,
become_method=None,
become_user=None,
check=False,
diff=False,
listhosts=None,
listtasks=None,
listtags=None,
forks=5,
tags=[],
skip_tags=[],
verbosity=3,
syntax=None,
start_at_task=None,
inventory=None,
passwords=None):
"""初始化"""
context.CLIARGS = ImmutableDict(
connection=connection,
remote_user=remote_user,
ack_pass=ack_pass,
sudo=sudo,
sudo_user=sudo_user,
ask_sudo_pass=ask_sudo_pass,
module_path=module_path,
become=become,
become_method=become_method,
become_user=become_user,
verbosity=verbosity,
listhosts=listhosts,
listtasks=listtasks,
listtags=listtags,
forks=forks,
tags=tags,
skip_tags=skip_tags,
syntax=syntax,
start_at_task=start_at_task,
)
# inventory 文件
self.inventory = inventory if inventory else "localhost,"
# 实例化数据解析器,用于解析 存放主机列表的资源库文件
self.loader = DataLoader()
# 实例化 资产配置对象,InventoryManager管理资源库
self.inv_obj = InventoryManager(loader=self.loader,
sources=self.inventory)
# 设置密码，可以为空字典
self.passwords = {"conn_pass": passwords}
# 实例化回调插件对象
self.results_callback = ResultCallback()
# 变量管理器,假如有变量，所有的变量应该交给他管理。 这里他会从 inventory 对象中获取到所有已定义好的变量。 这里也需要数据解析器。
self.variable_manager = VariableManager(self.loader, self.inv_obj)
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=20,
check=False)
loader = DataLoader()
passwords = dict(vault_pass='******')
inventory = InventoryManager(loader=loader, sources='/etc/ansible/hosts')
variable_manager = VariableManager(loader=loader, inventory=inventory)
play_source = dict(
name='Ansible Play',
hosts='pool',
gather_facts='no',
tasks=[
dict(action=dict(module='shell', args='systemctl status indy-node'),
register='shell_out'),
dict(action=dict(module='debug', args=dict(
msg='{{shell_out.stdout}}')))
])
play = Play().load(play_source,
def run_playbook(playbook, host_list, vars):
# https://github.com/celery/billiard/issues/189
# https://github.com/Mirantis/kostyor-openstack-ansible/commit/407ec033514600cd62f4931f199efd13405b0aae
import multiprocessing
import billiard
multiprocessing.Process = billiard.Process
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'
])
loader = DataLoader()
variable_manager = VariableManager(loader=loader)
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=False,
become_method='sudo',
become_user='******',
verbosity=None,
check=False,
diff=False)
passwords = {}
inventory = InventoryManager(loader=loader)
inventory.add_group('ci')
inventory.add_host(host_list.values()[0], 'ci')
inventory.reconcile_inventory()
variable_manager.set_inventory(inventory)
variable_manager.extra_vars = vars
playbook_path = playbook
constants.HOST_KEY_CHECKING = False
pbex = PlaybookExecutor(playbooks=[playbook_path],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords)
results = pbex.run()
pubkey = None
try:
pubkey = variable_manager._nonpersistent_fact_cache[
host_list['ci']]['pubkey']['stdout']
except KeyError:
pass
return results, pubkey
class ResultCallback(CallbackBase):
def v2_runner_on_ok(self, result, **kwargs):
print(json.dumps({result._host.name: result._result}))
if __name__ == '__main__':
Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff'])
options = Options(connection='smart', module_path=[], forks=6, become=None, become_method=None, become_user=None, check=False, diff=False)
loader = DataLoader()
passwords = {}
callback = ResultCallback()
inventory = InventoryManager(loader=loader, sources='hosts.py')
variable_manager = VariableManager(loader=loader, inventory=inventory)
source = {
'hosts' : 'mytest',
'gather_facts' : 'False',
'tasks' : [
{
'name' : 'shell',
'shell' : 'ls /',
'register' : 'result',
},
{
'debug' : {
'msg' : ' {{ result.stdout }}',
def _get_inventory(self, inventory_content):
fake_loader = DictDataLoader({__file__: inventory_content})
return InventoryManager(loader=fake_loader, sources=[__file__])
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.plugins.callback import CallbackBase
from ansible import context
from ansible.module_utils.common.collections import ImmutableDict
###############################
# InventoryManager 类
###############################
# 读取资产清单信息
loader = DataLoader()
"""
sources 可以是绝对和相对路径
"""
inventory_manager = InventoryManager(loader=loader, sources=['my_hots.txt'])
###############################
# VariableManager 类
###############################
variable_manager = VariableManager(loader=loader, inventory=inventory_manager)
# 方法2
context.CLIARGS = ImmutableDict(connection='smart',
module_path=None,
verbosity=5,
forks=10,
become=None,
become_method=None,
become_user=None,
check=False,
def setUp(self):
fake_loader = DictDataLoader({})
self.i = InventoryManager(loader=fake_loader, sources=[None])
def _run_ansible(self, args):
"""Actually build an run an ansible play and return the results"""
zclass = args.pop('zbx_class')
# The leadup to the TaskQueueManager() call below is
# copy pasted from Ansible's example:
# https://docs.ansible.com/ansible/developing_api.html#python-api-2-0
# pylint: disable=invalid-name
Options = namedtuple('Options', [
'connection', 'module_path', 'forks', 'become', 'become_method',
'become_user', 'check', 'diff'
])
loader = DataLoader()
options = Options(connection='local',
module_path=None,
forks=1,
become=None,
become_method=None,
become_user=None,
check=False,
diff=False)
passwords = dict(vault_pass='******')
results_callback = ResultsCallback()
inventory = InventoryManager(loader=loader)
variable_manager = VariableManager(loader=loader, inventory=inventory)
play_source = dict(name="Ansible Play",
hosts=self.pattern,
gather_facts='no',
tasks=[
dict(action=dict(module=zclass, args=args)),
])
play = Play().load(play_source,
variable_manager=variable_manager,
loader=loader)
tqm = None
try:
tqm = TaskQueueManager(inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords=passwords,
stdout_callback=results_callback)
return_code = tqm.run(play)
finally:
if tqm is not None:
tqm.cleanup()
# Remove ansible tmpdir
shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
if return_code != 0:
raise ResultsException(
"Ansible module run failed, no results given.")
if results_callback.result.is_unreachable():
message = "Ansible module run failed: module output:\n%s" % \
json.dumps(results_callback.raw_result, indent=4)
raise ResultsException(message)
if results_callback.result.is_failed():
raise ResultsException(results_callback.raw_result)
return results_callback.raw_result
'private_key_file',
'ssh_common_args',
'ssh_extra_args',
'sftp_extra_args',
'scp_extra_args',
'become',
'become_method',
'become_user',
'verbosity',
'check',
'diff'
])
loader = DataLoader()
hosts_path = InventoryManager(loader=loader, sources="/etc/ansible/hosts")
variable_manager = VariableManager(loader=loader, inventory=hosts_path)
inventory=hosts_path
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,
become_method=None,
become_user=None,
check=False,
diff=False)
# initialize needed objects
loader = DataLoader(
) # Takes care of finding and reading yaml, json and ini files
passwords = dict()
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
# results_callback = ResultCallback()
# create inventory, use path to host config file as source or hosts in a comma separated string
# inventory = InventoryManager(loader=loader, sources='localhost,')
inventory = InventoryManager(loader=loader, sources=['/root/myansi/hosts'])
# variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context
variable_manager = VariableManager(loader=loader, inventory=inventory)
# create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally.
play_source = dict(
name="Ansible Play",
hosts='webservers',
gather_facts='no',
tasks=[
# dict(action=dict(module='shell', args='ls'), register='shell_out'),
dict(action=dict(module='yum', args='name=vsftpd state=latest'),
register='shell_out'),
# dict(action=dict(module='shell', args='id zhangsan'), register='shell_out'),
# dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}')))
def __init__(self, playbook, hosts=None,subset=None,tags=None):
print "First tags is: %s" %tags
if tags is None:
tags='all'
self.Options = namedtuple('Options',
['connection',
'remote_user',
'ask_sudo_pass',
'verbosity',
'ack_pass',
'module_path',
'forks',
'become',
'become_method',
'become_user',
'check',
'listhosts',
'listtasks',
'listtags',
'syntax',
'sudo_user',
'sudo',
'diff',
'subset',
'tags'])
self.ops = self.Options(connection='smart',
remote_user=None,
ack_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,
subset=[subset],
tags=[tags])
self.loader = DataLoader()
self.passwords = dict()
self.results_callback = ResultCallback()
self.inventory = InventoryManager(loader=self.loader, sources=[hosts])
if self.ops.subset != [None]:
self.inventory.subset(self.ops.subset)
self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory)
print "Tags is %s:"%self.ops.tags
# setup playbook executor, but don't run until run() called
self.pbex = PlaybookExecutor(
playbooks=[playbook],
inventory=self.inventory,
variable_manager=self.variable_manager,
loader=self.loader,
options=self.ops,
passwords=self.passwords)