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')
