cookies与session

cookies与session

1、Cookies

　　Cookie是由服务器端生成，发送给User-Agent（一般是浏览器），浏览器会将Cookie的key/value保存到某个目录下的文本文件内，下次请求同一网站时就发送该Cookie给服务器（前提是浏览器设置为启用cookie）。Cookie名称和值可以由服务器端开发自己定义，这样服务器可以知道该用户是否是合法用户以及是否需要重新登录等，服务器可以设置或读取Cookies中包含信息，借此维护用户跟服务器会话中的状态。

cookie的作用

　　服务器可以利用Cookies包含信息的任意性来筛选并经常性维护这些信息，以判断在HTTP传输中的状态。Cookies最典型的应用是判定注册用户是否已经登录网站，用户可能会得到提示，是否在下一次进入此网站时保留用户信息以便简化登录手续，这些都是Cookies的功用。另一个重要应用场合是“购物车”之类处理。用户可能会在一段时间内在同一家网站的不同页面中选择不同的商品，这些信息都会写入Cookies，以便在最后付款时提取信息。

1.基本操作

Cookie的操作

　　简单来说，Cookie 是保存在浏览器的一个键值对，每次的HTTP请求都会携带 Cookie 。

获取所有的Cookies

self.cookies

设置Cookie

self.set_cookie(self, name, value, domain=None, expires=None, path="/", expires_days=None, **kwargs)
#get_cookie， set_cookie普通的设置cookie， clear_cookie， clear_all_cookies是删除cookie。

可接受的参数描述：

参数	描述
name	Cookie的Key
value	Cookie的value
domain	生效的域名
expires	以秒为过期时间，默认从 1970-01-01T00:00:10.000Z
path	生效路径
expires_days	以天数过期时间，如果设置为 None 则关闭浏览器Cookie就失效

例子：

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        if not self.get_cookie("mycookie"):
            self.set_cookie("mycookie", "myvalue")
            self.write("Your cookie was not set yet!")
        else:
            self.write("Your cookie was set!")

2、加密cookie（签名）

　　Cookie 很容易被恶意的客户端伪造。加入你想在 cookie 中保存当前登陆用户的 id 之类的信息，你需要对 cookie 作签名以防止伪造。Tornado 通过 set_secure_cookie 和 get_secure_cookie 方法直接支持了这种功能。 要使用这些方法，你需要在创建应用时提供一个密钥，名字为 cookie_secret。 你可以把它作为一个关键词参数传入应用的设置中：

设置一个加密Cookie所需要的参数：

self.set_secure_cookie(self, name, value, expires_days=30, version=None, **kwargs):

实例：

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        if not self.get_secure_cookie("mycookie"):
            self.set_secure_cookie("mycookie", "myvalue")
            self.write("Your cookie was not set yet!")
        else:
            self.write("Your cookie was set!")
             
application = tornado.web.Application([
    (r"/", MainHandler),
], cookie_secret="61oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=")

def _create_signature_v1(secret, *parts):
    hash = hmac.new(utf8(secret), digestmod=hashlib.sha1)
    for part in parts:
        hash.update(utf8(part))
    return utf8(hash.hexdigest())

# 加密
def _create_signature_v2(secret, s):
    hash = hmac.new(utf8(secret), digestmod=hashlib.sha256)
    hash.update(utf8(s))
    return utf8(hash.hexdigest())

