def _parse_message(self): if self._size is None: if len(self._data) >= 4: header_data = self._data[:4] self._data = self._data[4:] header_value = deserialize_uint32(header_data) if header_value == 0xFFFFFFFF: # keep-alive request self._conn.write(serialize_uint32(0xFFFFFFFE)) return True elif header_value == 0xFFFFFFFE: # keep-alive response return True self._size = header_value if self._size > self._max_message_size: template = ("received message size %s is greater than " + "maximum message size %s") error_msg = template % (self._size, self._max_message_size) error = MessageTooLargeError(error_msg) self.close() safe_callback(self._error_callback, error) return False if self._size is not None: if len(self._data) >= self._size: message = self._data[:self._size] self._data = self._data[self._size:] self._size = None safe_callback(self._message_callback, message) return True return False
class TCPReader(object) : def __init__(self, socket, events, receive_callback) : self._socket = socket self._events = events self._receive_callback = receive_callback self._receiving = False self._kickstarting = False self._read_event_registered = False def start_receive(self) : assert not self._receiving self._receiving = True assert not self._read_event_registered self._kickstart() def stop_receive(self) : assert self._receiving self._receiving = False self._unregister_read_event() def cleanup(self) : if self._receiving : self.stop_receive() def _kickstart(self) : if self._kickstarting : return self._kickstarting = True def callback() : self._kickstarting = False if not self._receiving : return self._perform_read() self._events.io_loop().add_callback(callback) def _perform_read(self) : data_list = [] close_received = False try : while True : data = self._socket.recv(65536) if not data : close_received = True break data_list.append(data) except socket.error, e : if e.args[0] not in (errno.EWOULDBLOCK, errno.EAGAIN) : self._events.notify_error(e) return self._register_read_event() data = "".join(data_list) if data : safe_callback(self._receive_callback, data) if not self._receiving : return if close_received : safe_callback(self._receive_callback, "") if self._receiving : self.stop_receive()
def _read_handler(self, fd, events) : unused(fd) if events & self._io_loop.READ : n = self._max_receive_size while self._socket is not None : try : data, from_end_point = self._socket.recvfrom(n) except socket.error, e : if is_blocking_error(e) : break safe_callback(self._receive_callback, data, from_end_point)
def _on_data_received(self, data): if len(data) == 0: # eof received self.close() error = RemoteClosedError("remote end closed") safe_callback(self._error_callback, error) return self._data += data while self._conn is not None: if not self._parse_message(): break
def _ready_for_accept(self): while self._accepting: try: client_socket, client_address = self._socket.accept() except socket.error, e: if e.args[0] in [errno.EWOULDBLOCK, errno.EAGAIN]: return else: safe_callback(self._error_callback, e) return socket_set_blocking(client_socket, False) safe_callback(self._accept_callback, client_socket, client_address)
def _on_keepalive_timer(self): assert self._conn is not None assert self._keepalive_time is not None self._keepalive_timer = None self._keepalive_timer = self._io_loop.add_timeout( time.time() + self._keepalive_time, self._on_keepalive_timer) self._keepalive_attempts += 1 self._conn.write(serialize_uint32(0xFFFFFFFF)) if self._keepalive_attempts > self._keepalive_max_attempts: error_msg = "keepalive failed" error = KeepaliveFailedError(error_msg) self.close() safe_callback(self._error_callback, error)
def _event_handler(self, fd, events) : unused(fd) if events & self._io_loop.ERROR : error = socket_error(self._socket) assert error is not None safe_callback(self._error_callback, error) return if events & self._io_loop.READ : if self._read_callback is not None : safe_callback(self._read_callback) if events & self._io_loop.WRITE : if self._write_callback is not None : safe_callback(self._write_callback) if self._activity_callback is not None : safe_callback(self._activity_callback)
def _event_handler(self, fd, events) : unused(fd) if self._socket is None : return self._io_loop.remove_handler(self._socket.fileno()) self._handler_added = False if events & self._io_loop.ERROR : error = socket_error(self._socket) assert error is not None self._close_socket() safe_callback(self._error_callback, error) return if events & self._io_loop.WRITE : error = socket_error(self._socket) if error is not None : self._close_socket() safe_callback(self._error_callback, error) return sock = self._socket self._socket = None safe_callback(self._connect_callback, sock)
def notify_error(self, error) : if self._error_callback is not None : safe_callback(self._error_callback, error)
def _on_error(self, error) : self.close() safe_callback(self._error_callback, error)
if e.args[0] in [errno.EWOULDBLOCK, errno.EAGAIN] : self._queue.append(data) return self._error_occurred = True self._events.notify_error(e) return self._unregister_write_event() if self._shutdown_requested : try : self._socket.shutdown(socket.SHUT_WR) except socket.error, e : self._error_occurred = True self._events.notify_error(e) return if self._queue_emptied_callback is not None : safe_callback(self._queue_emptied_callback) # # TCPReader # class TCPReader(object) : def __init__(self, socket, events, receive_callback) : self._socket = socket self._events = events self._receive_callback = receive_callback self._receiving = False self._kickstarting = False self._read_event_registered = False
def notify_error() : if self._socket is None : return self._close_socket() safe_callback(self._error_callback, e)
def _on_error(self, error): # TCPConnection is already closed self.disable_keepalive() self._conn = None safe_callback(self._error_callback, error)