mirror of
https://github.com/ansible-collections/community.general.git
synced 2026-04-04 01:33:09 +00:00
2aeb79f45f
This is incomplete work, and requires some minor tweeks to the integration tests which are not included in this commit.
195 lines
7.0 KiB
Python
Executable File
195 lines
7.0 KiB
Python
Executable File
#!/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
|
|
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,
|
|
subset_opts=True,
|
|
async_opts=True,
|
|
output_opts=True,
|
|
connect_opts=True,
|
|
check_opts=True,
|
|
diff_opts=False,
|
|
)
|
|
|
|
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)
|
|
|
|
# su and sudo command line arguments need to be mutually exclusive
|
|
if (options.su or options.su_user or options.ask_su_pass) and \
|
|
(options.sudo or options.sudo_user or options.ask_sudo_pass):
|
|
parser.error("Sudo arguments ('--sudo', '--sudo-user', and '--ask-sudo-pass') "
|
|
"and su arguments ('-su', '--su-user', and '--ask-su-pass') are "
|
|
"mutually exclusive")
|
|
|
|
if (options.ask_vault_pass and options.vault_password_file):
|
|
parser.error("--ask-vault-pass and --vault-password-file are mutually exclusive")
|
|
|
|
return (options, args)
|
|
|
|
# ----------------------------------------------
|
|
|
|
def run(self, options, args):
|
|
''' use Runner lib to do SSH things '''
|
|
|
|
pattern = args[0]
|
|
|
|
#-------------------------------------------------------------------------------
|
|
# FIXME: the password asking stuff needs to be ported over still
|
|
#-------------------------------------------------------------------------------
|
|
#sshpass = None
|
|
#sudopass = None
|
|
#su_pass = None
|
|
#vault_pass = None
|
|
#
|
|
#options.ask_pass = options.ask_pass or C.DEFAULT_ASK_PASS
|
|
## Never ask for an SSH password when we run with local connection
|
|
#if options.connection == "local":
|
|
# options.ask_pass = False
|
|
#options.ask_sudo_pass = options.ask_sudo_pass or C.DEFAULT_ASK_SUDO_PASS
|
|
#options.ask_su_pass = options.ask_su_pass or C.DEFAULT_ASK_SU_PASS
|
|
#options.ask_vault_pass = options.ask_vault_pass or C.DEFAULT_ASK_VAULT_PASS
|
|
#
|
|
#(sshpass, sudopass, su_pass, vault_pass) = utils.ask_passwords(ask_pass=options.ask_pass, ask_sudo_pass=options.ask_sudo_pass, ask_su_pass=options.ask_su_pass, ask_vault_pass=options.ask_vault_pass)
|
|
#
|
|
# read vault_pass from a file
|
|
#if not options.ask_vault_pass and options.vault_password_file:
|
|
# vault_pass = utils.read_vault_file(options.vault_password_file)
|
|
#-------------------------------------------------------------------------------
|
|
|
|
# FIXME: needs vault password, after the above is fixed
|
|
loader = DataLoader()
|
|
variable_manager = VariableManager()
|
|
|
|
inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=options.inventory)
|
|
if options.subset:
|
|
inventory.subset(options.subset)
|
|
|
|
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)
|