Python Event.set_fd方法代码示例

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import set_fd [as 别名]
class Acceptor:

    def __init__(self, prefix=None):
        self._prefix = prefix

        self._fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._fd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self._fd.setblocking(False)

        self._rev = Event()
        self._rev.set_write(False)
        self._rev.set_fd(self._fd.fileno())
        self._rev.set_handler(lambda ev: self._on_accept())

        self._onAccepted = None
        self._onClosed = None

    def bind(self, addr, port):
        _logger.debug('bind')
        self._fd.bind((addr, port))
        _logger.debug('bind to: %s:%d', addr, port)

    def listen(self, backlog=0):
        _logger.debug('listen')
        self._fd.listen(backlog)
        Event.addEvent(self._rev)

    def _on_accept(self):
        _logger.debug('_on_accept')
        while True:
            try:
                sock, addr = self._fd.accept()
                _logger.debug('fd: %d accept fd: %d',
                              self._fd.fileno(), sock.fileno())
            except socket.error as msg:
                if msg.errno == errno.ECONNABORTED:
                    continue
                if msg.errno != errno.EAGAIN and msg.errno != errno.EINPROGRESS:
                    _logger.error('fd: %d, accept: %s',
                                  self._fd.fileno(), os.strerror(msg.errno))
                    self._fd.close()
                    if self._onClosed is not None:
                        try:
                            self._onClosed(self)
                        except Exception as ex:
                            _logger.error('_onClosed: %s', str(ex))
                            _logger.exception(traceback.format_exc())
                return
            else:
                new_stream = Stream(sock, prefix=self._prefix)
                new_stream._connected = True
                try:
                    self._onAccepted(new_stream, addr)
                except Exception as e:
                    _logger.error('_onAccepted: %s', e)
                    _logger.exception(traceback.format_exc())
                    new_stream.close()

    def set_on_accepted(self, on_accepted):
        self._onAccepted = on_accepted

    def set_on_closed(self, on_closed):
        self._onClosed = on_closed

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import set_fd [as 别名]
class NonBlocking(object):

    class _ReceiveHandlerContext(object):

        def __init__(self, handler):
            self.handler = handler
            self.remain = []

    def __init__(self, fd, prefix=None):
        self._fd = fd
        self._prefix = prefix
        self.set_non_blocking()

        self._to_send = deque()
        self._to_send_bytes = 0

        self._encoders = []
        self._decoders = []

        self._error = False

        self._connected = False
        self._fin_received = False
        self._fin_appended = False
        self._fin_sent = False
        self._closed = False

        self._on_ready_to_send = None
        self._on_send_buffer_full = None
        self._on_received = None
        self._on_fin_received = None
        self._on_closed = None

        self._fin_ev = None
        self._close_ev = None

        self._wev = Event()
        self._wev.set_write(True)
        self._wev.set_fd(self._fd.fileno())
        self._wev.set_handler(lambda ev: self._on_send())

        self._rev = Event()
        self._rev.set_write(False)
        self._rev.set_fd(self._fd.fileno())
        self._rev.set_handler(lambda ev: self._on_receive())

        self._errorType = socket.error

        self._decode_error = False
        self._on_decode_error = None

    def __hash__(self):
        return hash(self._fd.fileno())

    def __eq__(self, other):
        if not isinstance(other, NonBlocking):
            return False
        return self._fd.fileno() == other._fd.fileno()

    def __str__(self):
        if self._closed:
            return "%s: #" % self._prefix
        else:
            return "%s: %d" % (self._prefix, self._fd.fileno())

    def set_non_blocking(self):
        raise NotImplemented

    def set_on_ready_to_send(self, handler):
        self._on_ready_to_send = handler

    def set_on_send_buffer_full(self, handler):
        self._on_send_buffer_full = handler

    def set_on_received(self, on_received):
        self._on_received = on_received

    def set_on_fin_received(self, on_fin_received):
        self._on_fin_received = on_fin_received

    def set_on_closed(self, on_closed):
        self._on_closed = on_closed

    def set_on_decode_error(self, on_decode_error):
        self._on_decode_error = on_decode_error

    def append_send_handler(self, handler):
        self._encoders.append(handler)

    def append_receive_handler(self, handler):
        self._decoders.append(self._ReceiveHandlerContext(handler))

    def start_receiving(self):
        _logger.debug('%s, start_receiving', str(self))
        if self._close_ev is not None:
            return
        if not self._connected or self._fin_received or self.is_closed():
            return
        if not Event.isEventSet(self._rev):
            _logger.debug('%s, start_receiving::addEvent', str(self))
#.........这里部分代码省略.........