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 sys
WEEK = 604800
CONF = 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_time
cache.configure_cache_region(CONF,region)
print("***CONF.cache.backend is %s"%(CONF.cache.backend))
print("####configure the backend is %s"%(region.backend))
return region
def _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_time
if 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 = region
def get(self,key):
value = self.region.get(key)
if value == cache.NO_VALUE:
return None
return value
def 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 backend
print('_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.memcached
config_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 value
return 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:
return
try:
return context[galnce_id]
except exception.NotFound:
LOG.error('cannot find the values!')
'''
def myfun(key,value):
global cl
if 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 cl2
if 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 = 1234
context = {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')
'''