Exemplo n.º 1
0
    def set_amount(cls, r, amount):
        old_amount = int(r._name)
        if old_amount != amount:
            r._name = str(amount)
            r._commit()
            
        #update the cache for the amount = 0 and amount = None cases
        rel = cls.rels[(r._thing1.__class__, r._thing2.__class__)]
        for a in set((old_amount, amount, None)):
            # clear memoizing around this thing's author
            if not r._thing2._loaded: r._thing2._load()
            if hasattr(r._thing2, "author_id"):
                clear_memo('report._by_author', cls, r._thing2.author_id,
                           amount = a)

            for t in (r._thing1, r._thing2):
                thing_key = cls._cache_prefix(rel, t.__class__,
                                              amount = a) + str(t._id)
                v = cache.get(thing_key)
                if v is not None:
                    if a == old_amount and old_amount != amount and r._id in v:
                        v.remove(r._id)
                    elif r._id not in v:
                        v.append(r._id)
                    cache.set(thing_key, v)
Exemplo n.º 2
0
def password_email(user):
    key = passhash(random.randint(0, 1000), user.email)
    passlink = 'http://' + g.domain + '/resetpassword/' + key
    cache.set("reset_%s" %key, user._id, time=1800)
    simple_email(user.email, '*****@*****.**',
                 '%s password reset' % g.front_page_title,
                 PasswordReset(user=user, passlink=passlink).render(style='email'))
Exemplo n.º 3
0
def password_email(user):
    key = passhash(random.randint(0, 1000), user.email)
    passlink = 'http://' + c.domain + '/resetpassword/' + key
    cache.set("reset_%s" %key, user._id, time=1800)
    simple_email(user.email, '*****@*****.**',
                 'reddit.com password reset',
                 Password_Reset(user=user, passlink=passlink).render())
Exemplo n.º 4
0
        def new_fn(*a, **kw):

            #if the keyword param _update == True, the cache will be
            #overwritten no matter what
            update = kw.pop('_update', False)

            key = make_key(iden, *a, **kw)

            res = None if update else cache.get(key, stale=stale)

            if res is None:
                # not cached, we should calculate it.
                with make_lock('memoize_lock(%s)' % key):
                    # see if it was completed while we were waiting
                    # for the lock
                    stored = None if update else cache.get(key)
                    if stored is not None:
                        # it was calculated while we were waiting
                        res = stored
                    else:
                        # okay now go and actually calculate it
                        res = fn(*a, **kw)
                        if res is None:
                            res = NoneResult
                        cache.set(key, res, time = time)

            if res == NoneResult:
                res = None

            return res
Exemplo n.º 5
0
    def _commit(self, keys=None):
        if not self._created:
            self._create()

        if self._dirty:
            if keys:
                keys = tup(keys)
                to_set = dict((k, self._dirties[k])
                              for k in keys if self._dirties.has_key(k))
            else:
                to_set = self._dirties

            data_props = {}
            thing_props = {}
            for k, v in to_set.iteritems():
                if k.startswith('_'):
                    thing_props[k[1:]] = v
                else:
                    data_props[k] = v

            if data_props:
                self._set_data(self._type_id, self._id, **data_props)
            
            if thing_props:
                self._set_props(self._type_id, self._id, **thing_props)
            
            if keys:
                for k in keys:
                    if self._dirties.has_key(k):
                        del self._dirties[k]
            else:
                self._dirties.clear()

        # always set the cache
        cache.set(thing_prefix(self.__class__.__name__, self._id), self)
Exemplo n.º 6
0
def password_email(user):
    key = passhash(random.randint(0, 1000), user.email)
    passlink = 'http://' + g.domain + '/resetpassword/' + key
    cache.set("reset_%s" %key, user._id, time=1800)
    simple_email(user.email, '*****@*****.**',
                 'lesswrong.com password reset',
                 PasswordReset(user=user, passlink=passlink).render(style='email'))
