X-Git-Url: https://git.openstreetmap.org./osqa.git/blobdiff_plain/80e81e8ba3e132d6b51a0bb4c794d8f2c1f600d9..c8f355dd7205132ecd2c1bc27dc4e8944fdd6252:/forum/models/base.py?ds=inline diff --git a/forum/models/base.py b/forum/models/base.py index 627888f..2cfe7db 100644 --- a/forum/models/base.py +++ b/forum/models/base.py @@ -1,5 +1,9 @@ import datetime import re +try: + from hashlib import md5 +except: + from md5 import new as md5 from urllib import quote_plus, urlencode from django.db import models, IntegrityError, connection, transaction from django.utils.http import urlquote as django_urlquote @@ -12,72 +16,174 @@ from django.template.defaultfilters import slugify from django.db.models.signals import post_delete, post_save, pre_save, pre_delete from django.utils.translation import ugettext as _ from django.utils.safestring import mark_safe +from django.utils.encoding import force_unicode from django.contrib.sitemaps import ping_google import django.dispatch from forum import settings import logging +if not hasattr(cache, 'get_many'): + #put django 1.2 code here + pass + class LazyQueryList(object): def __init__(self, model, items): - self.model = model self.items = items + self.model = model def __getitem__(self, k): - return self.model.objects.get(id=self.items[k]) + return self.model.objects.get(id=self.items[k][0]) def __iter__(self): for id in self.items: - yield self.model.objects.get(id=id) + yield self.model.objects.get(id=id[0]) def __len__(self): return len(self.items) +class ToFetch(unicode): + pass + class CachedQuerySet(models.query.QuerySet): + def lazy(self): - if len(self.query.extra) == 0: - return LazyQueryList(self.model, list(self.values_list('id', flat=True))) + if not len(self.query.aggregates): + values_list = ['id'] + + if len(self.query.extra): + extra_keys = self.query.extra.keys() + values_list += extra_keys + + return LazyQueryList(self.model, list(self.values_list(*values_list))) else: return self -from action import Action + def obj_from_datadict(self, datadict): + obj = self.model() + obj.__dict__.update(datadict) -class CachedManager(models.Manager): - use_for_related_fields = True - int_cache_re = re.compile('^_[\w_]+cache$') + if hasattr(obj, '_state'): + obj._state.db = 'default' - def get_query_set(self): - return CachedQuerySet(self.model) - - def cache_obj(self, obj): - int_cache_keys = [k for k in obj.__dict__.keys() if self.int_cache_re.match(k)] - d = obj.__dict__ - for k in int_cache_keys: - if not isinstance(obj.__dict__[k], Action): - del obj.__dict__[k] + return obj - cache.set(self.model.cache_key(obj.id), obj, 60 * 60) + def _base_clone(self): + return self._clone(klass=models.query.QuerySet) def get(self, *args, **kwargs): - try: - pk = [v for (k,v) in kwargs.items() if k in ('pk', 'pk__exact', 'id', 'id__exact' - ) or k.endswith('_ptr__pk') or k.endswith('_ptr__id')][0] - except: - pk = None + key = self.model.infer_cache_key(kwargs) - if pk is not None: - key = self.model.cache_key(pk) + if key is not None: obj = cache.get(key) if obj is None: - obj = super(CachedManager, self).get(*args, **kwargs) - self.cache_obj(obj) + obj = self._base_clone().get(*args, **kwargs) + obj.cache() else: - d = obj.__dict__ + obj = self.obj_from_datadict(obj) + obj.reset_original_state() return obj - - return super(CachedManager, self).get(*args, **kwargs) + + return self._base_clone().get(*args, **kwargs) + + def _fetch_from_query_cache(self, key): + invalidation_key = self.model._get_cache_query_invalidation_key() + cached_result = cache.get_many([invalidation_key, key]) + + if not invalidation_key in cached_result: + self.model._set_query_cache_invalidation_timestamp() + return None + + if (key in cached_result) and(cached_result[invalidation_key] < cached_result[key][0]): + return cached_result[key][1] + + return None + + def count(self): + cache_key = self.model._generate_cache_key("CNT:%s" % self._get_query_hash()) + result = self._fetch_from_query_cache(cache_key) + + if result is not None: + return result + + result = super(CachedQuerySet, self).count() + cache.set(cache_key, (datetime.datetime.now(), result), 60 * 60) + return result + + def iterator(self): + cache_key = self.model._generate_cache_key("QUERY:%s" % self._get_query_hash()) + on_cache_query_attr = self.model.value_to_list_on_cache_query() + + to_return = None + to_cache = {} + + with_aggregates = len(self.query.aggregates) > 0 + key_list = self._fetch_from_query_cache(cache_key) + + if key_list is None: + if not with_aggregates: + values_list = [on_cache_query_attr] + + if len(self.query.extra): + values_list += self.query.extra.keys() + + key_list = [v[0] for v in self.values_list(*values_list)] + to_cache[cache_key] = (datetime.datetime.now(), key_list) + else: + to_return = list(super(CachedQuerySet, self).iterator()) + to_cache[cache_key] = (datetime.datetime.now(), [ + (row.__dict__[on_cache_query_attr], dict([(k, row.__dict__[k]) for k in self.query.aggregates.keys()])) + for row in to_return]) + elif with_aggregates: + tmp = key_list + key_list = [k[0] for k in tmp] + with_aggregates = [k[1] for k in tmp] + del tmp + + if (not to_return) and key_list: + row_keys = [self.model.infer_cache_key({on_cache_query_attr: attr}) for attr in key_list] + cached = cache.get_many(row_keys) + + to_return = [ + (ck in cached) and self.obj_from_datadict(cached[ck]) or ToFetch(force_unicode(key_list[i])) for i, ck in enumerate(row_keys) + ] + + if len(cached) != len(row_keys): + to_fetch = [unicode(tr) for tr in to_return if isinstance(tr, ToFetch)] + + fetched = dict([(force_unicode(r.__dict__[on_cache_query_attr]), r) for r in + models.query.QuerySet(self.model).filter(**{"%s__in" % on_cache_query_attr: to_fetch})]) + + to_return = [(isinstance(tr, ToFetch) and fetched[unicode(tr)] or tr) for tr in to_return] + to_cache.update(dict([(self.model.infer_cache_key({on_cache_query_attr: attr}), r._as_dict()) for attr, r in fetched.items()])) + + if with_aggregates: + for i, r in enumerate(to_return): + r.__dict__.update(with_aggregates[i]) + + + if len(to_cache): + cache.set_many(to_cache, 60 * 60) + + if to_return: + for row in to_return: + if hasattr(row, 'leaf'): + yield row.leaf + else: + yield row + + def _get_query_hash(self): + return md5(unicode(self.query).encode("utf-8")).hexdigest() + + + +class CachedManager(models.Manager): + use_for_related_fields = True + + def get_query_set(self): + return CachedQuerySet(self.model) def get_or_create(self, *args, **kwargs): try: @@ -87,26 +193,26 @@ class CachedManager(models.Manager): class DenormalizedField(object): - def __init__(self, manager, **kwargs): + def __init__(self, manager, *args, **kwargs): self.manager = manager - self.filter = kwargs + self.filter = (args, kwargs) def setup_class(self, cls, name): - dict_name = '_%s_cache_' % name + dict_name = '_%s_dencache_' % name def getter(inst): val = inst.__dict__.get(dict_name, None) if val is None: - val = getattr(inst, self.manager).filter(**self.filter).count() + val = getattr(inst, self.manager).filter(*self.filter[0], **self.filter[1]).count() inst.__dict__[dict_name] = val - inst.__class__.objects.cache_obj(inst) + inst.cache() return val def reset_cache(inst): inst.__dict__.pop(dict_name, None) - inst.__class__.objects.cache_obj(inst) + inst.uncache() cls.add_to_class(name, property(getter)) cls.add_to_class("reset_%s_cache" % name, reset_cache) @@ -141,20 +247,37 @@ class BaseModel(models.Model): def __init__(self, *args, **kwargs): super(BaseModel, self).__init__(*args, **kwargs) - self._original_state = dict([(k, v) for k,v in self.__dict__.items() if not k in kwargs]) + self.reset_original_state(kwargs.keys()) - @classmethod - def cache_key(cls, pk): - return '%s.%s:%s' % (settings.APP_URL, cls.__name__, pk) + def reset_original_state(self, reset_fields=None): + self._original_state = self._as_dict() + + if reset_fields: + self._original_state.update(dict([(f, None) for f in reset_fields])) def get_dirty_fields(self): - missing = object() - return dict([(k, self._original_state.get(k, None)) for k,v in self.__dict__.items() - if self._original_state.get(k, missing) == missing or self._original_state[k] != v]) + return [f.name for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname]] + + def _as_dict(self): + return dict([(name, getattr(self, name)) for name in + ([f.attname for f in self._meta.fields] + [k for k in self.__dict__.keys() if k.endswith('_dencache_')]) + ]) - def save(self, *args, **kwargs): + def _get_update_kwargs(self): + return dict([ + (f.name, getattr(self, f.name)) for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname] + ]) + + def save(self, full_save=False, *args, **kwargs): put_back = [k for k, v in self.__dict__.items() if isinstance(v, models.expressions.ExpressionNode)] - super(BaseModel, self).save() + + if hasattr(self, '_state'): + self._state.db = 'default' + + if self.id and not full_save: + self.__class__.objects.filter(id=self.id).update(**self._get_update_kwargs()) + else: + super(BaseModel, self).save() if put_back: try: @@ -165,115 +288,60 @@ class BaseModel(models.Model): logging.error("Unable to read %s from %s" % (", ".join(put_back), self.__class__.__name__)) self.uncache() - self._original_state = dict(self.__dict__) + self.reset_original_state() + self._set_query_cache_invalidation_timestamp() self.cache() - def cache(self): - self.__class__.objects.cache_obj(self) - - def uncache(self): - cache.delete(self.cache_key(self.pk)) - - def delete(self): - self.uncache() - super(BaseModel, self).delete() - - -class ActiveObjectManager(models.Manager): - use_for_related_fields = True - def get_query_set(self): - return super(ActiveObjectManager, self).get_query_set().filter(canceled=False) - -class UndeletedObjectManager(models.Manager): - def get_query_set(self): - return super(UndeletedObjectManager, self).get_query_set().filter(deleted=False) - -class GenericContent(models.Model): - content_type = models.ForeignKey(ContentType) - object_id = models.PositiveIntegerField() - content_object = generic.GenericForeignKey('content_type', 'object_id') - - class Meta: - abstract = True - app_label = 'forum' - -class MetaContent(BaseModel): - node = models.ForeignKey('Node', null=True, related_name='%(class)ss') - - def __init__(self, *args, **kwargs): - if 'content_object' in kwargs: - kwargs['node'] = kwargs['content_object'] - del kwargs['content_object'] - - super (MetaContent, self).__init__(*args, **kwargs) - - @property - def content_object(self): - return self.node.leaf - - class Meta: - abstract = True - app_label = 'forum' - -from user import User - -class UserContent(models.Model): - user = models.ForeignKey(User, related_name='%(class)ss') + @classmethod + def _get_cache_query_invalidation_key(cls): + return cls._generate_cache_key("INV_TS") - class Meta: - abstract = True - app_label = 'forum' + @classmethod + def _set_query_cache_invalidation_timestamp(cls): + cache.set(cls._get_cache_query_invalidation_key(), datetime.datetime.now(), 60 * 60 * 24) + for base in filter(lambda c: issubclass(c, BaseModel) and (not c is BaseModel), cls.__bases__): + base._set_query_cache_invalidation_timestamp() -class DeletableContent(models.Model): - deleted = models.BooleanField(default=False) - deleted_at = models.DateTimeField(null=True, blank=True) - deleted_by = models.ForeignKey(User, null=True, blank=True, related_name='deleted_%(class)ss') + @classmethod + def _generate_cache_key(cls, key, group=None): + if group is None: + group = cls.__name__ - active = UndeletedObjectManager() + return '%s:%s:%s' % (settings.APP_URL, group, key) - class Meta: - abstract = True - app_label = 'forum' + def cache_key(self): + return self._generate_cache_key(self.id) - def mark_deleted(self, user): - if not self.deleted: - self.deleted = True - self.deleted_at = datetime.datetime.now() - self.deleted_by = user - self.save() - return True - else: - return False + @classmethod + def value_to_list_on_cache_query(cls): + return 'id' - def unmark_deleted(self): - if self.deleted: - self.deleted = False - self.save() - return True - else: - return False + @classmethod + def infer_cache_key(cls, querydict): + try: + pk = [v for (k,v) in querydict.items() if k in ('pk', 'pk__exact', 'id', 'id__exact' + ) or k.endswith('_ptr__pk') or k.endswith('_ptr__id')][0] -mark_canceled = django.dispatch.Signal(providing_args=['instance']) + return cls._generate_cache_key(pk) + except: + return None -class CancelableContent(models.Model): - canceled = models.BooleanField(default=False) + def cache(self): + cache.set(self.cache_key(), self._as_dict(), 60 * 60) - def cancel(self): - if not self.canceled: - self.canceled = True - self.save() - mark_canceled.send(sender=self.__class__, instance=self) - return True - - return False + def uncache(self): + cache.delete(self.cache_key()) - class Meta: - abstract = True - app_label = 'forum' + def delete(self): + self.uncache() + self._set_query_cache_invalidation_timestamp() + super(BaseModel, self).delete() +from user import User from node import Node, NodeRevision, NodeManager +from action import Action