cookies與session

時間 2019-11-16

原文原文鏈接

cookies與session

一、Cookies

　　Cookie是由服務器端生成，發送給User-Agent（通常是瀏覽器），瀏覽器會將Cookie的key/value保存到某個目錄下的文本文件內，下次請求同一網站時就發送該Cookie給服務器（前提是瀏覽器設置爲啓用cookie）。Cookie名稱和值能夠由服務器端開發本身定義，這樣服務器能夠知道該用戶是不是合法用戶以及是否須要從新登陸等，服務器能夠設置或讀取Cookies中包含信息，藉此維護用戶跟服務器會話中的狀態。html

cookie的做用

　　服務器能夠利用Cookies包含信息的任意性來篩選並常常性維護這些信息，以判斷在HTTP傳輸中的狀態。Cookies最典型的應用是斷定註冊用戶是否已經登陸網站，用戶可能會獲得提示，是否在下一次進入此網站時保留用戶信息以便簡化登陸手續，這些都是Cookies的功用。另外一個重要應用場合是「購物車」之類處理。用戶可能會在一段時間內在同一家網站的不一樣頁面中選擇不一樣的商品，這些信息都會寫入Cookies，以便在最後付款時提取信息。node

1.基本操做

Cookie的操做python

　　簡單來講，Cookie 是保存在瀏覽器的一個鍵值對，每次的HTTP請求都會攜帶 Cookie 。git

獲取全部的Cookiesweb

self.cookies

設置Cookieredis

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!")

View Code

二、加密cookie（簽名）

　　Cookie 很容易被惡意的客戶端僞造。加入你想在 cookie 中保存當前登錄用戶的 id 之類的信息，你須要對 cookie 做簽名以防止僞造。Tornado 經過 set_secure_cookie 和 get_secure_cookie 方法直接支持了這種功能。要使用這些方法，你須要在建立應用時提供一個密鑰，名字爲 cookie_secret。你能夠把它做爲一個關鍵詞參數傳入應用的設置中：json

設置一個加密Cookie所須要的參數：api

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=")

View Code

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的實現機制相同。

三、用戶認證

　　當前已經經過認證的用戶在每一個請求處理函數中均可以經過 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()

基於cookie實現用戶驗證_demo

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()

基於簽名cookie實現用戶驗證_demo

二、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組件來知足咱們的需求。

一、面向對象基礎

面向對象中經過索引的方式訪問對象，須要內部實現 __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

View Code

二、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()

View Code

三、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

自定義session

考慮到減輕服務器性能上和防止用戶數據丟失，一般咱們會把其存放於緩存，數據庫或redis...中

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

config.py

#!/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)

session

四、分佈式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)