| """distutils.spawn | |
| Provides the 'spawn()' function, a front-end to various platform- | |
| specific functions for launching another program in a sub-process. | |
| Also provides the 'find_executable()' to search the path for a given | |
| executable name. | |
| """ | |
| __revision__ = "$Id$" | |
| import sys | |
| import os | |
| from distutils.errors import DistutilsPlatformError, DistutilsExecError | |
| from distutils import log | |
| def spawn(cmd, search_path=1, verbose=0, dry_run=0): | |
| """Run another program, specified as a command list 'cmd', in a new process. | |
| 'cmd' is just the argument list for the new process, ie. | |
| cmd[0] is the program to run and cmd[1:] are the rest of its arguments. | |
| There is no way to run a program with a name different from that of its | |
| executable. | |
| If 'search_path' is true (the default), the system's executable | |
| search path will be used to find the program; otherwise, cmd[0] | |
| must be the exact path to the executable. If 'dry_run' is true, | |
| the command will not actually be run. | |
| Raise DistutilsExecError if running the program fails in any way; just | |
| return on success. | |
| """ | |
| if os.name == 'posix': | |
| _spawn_posix(cmd, search_path, dry_run=dry_run) | |
| elif os.name == 'nt': | |
| _spawn_nt(cmd, search_path, dry_run=dry_run) | |
| elif os.name == 'os2': | |
| _spawn_os2(cmd, search_path, dry_run=dry_run) | |
| else: | |
| raise DistutilsPlatformError, \ | |
| "don't know how to spawn programs on platform '%s'" % os.name | |
| def _nt_quote_args(args): | |
| """Quote command-line arguments for DOS/Windows conventions. | |
| Just wraps every argument which contains blanks in double quotes, and | |
| returns a new argument list. | |
| """ | |
| # XXX this doesn't seem very robust to me -- but if the Windows guys | |
| # say it'll work, I guess I'll have to accept it. (What if an arg | |
| # contains quotes? What other magic characters, other than spaces, | |
| # have to be escaped? Is there an escaping mechanism other than | |
| # quoting?) | |
| for i, arg in enumerate(args): | |
| if ' ' in arg: | |
| args[i] = '"%s"' % arg | |
| return args | |
| def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0): | |
| executable = cmd[0] | |
| cmd = _nt_quote_args(cmd) | |
| if search_path: | |
| # either we find one or it stays the same | |
| executable = find_executable(executable) or executable | |
| log.info(' '.join([executable] + cmd[1:])) | |
| if not dry_run: | |
| # spawn for NT requires a full path to the .exe | |
| try: | |
| rc = os.spawnv(os.P_WAIT, executable, cmd) | |
| except OSError, exc: | |
| # this seems to happen when the command isn't found | |
| raise DistutilsExecError, \ | |
| "command '%s' failed: %s" % (cmd[0], exc[-1]) | |
| if rc != 0: | |
| # and this reflects the command running but failing | |
| raise DistutilsExecError, \ | |
| "command '%s' failed with exit status %d" % (cmd[0], rc) | |
| def _spawn_os2(cmd, search_path=1, verbose=0, dry_run=0): | |
| executable = cmd[0] | |
| if search_path: | |
| # either we find one or it stays the same | |
| executable = find_executable(executable) or executable | |
| log.info(' '.join([executable] + cmd[1:])) | |
| if not dry_run: | |
| # spawnv for OS/2 EMX requires a full path to the .exe | |
| try: | |
| rc = os.spawnv(os.P_WAIT, executable, cmd) | |
| except OSError, exc: | |
| # this seems to happen when the command isn't found | |
| raise DistutilsExecError, \ | |
| "command '%s' failed: %s" % (cmd[0], exc[-1]) | |
| if rc != 0: | |
| # and this reflects the command running but failing | |
| log.debug("command '%s' failed with exit status %d" % (cmd[0], rc)) | |
| raise DistutilsExecError, \ | |
| "command '%s' failed with exit status %d" % (cmd[0], rc) | |
| def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0): | |
| log.info(' '.join(cmd)) | |
| if dry_run: | |
| return | |
| exec_fn = search_path and os.execvp or os.execv | |
| pid = os.fork() | |
| if pid == 0: # in the child | |
| try: | |
| exec_fn(cmd[0], cmd) | |
| except OSError, e: | |
| sys.stderr.write("unable to execute %s: %s\n" % | |
| (cmd[0], e.strerror)) | |
| os._exit(1) | |
| sys.stderr.write("unable to execute %s for unknown reasons" % cmd[0]) | |
| 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 | |
| raise DistutilsExecError, \ | |
| "command '%s' failed: %s" % (cmd[0], exc[-1]) | |
| if os.WIFSIGNALED(status): | |
| raise DistutilsExecError, \ | |
| "command '%s' terminated by signal %d" % \ | |
| (cmd[0], os.WTERMSIG(status)) | |
| elif os.WIFEXITED(status): | |
| exit_status = os.WEXITSTATUS(status) | |
| if exit_status == 0: | |
| return # hey, it succeeded! | |
| else: | |
| raise DistutilsExecError, \ | |
| "command '%s' failed with exit status %d" % \ | |
| (cmd[0], exit_status) | |
| elif os.WIFSTOPPED(status): | |
| continue | |
| else: | |
| raise DistutilsExecError, \ | |
| "unknown error executing '%s': termination status %d" % \ | |
| (cmd[0], status) | |
| def find_executable(executable, path=None): | |
| """Tries to find 'executable' in the directories listed in 'path'. | |
| A string listing directories separated by 'os.pathsep'; defaults to | |
| os.environ['PATH']. Returns the complete filename or None if not found. | |
| """ | |
| if path is None: | |
| path = os.environ['PATH'] | |
| paths = path.split(os.pathsep) | |
| base, ext = os.path.splitext(executable) | |
| if (sys.platform == 'win32' or os.name == 'os2') and (ext != '.exe'): | |
| executable = executable + '.exe' | |
| if not os.path.isfile(executable): | |
| for p in paths: | |
| f = os.path.join(p, executable) | |
| if os.path.isfile(f): | |
| # the file exists, we have a shot at spawn working | |
| return f | |
| return None | |
| else: | |
| return executable |