Annikka/evennia
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added at_idmapper_flush to allow objects more control of their flush characteristics.

Browse source
This commit is contained in:
Griatch 2016-10-02 19:14:22 +02:00
parent cd616caf29
commit 15025c0586
6 changed files with 74 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

20
evennia/objects/models.py
View file

@ -51,10 +51,10 @@ class ContentsHandler(object):
Re-initialize the content cache
"""
print "__init__", self.obj, calledby()
#print "__init__", self.obj, calledby()
self._pkcache.update(dict((obj.pk, None) for obj in
ObjectDB.objects.filter(db_location=self.obj) if obj.pk))
print "init contentscache: self._pkcache:", self.obj, self._pkcache
#print "init contentscache: self._pkcache:", self.obj, self._pkcache, id(self._pkcache), id(self)
def get(self, exclude=None):
"""
@ -70,15 +70,15 @@ class ContentsHandler(object):
if exclude:
pks = [pk for pk in self._pkcache if pk not in [excl.pk for excl in make_iter(exclude)]]
else:
print calledby()
print "get: self._pkcache", self.obj, self._pkcache
#print calledby()
#print "get: self._pkcache", self.obj, self._pkcache, id(self._pkcache), id(self)
pks = self._pkcache
try:
return [self._idcache[pk] for pk in pks]
except KeyError, err:
# this can happen if the idmapper cache was cleared for an object
# in the contents cache. If so we need to re-initialize and try again.
print "content_cache.get keyerror:", err, self._pkcache, self._idcache
#print "content_cache.get keyerror:", err, self._pkcache, self._idcache
self.init()
try:
return [self._idcache[pk] for pk in pks]
@ -96,7 +96,7 @@ class ContentsHandler(object):
"""
self._pkcache[obj.pk] = None
print "add self._pkcache:", self.obj, obj, obj.pk, self._pkcache
#print "add self._pkcache:", self.obj, obj, obj.pk, self._pkcache
def remove(self, obj):
"""
@ -107,7 +107,7 @@ class ContentsHandler(object):
"""
self._pkcache.pop(obj.pk, None)
print "remove self._pkcache", self.obj, obj, obj.pk, self._pkcache
#print "remove self._pkcache", self.obj, obj, obj.pk, self._pkcache
def clear(self):
"""
@ -116,7 +116,7 @@ class ContentsHandler(object):
"""
self._pkcache = {}
self.init()
print "clear _pkcache", self.obj, self._pkcache
#print "clear _pkcache", self.obj, self._pkcache
#------------------------------------------------------------
#
@ -272,12 +272,12 @@ class ObjectDB(TypedObject):
# remove the safe flag
del self._safe_contents_update
print "location_set:", self.key, old_location, self.db_location
#print "location_set:", self.key, old_location, self.db_location
# update the contents cache
if old_location:
old_location.contents_cache.remove(self)
if self.db_location:
print "cache add:", self.db_location, self
#print "cache add:", self.db_location, self
self.db_location.contents_cache.add(self)
except RuntimeError:

4
evennia/objects/objects.py
View file

@ -228,7 +228,7 @@ class DefaultObject(with_metaclass(TypeclassBase, ObjectDB)):
"""
con = self.contents_cache.get(exclude=exclude)
print "contents_get:", self, con, calledby()
#print "contents_get:", self, con, id(self), calledby()
return con
contents = property(contents_get)
@ -267,7 +267,6 @@ class DefaultObject(with_metaclass(TypeclassBase, ObjectDB)):
return "{}(#{})".format(self.name, self.id)
return self.name
def search(self, searchdata,
global_search=False,
use_nicks=True, # should this default to off?
@ -1134,7 +1133,6 @@ class DefaultObject(with_metaclass(TypeclassBase, ObjectDB)):
"""
pass
# hooks called when moving the object
def at_before_move(self, destination):

10
evennia/typeclasses/attributes.py
View file

@ -325,6 +325,14 @@ class AttributeHandler(object):
self._catcache.pop(catkey, None)
self._cache_complete = False
def reset_cache(self):
"""
Reset cache from the outside.
"""
self._cache_complete = False
self._cache = {}
self._catcache = {}
def has(self, key=None, category=None):
"""
Checks if the given Attribute (or list of Attributes) exists on
@ -910,7 +918,6 @@ class NAttributeHandler(object):
"""
self._store[key] = value
self.obj.set_recache_protection()
def remove(self, key):
"""
@ -922,7 +929,6 @@ class NAttributeHandler(object):
"""
if key in self._store:
del self._store[key]
self.obj.set_recache_protection(self._store)
def clear(self):
"""

21
evennia/typeclasses/models.py
View file

@ -376,6 +376,27 @@ class TypedObject(SharedMemoryModel):
raise Exception("dbref cannot be deleted!")
dbref = property(__dbref_get, __dbref_set, __dbref_del)
def at_idmapper_flush(self):
"""
This is called when the idmapper cache is flushed and
allows customized actions when this happens.
Returns:
do_flush (bool): If True, flush this object as normal. If
False, don't flush and expect this object to handle
the flushing on its own.
"""
if self.nattributes.all():
# we can't flush this object if we have non-persistent
# attributes stored - those would get lost! Nevertheless
# we try to flush as many references as we can.
self.attributes.reset_cache()
self.tags.reset_cache()
return False
# a normal flush
return True
#
# Object manipulation methods
#

7
evennia/typeclasses/tags.py
View file

@ -212,6 +212,13 @@ class TagHandler(object):
self._catcache.pop(catkey, None)
self._cache_complete = False
def reset_cache(self):
"""
Reset the cache from the outside.
"""
self._cache_complete = False
self._cache = {}
self._catcache = {}
def add(self, tag=None, category=None, data=None):
"""

45
evennia/utils/idmapper/models.py
View file

@ -79,7 +79,6 @@ class SharedMemoryModelBase(ModelBase):
# the dbmodel is either the proxy base or ourselves
dbmodel = cls._meta.proxy_for_model if cls._meta.proxy else cls
cls.__dbclass__ = dbmodel
dbmodel._idmapper_recache_protection = False
if not hasattr(dbmodel, "__instance_cache__"):
# we store __instance_cache__ only on the dbmodel base
dbmodel.__instance_cache__ = {}
@ -291,8 +290,10 @@ class SharedMemoryModel(with_metaclass(SharedMemoryModelBase, Model)):
"""
try:
if force or not cls._idmapper_recache_protection:
if force or cls.at_idmapper_flush():
del cls.__dbclass__.__instance_cache__[key]
else:
cls._dbclass__.__instance_cache__[key].refresh_from_db()
except KeyError:
pass
@ -319,27 +320,37 @@ class SharedMemoryModel(with_metaclass(SharedMemoryModelBase, Model)):
cls.__dbclass__.__instance_cache__ = {}
else:
cls.__dbclass__.__instance_cache__ = dict((key, obj) for key, obj in cls.__dbclass__.__instance_cache__.items()
if obj._idmapper_recache_protection)
if not obj.at_idmapper_flush())
for ins in cls.__dbclass__.__instance_cache__.itervalues():
ins.refresh_from_db()
#flush_instance_cache = classmethod(flush_instance_cache)
# per-instance methods
def at_idmapper_flush(self):
"""
This is called when the idmapper cache is flushed and
allows customized actions when this happens.
Returns:
do_flush (bool): If True, flush this object as normal. If
False, don't flush and expect this object to handle
the flushing on its own.
"""
return True
def flush_from_cache(self, force=False):
"""
Flush this instance from the instance cache. Use
`force` to override recache_protection for the object.
`force` to override the result of at_idmapper_flush() for the object.
"""
pk = self._get_pk_val()
if pk and (force or not self._idmapper_recache_protection):
self.__class__.__dbclass__.__instance_cache__.pop(pk, None)
def set_recache_protection(self, mode=True):
"""
Set if this instance should be allowed to be recached.
"""
self._idmapper_recache_protection = bool(mode)
if pk:
if force or self.at_idmapper_flush():
self.__class__.__dbclass__.__instance_cache__.pop(pk, None)
else:
self.refresh_from_db()
def delete(self, *args, **kwargs):
"""
@ -415,7 +426,6 @@ class WeakSharedMemoryModelBase(SharedMemoryModelBase):
def _prepare(cls):
super(WeakSharedMemoryModelBase, cls)._prepare()
cls.__dbclass__.__instance_cache__ = WeakValueDictionary()
cls._idmapper_recache_protection = False
class WeakSharedMemoryModel(with_metaclass(WeakSharedMemoryModelBase, SharedMemoryModel)):
@ -429,10 +439,9 @@ class WeakSharedMemoryModel(with_metaclass(WeakSharedMemoryModelBase, SharedMemo
def flush_cache(**kwargs):
"""
Flush idmapper cache. When doing so the cache will
look for a property `_idmapper_cache_flush_safe` on the
class/subclass instance and only flush if this
is `True`.
Flush idmapper cache. When doing so the cache will fire the
at_idmapper_flush hook to allow the object to optionally handle
its own flushing.
Uses a signal so we make sure to catch cascades.