def create_signed_value(secret, name, value, version=None, clock=None,
                        key_version=None):
    if version is None:
        version = DEFAULT_SIGNED_VALUE_VERSION
    if clock is None:
        clock = time.time

    timestamp = utf8(str(int(clock())))
    value = base64.b64encode(utf8(value))
    if version == 1:
        signature = _create_signature_v1(secret, name, value, timestamp)
        value = b"|".join([value, timestamp, signature])
        return value
    elif version == 2:
        # The v2 format consists of a version number and a series of
        # length-prefixed fields "%d:%s", the last of which is a
        # signature, all separated by pipes.  All numbers are in
        # decimal format with no leading zeros.  The signature is an
        # HMAC-SHA256 of the whole string up to that point, including
        # the final pipe.
        #
        # The fields are:
        # - format version (i.e. 2; no length prefix)
        # - key version (integer, default is 0)
        # - timestamp (integer seconds since epoch)
        # - name (not encoded; assumed to be ~alphanumeric)
        # - value (base64-encoded)
        # - signature (hex-encoded; no length prefix)
        def format_field(s):
            return utf8("%d:" % len(s)) + utf8(s)
        to_sign = b"|".join([
            b"2",
            format_field(str(key_version or 0)),
            format_field(timestamp),
            format_field(name),
            format_field(value),
            b''])

        if isinstance(secret, dict):
            assert key_version is not None, 'Key version must be set when sign key dict is used'
            assert version >= 2, 'Version must be at least 2 for key version support'
            secret = secret[key_version]

        signature = _create_signature_v2(secret, to_sign)
        return to_sign + signature
    else:
        raise ValueError("Unsupported version %d" % version)

# 解密
def _decode_signed_value_v1(secret, name, value, max_age_days, clock):
    parts = utf8(value).split(b"|")
    if len(parts) != 3:
        return None
    signature = _create_signature_v1(secret, name, parts[0], parts[1])
    if not _time_independent_equals(parts[2], signature):
        gen_log.warning("Invalid cookie signature %r", value)
        return None
    timestamp = int(parts[1])
    if timestamp < clock() - max_age_days * 86400:
        gen_log.warning("Expired cookie %r", value)
        return None
    if timestamp > clock() + 31 * 86400:
        # _cookie_signature does not hash a delimiter between the
        # parts of the cookie, so an attacker could transfer trailing
        # digits from the payload to the timestamp without altering the
        # signature.  For backwards compatibility, sanity-check timestamp
        # here instead of modifying _cookie_signature.
        gen_log.warning("Cookie timestamp in future; possible tampering %r",
                        value)
        return None
    if parts[1].startswith(b"0"):
        gen_log.warning("Tampered cookie %r", value)
        return None
    try:
        return base64.b64decode(parts[0])
    except Exception:
        return None


def _decode_fields_v2(value):
    def _consume_field(s):
        length, _, rest = s.partition(b':')
        n = int(length)
        field_value = rest[:n]
        # In python 3, indexing bytes returns small integers; we must
        # use a slice to get a byte string as in python 2.
        if rest[n:n + 1] != b'|':
            raise ValueError("malformed v2 signed value field")
        rest = rest[n + 1:]
        return field_value, rest

    rest = value[2:]  # remove version number
    key_version, rest = _consume_field(rest)
    timestamp, rest = _consume_field(rest)
    name_field, rest = _consume_field(rest)
    value_field, passed_sig = _consume_field(rest)
    return int(key_version), timestamp, name_field, value_field, passed_sig


def _decode_signed_value_v2(secret, name, value, max_age_days, clock):
    try:
        key_version, timestamp, name_field, value_field, passed_sig = _decode_fields_v2(value)
    except ValueError:
        return None
    signed_string = value[:-len(passed_sig)]

    if isinstance(secret, dict):
        try:
            secret = secret[key_version]
        except KeyError:
            return None

    expected_sig = _create_signature_v2(secret, signed_string)
    if not _time_independent_equals(passed_sig, expected_sig):
        return None
    if name_field != utf8(name):
        return None
    timestamp = int(timestamp)
    if timestamp < clock() - max_age_days * 86400:
        # The signature has expired.
        return None
    try:
        return base64.b64decode(value_field)
    except Exception:
        return None


def get_signature_key_version(value):
    value = utf8(value)
    version = _get_version(value)
    if version < 2:
        return None
    try:
        key_version, _, _, _, _ = _decode_fields_v2(value)
    except ValueError:
        return None

    return key_version

签名Cookie的本质是：

写cookie过程：

