Python StrictRedis.echo方法代码示例

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import echo [as 别名]
    def test_connection_pool_with_default_settings(self) -> None:
        """
        Use the settings that are already validated via Smoke Test to check the Connection Pool creation

        Basically, this repeats the test from the Smoke Tests, but now using the RedisQueueConfiguration implementation
        """
        config = ConfigurationFileFinder().find_as_json()
        redis_config = config['tts']['queues']['test']
        redis_queue = RedisQueueConfiguration(redis_config)
        pool = redis_queue.create_redis_connection_pool()
        redis_connection = StrictRedis(connection_pool=pool)
        self.assertEqual(
            b'test',
            redis_connection.echo(b'test')
        )
        del redis_connection

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import echo [as 别名]
    expected_redis_keys = ["host", "port", "database"]
    missing_redis_keys = list()

    for expected_redis_key in expected_redis_keys:
        if expected_redis_key not in config["redis"]:
            missing_redis_keys.append(expected_redis_key)

    if len(missing_redis_keys):
        raise RequestsRespectfulConfigError(
            "'%s' %s missing from the 'redis' configuration key in 'requests-respectful.config.yml'" % (
                ", ".join(missing_redis_keys),
                "is" if len(missing_redis_keys) == 1 else "are"
            )
        )
except FileNotFoundError:
    config = default_config


# REDIS CLIENT
redis = StrictRedis(
    host=config["redis"]["host"],
    port=config["redis"]["port"],
    db=config["redis"]["database"]
)

try:
    redis.echo("Testing Connection")
except ConnectionError:
    raise RequestsRespectfulRedisError("Could not establish a connection to the provided Redis server")

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import echo [as 别名]
class RespectfulRequester:

    def __init__(self):
        self.redis = StrictRedis(
            host=config["redis"]["host"],
            port=config["redis"]["port"],
            password=config["redis"]["password"],
            db=config["redis"]["database"])

        try:
            self.redis.echo("Testing Connection")
        except ConnectionError:
            raise RequestsRespectfulRedisError("Could not establish a connection to the provided Redis server")

    def __getattr__(self, attr):
        if attr in ["delete", "get", "head", "options", "patch", "post", "put"]:
            return getattr(self, "_requests_proxy_%s" % attr)
        else:
            raise AttributeError()

    @property
    def redis_prefix(self):
        return "RespectfulRequester"

    def request(self, request_func, realms, wait=False):
        if not isinstance(realms, Sequence) or isinstance(realms, basestring):
            realms = [realms]

        for realm in realms:
            if realm not in self.fetch_registered_realms():
                raise RequestsRespectfulError("Realm '%s' hasn't been registered" % realm)

        if wait:
            while True:
                try:
                    return self._perform_request(request_func, realms)
                except RequestsRespectfulRateLimitedError:
                    pass

                time.sleep(1)
        else:
            return self._perform_request(request_func, realms)

    def fetch_registered_realms(self):
        return list(map(lambda k: k.decode("utf-8"), self.redis.smembers("%s:REALMS" % self.redis_prefix)))

    def register_realm(self, realm, max_requests, timespan):
        redis_key = self._realm_redis_key(realm)

        if not self.redis.hexists(redis_key, "max_requests"):
            self.redis.hmset(redis_key, {"max_requests": max_requests, "timespan": timespan})
            self.redis.sadd("%s:REALMS" % self.redis_prefix, realm)

        return True

    def update_realm(self, realm, **kwargs):
        redis_key = self._realm_redis_key(realm)
        updatable_keys = ["max_requests", "timespan"]

        for updatable_key in updatable_keys:
            if updatable_key in kwargs and type(kwargs[updatable_key]) == int:
                self.redis.hset(redis_key, updatable_key, kwargs[updatable_key])

        return True

    def unregister_realm(self, realm):
        self.redis.delete(self._realm_redis_key(realm))
        self.redis.srem("%s:REALMS" % self.redis_prefix, realm)

        request_keys = self.redis.keys("%s:REQUEST:%s:*" % (self.redis_prefix, realm))
        [self.redis.delete(k) for k in request_keys]

        return True

    def realm_max_requests(self, realm):
        realm_info = self._fetch_realm_info(realm)
        return int(realm_info["max_requests".encode("utf-8")].decode("utf-8"))

    def realm_timespan(self, realm):
        realm_info = self._fetch_realm_info(realm)
        return int(realm_info["timespan".encode("utf-8")].decode("utf-8"))

    @classmethod
    def configure(cls, **kwargs):
        if "redis" in kwargs:
            if type(kwargs["redis"]) != dict:
                raise RequestsRespectfulConfigError("'redis' key must be a dict")

            expected_redis_keys = ["host", "port", "password", "database"]
            missing_redis_keys = list()

            for expected_redis_key in expected_redis_keys:
                if expected_redis_key not in kwargs["redis"]:
                    missing_redis_keys.append(expected_redis_key)

            if len(missing_redis_keys):
                raise RequestsRespectfulConfigError("'%s' %s missing from the 'redis' configuration key" % (
                    ", ".join(missing_redis_keys),
                    "is" if len(missing_redis_keys) == 1 else "are"
                ))
#.........这里部分代码省略.........

# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import echo [as 别名]
class TestReads(TestCase):

    def setUp(self):
        from redis import StrictRedis as Redis

        self.redis = Redis(db=15)
        self.mockredis = MockRedis()
        self.logger = logging.getLogger("mockredis.TestReads")

    def tearDown(self):

        test_keys = self.redis.keys("MOCKREDIS*")
        if len(test_keys) > 0:
            self.redis.delete(*test_keys)
        self.mockredis.flushdb()

    def connections(self):
        self.assertEqual("testing_redis",
                         self.redis.echo("testing_redis"))
        self.assertEqual("testing_redis",
                         self.mockredis.echo("testing_redis"))

    def execute(self, method, params):
        '''
        Execute command on redis and mockredis
        '''

        getattr(self.redis, method)(*params)
        getattr(self.mockredis, method)(*params)

    def assert_execute(self, method, params):
        '''
        Assert that method response is the same
        for redis and mockredis
        '''

        self.logger.debug("method={method},params={params}"
                          .format(method=method, params=params))
        self.assertEqual(
            getattr(self.redis, method)(*params),
            getattr(self.mockredis, method)(*params),
            "testing {method}".format(method=method)
        )

    def write(self):
        '''
        successful writes for redis/mockredis (responses NOT compared)
        '''

        for method, details in redis_writes.items():
            for m, params in self.gather_params(method, details):
                self.execute(method, params)

    def test_reads(self):
        '''
        equality of responses for redis/mockredis
        '''

        self.write()

        for method, details in redis_reads.items():
            for m, params in self.gather_params(method, details):
                    self.assert_execute(method, params)

    def gather_params(self, method, details):
        for param in details["params"]:
            for use_key in details["keys"]:
                if "values" in details:
                    values = details["values"]
                else:
                    values = [""]
                for i in range(len(values)):
                    param = [p.format(key=key.format(test=use_key),
                                      attr=attr.format(test=use_key),
                                      value=values[i],
                                      index=i)
                             for p in param]

                    yield method, param

    def test_reads_clean(self):
        '''
        equality of responses on clean db for redis/mockredis
        '''

        for method, details in redis_reads.items():
            for m, params in self.gather_params(method, details):
                    self.assert_execute(method, params)