mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-04-28 21:31:26 -07:00
edcbef27ec
* Retain vault password as bytes in 2.2 Prior to 2.2.1, the vault password was read in as byes and then remained bytes all the way through the code. A bug existed where bytes and text were mixed, leading to a traceback with non-ascii passwords. In devel, this was fixed by changing the read in password to text type to match with our overall strategy of converting at the borders. This was backported to stable-2.2 for the 2.2.1 release. On reflection, this should not have been backported as it causes passwords which were originally non-utf-8 to become utf-8. People will then have their working 2.2.x vault files become in-accessible. this commit pipes bytes all the way through the system for vault password. That way if a password is read in as a non-utf-8 character sequence, it will continue to work in 2.2.2+. This change is only for the 2.2 branch, not for 2.3 and beyond. Why not everywhere? The reason is that non-utf-8 passwords will cause problems when vault files are shared between systems or users. If the password is read from the prompt and one user/machine has a latin1 encoded locale while a second one has utf-8, the non-ascii password typed in won't match between machines. Deal with this by making sure that when we encrypt the data, we always use valid utf-8. Fixes #20398 (cherry picked from commit 5dcce0666a81917c68b76286685642fd72d84327)
659 lines
30 KiB
Python
659 lines
30 KiB
Python
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
|
# (c) 2016, Toshio Kuratomi <tkuratomi@ansible.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/>.
|
|
|
|
# Make coding more python3-ish
|
|
from __future__ import (absolute_import, division, print_function)
|
|
__metaclass__ = type
|
|
|
|
import operator
|
|
import optparse
|
|
import os
|
|
import sys
|
|
import time
|
|
import yaml
|
|
import re
|
|
import getpass
|
|
import subprocess
|
|
from abc import ABCMeta, abstractmethod
|
|
|
|
from ansible.release import __version__
|
|
from ansible import constants as C
|
|
from ansible.compat.six import with_metaclass
|
|
from ansible.errors import AnsibleError, AnsibleOptionsError
|
|
from ansible.module_utils._text import to_bytes, to_text
|
|
|
|
try:
|
|
from __main__ import display
|
|
except ImportError:
|
|
from ansible.utils.display import Display
|
|
display = Display()
|
|
|
|
|
|
class SortedOptParser(optparse.OptionParser):
|
|
'''Optparser which sorts the options by opt before outputting --help'''
|
|
|
|
#FIXME: epilog parsing: OptionParser.format_epilog = lambda self, formatter: self.epilog
|
|
|
|
def format_help(self, formatter=None, epilog=None):
|
|
self.option_list.sort(key=operator.methodcaller('get_opt_string'))
|
|
return optparse.OptionParser.format_help(self, formatter=None)
|
|
|
|
|
|
# Note: Inherit from SortedOptParser so that we get our format_help method
|
|
class InvalidOptsParser(SortedOptParser):
|
|
'''Ignore invalid options.
|
|
|
|
Meant for the special case where we need to take care of help and version
|
|
but may not know the full range of options yet. (See it in use in set_action)
|
|
'''
|
|
def __init__(self, parser):
|
|
# Since this is special purposed to just handle help and version, we
|
|
# take a pre-existing option parser here and set our options from
|
|
# that. This allows us to give accurate help based on the given
|
|
# option parser.
|
|
SortedOptParser.__init__(self, usage=parser.usage,
|
|
option_list=parser.option_list,
|
|
option_class=parser.option_class,
|
|
conflict_handler=parser.conflict_handler,
|
|
description=parser.description,
|
|
formatter=parser.formatter,
|
|
add_help_option=False,
|
|
prog=parser.prog,
|
|
epilog=parser.epilog)
|
|
self.version=parser.version
|
|
|
|
def _process_long_opt(self, rargs, values):
|
|
try:
|
|
optparse.OptionParser._process_long_opt(self, rargs, values)
|
|
except optparse.BadOptionError:
|
|
pass
|
|
|
|
def _process_short_opts(self, rargs, values):
|
|
try:
|
|
optparse.OptionParser._process_short_opts(self, rargs, values)
|
|
except optparse.BadOptionError:
|
|
pass
|
|
|
|
|
|
class CLI(with_metaclass(ABCMeta, object)):
|
|
''' code behind bin/ansible* programs '''
|
|
|
|
VALID_ACTIONS = ['No Actions']
|
|
|
|
_ITALIC = re.compile(r"I\(([^)]+)\)")
|
|
_BOLD = re.compile(r"B\(([^)]+)\)")
|
|
_MODULE = re.compile(r"M\(([^)]+)\)")
|
|
_URL = re.compile(r"U\(([^)]+)\)")
|
|
_CONST = re.compile(r"C\(([^)]+)\)")
|
|
|
|
PAGER = 'less'
|
|
|
|
# -F (quit-if-one-screen) -R (allow raw ansi control chars)
|
|
# -S (chop long lines) -X (disable termcap init and de-init)
|
|
LESS_OPTS = 'FRSX'
|
|
|
|
def __init__(self, args, callback=None):
|
|
"""
|
|
Base init method for all command line programs
|
|
"""
|
|
|
|
self.args = args
|
|
self.options = None
|
|
self.parser = None
|
|
self.action = None
|
|
self.callback = callback
|
|
|
|
def set_action(self):
|
|
"""
|
|
Get the action the user wants to execute from the sys argv list.
|
|
"""
|
|
for i in range(0, len(self.args)):
|
|
arg = self.args[i]
|
|
if arg in self.VALID_ACTIONS:
|
|
self.action = arg
|
|
del self.args[i]
|
|
break
|
|
|
|
if not self.action:
|
|
# if we're asked for help or version, we don't need an action.
|
|
# have to use a special purpose Option Parser to figure that out as
|
|
# the standard OptionParser throws an error for unknown options and
|
|
# without knowing action, we only know of a subset of the options
|
|
# that could be legal for this command
|
|
tmp_parser = InvalidOptsParser(self.parser)
|
|
tmp_options, tmp_args = tmp_parser.parse_args(self.args)
|
|
if not(hasattr(tmp_options, 'help') and tmp_options.help) or (hasattr(tmp_options, 'version') and tmp_options.version):
|
|
raise AnsibleOptionsError("Missing required action")
|
|
|
|
def execute(self):
|
|
"""
|
|
Actually runs a child defined method using the execute_<action> pattern
|
|
"""
|
|
fn = getattr(self, "execute_%s" % self.action)
|
|
fn()
|
|
|
|
@abstractmethod
|
|
def run(self):
|
|
"""Run the ansible command
|
|
|
|
Subclasses must implement this method. It does the actual work of
|
|
running an Ansible command.
|
|
"""
|
|
|
|
if self.options.verbosity > 0:
|
|
if C.CONFIG_FILE:
|
|
display.display(u"Using %s as config file" % to_text(C.CONFIG_FILE))
|
|
else:
|
|
display.display(u"No config file found; using defaults")
|
|
|
|
@staticmethod
|
|
def ask_vault_passwords():
|
|
''' prompt for vault password and/or password change '''
|
|
|
|
vault_pass = None
|
|
try:
|
|
vault_pass = getpass.getpass(prompt="Vault password: ")
|
|
|
|
except EOFError:
|
|
pass
|
|
|
|
# enforce no newline chars at the end of passwords
|
|
if vault_pass:
|
|
vault_pass = to_bytes(vault_pass, errors='surrogate_or_strict', nonstring='simplerepr').strip()
|
|
|
|
return vault_pass
|
|
|
|
@staticmethod
|
|
def ask_new_vault_passwords():
|
|
new_vault_pass = None
|
|
try:
|
|
new_vault_pass = getpass.getpass(prompt="New Vault password: ")
|
|
new_vault_pass2 = getpass.getpass(prompt="Confirm New Vault password: ")
|
|
if new_vault_pass != new_vault_pass2:
|
|
raise AnsibleError("Passwords do not match")
|
|
except EOFError:
|
|
pass
|
|
|
|
if new_vault_pass:
|
|
new_vault_pass = to_bytes(new_vault_pass, errors='surrogate_or_strict', nonstring='simplerepr').strip()
|
|
|
|
return new_vault_pass
|
|
|
|
def ask_passwords(self):
|
|
''' prompt for connection and become passwords if needed '''
|
|
|
|
op = self.options
|
|
sshpass = None
|
|
becomepass = None
|
|
become_prompt = ''
|
|
|
|
try:
|
|
if op.ask_pass:
|
|
sshpass = getpass.getpass(prompt="SSH password: ")
|
|
become_prompt = "%s password[defaults to SSH password]: " % op.become_method.upper()
|
|
if sshpass:
|
|
sshpass = to_bytes(sshpass, errors='strict', nonstring='simplerepr')
|
|
else:
|
|
become_prompt = "%s password: " % op.become_method.upper()
|
|
|
|
if op.become_ask_pass:
|
|
becomepass = getpass.getpass(prompt=become_prompt)
|
|
if op.ask_pass and becomepass == '':
|
|
becomepass = sshpass
|
|
if becomepass:
|
|
becomepass = to_bytes(becomepass)
|
|
except EOFError:
|
|
pass
|
|
|
|
return (sshpass, becomepass)
|
|
|
|
def normalize_become_options(self):
|
|
''' this keeps backwards compatibility with sudo/su self.options '''
|
|
self.options.become_ask_pass = self.options.become_ask_pass or self.options.ask_sudo_pass or self.options.ask_su_pass or C.DEFAULT_BECOME_ASK_PASS
|
|
self.options.become_user = self.options.become_user or self.options.sudo_user or self.options.su_user or C.DEFAULT_BECOME_USER
|
|
|
|
if self.options.become:
|
|
pass
|
|
elif self.options.sudo:
|
|
self.options.become = True
|
|
self.options.become_method = 'sudo'
|
|
elif self.options.su:
|
|
self.options.become = True
|
|
self.options.become_method = 'su'
|
|
|
|
def validate_conflicts(self, vault_opts=False, runas_opts=False, fork_opts=False):
|
|
''' check for conflicting options '''
|
|
|
|
op = self.options
|
|
|
|
if vault_opts:
|
|
# Check for vault related conflicts
|
|
if (op.ask_vault_pass and op.vault_password_file):
|
|
self.parser.error("--ask-vault-pass and --vault-password-file are mutually exclusive")
|
|
|
|
if runas_opts:
|
|
# Check for privilege escalation conflicts
|
|
if (op.su or op.su_user) and (op.sudo or op.sudo_user) or \
|
|
(op.su or op.su_user) and (op.become or op.become_user) or \
|
|
(op.sudo or op.sudo_user) and (op.become or op.become_user):
|
|
|
|
self.parser.error("Sudo arguments ('--sudo', '--sudo-user', and '--ask-sudo-pass') "
|
|
"and su arguments ('-su', '--su-user', and '--ask-su-pass') "
|
|
"and become arguments ('--become', '--become-user', and '--ask-become-pass')"
|
|
" are exclusive of each other")
|
|
|
|
if fork_opts:
|
|
if op.forks < 1:
|
|
self.parser.error("The number of processes (--forks) must be >= 1")
|
|
|
|
@staticmethod
|
|
def expand_tilde(option, opt, value, parser):
|
|
setattr(parser.values, option.dest, os.path.expanduser(value))
|
|
|
|
@staticmethod
|
|
def expand_paths(option, opt, value, parser):
|
|
"""optparse action callback to convert a PATH style string arg to a list of path strings.
|
|
|
|
For ex, cli arg of '-p /blip/foo:/foo/bar' would be split on the
|
|
default os.pathsep and the option value would be set to
|
|
the list ['/blip/foo', '/foo/bar']. Each path string in the list
|
|
will also have '~/' values expand via os.path.expanduser()."""
|
|
path_entries = value.split(os.pathsep)
|
|
expanded_path_entries = [os.path.expanduser(path_entry) for path_entry in path_entries]
|
|
setattr(parser.values, option.dest, expanded_path_entries)
|
|
|
|
@staticmethod
|
|
def base_parser(usage="", output_opts=False, runas_opts=False, meta_opts=False, runtask_opts=False, vault_opts=False, module_opts=False,
|
|
async_opts=False, connect_opts=False, subset_opts=False, check_opts=False, inventory_opts=False, epilog=None, fork_opts=False, runas_prompt_opts=False):
|
|
''' create an options parser for most ansible scripts '''
|
|
|
|
# TODO: implement epilog parsing
|
|
# OptionParser.format_epilog = lambda self, formatter: self.epilog
|
|
|
|
# base opts
|
|
parser = SortedOptParser(usage, version=CLI.version("%prog"))
|
|
parser.add_option('-v','--verbose', dest='verbosity', default=C.DEFAULT_VERBOSITY, action="count",
|
|
help="verbose mode (-vvv for more, -vvvv to enable connection debugging)")
|
|
|
|
if inventory_opts:
|
|
parser.add_option('-i', '--inventory-file', dest='inventory',
|
|
help="specify inventory host path (default=%s) or comma separated host list." % C.DEFAULT_HOST_LIST,
|
|
default=C.DEFAULT_HOST_LIST, action="callback", callback=CLI.expand_tilde, type=str)
|
|
parser.add_option('--list-hosts', dest='listhosts', action='store_true',
|
|
help='outputs a list of matching hosts; does not execute anything else')
|
|
parser.add_option('-l', '--limit', default=C.DEFAULT_SUBSET, dest='subset',
|
|
help='further limit selected hosts to an additional pattern')
|
|
|
|
if module_opts:
|
|
parser.add_option('-M', '--module-path', dest='module_path', default=None,
|
|
help="specify path(s) to module library (default=%s)" % C.DEFAULT_MODULE_PATH,
|
|
action="callback", callback=CLI.expand_tilde, type=str)
|
|
if runtask_opts:
|
|
parser.add_option('-e', '--extra-vars', dest="extra_vars", action="append",
|
|
help="set additional variables as key=value or YAML/JSON", default=[])
|
|
|
|
if fork_opts:
|
|
parser.add_option('-f','--forks', dest='forks', default=C.DEFAULT_FORKS, type='int',
|
|
help="specify number of parallel processes to use (default=%s)" % C.DEFAULT_FORKS)
|
|
|
|
if vault_opts:
|
|
parser.add_option('--ask-vault-pass', default=C.DEFAULT_ASK_VAULT_PASS, dest='ask_vault_pass', action='store_true',
|
|
help='ask for vault password')
|
|
parser.add_option('--vault-password-file', default=C.DEFAULT_VAULT_PASSWORD_FILE, dest='vault_password_file',
|
|
help="vault password file", action="callback", callback=CLI.expand_tilde, type=str)
|
|
parser.add_option('--new-vault-password-file', dest='new_vault_password_file',
|
|
help="new vault password file for rekey", action="callback", callback=CLI.expand_tilde, type=str)
|
|
parser.add_option('--output', default=None, dest='output_file',
|
|
help='output file name for encrypt or decrypt; use - for stdout',
|
|
action="callback", callback=CLI.expand_tilde, type=str)
|
|
|
|
if subset_opts:
|
|
parser.add_option('-t', '--tags', dest='tags', default=[], action='append',
|
|
help="only run plays and tasks tagged with these values")
|
|
parser.add_option('--skip-tags', dest='skip_tags', default=[], action='append',
|
|
help="only run plays and tasks whose tags do not match these values")
|
|
|
|
if output_opts:
|
|
parser.add_option('-o', '--one-line', dest='one_line', action='store_true',
|
|
help='condense output')
|
|
parser.add_option('-t', '--tree', dest='tree', default=None,
|
|
help='log output to this directory')
|
|
|
|
if connect_opts:
|
|
connect_group = optparse.OptionGroup(parser, "Connection Options", "control as whom and how to connect to hosts")
|
|
connect_group.add_option('-k', '--ask-pass', default=C.DEFAULT_ASK_PASS, dest='ask_pass', action='store_true',
|
|
help='ask for connection password')
|
|
connect_group.add_option('--private-key','--key-file', default=C.DEFAULT_PRIVATE_KEY_FILE, dest='private_key_file',
|
|
help='use this file to authenticate the connection')
|
|
connect_group.add_option('-u', '--user', default=C.DEFAULT_REMOTE_USER, dest='remote_user',
|
|
help='connect as this user (default=%s)' % C.DEFAULT_REMOTE_USER)
|
|
connect_group.add_option('-c', '--connection', dest='connection', default=C.DEFAULT_TRANSPORT,
|
|
help="connection type to use (default=%s)" % C.DEFAULT_TRANSPORT)
|
|
connect_group.add_option('-T', '--timeout', default=C.DEFAULT_TIMEOUT, type='int', dest='timeout',
|
|
help="override the connection timeout in seconds (default=%s)" % C.DEFAULT_TIMEOUT)
|
|
connect_group.add_option('--ssh-common-args', default='', dest='ssh_common_args',
|
|
help="specify common arguments to pass to sftp/scp/ssh (e.g. ProxyCommand)")
|
|
connect_group.add_option('--sftp-extra-args', default='', dest='sftp_extra_args',
|
|
help="specify extra arguments to pass to sftp only (e.g. -f, -l)")
|
|
connect_group.add_option('--scp-extra-args', default='', dest='scp_extra_args',
|
|
help="specify extra arguments to pass to scp only (e.g. -l)")
|
|
connect_group.add_option('--ssh-extra-args', default='', dest='ssh_extra_args',
|
|
help="specify extra arguments to pass to ssh only (e.g. -R)")
|
|
|
|
parser.add_option_group(connect_group)
|
|
|
|
runas_group = None
|
|
rg = optparse.OptionGroup(parser, "Privilege Escalation Options", "control how and which user you become as on target hosts")
|
|
if runas_opts:
|
|
runas_group = rg
|
|
# priv user defaults to root later on to enable detecting when this option was given here
|
|
runas_group.add_option("-s", "--sudo", default=C.DEFAULT_SUDO, action="store_true", dest='sudo',
|
|
help="run operations with sudo (nopasswd) (deprecated, use become)")
|
|
runas_group.add_option('-U', '--sudo-user', dest='sudo_user', default=None,
|
|
help='desired sudo user (default=root) (deprecated, use become)')
|
|
runas_group.add_option('-S', '--su', default=C.DEFAULT_SU, action='store_true',
|
|
help='run operations with su (deprecated, use become)')
|
|
runas_group.add_option('-R', '--su-user', default=None,
|
|
help='run operations with su as this user (default=%s) (deprecated, use become)' % C.DEFAULT_SU_USER)
|
|
|
|
# consolidated privilege escalation (become)
|
|
runas_group.add_option("-b", "--become", default=C.DEFAULT_BECOME, action="store_true", dest='become',
|
|
help="run operations with become (does not imply password prompting)")
|
|
runas_group.add_option('--become-method', dest='become_method', default=C.DEFAULT_BECOME_METHOD, type='choice', choices=C.BECOME_METHODS,
|
|
help="privilege escalation method to use (default=%s), valid choices: [ %s ]" % (C.DEFAULT_BECOME_METHOD, ' | '.join(C.BECOME_METHODS)))
|
|
runas_group.add_option('--become-user', default=None, dest='become_user', type='string',
|
|
help='run operations as this user (default=%s)' % C.DEFAULT_BECOME_USER)
|
|
|
|
if runas_opts or runas_prompt_opts:
|
|
if not runas_group:
|
|
runas_group = rg
|
|
runas_group.add_option('--ask-sudo-pass', default=C.DEFAULT_ASK_SUDO_PASS, dest='ask_sudo_pass', action='store_true',
|
|
help='ask for sudo password (deprecated, use become)')
|
|
runas_group.add_option('--ask-su-pass', default=C.DEFAULT_ASK_SU_PASS, dest='ask_su_pass', action='store_true',
|
|
help='ask for su password (deprecated, use become)')
|
|
runas_group.add_option('-K', '--ask-become-pass', default=False, dest='become_ask_pass', action='store_true',
|
|
help='ask for privilege escalation password')
|
|
|
|
if runas_group:
|
|
parser.add_option_group(runas_group)
|
|
|
|
if async_opts:
|
|
parser.add_option('-P', '--poll', default=C.DEFAULT_POLL_INTERVAL, type='int', dest='poll_interval',
|
|
help="set the poll interval if using -B (default=%s)" % C.DEFAULT_POLL_INTERVAL)
|
|
parser.add_option('-B', '--background', dest='seconds', type='int', default=0,
|
|
help='run asynchronously, failing after X seconds (default=N/A)')
|
|
|
|
if check_opts:
|
|
parser.add_option("-C", "--check", default=False, dest='check', action='store_true',
|
|
help="don't make any changes; instead, try to predict some of the changes that may occur")
|
|
parser.add_option('--syntax-check', dest='syntax', action='store_true',
|
|
help="perform a syntax check on the playbook, but do not execute it")
|
|
parser.add_option("-D", "--diff", default=False, dest='diff', action='store_true',
|
|
help="when changing (small) files and templates, show the differences in those files; works great with --check")
|
|
|
|
if meta_opts:
|
|
parser.add_option('--force-handlers', default=C.DEFAULT_FORCE_HANDLERS, dest='force_handlers', action='store_true',
|
|
help="run handlers even if a task fails")
|
|
parser.add_option('--flush-cache', dest='flush_cache', action='store_true',
|
|
help="clear the fact cache")
|
|
|
|
return parser
|
|
|
|
@abstractmethod
|
|
def parse(self):
|
|
"""Parse the command line args
|
|
|
|
This method parses the command line arguments. It uses the parser
|
|
stored in the self.parser attribute and saves the args and options in
|
|
self.args and self.options respectively.
|
|
|
|
Subclasses need to implement this method. They will usually create
|
|
a base_parser, add their own options to the base_parser, and then call
|
|
this method to do the actual parsing. An implementation will look
|
|
something like this::
|
|
|
|
def parse(self):
|
|
parser = super(MyCLI, self).base_parser(usage="My Ansible CLI", inventory_opts=True)
|
|
parser.add_option('--my-option', dest='my_option', action='store')
|
|
self.parser = parser
|
|
super(MyCLI, self).parse()
|
|
# If some additional transformations are needed for the
|
|
# arguments and options, do it here.
|
|
"""
|
|
self.options, self.args = self.parser.parse_args(self.args[1:])
|
|
if hasattr(self.options, 'tags') and not self.options.tags:
|
|
# optparse defaults does not do what's expected
|
|
self.options.tags = ['all']
|
|
if hasattr(self.options, 'tags') and self.options.tags:
|
|
if not C.MERGE_MULTIPLE_CLI_TAGS:
|
|
if len(self.options.tags) > 1:
|
|
display.deprecated('Specifying --tags multiple times on the command line currently uses the last specified value. In 2.4, values will be merged instead. Set merge_multiple_cli_tags=True in ansible.cfg to get this behavior now.', version=2.5, removed=False)
|
|
self.options.tags = [self.options.tags[-1]]
|
|
|
|
tags = set()
|
|
for tag_set in self.options.tags:
|
|
for tag in tag_set.split(u','):
|
|
tags.add(tag.strip())
|
|
self.options.tags = list(tags)
|
|
|
|
if hasattr(self.options, 'skip_tags') and self.options.skip_tags:
|
|
if not C.MERGE_MULTIPLE_CLI_TAGS:
|
|
if len(self.options.skip_tags) > 1:
|
|
display.deprecated('Specifying --skip-tags multiple times on the command line currently uses the last specified value. In 2.4, values will be merged instead. Set merge_multiple_cli_tags=True in ansible.cfg to get this behavior now.', version=2.5, removed=False)
|
|
self.options.skip_tags = [self.options.skip_tags[-1]]
|
|
|
|
skip_tags = set()
|
|
for tag_set in self.options.skip_tags:
|
|
for tag in tag_set.split(u','):
|
|
skip_tags.add(tag.strip())
|
|
self.options.skip_tags = list(skip_tags)
|
|
|
|
@staticmethod
|
|
def version(prog):
|
|
''' return ansible version '''
|
|
result = "{0} {1}".format(prog, __version__)
|
|
gitinfo = CLI._gitinfo()
|
|
if gitinfo:
|
|
result = result + " {0}".format(gitinfo)
|
|
result += "\n config file = %s" % C.CONFIG_FILE
|
|
if C.DEFAULT_MODULE_PATH is None:
|
|
cpath = "Default w/o overrides"
|
|
else:
|
|
cpath = C.DEFAULT_MODULE_PATH
|
|
result = result + "\n configured module search path = %s" % cpath
|
|
result = result + "\n python version = %s" % ''.join(sys.version.splitlines())
|
|
return result
|
|
|
|
@staticmethod
|
|
def version_info(gitinfo=False):
|
|
''' return full ansible version info '''
|
|
if gitinfo:
|
|
# expensive call, user with care
|
|
ansible_version_string = CLI.version('')
|
|
else:
|
|
ansible_version_string = __version__
|
|
ansible_version = ansible_version_string.split()[0]
|
|
ansible_versions = ansible_version.split('.')
|
|
for counter in range(len(ansible_versions)):
|
|
if ansible_versions[counter] == "":
|
|
ansible_versions[counter] = 0
|
|
try:
|
|
ansible_versions[counter] = int(ansible_versions[counter])
|
|
except:
|
|
pass
|
|
if len(ansible_versions) < 3:
|
|
for counter in range(len(ansible_versions), 3):
|
|
ansible_versions.append(0)
|
|
return {'string': ansible_version_string.strip(),
|
|
'full': ansible_version,
|
|
'major': ansible_versions[0],
|
|
'minor': ansible_versions[1],
|
|
'revision': ansible_versions[2]}
|
|
|
|
@staticmethod
|
|
def _git_repo_info(repo_path):
|
|
''' returns a string containing git branch, commit id and commit date '''
|
|
result = None
|
|
if os.path.exists(repo_path):
|
|
# Check if the .git is a file. If it is a file, it means that we are in a submodule structure.
|
|
if os.path.isfile(repo_path):
|
|
try:
|
|
gitdir = yaml.safe_load(open(repo_path)).get('gitdir')
|
|
# There is a possibility the .git file to have an absolute path.
|
|
if os.path.isabs(gitdir):
|
|
repo_path = gitdir
|
|
else:
|
|
repo_path = os.path.join(repo_path[:-4], gitdir)
|
|
except (IOError, AttributeError):
|
|
return ''
|
|
f = open(os.path.join(repo_path, "HEAD"))
|
|
line = f.readline().rstrip("\n")
|
|
if line.startswith("ref:"):
|
|
branch_path = os.path.join(repo_path, line[5:])
|
|
else:
|
|
branch_path = None
|
|
f.close()
|
|
if branch_path and os.path.exists(branch_path):
|
|
branch = '/'.join(line.split('/')[2:])
|
|
f = open(branch_path)
|
|
commit = f.readline()[:10]
|
|
f.close()
|
|
else:
|
|
# detached HEAD
|
|
commit = line[:10]
|
|
branch = 'detached HEAD'
|
|
branch_path = os.path.join(repo_path, "HEAD")
|
|
|
|
date = time.localtime(os.stat(branch_path).st_mtime)
|
|
if time.daylight == 0:
|
|
offset = time.timezone
|
|
else:
|
|
offset = time.altzone
|
|
result = "({0} {1}) last updated {2} (GMT {3:+04d})".format(branch, commit,
|
|
time.strftime("%Y/%m/%d %H:%M:%S", date), int(offset / -36))
|
|
else:
|
|
result = ''
|
|
return result
|
|
|
|
@staticmethod
|
|
def _gitinfo():
|
|
basedir = os.path.join(os.path.dirname(__file__), '..', '..', '..')
|
|
repo_path = os.path.join(basedir, '.git')
|
|
result = CLI._git_repo_info(repo_path)
|
|
submodules = os.path.join(basedir, '.gitmodules')
|
|
if not os.path.exists(submodules):
|
|
return result
|
|
f = open(submodules)
|
|
for line in f:
|
|
tokens = line.strip().split(' ')
|
|
if tokens[0] == 'path':
|
|
submodule_path = tokens[2]
|
|
submodule_info = CLI._git_repo_info(os.path.join(basedir, submodule_path, '.git'))
|
|
if not submodule_info:
|
|
submodule_info = ' not found - use git submodule update --init ' + submodule_path
|
|
result += "\n {0}: {1}".format(submodule_path, submodule_info)
|
|
f.close()
|
|
return result
|
|
|
|
def pager(self, text):
|
|
''' find reasonable way to display text '''
|
|
# this is a much simpler form of what is in pydoc.py
|
|
if not sys.stdout.isatty():
|
|
display.display(text)
|
|
elif 'PAGER' in os.environ:
|
|
if sys.platform == 'win32':
|
|
display.display(text)
|
|
else:
|
|
self.pager_pipe(text, os.environ['PAGER'])
|
|
else:
|
|
p = subprocess.Popen('less --version', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
|
p.communicate()
|
|
if p.returncode == 0:
|
|
self.pager_pipe(text, 'less')
|
|
else:
|
|
display.display(text)
|
|
|
|
@staticmethod
|
|
def pager_pipe(text, cmd):
|
|
''' pipe text through a pager '''
|
|
if 'LESS' not in os.environ:
|
|
os.environ['LESS'] = CLI.LESS_OPTS
|
|
try:
|
|
cmd = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=sys.stdout)
|
|
cmd.communicate(input=to_bytes(text))
|
|
except IOError:
|
|
pass
|
|
except KeyboardInterrupt:
|
|
pass
|
|
|
|
@classmethod
|
|
def tty_ify(cls, text):
|
|
|
|
t = cls._ITALIC.sub("`" + r"\1" + "'", text) # I(word) => `word'
|
|
t = cls._BOLD.sub("*" + r"\1" + "*", t) # B(word) => *word*
|
|
t = cls._MODULE.sub("[" + r"\1" + "]", t) # M(word) => [word]
|
|
t = cls._URL.sub(r"\1", t) # U(word) => word
|
|
t = cls._CONST.sub("`" + r"\1" + "'", t) # C(word) => `word'
|
|
|
|
return t
|
|
|
|
@staticmethod
|
|
def read_vault_password_file(vault_password_file, loader):
|
|
"""
|
|
Read a vault password from a file or if executable, execute the script and
|
|
retrieve password from STDOUT
|
|
"""
|
|
|
|
this_path = os.path.realpath(os.path.expanduser(vault_password_file))
|
|
if not os.path.exists(this_path):
|
|
raise AnsibleError("The vault password file %s was not found" % this_path)
|
|
|
|
if loader.is_executable(this_path):
|
|
try:
|
|
# STDERR not captured to make it easier for users to prompt for input in their scripts
|
|
p = subprocess.Popen(this_path, stdout=subprocess.PIPE)
|
|
except OSError as e:
|
|
raise AnsibleError("Problem running vault password script %s (%s). If this is not a script, remove the executable bit from the file." % (' '.join(this_path), e))
|
|
stdout, stderr = p.communicate()
|
|
if p.returncode != 0:
|
|
raise AnsibleError("Vault password script %s returned non-zero (%s): %s" % (this_path, p.returncode, p.stderr))
|
|
vault_pass = stdout.strip(b'\r\n')
|
|
else:
|
|
try:
|
|
f = open(this_path, "rb")
|
|
vault_pass=f.read().strip()
|
|
f.close()
|
|
except (OSError, IOError) as e:
|
|
raise AnsibleError("Could not read vault password file %s: %s" % (this_path, e))
|
|
|
|
return vault_pass
|
|
|
|
def get_opt(self, k, defval=""):
|
|
"""
|
|
Returns an option from an Optparse values instance.
|
|
"""
|
|
try:
|
|
data = getattr(self.options, k)
|
|
except:
|
|
return defval
|
|
# FIXME: Can this be removed if cli and/or constants ensures it's a
|
|
# list?
|
|
if k == "roles_path":
|
|
if os.pathsep in data:
|
|
data = data.split(os.pathsep)[0]
|
|
return data
|