• 将值进行base64加密
• 对除值以外的内容进行签名，哈希算法（无法逆向解析）
• 拼接 签名 + 加密值

读cookie过程：

• 读取 签名 + 加密值
• 对签名进行验证
• base64解密，获取值内容

签名后的cookie除了时间戳和一个 HMAC 签名还包含编码 后的cookie值. 如果cookie过期或者签名不匹配, get_secure_cookie 将返回 None 就像没有设置cookie一样

注：许多API验证机制和安全cookie的实现机制相同。

3、用户认证

　　当前已经通过认证的用户在每个请求处理函数中都可以通过 self.current_user 得到, 在每个模板中 可以使用 current_user 获得. 默认情况下, current_user 是 None.

　　为了在你的应用程序中实现用户认证, 你需要在你的请求处理函数中复写 get_current_user() 方法来判断当前用户, 比如可以基于cookie的值. 这里有一个例子, 这个例子允许用户简单的通过一个保存在cookie中的特殊昵称 登录到应用程序中:

　　你可以使用 Python 装饰器(decorator) tornado.web.authenticated 要求用户登录. 如果请求方法带有这个装饰器 并且用户没有登录, 用户将会被重定向到 login_url (另一个应用设置)

　　如果你使用 authenticated 装饰 post() 方法并且用户没有登录, 服务将返回一个 403 响应. @authenticated 装饰器是 if not self.current_user: self.redirect() 的简写. 可能不适合 非基于浏览器的登录方案.

import tornado.ioloop
import tornado.web
 
class MainHandler(tornado.web.RequestHandler):
 
    def get(self):
        login_user = self.get_secure_cookie("login_user", None)
        if login_user:
            self.write(login_user)
        else:
            self.redirect('/login')
 
class LoginHandler(tornado.web.RequestHandler):
    def get(self):
        self.current_user()
 
        self.render('login.html', **{'status': ''})
 
    def post(self, *args, **kwargs):
 
        username = self.get_argument('name')
        password = self.get_argument('pwd')
        if username == 'wupeiqi' and password == '123':
            self.set_secure_cookie('login_user', 'Li')
            self.redirect('/')
        else:
            self.render('login.html', **{'status': '用户名或密码错误'})
 
settings = {
    'template_path': 'template',
    'static_path': 'static',
    'static_url_prefix': '/static/',
    'cookie_secret': 'aiuasdhflashjdfoiuashdfiuh'
}
 
application = tornado.web.Application([
    (r"/index", MainHandler),
    (r"/login", LoginHandler),
], **settings)
 
 
if __name__ == "__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

import tornado.ioloop
import tornado.web
 
class BaseHandler(tornado.web.RequestHandler):
 
    def get_current_user(self):
        return self.get_secure_cookie("login_user")
 
class MainHandler(BaseHandler):
 
    @tornado.web.authenticated
    def get(self):
        login_user = self.current_user
        self.write(login_user)
 
 
 
class LoginHandler(tornado.web.RequestHandler):
    def get(self):
        self.current_user()
 
        self.render('login.html', **{'status': ''})
 
    def post(self, *args, **kwargs):
 
        username = self.get_argument('name')
        password = self.get_argument('pwd')
        if username == 'wupeiqi' and password == '123':
            self.set_secure_cookie('login_user', 'Li')
            self.redirect('/')
        else:
            self.render('login.html', **{'status': '用户名或密码错误'})
 
settings = {
    'template_path': 'template',
    'static_path': 'static',
    'static_url_prefix': '/static/',
    'cookie_secret': 'aiuasdhflashjdfoiuashdfiuh',
    'login_url': '/login'
}
 
application = tornado.web.Application([
    (r"/index", MainHandler),
    (r"/login", LoginHandler),
], **settings)
 
 
if __name__ == "__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()

2、Session

　　在WEB开发中，服务器可以为每个用户浏览器创建一个会话对象（session对象），注意：一个浏览器独占一个session对象(默认情况下)。因此，在需要保存用户数据时，服务器程序可以把用户数据写到用户浏览器独占的session中，当用户使用浏览器访问其它程序时，其它程序可以从用户的session中取出该用户的数据，为用户服务。

