def testMulti(self):
assert_pformat_equal(len(LocalSyncCache.CACHES), 0)
c1 = LocalSyncCache(id="test1")
assert_pformat_equal(len(LocalSyncCache.CACHES), 1)
c2 = LocalSyncCache(id="test1", unique_ids=False)
assert_pformat_equal(len(LocalSyncCache.CACHES), 2)
c1["c1"] = "foo"
c2["c2"] = "bar"
assert_pformat_equal(c1, {"c1": "foo"})
assert_pformat_equal(c2, {"c2": "bar"})
c1.check_state()
c2.check_state()
assert_pformat_equal(c1, {"c1": "foo"})
assert_pformat_equal(c2, {"c2": "bar"})
c1.clear()
assert_pformat_equal(c1, {})
# In a "new request" all the same caches should be cleared
c2.check_state()
assert_pformat_equal(c2, {})
cache_information = LocalSyncCache.get_cache_information()
assert_pformat_equal(len(cache_information), 2)
def testMulti(self):
self.assertEqual(len(LocalSyncCache.CACHES), 0)
c1 = LocalSyncCache(id="test1")
self.assertEqual(len(LocalSyncCache.CACHES), 1)
c2 = LocalSyncCache(id="test1", unique_ids=False)
self.assertEqual(len(LocalSyncCache.CACHES), 2)
c1["c1"] = "foo"
c2["c2"] = "bar"
self.assertEqual(c1, {'c1': 'foo'})
self.assertEqual(c2, {'c2': 'bar'})
c1.check_state()
c2.check_state()
self.assertEqual(c1, {'c1': 'foo'})
self.assertEqual(c2, {'c2': 'bar'})
c1.clear()
self.assertEqual(c1, {})
# In a "new request" all the same caches should be cleared
c2.check_state()
self.assertEqual(c2, {})
cache_information = LocalSyncCache.get_cache_information()
self.assertEqual(len(cache_information), 2)
def testMulti(self):
self.assertEqual(len(LocalSyncCache.CACHES), 0)
c1 = LocalSyncCache(id="test1")
self.assertEqual(len(LocalSyncCache.CACHES), 1)
c2 = LocalSyncCache(id="test1", unique_ids=False)
self.assertEqual(len(LocalSyncCache.CACHES), 2)
c1["c1"] = "foo"
c2["c2"] = "bar"
self.assertEqual(c1, {'c1': 'foo'})
self.assertEqual(c2, {'c2': 'bar'})
c1.check_state()
c2.check_state()
self.assertEqual(c1, {'c1': 'foo'})
self.assertEqual(c2, {'c2': 'bar'})
c1.clear()
self.assertEqual(c1, {})
# In a "new request" all the same caches should be cleared
c2.check_state()
self.assertEqual(c2, {})
cache_information = LocalSyncCache.get_cache_information()
self.assertEqual(len(cache_information), 2)
def testMulti(self):
assert_pformat_equal(len(LocalSyncCache.CACHES), 0)
c1 = LocalSyncCache(id="test1")
assert_pformat_equal(len(LocalSyncCache.CACHES), 1)
c2 = LocalSyncCache(id="test1", unique_ids=False)
assert_pformat_equal(len(LocalSyncCache.CACHES), 2)
c1["c1"] = "foo"
c2["c2"] = "bar"
assert_pformat_equal(c1, {"c1": "foo"})
assert_pformat_equal(c2, {"c2": "bar"})
c1.check_state()
c2.check_state()
assert_pformat_equal(c1, {"c1": "foo"})
assert_pformat_equal(c2, {"c2": "bar"})
c1.clear()
assert_pformat_equal(c1, {})
# In a "new request" all the same caches should be cleared
c2.check_state()
assert_pformat_equal(c2, {})
cache_information = LocalSyncCache.get_cache_information()
assert_pformat_equal(len(cache_information), 2)
class SiteAliasManager(models.Manager):
ALIAS_CACHE = None
def get_from_host(self, current_host):
if self.ALIAS_CACHE is None:
# first request after startup / model.save() -> fill the cache
logger.debug("init LocalSyncCache for SiteAlias cache")
self.ALIAS_CACHE = LocalSyncCache(id="SiteAliasCache")
if "string" not in self.ALIAS_CACHE:
logger.debug("Fill SiteAlias cache")
self.ALIAS_CACHE["string"] = {}
self.ALIAS_CACHE["regex"] = []
queryset = self.all()
for site_alias in queryset:
site = site_alias.site
alias = site_alias.alias
if site_alias.regex:
regex = compile_alias(alias)
self.ALIAS_CACHE["regex"].append((regex, site))
else:
self.ALIAS_CACHE["string"][alias.lower()] = site
self.ALIAS_CACHE["regex"] = tuple(self.ALIAS_CACHE["regex"])
logger.debug("Alias string cache: %s" %
repr(self.ALIAS_CACHE["string"]))
logger.debug("Alias regex cache: %s" %
repr(self.ALIAS_CACHE["regex"]))
# Try first all string alias:
try:
return self.ALIAS_CACHE["string"][current_host]
except KeyError:
logger.debug("No site found in string cache for %r" % current_host)
# Try all regex alias:
for regex, site in self.ALIAS_CACHE["regex"]:
match = regex.search(current_host)
if match is not None:
return site
logger.debug("No site found in regex cache for %r" % current_host)
raise self.model.DoesNotExist("No alias found for %r" % current_host)
def clear_cache(self):
if self.ALIAS_CACHE is not None:
logger.debug("Clear SiteAlias cache")
self.ALIAS_CACHE.clear()
logger.debug("Clear DynamicSiteMiddlewareCache cache")
sites_models.SITE_CACHE.clear()
class SiteAliasManager(models.Manager):
ALIAS_CACHE = None
def get_from_host(self, current_host):
if self.ALIAS_CACHE is None:
# first request after startup / model.save() -> fill the cache
logger.debug("init LocalSyncCache for SiteAlias cache")
self.ALIAS_CACHE = LocalSyncCache(id="SiteAliasCache")
if "string" not in self.ALIAS_CACHE:
logger.debug("Fill SiteAlias cache")
self.ALIAS_CACHE["string"] = {}
self.ALIAS_CACHE["regex"] = []
queryset = self.all()
for site_alias in queryset:
site = site_alias.site
alias = site_alias.alias
if site_alias.regex:
regex = compile_alias(alias)
self.ALIAS_CACHE["regex"].append((regex, site))
else:
self.ALIAS_CACHE["string"][alias.lower()] = site
self.ALIAS_CACHE["regex"] = tuple(self.ALIAS_CACHE["regex"])
logger.debug("Alias string cache: %s" % repr(self.ALIAS_CACHE["string"]))
logger.debug("Alias regex cache: %s" % repr(self.ALIAS_CACHE["regex"]))
# Try first all string alias:
try:
return self.ALIAS_CACHE["string"][current_host]
except KeyError:
logger.debug("No site found in string cache for %r" % current_host)
# Try all regex alias:
for regex, site in self.ALIAS_CACHE["regex"]:
match = regex.search(current_host)
if match is not None:
return site
logger.debug("No site found in regex cache for %r" % current_host)
raise self.model.DoesNotExist("No alias found for %r" % current_host)
def clear_cache(self):
if self.ALIAS_CACHE is not None:
logger.debug("Clear SiteAlias cache")
self.ALIAS_CACHE.clear()
logger.debug("Clear DynamicSiteMiddlewareCache cache")
sites_models.SITE_CACHE.clear()
def testLocalSyncCacheMiddleware(self):
middleware = LocalSyncCacheMiddleware()
c1 = LocalSyncCache(id="testLocalSyncCacheMiddleware1")
c2 = LocalSyncCache(id="testLocalSyncCacheMiddleware1",
unique_ids=False)
c3 = LocalSyncCache(id="testLocalSyncCacheMiddleware2")
assert_pformat_equal(len(LocalSyncCache.CACHES), 3)
c1["c1"] = "foo"
c2["c2"] = "bar"
c3["foo"] = "bar"
middleware.process_request(None)
assert_pformat_equal(c1, {"c1": "foo"})
assert_pformat_equal(c2, {"c2": "bar"})
assert_pformat_equal(c3, {"foo": "bar"})
c1.clear()
assert_pformat_equal(c1, {})
# In a "new request" all the same caches should be cleared
middleware.process_request(None)
assert_pformat_equal(c2, {})
# Other caches should be not affected by clear()
assert_pformat_equal(c3, {"foo": "bar"})
c1["c1"] = "foo2"
c2["c2"] = "bar2"
middleware.process_request(None)
assert_pformat_equal(c1, {"c1": "foo2"})
assert_pformat_equal(c2, {"c2": "bar2"})
assert_pformat_equal(c3, {"foo": "bar"})
c2.clear()
assert_pformat_equal(c2, {})
# In a "new request" all the same caches should be cleared
middleware.process_request(None)
assert_pformat_equal(c1, {})
# print LocalSyncCache.pformat_cache_information()
cache_information = LocalSyncCache.get_cache_information()
assert_pformat_equal(len(cache_information), 3)
for item in cache_information:
instance = item["instance"]
assert_pformat_equal(instance.request_counter, 4)
if instance.id == "testLocalSyncCacheMiddleware2":
assert_pformat_equal(instance.own_clear_counter, 0)
assert_pformat_equal(instance.ext_clear_counter, 0)
assert_pformat_equal(instance, {"foo": "bar"})
else:
assert_pformat_equal(instance.own_clear_counter, 1)
assert_pformat_equal(instance.ext_clear_counter, 1)
assert_pformat_equal(instance, {})
def testLocalSyncCacheMiddleware(self):
middleware = LocalSyncCacheMiddleware()
c1 = LocalSyncCache(id="testLocalSyncCacheMiddleware1")
c2 = LocalSyncCache(id="testLocalSyncCacheMiddleware1", unique_ids=False)
c3 = LocalSyncCache(id="testLocalSyncCacheMiddleware2")
self.assertEqual(len(LocalSyncCache.CACHES), 3)
c1["c1"] = "foo"
c2["c2"] = "bar"
c3["foo"] = "bar"
middleware.process_request(None)
self.assertEqual(c1, {'c1': 'foo'})
self.assertEqual(c2, {'c2': 'bar'})
self.assertEqual(c3, {'foo': 'bar'})
c1.clear()
self.assertEqual(c1, {})
# In a "new request" all the same caches should be cleared
middleware.process_request(None)
self.assertEqual(c2, {})
# Other caches should be not affected by clear()
self.assertEqual(c3, {'foo': 'bar'})
c1["c1"] = "foo2"
c2["c2"] = "bar2"
middleware.process_request(None)
self.assertEqual(c1, {'c1': 'foo2'})
self.assertEqual(c2, {'c2': 'bar2'})
self.assertEqual(c3, {'foo': 'bar'})
c2.clear()
self.assertEqual(c2, {})
# In a "new request" all the same caches should be cleared
middleware.process_request(None)
self.assertEqual(c1, {})
# print LocalSyncCache.pformat_cache_information()
cache_information = LocalSyncCache.get_cache_information()
self.assertEqual(len(cache_information), 3)
for item in cache_information:
instance = item["instance"]
self.assertEqual(instance.request_counter, 4)
if instance.id == "testLocalSyncCacheMiddleware2":
self.assertEqual(instance.own_clear_counter, 0)
self.assertEqual(instance.ext_clear_counter, 0)
self.assertEqual(instance, {'foo': 'bar'})
else:
self.assertEqual(instance.own_clear_counter, 1)
self.assertEqual(instance.ext_clear_counter, 1)
self.assertEqual(instance, {})
