ACIL FM

Nama	Ukuran	Aksi
dummy	-	Open
__pycache__	-	Open
connection.py	31.11 MB	View DL Edit
context.py	10.99 MB	View DL Edit
forkserver.py	11.86 MB	View DL Edit
heap.py	11.35 MB	View DL Edit
managers.py	46.19 MB	View DL Edit
pool.py	31.79 MB	View DL Edit
popen_fork.py	2.32 MB	View DL Edit
popen_forkserver.py	2.18 MB	View DL Edit
popen_spawn_posix.py	1.98 MB	View DL Edit
popen_spawn_win32.py	3.92 MB	View DL Edit
process.py	11.72 MB	View DL Edit
queues.py	11.74 MB	View DL Edit
reduction.py	9.29 MB	View DL Edit
resource_sharer.py	5.01 MB	View DL Edit
resource_tracker.py	8.41 MB	View DL Edit
sharedctypes.py	6.16 MB	View DL Edit
shared_memory.py	17.96 MB	View DL Edit
spawn.py	9.08 MB	View DL Edit
synchronize.py	11.34 MB	View DL Edit
util.py	13.68 MB	View DL Edit
__init__.py	916 B	View DL Edit

Edit file: /lib64/python3.9/multiprocessing/popen_forkserver.py

import io
import os

from .context import reduction, set_spawning_popen
if not reduction.HAVE_SEND_HANDLE:
    raise ImportError('No support for sending fds between processes')
from . import forkserver
from . import popen_fork
from . import spawn
from . import util

__all__ = ['Popen']

#
# Wrapper for an fd used while launching a process
#

class _DupFd(object):
    def __init__(self, ind):
        self.ind = ind
    def detach(self):
        return forkserver.get_inherited_fds()[self.ind]

#
# Start child process using a server process
#

class Popen(popen_fork.Popen):
    method = 'forkserver'
    DupFd = _DupFd

def __init__(self, process_obj):
        self._fds = []
        super().__init__(process_obj)

def duplicate_for_child(self, fd):
        self._fds.append(fd)
        return len(self._fds) - 1

def _launch(self, process_obj):
        prep_data = spawn.get_preparation_data(process_obj._name)
        buf = io.BytesIO()
        set_spawning_popen(self)
        try:
            reduction.dump(prep_data, buf)
            reduction.dump(process_obj, buf)
        finally:
            set_spawning_popen(None)

self.sentinel, w = forkserver.connect_to_new_process(self._fds)
        # Keep a duplicate of the data pipe's write end as a sentinel of the
        # parent process used by the child process.
        _parent_w = os.dup(w)
        self.finalizer = util.Finalize(self, util.close_fds,
                                       (_parent_w, self.sentinel))
        with open(w, 'wb', closefd=True) as f:
            f.write(buf.getbuffer())
        self.pid = forkserver.read_signed(self.sentinel)

def poll(self, flag=os.WNOHANG):
        if self.returncode is None:
            from multiprocessing.connection import wait
            timeout = 0 if flag == os.WNOHANG else None
            if not wait([self.sentinel], timeout):
                return None
            try:
                self.returncode = forkserver.read_signed(self.sentinel)
            except (OSError, EOFError):
                # This should not happen usually, but perhaps the forkserver
                # process itself got killed
                self.returncode = 255

return self.returncode

Batal