Session与Cookie的区别：

　　Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据可以保存在集群、数据库、文件中。

　　Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。

　　Session 必须要依赖 Cookie ，因为 Cookie的值就等于 Session 的Key

Session的工作原理:

　　当用户第一次访问时，服务器会给其创建一个sesion，并且把session的Id(本质是随机字符串)以cookie的形式发送给客户端浏览器，下次再去访问服务器时，客户机浏览器会把存储到cookie中的session的Id一起传递到服务器端，服务器发现客户机浏览器带session id过来了，就会使用内存中与之对应的session为之服务

自定义一个Session组件

　　由于Tornado不支持Session，故我们需要自定义一个Session组件来满足我们的需求。

1、面向对象基础

面向对象中通过索引的方式访问对象，需要内部实现 __getitem__ 、__delitem__、__setitem__方法

class Foo(object):
    def __getitem__(self, key):
        print('__getitem__', key)

    def __setitem__(self, key, value):
        print('__setitem__', key, value)

    def __delitem__(self, key):
        print('__delitem__', key)


obj = Foo()

result = obj['k1']  # 自动触发执行 __getitem__
obj['k2'] = 'Mike'  # 自动触发执行 __setitem__
del obj['k1']

#执行结果
__getitem__ k1
__setitem__ k2 Mike
__delitem__ k1

2、Tornado扩展

　　Tornado源码中有很多扩展点（钩子）供开发者使用，默认执行Handler的get/post等方法之前默认会执行 initialize方法，所以可以通过自定义的方式使得所有请求在处理前执行操作...

import tornado.ioloop,tornado.web
from session import Session

#既然Index与MangeHandler每次均要调用Session方法，我们何不创建一个基类统一调用，Index与Manage继承基类不就ok了
class BaseHandler(tornado.web.RequestHandler):
    #初始化方法，一调用就立刻执行
    def initialize(self):
        self.session=Session(self)

class IndexHandler(BaseHandler):
    def get(self, *args, **kwargs):
       if self.get_argument('u',None) in ['admin','user']:
           # self.session.set_value('is_login',True)
            self.session['is_login']=True #调用__setitem__方法
       else:
           self.write('请登录')
    def post(self, *args, **kwargs):
        pass

class ManageHandler(BaseHandler):
    def get(self, *args, **kwargs):
        # val=self.session.get_value('is_login')
        val=self.session['is_login'] #调用__getitem方法
        if val:
            self.write('成功')
        else:
            self.write("失败")
    def post(self, *args, **kwargs):
        pass

application=tornado.web.Application([
    (r'/index',IndexHandler),
    (r'/manager',ManageHandler),
])

if __name__=='__main__':
    application.listen(9999)
    tornado.ioloop.IOLoop.instance().start()

3、session

Session其实就是定义在服务器端用于保存用户回话的容器，其必须依赖cookie才能实现。

#!/usr/bin/env/ python
# -*-coding:utf-8 -*-
#自定义session 模块化
container={}
class Session:
    """封装了__getitem__和__setitem__魔法方法"""
    def __init__(self,handler):
        self.handler=handler
        self.random_str=None

    #定义一个生成随机字符串的私有方法，只能内部访问
    def __generate_random_str(self):
        import hashlib
        import time
        obj=hashlib.md5()
        obj.update(bytes(str(time.time()),encoding='utf-8'))
        random_str=obj.hexdigest()
        return random_str

