Python playbook.PlayBook类代码示例

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_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(dir, extra_vars):
    utils.VERBOSITY = 0
    playbook_cb = MyPlaybookCallbacks(verbose=utils.VERBOSITY)
    stats = callbacks.AggregateStats()
    runner_cb = MyPlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)

    inventory = """
[localhost]
localhost ansible_connection=local
"""

    # Create a temporary file and write the template string to it
    hosts = tempfile.NamedTemporaryFile(delete=False, dir=dir)
    hosts.write(inventory)
    hosts.close()

    pb = PlayBook(
        playbook=os.path.join(dir, "playbook.yml"),
        host_list=hosts.name,
        callbacks=playbook_cb,
        runner_callbacks=runner_cb,
        extra_vars=extra_vars,
        stats=stats
    )

    results = pb.run()

    # Ensure on_stats callback is called
    # for callback modules
    playbook_cb.on_stats(pb.stats)
    logger().info(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='rack',
        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 gather_facts(host, inventory=None):
    if inventory is None:
        inventory = get_inventory()

    # Gather facts
    try:

        # ... temporary playbook file
        playbook_file = tempfile.NamedTemporaryFile()
        playbook_file.write(SETUP_PLAYBOOK.format(host=host))
        playbook_file.seek(0)

        # ... run setup module
        stats = ansible.callbacks.AggregateStats()
        # callbacks = ansible.callbacks.PlaybookCallbacks(verbose=VERBOSITY)
        # runner_callbacks = ansible.callbacks.PlaybookRunnerCallbacks(
        #     stats, verbose=VERBOSITY)
        playbook = PlayBook(
            playbook=playbook_file.name,
            inventory=inventory,
            callbacks=Callbacks(),
            runner_callbacks=Callbacks(),
            stats=stats,
        )
        playbook.run()

    finally:
        playbook_file.close()

    return playbook.SETUP_CACHE

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 gather_facts(host, inventory=None, user=None):
    if inventory is None:
        inventory = get_inventory()

    # Gather facts
    try:

        # ... temporary playbook file
        playbook_file = tempfile.NamedTemporaryFile()
        playbook_file.write(SETUP_PLAYBOOK.format(host=host))
        playbook_file.seek(0)

        # ... run setup module
        stats = ansible.callbacks.AggregateStats()
        playbook = PlayBook(
            playbook=playbook_file.name,
            inventory=inventory,
            callbacks=Callbacks(),
            runner_callbacks=Callbacks(),
            remote_user=user or C.DEFAULT_REMOTE_USER,
            stats=stats,
        )
        results = playbook.run()

        # ... notify the user of failures
        for host, result in results.iteritems():
            if result.get('unreachable') or result.get('failures'):
                yellow('Unable to gather facts for host "{}"'.format(host))

    finally:
        playbook_file.close()

    return playbook.SETUP_CACHE

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 Test(self,host):
     playbook = PlayBook(playbook='/Users/ezeng/Development/mesos-poc/vm_booting/playbook.yml',
                         # inventory=Inventory('/Users/ezeng/Development/mesos-poc/vm_booting/ansible/inventory'),
                         host_list=host.split(","),
                         callbacks=playbook_cb,
                         runner_callbacks=runner_cb,
                         stats=stats)
     playbook.run()

def deploy_service(username, passwd, hosts, extras):

	ruta = os.path.join(ROLESDIR, 'ansible-role-mailserver/site.yml')
	
	pb = PlayBook(playbook=ruta, sudo=True, sudo_pass=passwd, host_list=hosts,
		remote_user=username, extra_vars=extras, callbacks=playbook_cb,
		runner_callbacks=runner_cb, stats=stats)
	
	pb.run()

def execute(taskexecution_id):
    from ansible.playbook import PlayBook
    from ansible.inventory import Inventory
    from ansible import callbacks
    from ansible import utils

    utils.VERBOSITY = 0
    playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
    stats = callbacks.AggregateStats()
    runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY)

    time.sleep(5)

    taskexecution = TaskExecution.objects.get(pk=taskexecution_id)
    taskexecution.start()
    taskexecution.save()

    inventory = "[local]\n\
localhost   ansible_connection=local\n\
\n\
[tasker]\n\
localhost\n\
\n\
[tasker:vars]\n\
taskexecution_id={}".format(taskexecution_id)

    hosts = NamedTemporaryFile(delete=False)
    hosts.write(inventory)
    hosts.close()

    pb = PlayBook(
        playbook='/tmp/main.yml',
        host_list=hosts.name,
        # remote_user='mskarbek',
        callbacks=playbook_cb,
        runner_callbacks=runner_cb,
        stats=stats,
        # private_key_file='/path/to/key.pem'
    )

    results = pb.run()

    playbook_cb.on_stats(pb.stats)

    os.remove(hosts.name)

    status = results.get('localhost')

    if status['failures'] > 0 or status['unreachable'] > 0:
        taskexecution.failed()
        taskexecution.save()
        return False

    taskexecution.succeed()
    taskexecution.save()
    return True

 def run(self):
     pb = PlayBook(playbook=self.playbook,
                   host_list=self.host_list,
                   module_path=self.module_path,
                   callbacks=self.playbook_cb,
                   runner_callbacks=self.runner_cb,
                   stats=self.stats
                   )
     results = pb.run()
     return results
     print results

    def action(self, resource, action):
        # This would require to put this file to remote and execute it (mostly)

        ssh_props = find_named_transport(resource, 'ssh')

        remote_user = ssh_props['user']
        private_key_file = ssh_props.get('key')
        ssh_password = ssh_props.get('password')

        action_file = os.path.join(
            resource.db_obj.actions_path,
            resource.actions[action])

        variables = resource.args
        if 'roles' in variables:
            self.download_roles(variables['roles'])

        host = resource.ip()
        transport = C.DEFAULT_TRANSPORT

        C.HOST_KEY_CHECKING = False

        stats = callbacks.AggregateStats()
        playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY)
        runner_cb = callbacks.PlaybookRunnerCallbacks(
            stats, verbose=utils.VERBOSITY)

        opts = dict(
            playbook=action_file,
            remote_user=remote_user,
            host_list=[host],
            extra_vars=variables,
            callbacks=playbook_cb,
            runner_callbacks=runner_cb,
            stats=stats,
            transport=transport)

        if ssh_password:
            opts['remote_pass'] = ssh_password
        elif private_key_file:
            opts['private_key_file'] = private_key_file
        else:
            raise Exception("No key and no password given")

        play = PlayBook(**opts)

        play.run()
        summary = stats.summarize(host)

        if summary.get('unreachable') or summary.get('failures'):
            raise errors.SolarError(
                'Ansible playbook %s failed with next summary %s',
                action_file, summary)

def systemtemplate_Install():
        playbook = PlayBook(remote_user='root',
                            remote_pass=passwd,
                            playbook='./ansible/play-books/cldstk-preseed-kvm-systmpl.yml',
                            callbacks=playbook_cb,
                            runner_callbacks=runner_cb,
                            stats=stats,
                            host_list='ansible/hosts'
                            )

        playoutput = playbook.run()
        for l in playoutput:print l,playoutput[l]

def db_replication_Install():
        playbook = PlayBook(remote_user='root',
                            remote_pass=passwd,
                            playbook='./ansible/play-books/mysql-replication-setup.yml',
                            callbacks=playbook_cb,
                            runner_callbacks=runner_cb,
                            stats=stats,
                            host_list='ansible/hosts'
                            )

        playoutput = playbook.run()
        for l in playoutput:print l,playoutput[l]