def run_installer(user_list, package_list, sudo_password):
"""
Runs the playbook `installer.yml` with the supplied parameters
"""
# Create the inventory
controller = Host(name="localhost")
controller.set_variable('users', user_list)
controller.set_variable('apt_packages', package_list)
local_inventory = Inventory([])
local_inventory.get_group('all').add_host(controller)
# Boilerplate for callbacks setup
utils.VERBOSITY = 0
# Output callbacks setup
output_callbacks = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
# API callbacks setup
stats = callbacks.AggregateStats()
api_callbacks = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
provision_playbook = PlayBook(playbook="installer.yml",
stats=stats,
callbacks=output_callbacks,
runner_callbacks=api_callbacks,
inventory=local_inventory,
transport="local",
become_pass=sudo_password)
playbook_result = provision_playbook.run()
return playbook_result
def setup_create_playbook(playbook, hosts, private_key, only_tags):
inventory = ansible.inventory.Inventory(hosts)
#playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
stats = callbacks.AggregateStats()
# runner_cb = callbacks.PlaybookRunnerCallbacks(
# stats, verbose=utils.VERBOSITY)
head, tail = os.path.split(playbook)
deployment_name = tail.rsplit(".")[0]
cb = CallbackModule(deployment_name)
if private_key:
pb = ansible.playbook.PlayBook(playbook=playbook,
inventory=inventory,
callbacks=cb,
runner_callbacks=cb,
stats=stats,
private_key_file=private_key,
only_tags=only_tags)
else:
pb = ansible.playbook.PlayBook(playbook=playbook,
inventory=inventory,
callbacks=cb,
runner_callbacks=cb,
stats=stats,
only_tags=only_tags)
return pb
def run_ansible_in_python(task):
stats = callbacks.AggregateStats()
## everything between this comment
## and the "end" should hopefully not be necessary
## after Ansible 1.4.6 or 1.5 is released, since there
## will be an implicit sys.executable interpreter for the localhost
## host. This will almost certainly need tweaking anyway for dynamic inventory
## in ec2. I'm not sure yet how this would work.
localhost = Host('localhost')
localhost.set_variable('ansible_python_interpreter', sys.executable)
all_group = Group('all')
all_group.add_host(localhost)
inventory = Inventory(None)
inventory.add_group(all_group)
os.putenv('EC2_INI_PATH', 'lib/glue/ec2-external.ini')
ec2_inventory = InventoryScript(filename='lib/glue/ec2.py')
inventory.parser = ec2_inventory
[inventory.add_group(group) for group in ec2_inventory.groups.values()]
## end
pb = playbook.PlayBook(playbook=task.inputs[0].abspath(),
inventory=inventory,
stats=stats,
callbacks=callbacks.PlaybookCallbacks(verbose=3),
runner_callbacks=callbacks.PlaybookRunnerCallbacks(stats, verbose=3)
)
pb.run()
def setup_create_playbook(playbook, hosts, private_key, only_tags):
try:
import ansible.playbook
import ansible.inventory
from ansible import callbacks
except ImportError:
current.log.error("ansible module needed for Setup")
inventory = ansible.inventory.Inventory(hosts)
#playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
stats = callbacks.AggregateStats()
# runner_cb = callbacks.PlaybookRunnerCallbacks(
# stats, verbose=utils.VERBOSITY)
head, tail = os.path.split(playbook)
deployment_name = tail.rsplit(".")[0]
cb = CallbackModule(deployment_name)
pb = ansible.playbook.PlayBook(playbook = playbook,
inventory = inventory,
callbacks = cb,
runner_callbacks = cb,
stats = stats,
private_key_file = private_key,
only_tags = only_tags
)
return pb
def run(self):
stats = callbacks.AggregateStats()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
pb = ansible.playbook.PlayBook(playbook=self.tmp,
inventory=self.conf["inventory"],
remote_user=self.conf["remote_user"],
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats)
pb.run()
hosts = sorted(pb.stats.processed.keys())
display(callbacks.banner("‽"))
for h in hosts:
t = pb.stats.summarize(h)
display("%s : %s %s %s %s" % (
h,
t['ok'],
t['changed'],
t['unreachable'],
t['failures'],
),
screen_only=True)
def test_playbook_hash_merge(self):
# save default hash behavior so we can restore it in the end of the test
saved_hash_behavior = C.DEFAULT_HASH_BEHAVIOUR
C.DEFAULT_HASH_BEHAVIOUR = "merge"
test_callbacks = TestCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=os.path.join(self.test_dir, 'test_hash_behavior',
'playbook.yml'),
host_list='test/ansible_hosts',
stats=ans_callbacks.AggregateStats(),
callbacks=test_callbacks,
runner_callbacks=test_callbacks)
playbook.run()
with open('/tmp/ansible_test_messages.out') as f:
actual = [l.strip() for l in f.readlines()]
print "**ACTUAL**"
print actual
expected = ["hello: Hello World!", "goodbye: Goodbye World!"]
print "**EXPECTED**"
print expected
assert actual == expected
# restore default hash behavior
C.DEFAULT_HASH_BEHAVIOUR = saved_hash_behavior
def install_stuff(ip_list, sshpass, req_list):
task_id = str(install_stuff.request.id)
db.write_in_progress(req_list, ip_list, task_id)
pb_name = helper.write_playbook(req_list)
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
stats = callbacks.AggregateStats()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
pb = PlayBook(
remote_user='******',
remote_pass=sshpass,
playbook=pb_name,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats,
host_list=ip_list,
)
results = pb.run()
if results[ip_list[:-1]]['unreachable'] != 0:
os.remove(pb_name)
db.del_in_progress(task_id)
raise RuntimeError('df//' + ip_list[:-1] + '//' + '1' + '//fd')
if results[ip_list[:-1]]['failures'] != 0:
os.remove(pb_name)
db.del_in_progress(task_id)
raise RuntimeError('df//' + ip_list[:-1] + '//' + '1' + '//fd')
os.remove(pb_name)
db.del_in_progress(task_id)
ans = '//' + ip_list[:-1] + '//0//'
return ans
def run_playbook(self,
playbook,
host_list=None,
use_sudo=True,
local=False,
extra_vars={},
ans_remote_user=AnsibleConstants.DEFAULT_REMOTE_USER,
ans_remote_pass=AnsibleConstants.DEFAULT_REMOTE_PASS,
only_tags=None,
skip_tags=None):
"""Runs an ansible playbook
From ansible doc:
lib/ansible/__init__.py
playbook: path to a playbook file
host_list: path to a file like /etc/ansible/hosts
module_path: path to ansible modules, like /usr/share/ansible/
forks: desired level of paralellism
timeout: connection timeout
remote_user: run as this user if not specified in a particular play
remote_pass: use this remote password (for all plays) vs using SSH keys
sudo_pass: if sudo==True, and a password is required, this is the sudo password
remote_port: default remote port to use if not specified with the host or play
transport: how to connect to hosts that don't specify a transport (local, paramiko, etc)
callbacks output callbacks for the playbook
runner_callbacks: more callbacks, this time for the runner API
stats: holds aggregate data about events occuring to each host
sudo: if not specified per play, requests all plays use sudo mode
inventory: can be specified instead of host_list to use a pre-existing inventory object
check: don't change anything, just try to detect some potential changes
only_tags: List of tags to include. Only run task of tasks in the include list.
skip_tags: List of tags to skip. Run all task but tagged in the skip list.
"""
use_transport = AnsibleConstants.DEFAULT_TRANSPORT
if local:
use_transport = "local"
host_list = []
host_list.append("127.0.0.1")
playbook = ansible.playbook.PlayBook(
playbook=playbook,
host_list=host_list if host_list != [] else self.__host_list,
stats=ans_callbacks.AggregateStats(),
callbacks=self.callbacks,
runner_callbacks=self.callbacks,
transport=use_transport,
sudo=use_sudo,
extra_vars=extra_vars,
remote_user=ans_remote_user,
remote_pass=ans_remote_pass,
only_tags=only_tags,
skip_tags=skip_tags)
playbook.SETUP_CACHE.clear()
result = playbook.run()
# The result is a dict. I'm going to add
# The "alienvault" key with our "internal"
# values
result['alienvault'] = {'lasterror': self.callbacks.lasterror}
return result
def adduser(ips, users):
inventory = """
{% for i in hosts -%}
{{ i }}
{% endfor %}
"""
inventory_template = jinja2.Template(inventory)
rendered_inventory = inventory_template.render({'hosts': ips})
hosts = NamedTemporaryFile(delete=False, suffix='tmp', dir='/tmp/ansible/')
hosts.write(rendered_inventory)
hosts.close()
inventory = Inventory(hosts.name)
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats)
vars = {}
vars['users'] = users
results = PlayBook(playbook='user.yaml',
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats,
inventory=inventory,
extra_vars=vars)
res = results.run()
logs = []
logs.append("finish playbook\n")
logs.append(str(res))
return logs
def runPlayBook(path):
stats = callbacks.AggregateStats()
inven = Inventory(host_list=path["hosts"]);
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)
pb = PlayBook(inventory=inven,playbook=path["playbook"],stats=stats,callbacks=playbook_cb,runner_callbacks=runner_cb,)
pb.run()
def run(validation, cancel_event):
C.HOST_KEY_CHECKING = False
stats = callbacks.AggregateStats()
playbook_callbacks = SilentPlaybookCallbacks(cancel_event)
runner_callbacks = callbacks.DefaultRunnerCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=validation['playbook'],
host_list='tripleo-ansible-inventory.py',
stats=stats,
callbacks=playbook_callbacks,
runner_callbacks=runner_callbacks)
try:
result = playbook.run()
except ValidationCancelled:
result = {}
for host in playbook.inventory.list_hosts():
result[host] = {
'failures': 1,
'unreachable': 0,
'description': "Validation was cancelled.",
}
for host, status in result.items():
success = status['failures'] == 0 and status['unreachable'] == 0
result[host]['success'] = success
return result
def prepare(self):
if self.status == "Not playable":
raise RuntimeError("Not allowed to play %s" % self.name)
self.current_task = 0
self.tasks = []
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
stats = callbacks.AggregateStats()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
pb = ansible.playbook.PlayBook(playbook=self.path,
inventory=ansible.inventory.Inventory(
self.inventory_file),
remote_user=self.ssh_user,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats,
sudo="1",
extra_vars={"env": self.env})
for (play_ds, play_basedir) in zip(pb.playbook, pb.play_basedirs):
play = ansible.playbook.Play(pb,
play_ds,
play_basedir,
vault_password=pb.vault_password)
label = play.name
for task in play.tasks():
if (set(task.tags).intersection(pb.only_tags)
and not set(task.tags).intersection(pb.skip_tags)):
if getattr(task, 'name', None) is not None:
self.tasks.append(task.name)
self.status = "Not played"
self.priority = self.depPriority + len(self.tasks)
def ansible_book(db, pb, args):
playbook_cp = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
stats = callbacks.AggregateStats()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
playbook = PlayBook(playbook=pb,
extra_vars=args,
callbacks=playbook_cp,
stats=stats,
runner_callbacks=runner_cb,
inventory=autils.get_inventory(db))
try:
results = playbook.run()
except:
logger.error(traceback.format_exc())
results = {
'error': {
'unreachable': 0,
'skipped': 0,
'ok': 0,
'changed': 0,
'failures': 1
}
}
return results
def _run(self,
test_playbook,
host_list='test/ansible_hosts',
extra_vars=None):
''' run a module and get the localhost results '''
# This ensures tests are independent of eachother
global EVENTS
ansible.playbook.SETUP_CACHE.clear()
EVENTS = []
self.test_callbacks = TestCallbacks()
self.playbook = ansible.playbook.PlayBook(
playbook=test_playbook,
host_list=host_list,
module_path='library/',
forks=1,
timeout=5,
remote_user=self.user,
remote_pass=None,
extra_vars=extra_vars,
stats=ans_callbacks.AggregateStats(),
callbacks=self.test_callbacks,
runner_callbacks=self.test_callbacks)
result = self.playbook.run()
return result
def _test_playbook_undefined_vars(self, playbook, fail_on_undefined):
# save DEFAULT_UNDEFINED_VAR_BEHAVIOR so we can restore it in the end of the test
saved_undefined_var_behavior = C.DEFAULT_UNDEFINED_VAR_BEHAVIOR
C.DEFAULT_UNDEFINED_VAR_BEHAVIOR = fail_on_undefined
test_callbacks = TestCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=os.path.join(self.test_dir,
'test_playbook_undefined_vars', playbook),
host_list='test/test_playbook_undefined_vars/hosts',
stats=ans_callbacks.AggregateStats(),
callbacks=test_callbacks,
runner_callbacks=test_callbacks)
actual = playbook.run()
C.DEFAULT_UNDEFINED_VAR_BEHAVIOR = saved_undefined_var_behavior
# if different, this will output to screen
print "**ACTUAL**"
print utils.jsonify(actual, format=True)
expected = {
"localhost": {
"changed": 0,
"failures": 0,
"ok": int(not fail_on_undefined) + 1,
"skipped": 0,
"unreachable": int(fail_on_undefined)
}
}
print "**EXPECTED**"
print utils.jsonify(expected, format=True)
assert utils.jsonify(expected,
format=True) == utils.jsonify(actual, format=True)
def test_playbook_always_run(self):
test_callbacks = TestCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=os.path.join(self.test_dir, 'playbook-always-run.yml'),
host_list='test/ansible_hosts',
stats=ans_callbacks.AggregateStats(),
callbacks=test_callbacks,
runner_callbacks=test_callbacks,
check=True)
actual = playbook.run()
# if different, this will output to screen
print "**ACTUAL**"
print utils.jsonify(actual, format=True)
expected = {
"localhost": {
"changed": 4,
"failures": 0,
"ok": 4,
"skipped": 8,
"unreachable": 0
}
}
print "**EXPECTED**"
print utils.jsonify(expected, format=True)
assert utils.jsonify(expected,
format=True) == utils.jsonify(actual, format=True)
def _setup(cls, playbook, inventory, stats, callbacks, runner_callbacks,
host_list, limit):
"""
Setup dependencies for the Ansible PlayBook and return them
in a namedtuple.
"""
deps = collections.namedtuple("Dependencies", [
"playbook", "inventory", "stats", "callbacks", "runner_callbacks"
])
deps.playbook = playbook
if stats is None:
deps.stats = ansible_callbacks.AggregateStats()
else:
deps.stats = stats
if callbacks is None:
deps.callbacks = ansible_callbacks.PlaybookCallbacks(
verbose=utils.VERBOSITY)
else:
deps.callbacks = callbacks
if runner_callbacks is None:
deps.runner_callbacks = ansible_callbacks.PlaybookRunnerCallbacks(
stats, verbose=utils.VERBOSITY)
else:
deps.runner_callbacks = runner_callbacks
if inventory is None:
deps.inventory = ansible.inventory.Inventory(host_list=host_list)
if limit:
PlayBook._setup_inventory_limit(deps.inventory, limit)
else:
deps.inventory = inventory
return deps
def playbook():
inventory = """
[initial]
{% for i in hosts %}
{{ i }}
{% endfor %}
"""
inventory_template = jinja2.Template(inventory)
data = json.loads(request.get_data())
inst_ip = data["ips"]
rendered_inventory = inventory_template.render({'hosts': inst_ip})
hosts = NamedTemporaryFile(delete=False, suffix='tmp', dir='/tmp/ansible/')
hosts.write(rendered_inventory)
hosts.close()
'''
前端传递过来的Json数据，在Flask里面用了jinja2渲染成Ansible能识别的格式，并以临时文件的形式存在于/tmp/ansible/目录下
/tmp/ansible/目录可以提前建立
'''
inventory = Inventory(hosts.name)
vars = {}
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats)
pb = PlayBook(playbook='/root/ansible/mytest.yml', callbacks=playbook_cb, runner_callbacks=runner_cb, stats=stats,
inventory=inventory, extra_vars=vars)
job = q.enqueue_call(pb.run, result_ttl=5000, timeout=2000)
jid = job.get_id()
if jid:
app.logger.info("Job Succesfully Queued with JobID: %s" % jid)
else:
app.logger.error("Failed to Queue the Job")
return jid
def playbook_run(self, message, args):
"""Run a playbook"""
if isinstance(args, str) or isinstance(args, unicode):
arg = args
elif isinstance(args, list):
arg = args[0]
else:
message.error('参数类型错误')
return
message.send('Starting to execute playbook: {}'.format(arg))
pb_dict = self.all_playbooks[arg]
stats = callbacks.AggregateStats(),
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
if pb_dict['hosts']:
pb = playbook.PlayBook(
playbook=pb_dict['path'],
host_list=pb_dict['hosts'],
stats=stats,
callbacks=callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY),
runner_callbacks=runner_cb)
else:
pb = playbook.PlayBook(playbook=pb_dict['path'],
inventory=common.inventory)
results = pb.run()
return results
def run_playbook(
remote_user=None,
remote_pass=None,
inventory=None,
playbook_uri=None,
extra_vars=None,
only_tags=None,
playbook_args='',
):
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
if os.path.isfile(playbook_uri):
return PlayBook(
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats,
playbook=playbook_uri,
remote_user=remote_user,
remote_pass=remote_pass,
inventory=inventory,
extra_vars=extra_vars,
only_tags=only_tags,
).run()
else:
print '"{}" is an invalid file.'.format(playbook_uri)
def RunRecepie(inventory, playbook_file):
"""
Run playbook
:param hosts:
:return:
"""
# Boilerplace callbacks for stdout/stderr and log output
utils.VERBOSITY = 0
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
stats = callbacks.AggregateStats()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)
pb = PlayBook(
playbook=playbook_file,
inventory=inventory,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats,
)
results = pb.run()
# Ensure on_stats callback is called
# for callback modules
playbook_cb.on_stats(pb.stats)
return results
def prepare_runner(self,
_playbook_path,
options={},
tasks=None,
_extra_vars={},
verbosity=3):
_OPTIONS = self.__prepare_runner_metadata(options, tasks)
_vb = _OPTIONS['verbosity']
_inventory = inventory.Inventory(self.HOSTS_INI_FILE)
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=_vb)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=_vb)
runner = playbook.PlayBook(
playbook=_playbook_path,
inventory=_inventory,
extra_vars=_extra_vars,
private_key_file=self.PRIVATE_KEY,
#vault_password=vaultpass,
only_tags=tasks,
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb)
return runner
def test_playbook_hash_merge(self):
# save default hash behavior so we can restore it in the end of the test
saved_hash_behavior = C.DEFAULT_HASH_BEHAVIOUR
C.DEFAULT_HASH_BEHAVIOUR = "merge"
test_callbacks = TestCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=os.path.join(self.test_dir, 'test_hash_behavior',
'playbook.yml'),
host_list='test/ansible_hosts',
stats=ans_callbacks.AggregateStats(),
callbacks=test_callbacks,
runner_callbacks=test_callbacks)
playbook.run()
filename = '/tmp/ansible_test_messages.out'
expected_lines = ["goodbye: Goodbye World!", "hello: Hello World!"]
self._compare_file_output(filename, expected_lines)
filename = '/tmp/ansible_test_role_messages.out'
expected_lines = [
"goodbye: Goodbye World!", "hello: Hello World!",
"inside_a_role: Indeed!"
]
self._compare_file_output(filename, expected_lines)
# restore default hash behavior
C.DEFAULT_HASH_BEHAVIOUR = saved_hash_behavior
def aws(phase):
#parse args
with open("keys/rootkey.csv", "r") as keyfile:
lines = keyfile.readlines()
aws_access_key = lines[0].split('=')[1].strip(' ').rstrip()
aws_secret_key = lines[1].split('=')[1].strip(' ').rstrip()
os.environ['AWS_ACCESS_KEY_ID'] = aws_access_key
os.environ['AWS_SECRET_ACCESS_KEY'] = aws_secret_key
d = deployment()
red = redis.StrictRedis(host='localhost', port=6379, db=0)
if phase == 0:
print "Clean up stale reservations...*****************\n"
d.destroy_aws_instance()
if phase == 1:
d.create_aws_instance()
d.create_aws_instance()
print "\nCheck AWS instance status...******************"
aws_ip = d.get_aws_reservation()
while aws_ip == None or len(aws_ip) < 2:
print "AWS Instance not ready, retry after 30 sec"
time.sleep(30)
aws_ip = d.get_aws_reservation()
canary = aws_ip[0]
production = aws_ip[1]
print "AWS Canary Instance =" + canary
print "AWS Production Instance =" + production
print "Update Redis"
red.set('canary', "http://" + canary + ":3000")
red.set('production', "http://" + production + ":3000")
red.set('production0', "http://" + production + ":3000")
red.set('instances', 1)
print red.get('canary')
print red.get('production')
print "\nWriting Inventory...**************************"
aws_inv_can = "canary ansible_ssh_host=" + canary + " ansible_ssh_user=ubuntu ansible_ssh_private_key_file=./keys/devops.pem\n"
with open("inventory_canary", "w") as f:
f.write(aws_inv_can)
aws_inv_prod = "production ansible_ssh_host=" + production + " ansible_ssh_user=ubuntu ansible_ssh_private_key_file=./keys/devops.pem\n"
with open("inventory_production", "w") as f:
f.write(aws_inv_prod)
with open("inventory", "w") as f:
f.write(aws_inv_can + "\n")
f.write(aws_inv_prod)
if phase == 2:
os.environ['ANSIBLE_HOST_KEY_CHECKING'] = "false"
utils.VERBOSITY = 0
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
stats = callbacks.AggregateStats()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
inventory = Inventory('inventory')
print "\nRun Ansible PlayBook...**********************"
pb = PlayBook(playbook='server_play.yml',
inventory=inventory,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats)
pb.run()
def __init__(self, tool):
threading.Thread.__init__(self)
self._exit = False
self._tool = tool
self._ansible_stats = callbacks.AggregateStats()
self._ansible_playbook_cb = LoggingCallbacks(verbose=3)
self._ansible_runner_cb = LoggingRunnerCallbacks(self._ansible_stats, verbose=3)
self._endpoint_db = {}
for policy in self._tool.config.epg_policies:
self._endpoint_db[(policy.tenant, policy.app, policy.name)] = []
def test_playbook_vars(self):
test_callbacks = TestCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=os.path.join(self.test_dir, 'test_playbook_vars',
'playbook.yml'),
host_list='test/test_playbook_vars/hosts',
stats=ans_callbacks.AggregateStats(),
callbacks=test_callbacks,
runner_callbacks=test_callbacks)
playbook.run()
def exec_playbook(cmd):
# Hosts where execute commands
example_host1 = ansible.inventory.host.Host(name="ansible01.ad.jadbp.lab")
example_host2 = ansible.inventory.host.Host(name="ansible02.ad.jadbp.lab")
# Setting variables
example_host1.set_variable('cmd', cmd)
example_host2.set_variable('cmd', cmd)
# ANSIBLE_SSH_ARGS??? como variable??
# Setting remote user (in ansible 2.0 ssh_user must be used)
example_host1.set_variable('ansible_ssh_user', 'jadebustos')
example_host2.set_variable('ansible_ssh_user', 'jadebustos')
# Setting hosts group
task_group = ansible.inventory.group.Group(name="test")
# Hosts added to group
task_group.add_host(example_host1)
task_group.add_host(example_host2)
# Inventory
task_inventory = ansible.inventory.Inventory()
task_inventory.add_group(task_group)
task_inventory.subset('test')
# Callbacks
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
# Playbook
# https://github.com/ansible/ansible/blob/release1.8.4/lib/ansible/playbook/__init__.py#L42-L84
try:
pb = ansible.playbook.PlayBook(playbook="ansible-template.yml",
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
inventory=task_inventory,
check=True)
pr = pb.run()
except:
print traceback.format_exc()
# Another way to get information
# hosts = sorted(pb.stats.processed.keys())
# for h in hosts:
# print ', '.join(pb.stats.summarize(h).keys())
return pr
def __call__(self):
playbook = os.path.join(self._basedir, self.playbook)
ansible_conf = get_ansible_conf()
remote_user = ansible_conf['remote_user']
remote_pass = ansible_conf['remote_pass']
private_key_file = None
if ansible_conf.has_key('private_key_file'):
private_key_file = ansible_conf['private_key_file']
host = self.parameter[0]
port = self.parameter[1]
max_memory = self.parameter[2]
max_connection = self.parameter[3]
is_bind = self.parameter[4]
print self.parameter
if is_bind == u"1":
bind_ipaddress = host
else:
bind_ipaddress = '0.0.0.0'
temp_conf = os.path.join(self._basedir, 'mcadmin/memcached.conf.temp')
dest_conf = os.path.join('/data/services/memcached/conf/memcached_' + str(port) + '.conf')
extra_vars = {"temp_conf":temp_conf, "dest_conf":dest_conf, "port":port, "max_memory":max_memory,
"max_connection":max_connection, "bind_ipaddress":bind_ipaddress}
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,verbose=utils.VERBOSITY)
if not private_key_file:
res=ansible.playbook.PlayBook(
inventory=Inventory([host]),
playbook=playbook,
remote_user=remote_user,
remote_pass=remote_pass,
extra_vars=extra_vars,
stats=stats,
sudo=True,
sudo_user='******',
sudo_pass=remote_pass,
callbacks=playbook_cb,
runner_callbacks=runner_cb
).run()
else:
res=ansible.playbook.PlayBook(
inventory=Inventory([host]),
playbook=playbook,
remote_user=remote_user,
remote_pass=remote_pass,
private_key_file=private_key_file,
extra_vars=extra_vars,
stats=stats,
sudo=True,
sudo_user='******',
sudo_pass=remote_pass,
callbacks=playbook_cb,
runner_callbacks=runner_cb
).run()
return res
def test_playbook_vars(self):
test_callbacks = TestCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=os.path.join(self.test_dir, 'test_playbook_vars',
'playbook.yml'),
host_list='test/test_playbook_vars/hosts',
stats=ans_callbacks.AggregateStats(),
callbacks=test_callbacks,
runner_callbacks=test_callbacks)
playbook.run()
assert playbook.SETUP_CACHE['host1'] == {'attr2': 2, 'attr1': 1}
assert playbook.SETUP_CACHE['host2'] == {'attr2': 2}
def test_yaml_hosts_list(self):
# Make sure playbooks support hosts: [host1, host2]
# TODO: Actually run the play on more than one host
test_callbacks = TestCallbacks()
playbook = ansible.playbook.PlayBook(
playbook=os.path.join(self.test_dir, 'hosts_list.yml'),
host_list='test/ansible_hosts',
stats=ans_callbacks.AggregateStats(),
callbacks=test_callbacks,
runner_callbacks=test_callbacks)
play = ansible.playbook.Play(playbook, playbook.playbook[0])
assert play.hosts == ';'.join(('host1', 'host2', 'host3'))
