Esempio n. 1
0
class RedisClient():
    __r = None
    __type = None

    def handle(self):
        return self.__r

    def memused(self):
        if not self.__r:
            return None
        try:
            mem = []
            if self.__type == "TCP_SOCKET" or self.__type == "UNIX_DOMAIN":
                mem.append(self.__r.info()['used_memory'])
            elif self.__type == "REDIS_CLUSTER":
                for key, value in self.__r.info().iteritems():
                    mem.append(value['used_memory'])
            return sum(mem), mem
        except Exception as e:
            raise Exception("Error dumping memory info: " + str(e))

    def dbsize(self):
        if not self.__r:
            return None
        try:
            keys = []
            if self.__type == "TCP_SOCKET" or self.__type == "UNIX_DOMAIN":
                keys.append(self.__r.dbsize())
            elif self.__type == "REDIS_CLUSTER":
                keys = self.__r.dbsize().values()
            return sum(keys), keys
        except Exception as e:
            raise Exception("Error dumping index size: " + str(e))

    def __init__(self, cfg, kind=None, logger=None):
        try:
            self.__type = cfg.get("TYPE", "Redis")
            self.__db = cfg.get("DATABASE", 0)
            if not self.__type:
                self.__r = redis.StrictRedis(host='localhost',
                                             port=6379,
                                             db=self.__db)
                self.__type = 'TCP_SOCKET'

            if self.__type == "UNIX_DOMAIN":
                self.__r = redis.Redis(unix_socket_path='/tmp/redis.sock',
                                       db=self.__db)

            elif self.__type == "REDIS_CLUSTER":
                from rediscluster import StrictRedisCluster
                from ast import literal_eval
                if kind.upper() == "JAVA":
                    nodes = literal_eval(cfg.get("JAVA_NODES", "RedisCluster"))
                elif kind.upper() == "NATIVE":
                    nodes = literal_eval(
                        cfg.get("NATIVE_NODES", "RedisCluster"))
                elif kind.upper() == "RESULT":
                    nodes = literal_eval(
                        cfg.get("RESULT_NODES", "RedisCluster"))
                else:
                    logger.error("Unknown kind of REDIS_CLUSTER: %s", kind)
                self.__r = StrictRedisCluster(startup_nodes=nodes,
                                              decode_responses=True)

            elif self.__type == "TCP_SOCKET":
                port = cfg.get("PORT", "Redis")
                host = cfg.get("HOST", "Redis")
                self.__r = redis.StrictRedis(host=host,
                                             port=port,
                                             db=self.__db)

            else:
                if logger:
                    logger.error("Invalid redis cfg type %s", self.__type)
                print("Invalid redis cfg type %s" % (self.__type))
                return None

            # check if Redis server is available
            response = self.__r.client_list()

        except (redis.exceptions.ConnectionError,
                redis.exceptions.BusyLoadingError):
            if logger:
                logger.error("Redis connection error")
            print("Redis connection error")
            return None

        except ImportError as e:
            if logger:
                logger.error("Redis module not available. Please install.")
            print("Redis module not available. Please install.")
            return None
    rs = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)

    logging.basicConfig(format='%(asctime)s: %(levelname)s: %(message)s', level=logging.DEBUG)

    if len(sys.argv) < 3:
        logging.error("Invalid number of arguments.")
        logging.info("Usage: ./redis-app-benchmark.py <batch_size> <num_processes>")
        exit(1)

    batch_size = int(sys.argv[1])
    num_processes = int(sys.argv[2])

    for k in range(batch_size * num_processes): keys.append(uuid.uuid4())

    try:
        response = rs.client_list()
        for r in response :
            logging.info('Client: ' + r)
    except redis.ConnectionError, e:
        # if you end up here, redis instance is down
        logging.error('connection error: ' + str(e))
        exit(1)

    rs.flushdb()

    print_cluster_info(rs)
    print_dbsize(rs)

    do_set(rs, batch_size, num_processes)
    
    print_dbsize(rs)