Exemplo n.º 7
0
    def _incr(self, prop, amt = 1):

        if self._dirty:
            raise ValueError, "cannot incr dirty thing"

        prefix = thing_prefix(self.__class__.__name__)
        key =  prefix + prop + '_' + str(self._id)
        cache_val = old_val = cache.get(key)
        if old_val is None:
            old_val = getattr(self, prop)

        if self._defaults.has_key(prop) and self._defaults[prop] == old_val:
            #potential race condition if the same property gets incr'd
            #from default at the same time
            setattr(self, prop, old_val + amt)
            self._commit(prop)
        else:
            self.__setattr__(prop, old_val + amt, False)
            #db
            if prop.startswith('_'):
                tdb.incr_thing_prop(self._type_id, self._id, prop[1:], amt)
            else:
                self._incr_data(self._type_id, self._id, prop, amt)
            cache.set(prefix + str(self._id), self)
            
        #cache
        if cache_val:
            cache.incr(key, amt)
        else:
            cache.set(key, getattr(self, prop))
Exemplo n.º 8
0
def cached_query(query, sr):
    """Returns the results from running query. The results are cached and
    only recomputed after 'expire_delta'"""
    query._limit = 150
    query._write_cache = True
    iden = query._iden()

    read_cache = True
    #if query is in the cache, the expire flag is true, and the access
    #time is old, set read_cache = False
    if cache.get(iden) is not None:
        if cache.get(expire_key(sr)):
            access_time = cache.get(access_key(sr))
            if not access_time or datetime.now() > access_time + expire_delta:
                cache.delete(expire_key(sr))
                read_cache = False
    #if the query isn't in the cache, set read_cache to false so we
    #record the access time
    else:
        read_cache = False

    #set access time to the last time the query was actually run (now)
    if not read_cache:
        cache.set(access_key(sr), datetime.now())

    query._read_cache = read_cache
    res = list(query)

    return res
Exemplo n.º 9
0
Arquivo: thing.py Projeto: cmak/reddit
    def __iter__(self):
        used_cache = False

        if self._stats_collector:
            self._stats_collector.add(self)

        lst = None
        if self._read_cache:
            names = cache.get(self._iden())
            if names:
                lst = Thing._by_fullname(names, data = self._data, return_dict = False)

        if lst is None:
            #hit the db
            try:
                lst = self._cursor().fetchall()
            except NotFound:
                lst = ()
        else:
            used_cache = True

        if self._write_cache and not used_cache:
            names = tuple(i._fullname for i in lst)
            cache.set(self._iden(), names, self._cache_time)

        for i in lst:
            yield i
Exemplo n.º 10
0
        def new_fn(*a, **kw):

            #if the keyword param _update == True, the cache will be
            #overwritten no matter what
            update = False
            if kw.has_key('_update'):
                update = kw['_update']
                del kw['_update']

            key = make_key(iden, *a, **kw)

            res = None if update else cache.get(key)

            if res is None:
                # not cached, we should calculate it.
                with make_lock('memoize_lock(%s)' % key):
                    stored = None if update else cache.get(key)
                    if stored is None:
                        # okay now go and actually calculate it
                        res = fn(*a, **kw)
                        if res is None:
                            res = NoneResult
                        cache.set(key, res, time = time)
                    else:
                        # it was calculated while we were waiting on
                        # the lock
                        res = stored

            if res == NoneResult:
                res = None

            return res
Exemplo n.º 11
0
    def __iter__(self):
        used_cache = False

        def _retrieve():
            return self._cursor().fetchall()

        names = lst = []

        names = cache.get(self._iden()) if self._read_cache else None
        if names is None and not self._write_cache:
            # it wasn't in the cache, and we're not going to
            # replace it, so just hit the db
            lst = _retrieve()
        elif names is None and self._write_cache:
            # it's not in the cache, and we have the power to
            # update it, which we should do in a lock to prevent
            # concurrent requests for the same data
            with g.make_lock("thing_query", "lock_%s" % self._iden()):
                # see if it was set while we were waiting for our
                # lock
                names = cache.get(self._iden(), allow_local = False) \
                                  if self._read_cache else None
                if names is None:
                    lst = _retrieve()
                    cache.set(self._iden(),
                              [ x._fullname for x in lst ],
                              self._cache_time)

        if names and not lst:
            # we got our list of names from the cache, so we need to
            # turn them back into Things
            lst = Thing._by_fullname(names, data = self._data, return_dict = False)

        for item in lst:
            yield item