#把随机字符串内生成一个字典对象并写入数据并把随机字符串通过cookie写到客户端
    # def set_value(self,key,value):
    def __setitem__(self, key, value): #魔法方法 使得调用时像字典一样简单赋值
        """
         __setitem__(self, key, value) 定义当一个条目被赋值时的行为,使用 self[key] = value 。这也是可变容器和不可变容器协议中都要有的一部分
        """
        # 判断
        #在container中加入随机字符串
        #定义专属于自己的数据
        #往客户机中写入随机字符串

        #判断，请求用户是否已有随机字符串
        if not self.random_str: #如果container中有
            random_str=self.handler.get_cookie('k1',None)
        #如果没有则生成
            if not random_str:
                random_str = self.__generate_random_str()
                container[random_str] = {}
            else:
                #客户机有随机字符串
                if random_str in container.keys():
                    # 再次确认一下服务器端是否存在，防止服务端重启后，数据被清空
                    pass
                else:
                    random_str=self.__generate_random_str()
                    container[random_str] = {}
        container[random_str][key]=value
        self.handler.set_cookie('k1',random_str)

#获取客户端的随机字符串并取值
    # def get_value(self,key):
    def __getitem__(self, item):#魔法方法 使得调用时像字典一样简单取值
        """
         __getitem__(self, key) 定义当一个条目被访问时，使用符号 self[key] 。这也是不可变容器和可变容器都要有的协议的一部分。如果键的类型错误和 KeyError 或者没有合适的值。那么应该抛出适当的 TypeError 异常
       
        """
        #获取客户端的随机字符串
        #从container中获取我的数据
        #专属信息【key】
        random_str=self.handler.get_cookie("k1")
        if not random_str:
            return None
        #客户机有随机字符串话,获取该字符串在服务器中对应的数据
        user_info_dict=container.get(random_str,None)
        if not user_info_dict:
            #如果服务器中没有的话，cookie有可能是伪造的
            return None
        #获取值
        value=user_info_dict.get(item,None)
        return value

考虑到减轻服务器性能上和防止用户数据丢失，通常我们会把其存放于缓存，数据库或redis...中

#!/usr/bin/env/ python
# -*-coding:utf-8 -*-
#Session的类型：cache/redis/memcached
SESSION_TYPE='cache'
#Session超时时间
SESSION_EXPIRES=60*20
LOGIN_URL='/login'

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import config
from hashlib import sha1
import os
import time
import json

#生成随机字符串
create_session_id = lambda: sha1(bytes('%s%s' % (os.urandom(16), time.time()), encoding='utf-8')).hexdigest()


class SessionFactory:

    @staticmethod
    def get_session_obj(handler):
        obj = None

        if config.SESSION_TYPE == "cache":
            obj = CacheSession(handler)
        elif config.SESSION_TYPE == "memcached":
            obj = MemcachedSession(handler)
        elif config.SESSION_TYPE == "py_redis":
            obj = RedisSession(handler)
        return obj


class CacheSession:
    session_container = {}
    session_id = "__sessionId__"

    def __init__(self, handler):
        self.handler = handler
        client_random_str = handler.get_cookie(CacheSession.session_id, None)
        if client_random_str and client_random_str in CacheSession.session_container:
            self.random_str = client_random_str
        else:
            self.random_str = create_session_id()
            CacheSession.session_container[self.random_str] = {}

        expires_time = time.time() + config.SESSION_EXPIRES
        handler.set_cookie(CacheSession.session_id, self.random_str, expires=expires_time)

    def __getitem__(self, key):
        ret = CacheSession.session_container[self.random_str].get(key, None)
        return ret

    def __setitem__(self, key, value):
        CacheSession.session_container[self.random_str][key] = value

    def __delitem__(self, key):
        if key in CacheSession.session_container[self.random_str]:
            del CacheSession.session_container[self.random_str][key]

import redis

