redis连接池归还

Administrator

2023-08-04 a303ae5142442b3c4a50e1bc0816c4ed64625a78

redis连接池归还

 db/redis_manager.py

@@ -1,6 +1,8 @@
"""
redis管理器
"""
import time

import redis

import constant
@@ -19,7 +21,7 @@
        self.db = db

    def getRedis(self):
        return redis.Redis(connection_pool=self.pool)
        return redis.Redis(connection_pool=self.pool, timeout=config["timeout"])

    def getRedisNoPool(self):
        return redis.Redis(host=config["host"], port=config["port"], password=config["pwd"], db=self.db,
@@ -29,160 +31,179 @@
class RedisUtils:
    @classmethod
    def get(cls, redis_, key, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("get:{}", key)
            return redis_.get(key)
        finally:
            logger_redis_debug.info("get({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def scard(cls, redis_, key, auto_free=True):
        __start_time = time.time()
        try:
            return redis_.scard(key)
        finally:
            logger_redis_debug.info("scard({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def delete(cls, redis_, key, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("delete:{}", key)
            return redis_.delete(key)

        finally:
            logger_redis_debug.info("delete({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def keys(cls, redis_, key, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("keys:{}", key)
            return redis_.keys(key)
        finally:
            logger_redis_debug.info("keys({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def set(cls, redis_, key, val, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("set:{}", key)
            return redis_.set(key, val)
        finally:
            logger_redis_debug.info("set({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def setex(cls, redis_, key, expire, val, auto_free=True):
        logger_redis_debug.info("setex:{}", key)
        __start_time = time.time()
        try:
            return redis_.setex(key, expire, val)
        finally:
            logger_redis_debug.info("setex({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def setnx(cls, redis_, key, val, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("setnx:{}", key)
            return redis_.setnx(key, val)
        finally:
            logger_redis_debug.info("setnx({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def expire(cls, redis_, key, expire, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("expire:{}", key)
            return redis_.expire(key, expire)
        finally:
            logger_redis_debug.info("expire({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def sadd(cls, redis_, key, val, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("sadd:{}", key)
            return redis_.sadd(key, val)
        finally:
            logger_redis_debug.info("sadd({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def sismember(cls, redis_, key, val, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("sismember:{}", key)
            return redis_.sismember(key, val)
        finally:
            logger_redis_debug.info("sismember({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def smembers(cls, redis_, key, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("smembers:{}", key)
            return redis_.smembers(key)
        finally:
            logger_redis_debug.info("smembers({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def srem(cls, redis_, key, val, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("srem:{}", key)
            return redis_.srem(key, val)
        finally:
            logger_redis_debug.info("srem({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def incrby(cls, redis_, key, num, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("incrby:{}", key)
            return redis_.incrby(key, num)
        finally:
            logger_redis_debug.info("incrby({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def lpush(cls, redis_, key, val, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("lpush:{}", key)

            return redis_.lpush(key, val)
        finally:
            logger_redis_debug.info("lpush({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def lpop(cls, redis_, key, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("lpop:{}", key)

            return redis_.lpop(key)
        finally:
            logger_redis_debug.info("lpop({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass

    @classmethod
    def rpush(cls, redis_, key, val, auto_free=True):
        __start_time = time.time()
        try:
            logger_redis_debug.info("rpush:{}", key)

            return redis_.rpush(key, val)
        finally:
            logger_redis_debug.info("rpush({}):{}", round((time.time() - __start_time) * 1000, 3), key)
            if auto_free:
                # redis_.connection_pool.disconnect()
                pass