Exemplo n.º 12
0
def get_hot(sr):
    q = Link._query(Link.c.sr_id == sr._id,
                    sort = desc('_hot'),
                    write_cache = True,
                    limit = 150)

    iden = q._iden()

    read_cache = True
    #if query is in the cache, the expire flag is true, and the access
    #time is old, set read_cache = False
    if cache.get(iden) is not None:
        if cache.get(expire_key(sr)):
            access_time = cache.get(access_key(sr))
            if not access_time or datetime.now() > access_time + expire_delta:
                cache.delete(expire_key(sr))
                read_cache = False
    #if the query isn't in the cache, set read_cache to false so we
    #record the access time
    else:
        read_cache = False

    if not read_cache:
        cache.set(access_key(sr), datetime.now())
    
    q._read_cache = read_cache
    res = list(q)
    
    #set the #1 link so we can ignore it later. expire after TOP_CACHE
    #just in case something happens and that sr doesn't update
    if res:
        cache.set(top_key(sr), res[0]._fullname, TOP_CACHE)

    return res
Exemplo n.º 13
0
def get_image(iden):
    solution = cache.get(str(iden))
    if not solution:
        solution = make_solution()
        cache.set(str(iden), solution, time = 300)
    r = RandCaptcha(solution=solution)
    return r.render()
Exemplo n.º 14
0
def password_email(user):
    key = passhash(random.randint(0, 1000), user.email)
    passlink = 'http://' + g.domain + '/resetpassword/' + key
    print "Generated password reset link: " + passlink
    cache.set("reset_%s" %key, user._id, time=1800)
    simple_email(user.email, '*****@*****.**',
                 'reddit.com password reset',
                 PasswordReset(user=user, passlink=passlink).render(style='email'))
Exemplo n.º 15
0
 def _commit(self):
     DataThing._commit(self)
     #if i denormalized i need to check here
     if denorm1: self._thing1._commit(denorm1[0])
     if denorm2: self._thing2._commit(denorm2[0])
     #set fast query cache
     cache.set(thing_prefix(self.__class__.__name__)
               + str((self._thing1_id, self._thing2_id, self._name)),
               self._id)
Exemplo n.º 16
0
def password_email(user):
    key = passhash(random.randint(0, 1000), user.email)
    passlink = "http://" + g.domain + "/resetpassword/" + key
    cache.set("reset_%s" % key, user._id, time=1800)
    simple_email(
        user.email,
        "*****@*****.**",
        "%s password reset" % g.front_page_title,
        PasswordReset(user=user, passlink=passlink).render(style="email"),
    )
Exemplo n.º 17
0
Arquivo: thing.py Projeto: cmak/reddit
 def _delete(self):
     tdb.del_rel(self._type_id, self._id)
     
     #clear cache
     prefix = thing_prefix(self.__class__.__name__)
     #TODO - there should be just one cache key for a rel?
     cache.delete(prefix + str(self._id))
     #update fast query cache
     cache.set(prefix + str((self._thing1_id,
                             self._thing2_id,
                             self._name)), None)
Exemplo n.º 18
0
def valid_solution(iden, solution):
    if (not iden
        or not solution
        or len(iden) != IDEN_LENGTH
        or len(solution) != SOL_LENGTH
        or solution.upper() != cache.get(str(iden))): 
        solution = make_solution()
        cache.set(str(iden), solution, time = 300)
        return False
    else:
        cache.delete(str(iden))
        return True
Exemplo n.º 19
0
        def _delete(self):
            tdb.del_rel(self._type_id, self._id)

            # clear cache
            prefix = thing_prefix(self.__class__.__name__)
            # TODO - there should be just one cache key for a rel?
            cache.delete(prefix + str(self._id))
            # update fast query cache
            cache.set(prefix + str((self._thing1_id, self._thing2_id, self._name)), None)
            # temporarily set this property so the rest of this request
            # know it's deleted. save -> unsave, hide -> unhide
            self._name = "un" + self._name
Exemplo n.º 20
0
 def new_fn(*a, **kw):
     key = iden + str(a) + str(kw)
     #print 'CHECKING', key
     res = cache.get(key)
     if res is None:
         res = fn(*a, **kw)
         if res is None:
             res = NoneResult
         cache.set(key, res, time = time)
     if res == NoneResult:
         res = None
     return res
Exemplo n.º 21
0
        def new_fn(*a, **kw):
            from r2.config import cache

            key = iden + hash(*a, **kw)
            # print 'CHECKING', key
            res = cache.get(key)
            if res is None:
                res = fn(*a, **kw)
                if res is None:
                    res = NoneResult
                cache.set(key, res, time=time)
            if res == NoneResult:
                res = None
            return res