pool = redis.ConnectionPool(host='192.168.49.130', port=6379)
r = redis.Redis(connection_pool=pool)
class RedisSession:
    session_id = "__sessionId__"

    def __init__(self, handler):
        self.handler = handler
        #从客户端获取随机字符串
        client_random_str = handler.get_cookie(RedisSession.session_id, None)
        # 判断客户机是否有随机字符串，还有服务器端是否也存在，防止服务端重启后，数据被清空
        if client_random_str and r.exists(client_random_str) :
            self.random_str = client_random_str
        else:
            self.random_str = create_session_id()#生成随机字符串
            r.hset('self.random_str',None,None)#创建Session

        #来一次访问更新一下时间
        r.expire('self.random_str', config.SESSION_EXPIRES)
        expires_time = time.time() + config.SESSION_EXPIRES
        handler.set_cookie(RedisSession.session_id, self.random_str, expires=expires_time)

    def __getitem__(self ,key):
        ret_str=r.hget(self.random_str,key)
        #判断是否为空
        if ret_str:
            #不为空则检测索取所取的值是否能loads
            try:
                ret=json.loads(ret_str)
            except:
                ret=ret_str
            return ret

    def __setitem__(self, key, value):
        if type(value)==dict:
            r.hset(self.random_str,key,json.dumps(value))#因为value是会以字符串的形式写进redis里的，故先把其dumps成字符串，方便后面的取值操作通过loads还原其类型
        else:
            r.hset(self.random_str, key,value)

    def __delitem__(self, key):
        r.hdel(self.random_str,key)


import memcache
mc=memcache.Client(['192.168.49.130:12000'],debug=True) #连接
mc.set('session_container',json.dumps({}))#由于Memcached存储的是字符串类型，因此我们需把dict给json.dumps
class MemcachedSession:
    session_id = "__sessionId__"

    def __init__(self, handler):
        self.handler = handler
        #从客户端获取随机字符串
        client_random_str = handler.get_cookie(MemcachedSession.session_id, None)

        s_c = json.loads(mc.get('session_container'))
        # 判断客户机是否有随机字符串，还有服务器端是否也存在，防止服务端重启后，数据被清空
        if client_random_str and client_random_str in s_c:
            self.random_str = client_random_str
        else:
            self.random_str = create_session_id()
            s_c[self.random_str] = {}
            mc.set('session_container', json.dumps(s_c), config.SESSION_EXPIRES)

        #来一次访问更新一下时间
        mc.set('session_container',json.dumps(s_c),config.SESSION_EXPIRES)
        expires_time = time.time() + config.SESSION_EXPIRES
        handler.set_cookie(MemcachedSession.session_id, self.random_str, expires=expires_time)

    def __getitem__(self ,key):
        s_c = json.loads(mc.get('session_container'))
        ret = s_c[self.random_str].get(key, None)
        return ret

    def __setitem__(self, key, value):
        s_c = json.loads(mc.get('session_container'))
        s_c[self.random_str][key] =value
        mc.set('session_container',json.dumps(s_c),config.SESSION_EXPIRES)

    def __delitem__(self, key):
        s_c = json.loads(mc.get('session_container'))
        if key in s_c[self.random_str]:
            del s_c[self.random_str][key]
            mc.set('session_container', json.dumps(s_c), config.SESSION_EXPIRES)

4、分布式Session

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

import sys
import math
from bisect import bisect


if sys.version_info >= (2, 5):
    import hashlib
    md5_constructor = hashlib.md5
else:
    import md5
    md5_constructor = md5.new


