我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用os.WIFEXITED。
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 wait_child(pid): while True: try: # wait for child process wpid, sts = os.waitpid(pid, 0) except KeyboardInterrupt: # handle exceptions when parent is waiting handle_parent_exit(pid) # if child process stopped if os.WIFSTOPPED(sts): continue # if receive keybord interuption or kill signal elif os.WIFSIGNALED(sts): return sts # seems not work elif os.WIFEXITED(sts): return sts else: raise "Not stopped, signaled or exited???"
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 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 wait_on_children(self): """Wait on children exit.""" while self.running: try: pid, status = os.wait() if os.WIFEXITED(status) or os.WIFSIGNALED(status): self._remove_children(pid) self._verify_and_respawn_children(pid, status) except OSError as err: if err.errno not in (errno.EINTR, errno.ECHILD): raise except KeyboardInterrupt: LOG.info(_LI('Caught keyboard interrupt. Exiting.')) os.killpg(0, signal.SIGTERM) break except exception.SIGHUPInterrupt: self.reload() continue eventlet.greenio.shutdown_safe(self.sock) self.sock.close() LOG.debug('Exited')
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 signalStatus(self, signal): """ Construct a status from the given signal. @type signal: L{int} between 0 and 255 inclusive. @param signal: The signal number which the status will represent. @rtype: L{int} @return: A status integer for the given signal. """ # /* If WIFSIGNALED(STATUS), the terminating signal. */ # #define __WTERMSIG(status) ((status) & 0x7f) # /* Nonzero if STATUS indicates termination by a signal. */ # #define __WIFSIGNALED(status) \ # (((signed char) (((status) & 0x7f) + 1) >> 1) > 0) status = signal # Sanity check self.assertTrue(os.WIFSIGNALED(status)) self.assertEqual(os.WTERMSIG(status), signal) self.assertFalse(os.WIFEXITED(status)) return status
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_on_children(self): while self.running: try: pid, status = os.wait() if os.WIFEXITED(status) or os.WIFSIGNALED(status): self._remove_children(pid) self._verify_and_respawn_children(pid, status) except OSError as err: if err.errno not in (errno.EINTR, errno.ECHILD): raise except KeyboardInterrupt: LOG.info('Caught keyboard interrupt. Exiting.') break except glare_exc.SIGHUPInterrupt: self.reload() continue eventlet.greenio.shutdown_safe(self.sock) self.sock.close() LOG.debug('Exited')
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 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 _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 _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!")
def getoutput(cmd, successful_status=(0,), stacklevel=1): try: status, output = commands.getstatusoutput(cmd) except EnvironmentError, e: warnings.warn(str(e), UserWarning, stacklevel=stacklevel) return False, '' if os.WIFEXITED(status) and os.WEXITSTATUS(status) in successful_status: return True, output return False, output
def wait_child(self): """Override to find out whether dpkg exited or not. The C{run()} method returns os.WEXITSTATUS(res) without checking os.WIFEXITED(res) first, so it can signal that everything is ok, even though something causes dpkg not to exit cleanly. Save whether dpkg exited cleanly into the C{dpkg_exited} attribute. If dpkg exited cleanly the exit code can be used to determine whether there were any errors. If dpkg didn't exit cleanly it should mean that something went wrong. """ res = super(LandscapeInstallProgress, self).wait_child() self.dpkg_exited = os.WIFEXITED(res) return res
def _verify_and_respawn_children(self, pid, status): if len(self.stale_children) == 0: LOG.debug('No stale children') if os.WIFEXITED(status) and os.WEXITSTATUS(status) != 0: LOG.error(_LE('Not respawning child %d, cannot ' 'recover from termination'), pid) if not self.children and not self.stale_children: LOG.info(_LI('All workers have terminated. Exiting')) self.running = False else: if len(self.children) < self.conf.workers: self.run_child()
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, technically, the child is still alive until its output is read. """ if self.isalive(): pid, status = os.waitpid(self.pid, 0) else: raise ExceptionPexpect ('Cannot wait for dead child process.') 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): raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?') return self.exitstatus
def Wait(self): # This is a list of async jobs try: pid, status = os.wait() except OSError as e: if e.errno == errno.ECHILD: #log('WAIT ECHILD') return False # nothing to wait for caller should stop else: # What else can go wrong? raise #log('WAIT got %s %s', pid, status) # TODO: change status in more cases. if os.WIFSIGNALED(status): pass elif os.WIFEXITED(status): status = os.WEXITSTATUS(status) #log('exit status: %s', status) # This could happen via coding error. But this may legitimately happen # if a grandchild outlives the child (its parent). Then it is reparented # under this process, so we might receive notification of its exit, even # though we didn't start it. We can't have any knowledge of such # processes, so print a warning. if pid not in self.callbacks: util.warn("PID %d stopped, but osh didn't start it", pid) return True # caller should keep waiting callback = self.callbacks.pop(pid) callback(pid, status) self.last_status = status # for wait -n return True # caller should keep waiting
