# Buggy code
def _run(
    cmd,
    cwd=None,
    stdin=None,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    output_loglevel="debug",
    log_callback=None,
    runas=None,
    shell=DEFAULT_SHELL,
    python_shell=False,
    env=None,
    clean_env=False,
    rstrip=True,
    template=None,
    umask=None,
    timeout=None,
    with_communicate=True,
    reset_system_locale=True,
    ignore_retcode=False,
    saltenv="base",
    pillarenv=None,
    pillar_override=None,
    use_vt=False,
    password=None,
    bg=False,
    encoded_cmd=False,
    **kwargs,
):
    """
    Do the DRY thing and only call subprocess.Popen() once
    """
    if "pillar" in kwargs and not pillar_override:
        pillar_override = kwargs["pillar"]
    if _is_valid_shell(shell) is False:
        log.warning(
            "Attempt to run a shell command with what may be an invalid shell! "
            "Check to ensure that the shell <{0}> is valid for this user.".format(shell)
        )

    log_callback = _check_cb(log_callback)

    if runas is None and "__context__" in globals():
        runas = __context__.get("runas")

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser("~{0}".format("" if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = "/"
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = "The shell {0} is not available".format(shell)
            raise CommandExecutionError(msg)
    if salt.utils.is_windows() and use_vt:  # Memozation so not much overhead
        raise CommandExecutionError("VT not available on windows")

    if shell.lower().strip() == "powershell":
        # Strip whitespace
        if isinstance(cmd, six.string_types):
            cmd = cmd.strip()

        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == "script":
            cmd = (
                "Powershell -NonInteractive -NoProfile -ExecutionPolicy Bypass -File "
                + cmd
            )
        elif encoded_cmd:
            cmd = "Powershell -NonInteractive -EncodedCommand {0}".format(cmd)
        else:
            cmd = 'Powershell -NonInteractive -NoProfile "{0}"'.format(
                cmd.replace('"', '\\"')
            )

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv, pillarenv, pillar_override)

    ret = {}

    # If the pub jid is here then this is a remote ex or salt call command and needs to be
    # checked if blacklisted
    if "__pub_jid" in kwargs:
        if not _check_avail(cmd):
            msg = 'This shell command is not permitted: "{0}"'.format(cmd)
            raise CommandExecutionError(msg)

    env = _parse_env(env)

    for bad_env_key in (x for x, y in six.iteritems(env) if y is None):
        log.error(
            "Environment variable '{0}' passed without a value. "
            "Setting value to an empty string".format(bad_env_key)
        )
        env[bad_env_key] = ""

    def _get_stripped(cmd):
        # Return stripped command string copies to improve logging.
        if isinstance(cmd, list):
            return [x.strip() if isinstance(x, str) else x for x in cmd]
        elif isinstance(cmd, str):
            return cmd.strip()
        else:
            return cmd

    if _check_loglevel(output_loglevel) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        msg = "Executing command {0}{1}{0} {2}in directory '{3}'{4}".format(
            "'" if not isinstance(cmd, list) else "",
            _get_stripped(cmd),
            "as user '{0}' ".format(runas) if runas else "",
            cwd,
            ". Executing command in the background, no output will be logged."
            if bg
            else "",
        )
        log.info(log_callback(msg))

    if runas and salt.utils.is_windows():
        if not password:
            msg = "password is a required argument for runas on Windows"
            raise CommandExecutionError(msg)

        if not HAS_WIN_RUNAS:
            msg = "missing salt/utils/win_runas.py"
            raise CommandExecutionError(msg)

        if not isinstance(cmd, list):
            cmd = salt.utils.shlex_split(cmd, posix=False)

        cmd = " ".join(cmd)

        return win_runas(cmd, runas, password, cwd)

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError("User '{0}' is not available".format(runas))
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = (
                "import sys, os, itertools; "
                'sys.stdout.write("\\0".join(itertools.chain(*os.environ.items())))'
            )
            if __grains__["os"] in ["MacOS", "Darwin"]:
                env_cmd = ("sudo", "-i", "-u", runas, "--", sys.executable)
            elif __grains__["os"] in ["FreeBSD"]:
                env_cmd = (
                    "su",
                    "-",
                    runas,
                    "-c",
                    "{0} -c {1}".format(shell, sys.executable),
                )
            elif __grains__["os_family"] in ["Solaris"]:
                env_cmd = ("su", "-", runas, "-c", sys.executable)
            elif __grains__["os_family"] in ["AIX"]:
                env_cmd = ("su", runas, "-c", sys.executable)
            else:
                env_cmd = ("su", "-s", shell, "-", runas, "-c", sys.executable)
            env_encoded = subprocess.Popen(
                env_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE
            ).communicate(py_code.encode(__salt_system_encoding__))[0]
            if six.PY2:
                import itertools

                env_runas = dict(itertools.izip(*[iter(env_encoded.split(b"\0"))] * 2))
            elif six.PY3:
                if isinstance(env_encoded, str):
                    env_encoded = env_encoded.encode(__salt_system_encoding__)
                env_runas = dict(list(zip(*[iter(env_encoded.split(b"\0"))] * 2)))
            env_runas.update(env)
            env = env_runas
            # Encode unicode kwargs to filesystem encoding to avoid a
            # UnicodeEncodeError when the subprocess is invoked.
            fse = sys.getfilesystemencoding()
            for key, val in six.iteritems(env):
                if isinstance(val, six.text_type):
                    env[key] = val.encode(fse)
        except ValueError:
            raise CommandExecutionError(
                "Environment could not be retrieved for User '{0}'".format(runas)
            )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault("LC_CTYPE", "C")
            env.setdefault("LC_NUMERIC", "C")
            env.setdefault("LC_TIME", "C")
            env.setdefault("LC_COLLATE", "C")
            env.setdefault("LC_MONETARY", "C")
            env.setdefault("LC_MESSAGES", "C")
            env.setdefault("LC_PAPER", "C")
            env.setdefault("LC_NAME", "C")
            env.setdefault("LC_ADDRESS", "C")
            env.setdefault("LC_TELEPHONE", "C")
            env.setdefault("LC_MEASUREMENT", "C")
            env.setdefault("LC_IDENTIFICATION", "C")
        else:
            # On Windows set the codepage to US English.
            if python_shell:
                cmd = "chcp 437 > nul & " + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    if python_shell is None:
        python_shell = False

    kwargs = {
        "cwd": cwd,
        "shell": python_shell,
        "env": run_env,
        "stdin": str(stdin) if stdin is not None else stdin,
        "stdout": stdout,
        "stderr": stderr,
        "with_communicate": with_communicate,
        "timeout": timeout,
        "bg": bg,
    }

    if umask is not None:
        _umask = str(umask).lstrip("0")

        if _umask == "":
            msg = "Zero umask is not allowed."
            raise CommandExecutionError(msg)

        try:
            _umask = int(_umask, 8)
        except ValueError:
            msg = "Invalid umask: '{0}'".format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs["preexec_fn"] = functools.partial(
            salt.utils.chugid_and_umask, runas, _umask
        )

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs["shell"] is True:
            kwargs["executable"] = shell
        kwargs["close_fds"] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            "Specified cwd '{0}' either not absolute or does not exist".format(cwd)
        )

    if python_shell is not True and not isinstance(cmd, list):
        posix = True
        if salt.utils.is_windows():
            posix = False
        cmd = salt.utils.shlex_split(cmd, posix=posix)
    if not use_vt:
        # This is where the magic happens
        try:
            proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
        except (OSError, IOError) as exc:
            raise CommandExecutionError(
                "Unable to run command '{0}' with the context '{1}', "
                "reason: {2}".format(cmd, kwargs, exc)
            )

        try:
            proc.run()
        except TimedProcTimeoutError as exc:
            ret["stdout"] = str(exc)
            ret["stderr"] = ""
            ret["retcode"] = None
            ret["pid"] = proc.process.pid
            # ok return code for timeouts?
            ret["retcode"] = 1
            return ret

        out, err = proc.stdout, proc.stderr
        if err is None:
            # Will happen if redirect_stderr is True, since stderr was sent to
            # stdout.
            err = ""

        if rstrip:
            if out is not None:
                out = salt.utils.to_str(out).rstrip()
            if err is not None:
                err = salt.utils.to_str(err).rstrip()
        ret["pid"] = proc.process.pid
        ret["retcode"] = proc.process.returncode
        ret["stdout"] = out
        ret["stderr"] = err
    else:
        to = ""
        if timeout:
            to = " (timeout: {0}s)".format(timeout)
        if _check_loglevel(output_loglevel) is not None:
            msg = "Running {0} in VT{1}".format(cmd, to)
            log.debug(log_callback(msg))
        stdout, stderr = "", ""
        now = time.time()
        if timeout:
            will_timeout = now + timeout
        else:
            will_timeout = -1
        try:
            proc = vt.Terminal(
                cmd,
                shell=True,
                log_stdout=True,
                log_stderr=True,
                cwd=cwd,
                preexec_fn=kwargs.get("preexec_fn", None),
                env=run_env,
                log_stdin_level=output_loglevel,
                log_stdout_level=output_loglevel,
                log_stderr_level=output_loglevel,
                stream_stdout=True,
                stream_stderr=True,
            )
            ret["pid"] = proc.pid
            while proc.has_unread_data:
                try:
                    try:
                        time.sleep(0.5)
                        try:
                            cstdout, cstderr = proc.recv()
                        except IOError:
                            cstdout, cstderr = "", ""
                        if cstdout:
                            stdout += cstdout
                        else:
                            cstdout = ""
                        if cstderr:
                            stderr += cstderr
                        else:
                            cstderr = ""
                        if timeout and (time.time() > will_timeout):
                            ret["stderr"] = ("SALT: Timeout after {0}s\n{1}").format(
                                timeout, stderr
                            )
                            ret["retcode"] = None
                            break
                    except KeyboardInterrupt:
                        ret["stderr"] = "SALT: User break\n{0}".format(stderr)
                        ret["retcode"] = 1
                        break
                except vt.TerminalException as exc:
                    log.error("VT: {0}".format(exc), exc_info_on_loglevel=logging.DEBUG)
                    ret = {"retcode": 1, "pid": "2"}
                    break
                # only set stdout on success as we already mangled in other
                # cases
                ret["stdout"] = stdout
                if not proc.isalive():
                    # Process terminated, i.e., not canceled by the user or by
                    # the timeout
                    ret["stderr"] = stderr
                    ret["retcode"] = proc.exitstatus
                ret["pid"] = proc.pid
        finally:
            proc.close(terminate=True, kill=True)
    try:
        if ignore_retcode:
            __context__["retcode"] = 0
        else:
            __context__["retcode"] = ret["retcode"]
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret


