def __init__(self, *args, **kwargs):
"""Patch ``kwargs['cache_args']``."""
if not 'cache_args' in kwargs:
# Read the ``cache.*`` ones into ``cache_args``.
cache_args = {}
prefix = 'mako.cache_args.'
for key in settings.keys():
if key.startswith(prefix):
name = key.split(prefix)[1].strip()
value = settings[key]
try:
value = value.strip()
except AttributeError:
pass
cache_args[name] = value
coerce_cache_params(cache_args)
cache_args['timeout'] = cache_args.get('expire')
type_arg = cache_args.get('type')
if type_arg and type_arg.startswith('dogpile.cache'):
cache_args = coerge_dogpile_args(cache_args)
register_plugin("dogpile.cache",
"pyramid_weblayer.patch", "UnicodeKeyCapableMakoPlugin")
kwargs['cache_impl'] = 'dogpile.cache'
kwargs['cache_args'] = cache_args
super(TemplateLookup, self).__init__(*args, **kwargs)
def __init__(
self, directories=None,
module_directory='/tmp/mako_modules',
cache=None,
**kwargs):
from mako.lookup import TemplateLookup
if cache is None:
self.template_lookup = TemplateLookup(
directories=directories or ['content/templates'],
module_directory=module_directory,
**kwargs)
else:
from mako.cache import register_plugin
register_plugin('wheezy', 'wheezy.web.templates', 'MakoCacheImpl')
self.template_lookup = TemplateLookup(
directories=directories or ['content/templates'],
module_directory=module_directory,
cache_impl='wheezy',
cache_args={'cache': cache},
**kwargs)
f"cannot access local variable {var} where it is not associated",
)
return any((msg in rendered_output) for msg in error_msgs)
class PlainCacheImpl(CacheImpl):
"""Simple memory cache impl so that tests which
use caching can run without beaker."""
def __init__(self, cache):
self.cache = cache
self.data = {}
def get_or_create(self, key, creation_function, **kw):
if key in self.data:
return self.data[key]
else:
self.data[key] = data = creation_function(**kw)
return data
def put(self, key, value, **kw):
self.data[key] = value
def get(self, key, **kw):
return self.data[key]
def invalidate(self, key, **kw):
del self.data[key]
register_plugin("plain", __name__, "PlainCacheImpl")
cache.set(key, value, timeout)
return value
def set(self, key, value, **kwargs):
timeout = kw.get('timeout', None)
cache.set(key, value, timeout)
def get(self, key, **kwargs):
return cache.get(key)
def invalidate(self, key, **kwargs):
cache.delete(key)
# optional - register the class locally
register_plugin("django_cache", __name__, "DjangoCache")
########NEW FILE########
__FILENAME__ = defaults
"""Options used only by Django"""
import os
import logging
from django.conf import settings
from nemo.parser import nemo
MAKO_TEMPLATE_DIRS=(os.path.join(settings.SITE_ROOT, 'templates'),)
MAKO_TEMPLATE_OPTS=dict(input_encoding='utf-8',
output_encoding='utf-8',
module_directory=os.path.join(settings.SITE_ROOT, 'cache'),
preprocessor=nemo
)
from mako.cache import register_plugin
from mako.template import Template
import mock
import pytest
from .. import eq_
try:
import mako # noqa
except ImportError:
raise pytest.skip("this test suite requires mako templates")
register_plugin(
"dogpile.cache", "dogpile.cache.plugins.mako_cache", "MakoPlugin"
)
class TestMakoPlugin(TestCase):
def _mock_fixture(self):
reg = mock.MagicMock()
reg.get_or_create.return_value = "hello world"
my_regions = {"myregion": reg}
return (
{
"cache_impl": "dogpile.cache",
"cache_args": {"regions": my_regions},
},
reg,
)
return fn(*arg, **kw)
finally:
exceptions._install_highlighting()
return function_named(go, fn.__name__)
class PlainCacheImpl(CacheImpl):
"""Simple memory cache impl so that tests which
use caching can run without beaker. """
def __init__(self, cache):
self.cache = cache
self.data = {}
def get_or_create(self, key, creation_function, **kw):
if key in self.data:
return self.data[key]
else:
self.data[key] = data = creation_function(**kw)
return data
def put(self, key, value, **kw):
self.data[key] = value
def get(self, key, **kw):
return self.data[key]
def invalidate(self, key, **kw):
del self.data[key]
register_plugin("plain", __name__, "PlainCacheImpl")
self.key = key
self._setup_kwargs(kw)
self.realcacheimpl.put(key, value, **kw)
def get(self, key, **kw):
self.key = key
self._setup_kwargs(kw)
return self.realcacheimpl.get(key, **kw)
def invalidate(self, key, **kw):
self.key = key
self._setup_kwargs(kw)
self.realcacheimpl.invalidate(key, **kw)
register_plugin("mock", __name__, "MockCacheImpl")
class CacheTest(TemplateTest):
real_backend = "simple"
def _install_mock_cache(self, template, implname=None):
template.cache_impl = "mock"
impl = template.cache.impl
impl.set_backend(template.cache, implname or self.real_backend)
return impl
def test_def(self):
t = Template(
"""
from vilya.libs.store import mc, ONE_HOUR
from mako.cache import CacheImpl, register_plugin
class McCacheImpl(CacheImpl):
"""基于mc的页面cache实现"""
def __init__(self, cache):
self.cache = cache
def get_or_create(self, key, creation_function, **kw):
r = mc.get(key)
if r is None:
r = creation_function()
expiretime = kw.get("timeout", ONE_HOUR)
mc.set(key, r, expiretime)
return r
def set(self, key, value, **kw):
expiretime = kw.get("timeout", ONE_HOUR)
mc.set(key, value, expiretime)
def get(self, key, **kw):
return mc.get(key)
def invalidate(self, key, **kw):
mc.delete(key)
register_plugin("mccache", __name__, "McCacheImpl")
self.realcacheimpl.put(key, value, **kw)
def get(self, key, **kw):
self.key = key
self.kwargs = kw.copy()
if self.realcacheimpl:
return self.realcacheimpl.get(key, **kw)
def invalidate(self, key, **kw):
self.key = key
self.kwargs = kw.copy()
if self.realcacheimpl:
self.realcacheimpl.invalidate(key, **kw)
register_plugin("mock", __name__, "MockCacheImpl")
class BeakerCacheTest(TemplateTest):
def _regions(self):
return beaker.cache.CacheManager(
cache_regions={
'short': {
'expire': 1,
'type': 'memory'
},
'long': {
'expire': 60,
'type': 'memory'
}
})
from .. import eq_
from unittest import TestCase
from nose import SkipTest
try:
import mako
except ImportError:
raise SkipTest("this test suite requires mako templates")
from mako.template import Template
from mako.cache import register_plugin
import mock
register_plugin("dogpile.cache", "dogpile.cache.plugins.mako_cache", "MakoPlugin")
class TestMakoPlugin(TestCase):
def _mock_fixture(self):
reg = mock.MagicMock()
reg.get_or_create.return_value = "hello world"
my_regions = {"myregion": reg}
return {"cache_impl": "dogpile.cache", "cache_args": {"regions": my_regions}}, reg
def test_basic(self):
kw, reg = self._mock_fixture()
t = Template('<%page cached="True" cache_region="myregion"/>hi', **kw)
t.render()
eq_(reg.get_or_create.call_count, 1)
def test_timeout(self):
kw, reg = self._mock_fixture()
from vilya.libs.store import mc, ONE_HOUR
from mako.cache import CacheImpl, register_plugin
class McCacheImpl(CacheImpl):
"""基于mc的页面cache实现"""
def __init__(self, cache):
self.cache = cache
def get_or_create(self, key, creation_function, **kw):
r = mc.get(key)
if r is None:
r = creation_function()
expiretime = kw.get('timeout', ONE_HOUR)
mc.set(key, r, expiretime)
return r
def set(self, key, value, **kw):
expiretime = kw.get('timeout', ONE_HOUR)
mc.set(key, value, expiretime)
def get(self, key, **kw):
return mc.get(key)
def invalidate(self, key, **kw):
mc.delete(key)
register_plugin("mccache", __name__, "McCacheImpl")
