def start_unblock_server(poll=None):
    global server_addr
    if not poll:
        if 'EPoll' in dir(iopoll):
            poll = iopoll.EPoll(True)
        else:
            poll = iopoll.Poll()
    server = TCPSocketEngine(poll, is_blocking=False, debug=False)
    server.set_logger(getLogger("server"))
#    server.get_time = tc.time
    
    print "starting unblock server with", str(poll)
    def _on_recv(conn):
        #print "on_recv"
#        server.remove_conn(conn)
        server.watch_conn(conn)
        server.write_unblock(conn, conn.get_readbuf(), None, None)
        return
    server.listen_addr(server_addr, server.read_unblock, (len(data), _on_recv, None))

    def _run(_server):
        while True:
            try:
                _server.poll()
            except Exception, e:
                traceback.print_exc()
                os._exit(1)
        return
def start_echo_line_server():
    global server_addr
    poll = None
    if 'EPoll' in dir(iopoll):
        poll = iopoll.EPoll(True)
        print "using epoll et mode"
    else:
        poll = iopoll.Poll()
    server = TCPSocketEngine(poll, is_blocking=False, debug=False)
    server.set_logger(getLogger("server"))
#    server.get_time = tc.time

    def _on_recv(conn):
        server.watch_conn(conn)
        server.write_unblock(conn, conn.get_readbuf(), None, None)
        return
    server.listen_addr(server_addr, server.readline_unblock, (MAX_LINE_LEN, _on_recv, None))

    def _run(_server):
        while True:
            try:
                _server.poll()
            except Exception, e:
                traceback.print_exc()
                os._exit(1)
        return
def start_echo_server():
    global server_addr
    poll = None
    if 'EPoll' in dir(iopoll):
        poll = iopoll.EPoll(True)
        print "using epoll et mode"
    else:
        poll = iopoll.Poll()
    server = TCPSocketEngine(poll, is_blocking=False, debug=False)
    server.set_logger(getLogger("server"))
#    server.get_time = tc.time

    def _on_readable(conn):
        def __on_send(conn):
            #print "write_ok"
            #_on_readable(conn)
            server.watch_conn(conn)
            return
        buf, eof = server.read_avail(conn, 4096)
        if buf:
            #print "write", len(buf)
            server.write_unblock(conn, buf, __on_send, None)
        elif eof:
            server.close_conn(conn)
        else:
            server.watch_conn(conn)
        return
    server.listen_addr(server_addr, readable_cb=_on_readable)

    def _run(_server):
        while True:
            try:
                _server.poll()
            except Exception, e:
                traceback.print_exc()
                os._exit(1)
        return
예제 #4
0
class PaxosServer (object):

    def __init__ (self, logger, _id, addr):
        self.logger = logger
        self._bind_addr = addr
        self.server_id = _id
        self.is_running = False
        self.server = TCPSocketEngine (get_poll(), debug=True, is_blocking=False)
        self.server.set_timeout (10, 1800)
        self.server.set_logger (self.logger)
        self._timers = TimerEvents (time.time, logger)
        self.passive_sock = None
        self._handles = {
                packet.StatusReq.__name__: self._recv_status_req
                }
        self._empty_head_ack = NetHead ().pack ()
        print "init"

    def start (self):
        if self.is_running:
            return
        self.is_running = True
        self._timers.start ()
        self.passive_sock = self.server.listen_addr (self._bind_addr,
                readable_cb=self._read_msg, readable_cb_args=(self._server_nexus, None, ),
                backlog=50)
        self.logger.info ("%s started" % (self.server_id))


    def loop (self):
        while self.is_running:
            try:
                self.server.poll (timeout=100)
            except KeyboardInterrupt, e:
                raise e
            except Exception, e:
                self.logger.exception_ex (e)