# Traceback (ValueError)
Function: cron.present
Result: False
Comment: An exception occurred in this state: Traceback (most recent call last):
File "/usr/lib/python3.6/site-packages/salt/state.py", line 1820, in call
**cdata['kwargs'])
File "/usr/lib/python3.6/site-packages/salt/loader.py", line 1724, in wrapper
return f(*args, **kwargs)
File "/usr/lib/python3.6/site-packages/salt/states/cron.py", line 335, in present
identifier=identifier)
File "/usr/lib/python3.6/site-packages/salt/modules/cron.py", line 461, in set_job
lst = list_tab(user)
File "/usr/lib/python3.6/site-packages/salt/modules/cron.py", line 293, in list_tab
data = raw_cron(user)
File "/usr/lib/python3.6/site-packages/salt/modules/cron.py", line 270, in raw_cron
python_shell=False).splitlines(True)
File "/usr/lib/python3.6/site-packages/salt/modules/cmdmod.py", line 1289, in run_stdout
**kwargs)
File "/usr/lib/python3.6/site-packages/salt/modules/cmdmod.py", line 540, in _run
proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
File "/usr/lib/python3.6/site-packages/salt/utils/timed_subprocess.py", line 41, in __init__
self.process = subprocess.Popen(args, **kwargs)
File "/usr/lib/python3.6/subprocess.py", line 707, in __init__
restore_signals, start_new_session)
File "/usr/lib/python3.6/subprocess.py", line 1251, in _execute_child
for dir in os.get_exec_path(env))
File "/usr/lib/python3.6/os.py", line 640, in get_exec_path
"env cannot contain 'PATH' and b'PATH' keys")
ValueError: env cannot contain 'PATH' and b'PATH' keys

