openstack中关于oslo.cache模块，主要用于读取缓存中的数据

需要用到的模块包括oslo.cache和dogpile.cache模块

下面通过demo代码来具体说明oslo.cache模块是怎么使用的：

1. cache.conf文件，这个文件主要是一些配置信息

[cache]
memcache_servers = 127.0.0.1:11211
enabled = true
#选择相应的存储后端，不同的存储后端，对应的不同的类型，后面代码中会有演示说明
#backend = dogpile.cache.memory
backend = oslo_cache.memcache_pool#下面是自己的配置项，可以通过oslo.config模块来配置
[feature]
caching = True
cache_time = 7200

2.cacheutils.py文件，这个文件类似于cache_utils.py文件，对oslo.cache模块进行了二次封装。这里主要是demo代码，可以脱离opensatck环境运行！

from oslo_cache import core as cache 
from oslo_config import cfg 
import sysWEEK = 604800CONF = cfg.CONF	#get the CONF obejct!下面是配置“feature”配置组，“cache”配置组不用单独配置，后面可以直接调用API进行处理！
caching = cfg.BoolOpt('caching',default = True)
cache_time = cfg.IntOpt('cache_time',default=3600)feature_group = cfg.OptGroup(name = 'feature',title = 'feature name'
)CONF.register_group(feature_group)
CONF.register_opts([caching,cache_time],feature_group)#load config file here
CONF(sys.argv[1:],default_config_files=['cache.conf'])#cache.configure函数可以直接对cache配置组进行配置，配置过程也类似于上面的feature配置，具体可以查看oslo.cache中的代码！
cache.configure(CONF)  #confiure the cache group!#下面的函数就是返回region类对象，传入的参数是CONF
#cache.configure_cache_region(CONF,region)是配置存储后端
def _get_default_cache_region(expiration_time):region = cache.create_region()if expiration_time != 0:CONF.cache.expiration_time = expiration_timecache.configure_cache_region(CONF,region)print("***CONF.cache.backend is %s"%(CONF.cache.backend))print("####configure the backend is %s"%(region.backend))return regiondef _get_custom_cache_region(expiration_time=WEEK,backend=None,url=None):region = cache.create_region()region_params = {}if expiration_time != 0:region_params['expiration_time'] = expiration_timeif backend == 'oslo_cache.dict':region_params['arguments'] = {'expiration_time':expiration_time}elif backend == 'dogpile.cache.memcached':region_params['arguments'] = {'url':url}else:print('old style configuration can use only dictionary or memcached backends')region.configure(backend,**region_params)return region#CacheClient类就是对region的二次封装，而region中的方法，是对后端类对象方法的二次封装，后面会具体说明
class CacheClient():def __init__(self,region):self.region = regiondef get(self,key):value = self.region.get(key)if value == cache.NO_VALUE:return Nonereturn valuedef get_or_create(self,key,creator):return self.region.get_or_create(key,creator)def set(self,key,value):return self.region.set(key,value)def add(self,key,value):return self.region.get_or_create(key,lambda : value)def delete(self,key):return self.region.delete(key)def get_multi(self,keys):values = self.region.get_multi(keys)return [None if value is cache.NO_VALUE else value for value in values]def delete_multi(self,keys):return self.region.delete_multi(keys)def _warn_if_null_backend():if CONF.cache.backend == 'dogpile.cache.null':print("Cache enabled with backend dogpile.cache.null.")#这个方法就是返回一个CacheClient类对象，这个CacheClient类对象，已经进行初始化了，可以直接调用其中的method对数据进行存储和读取！
def get_client(expiration_time=0):"""Used to get a caching client."""# If the operator has [cache]/enabled flag on then we let oslo_cache# configure the region from configuration settings.if CONF.cache.enabled:_warn_if_null_backend()print('_get_default_cache_region')print('%s'%(_get_default_cache_region(expiration_time=expiration_time)))return CacheClient(_get_default_cache_region(expiration_time=expiration_time))# If [cache]/enabled flag is off, we use the dictionary backendprint('_get_custom_cache_region')return CacheClient(_get_custom_cache_region(expiration_time=expiration_time,backend='oslo_cache.dict'))#if __name__=='__main__':
print("the caching is %s and the cache_time is %s"%(CONF.feature.caching,CONF.feature.cache_time))
#print('enable = %s and backend = %s'%(CONF.cache.enabled,CONF.cache.backend))

上面代码中，会调用cache.configure_cache_region(conf, region)函数配置存储后端，下面就这个函数进行详细的说明是如何进行配置的

