部署

服务地址：硬编码IP、DNS解析、在服务前端配置负载均衡器。
两种部署思路：
- 每个服务器程序编写服务的所有功能：成为unix守护进程或者windows服务，安排系统级的日志，支持配置文件，提供启动、关闭、重启功能。这些功能不一定自己编写，也使用第三方库。
- 服务器程序只实现最小功能，只是一个普通的前台程序，而不是守护进程。一般重环境变量中获得配置。不过可以添加框架使思路二变成思路一的守护进程。Paas服务即是如此，重复的功能平台方搞定。
- 推荐supervisord

参考：十二要素应用宣言

单线程服务器

以一个简单的TCP协议为例：
即使 listen()的参数大于0，第一个对话未完成时，第二个对话仍旧会在队列中，只是减少了切换时建立连接的时间。

缺点：

拒绝服务攻击
严重浪费CPU资源，因为在等待客户端时，服务端什么都不能做。

tips：性能测试使用 trace 模块：python -m trace -tg --ignore-dir=/usr main.py

多线程与多进程服务器

利用操作系统的多路复用。可以创建多个共享相同内存的线程，或者完全独立的进程。

优点：简单，复用单线程代码。

缺点:

服务器同时通信的客户端数量受OS限制。
即使某个客户端空闲或者运行缓慢，仍会独占线程或进程。
大量客户端时，上下文切换成本很大。

模块：threading 和 multiprocessing

异步服务器

利用服务端向客户端发送响应后等待下一次响应的时间。

异步（asyhchronous），表示从不停下来，区别于同步（synchronized）

操作系统级异步

传统的 select(), 后续 Linux 的 poll() 和 BSD 的 epoll()

看下面这段简单的异步代码：精髓在于自己设计数据结构保存客户端状态，而不依赖操作系统的上下文切换。

#!/usr/bin/env python3
# Foundations of Python Network Programming, Third Edition
# https://github.com/brandon-rhodes/fopnp/blob/m/py3/chapter07/srv_async.py
# Asynchronous I/O driven directly by the poll() system call.

# zen_utils 是自己编写的处理各种业务逻辑的包
import select, zen_utils

# 两层循环，while 不断调用 poll(), 针对poll返回的不通事件再循环
# 为了代码简洁，用生成器写
def all_events_forever(poll_object):
    while True:
        for fd, event in poll_object.poll():
            yield fd, event

def serve(listener):
    # 维护 sockets 字典和 address 字典
    sockets = {listener.fileno(): listener} 
    addresses = {}
    # 要接受和要发送的缓存字典。这四个字典是核心。
    bytes_received = {}
    bytes_to_send = {}

    poll_object = select.poll()
    # 监听套接字始终在 sockets 字典里，且状态始终未 POLLIN
    poll_object.register(listener, select.POLLIN)

    for fd, event in all_events_forever(poll_object):
        sock = sockets[fd]

        # Socket closed: remove it from our data structures.
        # 出错、关闭、异常等

        if event & (select.POLLHUP | select.POLLERR | select.POLLNVAL):
            address = addresses.pop(sock)
            rb = bytes_received.pop(sock, b'')
            sb = bytes_to_send.pop(sock, b'')
            if rb:
                print('Client {} sent {} but then closed'.format(address, rb))
            elif sb:
                print('Client {} closed before we sent {}'.format(address, sb))
            else:
                print('Client {} closed socket normally'.format(address))
            poll_object.unregister(fd)
            del sockets[fd]

        # New socket: add it to our data structures.
        # 监听套接字，accept

        elif sock is listener:
            sock, address = sock.accept()
            print('Accepted connection from {}'.format(address))
            sock.setblocking(False)     # force socket.timeout if we blunder
            sockets[sock.fileno()] = sock
            addresses[sock] = address
            poll_object.register(sock, select.POLLIN)

        # Incoming data: keep receiving until we see the suffix.
        # POLLIN状态，recv()

        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.
        # POLLOUT状态，send

        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)

回调风格的 asynio

把 select 调用的细节隐藏起来。

通过对象实例来维护每个打开的客户端链接，使用对象的方法调用。

#!/usr/bin/env python3
# Foundations of Python Network Programming, Third Edition
# https://github.com/brandon-rhodes/fopnp/blob/m/py3/chapter07/srv_asyncio1.py
# Asynchronous I/O inside "asyncio" callback methods.

import asyncio, zen_utils

# 一个对象实例维护一个客户端链接
class ZenServer(asyncio.Protocol):

    def connection_made(self, transport):
        self.transport = transport
        self.address = transport.get_extra_info('peername')
        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() 即可
            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()

协程风格的 asyncio

协程（coroutine）是一个函数，在进行IO操作是不会阻塞，而是暂停，将控制权转移回调用方。python支持协程的标准形式就是生成器 yield。

#!/usr/bin/env python3
# Foundations of Python Network Programming, Third Edition
# https://github.com/brandon-rhodes/fopnp/blob/m/py3/chapter07/srv_asyncio2.py
# Asynchronous I/O inside an "asyncio" coroutine.

import asyncio, zen_utils

@asyncio.coroutine
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'?'):
            # 注意 yield from 
            more_data = yield from reader.read(4096)
            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()

完美方案

异步的缺点是：所有操作都在单个线程中完成。即使多核机器，也只会使用一个核。

方案：检查核数，有几个核，就启动几个事件循环进程。在每个CPU上，使用异步（回调或者协程）方案。操作系统负责新建立的连接分配给某个服务器进程。

Python网络编程笔记（六）：服务器架构