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()
#!/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() #持续监听并接收新请求