Esempio n. 3
0
class RedisClient(object):
    __r = None
    __type = None
    __specified = False
    __port = 6379
    __host = 'localhost'

    def specified(self):
        return self.__specified

    def handle(self):
        return self.__r

    def pipeline(self, transaction=False):
        return self.__r.pipeline(transaction=transaction)

    def memused(self):
        if not self.__r:
            return None
        try:
            mem = []
            if self.__type == "TCP_SOCKET" or self.__type == "UNIX_DOMAIN":
                mem.append(self.__r.info()['used_memory'])
            elif self.__type == "REDIS_CLUSTER":
                for key, value in self.__r.info().iteritems():
                    mem.append(value['used_memory'])
            return sum(mem), mem
        except Exception as e:
            raise Exception("Error dumping memory info: " + str(e))

    def dbsize(self):
        if not self.__r:
            return None
        try:
            keys = []
            if self.__type == "TCP_SOCKET" or self.__type == "UNIX_DOMAIN":
                keys.append(self.__r.dbsize())
            elif self.__type == "REDIS_CLUSTER":
                keys = self.__r.dbsize().values()
            return sum(keys), keys
        except Exception as e:
            raise Exception("Error dumping index size: " + str(e))

    def flush(self):
        try:
            if self.__r:
                self.__r.flushall()
                self.__r.flushdb()
        except Exception as e:
            raise Exception("Error flushing: " + str(e))

    def __init__(self, cfg, kind=None, logger=None, readonly=False):
        try:
            self.__type = cfg.get("TYPE", "Redis")
            self.__db = cfg.get("DATABASE", 0)
            if not self.__type:
                self.__specified = True
                self.__r = redis.StrictRedis(host=self.__host,
                                             port=self.__port,
                                             db=self.__db)
                self.__type = 'TCP_SOCKET'

            if self.__type == "UNIX_DOMAIN":
                self.__specified = True
                self.__r = redis.Redis(unix_socket_path='/tmp/redis.sock',
                                       db=self.__db)

            elif self.__type == "REDIS_CLUSTER":
                from rediscluster import StrictRedisCluster
                from ast import literal_eval
                nodes = None
                if kind.upper() == "JAVA":
                    val = cfg.get("JAVA_NODES", "RedisCluster")
                    if val:
                        nodes = literal_eval(val)
                elif kind.upper() == "NATIVE":
                    val = cfg.get("NATIVE_NODES", "RedisCluster")
                    if val:
                        nodes = literal_eval(val)
                elif kind.upper() == "JAVA_VERSION":
                    val = cfg.get("JAVA_VERSION_NODES", "RedisCluster")
                    if val:
                        nodes = literal_eval(val)
                elif kind.upper() == "NATIVE_VERSION":
                    val = cfg.get("NATIVE_VERSION_NODES", "RedisCluster")
                    if val:
                        nodes = literal_eval(val)
                elif kind.upper() == "RESULT":
                    val = cfg.get("RESULT_NODES", "RedisCluster")
                    if val:
                        nodes = literal_eval(val)
                else:
                    logger.error("Unknown kind of REDIS_CLUSTER: %s", kind)
                if nodes:
                    self.__specified = True
                    self.__r = StrictRedisCluster(startup_nodes=nodes,
                                                  decode_responses=True,
                                                  readonly_mode=readonly)
                else:
                    raise Exception("Redis kind %s not specified!" % kind)

            elif self.__type == "TCP_SOCKET":
                self.__host = cfg.get("HOST", "Redis")
                self.__port = cfg.get("PORT", "Redis")
                self.__specified = True
                self.__r = redis.StrictRedis(host=self.__host,
                                             port=self.__port,
                                             db=self.__db)

            else:
                if logger:
                    logger.error("Invalid redis cfg type %s", self.__type)
                print("Invalid redis cfg type %s" % self.__type)

            # check if Redis server is available
            response = self.__r.client_list()

        except (redis.exceptions.ConnectionError,
                redis.exceptions.BusyLoadingError):
            if logger:
                logger.error("Redis connection error")
            print("Redis connection error")

        except ImportError as ie:
            if logger:
                logger.error(
                    "Redis module not available. Please install. Error: %s",
                    str(ie))
            print("Redis module not available. Please install.")

        except Exception as e:
            if logger:
                logger.error("Error getting kind %s from config: %s!", kind,
                             str(e))
            print("Kind %s doesn't exist in config. Error %s." %
                  (kind, str(e)))