Python Popen.__init__方法代码示例

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
 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()

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
    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)

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
 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)

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
    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"

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
    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()

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
 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()

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
    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()

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
  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')

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
 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)

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
 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)

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
 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()

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
    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)

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
    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)

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
 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))

# 需要导入模块: from subprocess import Popen [as 别名]
# 或者: from subprocess.Popen import __init__ [as 别名]
	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()