def __init__(self, args, logger, **kwargs): _kwargs = kwargs.copy() for fdname in self.fdnames: _kwargs[fdname] = PIPE Popen.__init__(self, args, **_kwargs) self.logger = logger self.wrapfds()
def __init__(self, main_window, argv=sys.argv): Popen.__init__(self, ["python.exe", '-m']) # self.subprocess = AppViewer.SubProcessAppViewer(self) self._argv = argv self._main_window = main_window self.proc = None
def __init__(self, args, wait_for_traps_listener_port=0, **kwargs): ''' Creates child and (optionally) waits for trap listener ready ''' Popen.__init__(self, args, **{**kwargs, 'stdout': PIPE, 'stderr': PIPE}) if wait_for_traps_listener_port > 0: self.__wait_for_trap_listener( expected_port=wait_for_traps_listener_port)
def __init__(self, args, close_fds=False, cwd=None, env=None, deathSignal=0, childUmask=None, stdin=PIPE, stdout=PIPE, stderr=PIPE): if not isinstance(args, list): args = list(args) if env is not None and not isinstance(env, list): env = list(("=".join(item) for item in env.iteritems())) self._childUmask = childUmask self._deathSignal = int(deathSignal) Popen.__init__(self, args, close_fds=close_fds, cwd=cwd, env=env, stdin=stdin, stdout=stdout, stderr=stderr)
def __init__(self, label='bithorded', bithorded=os.environ.get('BITHORDED', 'bithorded'), config={}): cmd = ['stdbuf', '-o0', '-e0', bithorded, '-c', '/dev/stdin', '--log.level=TRACE'] Popen.__init__(self, cmd, stderr=STDOUT, stdout=PIPE, stdin=PIPE) self._cleanup = list() if hasattr(config, 'setdefault'): suffix = (time(), os.getpid()) server_cfg = config.setdefault('server', {}) server_cfg.setdefault('tcpPort', 0) server_cfg.setdefault('inspectPort', 0) server_cfg.setdefault('unixSocket', "bhtest-sock-%d-%d" % suffix) self._cleanup.append(lambda: os.unlink(server_cfg['unixSocket'])) cache_cfg = config.setdefault('cache', {}) if 'dir' not in cache_cfg: from shutil import rmtree d = 'bhtest-cache-%d-%d' % suffix self._cleanup.append(lambda: rmtree(d, ignore_errors=True)) os.mkdir(d) cache_cfg['dir'] = d self.buffer = LineBuffer(label, self.stdout) self.config = config self.label = label self.started = False self._run()
def __init__(self, args, ready=None, timeout=30, skip_valgrind=False, **kwargs): """Start an example process""" args = list(args) if platform.system() == "Windows": args[0] += ".exe" self.timeout = timeout self.args = args self.out = "" if not skip_valgrind: args = self.env_args + args try: Popen.__init__(self, args, stdout=PIPE, stderr=STDOUT, universal_newlines=True, **kwargs) except Exception as e: raise ProcError(self, str(e)) # Start reader thread. self.pattern = ready self.ready = Event() # Help with Python 2.5, 2.6, 2.7 changes to Event.wait(), Event.is_set self.ready_set = False self.error = None self.thread = Thread(target=self.run_) self.thread.daemon = True self.thread.start() if self.pattern: self.wait_ready()
def __init__(self, args, valgrind=True, helgrind=False, **kwargs): """Start an example process""" self.args = list(args) self.kwargs = kwargs self._out = tempfile.TemporaryFile(mode='w+') valgrind_exe = valgrind and os.getenv("VALGRIND") if valgrind_exe: # run valgrind for speed, not for detailed information vg = [valgrind_exe] if helgrind: vg += ["--tool=helgrind", "--quiet", "--error-exitcode=42"] else: vg += ["--tool=memcheck" ] + os.getenv("VALGRIND_ARGS").split(' ') self.args = vg + self.args if os.getenv("PROCTEST_VERBOSE"): sys.stderr.write("\n== running == " + " ".join(self.args) + "\n") try: Popen.__init__(self, self.args, stdout=self._out, stderr=STDOUT, **kwargs) except OSError as e: if e.errno == errno.ENOENT: raise NotFoundError(self, str(e)) raise ProcError(self, str(e)) except Exception as e: raise ProcError(self, str(e))
def __init__(self, argv, map=None, timeout=None, close_when_done=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, preexec_fn=None, bufsize=0, **popen_keyw): """Accepts all the same arguments and keywords as `subprocess.Popen`. Input or outputs specified as `PIPE` (now the default) for are wrapped in an asynchronous pipe dispatcher. The timeout is used to create an alarm, which can be cancelled by calling `cancel_timeout()`, `communicate()`, `wait()` or `kill()`. """ Observable.__init__(self) self._map = map # Create the subprocess itself, wrapping preexec_fn in the clear_signals call Popen.__init__(self, argv, preexec_fn=lambda: self.clear_signals(preexec_fn), stdin=stdin, stdout=stdout, stderr=stderr, **popen_keyw) # Set the timeout on the subprocess. If it fails, ignore the failure. try: fto = float(timeout) self._alarmobj = alarm.alarm(fto, self.kill) if fto > 0 else None except: self._alarmobj = None # Wrap the pipe I/O. Sets the Popen and pipe buffer sizes the same; perhaps not optimal. if stdout == PIPE: self.stdout = OutputPipeDispatcher(self.stdout, map=map, ignore_broken_pipe=True, universal_newlines=self.universal_newlines, maxdata=bufsize) self.stdout.obs_add(self._pipe_event) if stderr == PIPE: self.stderr = OutputPipeDispatcher(self.stderr, map=map, ignore_broken_pipe=True, universal_newlines=self.universal_newlines, maxdata=bufsize) self.stderr.obs_add(self._pipe_event) if stdin == PIPE: self.stdin = InputPipeDispatcher(self.stdin, map=map, ignore_broken_pipe=True, close_when_done=close_when_done, maxdata=bufsize) self.stdin.obs_add(self._pipe_event)
def __init__(self, label='bithorded', bithorded=os.environ.get('BITHORDED', 'bithorded'), config={}): Popen.__init__(self, ['stdbuf', '-o0', '-e0', bithorded, '-c', '/dev/stdin'], stderr=STDOUT, stdout=PIPE, stdin=PIPE) self._cleanup = list() if hasattr(config, 'setdefault'): suffix = (time(), os.getpid()) server_cfg = config.setdefault('server', {}) server_cfg.setdefault('tcpPort', 0) server_cfg.setdefault('inspectPort', 0) server_cfg.setdefault('unixSocket', "bhtest-sock-%d-%d" % suffix) self._cleanup.append(lambda: os.unlink(server_cfg['unixSocket'])) cache_cfg = config.setdefault('cache', {}) if 'dir' not in cache_cfg: from shutil import rmtree d = 'bhtest-cache-%d-%d' % suffix self._cleanup.append(lambda: rmtree(d, ignore_errors=True)) os.mkdir(d) cache_cfg['dir'] = d self.buffer = LineBuffer(label, self.stdout) self.config = config self.label = label self.started = False self._run()
def __init__(self, args, executable=None, stdin=None, stdout=None, stderr=None, cwd=None, env={}, time_limit=None, rss_limit=None, vm_limit=None): self._time_limit = time_limit self._rss_limit = rss_limit self._vm_limit = vm_limit self.cputime = None self.maxrss = 0 self.maxvm = 0 self.verdict = None Popen.__init__( self, args, bufsize=-1, executable=executable, stdin=stdin, stdout=stdout, stderr=stderr, close_fds=True, preexec_fn=self._preexec_hook, cwd=cwd, env=env) _, status = waitpid(self.pid, WUNTRACED) assert WIFSTOPPED(status), "cannot start subprocess" if WSTOPSIG(status) != SIGTRAP: self.kill() self.wait() assert False, "subprocess stopped unexpectedly"
def __init__(self, args, valgrind=True, helgrind=False, **kwargs): """Start an example process""" self.args = list(args) self.kwargs = kwargs self._out = tempfile.TemporaryFile() valgrind_exe = valgrind and os.getenv("VALGRIND") if valgrind_exe: # run valgrind for speed, not for detailed information vg = [ valgrind_exe, "--quiet", "--num-callers=2", "--error-exitcode=%s" % self.valgrind_exit ] if helgrind: vg += ["--tool=helgrind", "--history-level=none"] else: vg += [ "--tool=memcheck", "--leak-check=full", "--leak-resolution=low" ] self.args = vg + self.args self._out.flush() try: Popen.__init__(self, self.args, stdout=self._out, stderr=STDOUT, **kwargs) except OSError, e: if e.errno == errno.ENOENT: raise NotFoundError(self, str(e)) raise ProcError(self, str(e))
def __init__(self, args, stdout=None, iotimeout=None, timeout=None, **kwargs): self._output = stdout Popen.__init__(self, args, stdout=PIPE, stderr=STDOUT, **kwargs) self._iostream = IOStream(self.stdout, self._output, iotimeout, timeout, self.timeout_callback) self._iostream.start()
def __init__(self, argv, map=None, timeout=None, close_when_done=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, preexec_fn=None, bufsize=0, **popen_keyw): """Accepts all the same arguments and keywords as `subprocess.Popen`. Input or outputs specified as `PIPE` (now the default) for are wrapped in an asynchronous pipe dispatcher. The timeout is used to create an alarm, which can be cancelled by calling `cancel_timeout()`, `communicate()`, `wait()` or `kill()`. """ Observable.__init__(self) self._map = map # Create the subprocess itself, wrapping preexec_fn in the clear_signals call Popen.__init__(self, argv, preexec_fn=lambda: self.clear_signals(preexec_fn), stdin=stdin, stdout=stdout, stderr=stderr, **popen_keyw) # Set the timeout on the subprocess. If it fails, ignore the failure. try: fto = float(timeout) self._alarmobj = alarm.alarm(fto, self.kill) if fto > 0 else None except: self._alarmobj = None # Wrap the pipe I/O. Sets the Popen and pipe buffer sizes the same; perhaps not optimal. if stdout == PIPE: self.stdout = OutputPipeDispatcher( self.stdout, map=map, ignore_broken_pipe=True, universal_newlines=self.universal_newlines, maxdata=bufsize) self.stdout.obs_add(self._pipe_event) if stderr == PIPE: self.stderr = OutputPipeDispatcher( self.stderr, map=map, ignore_broken_pipe=True, universal_newlines=self.universal_newlines, maxdata=bufsize) self.stderr.obs_add(self._pipe_event) if stdin == PIPE: self.stdin = InputPipeDispatcher(self.stdin, map=map, ignore_broken_pipe=True, close_when_done=close_when_done, maxdata=bufsize) self.stdin.obs_add(self._pipe_event)
def __init__(self, hide_stderr=False): stderr_file = open('/dev/null','w') if hide_stderr else None Popen.__init__(self, ['gdb'], stdin=PIPE, stdout=PIPE, stderr=stderr_file) self._buffer = '' self.read_until_prompt() self.cmd('set print elements 0') self.cmd('set width 0')
def __init__(self, command, *args, **options): args = (command, ) + args options.setdefault('stdout', PIPE) options.setdefault('stderr', STDOUT) if isinstance(options['stdout'], basestring): options['stdout'] = open(options['stdout'], 'w') self.daemon = options.pop('daemon', True) Popen.__init__(self, args, **options)
def __init__ (self, *args, **keywords): self.time = 0 self.vmpeak = 0 self.timeout = False self.memout = False self.path = args[0] Popen.__init__(self, *args, **keywords) PROCESS_QUERY_INFORMATION = 0x0400 PROCESS_VM_READ = 0x0010 self.hProcess = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, False, self.pid)
def __init__(self, *args, **keywords): self.time = 0 self.vmpeak = 0 self.timeout = False self.memout = False self.path = args[0] Popen.__init__(self, *args, **keywords) PROCESS_QUERY_INFORMATION = 0x0400 PROCESS_VM_READ = 0x0010 self.hProcess = ctypes.windll.kernel32.OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, False, self.pid)
def __init__(self, args): Popen.__init__(self, args, shell=False, stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True) self.fromchild = self.stdout self.tochild = self.stdin self.errors = self.stderr
def __init__(self, command, filename, preexec_fn=_setlimits): """Class constructor. :param command: A command to run, e.g., "python". :param filename: A script file to pass to the `command`. :param preexec_fn: A function to call in the child process. """ self.arg_list = [command, filename] Popen.__init__(self, self.arg_list, stdout=PIPE, stdin=PIPE, preexec_fn=preexec_fn)
def start(self): if self.DEBUG: printe(' '.join( ["'" + arg + "'" if ' ' in arg else arg for arg in self.args])) from subprocess import PIPE Popen.__init__(self, self.args, stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True)
def run(self): Popen.__init__(self, [self.path, '-idle', '-slave', '-quiet']+self.args, stdin=PIPE, stdout=PIPE, stderr=PIPE) self.manager = Manager() self.defaults = self.manager.dict() self._state = Value('i') self._state.value = STOPPED self.notifier = SelectQueue() self.calls = SelectQueue() self.results = Queue() self.ioworker = IOWorker(self.stdin, self.stdout, self._state, self.notifier, self.calls, self.results) self.ioworker.start()
def __init__(self, host, nodes): self.host = host self.nodes = nodes self.out = None self.err = None self._pids = None self._cond = Condition() self._pids_thread = Thread(target=self._pids_thread_target) args = ['ssh', host, 'python3', os.path.join(os.getcwd(), 'launch.py')] args.extend(['{}:{}:{}'.format(i, host, p) for i, p in nodes.items()]) Popen.__init__(self, args, stdout=PIPE, stderr=PIPE) self._pids_thread.start()
def __init__(self, args, close_fds=False, cwd=None, env=None, deathSignal=0): if not isinstance(args, list): args = list(args) if env is not None and not isinstance(env, list): env = list(("=".join(item) for item in env.iteritems())) self._deathSignal = int(deathSignal) Popen.__init__(self, args, close_fds=close_fds, cwd=cwd, env=env, stdin=PIPE, stdout=PIPE, stderr=PIPE)
def __init__ (self, *args, **keywords): self.time = 0 self.vmpeak = 0 self.timeout = False self.memout = False self.path = args[0] # Raise stack limit as high as it goes (hopefully unlimited) soft, hard = resource.getrlimit(resource.RLIMIT_STACK) resource.setrlimit(resource.RLIMIT_STACK, (hard, hard)) # Now start the process Popen.__init__(self, *args, **keywords)
def __init__(self, args, ready=None, timeout=30, skip_valgrind=False, **kwargs): """Start an example process""" args = list(args) if platform.system() == "Windows": args[0] += ".exe" self.timeout = timeout self.args = args self.out = "" if not skip_valgrind: args = self.env_args + args try: Popen.__init__(self, args, stdout=PIPE, stderr=STDOUT, **kwargs) except Exception, e: raise ProcError(self, str(e))
def __init__(self, args, **kwargs): """Start an example process""" args = list(args) self.args = args self._out = os.tmpfile() try: Popen.__init__(self, self.env_args + self.args, stdout=self._out, stderr=STDOUT, **kwargs) except OSError, e: if e.errno == errno.ENOENT: raise NotFoundError(self, str(e)) raise ProcError(self, str(e))
def __init__(self, *args, **keywords): self.time = 0 self.vmpeak = 0 self.timeout = False self.memout = False self._aborted = False self._abort_lock = threading.Lock() self._abort_cv = threading.Condition(self._abort_lock) self.on_osx = sys.platform.startswith('darwin') self._set_stack_limit() # Now start the process Popen.__init__(self, *args, **keywords) self.psutil_process = psutil.Process(self.pid)
def run(self): from subprocess import PIPE rout = self.return_stdout rerr = self.return_stderr Popen.__init__(self, self.args, stdout=self.custom_stdout or (PIPE if rout else None), stderr=PIPE if rerr else None, universal_newlines=True ) self.wait() if self.returncode != 0: raise CmdError(self) if self.return_self: return self elif rout and rerr: return self.stdout.read(), self.stderr.read() elif rout: return self.stdout.read() elif rerr: return self.stderr.read()
def run(self): Popen.__init__(self, [self.path, '-idle', '-slave', '-quiet'] + self.args, stdin=PIPE, stdout=PIPE, stderr=PIPE) self.manager = Manager() self.defaults = self.manager.dict() self._state = Value('i') self._state.value = STOPPED self.notifier = SelectQueue() self.calls = SelectQueue() self.results = Queue() self.ioworker = IOWorker(self.stdin, self.stdout, self._state, self.notifier, self.calls, self.results) self.ioworker.start()
def __init__(self, args, map=None, stdin=PIPE, stdout=PIPE, stderr=PIPE, callback=None, maxwrite=512, maxread=1024, **keywmap): """Init the subprocess object, wrapping the standard I/O pipes in dispatchers. Note that the defaults are changed to PIPE for all I/O.""" if map is None: self._map = process_map else: self._map = map self.__callback = callback Popen.__init__(self, args, stdin=stdin, stdout=stdout, stderr=stderr, **keywmap) self.add_subprocess(map) if self.stdin: self.stdin = StdInputHandler(self.stdin, self, maxdata=maxwrite) if self.stdout: self.stdout = StdOutputHandler(self.stdout, self, maxdata=maxread) if self.stderr: self.stderr = StdOutputHandler(self.stderr, self, maxdata=maxread)
def __init__(self, timeslot, mainpassword=""): cmd = config.LIQUIDSOAP + " -v - " # take commands from standard input # spawn the process Popen.__init__(self, shlex.split(cmd), bufsize=-1, universal_newlines=True, stdin=PIPE, stdout=None, stderr=STDOUT) self.logger = logging.getLogger("radiomate.jukebox") logging.basicConfig(filename=config.LOGFILENAME, level=config.LOGGINGLEVEL) # initialize the connection to the database try: self.cm = dao.DBConnectionManager(dbhost = config.DBHOST, dbuser = config.DBUSER, dbpassword = config.DBPASSWORD, database = config.DATABASE) self.pldao = dao.PlayListDAO(self.cm) except Exception, e: raise JukeSlotException(str(e))
def run(self, node, quiet=True): self.node = node if node == this_host: launch_cmd = '' else: launch_cmd = "ssh -x %s" % node cmd = "%s %s %s %s" % (launch_cmd, sys.executable, os.path.abspath(self.script), " ".join(self.args)) print cmd self._output = tempfile.TemporaryFile() if quiet: stdout = self._output else: stdout = None Popen.__init__(self, cmd, stdin=None, stdout=stdout, stderr=STDOUT, shell=True)
def __init__(self, args, skip_valgrind=False, **kwargs): """Start an example process""" args = list(args) if skip_valgrind: self.args = args else: self.args = self.vg_args + args self.kwargs = kwargs self._out = os.tmpfile() try: Popen.__init__(self, self.args, stdout=self._out, stderr=STDOUT, **kwargs) except OSError, e: if e.errno == errno.ENOENT: raise NotFoundError(self, str(e)) raise ProcError(self, str(e))
def __init__(self, **kwargs): self.host = "localhost" self.port = find_free_port() self.client_urls = ["http://{}:{}".format(self.host, self.port)] self.peer_urls = ["http://{}:{}".format(self.host, find_free_port())] tempdir = mkdtemp() register(rmtree, tempdir) kwargs["args"] = [EtcdWrap._etcd_, "--debug", "--data-dir", tempdir, "--listen-client-urls", ",".join(self.client_urls), "--advertise-client-urls", ",".join(self.client_urls), "--listen-peer-urls", ",".join(self.peer_urls)] kwargs["stderr"] = DEVNULL Popen.__init__(self, **kwargs)
def __init__(self, args, close_fds=False, cwd=None, env=None, deathSignal=0, childUmask=None, stdin=PIPE, stdout=PIPE, stderr=PIPE, restore_sigpipe=False): if not isinstance(args, list): args = list(args) self._childUmask = childUmask self._deathSignal = int(deathSignal) if SUPPORTS_RESTORE_SIGPIPE: kw = {'restore_sigpipe': restore_sigpipe} else: kw = {} Popen.__init__(self, args, close_fds=close_fds, cwd=cwd, env=env, stdin=stdin, stdout=stdout, stderr=stderr, **kw)
def __init__(self, args, cpulimit=30, filesizelimit=500, stdinput=None, **keys): self.results = None self.tempout = self.temperr = self.tempin = None args = "limited-exec %s %s %s" % (cpulimit, filesizelimit, args) if keys.get('stdout', None) or PIPE == PIPE: self.tempout = mkstemp() keys['stdout'] = self.tempout[0] if keys.get('stderr', None) or PIPE == PIPE: self.temperr = mkstemp() keys['stderr'] = self.temperr[0] if stdinput is not None: self.tempin = mkstemp() os.write(self.tempin[0], stdinput) os.lseek(self.tempin[0], 0, 0) keys['stdin'] = self.tempin[0] Popen.__init__ (self, re.split(r'\s+', args), **keys)
def run(self, node, quiet=True): self.node = node if node == this_host: launch_cmd = '' else: launch_cmd = "ssh -x %s" % node cmd = "%s %s %s %s" % (launch_cmd, sys.executable, os.path.abspath(self.script), " ".join( self.args)) print cmd self._output = tempfile.TemporaryFile() if quiet: stdout = self._output else: stdout = None Popen.__init__(self, cmd, stdin=None, stdout=stdout, stderr=STDOUT, shell=True)
def __init__(self, size=(1024,768), color_depth=24, bgcolor='black', **kwargs): self.color_depth = color_depth self.size = size self.bgcolor = bgcolor self.screen = 0 self.process = None self.display = None mutex.acquire() try: self.display = self.get_next_free_display() while self.display in USED_DISPLAY_NUMBER_LIST: self.display += 1 USED_DISPLAY_NUMBER_LIST.append(self.display) finally: mutex.release() Popen.__init__(self,self._cmd); self.redirect_display(True) time.sleep(0.1)
def __init__( self, args, stdin: PopenStdArg = None, stdout: PopenStdArg = None, stderr: PopenStdArg = None, **kwargs, ) -> None: Popen.__init__(cast(Popen, self), args, stdin=stdin, stdout=stdout, stderr=stderr, **kwargs) EventManager.__init__(self) # Construct a dict of name=(stream, wrapper, is_pipe) for std streams self._name = " ".join(args) self._std = dict((name, [stream, None, desc == PIPE]) for name, desc, stream in zip( ("stdin", "stdout", "stderr"), (stdin, stdout, stderr), (self.stdin, self.stdout, self.stderr), )) self._iterator: Optional[Iterator[str]] = None
def __init__(self, cmd, cwd=None, env=None, flags=None, stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True): """Create a child process. "cmd" is the command to run, either a list of arguments or a string. "cwd" is a working directory in which to start the child process. "env" is an environment dictionary for the child. "flags" are system-specific process creation flags. On Windows this can be a bitwise-OR of any of the win32process.CREATE_* constants (Note: win32process.CREATE_NEW_PROCESS_GROUP is always OR'd in). On Unix, this is currently ignored. "stdin", "stdout", "stderr" can be used to specify file objects to handle read (stdout/stderr) and write (stdin) events from/to the child. By default a file handle will be created for each io channel automatically, unless set explicitly to None. When set to None, the parent io handles will be used, which can mean the output is redirected to Komodo's log files. "universal_newlines": On by default (the opposite of subprocess). """ self.__use_killpg = False auto_piped_stdin = False preexec_fn = None shell = False if not isinstance(cmd, (list, tuple)): # The cmd is the already formatted, ready for the shell. Otherwise # subprocess.Popen will treat this as simply one command with # no arguments, resulting in an unknown command. shell = True if sys.platform.startswith("win"): # On Windows, cmd requires some special handling of multiple quoted # arguments, as this is what cmd will do: # See if the first character is a quote character and if so, # strip the leading character and remove the last quote character # on the command line, preserving any text after the last quote # character. if cmd and shell and cmd.count('"') > 2: if not cmd.startswith('""') or not cmd.endswith('""'): # Needs to be a re-quoted with additional double quotes. # http://bugs.activestate.com/show_bug.cgi?id=75467 cmd = '"%s"' % (cmd, ) # XXX - subprocess needs to be updated to use the wide string API. # subprocess uses a Windows API that does not accept unicode, so # we need to convert all the environment variables to strings # before we make the call. Temporary fix to bug: # http://bugs.activestate.com/show_bug.cgi?id=72311 if env: encoding = sys.getfilesystemencoding() _enc_env = {} for key, value in env.items(): try: _enc_env[key.encode(encoding)] = value.encode(encoding) except UnicodeEncodeError: # Could not encode it, warn we are dropping it. log.warn("Could not encode environment variable %r " "so removing it", key) env = _enc_env if flags is None: flags = CREATE_NO_WINDOW # If we don't have standard handles to pass to the child process # (e.g. we don't have a console app), then # `subprocess.GetStdHandle(...)` will return None. `subprocess.py` # handles that (http://bugs.python.org/issue1124861) # # However, if Komodo is started from the command line, then # the shell's stdin handle is inherited, i.e. in subprocess.py: # p2cread = GetStdHandle(STD_INPUT_HANDLE) # p2cread == 3 # A few lines later this leads to: # Traceback (most recent call last): # ... # File "...\lib\mozilla\python\komodo\process.py", line 130, in __init__ # creationflags=flags) # File "...\lib\python\lib\subprocess.py", line 588, in __init__ # errread, errwrite) = self._get_handles(stdin, stdout, stderr) # File "...\lib\python\lib\subprocess.py", line 709, in _get_handles # p2cread = self._make_inheritable(p2cread) # File "...\lib\python\lib\subprocess.py", line 773, in _make_inheritable # DUPLICATE_SAME_ACCESS) # WindowsError: [Error 6] The handle is invalid # # I suspect this indicates that the stdin handle inherited by # the subsystem:windows komodo.exe process is invalid -- perhaps # because of mis-used of the Windows API for passing that handle # through. The same error can be demonstrated in PythonWin: # from _subprocess import * # from subprocess import * # h = GetStdHandle(STD_INPUT_HANDLE) # p = Popen("python -c '1'") # p._make_interitable(h) # # I don't understand why the inherited stdin is invalid for # `DuplicateHandle`, but here is how we are working around this: # If we detect the condition where this can fail, then work around # it by setting the handle to `subprocess.PIPE`, resulting in # a different and workable code path. if self._needToHackAroundStdHandles() \ and not (flags & CREATE_NEW_CONSOLE): if stdin is None and sys.stdin \ and sys.stdin.fileno() not in (0, 1, 2): stdin = PIPE auto_piped_stdin = True if stdout is None and sys.stdout \ and sys.stdout.fileno() not in (0, 1, 2): stdout = PIPE if stderr is None and sys.stderr \ and sys.stderr.fileno() not in (0, 1, 2): stderr = PIPE else: # Set flags to 0, subprocess raises an exception otherwise. flags = 0 # Set a preexec function, this will make the sub-process create it's # own session and process group - bug 80651, bug 85693. preexec_fn = os.setsid # Mark as requiring progressgroup killing. This will allow us to # later kill both the spawned shell and the sub-process in one go # (see the kill method) - bug 85693. self.__use_killpg = True # Internal attributes. self.__cmd = cmd self.__retval = None self.__hasTerminated = threading.Condition() # Launch the process. # print "Process: %r in %r" % (cmd, cwd) Popen.__init__(self, cmd, cwd=cwd, env=env, shell=shell, stdin=stdin, stdout=stdout, stderr=stderr, preexec_fn=preexec_fn, universal_newlines=universal_newlines, creationflags=flags) if auto_piped_stdin: self.stdin.close()
def __init__(self, cmd, **args): self.cmd = cmd BasePopen.__init__(self, cmd, **args)
def start(self): if self.DEBUG: printe(" ".join(["'" + arg + "'" if " " in arg else arg for arg in self.args])) from subprocess import PIPE Popen.__init__(self, self.args, stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True)
def __init__(self, *args, **kwargs): _Popen.__init__(self, *args, **kwargs) if self.stdin is not None: self.stdin = GeventFile(self.stdin) if self.stdout is not None: self.stdout = GeventFile(self.stdout)
def __init__(self, cmd, cwd=None, env=None, flags=None, stdin=PIPE, stdout=PIPE, stderr=PIPE, universal_newlines=True): """Create a child process. "cmd" is the command to run, either a list of arguments or a string. "cwd" is a working directory in which to start the child process. "env" is an environment dictionary for the child. "flags" are system-specific process creation flags. On Windows this can be a bitwise-OR of any of the win32process.CREATE_* constants (Note: win32process.CREATE_NEW_PROCESS_GROUP is always OR'd in). On Unix, this is currently ignored. "stdin", "stdout", "stderr" can be used to specify file objects to handle read (stdout/stderr) and write (stdin) events from/to the child. By default a file handle will be created for each io channel automatically, unless set explicitly to None. When set to None, the parent io handles will be used, which can mean the output is redirected to Komodo's log files. "universal_newlines": On by default (the opposite of subprocess). """ self.__use_killpg = False auto_piped_stdin = False preexec_fn = None shell = False if not isinstance(cmd, (list, tuple)): # The cmd is the already formatted, ready for the shell. Otherwise # subprocess.Popen will treat this as simply one command with # no arguments, resulting in an unknown command. shell = True if sys.platform.startswith("win"): # On Windows, cmd requires some special handling of multiple quoted # arguments, as this is what cmd will do: # See if the first character is a quote character and if so, # strip the leading character and remove the last quote character # on the command line, preserving any text after the last quote # character. if cmd and shell and cmd.count('"') > 2: if not cmd.startswith('""') or not cmd.endswith('""'): # Needs to be a re-quoted with additional double quotes. # http://bugs.activestate.com/show_bug.cgi?id=75467 cmd = '"%s"' % (cmd, ) # XXX - subprocess needs to be updated to use the wide string API. # subprocess uses a Windows API that does not accept unicode, so # we need to convert all the environment variables to strings # before we make the call. Temporary fix to bug: # http://bugs.activestate.com/show_bug.cgi?id=72311 if env: encoding = sys.getfilesystemencoding() _enc_env = {} for key, value in env.items(): try: _enc_env[key.encode(encoding)] = value.encode(encoding) except UnicodeEncodeError: # Could not encode it, warn we are dropping it. log.warn( "Could not encode environment variable %r " "so removing it", key) env = _enc_env if flags is None: flags = CREATE_NO_WINDOW # If we don't have standard handles to pass to the child process # (e.g. we don't have a console app), then # `subprocess.GetStdHandle(...)` will return None. `subprocess.py` # handles that (http://bugs.python.org/issue1124861) # # However, if Komodo is started from the command line, then # the shell's stdin handle is inherited, i.e. in subprocess.py: # p2cread = GetStdHandle(STD_INPUT_HANDLE) # p2cread == 3 # A few lines later this leads to: # Traceback (most recent call last): # ... # File "...\lib\mozilla\python\komodo\process.py", line 130, in __init__ # creationflags=flags) # File "...\lib\python\lib\subprocess.py", line 588, in __init__ # errread, errwrite) = self._get_handles(stdin, stdout, stderr) # File "...\lib\python\lib\subprocess.py", line 709, in _get_handles # p2cread = self._make_inheritable(p2cread) # File "...\lib\python\lib\subprocess.py", line 773, in _make_inheritable # DUPLICATE_SAME_ACCESS) # WindowsError: [Error 6] The handle is invalid # # I suspect this indicates that the stdin handle inherited by # the subsystem:windows komodo.exe process is invalid -- perhaps # because of mis-used of the Windows API for passing that handle # through. The same error can be demonstrated in PythonWin: # from _subprocess import * # from subprocess import * # h = GetStdHandle(STD_INPUT_HANDLE) # p = Popen("python -c '1'") # p._make_interitable(h) # # I don't understand why the inherited stdin is invalid for # `DuplicateHandle`, but here is how we are working around this: # If we detect the condition where this can fail, then work around # it by setting the handle to `subprocess.PIPE`, resulting in # a different and workable code path. if self._needToHackAroundStdHandles() \ and not (flags & CREATE_NEW_CONSOLE): if stdin is None and sys.stdin \ and sys.stdin.fileno() not in (0,1,2): stdin = PIPE auto_piped_stdin = True if stdout is None and sys.stdout \ and sys.stdout.fileno() not in (0,1,2): stdout = PIPE if stderr is None and sys.stderr \ and sys.stderr.fileno() not in (0,1,2): stderr = PIPE else: # Set flags to 0, subprocess raises an exception otherwise. flags = 0 # Set a preexec function, this will make the sub-process create it's # own session and process group - bug 80651, bug 85693. preexec_fn = os.setsid # Mark as requiring progressgroup killing. This will allow us to # later kill both the spawned shell and the sub-process in one go # (see the kill method) - bug 85693. self.__use_killpg = True # Internal attributes. self.__cmd = cmd self.__retval = None self.__hasTerminated = threading.Condition() # Launch the process. #print "Process: %r in %r" % (cmd, cwd) Popen.__init__(self, cmd, cwd=cwd, env=env, shell=shell, stdin=stdin, stdout=stdout, stderr=stderr, preexec_fn=preexec_fn, universal_newlines=universal_newlines, creationflags=flags) if auto_piped_stdin: self.stdin.close()
def __init__(self): Popen.__init__(self, ['less', '-FRX'], stdin=PIPE)
def __init__(self, arg, *args, **kwargs): if arg[:2] == [sys.executable, '-c']: assert len(arg) == 3, arg arg = arg[:2] + [monkey_patch + arg[2]] _Popen.__init__(self, arg, *args, **kwargs)
def __init__(self, *popen_args, **popen_kwargs): if sys.version_info.major ==2: return Popen.__init__(*popen_args, **popen_kwargs) if sys.version_info.major == 3 : popen_kwargs['encoding'] = 'utf8' return Popen.__init__(*popen_args, **popen_kwargs)
def __init__(self, *args, **kwargs): self.timeout = kwargs.pop('timeout', 0) self.timer = None self.done = Event() Popen.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs): self.encoding = kwargs.pop("encoding", None) self.machine = kwargs.pop("machine", None) Popen.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs): self._procname = args[0][0] Popen.__init__(self, *args, **kwargs)
def __init__(self, cargs, *args): Popen.__init__(self, cargs, *args, preexec_fn = preexec) self.args = cargs