def login_user(username): """Call this function after check_password passes. It generates an auth token that can be stored in a cookie to store a user session.""" token = generate_auth_token() user = get_user(username) user['auth'] = token get_redis().set("auth.%s" % token, str(get_numeric_user_id(username))) get_redis().expire("auth.%s" % token, resn_settings['Token Validity']) return token
def __init__(self, idx=None, **kwargs): if idx is None or str(idx) not in get_redis().smembers('%s__keys' % ( self.__class__.__redis_key__)): idx = str(get_redis().incr(self.__class__.__redis_key__)) get_redis().sadd('%s__keys' % self.__class__.__redis_key__, idx) self.idx = idx for k, v in kwargs.iteritems(): setattr(self, k, v)
def __setitem__(self, key, value): if type(value) == self.sub_type: self.__keys.add(key) self.__refs[key] = value redis_wrap.get_redis(self.system).incr('library:version', 1) pass else: raise ValueError('Value must be of type ' + str(self.sub_type)) pass
def fetch(self, prop, value): """Fetch an object with a prop equal value and return it, else return None""" lua = self.build_index.format(self.name, self.prefix, prop) target = '-'.join([self.name, 'index', prop]) redis_wrap.get_redis().eval(lua, 0, target) key = redis_wrap.get_redis().hget(target, value) if key is not None: return self[key] else: return None
def setup_module(module=None): get_redis().delete('bears') get_redis().delete('deers') get_redis().delete('villains') get_redis().delete('fishes') print sys._getframe(0).f_code.co_name, 'ok.'
def setup_module(module=None): get_redis().delete('bears') get_redis().delete('deers') get_redis().delete('villains') get_redis().delete('fishes') print(sys._getframe(0).f_code.co_name, 'ok.')
def validate_token(token): """ Validates the token stored in a cookie """ user_id = get_redis().get("auth.%s" % token) user = get_hash("users.%s" % user_id) if not len(user): return False return user['auth'] == token
def new_update(username, **update): """Creates a new update object and pushes the update to the feeds of the user's friends and followers.""" user = get_numeric_user_id(username) get_redis().incr("updates.counter") ctr = get_redis().get("updates.counter") upd = get_hash("updates." + ctr) upd['user'] = user for key in update: upd[key] = update[key] friends = get_redis().sunion("users.%s.friends" % user, "users.%s.followers" % user) for friend in friends: get_redis().lpush("users.%s.feed" % friend, ctr) get_redis().ltrim("users.%s.feed" % friend, 0, resn_settings['Feed Size']) get_redis().lpush("users.%s.updates" % user, ctr) #This is useful for maintaining a list of updates by a particular user
def create_user(id_attr, **kwargs): """ Creates a new user with attributes specified as keyword arguments 'id_attr' is the name of the attribute that will uniquely identify the user. """ get_redis().incr("users.counter") ctr = get_redis().get("users.counter") user = get_hash("users." + ctr) for key in kwargs: user[key] = kwargs[key] if id_attr not in kwargs: raise KeyError, "You did not specify any key '%s' in the call to this function." % id_attr else: get_redis().set("users.id.%s" % kwargs[id_attr], ctr) user['id'] = kwargs[id_attr]
def version(self): return redis_wrap.get_redis(self.system).get('library:version') or -1
def get_user_updates(username, limit = resn_settings['Feed Size']): """Returns a list of updates by the user. Useful for generating a user profile.""" user = get_numeric_user_id(username) return get_updates_from_list(get_redis().lrange("users.%s.updates" % user, 0, limit))
def get_feed(username, limit = resn_settings['Feed Size']): """Returns the feed containing updates by friends""" user = get_numeric_user_id(username) return get_updates_from_list(get_redis().lrange("users.%s.feed" % user, 0, limit))
def delete_update(update_id): """Deletes a particular update""" get_redis().delete("updates." + update_id)
def delete(self): redis_wrap.get_redis(self.system).delete(self.name) pass
def _deco(self, value): ret = fn(self, value) backref_key = gen_backref_key(self.__class__, name, value) get_redis().set(backref_key, self.idx) return ret
def get_numeric_user_id(username): return get_redis().get("users.id.%s" % username)
def __init__(self, name, system): self.name = name self.conn = get_redis(system)
def _getter(self): redis_key = gen_property_key(self.__class__, self.idx, key) val = get_redis().get(redis_key) if val: return _loads(val) return None
def load_by_key(cls, key): if cls._key_field: backref_key = gen_backref_key(cls, cls._key_field, key) idx = get_redis().get(backref_key,) return cls.load_by_idx(idx) raise AttributeError('key field has not given.')
def setUp(self): get_redis().delete(u'bears') get_redis().delete(u'villains') get_redis().delete(u'fishes')
def logout_user(username): """Clears the auth tokens.""" user = get_user(username) token = user['auth'] get_redis().delete("auth.%s" % token) del user['auth']
def __setitem__(self, key, value): redis_wrap.get_redis(self.system).incr('library:version', 1) super(APIObject, self).__setitem__(key, value) pass
def _setter(self, value): redis_key = gen_property_key(self.__class__, self.idx, key) get_redis().set(redis_key, _dumps(value))
import redis_wrap # redis_url = 'redis://*****:*****@jack.redistogo.com:9604/' redis_url = 'redis://127.0.0.1:6379/' redis_wrap.from_url(redis_url) redis_conn = redis_wrap.get_redis() left = redis_wrap.get_list('left') right = redis_wrap.get_list('right') color_mapping = redis_wrap.get_hash('color-mapping') vote_count = redis_wrap.get_hash('vote-count') state = redis_wrap.get_hash('state') # assorted vars such as current-position status_lock = redis_conn.lock('status-lock')
def delete_user(user): """ Deletes the user and removes all friendships """ friends = get_set("users.%s.friends" % user) for friend in friends: get_set("users.%s.friends" % friend).remove(user) get_redis().delete("users.%s" % user)
def setup_module(module=None): get_redis().delete('bears') get_redis().delete('villains') get_redis().delete('fishes')