# Fixed code
def _run(
    cmd,
    cwd=None,
    stdin=None,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    output_loglevel="debug",
    log_callback=None,
    runas=None,
    shell=DEFAULT_SHELL,
    python_shell=False,
    env=None,
    clean_env=False,
    rstrip=True,
    template=None,
    umask=None,
    timeout=None,
    with_communicate=True,
    reset_system_locale=True,
    ignore_retcode=False,
    saltenv="base",
    pillarenv=None,
    pillar_override=None,
    use_vt=False,
    password=None,
    bg=False,
    encoded_cmd=False,
    **kwargs,
):
    """
    Do the DRY thing and only call subprocess.Popen() once
    """
    if "pillar" in kwargs and not pillar_override:
        pillar_override = kwargs["pillar"]
    if _is_valid_shell(shell) is False:
        log.warning(
            "Attempt to run a shell command with what may be an invalid shell! "
            "Check to ensure that the shell <{0}> is valid for this user.".format(shell)
        )

    log_callback = _check_cb(log_callback)

    if runas is None and "__context__" in globals():
        runas = __context__.get("runas")

    # Set the default working directory to the home directory of the user
    # salt-minion is running as. Defaults to home directory of user under which
    # the minion is running.
    if not cwd:
        cwd = os.path.expanduser("~{0}".format("" if not runas else runas))

        # make sure we can access the cwd
        # when run from sudo or another environment where the euid is
        # changed ~ will expand to the home of the original uid and
        # the euid might not have access to it. See issue #1844
        if not os.access(cwd, os.R_OK):
            cwd = "/"
            if salt.utils.is_windows():
                cwd = os.tempnam()[:3]
    else:
        # Handle edge cases where numeric/other input is entered, and would be
        # yaml-ified into non-string types
        cwd = str(cwd)

    if not salt.utils.is_windows():
        if not os.path.isfile(shell) or not os.access(shell, os.X_OK):
            msg = "The shell {0} is not available".format(shell)
            raise CommandExecutionError(msg)
    if salt.utils.is_windows() and use_vt:  # Memozation so not much overhead
        raise CommandExecutionError("VT not available on windows")

    if shell.lower().strip() == "powershell":
        # Strip whitespace
        if isinstance(cmd, six.string_types):
            cmd = cmd.strip()

        # If we were called by script(), then fakeout the Windows
        # shell to run a Powershell script.
        # Else just run a Powershell command.
        stack = traceback.extract_stack(limit=2)

        # extract_stack() returns a list of tuples.
        # The last item in the list [-1] is the current method.
        # The third item[2] in each tuple is the name of that method.
        if stack[-2][2] == "script":
            cmd = (
                "Powershell -NonInteractive -NoProfile -ExecutionPolicy Bypass -File "
                + cmd
            )
        elif encoded_cmd:
            cmd = "Powershell -NonInteractive -EncodedCommand {0}".format(cmd)
        else:
            cmd = 'Powershell -NonInteractive -NoProfile "{0}"'.format(
                cmd.replace('"', '\\"')
            )

    # munge the cmd and cwd through the template
    (cmd, cwd) = _render_cmd(cmd, cwd, template, saltenv, pillarenv, pillar_override)

    ret = {}

    # If the pub jid is here then this is a remote ex or salt call command and needs to be
    # checked if blacklisted
    if "__pub_jid" in kwargs:
        if not _check_avail(cmd):
            msg = 'This shell command is not permitted: "{0}"'.format(cmd)
            raise CommandExecutionError(msg)

    env = _parse_env(env)

    for bad_env_key in (x for x, y in six.iteritems(env) if y is None):
        log.error(
            "Environment variable '{0}' passed without a value. "
            "Setting value to an empty string".format(bad_env_key)
        )
        env[bad_env_key] = ""

    def _get_stripped(cmd):
        # Return stripped command string copies to improve logging.
        if isinstance(cmd, list):
            return [x.strip() if isinstance(x, str) else x for x in cmd]
        elif isinstance(cmd, str):
            return cmd.strip()
        else:
            return cmd

    if _check_loglevel(output_loglevel) is not None:
        # Always log the shell commands at INFO unless quiet logging is
        # requested. The command output is what will be controlled by the
        # 'loglevel' parameter.
        msg = "Executing command {0}{1}{0} {2}in directory '{3}'{4}".format(
            "'" if not isinstance(cmd, list) else "",
            _get_stripped(cmd),
            "as user '{0}' ".format(runas) if runas else "",
            cwd,
            ". Executing command in the background, no output will be logged."
            if bg
            else "",
        )
        log.info(log_callback(msg))

    if runas and salt.utils.is_windows():
        if not password:
            msg = "password is a required argument for runas on Windows"
            raise CommandExecutionError(msg)

        if not HAS_WIN_RUNAS:
            msg = "missing salt/utils/win_runas.py"
            raise CommandExecutionError(msg)

        if not isinstance(cmd, list):
            cmd = salt.utils.shlex_split(cmd, posix=False)

        cmd = " ".join(cmd)

        return win_runas(cmd, runas, password, cwd)

    if runas:
        # Save the original command before munging it
        try:
            pwd.getpwnam(runas)
        except KeyError:
            raise CommandExecutionError("User '{0}' is not available".format(runas))
        try:
            # Getting the environment for the runas user
            # There must be a better way to do this.
            py_code = (
                "import sys, os, itertools; "
                'sys.stdout.write("\\0".join(itertools.chain(*os.environ.items())))'
            )
            if __grains__["os"] in ["MacOS", "Darwin"]:
                env_cmd = ("sudo", "-i", "-u", runas, "--", sys.executable)
            elif __grains__["os"] in ["FreeBSD"]:
                env_cmd = (
                    "su",
                    "-",
                    runas,
                    "-c",
                    "{0} -c {1}".format(shell, sys.executable),
                )
            elif __grains__["os_family"] in ["Solaris"]:
                env_cmd = ("su", "-", runas, "-c", sys.executable)
            elif __grains__["os_family"] in ["AIX"]:
                env_cmd = ("su", runas, "-c", sys.executable)
            else:
                env_cmd = ("su", "-s", shell, "-", runas, "-c", sys.executable)
            env_encoded = subprocess.Popen(
                env_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE
            ).communicate(py_code.encode(__salt_system_encoding__))[0]
            if six.PY2:
                import itertools

                env_runas = dict(itertools.izip(*[iter(env_encoded.split(b"\0"))] * 2))
            elif six.PY3:
                if isinstance(env_encoded, str):
                    env_encoded = env_encoded.encode(__salt_system_encoding__)
                env_runas = dict(list(zip(*[iter(env_encoded.split(b"\0"))] * 2)))

            env_runas = {sdecode(k): sdecode(v) for k, v in six.iteritems(env_runas)}
            env_runas.update(env)
            env = env_runas
            # Encode unicode kwargs to filesystem encoding to avoid a
            # UnicodeEncodeError when the subprocess is invoked.
            fse = sys.getfilesystemencoding()
            for key, val in six.iteritems(env):
                if isinstance(val, six.text_type):
                    env[key] = val.encode(fse)
        except ValueError:
            raise CommandExecutionError(
                "Environment could not be retrieved for User '{0}'".format(runas)
            )

    if reset_system_locale is True:
        if not salt.utils.is_windows():
            # Default to C!
            # Salt only knows how to parse English words
            # Don't override if the user has passed LC_ALL
            env.setdefault("LC_CTYPE", "C")
            env.setdefault("LC_NUMERIC", "C")
            env.setdefault("LC_TIME", "C")
            env.setdefault("LC_COLLATE", "C")
            env.setdefault("LC_MONETARY", "C")
            env.setdefault("LC_MESSAGES", "C")
            env.setdefault("LC_PAPER", "C")
            env.setdefault("LC_NAME", "C")
            env.setdefault("LC_ADDRESS", "C")
            env.setdefault("LC_TELEPHONE", "C")
            env.setdefault("LC_MEASUREMENT", "C")
            env.setdefault("LC_IDENTIFICATION", "C")
        else:
            # On Windows set the codepage to US English.
            if python_shell:
                cmd = "chcp 437 > nul & " + cmd

    if clean_env:
        run_env = env

    else:
        run_env = os.environ.copy()
        run_env.update(env)

    if python_shell is None:
        python_shell = False

    kwargs = {
        "cwd": cwd,
        "shell": python_shell,
        "env": run_env,
        "stdin": str(stdin) if stdin is not None else stdin,
        "stdout": stdout,
        "stderr": stderr,
        "with_communicate": with_communicate,
        "timeout": timeout,
        "bg": bg,
    }

    if umask is not None:
        _umask = str(umask).lstrip("0")

        if _umask == "":
            msg = "Zero umask is not allowed."
            raise CommandExecutionError(msg)

        try:
            _umask = int(_umask, 8)
        except ValueError:
            msg = "Invalid umask: '{0}'".format(umask)
            raise CommandExecutionError(msg)
    else:
        _umask = None

    if runas or umask:
        kwargs["preexec_fn"] = functools.partial(
            salt.utils.chugid_and_umask, runas, _umask
        )

    if not salt.utils.is_windows():
        # close_fds is not supported on Windows platforms if you redirect
        # stdin/stdout/stderr
        if kwargs["shell"] is True:
            kwargs["executable"] = shell
        kwargs["close_fds"] = True

    if not os.path.isabs(cwd) or not os.path.isdir(cwd):
        raise CommandExecutionError(
            "Specified cwd '{0}' either not absolute or does not exist".format(cwd)
        )

    if python_shell is not True and not isinstance(cmd, list):
        posix = True
        if salt.utils.is_windows():
            posix = False
        cmd = salt.utils.shlex_split(cmd, posix=posix)
    if not use_vt:
        # This is where the magic happens
        try:
            proc = salt.utils.timed_subprocess.TimedProc(cmd, **kwargs)
        except (OSError, IOError) as exc:
            raise CommandExecutionError(
                "Unable to run command '{0}' with the context '{1}', "
                "reason: {2}".format(cmd, kwargs, exc)
            )

        try:
            proc.run()
        except TimedProcTimeoutError as exc:
            ret["stdout"] = str(exc)
            ret["stderr"] = ""
            ret["retcode"] = None
            ret["pid"] = proc.process.pid
            # ok return code for timeouts?
            ret["retcode"] = 1
            return ret

        out, err = proc.stdout, proc.stderr
        if err is None:
            # Will happen if redirect_stderr is True, since stderr was sent to
            # stdout.
            err = ""

        if rstrip:
            if out is not None:
                out = salt.utils.to_str(out).rstrip()
            if err is not None:
                err = salt.utils.to_str(err).rstrip()
        ret["pid"] = proc.process.pid
        ret["retcode"] = proc.process.returncode
        ret["stdout"] = out
        ret["stderr"] = err
    else:
        to = ""
        if timeout:
            to = " (timeout: {0}s)".format(timeout)
        if _check_loglevel(output_loglevel) is not None:
            msg = "Running {0} in VT{1}".format(cmd, to)
            log.debug(log_callback(msg))
        stdout, stderr = "", ""
        now = time.time()
        if timeout:
            will_timeout = now + timeout
        else:
            will_timeout = -1
        try:
            proc = vt.Terminal(
                cmd,
                shell=True,
                log_stdout=True,
                log_stderr=True,
                cwd=cwd,
                preexec_fn=kwargs.get("preexec_fn", None),
                env=run_env,
                log_stdin_level=output_loglevel,
                log_stdout_level=output_loglevel,
                log_stderr_level=output_loglevel,
                stream_stdout=True,
                stream_stderr=True,
            )
            ret["pid"] = proc.pid
            while proc.has_unread_data:
                try:
                    try:
                        time.sleep(0.5)
                        try:
                            cstdout, cstderr = proc.recv()
                        except IOError:
                            cstdout, cstderr = "", ""
                        if cstdout:
                            stdout += cstdout
                        else:
                            cstdout = ""
                        if cstderr:
                            stderr += cstderr
                        else:
                            cstderr = ""
                        if timeout and (time.time() > will_timeout):
                            ret["stderr"] = ("SALT: Timeout after {0}s\n{1}").format(
                                timeout, stderr
                            )
                            ret["retcode"] = None
                            break
                    except KeyboardInterrupt:
                        ret["stderr"] = "SALT: User break\n{0}".format(stderr)
                        ret["retcode"] = 1
                        break
                except vt.TerminalException as exc:
                    log.error("VT: {0}".format(exc), exc_info_on_loglevel=logging.DEBUG)
                    ret = {"retcode": 1, "pid": "2"}
                    break
                # only set stdout on success as we already mangled in other
                # cases
                ret["stdout"] = stdout
                if not proc.isalive():
                    # Process terminated, i.e., not canceled by the user or by
                    # the timeout
                    ret["stderr"] = stderr
                    ret["retcode"] = proc.exitstatus
                ret["pid"] = proc.pid
        finally:
            proc.close(terminate=True, kill=True)
    try:
        if ignore_retcode:
            __context__["retcode"] = 0
        else:
            __context__["retcode"] = ret["retcode"]
    except NameError:
        # Ignore the context error during grain generation
        pass
    return ret