Пример #1
0
class Clear(object):
    def __init__(self, id):
        self.check_param()

        self.mapId_list = []
        self.setId_list = []

        for param in FLUSH_MAP_ID:
            self.mapId_list.append(param + id)

        for param in FLUSH_SET_ID:
            self.setId_list.append(param + id)

        self.ssdb = SSDB(host=SOURCE_IP, port=SOURCE_PORT)

    def check_param(self):
        if CHARACTER_SET == "" or SOURCE_IP == "" or SOURCE_PORT == "":
            print("Check Clear Parameters!")
            sys.exit()

        for param in FLUSH_MAP_ID:
            if param == "":
                print("Check Clear Parameters!")

        for param in FLUSH_SET_ID:
            if param == "":
                print("Check Clear Parameters!")

    def show_config(self):
        print("")
        print("SOURCE_IP = %s" % SOURCE_IP)
        print("SOURCE_PORT = %s" % SOURCE_PORT)
        print("")

        index = 1
        for param in self.mapId_list:
            print("mapId%s = %s,Size = %s" %
                  (index, param, self.ssdb.hsize(param)))
            index = index + 1
        print("")

        index = 1
        for param in self.setId_list:
            print("setId%s = %s,Size = %s" %
                  (index, param, self.ssdb.zsize(param)))
            index = index + 1
        print("")

    def clear_data(self):

        for param in self.mapId_list:
            self.ssdb.hclear(param)
            print("Clear %s Success!" % (param))

        for param in self.setId_list:
            self.ssdb.zclear(param)
            print("Clear %s Success!" % (param))

        print("Clear SSDB Success!")
Пример #2
0
def processSet(arg):
    keyList = arg[0]
    redisHost = arg[1]
    redisPort = arg[2]
    ssdbHost = arg[3]
    ssdbPort = arg[4]

    if len(keyList) == 0:
        return
    try:
        #get data from redis
        data = {}
        r = redis.Redis(host=redisHost, port=redisPort)
        pipeRedis = r.pipeline()
        #get keys
        for item in keyList:
            pipeRedis.smembers(item)
        retList = pipeRedis.execute()
        #print retList
        for i in range(len(retList)):
            if len(retList[i]) > 0:
                data[keyList[i]] = {}
                for item in retList[i]:
                    data[keyList[i]][item] = 0
        #put keys
        print "get redis data size: %d" % (len(data))
        #print data
        #put data to ssdb
        s = SSDB(SSDB_HOST, SSDB_PORT)
        for key in data:
            s.zclear(key)
            s.multi_zset(key, **data[key])
            print "zadd key: %s" % (key)

        #set expire
        setExpire(keyList, "sortedset", EX_TIME)
    except Exception, e:
        print e.message
Пример #3
0
class SSDBZset(object, SSDBBase):
    def __init__(self,
                 zset_name,
                 host="127.0.0.1",
                 port=8888,
                 max_connections=10,
                 timeout=60):
        self.zset_name = zset_name
        self.host = host
        self.port = port
        self.max_connections = max_connections
        self.timeout = timeout
        pool = BlockingConnectionPool(connection_class=Connection,
                                      max_connections=max_connections,
                                      timeout=timeout,
                                      host=host,
                                      port=port)
        self.ssdb = SSDB(connection_pool=pool)
        SSDBBase.__init__(self, self.ssdb)

    def set(self, key, value, score):
        return self.ssdb.zset(self.zset_name, key, score)

    def get(self, key):
        return self.ssdb.zget(self.zset_name, key)

    def delete(self, key):
        return self.ssdb.zdel(self.zset_name, key)

    def keys(self, key_start="", score_start="", score_end="", limit=10):
        return self.ssdb.zkeys(self.zset_name, key_start, score_start,
                               score_end, limit)

    def exists(self, key):
        return self.ssdb.zexists(self.zset_name, key)

    def size(self):
        return self.ssdb.zsize(self.zset_name)

    def list(self, name_start="", name_end="", limit=10):
        #列出名字处于区间 (name_start, name_end] 的 hashmap
        return self.ssdb.zlist(name_start, name_end, limit)

    def clear(self):
        return self.ssdb.zclear(self.zset_name)