做了个相当简单的ChatService，有登录、群发消息、退出这3个消息，协议就是用简单的json了，有时间再试试xmpp看看。”monkey.patch_all()” 这个调用就把python原生的一些socket对象和方法替换成非阻塞的异步调用，写起来感觉还是很方便。

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import sys
import simplejson
from gevent import monkey; monkey.patch_all();
from gevent.server import StreamServer
from common import Protocol, gen_pro_data, parse_pro_data

class ChatService:
    def __init__(self):
        self._clients = {}
        self._handlers = {
            Protocol.Connect : self.connect,
            Protocol.SendMsg : self.sendmsg,
            Protocol.Quit : self.quit,
        }

    def connect(self, sock, data):
        userinfo = self._clients.get(sock, None)
        if userinfo: return
        self._clients[sock] = data['name']
        print "New User : %s" % (data['name'],)

    def sendmsg(self, sock, data):
        msg = gen_pro_data(data)
        for s, u in self._clients.items():
            if sock != s:
                s.send(msg)

    def quit(self, sock, data=None):
        if sock in self._clients:
            print "User [%s] quit." % (self._clients[sock],)
            del self._clients[sock]
            sock.close()

    def process(self, sock, promsg):
        cmd = promsg['cmd']
        func = self._handlers[cmd]
        func(sock, promsg)

# server chat service
chatservice = ChatService()

def serve(sock, addr):
    while True:
        try:
            length = ord(sock.recv(1))
            content = sock.recv(length)
            # protocol :  length + json({'cmd' : 'sendmsg', 'msg' : 'hallo'})
            promsg = parse_pro_data(content)
            chatservice.process(sock, promsg)
        except:
            chatservice.quit(sock)
            break

if __name__ == "__main__":
    host = sys.argv[1]
    port = int(sys.argv[2])
    print "Start chat server on %s:%s" % (host, port)
    try:
        chatserver = StreamServer((host, port), serve)
        chatserver.serve_forever()
    except:
        chatserver.kill()

写了一个简单的测试，创建了5000个连接，然后定时发消息，服务器也没显得有什么压力。

def test():
    import gevent
    from gevent.pool import Pool

    def robot(idx, host, port):
        # client chat service
        chatservice = ChatService(host, port)
        chatservice.connect("user%s" % (idx,))
        while True:
            chatservice.sendmsg("hallo from %s" % (idx,))
            gevent.sleep(3)
    host = sys.argv[1]
    port = int(sys.argv[2])
    count = 5000
    pool = Pool(5000)
    for i in range(count):
        pool.spawn(robot, i, host, port)
    pool.join()

• 将处理函数的命名空间解析成模块，使用__import__，导入模块，获取处理函数的引用（见get_callable()）；
• 匹配访问路径，提取参数，使用正则表达式进行匹配。

# add url_base as namespace to handlers in url_patterns
def include(url_base, url_patterns):
    for index, src_pattern in enumerate(url_patterns):
        pattern = list(src_pattern)
        pattern[1] = "%s.%s" % (url_base, pattern[1])
        url_patterns[index] = tuple(pattern)
    return url_patterns

# get module name and func name
def get_mod_func(handler):
    try:
        dot = handler.rindex(".")
    except ValueError:
        return handler, ''
    return handler[:dot], handler[dot+1:]

# analyze handler path, return handler ref
def get_callable(handler):
    if not callable(handler):
        mod_name, func_name = get_mod_func(handler)
        mod = __import__(mod_name, globals(), locals(), [func_name])
        if func_name != '':
            func = getattr(mod, func_name)
            if not callable(func):
                raise AttributeError('%s.%s is not callable.' % (mod_name, func_name))
            return func
    return handler