class HashRing(object):
    """一致性哈希"""
    
    def __init__(self,nodes):
        '''初始化
        nodes : 初始化的节点，其中包含节点已经节点对应的权重
                默认每一个节点有32个虚拟节点
                对于权重，通过多创建虚拟节点来实现
                如：nodes = [
                        {'host':'127.0.0.1:8000','weight':1},
                        {'host':'127.0.0.1:8001','weight':2},
                        {'host':'127.0.0.1:8002','weight':1},
                    ]
        '''
        
        self.ring = dict()
        self._sorted_keys = []

        self.total_weight = 0
        
        self.__generate_circle(nodes)
        
            
            
    def __generate_circle(self,nodes):
        for node_info in nodes:
            self.total_weight += node_info.get('weight',1)
            
        for node_info in nodes:
            weight = node_info.get('weight',1)
            node = node_info.get('host',None)
                
            virtual_node_count = math.floor((32*len(nodes)*weight) / self.total_weight)
            for i in xrange(0,int(virtual_node_count)):
                key = self.gen_key_thirty_two( '%s-%s' % (node, i) )
                if self._sorted_keys.__contains__(key):
                    raise Exception('该节点已经存在.')
                self.ring[key] = node
                self._sorted_keys.append(key)
            
    def add_node(self,node):
        ''' 新建节点
        node : 要添加的节点，格式为：{'host':'127.0.0.1:8002','weight':1}，其中第一个元素表示节点，第二个元素表示该节点的权重。
        '''
        node = node.get('host',None)
        if not node:
                raise Exception('节点的地址不能为空.')
                
        weight = node.get('weight',1)
        
        self.total_weight += weight
        nodes_count = len(self._sorted_keys) + 1
        
        virtual_node_count = math.floor((32 * nodes_count * weight) / self.total_weight)
        for i in xrange(0,int(virtual_node_count)):
            key = self.gen_key_thirty_two( '%s-%s' % (node, i) )
            if self._sorted_keys.__contains__(key):
                raise Exception('该节点已经存在.')
            self.ring[key] = node
            self._sorted_keys.append(key)
        
    def remove_node(self,node):
        ''' 移除节点
        node : 要移除的节点 '127.0.0.1:8000'
        '''
        for key,value in self.ring.items():
            if value == node:
                del self.ring[key]
                self._sorted_keys.remove(key)
    
    def get_node(self,string_key):
        '''获取 string_key 所在的节点'''
        pos = self.get_node_pos(string_key)
        if pos is None:
            return None
        return self.ring[ self._sorted_keys[pos]].split(':')
    
    def get_node_pos(self,string_key):
        '''获取 string_key 所在的节点的索引'''
        if not self.ring:
            return None
            
        key = self.gen_key_thirty_two(string_key)
        nodes = self._sorted_keys
        pos = bisect(nodes, key)
        return pos
    
    def gen_key_thirty_two(self, key):
        
        m = md5_constructor()
        m.update(key)
        return long(m.hexdigest(), 16)
        
    def gen_key_sixteen(self,key):
        
        b_key = self.__hash_digest(key)
        return self.__hash_val(b_key, lambda x: x)

    def __hash_val(self, b_key, entry_fn):
        return (( b_key[entry_fn(3)] << 24)|(b_key[entry_fn(2)] << 16)|(b_key[entry_fn(1)] << 8)| b_key[entry_fn(0)] )

    def __hash_digest(self, key):
        m = md5_constructor()
        m.update(key)
        return map(ord, m.digest())


"""
nodes = [
    {'host':'127.0.0.1:8000','weight':1},
    {'host':'127.0.0.1:8001','weight':2},
    {'host':'127.0.0.1:8002','weight':1},
]

ring = HashRing(nodes)
result = ring.get_node('98708798709870987098709879087')
print result

"""

from hashlib import sha1
import os, time


create_session_id = lambda: sha1('%s%s' % (os.urandom(16), time.time())).hexdigest()


class Session(object):

    session_id = "__sessionId__"

    def __init__(self, request):
        session_value = request.get_cookie(Session.session_id)
        if not session_value:
            self._id = create_session_id()
        else:
            self._id = session_value
        request.set_cookie(Session.session_id, self._id)

    def __getitem__(self, key):
        # 根据 self._id ，在一致性哈西中找到其对应的服务器IP
        # 找到相对应的redis服务器，如： r = redis.StrictRedis(host='localhost', port=6379, db=0)
        # 使用python redis api 链接
        # 获取数据，即：
        # return self._redis.hget(self._id, name)

    def __setitem__(self, key, value):
        # 根据 self._id ，在一致性哈西中找到其对应的服务器IP
        # 使用python redis api 链接
        # 设置session
        # self._redis.hset(self._id, name, value)


    def __delitem__(self, key):
        # 根据 self._id 找到相对应的redis服务器
        # 使用python redis api 链接
        # 删除，即：
        return self._redis.hdel(self._id, name)

参考:http://www.cnblogs.com/wupeiqi/articles/5433893.html