configure_cache_region(conf, region)函数位于oslo_cache/core.py文件中，里面调用的是region.configure_from_config(config_dict,'%s.' % conf.cache.config_prefix)
config_dict是一个字典，里面是关于配置文件中的参数
config_prefix是oslo.cache
configure_from_config函数位于dogpile/cache/region.py文件中
在这个文件中调用返回的是：
return self.configure( #第一个参数是指定存储后端的名称，这里是dogpile.cache.memcachedconfig_dict["%sbackend" % prefix],#prefix是cache.oslo.expiration_time=config_dict.get("%sexpiration_time" % prefix, None),_config_argument_dict=config_dict,_config_prefix="%sarguments." % prefix,wrap=config_dict.get("%swrap" % prefix, None),replace_existing_backend=config_dict.get("%sreplace_existing_backend" % prefix, False),)
下面我们再看一下self.configure函数：
在这个函数中，会调用：
backend_cls = _backend_loader.load(backend)
self.backend = backend_cls(arguments or {})
最后return self，即返回region自身！
这里的backend_cls就是后端存储类对象，然后用参数对其进行初始化！
如果在cache.conf文件中配置
[cache]
memcache_servers = 127.0.0.1:11211
enabled = true
#backend = dogpile.cache.memory
backend = oslo_cache.memcache_pool
则可以看到cache.region.backend是如下类型的对象：
configure the backend is <oslo_cache.backends.memcache_pool.PooledMemcachedBackend object at 0x7f46bb3b2d68> 
如果backend = dogpile.cache.memory，则是：
configure the backend is <dogpile.cache.backends.memory.MemoryBackend object at 0x7f7ace9541d0>
如果都不进行配置的话，
####configure the backend is <dogpile.cache.backends.null.NullBackend object at 0x7f872a8d30b8>

可以看到的是，cache中封装的是region对象的add，set ，get等方法，region对象又是封装backend中的方法！

oslo_cache.backends.memcache_pool.PooledMemcachedBackend是位于oslo_cache/backends/memcache_pool.py文件中的PooledMemcachedBackend类对象！

3.app.py文件，这个文件主要是demo代码，演示如何对缓存数据进行设置和读写的

import cacheutils
import functools'''
nova首先创建了一个memoize装饰器，在该装饰器中首先调用get_client()获取一个CacheClient对象，
然后调用该函数的get()方法获取指定key的值，如果查不到则将该值保存到缓存中，
'''
_CACHE_TIME = 7 * 24 * 60 * 60
_CACHE = None
cl = None
cl2 = None
def memorize(func):@functools.wraps(func)def memorizer(context,image_id):global _CACHE	#这里用的是全局变量，不然的话，创建新的连接的时候，无法得到原来的值if not _CACHE:_CACHE = cacheutils.get_client(expiration_time=_CACHE_TIME)print('_CACHE is %s'%_CACHE)key="%s"%(func.__name__)key=str(key)value=_CACHE.get(key)if value is None:print('value is none!')value = func(context,image_id)val = _CACHE.set(key,value)value=_CACHE.get(key)print('the set return value is %s'%val)print('_CACHE.region = %s'%(_CACHE.region))return valuereturn memorizer@memorize
def id_to_glance_id(context,image_id):return context[image_id]@memorize
def glance_id_to_id(context,glance_id):if not glance_id:returntry:return context[galnce_id]except exception.NotFound:LOG.error('cannot find the values!')
'''
def myfun(key,value):global clif not cl:cl = cacheutils.get_client(expiration_time=_CACHE_TIME)key=str(key)cl.delete(key)val = cl.add(key,value)print('cl.add return value: val = %s'%val)print('key = %s'%key)VAL = cl.get(key)print('VAL1 is %s'%VAL)cl.set(key,'jihhhhsnna')VAL = cl.get(key)print('VAL2 is %s'%VAL)cl1 = cacheutils.get_client(expiration_time=_CACHE_TIME)#cl.delete(key)VAL = cl1.get(key)print('cl1 VAL3 is %s'%VAL)#print("####the backend is %s"%(cl1.region.backend))def myfun2(key):global cl2if not cl2:cl2 = cacheutils.get_client(expiration_time=_CACHE_TIME)key=str(key)print('key = %s'%key)Val = cl.get(key)print('value2 is %s'%Val)
'''
if __name__ == '__main__':image_id = 1234context = {1234:'this is image_id:1234'}value = id_to_glance_id(context,image_id)print('the value is %s'%value)
'''myfun('mykey',90)myfun2('mykey')
'''