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'))