gistfile1.py

# -*- coding: utf-8 -*-
import redis
import ujson
from django.conf import settings 

class RedisMasterSlave():
    
    master_pool = redis.ConnectionPool(host=settings.REDIS.get('master').get('HOST'), 
                                       port=settings.REDIS.get('master').get('PORT'), 
                                       db='musica')
    
    slave_pool = redis.ConnectionPool(host=settings.REDIS.get('slave').get('HOST'), 
                                      port=settings.REDIS.get('slave').get('PORT'), 
                                      db='musica')
    
    def slave(self):
        return redis.Redis(connection_pool=self.__class__.slave_pool)
    
    def master(self):
        return redis.Redis(connection_pool=self.__class__.master_pool)
    
    #metodos do master
    def rpush(self,*args,**kwargs):
        self.master().rpush(*args,**kwargs)

    def lpop(self,*args,**kwargs):
        return self.master().lpop(*args,**kwargs)
    
    def set(self,*args,**kwargs):
        self.master().set(*args,**kwargs)
        
    def flushall(self):
        self.master().flushall()

    def delete(self,*args,**kwargs):
        return self.master().delete(*args,**kwargs)
    
    def sadd(self,*args,**kwargs):
        return self.master().sadd(*args,**kwargs)
    
    def srem(self,*args,**kwargs):
        return self.master().srem(*args,**kwargs)
    
    #metodos slave
    def get(self,*args,**kwargs):
        return self.slave().get(*args,**kwargs)
    
    def sismember(self,*args,**kwargs):
        return self.slave().sismember(*args,**kwargs)
    
    def sismembers(self,*args,**kwargs):
        return self.slave().sinter(*args,**kwargs)
    
    def sinter(self,*args,**kwargs):
        return self.slave().sinter(*args,**kwargs)
    
    def scard(self,*args,**kwargs):
        return self.slave().scard(*args,**kwargs)

class Redis(object):
    
    @classmethod
    def client(cls):
        return RedisMasterSlave()
    
class RedisSet(object):

    def __init__(self,key):
        self.key = key
        
    def add(self,*args):
        for value in args:
            Redis.client().sadd(self.key, value)

    def remove(self,value):
        return Redis.client().srem(self.key, value)

    def has(self,value):
        return Redis.client().sismember(self.key, value)
    
    def all(self):
        return Redis.client().sismembers(self.key)
    
    def count(self):
        return Redis.client().scard(self.key)
    
    def clear(self):
        return Redis.client().delete(self.key)
    
    def replace(self,*args):
        pipe = Redis.client().master().pipeline()
        pipe.delete(self.key)
        for value in args:
            pipe.sadd(self.key, value)
        pipe.execute()
    
class RedisQueue(object):
    
    def __init__(self,key):
        self.key = key

    def push(self,obj):
        value = ujson.encode(obj)
        Redis.client().rpush(self.key, value)
    
    def pop(self):
        value = Redis.client().lpop(self.key)
        return self.from_json(value)
    
    def from_json(self,json):
        if json:
            return ujson.decode(json)        
    
    def pops(self,size):
        pipe = Redis.client().master().pipeline()
        for i in range(size):
            pipe.lpop(self.key)
        return [ self.from_json(json) for json in pipe.execute() ]
        
class RedisQueueHash(RedisQueue):
    
    def push(self,**kwargs):
        super(RedisQueueHash,self).push(kwargs)