Exemplo n.º 22
0
    def incr_descendant_karma(self, comments, amount):
        old_val = getattr(self, '_descendant_karma')

        comments.append(self._id)

        if hasattr(self, 'parent_id') and self.parent_id:
            Comment._byID(self.parent_id).incr_descendant_karma(comments, amount)
        else:
            from r2.lib.db import tdb_sql as tdb
            tdb.incr_things_prop(self._type_id, comments, 'descendant_karma', amount)

        self.__setattr__('_descendant_karma', old_val + amount, False)

        prefix = self.__class__.__name__ + '_'
        cache.set(prefix + str(self._id), self)
Exemplo n.º 23
0
        def new_fn(*a, **kw):

            #if the keyword param _update == True, the cache will be
            #overwritten no matter what
            update = False
            if kw.has_key('_update'):
                update = kw['_update']
                del kw['_update']

            key = _make_key(iden, a, kw)
            #print 'CHECKING', key

            res = None if update else cache.get(key)

            if res is None:
                res = fn(*a, **kw)
                if res is None:
                    res = NoneResult
                cache.set(key, res, time = time)
            if res == NoneResult:
                res = None
            return res
Exemplo n.º 24
0
    def __iter__(self):
        used_cache = False

        if self._stats_collector:
            self._stats_collector.add(self)

        def _retrieve():
            return self._cursor().fetchall()

        names = lst = []

        names = cache.get(self._iden()) if self._read_cache else None
        if names is None and not self._write_cache:
            # it wasn't in the cache, and we're not going to
            # replace it, so just hit the db
            lst = _retrieve()
        elif names is None and self._write_cache:
            # it's not in the cache, and we have the power to
            # update it, which we should do in a lock to prevent
            # concurrent requests for the same data
            with g.make_lock("lock_%s" % self._iden()):
                # see if it was set while we were waiting for our
                # lock
                names = cache.get(self._iden(), allow_local = False) \
                                  if self._read_cache else None
                if names is None:
                    lst = _retrieve()
                    cache.set(self._iden(),
                              [ x._fullname for x in lst ],
                              self._cache_time)

        if names and not lst:
            # we got our list of names from the cache, so we need to
            # turn them back into Things
            lst = Thing._by_fullname(names, data = self._data, return_dict = False)

        for item in lst:
            yield item
Exemplo n.º 25
0
    def __iter__(self):
        used_cache = False

        if self._stats_collector:
            self._stats_collector.add(self)

        lst = None
        if self._read_cache:
            names = cache.get(self._iden())
            if names is not None:
                lst = Thing._by_fullname(names, data = self._data, return_dict = False)

        if lst is None:
            #hit the db
            lst = self._cursor().fetchall()
        else:
            used_cache = True

        if self._write_cache and not used_cache:
            names = tuple(i._fullname for i in lst)
            cache.set(self._iden(), names, self._cache_time)

        for i in lst:
            yield i
Exemplo n.º 26
0
 def _cache_myself(self):
     cache.set(self._cache_key(), self)
Exemplo n.º 27
0
 def _cache_myself(self):
     ck = self._cache_key()
     cache.set(ck, self)
Exemplo n.º 28
0
 def _cache_myself(self):
     ck = self._cache_key()
     if self.__class__.__name__ in ("Link", "Comment", "Subreddit") and not self._t:
         log_text ("{} cache", "About to cache {} for %r" % ck, "warning")
     cache.set(ck, self)
Exemplo n.º 29
0
 def _cache_myself(self):
     ck = self._cache_key()
     if self.__class__.__name__ in ("Link", "Comment", "Subreddit") and not self._t and not self._deleted:
         raise ValueError("Refusing to cache {} for %r" % ck)
     cache.set(ck, self)
Exemplo n.º 30
0
def expire_hot(sr):
    """Called when a subreddit should be recomputed: after a vote (hence,
    submit) or deletion."""
    cache.set(expire_key(sr), True)
Exemplo n.º 31
0
 def _cache_myself(self):
     cache.set(self._cache_key(), self)
Exemplo n.º 32
0
def expire_hot(sr):
    cache.set(expire_key(sr), True)