# multiprocessing.connection.py


######### 인터페이스는 이거고
class _ConnectionBase:
    ...
    def recv_bytes(self, maxlength=None):
        """
        Receive bytes data as a bytes object.
        """
        self._check_closed()
        self._check_readable()
        if maxlength is not None and maxlength < 0:
            raise ValueError("negative maxlength")
        buf = self._recv_bytes(maxlength)
        if buf is None:
            self._bad_message_length()
        return buf.getvalue()



######### 윈도우즈 구현체는 이거고
if _winapi:

    class PipeConnection(_ConnectionBase):
        ...
        def _recv_bytes(self, maxsize=None):
            if self._got_empty_message:
                self._got_empty_message = False
                return io.BytesIO()
            else:
                bsize = 128 if maxsize is None else min(maxsize, 128)
                try:
                    ov, err = _winapi.ReadFile(self._handle, bsize,
                                                overlapped=True)
                    try:
                        if err == _winapi.ERROR_IO_PENDING:
                            waitres = _winapi.WaitForMultipleObjects(
                                [ov.event], False, INFINITE)
                            assert waitres == WAIT_OBJECT_0
                    except:
                        ov.cancel()
                        raise
                    finally:
                        nread, err = ov.GetOverlappedResult(True)
                        if err == 0:
                            f = io.BytesIO()
                            f.write(ov.getbuffer())
                            return f
                        elif err == _winapi.ERROR_MORE_DATA:
                            return self._get_more_data(ov, maxsize)
                except OSError as e:
                    if e.winerror == _winapi.ERROR_BROKEN_PIPE:
                        raise EOFError
                    else:
                        raise
            raise RuntimeError("shouldn't get here; expected KeyboardInterrupt")



########## xNix 구현체는 이거다.
##########   정확히는 유닉스에서 파이프/소켓 공용 구현체고,
##########   윈도우에서는 소켓 기반 연결에만 쓰인다 (윈도우의 Pipe()는 위의 PipeConnection을 씀)
class Connection(_ConnectionBase):
    ...
    if _winapi:
        def _close(self, _close=_multiprocessing.closesocket):
            _close(self._handle)
        _write = _multiprocessing.send
        _read = _multiprocessing.recv
    else:
        def _close(self, _close=os.close):
            _close(self._handle)
        _write = os.write
    # 유닉스면 os.read다. WSL도 리눅스라서 이 길을 탄다
        _read = os.read

    def _recv(self, size, read=_read):
        buf = io.BytesIO()
        handle = self._handle
        remaining = size
        while remaining > 0:
            # 이 read가 운영체제의 read다. read(2) 시스템콜.
            #   빈 파이프면 여기서 커널이 프로세스를 재운다. "서 있는" 지점의 실체.
            chunk = read(handle, remaining)
            n = len(chunk)
            if n == 0:
                if remaining == size:
                    raise EOFError
                else:
                    raise OSError("got end of file during message")
            buf.write(chunk)
            remaining -= n
        return buf

    def _recv_bytes(self, maxsize=None):
    # 이 함수는 운영체제 함수가 아니라 메시지 프레이밍 계층이다.
    #   os.read는 "최대 N바이트"만 보장하고 메시지 경계를 모르니,
    #   4바이트 길이 헤더(-1이면 8바이트 확장)를 먼저 읽고 본문을 그만큼 채워서
    #   문서가 약속한 "완전한 메시지 하나"를 복원한다
        buf = self._recv(4)
        size, = struct.unpack("!i", buf.getvalue())
        if size == -1:
            buf = self._recv(8)
            size, = struct.unpack("!Q", buf.getvalue())
        if maxsize is not None and size > maxsize:
            return None
        return self._recv(size)