diff --git a/bin/ansible b/bin/ansible index a0464c142af..3d4cb07ad96 100755 --- a/bin/ansible +++ b/bin/ansible @@ -67,14 +67,6 @@ class Cli(object): 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") - return (options, args) # ---------------------------------------------- @@ -104,46 +96,31 @@ class Cli(object): sshpass = None sudopass = None - su_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 - (sshpass, sudopass, su_pass) = utils.ask_passwords(ask_pass=options.ask_pass, ask_sudo_pass=options.ask_sudo_pass, ask_su_pass=options.ask_su_pass) - if options.su_user or options.ask_su_pass: - options.su = True - elif options.sudo_user or options.ask_sudo_pass: + (sshpass, sudopass) = utils.ask_passwords(ask_pass=options.ask_pass, ask_sudo_pass=options.ask_sudo_pass) + if options.sudo_user or options.ask_sudo_pass: options.sudo = True options.sudo_user = options.sudo_user or C.DEFAULT_SUDO_USER - options.su_user = options.su_user or C.DEFAULT_SU_USER if options.tree: utils.prepare_writeable_dir(options.tree) - runner = Runner( - module_name=options.module_name, - module_path=options.module_path, + module_name=options.module_name, module_path=options.module_path, module_args=options.module_args, - remote_user=options.remote_user, - remote_pass=sshpass, - inventory=inventory_manager, - timeout=options.timeout, + remote_user=options.remote_user, remote_pass=sshpass, + inventory=inventory_manager, timeout=options.timeout, private_key_file=options.private_key_file, forks=options.forks, pattern=pattern, - callbacks=self.callbacks, - sudo=options.sudo, - sudo_pass=sudopass, - sudo_user=options.sudo_user, - transport=options.connection, - subset=options.subset, + callbacks=self.callbacks, sudo=options.sudo, + sudo_pass=sudopass,sudo_user=options.sudo_user, + transport=options.connection, subset=options.subset, check=options.check, - diff=options.check, - su=options.su, - su_pass=su_pass, - su_user=options.su_user + diff=options.check ) if options.seconds: diff --git a/bin/ansible-playbook b/bin/ansible-playbook index 646b64a764f..c0db66993c5 100755 --- a/bin/ansible-playbook +++ b/bin/ansible-playbook @@ -83,13 +83,6 @@ def main(args): parser.print_help(file=sys.stderr) return 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") - inventory = ansible.inventory.Inventory(options.inventory) inventory.subset(options.subset) if len(inventory.list_hosts()) == 0: @@ -97,18 +90,14 @@ def main(args): sshpass = None sudopass = None - su_pass = None if not options.listhosts and not options.syntax and not options.listtasks: 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 - (sshpass, sudopass, su_pass) = utils.ask_passwords(ask_pass=options.ask_pass, ask_sudo_pass=options.ask_sudo_pass, ask_su_pass=options.ask_su_pass) + (sshpass, sudopass) = utils.ask_passwords(ask_pass=options.ask_pass, ask_sudo_pass=options.ask_sudo_pass) options.sudo_user = options.sudo_user or C.DEFAULT_SUDO_USER - options.su_user = options.su_user or C.DEFAULT_SU_USER - extra_vars = {} for extra_vars_opt in options.extra_vars: @@ -167,10 +156,7 @@ def main(args): only_tags=only_tags, skip_tags=skip_tags, check=options.check, - diff=options.diff, - su=options.su, - su_pass=su_pass, - su_user=options.su_user + diff=options.diff ) if options.listhosts or options.listtasks or options.syntax: diff --git a/lib/ansible/constants.py b/lib/ansible/constants.py index 2429aa4e929..bf9084ef992 100644 --- a/lib/ansible/constants.py +++ b/lib/ansible/constants.py @@ -127,11 +127,6 @@ DEFAULT_HASH_BEHAVIOUR = get_config(p, DEFAULTS, 'hash_behaviour', 'ANSIBLE_H DEFAULT_LEGACY_PLAYBOOK_VARIABLES = get_config(p, DEFAULTS, 'legacy_playbook_variables', 'ANSIBLE_LEGACY_PLAYBOOK_VARIABLES', True, boolean=True) DEFAULT_JINJA2_EXTENSIONS = get_config(p, DEFAULTS, 'jinja2_extensions', 'ANSIBLE_JINJA2_EXTENSIONS', None) DEFAULT_EXECUTABLE = get_config(p, DEFAULTS, 'executable', 'ANSIBLE_EXECUTABLE', '/bin/sh') -DEFAULT_SU_EXE = get_config(p, DEFAULTS, 'su_exe', 'ANSIBLE_SU_EXE', 'su') -DEFAULT_SU = get_config(p, DEFAULTS, 'su', 'ANSIBLE_SU', False, boolean=True) -DEFAULT_SU_FLAGS = get_config(p, DEFAULTS, 'su_flags', 'ANSIBLE_SU_FLAGS', '') -DEFAULT_SU_USER = get_config(p, DEFAULTS, 'su_user', 'ANSIBLE_SU_USER', 'root') -DEFAULT_ASK_SU_PASS = get_config(p, DEFAULTS, 'ask_su_pass', 'ANSIBLE_ASK_SU_PASS', False, boolean=True) DEFAULT_ACTION_PLUGIN_PATH = get_config(p, DEFAULTS, 'action_plugins', 'ANSIBLE_ACTION_PLUGINS', '/usr/share/ansible_plugins/action_plugins') DEFAULT_CALLBACK_PLUGIN_PATH = get_config(p, DEFAULTS, 'callback_plugins', 'ANSIBLE_CALLBACK_PLUGINS', '/usr/share/ansible_plugins/callback_plugins') @@ -166,5 +161,4 @@ DEFAULT_PASSWORD_CHARS = ascii_letters + digits + ".,:-_" DEFAULT_SUDO_PASS = None DEFAULT_REMOTE_PASS = None DEFAULT_SUBSET = None -DEFAULT_SU_PASS = None diff --git a/lib/ansible/playbook/__init__.py b/lib/ansible/playbook/__init__.py index c33b290b81e..dc7991aaf74 100644 --- a/lib/ansible/playbook/__init__.py +++ b/lib/ansible/playbook/__init__.py @@ -68,11 +68,7 @@ class PlayBook(object): inventory = None, check = False, diff = False, - any_errors_fatal = False, - su = False, - su_user = False, - su_pass = False, - ): + any_errors_fatal = False): """ playbook: path to a playbook file @@ -126,9 +122,6 @@ class PlayBook(object): self.only_tags = only_tags self.skip_tags = skip_tags self.any_errors_fatal = any_errors_fatal - self.su = su - self.su_user = su_user - self.su_pass = su_pass self.callbacks.playbook = self self.runner_callbacks.playbook = self @@ -310,39 +303,20 @@ class PlayBook(object): self.inventory.restrict_to(hosts) runner = ansible.runner.Runner( - pattern=task.play.hosts, - inventory=self.inventory, - module_name=task.module_name, - module_args=task.module_args, - forks=self.forks, - remote_pass=self.remote_pass, - module_path=self.module_path, - timeout=self.timeout, - remote_user=task.remote_user, - remote_port=task.play.remote_port, - module_vars=task.module_vars, - default_vars=task.default_vars, - private_key_file=self.private_key_file, - setup_cache=self.SETUP_CACHE, - basedir=task.play.basedir, - conditional=task.when, - callbacks=self.runner_callbacks, - sudo=task.sudo, - sudo_user=task.sudo_user, - transport=task.transport, - sudo_pass=task.sudo_pass, - is_playbook=True, - check=self.check, - diff=self.diff, - environment=task.environment, - complex_args=task.args, - accelerate=task.play.accelerate, - accelerate_port=task.play.accelerate_port, + pattern=task.play.hosts, inventory=self.inventory, module_name=task.module_name, + module_args=task.module_args, forks=self.forks, + remote_pass=self.remote_pass, module_path=self.module_path, + timeout=self.timeout, remote_user=task.remote_user, + remote_port=task.play.remote_port, module_vars=task.module_vars, + default_vars=task.default_vars, private_key_file=self.private_key_file, + setup_cache=self.SETUP_CACHE, basedir=task.play.basedir, + conditional=task.when, callbacks=self.runner_callbacks, + sudo=task.sudo, sudo_user=task.sudo_user, + transport=task.transport, sudo_pass=task.sudo_pass, is_playbook=True, + check=self.check, diff=self.diff, environment=task.environment, complex_args=task.args, + accelerate=task.play.accelerate, accelerate_port=task.play.accelerate_port, accelerate_ipv6=task.play.accelerate_ipv6, - error_on_undefined_vars=C.DEFAULT_UNDEFINED_VAR_BEHAVIOR, - su=task.su, - su_user=task.su_user, - su_pass=task.su_pass + error_on_undefined_vars=C.DEFAULT_UNDEFINED_VAR_BEHAVIOR ) if task.async_seconds == 0: @@ -472,30 +446,13 @@ class PlayBook(object): # push any variables down to the system setup_results = ansible.runner.Runner( - pattern=play.hosts, - module_name='setup', - module_args={}, - inventory=self.inventory, - forks=self.forks, - module_path=self.module_path, - timeout=self.timeout, - remote_user=play.remote_user, - remote_pass=self.remote_pass, - remote_port=play.remote_port, - private_key_file=self.private_key_file, - setup_cache=self.SETUP_CACHE, - callbacks=self.runner_callbacks, - sudo=play.sudo, - sudo_user=play.sudo_user, - transport=play.transport, - sudo_pass=self.sudo_pass, - is_playbook=True, - module_vars=play.vars, - default_vars=play.default_vars, - check=self.check, - diff=self.diff, - accelerate=play.accelerate, - accelerate_port=play.accelerate_port, + pattern=play.hosts, module_name='setup', module_args={}, inventory=self.inventory, + forks=self.forks, module_path=self.module_path, timeout=self.timeout, remote_user=play.remote_user, + remote_pass=self.remote_pass, remote_port=play.remote_port, private_key_file=self.private_key_file, + setup_cache=self.SETUP_CACHE, callbacks=self.runner_callbacks, sudo=play.sudo, sudo_user=play.sudo_user, + transport=play.transport, sudo_pass=self.sudo_pass, is_playbook=True, module_vars=play.vars, + default_vars=play.default_vars, check=self.check, diff=self.diff, + accelerate=play.accelerate, accelerate_port=play.accelerate_port, ).run() self.stats.compute(setup_results, setup=True) diff --git a/lib/ansible/playbook/play.py b/lib/ansible/playbook/play.py index a1651f5f3cc..92a40ba6ec0 100644 --- a/lib/ansible/playbook/play.py +++ b/lib/ansible/playbook/play.py @@ -34,7 +34,7 @@ class Play(object): 'handlers', 'remote_user', 'remote_port', 'included_roles', 'accelerate', 'accelerate_port', 'accelerate_ipv6', 'sudo', 'sudo_user', 'transport', 'playbook', 'tags', 'gather_facts', 'serial', '_ds', '_handlers', '_tasks', - 'basedir', 'any_errors_fatal', 'roles', 'max_fail_pct', 'su', 'su_user' + 'basedir', 'any_errors_fatal', 'roles', 'max_fail_pct' ] # to catch typos and so forth -- these are userland names @@ -43,8 +43,7 @@ class Play(object): 'hosts', 'name', 'vars', 'vars_prompt', 'vars_files', 'tasks', 'handlers', 'remote_user', 'user', 'port', 'include', 'accelerate', 'accelerate_port', 'accelerate_ipv6', 'sudo', 'sudo_user', 'connection', 'tags', 'gather_facts', 'serial', - 'any_errors_fatal', 'roles', 'pre_tasks', 'post_tasks', 'max_fail_percentage', - 'su', 'su_user' + 'any_errors_fatal', 'roles', 'pre_tasks', 'post_tasks', 'max_fail_percentage' ] # ************************************************* @@ -122,8 +121,6 @@ class Play(object): self.accelerate_port = ds.get('accelerate_port', None) self.accelerate_ipv6 = ds.get('accelerate_ipv6', False) self.max_fail_pct = int(ds.get('max_fail_percentage', 100)) - self.su = ds.get('su', self.playbook.su) - self.su_user = ds.get('su_user', self.playbook.su_user) load_vars = {} load_vars['playbook_dir'] = self.basedir @@ -435,8 +432,7 @@ class Play(object): # ************************************************* - def _load_tasks(self, tasks, vars=None, default_vars=None, sudo_vars=None, - additional_conditions=None, original_file=None, role_name=None): + def _load_tasks(self, tasks, vars=None, default_vars=None, sudo_vars=None, additional_conditions=None, original_file=None, role_name=None): ''' handle task and handler include statements ''' results = [] @@ -473,7 +469,7 @@ class Play(object): if 'meta' in x: if x['meta'] == 'flush_handlers': - results.append(Task(self, x)) + results.append(Task(self,x)) continue task_vars = self.vars.copy() @@ -541,13 +537,7 @@ class Play(object): loaded = self._load_tasks(data, mv, default_vars, included_sudo_vars, list(included_additional_conditions), original_file=include_filename, role_name=new_role) results += loaded elif type(x) == dict: - task = Task( - self, x, - module_vars=task_vars, - default_vars=default_vars, - additional_conditions=list(additional_conditions), - role_name=role_name - ) + task = Task(self,x,module_vars=task_vars,default_vars=default_vars,additional_conditions=list(additional_conditions),role_name=role_name) results.append(task) else: raise Exception("unexpected task type") diff --git a/lib/ansible/playbook/task.py b/lib/ansible/playbook/task.py index 0350ca2ac21..df496e11a80 100644 --- a/lib/ansible/playbook/task.py +++ b/lib/ansible/playbook/task.py @@ -30,8 +30,7 @@ class Task(object): 'delegate_to', 'first_available_file', 'ignore_errors', 'local_action', 'transport', 'sudo', 'remote_user', 'sudo_user', 'sudo_pass', 'items_lookup_plugin', 'items_lookup_terms', 'environment', 'args', - 'any_errors_fatal', 'changed_when', 'failed_when', 'always_run', 'delay', 'retries', 'until', - 'su', 'su_user', 'su_pass' + 'any_errors_fatal', 'changed_when', 'failed_when', 'always_run', 'delay', 'retries', 'until' ] # to prevent typos and such @@ -40,8 +39,7 @@ class Task(object): 'first_available_file', 'include', 'tags', 'register', 'ignore_errors', 'delegate_to', 'local_action', 'transport', 'remote_user', 'sudo', 'sudo_user', 'sudo_pass', 'when', 'connection', 'environment', 'args', - 'any_errors_fatal', 'changed_when', 'failed_when', 'always_run', 'delay', 'retries', 'until', - 'su', 'su_user', 'su_pass' + 'any_errors_fatal', 'changed_when', 'failed_when', 'always_run', 'delay', 'retries', 'until' ] def __init__(self, play, ds, module_vars=None, default_vars=None, additional_conditions=None, role_name=None): @@ -119,7 +117,6 @@ class Task(object): self.tags = [ 'all' ] self.register = ds.get('register', None) self.sudo = utils.boolean(ds.get('sudo', play.sudo)) - self.su = utils.boolean(ds.get('sudo', play.su)) self.environment = ds.get('environment', {}) self.role_name = role_name @@ -145,18 +142,13 @@ class Task(object): else: self.remote_user = ds.get('remote_user', play.playbook.remote_user) - self.sudo_user = None - self.sudo_pass = None - self.su_user = None - self.su_pass = None - if self.sudo: self.sudo_user = ds.get('sudo_user', play.sudo_user) self.sudo_pass = ds.get('sudo_pass', play.playbook.sudo_pass) - elif self.su: - self.su_user = ds.get('su_user', play.su_user) - self.su_pass = ds.get('su_pass', play.playbook.su_pass) - + else: + self.sudo_user = None + self.sudo_pass = None + # Both are defined if ('action' in ds) and ('local_action' in ds): raise errors.AnsibleError("the 'action' and 'local_action' attributes can not be used together") diff --git a/lib/ansible/runner/__init__.py b/lib/ansible/runner/__init__.py index 3108bc5e302..ef8d4aac211 100644 --- a/lib/ansible/runner/__init__.py +++ b/lib/ansible/runner/__init__.py @@ -141,9 +141,6 @@ class Runner(object): accelerate=False, # use accelerated connection accelerate_ipv6=False, # accelerated connection w/ IPv6 accelerate_port=None, # port to use with accelerated connection - su=False, # Are we running our command via su? - su_user=None, # User to su to when running command, ex: 'root' - su_pass=C.DEFAULT_SU_PASS ): # used to lock multiprocess inputs and outputs at various levels @@ -191,9 +188,6 @@ class Runner(object): self.accelerate_ipv6 = accelerate_ipv6 self.callbacks.runner = self self.original_transport = self.transport - self.su = su - self.su_user = su_user - self.su_pass = su_pass if self.transport == 'smart': # if the transport is 'smart' see if SSH can support ControlPersist if not use paramiko @@ -317,13 +311,12 @@ class Runner(object): or async_jid is not None or not conn.has_pipelining or not C.ANSIBLE_SSH_PIPELINING - or C.DEFAULT_KEEP_REMOTE_FILES - or self.su): + or C.DEFAULT_KEEP_REMOTE_FILES): self._transfer_str(conn, tmp, module_name, module_data) environment_string = self._compute_environment_string(inject) - if (self.sudo or self.su) and (self.sudo_user != 'root' or self.su_user != 'root'): + if tmp.find("tmp") != -1 and self.sudo and self.sudo_user != 'root': # deal with possible umask issues once sudo'ed to other user cmd_chmod = "chmod a+r %s" % remote_module_path self._low_level_exec_command(conn, cmd_chmod, tmp, sudoable=False) @@ -350,7 +343,7 @@ class Runner(object): else: argsfile = self._transfer_str(conn, tmp, 'arguments', args) - if (self.sudo or self.su) and (self.sudo_user != 'root' or self.su_user != 'root'): + if self.sudo and self.sudo_user != 'root': # deal with possible umask issues once sudo'ed to other user cmd_args_chmod = "chmod a+r %s" % argsfile self._low_level_exec_command(conn, cmd_args_chmod, tmp, sudoable=False) @@ -361,7 +354,7 @@ class Runner(object): cmd = " ".join([str(x) for x in [remote_module_path, async_jid, async_limit, async_module, argsfile]]) else: if async_jid is None: - if conn.has_pipelining and C.ANSIBLE_SSH_PIPELINING and not C.DEFAULT_KEEP_REMOTE_FILES and not self.su: + if conn.has_pipelining and C.ANSIBLE_SSH_PIPELINING and not C.DEFAULT_KEEP_REMOTE_FILES: in_data = module_data else: cmd = "%s" % (remote_module_path) @@ -376,7 +369,7 @@ class Runner(object): cmd = cmd.strip() if tmp.find("tmp") != -1 and not C.DEFAULT_KEEP_REMOTE_FILES and not persist_files: - if not self.sudo or self.su or self.sudo_user == 'root' or self.su_user == 'root': + if not self.sudo or self.sudo_user == 'root': # not sudoing or sudoing to root, so can cleanup files in the same step cmd = cmd + "; rm -rf %s >/dev/null 2>&1" % tmp @@ -386,13 +379,10 @@ class Runner(object): # specified in the play, not the sudo_user sudoable = False - if self.su: - res = self._low_level_exec_command(conn, cmd, tmp, su=sudoable, in_data=in_data) - else: - res = self._low_level_exec_command(conn, cmd, tmp, sudoable=sudoable, in_data=in_data) + res = self._low_level_exec_command(conn, cmd, tmp, sudoable=sudoable, in_data=in_data) if tmp.find("tmp") != -1 and not C.DEFAULT_KEEP_REMOTE_FILES and not persist_files: - if (self.sudo or self.su) and (self.sudo_user != 'root' or self.su_user != 'root'): + if self.sudo and self.sudo_user != 'root': # not sudoing to root, so maybe can't delete files as that other user # have to clean up temp files as original user in a second step cmd2 = "rm -rf %s >/dev/null 2>&1" % tmp @@ -623,9 +613,6 @@ class Runner(object): actual_transport = inject.get('ansible_connection', self.transport) actual_private_key_file = inject.get('ansible_ssh_private_key_file', self.private_key_file) self.sudo_pass = inject.get('ansible_sudo_pass', self.sudo_pass) - self.su = inject.get('ansible_su', self.su_pass) - self.su_user = inject.get('ansible_su_user', self.su_user) - self.su_pass = inject.get('ansible_su_pass', self.su_pass) if actual_private_key_file is not None: actual_private_key_file = os.path.expanduser(actual_private_key_file) @@ -811,10 +798,7 @@ class Runner(object): if tmp.find("tmp") != -1: # tmp has already been created return False - if not conn.has_pipelining or not C.ANSIBLE_SSH_PIPELINING or C.DEFAULT_KEEP_REMOTE_FILES or self.su: - # tmp is necessary to store module source code - return True - if not conn.has_pipelining: + if not conn.has_pipelining or not C.ANSIBLE_SSH_PIPELINING or C.DEFAULT_KEEP_REMOTE_FILES: # tmp is necessary to store the module source code # or we want to keep the files on the target system return True @@ -826,36 +810,20 @@ class Runner(object): # ***************************************************** - def _low_level_exec_command(self, conn, cmd, tmp, sudoable=False, - executable=None, su=False, in_data=None): + def _low_level_exec_command(self, conn, cmd, tmp, sudoable=False, executable=None, in_data=None): ''' execute a command string over SSH, return the output ''' if executable is None: executable = C.DEFAULT_EXECUTABLE sudo_user = self.sudo_user - su_user = self.su_user # compare connection user to sudo_user and disable if the same if hasattr(conn, 'user'): - if conn.user == sudo_user or conn.user == su_user: + if conn.user == sudo_user: sudoable = False - su = False - - if su: - rc, stdin, stdout, stderr = conn.exec_command(cmd, - tmp, - su_user=su_user, - su=su, - executable=executable, - in_data=in_data) - else: - rc, stdin, stdout, stderr = conn.exec_command(cmd, - tmp, - sudo_user, - sudoable=sudoable, - executable=executable, - in_data=in_data) + + rc, stdin, stdout, stderr = conn.exec_command(cmd, tmp, sudo_user, sudoable=sudoable, executable=executable, in_data=in_data) if type(stdout) not in [ str, unicode ]: out = ''.join(stdout.readlines()) @@ -913,11 +881,11 @@ class Runner(object): basefile = 'ansible-tmp-%s-%s' % (time.time(), random.randint(0, 2**48)) basetmp = os.path.join(C.DEFAULT_REMOTE_TMP, basefile) - if (self.sudo or self.su) and (self.sudo_user != 'root' or self.su != 'root') and basetmp.startswith('$HOME'): + if self.sudo and self.sudo_user != 'root' and basetmp.startswith('$HOME'): basetmp = os.path.join('/tmp', basefile) cmd = 'mkdir -p %s' % basetmp - if self.remote_user != 'root' or ((self.sudo or self.su) and (self.sudo_user != 'root' or self.su != 'root')): + if self.remote_user != 'root' or (self.sudo and self.sudo_user != 'root'): cmd += ' && chmod a+rx %s' % basetmp cmd += ' && echo %s' % basetmp diff --git a/lib/ansible/runner/connection_plugins/accelerate.py b/lib/ansible/runner/connection_plugins/accelerate.py index 17cc99c1d77..d260a634379 100644 --- a/lib/ansible/runner/connection_plugins/accelerate.py +++ b/lib/ansible/runner/connection_plugins/accelerate.py @@ -159,12 +159,9 @@ class Connection(object): except socket.timeout: raise errors.AnsibleError("timed out while waiting to receive data") - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable='/bin/sh', in_data=None, su=None, su_user=None): + def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the remote host ''' - if su or su_user: - raise errors.AnsibleError("Internal Error: this module does not support running commands via su") - if in_data: raise errors.AnsibleError("Internal Error: this module does not support optimized module pipelining") diff --git a/lib/ansible/runner/connection_plugins/chroot.py b/lib/ansible/runner/connection_plugins/chroot.py index 38c8af7a690..1080ea54b57 100644 --- a/lib/ansible/runner/connection_plugins/chroot.py +++ b/lib/ansible/runner/connection_plugins/chroot.py @@ -60,12 +60,9 @@ class Connection(object): return self - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable='/bin/sh', in_data=None, su=None, su_user=None): + def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the chroot ''' - if su or su_user: - raise errors.AnsibleError("Internal Error: this module does not support running commands via su") - if in_data: raise errors.AnsibleError("Internal Error: this module does not support optimized module pipelining") diff --git a/lib/ansible/runner/connection_plugins/fireball.py b/lib/ansible/runner/connection_plugins/fireball.py index dd9e09bacda..40848edead4 100644 --- a/lib/ansible/runner/connection_plugins/fireball.py +++ b/lib/ansible/runner/connection_plugins/fireball.py @@ -68,7 +68,7 @@ class Connection(object): return self - def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, executable='/bin/sh', in_data=None, su_user=None, su=None): + def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the remote host ''' if in_data: @@ -76,9 +76,9 @@ class Connection(object): vvv("EXEC COMMAND %s" % cmd) - if (self.runner.sudo and sudoable) or (self.runner.su and su): + if self.runner.sudo and sudoable: raise errors.AnsibleError( - "When using fireball, do not specify sudo or su to run your tasks. " + + "When using fireball, do not specify sudo to run your tasks. " + "Instead sudo the fireball action with sudo. " + "Task will communicate with the fireball already running in sudo mode." ) diff --git a/lib/ansible/runner/connection_plugins/funcd.py b/lib/ansible/runner/connection_plugins/funcd.py index 7244abcbe9a..a5dc631ef89 100644 --- a/lib/ansible/runner/connection_plugins/funcd.py +++ b/lib/ansible/runner/connection_plugins/funcd.py @@ -53,13 +53,10 @@ class Connection(object): self.client = fc.Client(self.host) return self - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, - executable='/bin/sh', in_data=None, su=None, su_user=None): + def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, + executable='/bin/sh', in_data=None): ''' run a command on the remote minion ''' - if su or su_user: - raise errors.AnsibleError("Internal Error: this module does not support running commands via su") - if in_data: raise errors.AnsibleError("Internal Error: this module does not support optimized module pipelining") diff --git a/lib/ansible/runner/connection_plugins/jail.py b/lib/ansible/runner/connection_plugins/jail.py index b721ad62b50..89b13bbc445 100644 --- a/lib/ansible/runner/connection_plugins/jail.py +++ b/lib/ansible/runner/connection_plugins/jail.py @@ -91,12 +91,9 @@ class Connection(object): local_cmd = '%s "%s" %s' % (self.jexec_cmd, self.jail, cmd) return local_cmd - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable='/bin/sh', in_data=None, su=None, su_user=None): + def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the chroot ''' - if su or su_user: - raise errors.AnsibleError("Internal Error: this module does not support running commands via su") - if in_data: raise errors.AnsibleError("Internal Error: this module does not support optimized module pipelining") diff --git a/lib/ansible/runner/connection_plugins/local.py b/lib/ansible/runner/connection_plugins/local.py index a752a6a2627..0cf7da42be6 100644 --- a/lib/ansible/runner/connection_plugins/local.py +++ b/lib/ansible/runner/connection_plugins/local.py @@ -41,13 +41,9 @@ class Connection(object): return self - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable='/bin/sh', in_data=None, su=None, su_user=None): + def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the local host ''' - # su requires to be run from a terminal, and therefore isn't supported here (yet?) - if su or su_user: - raise errors.AnsibleError("Internal Error: this module does not support running commands via su") - if in_data: raise errors.AnsibleError("Internal Error: this module does not support optimized module pipelining") diff --git a/lib/ansible/runner/connection_plugins/paramiko_ssh.py b/lib/ansible/runner/connection_plugins/paramiko_ssh.py index 29580bbba07..667e03c0e88 100644 --- a/lib/ansible/runner/connection_plugins/paramiko_ssh.py +++ b/lib/ansible/runner/connection_plugins/paramiko_ssh.py @@ -176,7 +176,7 @@ class Connection(object): return ssh - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable='/bin/sh', in_data=None, su=None, su_user=None): + def exec_command(self, cmd, tmp_path, sudo_user, sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the remote host ''' if in_data: @@ -191,7 +191,7 @@ class Connection(object): msg += ": %s" % str(e) raise errors.AnsibleConnectionFailed(msg) - if not (self.runner.sudo and sudo) and not (self.runner.su and su): + if not self.runner.sudo or not sudoable: if executable: quoted_command = executable + ' -c ' + pipes.quote(cmd) else: @@ -206,15 +206,12 @@ class Connection(object): chan.get_pty(term=os.getenv('TERM', 'vt100'), width=int(os.getenv('COLUMNS', 0)), height=int(os.getenv('LINES', 0))) - if self.runner.sudo or sudoable: - shcmd, prompt, success_key = utils.make_sudo_cmd(sudo_user, executable, cmd) - elif self.runner.su or su: - shcmd, prompt, success_key = utils.make_su_cmd(su_user, executable, cmd) + shcmd, prompt, success_key = utils.make_sudo_cmd(sudo_user, executable, cmd) vvv("EXEC %s" % shcmd, host=self.host) sudo_output = '' try: chan.exec_command(shcmd) - if self.runner.sudo_pass or self.runner.su_pass: + if self.runner.sudo_pass: while not sudo_output.endswith(prompt) and success_key not in sudo_output: chunk = chan.recv(bufsize) if not chunk: @@ -226,10 +223,7 @@ class Connection(object): 'closed waiting for password prompt') sudo_output += chunk if success_key not in sudo_output: - if sudoable: - chan.sendall(self.runner.sudo_pass + '\n') - elif su: - chan.sendall(self.runner.su_pass + '\n') + chan.sendall(self.runner.sudo_pass + '\n') except socket.timeout: raise errors.AnsibleError('ssh timed out waiting for sudo.\n' + sudo_output) diff --git a/lib/ansible/runner/connection_plugins/ssh.py b/lib/ansible/runner/connection_plugins/ssh.py index 3df297adc4e..d987d609a88 100644 --- a/lib/ansible/runner/connection_plugins/ssh.py +++ b/lib/ansible/runner/connection_plugins/ssh.py @@ -145,7 +145,7 @@ class Connection(object): return False return True - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable='/bin/sh', in_data=None, su_user=None, su=False): + def exec_command(self, cmd, tmp_path, sudo_user,sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the remote host ''' ssh_cmd = self._password_cmd() @@ -165,10 +165,7 @@ class Connection(object): ssh_cmd += ['-6'] ssh_cmd += [self.host] - if su and su_user: - sudocmd, prompt, success_key = utils.make_su_cmd(su_user, executable, cmd) - ssh_cmd.append(sudocmd) - elif not self.runner.sudo or not sudoable: + if not self.runner.sudo or not sudoable: if executable: ssh_cmd.append(executable + ' -c ' + pipes.quote(cmd)) else: @@ -186,7 +183,7 @@ class Connection(object): # the host to known hosts is not intermingled with multiprocess output. fcntl.lockf(self.runner.process_lockfile, fcntl.LOCK_EX) fcntl.lockf(self.runner.output_lockfile, fcntl.LOCK_EX) - + # create process if in_data: # do not use pseudo-pty @@ -209,8 +206,7 @@ class Connection(object): self._send_password() - if (self.runner.sudo and sudoable and self.runner.sudo_pass) or \ - (self.runner.su and su and self.runner.su_pass): + if self.runner.sudo and sudoable and self.runner.sudo_pass: # several cases are handled for sudo privileges with password # * NOPASSWD (tty & no-tty): detect success_key on stdout # * without NOPASSWD: @@ -229,7 +225,7 @@ class Connection(object): if p.stderr in rfd: chunk = p.stderr.read() if not chunk: - raise errors.AnsibleError('ssh connection closed waiting for sudo or su password prompt') + raise errors.AnsibleError('ssh connection closed waiting for sudo password prompt') sudo_errput += chunk incorrect_password = gettext.dgettext( "sudo", "Sorry, try again.") @@ -241,19 +237,16 @@ class Connection(object): if p.stdout in rfd: chunk = p.stdout.read() if not chunk: - raise errors.AnsibleError('ssh connection closed waiting for sudo or su password prompt') + raise errors.AnsibleError('ssh connection closed waiting for sudo password prompt') sudo_output += chunk if not rfd: # timeout. wrap up process communication stdout = p.communicate() - raise errors.AnsibleError('ssh connection error waiting for sudo or su password prompt') + raise errors.AnsibleError('ssh connection error waiting for sudo password prompt') if success_key not in sudo_output: - if sudoable: - stdin.write(self.runner.sudo_pass + '\n') - elif su: - stdin.write(self.runner.su_pass + '\n') + stdin.write(self.runner.sudo_pass + '\n') fcntl.fcntl(p.stdout, fcntl.F_SETFL, fcntl.fcntl(p.stdout, fcntl.F_GETFL) & ~os.O_NONBLOCK) fcntl.fcntl(p.stderr, fcntl.F_SETFL, fcntl.fcntl(p.stderr, fcntl.F_GETFL) & ~os.O_NONBLOCK) # We can't use p.communicate here because the ControlMaster may have stdout open as well @@ -269,18 +262,12 @@ class Connection(object): while True: rfd, wfd, efd = select.select(rpipes, [], rpipes, 1) - # fail early if the sudo/su password is wrong + # fail early if the sudo password is wrong if self.runner.sudo and sudoable and self.runner.sudo_pass: incorrect_password = gettext.dgettext( "sudo", "Sorry, try again.") if stdout.endswith("%s\r\n%s" % (incorrect_password, prompt)): - raise errors.AnsibleError('Incorrect sudo password') - - if self.runner.su and su and self.runner.sudo_pass: - incorrect_password = gettext.dgettext( - "su", "Sorry") - if stdout.endswith("%s\r\n%s" % (incorrect_password, prompt)): - raise errors.AnsibleError('Incorrect su password') + raise errors.AnsibleError('Incorrect sudo password') if p.stdout in rfd: dat = os.read(p.stdout.fileno(), 9000) diff --git a/lib/ansible/runner/connection_plugins/ssh_old.py b/lib/ansible/runner/connection_plugins/ssh_old.py index db4fc24fcc6..ea0857d4061 100644 --- a/lib/ansible/runner/connection_plugins/ssh_old.py +++ b/lib/ansible/runner/connection_plugins/ssh_old.py @@ -145,7 +145,7 @@ class Connection(object): return False return True - def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable='/bin/sh', in_data=None, su=False, su_user=None): + def exec_command(self, cmd, tmp_path, sudo_user,sudoable=False, executable='/bin/sh', in_data=None): ''' run a command on the remote host ''' if in_data: @@ -163,10 +163,7 @@ class Connection(object): ssh_cmd += ['-6'] ssh_cmd += [self.host] - if su and su_user: - sudocmd, prompt, success_key = utils.make_su_cmd(su_user, executable, cmd) - ssh_cmd.append(sudocmd) - elif not self.runner.sudo or not sudoable: + if not self.runner.sudo or not sudoable: if executable: ssh_cmd.append(executable + ' -c ' + pipes.quote(cmd)) else: @@ -186,6 +183,7 @@ class Connection(object): fcntl.lockf(self.runner.output_lockfile, fcntl.LOCK_EX) + try: # Make sure stdin is a proper (pseudo) pty to avoid: tcgetattr errors master, slave = pty.openpty() @@ -200,8 +198,7 @@ class Connection(object): self._send_password() - if (self.runner.sudo and sudoable and self.runner.sudo_pass) or \ - (self.runner.su and su and self.runner.su_pass): + if self.runner.sudo and sudoable and self.runner.sudo_pass: fcntl.fcntl(p.stdout, fcntl.F_SETFL, fcntl.fcntl(p.stdout, fcntl.F_GETFL) | os.O_NONBLOCK) sudo_output = '' @@ -211,17 +208,13 @@ class Connection(object): if p.stdout in rfd: chunk = p.stdout.read() if not chunk: - raise errors.AnsibleError('ssh connection closed waiting for sudo or su password prompt') + raise errors.AnsibleError('ssh connection closed waiting for sudo password prompt') sudo_output += chunk else: stdout = p.communicate() - raise errors.AnsibleError('ssh connection error waiting for sudo or su password prompt') - + raise errors.AnsibleError('ssh connection error waiting for sudo password prompt') if success_key not in sudo_output: - if sudoable: - stdin.write(self.runner.sudo_pass + '\n') - elif su: - stdin.write(self.runner.su_pass + '\n') + stdin.write(self.runner.sudo_pass + '\n') fcntl.fcntl(p.stdout, fcntl.F_SETFL, fcntl.fcntl(p.stdout, fcntl.F_GETFL) & ~os.O_NONBLOCK) # We can't use p.communicate here because the ControlMaster may have stdout open as well @@ -231,18 +224,12 @@ class Connection(object): while True: rfd, wfd, efd = select.select(rpipes, [], rpipes, 1) - # fail early if the sudo/su password is wrong + # fail early if the sudo password is wrong if self.runner.sudo and sudoable and self.runner.sudo_pass: incorrect_password = gettext.dgettext( "sudo", "Sorry, try again.") if stdout.endswith("%s\r\n%s" % (incorrect_password, prompt)): - raise errors.AnsibleError('Incorrect sudo password') - - if self.runner.su and su and self.runner.su_pass: - incorrect_password = gettext.dgettext( - "su", "su: Authentication failure") - if stdout.endswith("%s\r\n%s" % (incorrect_password, prompt)): - raise errors.AnsibleError('Incorrect su password') + raise errors.AnsibleError('Incorrect sudo password') if p.stdout in rfd: dat = os.read(p.stdout.fileno(), 9000) diff --git a/lib/ansible/utils/__init__.py b/lib/ansible/utils/__init__.py index ec540f6ecd8..a263ed15ff0 100644 --- a/lib/ansible/utils/__init__.py +++ b/lib/ansible/utils/__init__.py @@ -645,8 +645,6 @@ def base_parser(constants=C, usage="", output_opts=False, runas_opts=False, help='use this file to authenticate the connection') parser.add_option('-K', '--ask-sudo-pass', default=False, dest='ask_sudo_pass', action='store_true', help='ask for sudo password') - parser.add_option('--ask-su-pass', default=False, dest='ask_su_pass', - action='store_true', help='ask for su password') 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('-M', '--module-path', dest='module_path', @@ -670,15 +668,11 @@ def base_parser(constants=C, usage="", output_opts=False, runas_opts=False, if runas_opts: parser.add_option("-s", "--sudo", default=constants.DEFAULT_SUDO, action="store_true", dest='sudo', help="run operations with sudo (nopasswd)") - parser.add_option('-U', '--sudo-user', dest='sudo_user', default=None, - help='desired sudo user (default=root)') # Can't default to root because we need to detect when this option was given + parser.add_option('-U', '--sudo-user', dest='sudo_user', help='desired sudo user (default=root)', + default=None) # Can't default to root because we need to detect when this option was given parser.add_option('-u', '--user', default=constants.DEFAULT_REMOTE_USER, - dest='remote_user', help='connect as this user (default=%s)' % constants.DEFAULT_REMOTE_USER) - - parser.add_option('-S', '--su', default=constants.DEFAULT_SU, - action='store_true', help='run operations with su') - parser.add_option('-R', '--su-user', help='run operations with su as this ' - 'user (default=%s)' % constants.DEFAULT_SU_USER) + dest='remote_user', + help='connect as this user (default=%s)' % constants.DEFAULT_REMOTE_USER) if connect_opts: parser.add_option('-c', '--connection', dest='connection', @@ -705,12 +699,10 @@ def base_parser(constants=C, usage="", output_opts=False, runas_opts=False, return parser -def ask_passwords(ask_pass=False, ask_sudo_pass=False, ask_su_pass=False): +def ask_passwords(ask_pass=False, ask_sudo_pass=False): sshpass = None sudopass = None - su_pass = None sudo_prompt = "sudo password: " - su_prompt = "su password: " if ask_pass: sshpass = getpass.getpass(prompt="SSH password: ") @@ -721,10 +713,7 @@ def ask_passwords(ask_pass=False, ask_sudo_pass=False, ask_su_pass=False): if ask_pass and sudopass == '': sudopass = sshpass - if ask_su_pass: - su_pass = getpass.getpass(prompt=su_prompt) - - return (sshpass, sudopass, su_pass) + return (sshpass, sudopass) def do_encrypt(result, encrypt, salt_size=None, salt=None): if PASSLIB_AVAILABLE: @@ -797,21 +786,6 @@ def make_sudo_cmd(sudo_user, executable, cmd): prompt, sudo_user, executable or '$SHELL', pipes.quote('echo %s; %s' % (success_key, cmd))) return ('/bin/sh -c ' + pipes.quote(sudocmd), prompt, success_key) - -def make_su_cmd(su_user, executable, cmd): - """ - Helper function for connection plugins to create direct su commands - """ - # TODO: work on this function - randbits = ''.join(chr(random.randint(ord('a'), ord('z'))) for x in xrange(32)) - prompt = 'assword: ' - success_key = 'SUDO-SUCCESS-%s' % randbits - sudocmd = '%s %s %s %s -c %s' % ( - C.DEFAULT_SU_EXE, C.DEFAULT_SU_FLAGS, su_user, executable or '$SHELL', - pipes.quote('echo %s; %s' % (success_key, cmd)) - ) - return ('/bin/sh -c ' + pipes.quote(sudocmd), prompt, success_key) - _TO_UNICODE_TYPES = (unicode, type(None)) def to_unicode(value):