我们从Python开源项目中，提取了以下29个代码示例，用于说明如何使用subprocess.CREATE_NEW_PROCESS_GROUP。
def setUp(self): super(Base, self).setUp() self.lines = [] self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind(("127.0.0.1", 0)) self.t = threading.Thread(target=self.readlog) self.t.daemon = True self.t.start() examplepy = os.path.join(os.path.dirname(__file__), "examples.py") if os.name == 'posix': kwargs = { 'preexec_fn': os.setsid } else: kwargs = { 'creationflags': subprocess.CREATE_NEW_PROCESS_GROUP } self.subp = subprocess.Popen(['python', examplepy, self.name, str(self.sock.getsockname()[1])], **kwargs)
def _tunnel(ttype, args): cli_test_ssh_key_path = os.environ['CLI_TEST_SSH_KEY_PATH'] cmd = ('ssh-agent /bin/bash -c "ssh-add {0} 2> /dev/null && ' + '$(which dcos-tunnel) tunnel {1} {2}"' ).format(cli_test_ssh_key_path, ttype, ' '.join(args)) pfn = None if sys.platform != 'win32': pfn = os.setsid cflag = 0 if sys.platform == 'win32': cflag = subprocess.CREATE_NEW_PROCESS_GROUP print(cmd) return subprocess.Popen(shlex.split(cmd), preexec_fn=pfn, creationflags=cflag, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def pyrun(src): """Run python code 'src' in a separate interpreter. Return subprocess exit code. """ if PY3: src = bytes(src, 'ascii') with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f: f.write(src) f.flush() test_files.append(f.name) code = subprocess.call( [sys.executable, f.name], stdout=None, stderr=None, # creationflags=subprocess.CREATE_NEW_PROCESS_GROUP ) return code
def run_xcrysden(fname, block=True): if config.XCrysExec == None: warnings.warn("XCrysDen executable not found. Check configs.") return False spargs = dict( args = [config.XCrysExec, "--xsf", fname], stdout = subprocess.PIPE, stderr = subprocess.PIPE ) if not block: if os.name == 'posix': spargs['preexec_fn'] = os.setpgrp elif os.name == 'nt': spargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP p = subprocess.Popen(**spargs) if block: out, err = p.communicate() return True
def start(self): if sys.platform.startswith("win"): self.proc = subprocess.Popen( self.args, stdin=self.stdin_read, stdout=self.output, stderr=subprocess.STDOUT, bufsize=0, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP) else: self.proc = subprocess.Popen( self.args, stdin=self.stdin_read, stdout=self.output, stderr=subprocess.STDOUT, bufsize=0, ) return self.proc
def __init__(self, radio): self.radio = radio # start wireshark spargs = dict( args=['wireshark', '-k', '-i', '-'], # Read packets from stdin immediately stdin=subprocess.PIPE, stderr=open(os.devnull, 'w'), ) if os.name == 'posix': spargs['preexec_fn'] = os.setpgrp elif os.name == 'nt': spargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP self.wireshark_proc = subprocess.Popen(**spargs) self.pd = killerbee.PcapDumper(killerbee.DLT_IEEE802_15_4, self.wireshark_proc.stdin,)
def open_process(command, cwd=None, shell=True, _popen_lock=threading.Lock()): kwargs = { "shell": shell, "stdout": subprocess.PIPE, "stderr": subprocess.STDOUT, "stdin": subprocess.PIPE, "bufsize": 1, # Line buffered "universal_newlines": True, } if cwd is not None: kwargs["cwd"] = cwd # Prevent signal propagation from parent process try: # Windows kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP except AttributeError: # Unix kwargs["preexec_fn"] = os.setpgrp with _popen_lock: # Work around Python 2 Popen race condition return subprocess.Popen(command, **kwargs)
def submit_code(timeout=5): code = request.form.get("code", "") inp = request.form.get("input", "") print(code, inp) warnings = int(request.form.get("warnings", "0"), 10) use_hex = int(request.form.get("hex", "0"), 10) args = [sys.executable, 'main.py', '--safe', '--', code] stderr = PIPE if warnings: args.insert(2, "--warnings") stderr = STDOUT if use_hex: args.insert(2, "--hex") with Popen(args, stdin=PIPE, stdout=PIPE, stderr=stderr, creationflags=is_windows and subprocess.CREATE_NEW_PROCESS_GROUP) as process: process.stdin.write(bytearray(inp, "utf-8")) process.stdin.close() response = "" try: process.wait(timeout) except TimeoutExpired: response = "Timeout running code.\n" if is_windows: os.kill(process.pid, signal.CTRL_BREAK_EVENT) else: process.send_signal(signal.SIGTERM) try: process.wait(2) except TimeoutExpired: response += "Really timed out code\n" process.kill() response += process.stdout.read().decode("cp1252", errors="replace") return response
def executeCmd(cmd): command=['cmd.exe', '/c'] + cmd.split() res = subprocess.check_output(command, stderr=subprocess.STDOUT, stdin=subprocess.PIPE, universal_newlines=True) # info=subprocess.STARTUPINFO() # info.dwFlags=subprocess.STARTF_USESHOWWINDOW | subprocess.CREATE_NEW_PROCESS_GROUP # info.wShowWindow=subprocess.SW_HIDE # p=subprocess.Popen(command, startupinfo=info, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, universal_newlines=True) # results, _=p.communicate() return res
def __init__(self, cmd, timeout=30, maxread=2000, searchwindowsize=None, logfile=None, cwd=None, env=None, encoding=None, codec_errors='strict'): super(PopenSpawn, self).__init__(timeout=timeout, maxread=maxread, searchwindowsize=searchwindowsize, logfile=logfile, encoding=encoding, codec_errors=codec_errors) kwargs = dict(bufsize=0, stdin=subprocess.PIPE, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, cwd=cwd, env=env) if sys.platform == 'win32': startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW kwargs['startupinfo'] = startupinfo kwargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP if not isinstance(cmd, (list, tuple)): cmd = shlex.split(cmd) self.proc = subprocess.Popen(cmd, **kwargs) self.closed = False self._buf = self.string_type() self._read_queue = Queue() self._read_thread = threading.Thread(target=self._read_incoming) self._read_thread.setDaemon(True) self._read_thread.start()
def _get_new_progress_group_args(): """ Gets a tuple containing the `preexec_fn` and `creationflags` parameters to subprocess.Popen required to create a subprocess that can be killed via os.killpg without killing the process group of the parent process. """ preexec_fn = None creationflags = 0 if not is_jython(): if get_os() == 'windows': creationflags = subprocess.CREATE_NEW_PROCESS_GROUP else: preexec_fn = os.setsid return preexec_fn, creationflags
def _kill_with_event(self, event, name): tagname = "test_os_%s" % uuid.uuid1() m = mmap.mmap(-1, 1, tagname) m[0] = 0 # Run a script which has console control handling enabled. proc = subprocess.Popen([sys.executable, os.path.join(os.path.dirname(__file__), "win_console_handler.py"), tagname], creationflags=subprocess.CREATE_NEW_PROCESS_GROUP) # Let the interpreter startup before we send signals. See #3137. count, max = 0, 100 while count < max and proc.poll() is None: if m[0] == 1: break time.sleep(0.1) count += 1 else: # Forcefully kill the process if we weren't able to signal it. os.kill(proc.pid, signal.SIGINT) self.fail("Subprocess didn't finish initialization") os.kill(proc.pid, event) # proc.send_signal(event) could also be done here. # Allow time for the signal to be passed and the process to exit. time.sleep(0.5) if not proc.poll(): # Forcefully kill the process if we weren't able to signal it. os.kill(proc.pid, signal.SIGINT) self.fail("subprocess did not stop on {}".format(name))
def execute_job(self, full_id, resources_assigned): self.logger.info("Execute job %s ..." % (full_id, )) self.executed_jobs += 1 with open(os.devnull, 'r+b', 0) as DEVNULL: my_env = os.environ.copy() my_env['AETROS_ATTY'] = '1' if self.ssh_key_private is not None: my_env['AETROS_SSH_KEY_BASE64'] = self.ssh_key_private args = [sys.executable, '-m', 'aetros', 'start'] if resources_assigned['gpus']: for gpu_id in resources_assigned['gpus']: args += ['--gpu-device', gpu_id] args += [full_id] self.logger.info('$ ' + ' '.join(args)) self.server.send_message({'type': 'job-executed', 'id': full_id}) # Since JobBackend sends SIGINT to its current process group, wit sends also to its parents when same pg. # We need to change the process group of the process, so this won't happen. # If we don't this, the process of ServerCommand receives the SIGINT as well. kwargs = {} if os.name == 'nt': kwargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP else: kwargs['preexec_fn'] = os.setsid process = subprocess.Popen(args, bufsize=1, env=my_env, stdin=DEVNULL, stderr=subprocess.PIPE, stdout=subprocess.PIPE, **kwargs) if self.show_stdout: self.general_logger_stdout.attach(process.stdout, read_line=True) self.general_logger_stderr.attach(process.stderr, read_line=True) self.job_processes[full_id] = process
def _kill_with_event(self, event, name): tagname = "test_os_%s" % uuid.uuid1() m = mmap.mmap(-1, 1, tagname) m[0] = '0' # Run a script which has console control handling enabled. proc = subprocess.Popen([sys.executable, os.path.join(os.path.dirname(__file__), "win_console_handler.py"), tagname], creationflags=subprocess.CREATE_NEW_PROCESS_GROUP) # Let the interpreter startup before we send signals. See #3137. count, max = 0, 20 while count < max and proc.poll() is None: if m[0] == '1': break time.sleep(0.5) count += 1 else: self.fail("Subprocess didn't finish initialization") os.kill(proc.pid, event) # proc.send_signal(event) could also be done here. # Allow time for the signal to be passed and the process to exit. time.sleep(0.5) if not proc.poll(): # Forcefully kill the process if we weren't able to signal it. os.kill(proc.pid, signal.SIGINT) self.fail("subprocess did not stop on {}".format(name))
def StartProcess(commandline): TouchFile(watchdogfile) return subprocess.Popen([sys.executable]+commandline,creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
def __init__(self, cmd, timeout=30, maxread=2000, searchwindowsize=None, logfile=None, cwd=None, env=None, encoding=None, codec_errors='strict'): super(PopenSpawn, self).__init__(timeout=timeout, maxread=maxread, searchwindowsize=searchwindowsize, logfile=logfile, encoding=encoding, codec_errors=codec_errors) kwargs = dict(bufsize=0, stdin=subprocess.PIPE, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, cwd=cwd, env=env) if sys.platform == 'win32': startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW kwargs['startupinfo'] = startupinfo kwargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP if isinstance(cmd, string_types) and sys.platform != 'win32': cmd = shlex.split(cmd, posix=os.name == 'posix') self.proc = subprocess.Popen(cmd, **kwargs) self.pid = self.proc.pid self.closed = False self._buf = self.string_type() self._read_queue = Queue() self._read_thread = threading.Thread(target=self._read_incoming) self._read_thread.setDaemon(True) self._read_thread.start()
def start(self): if self.child_process: return # already started self.prestart() logger = open(os.path.join(self.base_dir, '%s.log' % self.name), 'wt') try: command = self.get_server_commandline() flags = 0 if os.name == 'nt': flags |= subprocess.CREATE_NEW_PROCESS_GROUP custom_env = os.environ.copy() custom_env["HOME"] = self.home kwargs = {'env': custom_env, 'creationflags': flags} if not self.debug: kwargs.update({'stdout': logger, 'stderr': logger}) self.child_process = subprocess.Popen(command, **kwargs) except Exception as exc: raise RuntimeError('failed to launch %s: %r' % (self.name, exc)) else: try: self.wait_booting() self.poststart() except: self.stop() raise finally: logger.close()
def test_log_follow(): package_install('chronos', deploy=True) args = ['dcos', 'service', 'log', 'chronos', '--follow'] if sys.platform == 'win32': proc = subprocess.Popen( args, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP, stdout=subprocess.PIPE, stderr=subprocess.PIPE) else: # disable stdout/stderr buffering: # https://docs.python.org/3/using/cmdline.html#cmdoption-u my_env = os.environ.copy() my_env['PYTHONUNBUFFERED'] = 'x' # os.setsid is only available for Unix: # https://docs.python.org/2/library/os.html#os.setsid proc = subprocess.Popen( args, preexec_fn=os.setsid, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=my_env) time.sleep(10) proc.poll() assert proc.returncode is None if sys.platform == 'win32': os.kill(proc.pid, signal.CTRL_BREAK_EVENT) else: # using Unix-only commands os.killpg + os.getgid # https://docs.python.org/2/library/os.html#os.killpg # https://docs.python.org/2/library/os.html#os.getpgid os.killpg(os.getpgid(proc.pid), 15) stdout = proc.stdout.read() stderr = proc.stderr.read() print('STDOUT: {}'.format(stdout)) print('STDERR: {}'.format(stderr)) assert len(stdout.decode('utf-8').split('\n')) > 3 assert_lines(['dcos', 'service', 'log', 'chronos', '--lines=4'], 4) exec_command(['dcos', 'package', 'uninstall', 'chronos', '--yes'])
def StartProcess(executable_name, clangd_log_path=None): if not clangd_log_path or not log.logger.isEnabledFor(log.DEBUG): clangd_log_path = os.devnull fdClangd = open(clangd_log_path, 'w+') # fix executable file name under windows (both cygwin and native win32) if sys_platform == 'msys' or sys_platform == 'win32': if not executable_name.endswith('.exe'): executable_name += '.exe' # apply platform-specific hacks if sys_platform != 'win32': # for posix or cygwin fdInRead, fdInWrite = Pipe() fdOutRead, fdOutWrite = Pipe() SetCloseOnExec(fdInWrite) SetCloseOnExec(fdOutRead) else: # only native win32 fdInRead, fdInWrite = Win32SocketPair() fdOutRead, fdOutWrite = Win32SocketPair() cwd = os.path.dirname(executable_name) # apply native win32's hack if sys_platform == 'win32': # we need hide this subprocess's window under windows, or it opens a new visible window startupinfo = subprocess.STARTUPINFO() startupinfo.dwFlags = subprocess.STARTF_USESTDHANDLES | subprocess.STARTF_USESHOWWINDOW startupinfo.wShowWindow = subprocess.SW_HIDE clangd = Popen( executable_name, stdin=fdInRead, stdout=fdOutWrite, stderr=fdClangd, cwd=cwd, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP, startupinfo=startupinfo) else: clangd = Popen( executable_name, stdin=fdInRead, stdout=fdOutWrite, stderr=fdClangd, cwd=cwd) return clangd, fdInWrite, fdOutRead, fdClangd
