class SocketEngineTest (object):
th = None
running = False
engine = None
server_addr = None
server_sock = None
def __init__ (self, logger):
self.engine = TCPSocketEngine (iopoll.Poll (), is_blocking=False)
self.engine.set_logger (logger)
self.engine.set_timeout (5, 5)
def start_client (self):
assert not self.running
self.running = True
def _run (self):
print "client started"
while self.running:
try:
l = self.engine.poll (1)
except Exception, e:
traceback.print_exc ()
os._exit (1)
return
self.th = threading.Thread (target=_run, args=(self, ))
self.th.setDaemon (1)
self.th.start ()
class TransWarpBase (object):
logger = None
def __init__(self):
self.engine = TCPSocketEngine(
io_poll.get_poll(), is_blocking=False, debug=True)
self.client_conn = dict()
self.head_len = proto.head_len()
self.is_running = False
self.engine.set_timeout(rw_timeout=120, idle_timeout=600)
def _on_recv_head(self, conn, msg_cb, head_err_cb=None):
assert callable(msg_cb)
try:
data_len = proto.unpack_head(conn.get_readbuf())
except Exception, e:
conn.error = e
if callable(head_err_cb):
head_err_cb(conn)
return
if data_len > 0:
self.engine.read_unblock(conn, data_len, msg_cb, head_err_cb)
else:
self.engine.watch_conn(conn)
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
class SocketEngineTest(object):
th = None
running = False
engine = None
server_addr = None
server_sock = None
def __init__(self, logger):
self.engine = TCPSocketEngine(iopoll.Poll(), is_blocking=False)
self.engine.set_logger(logger)
self.engine.set_timeout(5, 5)
def start_client(self):
assert not self.running
self.running = True
def _run(self):
print "client started"
while self.running:
try:
l = self.engine.poll(1)
except Exception, e:
traceback.print_exc()
os._exit(1)
return
self.th = threading.Thread(target=_run, args=(self, ))
self.th.setDaemon(1)
self.th.start()
def test_client_line():
poll = None
if 'EPoll' in dir(iopoll):
poll = iopoll.EPoll(True)
print "client using epoll et mode"
else:
poll = iopoll.Poll()
engine = TCPSocketEngine(poll, debug=False)
# engine.get_time = tc.time
engine.set_logger(getLogger("client"))
start_time = time.time()
def __on_conn_err(e, client_id):
print client_id, "connect error", str(e)
os._exit(1)
return
def __on_err(conn, client_id, count, *args):
print client_id, "error", str(conn.error), count
return
def __on_recv(conn, client_id, count, data):
global g_done_client
if count >= 0 and data:
buf = conn.get_readbuf()
if buf != data:
print "data recv invalid, client:%s, count:%s, data:[%s]" % (client_id, count, buf)
os._exit(0)
if count < g_round:
#print client_id, count
l = random.randint(1, MAX_LEN -1)
newdata = random_string(l)
engine.write_unblock(conn, newdata, __on_send, __on_err, (client_id, count + 1, newdata))
else:
engine.close_conn(conn)
g_done_client += 1
print "client", client_id, "done"
if g_done_client == g_client_num:
print "test client done time: ", time.time() - start_time
os._exit(0)
return
def __on_send( conn, client_id, count, data):
# print "send", client_id, count, "len", len(data)
engine.read_unblock(conn, len(data), __on_recv, __on_err, (client_id, count, data))
return
def __on_conn(sock, client_id):
# print "conn", client_id, time.time()
__on_recv(Connection(sock), client_id, -1, None)
return
def _run(engine):
global g_done_client
while g_done_client < g_client_num:
try:
engine.poll()
except Exception, e:
traceback.print_exc()
os._exit(1)
print g_done_client
return
def __init__(self):
self.engine = TCPSocketEngine(
io_poll.get_poll(), is_blocking=False, debug=True)
self.client_conn = dict()
self.head_len = proto.head_len()
self.is_running = False
self.engine.set_timeout(rw_timeout=120, idle_timeout=600)
def start_block_server():
global server_addr
server = TCPSocketEngine(iopoll.Poll(), is_blocking=True, debug=False)
server.set_logger(getLogger("server"))
def server_handler(conn):
sock = conn.sock
try:
_data = recv_all(sock, len(data))
send_all(sock, _data)
server.watch_conn(conn)
except Exception, e:
print "server handler", str(e)
getLogger("server").exception(str(e))
server.close_conn(conn)
return False
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
def start_unblock_server_ssl():
global server_addr
poll = None
if 'EPoll' in dir(iopoll):
poll = iopoll.EPoll(True)
print "using epoll et mode"
else:
poll = iopoll.Poll()
#server = SSLSocketEngine(poll, SSL_CERT, is_blocking=False, debug=True)
server = TCPSocketEngine(poll, is_blocking=False, debug=True)
patch_ssl_engine(server, SSL_CERT)
server.set_logger(getLogger("server"))
# server.get_time = tc.time
def _on_err(conn):
raise conn.error
def _on_send(conn):
#print "on send"
server.watch_conn(conn)
return
def _on_recv(conn):
#print "on_recv"
server.remove_conn(conn)
server.write_unblock(conn, conn.get_readbuf(), _on_send, _on_err)
return
server.listen_addr_ssl(server_addr, server.read_unblock, (len(data), _on_recv, None))
def _run(_server):
while True:
try:
_server.poll(1)
except Exception, e:
traceback.print_exc()
os._exit(1)
return
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"
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)
def __init__ (self, logger):
self.engine = TCPSocketEngine (iopoll.Poll (), is_blocking=False)
self.engine.set_logger (logger)
self.engine.set_timeout (5, 5)
def __init__(self, logger):
self.engine = TCPSocketEngine(iopoll.Poll(), is_blocking=False)
self.engine.set_logger(logger)
self.engine.set_timeout(5, 5)
