ansible/v2/bin/ansible

#!/usr/bin/env python

# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

########################################################

import os
import sys

from ansible import constants as C
from ansible.errors import *
from ansible.executor.task_queue_manager import TaskQueueManager
from ansible.inventory import Inventory
from ansible.parsing import DataLoader
from ansible.parsing.splitter import parse_kv
from ansible.playbook.play import Play
from ansible.utils.cli import base_parser, validate_conflicts, normalize_become_options, ask_passwords
from ansible.utils.vault import read_vault_file
from ansible.vars import VariableManager

########################################################

class Cli(object):
    ''' code behind bin/ansible '''

    def __init__(self):
        pass

    def parse(self):
        ''' create an options parser for bin/ansible '''

        parser = base_parser(
            usage='%prog <host-pattern> [options]',
            runas_opts=True,
            async_opts=True,
            output_opts=True,
            connect_opts=True,
            check_opts=True,
        )

        # options unique to ansible ad-hoc
        parser.add_option('-a', '--args', dest='module_args',
            help="module arguments", default=C.DEFAULT_MODULE_ARGS)
        parser.add_option('-m', '--module-name', dest='module_name',
            help="module name to execute (default=%s)" % C.DEFAULT_MODULE_NAME,
            default=C.DEFAULT_MODULE_NAME)

        options, args = parser.parse_args()

        if len(args) == 0 or len(args) > 1:
            parser.print_help()
            sys.exit(1)

        validate_conflicts(parser,options)

        return (options, args)

    # ----------------------------------------------

    def run(self, options, args):
        ''' use Runner lib to do SSH things '''

        pattern = args[0]

        if options.connection == "local":
            options.ask_pass = False

        sshpass    = None
        becomepass    = None
        vault_pass = None

        normalize_become_options(options)
        (sshpass, becomepass, vault_pass) = ask_passwords(options)

        if options.vault_password_file:
        # read vault_pass from a file
            vault_pass = read_vault_file(options.vault_password_file)

        loader = DataLoader(vault_password=vault_pass)
        variable_manager = VariableManager()

        inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=options.inventory)

        hosts = inventory.list_hosts(pattern)
        if len(hosts) == 0:
            raise AnsibleError("provided hosts list is empty")

        if options.listhosts:
            for host in hosts:
                print('    %s' % host.name)
            sys.exit(0)

        if ((options.module_name == 'command' or options.module_name == 'shell') and not options.module_args):
            raise AnsibleError("No argument passed to %s module" % options.module_name)

        # FIXME: async support needed
        #if options.seconds:
        #    callbacks.display("background launch...\n\n", color='cyan')
        #    results, poller = runner.run_async(options.seconds)
        #    results = self.poll_while_needed(poller, options)
        #else:
        #    results = runner.run()

        # create a pseudo-play to execute the specified module via a single task
        play_ds = dict(
            hosts = pattern,
            gather_facts = 'no',
            tasks = [
                dict(action=dict(module=options.module_name, args=parse_kv(options.module_args))),
            ]
        )

        play = Play().load(play_ds, variable_manager=variable_manager, loader=loader)

        # now create a task queue manager to execute the play
        try:
            tqm = TaskQueueManager(inventory=inventory, callback='minimal', variable_manager=variable_manager, loader=loader, options=options)
            result = tqm.run(play)
            tqm.cleanup()
        except AnsibleError:
            tqm.cleanup()
            raise

        return result

    # ----------------------------------------------

    def poll_while_needed(self, poller, options):
        ''' summarize results from Runner '''

        # BACKGROUND POLL LOGIC when -B and -P are specified
        if options.seconds and options.poll_interval > 0:
            poller.wait(options.seconds, options.poll_interval)

        return poller.results


########################################################

if __name__ == '__main__':
    #callbacks.display("", log_only=True)
    #callbacks.display(" ".join(sys.argv), log_only=True)
    #callbacks.display("", log_only=True)

    try:
        cli = Cli()
        (options, args) = cli.parse()
        result = cli.run(options, args)
        
    except AnsibleError, e:
        print(e)
        sys.exit(1)

    except Exception, e:
        # Generic handler for errors
        print("ERROR: %s" % str(e))
        sys.exit(1)

    sys.exit(result)