def __init__(self): super(BaseStream, self).__init__() self._read_result = Result() self._shutdown_result = Result() self._pending_writes = 0 self._flush_event = Event() self._flush_event.set()
def __init__(self): loop = evergreen.current.loop self._handle = pyuv.UDP(loop._loop) self._closed = False self._receive_result = Result() self._pending_writes = 0 self._flush_event = Event() self._flush_event.set() self._sockname = None
class PipeClient(BasePipeStream): def __init__(self): loop = evergreen.current.loop handle = pyuv.Pipe(loop._loop) super(PipeClient, self).__init__(handle) self._connect_result = Result() def connect(self, target): if self._connected: raise PipeError('already connected') with self._connect_result: try: self._handle.connect(target, self.__connect_cb) except PipeError: self.close() raise try: self._connect_result.get() except PipeError: self.close() raise self._set_connected() def __connect_cb(self, handle, error): if error is not None: self._connect_result.set_exception( PipeError(error, errno.strerror(error))) else: self._connect_result.set_value(None)
class PipeClient(BasePipeStream): def __init__(self): loop = evergreen.current.loop handle = pyuv.Pipe(loop._loop) super(PipeClient, self).__init__(handle) self._connect_result = Result() def connect(self, target): if self._connected: raise PipeError('already connected') with self._connect_result: try: self._handle.connect(target, self.__connect_cb) except PipeError: self.close() raise try: self._connect_result.get() except PipeError: self.close() raise self._set_connected() def __connect_cb(self, handle, error): if error is not None: self._connect_result.set_exception(PipeError(error, errno.strerror(error))) else: self._connect_result.set_value(None)
class TCPClient(TCPStream): def __init__(self): loop = evergreen.current.loop handle = pyuv.TCP(loop._loop) super(TCPClient, self).__init__(handle) self._connect_result = Result() def connect(self, target, source_address=None): if self._connected: raise TCPError('already connected') host, port = target try: r = socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM) except socket.error as e: raise TCPError(e) if not r: raise TCPError('getaddrinfo returned no result') err = None loop = self._handle.loop for item in r: with self._connect_result: addr = item[-1] idx = addr[0].find('%') if idx != -1: host, rest = addr[0], addr[1:] addr = (host[:idx],) + rest handle = pyuv.TCP(loop) try: if source_address: handle.bind(source_address) handle.connect(addr, self.__connect_cb) except TCPError as e: err = e handle.close() continue try: self._connect_result.get() except TCPError as e: err = e handle.close() continue else: self._handle.close() self._handle = handle break if err is not None: raise err self._set_connected() def __connect_cb(self, handle, error): if error is not None: self._connect_result.set_exception(TCPError(error, errno.strerror(error))) else: self._connect_result.set_value(None)
def __init__(self): loop = evergreen.current.loop handle = pyuv.Pipe(loop._loop) super(PipeClient, self).__init__(handle) self._connect_result = Result()
def __init__(self): loop = evergreen.current.loop handle = pyuv.TCP(loop._loop) super(TCPClient, self).__init__(handle) self._connect_result = Result()
class UDPEndpoint(object): def __init__(self): loop = evergreen.current.loop self._handle = pyuv.UDP(loop._loop) self._closed = False self._receive_result = Result() self._pending_writes = 0 self._flush_event = Event() self._flush_event.set() self._sockname = None @property def sockname(self): self._check_closed() if self._sockname is None: self._sockname = self._handle.getsockname() return self._sockname def bind(self, addr): self._check_closed() self._handle.bind(addr) def send(self, data, addr): self._check_closed() self._handle.send(addr, data, self.__send_cb) if self._pending_writes == 0: self._flush_event.clear() self._pending_writes += 1 def receive(self): self._check_closed() with self._receive_result: self._handle.start_recv(self.__receive_cb) return self._receive_result.get() def flush(self): self._check_closed() self._flush_event.wait() def close(self): if self._closed: return self._closed = True self._handle.close() def _check_closed(self): if self._closed: raise UDPError("endpoint is closed") def __send_cb(self, handle, error): self._pending_writes -= 1 if self._pending_writes == 0: self._flush_event.set() if error is not None: log.debug("send failed: %d %s", error, pyuv.errno.strerror(error)) evergreen.current.loop.call_soon(self.close) def __receive_cb(self, handle, addr, flags, data, error): self._handle.stop_recv() if error is not None: self._receive_result.set_exception(UDPError(error, errno.strerror(error))) else: self._receive_result.set_value((data, addr))
class BaseStream(AbstractBaseStream): """Base class for streams implemented using pyuv Stream objects as the underlying mechanism """ def __init__(self): super(BaseStream, self).__init__() self._read_result = Result() self._shutdown_result = Result() self._pending_writes = 0 self._flush_event = Event() self._flush_event.set() def flush(self): self._check_closed() self._flush_event.wait() def _read(self, n): with self._read_result: try: self._handle.start_read(self.__read_cb) except self.error_cls: self.close() raise try: data = self._read_result.get() except self.error_cls as e: self.close() if e.args[0] != errno.EOF: raise else: self._read_buffer.feed(data) def _write(self, data): try: self._handle.write(data, self.__write_cb) except self.error_cls: self.close() raise if self._pending_writes == 0: self._flush_event.clear() self._pending_writes += 1 return self._handle.write_queue_size == 0 def _shutdown(self): with self._shutdown_result: self._handle.shutdown(self.__shutdown_cb) self._shutdown_result.get() def _close(self): self._handle.close() def __read_cb(self, handle, data, error): self._handle.stop_read() if error is not None: self._read_result.set_exception(self.error_cls(error, pyuv.errno.strerror(error))) else: self._read_result.set_value(data) def __write_cb(self, handle, error): self._pending_writes -= 1 if self._pending_writes == 0: self._flush_event.set() if error is not None: log.debug('write failed: %d %s', error, pyuv.errno.strerror(error)) evergreen.current.loop.call_soon(self.close) def __shutdown_cb(self, handle, error): if error is not None: self._shutdown_result.set_exception(self.error_cls(error, pyuv.errno.strerror(error))) else: self._shutdown_result.set_value(None)
class BaseStream(AbstractBaseStream): """Base class for streams implemented using pyuv Stream objects as the underlying mechanism """ def __init__(self): super(BaseStream, self).__init__() self._read_result = Result() self._shutdown_result = Result() self._pending_writes = 0 self._flush_event = Event() self._flush_event.set() def flush(self): self._check_closed() self._flush_event.wait() def _read(self, n): with self._read_result: try: self._handle.start_read(self.__read_cb) except self.error_cls: self.close() raise try: data = self._read_result.get() except self.error_cls as e: self.close() if e.args[0] != errno.EOF: raise else: self._read_buffer.feed(data) def _write(self, data): try: self._handle.write(data, self.__write_cb) except self.error_cls: self.close() raise if self._pending_writes == 0: self._flush_event.clear() self._pending_writes += 1 return self._handle.write_queue_size == 0 def _shutdown(self): with self._shutdown_result: self._handle.shutdown(self.__shutdown_cb) self._shutdown_result.get() def _close(self): self._handle.close() def __read_cb(self, handle, data, error): self._handle.stop_read() if error is not None: self._read_result.set_exception( self.error_cls(error, pyuv.errno.strerror(error))) else: self._read_result.set_value(data) def __write_cb(self, handle, error): self._pending_writes -= 1 if self._pending_writes == 0: self._flush_event.set() if error is not None: log.debug('write failed: %d %s', error, pyuv.errno.strerror(error)) evergreen.current.loop.call_soon(self.close) def __shutdown_cb(self, handle, error): if error is not None: self._shutdown_result.set_exception( self.error_cls(error, pyuv.errno.strerror(error))) else: self._shutdown_result.set_value(None)
class UDPEndpoint(object): def __init__(self): loop = evergreen.current.loop self._handle = pyuv.UDP(loop._loop) self._closed = False self._receive_result = Result() self._pending_writes = 0 self._flush_event = Event() self._flush_event.set() self._sockname = None @property def sockname(self): self._check_closed() if self._sockname is None: self._sockname = self._handle.getsockname() return self._sockname def bind(self, addr): self._check_closed() self._handle.bind(addr) def send(self, data, addr): self._check_closed() self._handle.send(addr, data, self.__send_cb) if self._pending_writes == 0: self._flush_event.clear() self._pending_writes += 1 def receive(self): self._check_closed() with self._receive_result: self._handle.start_recv(self.__receive_cb) return self._receive_result.get() def flush(self): self._check_closed() self._flush_event.wait() def close(self): if self._closed: return self._closed = True self._handle.close() def _check_closed(self): if self._closed: raise UDPError('endpoint is closed') def __send_cb(self, handle, error): self._pending_writes -= 1 if self._pending_writes == 0: self._flush_event.set() if error is not None: log.debug('send failed: %d %s', error, pyuv.errno.strerror(error)) evergreen.current.loop.call_soon(self.close) def __receive_cb(self, handle, addr, flags, data, error): self._handle.stop_recv() if error is not None: self._receive_result.set_exception( UDPError(error, errno.strerror(error))) else: self._receive_result.set_value((data, addr))