我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用os.WEXITSTATUS。
def waitfinish(self, waiter=os.waitpid): pid, systemstatus = waiter(self.pid, 0) if systemstatus: if os.WIFSIGNALED(systemstatus): exitstatus = os.WTERMSIG(systemstatus) + 128 else: exitstatus = os.WEXITSTATUS(systemstatus) else: exitstatus = 0 signal = systemstatus & 0x7f if not exitstatus and not signal: retval = self.RETVAL.open('rb') try: retval_data = retval.read() finally: retval.close() retval = marshal.loads(retval_data) else: retval = None stdout = self.STDOUT.read() stderr = self.STDERR.read() self._removetemp() return Result(exitstatus, signal, retval, stdout, stderr)
def maybeCallProcessEnded(self): # two things must happen before we call the ProcessProtocol's # processEnded method. 1: the child process must die and be reaped # (which calls our own processEnded method). 2: the child must close # their stdin/stdout/stderr fds, causing the pty to close, causing # our connectionLost method to be called. #2 can also be triggered # by calling .loseConnection(). if self.lostProcess == 2: try: exitCode = sig = None if self.status != -1: if os.WIFEXITED(self.status): exitCode = os.WEXITSTATUS(self.status) else: sig = os.WTERMSIG(self.status) else: pass # wonder when this happens if exitCode or sig: e = error.ProcessTerminated(exitCode, sig, self.status) else: e = error.ProcessDone(self.status) self.proto.processEnded(failure.Failure(e)) self.proto = None except: log.err()
def poll(self, flag=os.WNOHANG): if self.returncode is None: while True: try: pid, sts = os.waitpid(self.pid, flag) except os.error as e: if e.errno == errno.EINTR: continue # Child process not yet created. See #1731717 # e.errno == errno.ECHILD == 10 return None else: break if pid == self.pid: if os.WIFSIGNALED(sts): self.returncode = -os.WTERMSIG(sts) else: assert os.WIFEXITED(sts) self.returncode = os.WEXITSTATUS(sts) return self.returncode
def _compute_returncode(self, status): if os.WIFSIGNALED(status): # The child process died because of a signal. return -os.WTERMSIG(status) elif os.WIFEXITED(status): # The child process exited (e.g sys.exit()). return os.WEXITSTATUS(status) else: # The child exited, but we don't understand its status. # This shouldn't happen, but if it does, let's just # return that status; perhaps that helps debug it. return status # # ?????: #
def proxy_command(command, command_args, credentials): # Unset variables for sanity sake os.unsetenv('AWS_DEFAULT_PROFILE') os.unsetenv('AWS_PROFILE') os.unsetenv('AWS_ACCESS_KEY_ID') os.unsetenv('AWS_SECRET_ACCESS_KEY') os.unsetenv('AWS_SESSION_TOKEN') os.unsetenv('AWS_SECURITY_TOKEN') # Set AWS/Boto environemnt variables before executing target command os.putenv('AWS_ACCESS_KEY_ID', (credentials['AccessKeyId'])) os.putenv('AWS_SECRET_ACCESS_KEY', (credentials['SecretAccessKey'])) os.putenv('AWS_SESSION_TOKEN', (credentials['SessionToken'])) os.putenv('AWS_SECURITY_TOKEN', (credentials['SessionToken'])) command_status = os.system(command + " " + " ".join(command_args)) exit(os.WEXITSTATUS(command_status))
def wait(self): if self.pid == None: 'Rule %s not initialized' % self.rulename return try: pid, status = os.waitpid(self.pid, 0) if pid != self.pid: print("\nWARNING! Received status for unknown process {}".format(pid)) sys.exit(3) if os.WIFEXITED(status): rcode = os.WEXITSTATUS(status) print("\n Rule session {0} terminated with return code: {1}.".format(pid,rcode)) except (RuntimeError, KeyboardInterrupt): print("Killing worker processes...") os.kill(self.pid, signal.SIGTERM) pid, status = os.waitpid(self.pid, 0) sys.exit(3)
def platformProcessEvent(self, event): pid, status = event if os.WIFEXITED(status): tid = self.getMeta("ThreadId", -1) exitcode = os.WEXITSTATUS(status) if tid != self.getPid(): # Set the selected thread ID to the pid cause # the old one's invalid if tid in self.pthreads: self.pthreads.remove(tid) self.setMeta("ThreadId", self.getPid()) self._fireExitThread(tid, exitcode) else: self._fireExit(exitcode) elif os.WIFSIGNALED(status): self._fireExit(os.WTERMSIG(status)) elif os.WIFSTOPPED(status): sig = os.WSTOPSIG(status) self.handlePosixSignal(sig) else: print("OMG WTF JUST HAPPENED??!?11/!?1?>!")
def GetExitStatus(exit_code): """Returns the argument to exit(), or -1 if exit() wasn't called. Args: exit_code: the result value of os.system(command). """ if os.name == 'nt': # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns # the argument to exit() directly. return exit_code else: # On Unix, os.WEXITSTATUS() must be used to extract the exit status # from the result of os.system(). if os.WIFEXITED(exit_code): return os.WEXITSTATUS(exit_code) else: return -1
def GetExitStatus(exit_code): """Returns the argument to exit(), or -1 if exit() wasn't called. Args: exit_code: the result value of os.system(command). """ if os.name == 'nt': # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns # the argument to exit() directly. return exit_code else: # On Unix, os.WEXITSTATUS() must be used to extract the exit status # from the result of os.system(). if os.WIFEXITED(exit_code): return os.WEXITSTATUS(exit_code) else: return -1 # Suppresses the "Invalid const name" lint complaint # pylint: disable-msg=C6409 # Exposes utilities from gtest_test_utils.
def poll(self, flag=os.WNOHANG): if self.returncode is None: while True: try: pid, sts = os.waitpid(self.pid, flag) except OSError as e: if e.errno == errno.EINTR: continue # Child process not yet created. See #1731717 # e.errno == errno.ECHILD == 10 return None else: break if pid == self.pid: if os.WIFSIGNALED(sts): self.returncode = -os.WTERMSIG(sts) else: assert os.WIFEXITED(sts) self.returncode = os.WEXITSTATUS(sts) return self.returncode
def exitStatus(self, code): """ Construct a status from the given exit code. @type code: L{int} between 0 and 255 inclusive. @param code: The exit status which the code will represent. @rtype: L{int} @return: A status integer for the given exit code. """ # /* Macros for constructing status values. */ # #define __W_EXITCODE(ret, sig) ((ret) << 8 | (sig)) status = (code << 8) | 0 # Sanity check self.assertTrue(os.WIFEXITED(status)) self.assertEqual(os.WEXITSTATUS(status), code) self.assertFalse(os.WIFSIGNALED(status)) return status
def send_command(self, args): command = "%s exec -i %s %s %s %s %s %s %s" % ( self.docker_command, "-t" if sys.stdout.isatty() else "", "--privileged" if self.docker_run_privileged else "", self.instance_name, self.command, ("--bazelrc=%s" % self.bazel_rc_file if self.bazel_rc_file and self.command else ""), ("--output_user_root=%s --output_base=%s" % ( TEMP_BAZEL_OUTPUT_USER_ROOT, self.bazel_output_base) if self.command and self.bazel_output_base else "--output_user_root=%s" % self.bazel_user_output_root if self.command and self.bazel_user_output_root else ""), '"%s"' % '" "'.join(args)) command = self._with_docker_machine(command) return os.WEXITSTATUS(os.system(command))
def print_exit_status(process, printer): exit_signal = None exit_code = None core_dumped = False try: wait_result = os.waitpid(process.pid, 0)[1] if os.WIFSIGNALED(wait_result): exit_signal = os.WTERMSIG(wait_result) exit_code = 128 + exit_signal elif os.WIFEXITED(wait_result): exit_code = os.WEXITSTATUS(wait_result) core_dumped = os.WCOREDUMP(wait_result) except ChildProcessError: # Must be Windows; waiting for a terminated process doesn't work (?) exit_code = process.returncode if exit_signal is not None: signal_name = signal_names.get(exit_signal, 'unknown signal') printer.print( Fore.RED + 'Terminated by %s (%i)' % (signal_name, exit_signal) + Style.RESET_ALL) exit_code = 128 + exit_signal if core_dumped: printer.print(Fore.RED + 'Core dumped' + Style.RESET_ALL) return exit_code
def wait_for_fork(pid, raise_error=True, expected_exitcode=0): """Wait for a process to complete This function will wait for the given pid to complete. If the exit code does not match that of the expected_exitcode an error is raised. """ rc = 0 try: (pid, rc) = os.waitpid(pid, 0) rc = os.WEXITSTATUS(rc) if rc != expected_exitcode: raise RuntimeError('The exit code %d is not %d' % (rc, expected_exitcode)) except Exception: if raise_error: raise return rc
def check_prerequsites(self): # TODO: Check that OS is Ubuntu?! # Check for sudo permission command = "timeout --foreground 2 sudo id" return_value = os.system("{0} > /dev/null 2>&1".format(command)) exit_status = os.WEXITSTATUS(return_value) if exit_status != 0: print "* ERROR: cyris: Passwordless sudo execution is not enabled." self.handle_error() quit(-1) # TODO: Check that SSH keys are defined?! # TODO: Check if Internet access is available?! ######################################################################### # Given a file with full path, separate the file name and the absolute path
def os_system(self, filename, command): # Make sure the command is executed even if no filename is provided for the log file if filename: return_value = os.system("{0} >> {1} 2>&1".format(command, filename)) else: return_value = os.system("{0} >> /dev/null".format(command)) exit_status = os.WEXITSTATUS(return_value) if exit_status != 0: print "* ERROR: cyris: Issue when executing command (exit status = %d):" % (exit_status) print " %s" % (command) print " Check the log file for details: %s" % (self.creation_log_file) self.handle_error() quit(-1) else: global RESPONSE_LIST RESPONSE_LIST.append(exit_status) ######################################################################### # Transmit information about cloning part in yaml file, send it to module # class to create script 'instantiation/vm_clone/create_bridges.sh' and # get the commands back
def run_command_killable(*argv): filename = argv[0] status = None pid = os.spawnvp(os.P_NOWAIT, filename, argv) try: status = waitpid_reap_other_children(pid) except BaseException as s: warn("An error occurred. Aborting.") stop_child_process(filename, pid) raise if status != 0: if status is None: error("%s exited with unknown status\n" % filename) else: error("%s failed with status %d\n" % (filename, os.WEXITSTATUS(status))) sys.exit(1)
def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED, _WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED, _WEXITSTATUS=os.WEXITSTATUS): # This method is called (indirectly) by __del__, so it cannot # refer to anything outside of its local scope.""" if _WIFSIGNALED(sts): self.returncode = -_WTERMSIG(sts) elif _WIFEXITED(sts): self.returncode = _WEXITSTATUS(sts) else: # Should never happen raise RuntimeError("Unknown child exit status!")
def poll(self, flag=os.WNOHANG): if self.returncode is None: try: pid, sts = os.waitpid(self.pid, flag) except os.error: # Child process not yet created. See #1731717 # e.errno == errno.ECHILD == 10 return None if pid == self.pid: if os.WIFSIGNALED(sts): self.returncode = -os.WTERMSIG(sts) else: assert os.WIFEXITED(sts) self.returncode = os.WEXITSTATUS(sts) return self.returncode
def _set_returncode(self, status): if os.WIFSIGNALED(status): self.returncode = -os.WTERMSIG(status) else: assert os.WIFEXITED(status) self.returncode = os.WEXITSTATUS(status) if self._exit_callback: callback = self._exit_callback self._exit_callback = None callback(self.returncode)
def _wait_child(self): try: # Don't block if no child processes have exited pid, status = os.waitpid(0, os.WNOHANG) if not pid: return None except OSError as exc: if exc.errno not in (errno.EINTR, errno.ECHILD): raise return None if os.WIFSIGNALED(status): sig = os.WTERMSIG(status) LOG.info(_LI('Child %(pid)d killed by signal %(sig)d'), dict(pid=pid, sig=sig)) else: code = os.WEXITSTATUS(status) LOG.info(_LI('Child %(pid)s exited with status %(code)d'), dict(pid=pid, code=code)) if pid not in self.children: LOG.warning(_LW('pid %d not in child list'), pid) return None wrap = self.children.pop(pid) wrap.children.remove(pid) return wrap
def maybeCallProcessEnded(self): # we don't call ProcessProtocol.processEnded until: # the child has terminated, AND # all writers have indicated an error status, AND # all readers have indicated EOF # This insures that we've gathered all output from the process. if self.pipes: #print "maybe, but pipes still", self.pipes.keys() return if not self.lostProcess: #print "maybe, but haven't .lostProcess yet" self.reapProcess() return try: exitCode = sig = None if self.status != -1: if os.WIFEXITED(self.status): exitCode = os.WEXITSTATUS(self.status) else: sig = os.WTERMSIG(self.status) else: pass # don't think this can happen if exitCode or sig: e = error.ProcessTerminated(exitCode, sig, self.status) else: e = error.ProcessDone(self.status) if self.proto is not None: self.proto.processEnded(failure.Failure(e)) self.proto = None except: log.err()
def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED, _WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED, _WEXITSTATUS=os.WEXITSTATUS): # This method is called (indirectly) by __del__, so it cannot # refer to anything outside of its local scope. if _WIFSIGNALED(sts): self.returncode = -_WTERMSIG(sts) elif _WIFEXITED(sts): self.returncode = _WEXITSTATUS(sts) else: # Should never happen raise RuntimeError("Unknown child exit status!")
def _wait_service(self): """Return the last died service or None""" try: # Don't block if no child processes have exited pid, status = os.waitpid(0, os.WNOHANG) if not pid: return None except OSError as exc: if exc.errno not in (errno.EINTR, errno.ECHILD): raise return None if os.WIFSIGNALED(status): sig = SIGNAL_TO_NAME.get(os.WTERMSIG(status)) LOG.info('Child %(pid)d killed by signal %(sig)s', dict(pid=pid, sig=sig)) else: code = os.WEXITSTATUS(status) LOG.info('Child %(pid)d exited with status %(code)d', dict(pid=pid, code=code)) for conf in self._running_services: if pid in self._running_services[conf]: return conf, self._running_services[conf].pop(pid) LOG.error('pid %d not in service list', pid)
def _on_sigchld(self, watcher): """Callback of libev child watcher. Called when libev event loop catches corresponding SIGCHLD signal. """ watcher.stop() # Status evaluation copied from `multiprocessing.forking` in Py2.7. if os.WIFSIGNALED(watcher.rstatus): self._popen.returncode = -os.WTERMSIG(watcher.rstatus) else: assert os.WIFEXITED(watcher.rstatus) self._popen.returncode = os.WEXITSTATUS(watcher.rstatus) self._returnevent.set() log.debug("SIGCHLD watcher callback for %s invoked. Exitcode " "stored: %s", self.pid, self._popen.returncode)
def getoutput(cmd, successful_status=(0,), stacklevel=1): try: status, output = getstatusoutput(cmd) except EnvironmentError: e = get_exception() warnings.warn(str(e), UserWarning, stacklevel=stacklevel) return False, output if os.WIFEXITED(status) and os.WEXITSTATUS(status) in successful_status: return True, output return False, output
def wait(self): '''This waits until the child exits. This is a blocking call. This will not read any data from the child, so this will block forever if the child has unread output and has terminated. In other words, the child may have printed output then called exit(), but, the child is technically still alive until its output is read by the parent. ''' if self.isalive(): pid, status = os.waitpid(self.pid, 0) else: return self.exitstatus self.exitstatus = os.WEXITSTATUS(status) if os.WIFEXITED(status): self.status = status self.exitstatus = os.WEXITSTATUS(status) self.signalstatus = None self.terminated = True elif os.WIFSIGNALED(status): self.status = status self.exitstatus = None self.signalstatus = os.WTERMSIG(status) self.terminated = True elif os.WIFSTOPPED(status): # pragma: no cover # You can't call wait() on a child process in the stopped state. raise PtyProcessError('Called wait() on a stopped child ' + 'process. This is not supported. Is some other ' + 'process attempting job control with our child pid?') return self.exitstatus
def _waitWithTimeout(process, args, timeout, nonZeroIsFatal=True): def _waitpid(pid): while True: try: return os.waitpid(pid, os.WNOHANG) except OSError, e: if e.errno == errno.EINTR: continue raise def _returncode(status): if os.WIFSIGNALED(status): return -os.WTERMSIG(status) elif os.WIFEXITED(status): return os.WEXITSTATUS(status) else: # Should never happen raise RuntimeError("Unknown child exit status!") end = time.time() + timeout delay = 0.0005 while True: (pid, status) = _waitpid(process.pid) if pid == process.pid: return _returncode(status) remaining = end - time.time() if remaining <= 0: msg = 'Process timed out after {0} seconds: {1}'.format(timeout, ' '.join(args)) if nonZeroIsFatal: abort(msg) else: log(msg) _kill_process(process.pid, signal.SIGKILL) return ERROR_TIMEOUT delay = min(delay * 2, remaining, .05) time.sleep(delay) # Makes the current subprocess accessible to the abort() function # This is a list of tuples of the subprocess.Popen or # multiprocessing.Process object and args.
def _on_child(self, watcher): watcher.stop() status = watcher.rstatus if os.WIFSIGNALED(status): self.returncode = -os.WTERMSIG(status) else: self.returncode = os.WEXITSTATUS(status) self.result.set(self.returncode)
def _handle_exitstatus(self, sts): if os.WIFSIGNALED(sts): self.returncode = -os.WTERMSIG(sts) elif os.WIFEXITED(sts): self.returncode = os.WEXITSTATUS(sts) else: # Should never happen raise RuntimeError("Unknown child exit status!")
