async def main():
"""一个异步TCP服务器"""
address = zen_utils.parse_command_line('asyncio server using callback') #从命令行获取(IP, port)元组
server = await loop.create_server(ZenServer, *address) #返回一个server对象
addr = server.sockets[0].getsockname() #获取该server对象上的监听套接字所绑定的地址
print(f'serving on {addr}')
async with server: #确保server对象能够顺利关闭；python3.7才能使用的代码
await server.serve_forever() #持续监听并接收新请求
sock, address = sock.accept()
print(f"accept connection from: {address}")
sock.setblocking(False)
sockets[sock.fileno()] = sock
poll_object.register(sock, select.PULLIN)
elif event & select.POLLIN:
more_data = sock.recv(4096)
if not more_data:
sock.close()
continue
data = bytes_recieved.pop(sock, b'') + more_data
if data.endswith(b"?"):
bytes_to_send[sock] = zen_utils.get_answer(data)
poll_object.modify(sock, select.POLLOUT)
else:
bytes_recieved[sock] = data
elif event & select.POLLOUT:
data = bytes_to_send.pop(sock)
n = sock.send(data)
if n < len(data):
bytes_to_send[sock] = data[n:]
else:
poll_object.modify(sock, select.POLLIN)
if __name__ == '__main__':
address = zen_utils.parse_command_line()
listener = zen_utils.create_srv_socket(address)
server(listener)
# uses the legacy "socketserver" standard library module to write a server.
from socketserver import BaseRequestHandler, TCPServer, ThreadingMixIn
import zen_utils
class ZenHandler(BaseRequestHandler):
def handle(self):
zen_utils.handler_conversation(self.request, self.client_address)
class ZenServer(ThreadingMixIn, TCPServer):
allow_reuse_address = 1
if __name__ == '__main__':
address = zen_utils.parse_command_line("legacy server")
server = ZenServer(address, ZenHandler)
server.serve_forever()
#!/usr/bin/env python3
#coding=utf-8
from socketserver import BaseRequestHandler, TCPServer, ThreadingMixIn
import zen_utils
class ZenHandler(BaseRequestHandler):
def handle(self):
zen_utils.handle_conversation(self.request, self.client_address)
class ZenServer(ThreadingMixIn, TCPServer):
allow_reuse_address = 1
# address_family = socket.AF_INET6 # uncomment if you need IPv6
if __name__ == '__main__':
address = zen_utils.parse_command_line('lagacy "SocketServer" server')
server = ZenServer(address, ZenHandler)
server.serve_forever()
print('Accepted connection from {}'.format(self.address))
def data_received(self, data):
self.data += data
if self.data.endswith(b'?'):
answer = zen_utils.get_answer(self.data)
self.transport.write(answer)
self.data = b''
def connection_lost(self, exc):
if exc:
print('Client {} error: {}'.format(self.address, exc))
elif self.data:
print('Client {} send {} but then closed'.format(
self.address, self.data))
else:
print('Client {} closed socket'.format(self.address))
if __name__ == "__main__":
address = zen_utils.parse_command_line('asyncio server using callbacks')
loop = asyncio.get_event_loop()
coro = loop.create_server(ZenServer, *address)
server = loop.run_until_complete(coro)
print('Listening at {}'.format(address))
try:
loop.run_forever()
finally:
server.close()
loop.close()
self.data = b''
print('Accepted connection from {}'.format(self.address))
def data_received(self, data):
self.data += data
if self.data.endswith(b'?'):
answer = zen_utils.get_answer(self.data)
self.transport.write(answer)
self.data = b''
def connection_lost(self, exc):
if exc:
print('Client {} error: {}'.format(self.address, exc))
elif self.data:
print('Client {} sent {} but then closed'
.format(self.address, self.data))
else:
print('Client {} closed socket'.format(self.address))
if __name__ == '__main__':
address = zen_utils.parse_command_line('asyncio server using callbacks')
loop = asyncio.get_event_loop()
coro = loop.create_server(ZenServer, *address)
server = loop.run_until_complete(coro)
print('Listening at {}'.format(address))
try:
loop.run_forever()
finally:
server.close()
loop.close()
sockets[sock.fileno()] = sock
addresses[sock] = address
poll_object.register(sock, select.POLLIN)
#In coming data: keep receiving until we see the suffix.
elif event & select.POLLIN:
more_data = sock.recv(4096)
if not more_data: # end of file
sock.close()
continue
data = bytes_received.pop(sock, b'') + more_data
if data.endswith(b'?'):
bytes_to_send[sock] = zen_utils.get_answer(data)
poll_object.modify(sock, select.POLLOUT)
else:
bytes_received[sock] = data
#Socket ready to send: keep sending untill all bytes are delivered.
elif event & select.POLLOUT:
data = bytes_to_send.pop(sock)
n = sock.send(data)
if n < len(data):
bytes_to_send[sock] = data[n:]
else:
poll_object.modify(sock, select.POLLIN)
if __name__ == "__main__":
address = zen_utils.parse_command_line('lower-level async server')
listener = zen_utils.create_srv_socket(address)
server(listener)
"""代码清单7-3 最简单的单线程服务器"""
import zen_utils
if __name__ == "__main__":
address = zen_utils.parse_command_line(
'simple single-threaded server') #解析命令行参数，获取address
listener = zen_utils.create_srv_socket(address) #创建【监听套接字】
zen_utils.accept_connections_forever(
listener) #监听循环：不断监听来自客户端的连接请求，并据此创建【连接套接字】
#!/usr/bin/env python
# encoding: utf-8
# Uses the legacy "socketserver" Standard Library module to write a server
from SocketServer import BaseRequestHandler, TCPServer, ThreadingMixIn
import zen_utils
class ZenHandler(BaseRequestHandler):
def handle(self):
zen_utils.handle_conversation(self.request, self.client_address)
class ZenServer(ThreadingMixIn, TCPServer):
allow_reuse_address = 1
# address_family = socket.AF_INET6 # uncomment if you need IPv6
if __name__ == '__main__':
address = zen_utils.parse_command_line('legacy "SocketServer" server')
server = ZenServer(address, ZenHandler)
server.serve_forever()
def handle_conversation(reader, writer):
address = writer.get_extra_info('peername')
print('Accepted connection from {}'.format(address))
while True:
data = b''
while not data.endswith(b'?'):
more_data = yield from reader.read()
if not more_data:
if data:
print('Client {} sent {!r} but then closed'
.format(address, data))
else:
print('Client {} closed socket normally'.format(address))
return
data += more_data
answer = zen_utils.get_answer(data)
writer.write(answer)
if __name__ == '__main__':
address = zen_utils.parse_command_line('asyncio server using coroutine')
loop = asyncio.get_event_loop()
coro = asyncio.start_server(handle_conversation, *address)
server = loop.run_until_complete(coro)
print('Listening at {}'.format(address))
try:
loop.run_forever()
finally:
server.close()
loop.close()
#多线程服务器
import zen_utils
from threading import Thread
def start_threads(listener, workers=4):
t = (listener, )
for i in range(workers):
#target是该run()方法要调用的可调用对象。默认为None，表示什么都不会调用。args是目标调用的参数元组
Thread(target=zen_utils.accept_connections_forever, args=t).start()
if __name__ == '__main__':
address = zen_utils.parse_command_line('多线程服务器')
listener = zen_utils.creat_srv_socket(address)
start_threads(listener)
import zen_utils
from threading import Thread
def start_threads(listener, workers=4):
t = (listener,)
for i in range(workers):
Thread(target=zen_utils.accept_connections_forever, args=t).start()
#Thread(target=zen_utils.accept_connections_forever, args=t).start()
if __name__ == '__main__':
address = zen_utils.parse_command_line('chatting room server')
listener = zen_utils.create_srv_socket(address)
start_threads(listener)
def main():
address = zen_utils.parse_command_line("Multi-threaded server")
listener = zen_utils.create_srv_socket(address)
start_threads(listener)
#! /usr/bin/env python3
# coding = utf-8
# srv_threaded.py - 多线程版本服务器
from threading import Thread
import zen_utils
def start_threads(listener, workers=4):
t = (listener,)
for i in range(4):
Thread(target=zen_utils.accept_connect_forever, args=t).start()
if __name__ == '__main__':
address = zen_utils.parse_command_line('multi-threaded server')
listener = zen_utils.create_srv_socket(address)
start_threads(listener)
#! /usr/bin/env python3
# coding = utf-8
# srv_single.py - 单线程服务器
import zen_utils
if __name__ == '__main__':
address = zen_utils.parse_command_line('simple single-threaded server')
listener = zen_utils.create_srv_socket(address)
zen_utils.accept_connect_forever(listener)
import zen_utils
if __name__ == '__main__':
address = zen_utils.parse_command_line('simple single-htreaded server')
listener = zen_utils.create_srv_socket(address)
zen_utils.accept_connections_forever(listener)
addresses[sock] = address
poll_object.register(sock, select.POLLIN)
# Incoming data: keep receiving until we see the suffix
elif event & select.POLLIN:
more_data = sock.recv(4096)
if not more_data: # end of the file
sock.close() # next poll() will POLLNVAL, and thus clean up
continue
data = bytes_received.pop(sock, b"") + more_data
if data.endswith(b"?"):
bytes_to_send[sock] = zen_utils.get_answer(data)
poll_object.modify(sock, select.POLLOUT)
else:
bytes_received[sock] = data
# Socket read to send: keep sending until all bytes are delivered
elif event & select.POLLOUT:
data = bytes_to_send.pop(sock)
n = sock.send(data)
if n < len(data):
bytes_to_send[sock] = data[n:]
else:
poll_object.modify(sock, select.POLLIN)
if __name__ == "__main__":
address = zen_utils.parse_command_line("low-level async server")
listener = zen_utils.create_srv_socket(address)
serve(listener)
# single threaded server that serves one client at a time; others must wait.
# http://127.0.0.1:7478/pac/pdown.pac?t=1537344619798
import zen_utils
if __name__ == '__main__':
address = zen_utils.parse_command_line("simple single threaded server")
listener = zen_utils.create_srv_socket(address)
zen_utils.accept_connections_forever(listener)
addresses[sock] = address # 把套接字名在字典做映射
poll_object.register(
sock, select.POLLIN) # 在 fd_set 数据结构中注册当前套接字并设定 poll in 状态
# incoming data: keep receiving until we see the suffix
elif event & select.POLLIN:
more_data = sock.recv(4096)
if not more_data: # end of file
sock.close() # next poll() will POLLNVAL, and thus clean up
continue
data = bytes_received.pop(sock, b'') + more_data
if data.endswith(b'?'):
bytes_to_send[sock] = zen_utils.get_answer(data)
poll_object.modify(sock, select.POLLOUT)
else:
bytes_received[sock] = data
# socket ready to send: keep sending until all bytes are delivered.
elif event & select.POLLOUT:
data = bytes_to_send.pop(sock)
n = sock.send(data)
if n < len(data):
bytes_to_send[sock] = data[n:]
else:
poll_object.modify(sock, select.POLLIN)
if __name__ == '__main__':
address = zen_utils.parse_command_line(
"low-level async server") # 返回一个 tuple 地址
listener = zen_utils.create_srv_socket(address) # 返回一个最大64个的监听套接字
server(listener)
#!/usr/bin/env python
#-*- coding: utf-8 -*-
"""
FileName:srv_legacy1.py
DESC: 使用标准库服务器模式构建的多线程服务器
"""
from socketserver import BaseRequestHandler, TCPServer, ThreadingMixIn
import zen_utils
class ZenHandler(BaseRequestHandler):
def handle(self):
zen_utils.handle_conversation(self.request, self.client_address)
class ZenServer(ThreadingMixIn, TCPServer):
allow_reuse_address = 1
#address_family = socket.AF_INET6 #uncomment if you need IPv6
if __name__ == "__main__":
address = zen_utils.parse_command_line('legacy SocketServer server')
server = ZenServer(address, ZenHandler)
server.serve_forever()
address = writer.get_extra_info('peername')
print('Accepted connection from {}'.format(address))
while True:
data = b''
while not data.endswith(b'?'):
more_data = yield from reader.read(4096)
if not more_data:
if data:
print('Client {} send {!r} but then closed'.format(
address, data))
else:
print('Client {} closed socket normally'.format(address))
return
data += more_data
answer = zen_utils.get_answer(data)
writer.write(answer)
if __name__ == '__main__':
address = zen_utils.parse_command_line('asyncio server using coroutine')
loop = asyncio.get_event_loop()
coro = asyncio.start_server(handle_conversation, *address)
server = loop.run_until + complete(coro)
print('Linsening at {}'.format(address))
try:
loop.run_forever()
finally:
server.close()
loop.close()
class ZenRequestHandler(asynchat.async_chat):
def __init__(self, sock):
asynchat.async_chat.__init__(self, sock)
self.set_terminator(b'?')
self.data = b''
def collect_incoming_data(self, more_data):
self.data += more_data
def found_terminator(self):
answer = zen_utils.get_answer(self.data + b'?')
self.push(answer)
self.initiate_send()
self.data = b''
class ZenServer(asyncore.dispatcher):
def handle_accept(self):
sock, address = self.accept()
ZenRequestHandler(sock)
if __name__ == '__main__':
address = zen_utils.parse_command_line('legacy "asyncore" server')
listener = zen_utils.create_srv_socket(address)
server = ZenServer(listener)
server.accepting = True # we already called listen()
asyncore.loop()
def main():
address = zen_utils.parse_command_line("Multi-threaded server")
listener = zen_utils.create_srv_socket(address)
start_threads(listener)
#!/usr/bin/env python3
# Foundations of Python Network Programming, Third Edition
# https://github.com/brandom-rhodes/fopnp/blob/mn/py3/chapter07/srv_threaded.py
import zen_utils
from threading import Thread
def start_threads(listener, workers=4):
t = (listener, )
for i in range(workers):
Thread(target=zen_utils.accept_connections_forever, args=t).start()
if __name__ == '__main__':
address = zen_utils.parse_command_line('multi-threaded server')
listener = zen_utils.create_srv_socket(address)
start_threads(listener)
async def main():
address = zen_utils.parse_command_line('asyncio server using coroutine')
server = await asyncio.start_server(handle_conversation, *address)
print('listening at {}'.format(address))
async with server: #确保server对象能够顺利关闭；python3.7才能使用的代码
await server.serve_forever() #持续监听并接收新请求
