Localcache

1 常用方法

1.1 Index

1.1.1 使用

from conf import config
from xlib import diskcache as _dc
from xlib.util import time_util
addr_list_a = _dc.Index("{data_dir}/addr_list_a".format(data_dir=config.LOCALDATA_DIR))

addr_list_a['127.0.0.1:8585'] = time_util.get_current_time()
addr_list_a['127.0.0.2:8585'] = time_util.get_current_time()
for item in addr_list_a:
    print "key={key} value={value}".format(key=item, value=addr_list_a[item])

# pop
print "--------------------------------pop"
addr_list_a.pop('127.0.0.2:8585')
for item in addr_list_a:
    print "key={key} value={value}".format(key=item, value=addr_list_a[item])

1.1.2 例子：服务启动时将 slot key 加载到本地存储中

from conf import config
from xlib import diskcache as _dc
slot_key_list = _dc.Index("{data_dir}/slot_key".format(data_dir=config.LOCALDATA_DIR))

if len(slot_key_list) != 16384:
    with open("./slot_key.md","r") as f:
        for line in f:
            line_list = line.strip().split("  ")
            key_index = int(line_list[0])
            key_name = "{{{hash_tag}}}:{slot}".format(hash_tag=line_list[-1], slot=key_index)
            slot_key_list[key_index] = key_name

# 生成随机 200 个 slot
import random
def get_random_list():
    slot_set = set()
    for i in range(0, 200):
        slot_set.add(random.randint(0,16383))
    return slot_set

• slot 生成工具 check_slot

1.2 kv

from conf import config
from xlib import diskcache as _dc
server_config = _dc.Cache(directory="{data_dir}/diskcache".format(data_dir=config.LOCALDATA_DIR))

# None
print server_config.get("addr_list_name")
# True
print server_config.set("addr_list_name", "a")
# a
print server_config.get("addr_list_name")

这里的 value 可以是 list 也可以是 dict

1.3 lock

acquire() 是同步的，即若加锁失败，会一直处于等待中，默认会 block，可以指定 block=False 为非阻塞

is_acquire = acquire(block=False) // 返回 True or False

from conf import config
from xlib import diskcache
from xlib.middleware import funcattr
from xlib.httpgateway import Request

@funcattr.api
def handler_demo(req):
    """
    demo
    """
    handler_locks = diskcache.Cache(directory="{data_dir}/handler_locks".format(data_dir=config.LOCALDATA_DIR))
    lock = diskcache.Lock(handler_locks, "handler_demo", expire=300)
    lock.acquire()
    try:
        stat, data = _handler_demo(req=req)
    except BaseException:
        stat, data = "ERR_SERVER_EXCEPTION", {}
    finally:
        lock.release()

    return stat, data

2 实践

2.1 装饰器

from xlib.middleware import cache

# 缓存 1 秒
@cache.cache_page(expire=1)
def generate_landing_page():
    return 3

2.2 普通方式缓存结果

场景:

• (1) 通过 req 指定了 idc，需要根据 idc 手动生成 key 名

• (2) 仅缓存成功的结果

# 指定 key 缓存
from xlib.middleware import cache

def get_host_list(req, pool=None, deployset_name=None):
    ENOVAL = "NODATA"
    key = "{region}_{app}_{func}_{arg1}_{arg2}".format(region=req.idc,
            app="x1",
            func="host_list",
            arg1=pool,
            arg2=deployset_name)

    result = cache.cache_obj.get(key, default=ENOVAL, retry=True)

    # find data
    if result != ENOVAL:
        req.log_res.add("{key}=cache_get|{num}".format(key=key, num=len(result)))
        return OK, result

    x1_resource_obj = X1Resource(req)
    stat, host_list = x1_resource_obj.host_list(pool=pool, deployset_name=deployset_name)
    if stat != OK:
        return stat, {}

    # set data
    cache.cache_obj.set(key, value=host_list, expire=15, retry=True)
    req.log_res.add("{key}=cache_set|{num}".format(key=key, num=len(host_list)))
    return OK, host_list

3 传送门

DiskCache Tutorial