def rpush(self, key, value, **kwargs):
"""
push the data into list of redis at right of list
param;
key:string
value:string
**kwargs: a dict
obj:object
baseobj:base object
return:
True or False
"""
#Save
#print "listfield rpush ",key,",",value
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.rpush(key, value)
self.change_log("list:insert", kwargs["obj"].id, kwargs["baseobj"],
pipe)
pipe.execute()
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
def change_log(self,oper,obj_id,baseobj,pipe=None,score=None):
"""
save the relation of Reference
list|sortset:insert:user_posts:user_id:post_id
list|sortset:delete:user_posts:user_id:post_id
param:
oper: the operation type is string
obj_id: id of object type is integer
baseobj: base object
pipe: redis pipe default is None
score: use rank
"""
#是否启用数据同步
if not setting.DATA_SYNC:
return
#初始化服务
dp = pipe or RedisClient.getInstance().redis
#保存chang_log
#String = 操作符： 主类型_引用类型s : 主类型ID: 此类型ID
basetype = str(baseobj.__class__.__name__).lower()
ref = self.ref.lower()
if basetype == ref:
ref = self.name.lower()
if oper.startswith("sortset"):
val = "%(oper)s:_:%(model_type)s_%(relate_type)ss:_:%(id)s:_:%(rid)s:_:%(score)s" % {"oper":oper,"model_type": basetype,"relate_type": ref,"id":baseobj.id,"rid" : obj_id ,"score":score}
else:
val = "%(oper)s:_:%(model_type)s_%(relate_type)ss:_:%(id)s:_:%(rid)s" % {"oper":oper,"model_type": basetype,"relate_type": ref,"id":baseobj.id,"rid" : obj_id}
logger.info("sync: " + val)
#保存数据dao Redis List Queue
dp.lpush("change_log",val)
def lpush(self,key,value,**kwargs):
"""
LPUSH key value Append an element to the head of the List value at key
param;
key:string
value:string
**kwargs: a dict
obj:object
baseobj:base object
return:
True or False
"""
#print "listfield lpush ",key,",",value
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = RedisClient.getInstance().redis.pipeline()
pipe.lpush(key,value)
self.change_log("list:insert",kwargs["obj"].id,kwargs["baseobj"],pipe)
pipe.execute()
if setting.Debug:
logger.info(" lpush key: %s,use : %s" % (key,datetime.datetime.now() - n))
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def zadd(self,key ,member ,score,**kwargs):
"""
add the member into the sorted set by score
if the member is exist then update it's score
param:
key:string
member:string
score:rank integer
**kwargs:include obj and baseobj
obj:object
baseobj:base object
return:
True or False
"""
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.zadd(key ,member ,score)
self.change_log("sortset:insert",kwargs["obj"].id,kwargs["baseobj"],pipe,score)
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def lpush(self, key, value, **kwargs):
"""
LPUSH key value Append an element to the head of the List value at key
param;
key:string
value:string
**kwargs: a dict
obj:object
baseobj:base object
return:
True or False
"""
#print "listfield lpush ",key,",",value
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = RedisClient.getInstance().redis.pipeline()
pipe.lpush(key, value)
self.change_log("list:insert", kwargs["obj"].id, kwargs["baseobj"],
pipe)
pipe.execute()
if setting.Debug:
logger.info(" lpush key: %s,use : %s" %
(key, datetime.datetime.now() - n))
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
def __init__(self, model_class):
"""
initialize the model class and get the redis's db
param:
model_class: model
"""
self.model_class = model_class
self._db = RedisClient.getInstance().redis
def __init__(self, model_class):
"""
initialize the model class and get the redis's db
param:
model_class: model
"""
self.model_class = model_class
self._db = RedisClient.getInstance().redis
def scard(self,key,**kwargs):
"""
SCARD key Return the number of elements (the cardinality) of the Set at key
param:
key:string
**kwargs:dict
return:
count
"""
return RedisClient.getInstance().redis.scard(key)
def zcard(self, key,**kwargs ):
"""
get the base integer of sorted set
param:
key:string
**kwarg:dict
return:
count of list
"""
return RedisClient.getInstance().redis.zcard( key )
def sismember(self,key,member_id,**kwargs):
"""
SISMEMBER key member Test if the specified value is a member of the Set at key
param:
key:string
member_id:string
**kwargs:dict
return:
objects of list
"""
return RedisClient.getInstance().redis.sismember(key,member_id)
def zscore(self, key ,member_id,**kwargs):
"""
get the score of member
param:
key:string
member_id:integer
**kwargs:dict
return:
score
"""
return RedisClient.getInstance().redis.zscore( key ,member_id)
def delete(self, key, pipe, **kwargs):
"""
delete the list use index
param:
key: string
pipe: redis pipe
return:
True or false
"""
db = pipe | RedisClient.getInstance().redis
return db.delete(key)
def llen(self, key, **kwargs):
"""
LLEN key Return the length of the List value at key
param;
key:string
**kwargs: a dict
return:
integer of length
"""
#print "len key",key
return RedisClient.getInstance().redis.llen(key)
def llen(self,key,**kwargs):
"""
LLEN key Return the length of the List value at key
param;
key:string
**kwargs: a dict
return:
integer of length
"""
#print "len key",key
return RedisClient.getInstance().redis.llen(key)
def delete(self,key,pipe,**kwargs):
"""
delete the list use index
param:
key: string
pipe: redis pipe
return:
True or false
"""
db = pipe | RedisClient.getInstance().redis
return db.delete(key)
def llen(self,key,**kwargs):
"""
get the length of list
param:
key:string
**kwargs:dict
return:
length of list
"""
# LLEN key Return the length of the List value at key
#print "len key",key
return RedisClient.getInstance().redis.llen(key)
def zrevrank( self,key , member_id,**kwargs):
"""
get the the index of member in sorted set
in front is the highest score
param:
key:string
member_id:integer
**kwargs:dict
return:
integer
"""
return RedisClient.getInstance().redis.zrevrank( key ,member_id)
def delete(self,key,pipe,**kwargs):
"""
delete the value of key
param;
key:string
pipe:redis
**kwargs:dict
return:
True or False
"""
db = pipe | RedisClient.getInstance().redis
return db.delete(key)
def zrevrange(self, key ,start=0, end=10,select = None,**kwargs):
"""
get the the index of member in sorted set
in front is the lowest score highest in the back
param:
key:string
member_id:integer
**kwargs:dict
return:
integer
"""
pks = RedisClient.getInstance().redis.zrevrange( key ,start, end)
return self.ref_klass.objects.filter(id=tuple(pks),select=select)
def smembers(self,key,select=None,**kwargs):
"""
SMEMBERS key Return all the members of the Set value at key
param:
key:string
select:object default is None
**kwargs:dict
return:
objects of list
"""
n = datetime.datetime.now()
pks = RedisClient.getInstance().redis.smembers(key)
logger.info("smembers key: %s,select: %s,use: %s" % (key,select,datetime.datetime.now() - n))
return self.ref_klass.objects.filter(id = tuple(pks),select=select)
def spop(self,key,select=None,**kwargs):
"""
SPOP key Remove and return (pop) a random element from the Set value at key
param:
key:string
**kwargs:include obj
obj:the object
select:related object
return:
object
"""
pk = RedisClient.getInstance().redis.spop(key)
self.change_log("set:delete",pk,kwargs["obj"])
return self.ref_klass.objects.filter(id=pk,select=select)
def zrangebyscore(self, key ,min, max,select = None,**kwargs):
"""
get the the member in sorted set between min and max
param:
key:string
min:integer
max:integer
select:object default is None
**kwargs:dict
return:
members of list
"""
pks = RedisClient.getInstance().redis.zrangebyscore( key ,min, max)
return self.ref_klass.objects.filter(id=tuple(pks),select=select)
def zrange(self, key , start=0, end=10,select=None,**kwargs):
"""
get the the member in sorted set between start and end
in front is the lowest score
param:
key:string
start:integer
end:integer
select:object default is None
**kwargs:dict
return:
members of list
"""
pks = RedisClient.getInstance().redis.zrange( key ,start, end)
return self.ref_klass.objects.filter(id=tuple(pks),select=select)
def rpop(self,key,select=None,**kwargs):
"""
get the data into list of redis at right of list
param;
key:string
value:string
**kwargs: a dict
select:the default is None the related object
return:
object
"""
# RPOP key Return and remove (atomically) the first element of the List at key
#print "rpop key",key
pk = RedisClient.getInstance().redis.rpop(key)
self.change_log("list:delete",pk,kwargs["obj"])
return self.ref_klass.objects.filter(id=pk,select=select)
def lrange(self,key,start=0,end=10,select=None,**kwargs):
"""
get the date in the list
param:
key:string
start:integer default is 0
end:integer default is 10
select:default is None related object
**kwargs:dict
return:
the data in list
"""
# LRANGE key start end Return a range of elements from the List at key
n = datetime.datetime.now()
pks = RedisClient.getInstance().redis.lrange(key,start,end)
logger.info("lrange key: %s,start: %s, end: %s ,select:%s,use : %s" % (key,start,end,select,datetime.datetime.now() - n))
return self.ref_klass.objects.filter(id=tuple(pks),select=select)
def rpop(self,key,**kwargs):
"""
RPOP key Return and remove (atomically) the first element of the List at key
param;
key:string
**kwargs: a dict
obj:object
return:
object
"""
#print "rpop key",key
pk = RedisClient.getInstance().redis.rpop(key)
self.change_log("list:delete",pk,kwargs["obj"])
objs = self.ref_klass.objects.filter(id=pk)
if objs:
return objs[0]
return None
def rpop(self, key, **kwargs):
"""
RPOP key Return and remove (atomically) the first element of the List at key
param;
key:string
**kwargs: a dict
obj:object
return:
object
"""
#print "rpop key",key
pk = RedisClient.getInstance().redis.rpop(key)
self.change_log("list:delete", pk, kwargs["obj"])
objs = self.ref_klass.objects.filter(id=pk)
if objs:
return objs[0]
return None
class DSetField(DAttribute):
#常量定义
redis = RedisClient.getInstance().redis
def __init__(self, ref=None, required=False, name=None):
"""
initialize reference object name index and required
param:
ref:reference object
required:True or False
name:string
"""
super(DAttribute, self).__init__()
self.ref = ref
self.name = name
self.index = False
self.required = required
@operSet
def sadd(self, key, member, **kwargs):
"""
SADD key member Add the specified member to the Set value at key
param:
key:string
member:string
**kwargs:include obj and baseobj
obj:the object
baseobj: base object
return:
True or False
"""
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = DSetField.redis.pipeline()
pipe.sadd(key, member)
self.change_log("set:insert", kwargs["obj"].id, kwargs["baseobj"],
pipe)
pipe.execute()
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
def lrange(self,key,start=0,end=10,**kwargs):
"""
LRANGE key start end Return a range of elements from the List at key
param:
key:string
start:integer default is 0
end:integer default is 10
**kwargs:dict
return:
the data in list
"""
if setting.Debug:
n = datetime.datetime.now()
pks = RedisClient.getInstance().redis.lrange(key,start,end)
if setting.Debug:
logger.info("lrange key: %s,start: %s, end: %s ,use : %s" % (key,start,end,datetime.datetime.now() - n))
#返回相关对象集合
return find_include(self.ref_klass,pks,kwargs)
def zrem(self, key,member_id,**kwargs):
"""
delete the member in sorted set
param:
key:string
member_id:integer
**kwargs:dict
return:
True or False
"""
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.zrem( key,member_id)
self.change_log("sortset:delete",member,kwargs["baseobj"])
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def lrange(self, key, start=0, end=10, **kwargs):
"""
LRANGE key start end Return a range of elements from the List at key
param:
key:string
start:integer default is 0
end:integer default is 10
**kwargs:dict
return:
the data in list
"""
if setting.Debug:
n = datetime.datetime.now()
pks = RedisClient.getInstance().redis.lrange(key, start, end)
if setting.Debug:
logger.info("lrange key: %s,start: %s, end: %s ,use : %s" %
(key, start, end, datetime.datetime.now() - n))
#返回相关对象集合
return find_include(self.ref_klass, pks, kwargs)
def srem(self,key,member,**kwargs):
"""
SREM key member Remove the specified member from the Set value at key
param:
key:string
member:string
**kwargs:include baseobj
baseobj: base object
return:
True or False
"""
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.srem(key,member)
self.change_log("list:delete",member,kwargs["baseobj"])
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def rpush(self,key,value,**kwargs):
"""
push the data into list of redis at right of list
param;
key:string
value:string
**kwargs: a dict
return:
True or False
"""
#Save
#print "listfield rpush ",key,",",value
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.rpush(key,value)
self.change_log("list:insert",kwargs["obj"].id,kwargs["baseobj"],pipe)
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def lpush(self,key,value,**kwargs):
"""
push the data into list of redis at left of list
param;
key:string
value:string
**kwargs: a dict
return:
True or False
"""
#LPUSH key value Append an element to the head of the List value at key
#print "listfield lpush ",key,",",value
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.lpush(key,value)
self.change_log("list:insert",kwargs["obj"].id,kwargs["baseobj"],pipe)
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def lrem(self,key,id,count=0,**kwargs):
"""
LREM key count value Remove the first-N, last-N, or all the elements matching value from the List at key
param:
key:string
count:integer
**kwargs:dict
return:
True or False
"""
# LREM key count value Remove the first-N, last-N, or all the elements matching value from the List at key
#print "rem key",key
#print "rem value",id
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.lrem(key,id,count)
self.change_log("list:delete",id,kwargs["baseobj"])
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def sadd(self,key,member,**kwargs):
"""
SADD key member Add the specified member to the Set value at key
param:
key:string
member:string
**kwargs:include obj and baseobj
obj:the object
baseobj: base object
return:
True or False
"""
# SADD key member Add the specified member to the Set value at key
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.sadd(key,member)
self.change_log("set:insert",kwargs["obj"].id,kwargs["baseobj"],pipe)
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
class DSortSetField(DAttribute):
#常量定义
redis = RedisClient.getInstance().redis
def __init__(self,
ref=None,
required=False,
index=False,
name=None,
limit=500):
"""
initialize name index reference object limit
param:
ref:reference object
required:True or False
index:True or False
name:string default is None
limit:integer default is 1000
"""
super(DAttribute, self).__init__()
self.name = name
self.index = index
self.ref = ref
self.required = required
#限制最大幅度，设置为0为不限制
self.limit = limit
@operSet
def zadd(self, key, member, score, **kwargs):
"""
add the member into the sorted set by score
if the member is exist then update it's score
param:
key:string
member:string
score:rank integer
**kwargs:include obj and baseobj
obj:object
baseobj:base object
return:
True or False
"""
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = DSortSetField.redis.pipeline()
pipe.zadd(key, member, score)
self.change_log("sortset:insert", kwargs["obj"].id,
kwargs["baseobj"], pipe, score)
pipe.execute()
#Start 删除超过LIMIT的
if self.limit > 0:
zcard = DSortSetField.redis.zcard(key)
#print "zcard",zcard
if zcard > self.limit:
#print "* " * 20
#print "Start 删除超过LIMIT的"
#print "rem %s " % key
delete_to = zcard - self.limit
DSortSetField.redis.zremrangebyrank(key, 0, delete_to)
#End
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
