123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965 |
- #
- # A higher level module for using sockets (or Windows named pipes)
- #
- # multiprocessing/connection.py
- #
- # Copyright (c) 2006-2008, R Oudkerk
- # Licensed to PSF under a Contributor Agreement.
- #
- from __future__ import absolute_import
-
- import io
- import os
- import sys
- import select
- import socket
- import struct
- import errno
- import tempfile
- import itertools
-
- import _multiprocessing
- from ..compat import setblocking
- from ..exceptions import AuthenticationError, BufferTooShort
- from ..five import monotonic
- from ..util import get_temp_dir, Finalize, sub_debug
- from ..reduction import ForkingPickler
-
- try:
- import _winapi
-
- WAIT_OBJECT_0 = _winapi.WAIT_OBJECT_0
- WAIT_TIMEOUT = _winapi.WAIT_TIMEOUT
- INFINITE = _winapi.INFINITE
- # if we got here, we seem to be running on Windows. Handle probably
- # missing WAIT_ABANDONED_0 constant:
- try:
- WAIT_ABANDONED_0 = _winapi.WAIT_ABANDONED_0
- except ImportError:
- # _winapi seems to be not exporting
- # this constant, fallback solution until
- # exported in _winapio
- WAIT_ABANDONED_0 = 128
- except ImportError:
- if sys.platform == 'win32':
- raise
- _winapi = None
-
- __all__ = ['Client', 'Listener', 'Pipe', 'wait']
-
- #
- #
- #
-
- BUFSIZE = 8192
- # A very generous timeout when it comes to local connections...
- CONNECTION_TIMEOUT = 20.
-
- _mmap_counter = itertools.count()
-
- default_family = 'AF_INET'
- families = ['AF_INET']
-
- if hasattr(socket, 'AF_UNIX'):
- default_family = 'AF_UNIX'
- families += ['AF_UNIX']
-
- if sys.platform == 'win32':
- default_family = 'AF_PIPE'
- families += ['AF_PIPE']
-
-
- def _init_timeout(timeout=CONNECTION_TIMEOUT):
- return monotonic() + timeout
-
-
- def _check_timeout(t):
- return monotonic() > t
-
-
- def arbitrary_address(family):
- '''
- Return an arbitrary free address for the given family
- '''
- if family == 'AF_INET':
- return ('localhost', 0)
- elif family == 'AF_UNIX':
- return tempfile.mktemp(prefix='listener-', dir=get_temp_dir())
- elif family == 'AF_PIPE':
- return tempfile.mktemp(prefix=r'\\.\pipe\pyc-%d-%d-' %
- (os.getpid(), next(_mmap_counter)))
- else:
- raise ValueError('unrecognized family')
-
-
- def _validate_family(family):
- '''
- Checks if the family is valid for the current environment.
- '''
- if sys.platform != 'win32' and family == 'AF_PIPE':
- raise ValueError('Family %s is not recognized.' % family)
-
- if sys.platform == 'win32' and family == 'AF_UNIX':
- # double check
- if not hasattr(socket, family):
- raise ValueError('Family %s is not recognized.' % family)
-
-
- def address_type(address):
- '''
- Return the types of the address
-
- This can be 'AF_INET', 'AF_UNIX', or 'AF_PIPE'
- '''
- if type(address) == tuple:
- return 'AF_INET'
- elif type(address) is str and address.startswith('\\\\'):
- return 'AF_PIPE'
- elif type(address) is str:
- return 'AF_UNIX'
- else:
- raise ValueError('address type of %r unrecognized' % address)
-
- #
- # Connection classes
- #
-
-
- class _ConnectionBase:
- _handle = None
-
- def __init__(self, handle, readable=True, writable=True):
- handle = handle.__index__()
- if handle < 0:
- raise ValueError("invalid handle")
- if not readable and not writable:
- raise ValueError(
- "at least one of `readable` and `writable` must be True")
- self._handle = handle
- self._readable = readable
- self._writable = writable
-
- # XXX should we use util.Finalize instead of a __del__?
-
- def __del__(self):
- if self._handle is not None:
- self._close()
-
- def _check_closed(self):
- if self._handle is None:
- raise OSError("handle is closed")
-
- def _check_readable(self):
- if not self._readable:
- raise OSError("connection is write-only")
-
- def _check_writable(self):
- if not self._writable:
- raise OSError("connection is read-only")
-
- def _bad_message_length(self):
- if self._writable:
- self._readable = False
- else:
- self.close()
- raise OSError("bad message length")
-
- @property
- def closed(self):
- """True if the connection is closed"""
- return self._handle is None
-
- @property
- def readable(self):
- """True if the connection is readable"""
- return self._readable
-
- @property
- def writable(self):
- """True if the connection is writable"""
- return self._writable
-
- def fileno(self):
- """File descriptor or handle of the connection"""
- self._check_closed()
- return self._handle
-
- def close(self):
- """Close the connection"""
- if self._handle is not None:
- try:
- self._close()
- finally:
- self._handle = None
-
- def send_bytes(self, buf, offset=0, size=None):
- """Send the bytes data from a bytes-like object"""
- self._check_closed()
- self._check_writable()
- m = memoryview(buf)
- # HACK for byte-indexing of non-bytewise buffers (e.g. array.array)
- if m.itemsize > 1:
- m = memoryview(bytes(m))
- n = len(m)
- if offset < 0:
- raise ValueError("offset is negative")
- if n < offset:
- raise ValueError("buffer length < offset")
- if size is None:
- size = n - offset
- elif size < 0:
- raise ValueError("size is negative")
- elif offset + size > n:
- raise ValueError("buffer length < offset + size")
- self._send_bytes(m[offset:offset + size])
-
- def send(self, obj):
- """Send a (picklable) object"""
- self._check_closed()
- self._check_writable()
- self._send_bytes(ForkingPickler.dumps(obj))
-
- 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()
-
- def recv_bytes_into(self, buf, offset=0):
- """
- Receive bytes data into a writeable buffer-like object.
- Return the number of bytes read.
- """
- self._check_closed()
- self._check_readable()
- with memoryview(buf) as m:
- # Get bytesize of arbitrary buffer
- itemsize = m.itemsize
- bytesize = itemsize * len(m)
- if offset < 0:
- raise ValueError("negative offset")
- elif offset > bytesize:
- raise ValueError("offset too large")
- result = self._recv_bytes()
- size = result.tell()
- if bytesize < offset + size:
- raise BufferTooShort(result.getvalue())
- # Message can fit in dest
- result.seek(0)
- result.readinto(
- m[offset // itemsize:(offset + size) // itemsize]
- )
- return size
-
- def recv_payload(self):
- return self._recv_bytes().getbuffer()
-
- def recv(self):
- """Receive a (picklable) object"""
- self._check_closed()
- self._check_readable()
- buf = self._recv_bytes()
- return ForkingPickler.loads(buf.getbuffer())
-
- def poll(self, timeout=0.0):
- """Whether there is any input available to be read"""
- self._check_closed()
- self._check_readable()
- return self._poll(timeout)
-
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_value, exc_tb):
- self.close()
-
-
- if _winapi:
-
- class PipeConnection(_ConnectionBase):
- """
- Connection class based on a Windows named pipe.
- Overlapped I/O is used, so the handles must have been created
- with FILE_FLAG_OVERLAPPED.
- """
- _got_empty_message = False
-
- def _close(self, _CloseHandle=_winapi.CloseHandle):
- _CloseHandle(self._handle)
-
- def _send_bytes(self, buf):
- ov, err = _winapi.WriteFile(self._handle, buf, 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:
- nwritten, err = ov.GetOverlappedResult(True)
- assert err == 0
- assert nwritten == len(buf)
-
- 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"
- )
-
- def _poll(self, timeout):
- if (self._got_empty_message or
- _winapi.PeekNamedPipe(self._handle)[0] != 0):
- return True
- return bool(wait([self], timeout))
-
- def _get_more_data(self, ov, maxsize):
- buf = ov.getbuffer()
- f = io.BytesIO()
- f.write(buf)
- left = _winapi.PeekNamedPipe(self._handle)[1]
- assert left > 0
- if maxsize is not None and len(buf) + left > maxsize:
- self._bad_message_length()
- ov, err = _winapi.ReadFile(self._handle, left, overlapped=True)
- rbytes, err = ov.GetOverlappedResult(True)
- assert err == 0
- assert rbytes == left
- f.write(ov.getbuffer())
- return f
-
-
- class Connection(_ConnectionBase):
- """
- Connection class based on an arbitrary file descriptor (Unix only), or
- a socket handle (Windows).
- """
-
- if _winapi:
- def _close(self, _close=_multiprocessing.closesocket):
- _close(self._handle)
- _write = _multiprocessing.send
- _read = _multiprocessing.recv
- else:
- def _close(self, _close=os.close): # noqa
- _close(self._handle)
- _write = os.write
- _read = os.read
-
- def send_offset(self, buf, offset, write=_write):
- return write(self._handle, buf[offset:])
-
- def _send(self, buf, write=_write):
- remaining = len(buf)
- while True:
- try:
- n = write(self._handle, buf)
- except OSError as exc:
- if exc.errno == errno.EINTR:
- continue
- raise
- remaining -= n
- if remaining == 0:
- break
- buf = buf[n:]
-
- def setblocking(self, blocking):
- setblocking(self._handle, blocking)
-
- def _recv(self, size, read=_read):
- buf = io.BytesIO()
- handle = self._handle
- remaining = size
- while remaining > 0:
- try:
- chunk = read(handle, remaining)
- except OSError as exc:
- if exc.errno == errno.EINTR:
- continue
- raise
- 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 _send_bytes(self, buf):
- # For wire compatibility with 3.2 and lower
- n = len(buf)
- self._send(struct.pack("!i", n))
- # The condition is necessary to avoid "broken pipe" errors
- # when sending a 0-length buffer if the other end closed the pipe.
- if n > 0:
- self._send(buf)
-
- def _recv_bytes(self, maxsize=None):
- buf = self._recv(4)
- size, = struct.unpack("!i", buf.getvalue())
- if maxsize is not None and size > maxsize:
- return None
- return self._recv(size)
-
- def _poll(self, timeout):
- r = wait([self], timeout)
- return bool(r)
-
-
- #
- # Public functions
- #
-
- class Listener(object):
- '''
- Returns a listener object.
-
- This is a wrapper for a bound socket which is 'listening' for
- connections, or for a Windows named pipe.
- '''
- def __init__(self, address=None, family=None, backlog=1, authkey=None):
- family = (family or (address and address_type(address)) or
- default_family)
- address = address or arbitrary_address(family)
-
- _validate_family(family)
- if family == 'AF_PIPE':
- self._listener = PipeListener(address, backlog)
- else:
- self._listener = SocketListener(address, family, backlog)
-
- if authkey is not None and not isinstance(authkey, bytes):
- raise TypeError('authkey should be a byte string')
-
- self._authkey = authkey
-
- def accept(self):
- '''
- Accept a connection on the bound socket or named pipe of `self`.
-
- Returns a `Connection` object.
- '''
- if self._listener is None:
- raise OSError('listener is closed')
- c = self._listener.accept()
- if self._authkey:
- deliver_challenge(c, self._authkey)
- answer_challenge(c, self._authkey)
- return c
-
- def close(self):
- '''
- Close the bound socket or named pipe of `self`.
- '''
- if self._listener is not None:
- self._listener.close()
- self._listener = None
-
- address = property(lambda self: self._listener._address)
- last_accepted = property(lambda self: self._listener._last_accepted)
-
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_value, exc_tb):
- self.close()
-
-
- def Client(address, family=None, authkey=None):
- '''
- Returns a connection to the address of a `Listener`
- '''
- family = family or address_type(address)
- _validate_family(family)
- if family == 'AF_PIPE':
- c = PipeClient(address)
- else:
- c = SocketClient(address)
-
- if authkey is not None and not isinstance(authkey, bytes):
- raise TypeError('authkey should be a byte string')
-
- if authkey is not None:
- answer_challenge(c, authkey)
- deliver_challenge(c, authkey)
-
- return c
-
-
- if sys.platform != 'win32':
-
- def Pipe(duplex=True, rnonblock=False, wnonblock=False):
- '''
- Returns pair of connection objects at either end of a pipe
- '''
- if duplex:
- s1, s2 = socket.socketpair()
- s1.setblocking(not rnonblock)
- s2.setblocking(not wnonblock)
- c1 = Connection(s1.detach())
- c2 = Connection(s2.detach())
- else:
- fd1, fd2 = os.pipe()
- if rnonblock:
- setblocking(fd1, 0)
- if wnonblock:
- setblocking(fd2, 0)
- c1 = Connection(fd1, writable=False)
- c2 = Connection(fd2, readable=False)
-
- return c1, c2
-
- else:
- from billiard.forking import duplicate
-
- def Pipe(duplex=True, rnonblock=False, wnonblock=False): # noqa
- '''
- Returns pair of connection objects at either end of a pipe
- '''
- address = arbitrary_address('AF_PIPE')
- if duplex:
- openmode = _winapi.PIPE_ACCESS_DUPLEX
- access = _winapi.GENERIC_READ | _winapi.GENERIC_WRITE
- obsize, ibsize = BUFSIZE, BUFSIZE
- else:
- openmode = _winapi.PIPE_ACCESS_INBOUND
- access = _winapi.GENERIC_WRITE
- obsize, ibsize = 0, BUFSIZE
-
- h1 = _winapi.CreateNamedPipe(
- address, openmode | _winapi.FILE_FLAG_OVERLAPPED |
- _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE,
- _winapi.PIPE_TYPE_MESSAGE | _winapi.PIPE_READMODE_MESSAGE |
- _winapi.PIPE_WAIT,
- 1, obsize, ibsize, _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL
- )
- h2 = _winapi.CreateFile(
- address, access, 0, _winapi.NULL, _winapi.OPEN_EXISTING,
- _winapi.FILE_FLAG_OVERLAPPED, _winapi.NULL
- )
- _winapi.SetNamedPipeHandleState(
- h2, _winapi.PIPE_READMODE_MESSAGE, None, None
- )
-
- overlapped = _winapi.ConnectNamedPipe(h1, overlapped=True)
- _, err = overlapped.GetOverlappedResult(True)
- assert err == 0
-
- c1 = PipeConnection(duplicate(h1, inheritable=True), writable=duplex)
- c2 = PipeConnection(duplicate(h2, inheritable=True), readable=duplex)
- _winapi.CloseHandle(h1)
- _winapi.CloseHandle(h2)
- return c1, c2
-
- #
- # Definitions for connections based on sockets
- #
-
-
- class SocketListener(object):
- '''
- Representation of a socket which is bound to an address and listening
- '''
- def __init__(self, address, family, backlog=1):
- self._socket = socket.socket(getattr(socket, family))
- try:
- # SO_REUSEADDR has different semantics on Windows (issue #2550).
- if os.name == 'posix':
- self._socket.setsockopt(socket.SOL_SOCKET,
- socket.SO_REUSEADDR, 1)
- self._socket.setblocking(True)
- self._socket.bind(address)
- self._socket.listen(backlog)
- self._address = self._socket.getsockname()
- except OSError:
- self._socket.close()
- raise
- self._family = family
- self._last_accepted = None
-
- if family == 'AF_UNIX':
- self._unlink = Finalize(
- self, os.unlink, args=(address, ), exitpriority=0
- )
- else:
- self._unlink = None
-
- def accept(self):
- while True:
- try:
- s, self._last_accepted = self._socket.accept()
- except OSError as exc:
- if exc.errno == errno.EINTR:
- continue
- raise
- else:
- break
- s.setblocking(True)
- return Connection(s.detach())
-
- def close(self):
- self._socket.close()
- if self._unlink is not None:
- self._unlink()
-
-
- def SocketClient(address):
- '''
- Return a connection object connected to the socket given by `address`
- '''
- family = address_type(address)
- with socket.socket(getattr(socket, family)) as s:
- s.setblocking(True)
- s.connect(address)
- return Connection(s.detach())
-
- #
- # Definitions for connections based on named pipes
- #
-
- if sys.platform == 'win32':
-
- class PipeListener(object):
- '''
- Representation of a named pipe
- '''
- def __init__(self, address, backlog=None):
- self._address = address
- self._handle_queue = [self._new_handle(first=True)]
-
- self._last_accepted = None
- sub_debug('listener created with address=%r', self._address)
- self.close = Finalize(
- self, PipeListener._finalize_pipe_listener,
- args=(self._handle_queue, self._address), exitpriority=0
- )
-
- def _new_handle(self, first=False):
- flags = _winapi.PIPE_ACCESS_DUPLEX | _winapi.FILE_FLAG_OVERLAPPED
- if first:
- flags |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
- return _winapi.CreateNamedPipe(
- self._address, flags,
- _winapi.PIPE_TYPE_MESSAGE | _winapi.PIPE_READMODE_MESSAGE |
- _winapi.PIPE_WAIT,
- _winapi.PIPE_UNLIMITED_INSTANCES, BUFSIZE, BUFSIZE,
- _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL
- )
-
- def accept(self):
- self._handle_queue.append(self._new_handle())
- handle = self._handle_queue.pop(0)
- try:
- ov = _winapi.ConnectNamedPipe(handle, overlapped=True)
- except OSError as e:
- if e.winerror != _winapi.ERROR_NO_DATA:
- raise
- # ERROR_NO_DATA can occur if a client has already connected,
- # written data and then disconnected -- see Issue 14725.
- else:
- try:
- _winapi.WaitForMultipleObjects([ov.event], False, INFINITE)
- except:
- ov.cancel()
- _winapi.CloseHandle(handle)
- raise
- finally:
- _, err = ov.GetOverlappedResult(True)
- assert err == 0
- return PipeConnection(handle)
-
- @staticmethod
- def _finalize_pipe_listener(queue, address):
- sub_debug('closing listener with address=%r', address)
- for handle in queue:
- _winapi.CloseHandle(handle)
-
- def PipeClient(address,
- errors=(_winapi.ERROR_SEM_TIMEOUT,
- _winapi.ERROR_PIPE_BUSY)):
- '''
- Return a connection object connected to the pipe given by `address`
- '''
- t = _init_timeout()
- while 1:
- try:
- _winapi.WaitNamedPipe(address, 1000)
- h = _winapi.CreateFile(
- address, _winapi.GENERIC_READ | _winapi.GENERIC_WRITE,
- 0, _winapi.NULL, _winapi.OPEN_EXISTING,
- _winapi.FILE_FLAG_OVERLAPPED, _winapi.NULL
- )
- except OSError as e:
- if e.winerror not in errors or _check_timeout(t):
- raise
- else:
- break
- else:
- raise
-
- _winapi.SetNamedPipeHandleState(
- h, _winapi.PIPE_READMODE_MESSAGE, None, None
- )
- return PipeConnection(h)
-
- #
- # Authentication stuff
- #
-
- MESSAGE_LENGTH = 20
-
- CHALLENGE = b'#CHALLENGE#'
- WELCOME = b'#WELCOME#'
- FAILURE = b'#FAILURE#'
-
-
- def deliver_challenge(connection, authkey):
- import hmac
- assert isinstance(authkey, bytes)
- message = os.urandom(MESSAGE_LENGTH)
- connection.send_bytes(CHALLENGE + message)
- digest = hmac.new(authkey, message).digest()
- response = connection.recv_bytes(256) # reject large message
- if response == digest:
- connection.send_bytes(WELCOME)
- else:
- connection.send_bytes(FAILURE)
- raise AuthenticationError('digest received was wrong')
-
-
- def answer_challenge(connection, authkey):
- import hmac
- assert isinstance(authkey, bytes)
- message = connection.recv_bytes(256) # reject large message
- assert message[:len(CHALLENGE)] == CHALLENGE, 'message = %r' % message
- message = message[len(CHALLENGE):]
- digest = hmac.new(authkey, message).digest()
- connection.send_bytes(digest)
- response = connection.recv_bytes(256) # reject large message
- if response != WELCOME:
- raise AuthenticationError('digest sent was rejected')
-
- #
- # Support for using xmlrpclib for serialization
- #
-
-
- class ConnectionWrapper(object):
-
- def __init__(self, conn, dumps, loads):
- self._conn = conn
- self._dumps = dumps
- self._loads = loads
- for attr in ('fileno', 'close', 'poll', 'recv_bytes', 'send_bytes'):
- obj = getattr(conn, attr)
- setattr(self, attr, obj)
-
- def send(self, obj):
- s = self._dumps(obj)
- self._conn.send_bytes(s)
-
- def recv(self):
- s = self._conn.recv_bytes()
- return self._loads(s)
-
-
- def _xml_dumps(obj):
- return xmlrpclib.dumps((obj,), None, None, None, 1).encode('utf-8') # noqa
-
-
- def _xml_loads(s):
- (obj,), method = xmlrpclib.loads(s.decode('utf-8')) # noqa
- return obj
-
-
- class XmlListener(Listener):
- def accept(self):
- global xmlrpclib
- import xmlrpc.client as xmlrpclib # noqa
- obj = Listener.accept(self)
- return ConnectionWrapper(obj, _xml_dumps, _xml_loads)
-
-
- def XmlClient(*args, **kwds):
- global xmlrpclib
- import xmlrpc.client as xmlrpclib # noqa
- return ConnectionWrapper(Client(*args, **kwds), _xml_dumps, _xml_loads)
-
- #
- # Wait
- #
-
- if sys.platform == 'win32':
-
- def _exhaustive_wait(handles, timeout):
- # Return ALL handles which are currently signalled. (Only
- # returning the first signalled might create starvation issues.)
- L = list(handles)
- ready = []
- while L:
- res = _winapi.WaitForMultipleObjects(L, False, timeout)
- if res == WAIT_TIMEOUT:
- break
- elif WAIT_OBJECT_0 <= res < WAIT_OBJECT_0 + len(L):
- res -= WAIT_OBJECT_0
- elif WAIT_ABANDONED_0 <= res < WAIT_ABANDONED_0 + len(L):
- res -= WAIT_ABANDONED_0
- else:
- raise RuntimeError('Should not get here')
- ready.append(L[res])
- L = L[res+1:]
- timeout = 0
- return ready
-
- _ready_errors = {_winapi.ERROR_BROKEN_PIPE, _winapi.ERROR_NETNAME_DELETED}
-
- def wait(object_list, timeout=None):
- '''
- Wait till an object in object_list is ready/readable.
-
- Returns list of those objects in object_list which are ready/readable.
- '''
- if timeout is None:
- timeout = INFINITE
- elif timeout < 0:
- timeout = 0
- else:
- timeout = int(timeout * 1000 + 0.5)
-
- object_list = list(object_list)
- waithandle_to_obj = {}
- ov_list = []
- ready_objects = set()
- ready_handles = set()
-
- try:
- for o in object_list:
- try:
- fileno = getattr(o, 'fileno')
- except AttributeError:
- waithandle_to_obj[o.__index__()] = o
- else:
- # start an overlapped read of length zero
- try:
- ov, err = _winapi.ReadFile(fileno(), 0, True)
- except OSError as e:
- err = e.winerror
- if err not in _ready_errors:
- raise
- if err == _winapi.ERROR_IO_PENDING:
- ov_list.append(ov)
- waithandle_to_obj[ov.event] = o
- else:
- # If o.fileno() is an overlapped pipe handle and
- # err == 0 then there is a zero length message
- # in the pipe, but it HAS NOT been consumed.
- ready_objects.add(o)
- timeout = 0
-
- ready_handles = _exhaustive_wait(waithandle_to_obj.keys(), timeout)
- finally:
- # request that overlapped reads stop
- for ov in ov_list:
- ov.cancel()
-
- # wait for all overlapped reads to stop
- for ov in ov_list:
- try:
- _, err = ov.GetOverlappedResult(True)
- except OSError as e:
- err = e.winerror
- if err not in _ready_errors:
- raise
- if err != _winapi.ERROR_OPERATION_ABORTED:
- o = waithandle_to_obj[ov.event]
- ready_objects.add(o)
- if err == 0:
- # If o.fileno() is an overlapped pipe handle then
- # a zero length message HAS been consumed.
- if hasattr(o, '_got_empty_message'):
- o._got_empty_message = True
-
- ready_objects.update(waithandle_to_obj[h] for h in ready_handles)
- return [oj for oj in object_list if oj in ready_objects]
-
- else:
-
- if hasattr(select, 'poll'):
- def _poll(fds, timeout):
- if timeout is not None:
- timeout = int(timeout * 1000) # timeout is in milliseconds
- fd_map = {}
- pollster = select.poll()
- for fd in fds:
- pollster.register(fd, select.POLLIN)
- if hasattr(fd, 'fileno'):
- fd_map[fd.fileno()] = fd
- else:
- fd_map[fd] = fd
- ls = []
- for fd, event in pollster.poll(timeout):
- if event & select.POLLNVAL:
- raise ValueError('invalid file descriptor %i' % fd)
- ls.append(fd_map[fd])
- return ls
- else:
- def _poll(fds, timeout): # noqa
- return select.select(fds, [], [], timeout)[0]
-
- def wait(object_list, timeout=None): # noqa
- '''
- Wait till an object in object_list is ready/readable.
-
- Returns list of those objects in object_list which are ready/readable.
- '''
- if timeout is not None:
- if timeout <= 0:
- return _poll(object_list, 0)
- else:
- deadline = monotonic() + timeout
- while True:
- try:
- return _poll(object_list, timeout)
- except OSError as e:
- if e.errno != errno.EINTR:
- raise
- if timeout is not None:
- timeout = deadline - monotonic()
|