使用装饰器管理缓存

这个来自python高手飞龙非龙的代码

# -*- coding: utf-8 -*-

#

# Copyright(c) 2010 poweredsites.org

#

# Licensed under the Apache License, Version 2.0 (the "License"); you may

# not use this file except in compliance with the License. You may obtain

# a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

# License for the specific language governing permissions and limitations

# under the License.



import hashlib

from datetime import datetime, timedelta

from decorator import decorator

from tornado.escape import utf8

from tornado.options import options



from poweredsites.libs.handler import BaseHandler

from poweredsites.db.caches import Page, Cache

from poweredsites.db import conn



__all__ = ("cache", "page", "mem", "key_gen", "remove")



_mem_caches = {}



def cache(expire=7200, condition="", key="", anonymous=False):

    """Decorator which caches the value of a method in a handler or a module.    

    

    expire: Cache will be expired time from now in seconds.

    condition: If the result of sql condition has changed, then cache expired. 

    key: The unique key of the cache identify in the DB 

    

    cache_pre: A method which is defined in self(handler or module), 

                it always be executed before cache or get from cache.

                

    cache_condition: A property which is defined in self(handler or module), it

                is used to construct a complex condition.

    """

    def wrapper(func, self, *args, **kwargs):

        now = datetime.now()

        if key:

            c = key

        else:

            c = self.__class__.__name__ + func.__name__

        k, handler, cond = key_gen(self, condition, anonymous, c, *args, **kwargs)



        value = Cache().findby_key(k)

        new_cond = {}



        if _valid_cache(value, handler, cond, new_cond, anonymous, now):

            if new_cond:

                c = Cache()

                c.key = k

                c.condition = new_cond["condition"]

                c.save(value["_id"])

            return value["value"]

        else:

            val = func(self, *args, **kwargs)



            c = Cache()

            # need key, or save will not work

            c.key = k

            c.value = val

            c.expire = now + timedelta(seconds=expire)

            c.condition = new_cond.get("condition", "")



            if value:

                c.save(value["_id"])

            else:

                c.insert()



            return val



    return decorator(wrapper)



def page(expire=7200, condition="", key="", anonymous=False):

    """Decorator which caches a whole page(headers + html) in a handler

    

    expire: Cache will be expired time from now in seconds.   

    condition: If the result of sql condition has changed, then cache expired.

    key: The unique key of the cache identify in the DB 

    

    """

    def wrapper(func, self, *args, **kwargs):

        now = datetime.now()

        if key:

            c = key

        else:

            c = self.__class__.__name__ + func.__name__

        k, handler, cond = key_gen(self, condition, anonymous, c, *args, **kwargs)



        value = Cache().findby_key(k)

        new_cond = {}



        is_valid = _valid_cache(value, handler, cond, new_cond, anonymous, now)

        if is_valid and value["status"] in (200, 304) and value["chunk"]:

            if new_cond:

                c = Page()

                c.key = k

                c.condition = new_cond["condition"]

                c.save(value["_id"])



            # finish request with cache chunk and headers

            self.set_status(value["status"])

            self.set_header("Content-Type", utf8(value["headers"]["Content-Type"]))

            self.write(utf8("".join(value["chunk"])))

        else:

            func(self, *args, **kwargs)



            c = Page()

            c.key = k

            c.status = self._status_code

            c.headers = self._headers

            c.chunk = self._write_buffer

            c.expire = now + timedelta(seconds=expire)

            c.condition = new_cond.get("condition", "")



            if value:

                c.save(value["_id"])

            else:

                c.insert()



    return decorator(wrapper)



def mem(expire=7200, key=""):

    """Mem cache to python dict by key"""

    def wrapper(func, self, *args, **kwargs):

        now = datetime.now()

        if key:

            c = key

        else:

            c = self.__class__.__name__ + func.__name__

        k, handler, cond = key_gen(self, "", False, c, *args, **kwargs)



        value = _mem_caches.get(k, None)

        if _valid_cache(value, handler, cond, [], False, now):

            return value["value"]

        else:

            val = func(self, *args, **kwargs)

            _mem_caches[k] = {"value":val, "expire":now}



            return val



    return decorator(wrapper)



def key_gen(self, condition, anonymous, key, *args, **kwargs):

    code = hashlib.md5()



    code.update(str(key))



    # copy args to avoid sort original args

    c = list(args[:])

    # sort c to avoid generate different key when args is the same

    # but sequence is different

    c.sort()

    c = [str(v) for v in c]

    code.update("".join(c))



    c = ["%s=%s" % (k, v) for k, v in kwargs]

    c.sort()

    code.update("".join(c))



    if isinstance(self, BaseHandler):

        handler = self

    else:

        handler = getattr(self, "handler")



    # execute cache_pre before get cache_condition

    # so we can construct a complex condition.

    cache_pre = getattr(self, "cache_pre", None)

    if cache_pre:

        cache_pre(*args, **kwargs)



    if not condition:

        condition = getattr(self, "cache_condition", "")



    # also update condition to key, so the same func 

    # has diff caches if there condition is diff(cache_condtion)

    code.update(str(condition))



    # cache for every users if anonymous is False

    if not anonymous and handler.current_user:

        # add userid= prefix to avoid key conflict

        # (eg. siteid + userid maybe equal another siteid)

        code.update(str("userid=%s" % handler.current_user.id))



    # page argument as key by default

    # Todo: add a argument option for key gen like condition

    page = handler.get_argument("page", "")

    if page:

        code.update(str("page=%s" % page))



    # cache for different host(the same uri may have different subdomain)

    code.update(handler.request.host)



    return code.hexdigest(), handler, condition



def remove(key):

    """Remove a cache's value."""

    c = Cache()

    v = c.findby_key(key)

    if v:

        c.remove(v["_id"])



def _valid_cache(value, handler, condition, new_condtion, anonymous, now):

    if not options.cache_enabled:

        return False



    if anonymous and handler.current_user:

        return False



    if condition:

        old_cond = value.get("condition", "") if value else ""

        rows = conn.mysql.query(condition)



        new_cond = ""

        for r in rows:

            new_cond += str(r)



        # unify to utf8, the string result return by pymongo is unicode

        new_cond = utf8(new_cond)

        old_cond = utf8(old_cond if old_cond else "")



        if old_cond != new_cond:

            new_condtion["condition"] = new_cond

            return False



    if value:

        if value["expire"] > now:

            return True

        else:

            return False

    else:

        return False