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 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 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_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 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 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 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 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 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 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 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 _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 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 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 book_set(self): #使用playbook模块
runner_cb = callbacks.PlaybookRunnerCallbacks(self.stats,
verbose=utils.VERBOSITY)
self.pb = ansible.playbook.PlayBook(playbook=self.playbook,
stats=self.stats,
extra_vars=self.extra_vars,
callbacks=self.playbook_cb,
runner_callbacks=runner_cb)
def __init__(self, playbook, extra_vars={}): # 初始化参数
self.stats = AllStats()
self.playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
self.runner_cb = callbacks.PlaybookRunnerCallbacks(self.stats,
verbose=2)
self.extra_vars = extra_vars
self.playbook = playbook
self.setbook = self.book_set()
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 run_ansible_on_host(host, logger, config):
import ansible.runner
import ansible.playbook
import ansible.inventory
from ansible import callbacks
from ansible import utils
# global verbosity for debugging e.g. ssh problems with ansible. ugly.
# utils.VERBOSITY = 4
# set up ansible inventory for the host
a_host = ansible.inventory.host.Host(name=host['id'])
a_host.set_variable('ansible_ssh_host', host['private_ip'])
# the following does not work, have to use the extra_vars instead
# a_host.set_variable('notebook_host_block_dev_path', '/dev/vdb')
a_group = ansible.inventory.group.Group(name='notebook_host')
a_group.add_host(a_host)
a_inventory = ansible.inventory.Inventory(host_list=[host['private_ip']])
a_inventory.add_group(a_group)
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)
logger.debug("_prepare_host(): running ansible")
logger.debug('_prepare_host(): inventory hosts %s' % a_inventory.host_list)
extra_vars = dict()
if 'DD_HOST_DATA_VOLUME_DEVICE' in config:
extra_vars['notebook_host_block_dev_path'] = config['DD_HOST_DATA_VOLUME_DEVICE']
pb = ansible.playbook.PlayBook(
playbook="/webapps/pouta_blueprints/source/ansible/notebook_playbook.yml",
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
inventory=a_inventory,
remote_user='******',
extra_vars=extra_vars,
)
pb_res = pb.run()
logger.debug(json.dumps(pb_res, sort_keys=True, indent=4, separators=(',', ': ')))
for host_name in pb_res.keys():
host_data = pb_res[host_name]
if host_data.get('unreachable', 0) + host_data.get('failures', 0) > 0:
raise RuntimeError('run_ansible_on_host(%s) failed' % host['id'])
def run():
machines = Machine.query.all()
inventory = Inventory([machine.name for machine in machines])
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats)
results = PlayBook(playbook='webapp/test.yml',
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats,
inventory=inventory).run()
return jsonify(results)
def run_playbook(playbook_path, hosts_path, key_file):
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=0)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=0)
playbook.PlayBook(playbook=playbook_path,
host_list=hosts_path,
stats=stats,
forks=4,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
private_key_file=key_file).run()
return stats
def Playbook():
vars={}
inventory = Inventory(hostfile)
stats = callbacks.AggregateStats()
playbook_cb =callbacks.PlaybookCallbacks()
runner_cb =callbacks.PlaybookRunnerCallbacks(stats)
hosts=request.args.get('ip')
task=request.args.get('playbook')
vars['hosts'] = hosts
play=task + '.yml'
results = PlayBook(playbook=play,callbacks=playbook_cb,runner_callbacks=runner_cb,stats=stats,inventory=inventory,extra_vars=vars)
res = results.run()
return json.dumps(res,indent=4)
def run_playbook(playbook_file_name, inventory_file_name):
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=0)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=0)
pb = ansible.playbook.PlayBook(
playbook_file_name,
inventory=inventory.Inventory(inventory_file_name),
callbacks=playbook_cb,
runner_callbacks=runner_cb,
stats=stats)
pb.run()
def runplaybook(path):
if not path.strip():
return
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,verbose=utils.VERBOSITY)
res=ansible.playbook.PlayBook(
playbook=path,
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb
).run()
data = json.dumps(res,indent=4)
return data
def pb():
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks()
runner_cb = callbacks.PlaybookRunnerCallbacks(stats)
inventory = Inventory('/export/servers/Ultron/ultron_test/ghosts')
res = ansible.playbook.PlayBook(
playbook="/etc/ansible/playbook/jengined_install.yml",
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
check=False,
inventory=inventory,
extra_vars={"ansible_ssh_pass": "******"})
return res.run()
def run_the_book(playbook='localhost.yml',
mypath=None,
module_path=None,
diff=False,
noop=False,
debug=False):
if mypath is not None:
local_inventory = ansible.inventory.Inventory(host_list=mypath +
'/inventory')
else:
local_inventory = ansible.inventory.Inventory()
local_inventory.subset('localhost')
# setting callbacks
stats = callbacks.AggregateStats()
if not debug:
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
else:
playbook_cb = callbacks.PlaybookCallbacks(verbose=True)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=True)
pb = ansible.playbook.PlayBook(playbook=playbook,
stats=stats,
module_path=module_path,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
inventory=local_inventory,
check=noop,
diff=diff)
# running the playbook
pr = pb.run()
return pr
def __call__(self):
playbook = os.path.join(self._basedir, self.playbook)
host = self.parameter[0]
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']
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={
'init_script':
os.path.join(
self._basedir,
'mcadmin/memcached')
},
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={
'init_script':
os.path.join(
self._basedir,
'mcadmin/memcached')
},
stats=stats,
sudo=True,
sudo_user='******',
sudo_pass=remote_pass,
callbacks=playbook_cb,
runner_callbacks=runner_cb).run()
return res
def playbook_api(self, yml_fp):
ret = None
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
pb = PlayBook(playbook=yml_fp,
host_list=self.ansible_host_list,
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb)
ret = pb.run()
def playbook_runner(playbook, inventory):
stats = callbacks.AggregateStats()
playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
runner_cb = callbacks.PlaybookRunnerCallbacks(stats,
verbose=utils.VERBOSITY)
res = ansible.playbook.PlayBook(
playbook=playbook,
stats=stats,
callbacks=playbook_cb,
runner_callbacks=runner_cb,
host_list=inventory,
).run()
return res
