Does _spawn_posix in distutils always raise an error?

Question

I'm afraid to send this to the distutils mailing list, because I'm pretty sure I'm making a dumb misinterpretation.

Here is the function _spawn_posix in distutils version 2.7.9:

def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
    log.info(' '.join(cmd))
    if dry_run:
        return
    executable = cmd[0]
    exec_fn = search_path and os.execvp or os.execv
    env = None
    if sys.platform == 'darwin':
        global _cfg_target, _cfg_target_split
        if _cfg_target is None:
            _cfg_target = sysconfig.get_config_var(
                                  'MACOSX_DEPLOYMENT_TARGET') or ''
            if _cfg_target:
                _cfg_target_split = [int(x) for x in _cfg_target.split('.')]
        if _cfg_target:
            # ensure that the deployment target of build process is not less
            # than that used when the interpreter was built. This ensures
            # extension modules are built with correct compatibility values
            cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
            if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
                my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
                          'now "%s" but "%s" during configure'
                                % (cur_target, _cfg_target))
                raise DistutilsPlatformError(my_msg)
            env = dict(os.environ,
                       MACOSX_DEPLOYMENT_TARGET=cur_target)
            exec_fn = search_path and os.execvpe or os.execve
    pid = os.fork()

    if pid == 0:  # in the child
        try:
            if env is None:
                exec_fn(executable, cmd)
            else:
                exec_fn(executable, cmd, env)
        except OSError, e:
            if not DEBUG:
                cmd = executable
            sys.stderr.write("unable to execute %r: %s\n" %
                             (cmd, e.strerror))
            os._exit(1)

        if not DEBUG:
            cmd = executable
        sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
        os._exit(1)
    else:   # in the parent
        # Loop until the child either exits or is terminated by a signal
        # (ie. keep waiting if it's merely stopped)
        while 1:
            try:
                pid, status = os.waitpid(pid, 0)
            except OSError, exc:
                import errno
                if exc.errno == errno.EINTR:
                    continue
                if not DEBUG:
                    cmd = executable
                raise DistutilsExecError, \
                      "command %r failed: %s" % (cmd, exc[-1])
            if os.WIFSIGNALED(status):
                if not DEBUG:
                    cmd = executable
                raise DistutilsExecError, \
                      "command %r terminated by signal %d" % \
                      (cmd, os.WTERMSIG(status))

            elif os.WIFEXITED(status):
                exit_status = os.WEXITSTATUS(status)
                if exit_status == 0:
                    return   # hey, it succeeded!
                else:
                    if not DEBUG:
                        cmd = executable
                    raise DistutilsExecError, \
                          "command %r failed with exit status %d" % \
                          (cmd, exit_status)

            elif os.WIFSTOPPED(status):
                continue

            else:
                if not DEBUG:
                    cmd = executable
                raise DistutilsExecError, \
                      "unknown error executing %r: termination status %d" % \
                      (cmd, status)

Obviously there's a lot there. No one wants to read that. All you need to do is the following:

Find the line exec_fn(executable, cmd). That's the line this whole function is setup to execute. It calls os.execvp.
Notice that exec_fn is only called when pid == 0.

Notice that when pid == 0, the following code is called:

    try:
        if env is None:
            exec_fn(executable, cmd)
        else:
            exec_fn(executable, cmd, env)
    except OSError, e:
        if not DEBUG:
            cmd = executable
        sys.stderr.write("unable to execute %r: %s\n" %
                         (cmd, e.strerror))
        os._exit(1)

    if not DEBUG:
        cmd = executable
    sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
    os._exit(1)

Notice here that if an OSError is raised in the try block, we exit to the system with a status of 1 (failure).
Notice that even if an OSError is not raised, we still exit to the system with a status of 1 (failure).
In both cases, the parent process, which has been waiting for the child to finish, raises a DistutilsExecError.

Can someone point out my error? Or do I happen to be using the version of distutils with a crazy bug that has since been fixed?

abcd · Accepted Answer · 2015-05-09T07:59:53.167

Aha, OK, the docs say about os.execvp and the other os.exec functions

These functions all execute a new program, replacing the current process; they do not return. On Unix, the new executable is loaded into the current process, and will have the same process id as the caller. Errors will be reported as OSError exceptions.

So once the call to exec_fn is made, if it's successful, the lines that follow are never executed. They have been replaced by the new os.execvp process.

Does _spawn_posix in distutils always raise an error?

1 Answers1