def __init__(self, mode):
print("mode: " + mode)
if mode == 'poll':
self.sel = selectors.PollSelector()
elif mode == 'epoll':
self.sel = selectors.EpollSelector()
else:
self.sel = selectors.SelectSelector()
def __init__(self, host, port, messageque: MessageQue, handlerClass):
self.lstn_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.lstn_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.lstn_sock.bind((host, port))
self.lstn_sock.setblocking(False)
self.enabled = True
self.sel = selectors.EpollSelector()
self.lstn_sock.listen(5)
self.handlerClass = handlerClass
self.messageque = messageque
print("socket {} listening {}:{} ".format(self.lstn_sock, host, port))
def read_avro():
ep = selectors.EpollSelector()
ep.register(sock, selectors.EVENT_READ)
while True:
pollrc = ep.select(timeout=int(opts.read_timeout)
if int(opts.read_timeout) > 0 else None)
try:
buf = sock.recv(4096, socket.MSG_DONTWAIT)
os.write(sys.stdout.fileno(), buf)
sys.stdout.flush()
except Exception:
break
def main():
global admin
admin = selectors.EpollSelector()
server = socket.socket()
server.bind(('127.0.0.1', 9999))
server.listen(5)
admin.register(server, selectors.EVENT_READ, accept)
while True:
events = admin.select()
for key, mask in events:
callback = key.data
sock = key.fileobj
callback(sock)
def _serve(sock):
selector = selectors.EpollSelector()
loop = asyncio.SelectorEventLoop(selector)
asyncio.set_event_loop(loop)
coro = asyncio.start_server(_handle_connection, sock=sock)
server = loop.run_until_complete(coro)
loop.add_signal_handler(signal.SIGTERM, loop.stop)
loop.add_signal_handler(signal.SIGINT, loop.stop)
logging.info('Starting server worker at http://{}:{}'.format(
address, port))
try:
loop.run_forever()
finally:
logging.info('Closing server worker...')
server.close()
coro.close()
loop.run_until_complete(coro)
def read_json():
decoder = json.JSONDecoder()
rbuf = bytes()
ep = selectors.EpollSelector()
ep.register(sock, selectors.EVENT_READ)
while True:
pollrc = ep.select(timeout=int(opts.read_timeout)
if int(opts.read_timeout) > 0 else None)
try:
buf = sock.recv(4096, socket.MSG_DONTWAIT)
rbuf += buf
while True:
rbuf = rbuf.lstrip()
data = decoder.raw_decode(rbuf.decode('ascii'))
rbuf = rbuf[data[1]:]
print(json.dumps(data[0]))
except ValueError as err:
sys.stdout.flush()
pass
except Exception:
break
def create_event_loop(self):
return asyncio.SelectorEventLoop(selectors.EpollSelector())
import socket
import selectors
server = socket.socket()
server.bind(("", 8885))
server.listen(10)
epoll_selector = selectors.EpollSelector()
def recv_data(conn):
data = conn.recv(1024)
if data:
print(data.decode())
conn.send(data)
else:
conn.close()
epoll_selector.unregister(conn)
print("客户端连接 关闭")
def connection(server):
conn, addr = server.accept()
print("用户{}连接".format(addr))
epoll_selector.register(conn, selectors.EVENT_READ, recv_data)
epoll_selector.register(server, selectors.EVENT_READ, connection)
while True:
# coding=utf-8
# IO多路复用epoll来显示我们的并发服务器
import socket
import selectors # IO多路复用选择器的模块
epoll_selector = selectors.EpollSelector() # 实力化一个和epoll通信的选择器
# epoll_selector = selectors.DefaultSelector() #根据系统自动选择通信器
server = socket.socket() # 生成套接字
server.bind(('', 7788)) # 指定端口
server.listen(1000) # 开启监听
def read(conn): # 传的对等连接套接字
recv_data = conn.recv(1024) # 接收数据
if recv_data: # 如果recv_data有数据就执行下面的代码，没有就执行else
print(recv_data)
conn.send(recv_data) # 返回接收的数据
else:
epoll_selector.unregister(conn) # 处理完数据后就不需要再监控了，就关闭监控
conn.close()
def accept(server): # 传一个监听套接字
conn, addr = server.accept() # 当有连接过来的时候，生成对等连接套接字
# 接收数据
epoll_selector.register(conn, selectors.EVENT_READ, read) # 注册事件，固定格式
epoll_selector.register(
server, selectors.EVENT_READ,
import socket
import selectors
epoll_selector = selectors.EpollSelector() # 如果是windows Def...
server = socket.socket()
server.bind(('', 8888))
server.listen(1000)
def read(conn):
recv_data = conn.recv(1024)
if recv_data:
print(recv_data)
conn.send(recv_data)
else:
epoll_selector.unregister(conn) # 取消注册
conn.close()
def accept(server):
conn, addr = server.accept()
epoll_selector.register(conn, selectors.EVENT_READ, read)
epoll_selector.register(server, selectors.EVENT_READ, accept)
## 事件循环
while True:
events = epoll_selector.select() # 查询准备好的事件，返回列表
import selectors # 提供IO多路技术
import socket
server = socket.socket()
server.bind(("0.0.0.0", 9998))
server.listen()
epoll = selectors.EpollSelector() # 生成一个spoll 选择器
# 1.2：写注册调用的函数
def funcbbb(conn):
data = conn.recv(102)
if data == b'':
epoll.unregister(conn) # 取消注册
conn.close()
else:
print(data)
conn.send(data)
# 1.1
def funcaaa(ser):
conn, addr = ser.accept()
print('处理了连接')
epoll.register(conn, selectors.EVENT_READ, funcbbb)
# 1.0：调用这个参数申请注册，
# 让他帮我看着这个server（第一个参数）
epoll.register(server, selectors.EVENT_READ, funcaaa) # 表示有数据过来了，可以读了
#passed to create socket connection. It listens for data from
#client and upon listening, sends the data back to the client.
#User is displayed stats such as time and number of active connections.
SERVER_IP = sys.argv[1]
PORT = sys.argv[2]
PORT_NUMBER = int(PORT)
parser = argparse.ArgumentParser()
parser.add_argument("IP", help="Type in the server ip")
parser.add_argument("Port", help="Type in the server port")
args = parser.parse_args()
BUF_SIZE = 1024
sel = selectors.EpollSelector()
peers = {}
peers_count = 0
#This function accepts the socket connection incoming from client
#and sets blocking to false. It then runs the read function
def accept(sock, mask):
conn, addr = sock.accept()
print('accepted from', addr)
conn.setblocking(False)
peers[conn.fileno()] = conn.getpeername()
sel.register(conn, selectors.EVENT_READ, read)
#This function is invoked by the accept function, receiving incoming data