# resolve path info, return handler and args
# path : path_info
# url_config : url_patterns, ref test()
# default_kwargs : default args passed to handler
def resolve(path, url_config, default_kwargs={}):
    import re
    for config in url_config:
        pattern, handler_name = config[0], config[1]
        other_args = config[2:]
        handler = get_callable(handler_name)
        match = re.compile(pattern).search(path)
        if match:
            kwargs = match.groupdict()
            # If there are any named groups, use those as kwargs, ignoring
            # non-named groups. Otherwise, pass all non-named arguments as
            # positional arguments.
            if kwargs:
                args = ()
                for arg in other_args: kwargs.update(arg)
            else:
                args = match.groups() + other_args
        kwargs.update(default_kwargs)
        return handler, args, kwargs
    else:
        raise 

def test():
    url_config = [
        (r"^/(?P<username>\w+)/blog/(?P<blogid>\d+)/?$", "user.test.blogview", {'test':True, 'arg0':'hello world'}),
        (r"^/user/(\d+)/?$", "lib.test2.userview", 'fuckgfw', 'fuckgov')
    ]
    url_config = include("app", url_config)
    handler, args, kwargs = resolve("/stephenchan/blog/890604/", url_config)
    handler(*args, **kwargs)

    handler, args, kwargs = resolve("/user/406098", url_config)
    handler(*args, **kwargs)

if __name__ == '__main__':
    test()

测试的目录结构如下：

|-- app
|   |-- __init__.py
|   |-- __init__.pyc
|   |-- lib
|   |   |-- __init__.py
|   |   |-- __init__.pyc
|   |   |-- test2.py
|   |   `-- test2.pyc
|   `-- user
|       |-- __init__.py
|       |-- __init__.pyc
|       |-- test.py
|       `-- test.pyc

两个测试的函数逻辑很简单：

# app.lib.test2.userview
def userview(uid, arg1, arg2):
    print """
    userid = %s
    arg1 = %s
    arg2 = %s
    """%(uid, arg1, arg2)

# app.user.test.blogview
def blogview(username, blogid, test=False, arg0=""):
    print """
    username = %s
    blogid = %s
    test = %s
    arg0 = %s
    """ % (username, blogid, test, arg0)

由于在匹配的结果中python正则表达式对象在matchObject.groups()返回的结果中包括了matchObject.groupdict()的结果，因此在匹配一个路径的时候难以将具名和非具名的参数分离，即具名参数和非具名参数只能以互斥的关系存在。test()函数中可以看到具名和非具名的两种路径的匹配设置。

import logging
import sys 

logger = logging.getLogger("endlesscode")
formatter = logging.Formatter('%(name)-12s %(asctime)s %(levelname)-8s %(message)s', '%a, %d %b %Y %H:%M:%S',)
file_handler = logging.FileHandler("test.log")
file_handler.setFormatter(formatter)
stream_handler = logging.StreamHandler(sys.stderr)
logger.addHandler(file_handler)
logger.addHandler(stream_handler)
#logger.setLevel(logging.ERROR)

logger.error("fuckgfw")

logger.removeHandler(stream_handler)
logger.error("fuckgov")

文档上已经说明得很清楚了，有几个比较特别的地方：

• 如果设置了setLevel的日志等级，则调用比设定低的日志记录函数则不会有任何的输出，比如:

  logger.setLevel(logging.ERROR)
  #没有生效，默认的info<error
  logger.info("fuckgfw")

• 一个logger如果添加了多个handler(logger.addHandler)，记录的时候会同时在多个hanlder上输出日志。
• 日志的输出格式是通过logging.Formatter来设定的，其初始化的参数如下：
  
• logging有一个basicConfig的成员函数，主要是用来配置一些基本的信息：

  logging.basicConfig(
      level=logging.ERROR,
      format='%(name)-12s %(asctime)s %(levelname)-8s %(message)s',
      datefmt='%a, %d %b %Y %H:%M:%S',
      filename=log_file,
      filemode='a')

  文档上的说明：

  Does basic configuration for the logging system by creating a StreamHandler with a default Formatter and adding it to the root logger. The functions debug(), info(), warning(), error() and critical() will call basicConfig() automatically if no handlers are defined for the root logger.

  参数如下：