aioreis 之 BaseRedis

#!/usr/bin/env python
# -*- coding:utf-8 -*-from aioredis import create_redis_pool
import datetime
import time as mod_time
from redis.exceptions import (
    ConnectionError,
    DataError,
    ExecAbortError,
    NoScriptError,
    PubSubError,
    RedisError,
    ResponseError,
    TimeoutError,
    WatchError,
)
_NOTSET = 'UTF-8'

try:
    from sanic.log import logger
except ImportError:
    from sanic.log import log as logger


__version__ = '0.1.0'


class BaseRedis:
    __coll__ = None  # KeyGroup name
    __dbkey__ = None  # which database connected to?
    __unique_fields__ = []
    __motor_redis_client__ = None
    __motor_redis_db__ = None
    __motor_redis_clients__ = {}
    __motor_redis_dbs__ = {}
    __app__ = None
    __apps__ = {}
    __timezone__ = None

    def __init__(self, *args, **kwargs):
        self.__dict__.update(kwargs)

    @classmethod
    async def Execute(cls, command, *args, **kwargs):
        kwargs['encoding'] = kwargs.pop('encoding', _NOTSET)
        return await cls.__motor_redis_client__.execute(command, *args, **kwargs)

    @staticmethod
    def init_app(app, open_listener='before_server_start',
                 close_listener='before_server_stop', name=None, uri=None):
        BaseRedis.__app__ = app
        BaseRedis.__apps__[name or app.name] = app

        if open_listener:
            @app.listener(open_listener)
            async def open_connection(app, loop):
                await BaseRedis.default_open_connection(app, loop, name, uri)

        if close_listener:
            @app.listener(close_listener)
            async def close_connection(app, loop):
                await BaseRedis.default_close_connection(app, loop)

    @staticmethod
    async def default_open_connection(app, loop, name=None, *args, **kwargs):
        if not name:
            name = app.name
        db = kwargs.pop('db', None)
        logger.info('opening motor connection for redis [{}]'.format(name))
        client = await create_redis_pool((app.config.redishost, app.config.redisport), db=db or app.config.redisdb,password=app.config.redispwd, loop=loop)
        app.motor_redis_client = client
        BaseRedis.__motor_redis_client__ = client
        BaseRedis.__motor_redis_db__ = db
        if not hasattr(app, 'motor_redis_clients'):
            app.motor_redis_clients = {}

        app.motor_redis_clients[name] = client
        BaseRedis.__motor_redis_clients__[name] = client
        BaseRedis.__motor_redis_dbs__[name] = db

    @staticmethod
    async def default_close_connection(app, loop):
        if hasattr(app, 'motor_clients'):
            for name, client in app.motor_redis_clients.items():
                logger.info('closing motor redis connection for [{}]'.format(name))
                client.close()
                await client.wait_closed()

    @classmethod
    async def set_keys(cls,dict_obj=None,*args,**kwargs):
        for key,item in dict_obj.items():
            await cls.set(key,item)
        return True

    def __delitem__(self, key):
        self.delete(key)

    @classmethod
    async def delete(cls,*keys):
        keys = [cls.__coll__ + item for item in keys]
        return await cls.Execute('DEL', *keys)

    @classmethod
    async def exists(cls, name):
        "Returns a boolean indicating whether key ``name`` exists"
        key = cls.__coll__ + name
        return await cls.Execute('EXISTS', key)
    __contains__ = exists

    @classmethod
    async def expire(cls, name, time):
        """
        Set an expire flag on key ``name`` for ``time`` seconds. ``time``
        can be represented by an integer or a Python timedelta object.
        """
        name = cls.__coll__ + name
        if isinstance(time, datetime.timedelta):
            time = time.seconds + time.days * 24 * 3600
        return await cls.Execute('EXPIRE', name, time)

    @classmethod
    async def expireat(cls, name, when):
        """
        Set an expire flag on key ``name``. ``when`` can be represented
        as an integer indicating unix time or a Python datetime object.
        """
        name = cls.__coll__ + name
        if isinstance(when, datetime.datetime):
            when = int(mod_time.mktime(when.timetuple()))
        return await cls.Execute('EXPIREAT', name, when)

    @classmethod
    async def keys(cls, pattern='*'):
        "Returns a list of keys matching ``pattern``"
        return await cls.Execute('KEYS', *pattern,encoding='utf-8')

    # SERVER INFORMATION
    @classmethod
    async def bgrewriteaof(cls):
        "Tell the Redis server to rewrite the AOF file from data in memory."
        return cls.Execute('BGREWRITEAOF')

    @classmethod
    async def bgsave(cls):
        """
        Tell the Redis server to save its data to disk.  Unlike save(),
        this method is asynchronous and returns immediately.
        """
        return cls.Execute('BGSAVE')

    @classmethod
    async def client_kill(cls, address):
        "Disconnects the client at ``address`` (ip:port)"
        return cls.Execute('CLIENT KILL', address)

    @classmethod
    async def client_list(cls):
        "Returns a list of currently connected clients"
        return cls.Execute('CLIENT LIST')

    @classmethod
    async def client_getname(cls):
        "Returns the current connection name"
        return cls.Execute('CLIENT GETNAME')

    @classmethod
    async def client_setname(cls, name):
        "Sets the current connection name"
        return cls.Execute('CLIENT SETNAME', name)

    @classmethod
    async def config_get(cls, pattern="*"):
        "Return a dictionary of configuration based on the ``pattern``"
        return cls.Execute('CONFIG GET', *pattern,encoding='utf-8')

    @classmethod
    async def config_set(cls, name, value):
        "Set config item ``name`` with ``value``"
        return cls.Execute('CONFIG SET', name, value)

    @classmethod
    async def config_resetstat(self):
        "Reset runtime statistics"
        return self.Execute('CONFIG RESETSTAT')

    @classmethod
    async def config_rewrite(cls):
        "Rewrite config file with the minimal change to reflect running config"
        return await cls.Execute('CONFIG REWRITE')

    @classmethod
    async def dbsize(self):
        "Returns the number of keys in the current database"
        return self.Execute('DBSIZE')

    @classmethod
    async def debug_object(cls, key):
        "Returns version specific meta information about a given key"
        return await cls.Execute('DEBUG OBJECT', key)

    @classmethod
    async def echo(cls, value):
        "Echo the string back from the server"
        return await cls.Execute('ECHO', value)

    @classmethod
    async def flushall(cls):
        "Delete all keys in all databases on the current host"
        return await cls.Execute('FLUSHALL')


    @classmethod
    async def flushdb(cls):
        "Delete all keys in the current database"
        return await cls.Execute('FLUSHDB')

    @classmethod
    async def info(cls, section=None):
        """
        Returns a dictionary containing information about the Redis server

        The ``section`` option can be used to select a specific section
        of information

        The section option is not supported by older versions of Redis Server,
        and will generate ResponseError
        """
        if section is None:
            return await cls.Execute('INFO')
        else:
            return await cls.Execute('INFO', section)


    async def lastsave(self):
        """
        Return a Python datetime object representing the last time the
        Redis database was saved to disk
        """
        return await self.Execute('LASTSAVE')


    async def ping(self):
        "Ping the Redis server"
        return await self.Execute('PING')

    async def save(self):
        """
        Tell the Redis server to save its data to disk,
        blocking until the save is complete
        """
        return await self.Execute('SAVE')

    async def time(self):
        """
        Returns the server time as a 2-item tuple of ints:
        (seconds since epoch, microseconds into this second).
        """
        return await self.Execute('TIME')

    # BASIC KEY COMMANDS
    @classmethod
    async def append(cls, key, value):
        """
        Appends the string ``value`` to the value at ``key``. If ``key``
        doesn't already exist, create it with a value of ``value``.
        Returns the new length of the value at ``key``.
        """
        return await cls.Execute('APPEND', key, value)

    def bitcount(self, key, start=None, end=None):
        """
        Returns the count of set bits in the value of ``key``.  Optional
        ``start`` and ``end`` paramaters indicate which bytes to consider
        """
        params = [key]
        if start is not None and end is not None:
            params.append(start)
            params.append(end)
        elif (start is not None and end is None) or \
                (end is not None and start is None):
            raise RedisError("Both start and end must be specified")
        return self.Execute('BITCOUNT', *params)

    def bitop(self, operation, dest, *keys):
        """
        Perform a bitwise operation using ``operation`` between ``keys`` and
        store the result in ``dest``.
        """
        return self.Execute('BITOP', operation, dest, *keys)

    @classmethod
    async def bitpos(cls, key, bit, start=None, end=None):
        """
        Return the position of the first bit set to 1 or 0 in a string.
        ``start`` and ``end`` difines search range. The range is interpreted
        as a range of bytes and not a range of bits, so start=0 and end=2
        means to look at the first three bytes.
        """
        key = cls.__coll__ + key
        if bit not in (0, 1):
            raise RedisError('bit must be 0 or 1')
        params = [key, bit]

        start is not None and params.append(start)

        if start is not None and end is not None:
            params.append(end)
        elif start is None and end is not None:
            raise RedisError("start argument is not set, "
                             "when end is specified")

        return await cls.Execute('BITPOS', *params)

    @classmethod
    async def decr(cls, name, amount=1):
        """
        Decrements the value of ``key`` by ``amount``.  If no key exists,
        the value will be initialized as 0 - ``amount``
        """
        name = cls.__coll__ + name
        return await cls.Execute('DECRBY', name, amount)

    @classmethod
    async def dump(cls, name):
        """
        Return a serialized version of the value stored at the specified key.
        If key does not exist a nil bulk reply is returned.
        """
        name = cls.__coll__ + name
        return await cls.Execute('DUMP', name)


    @classmethod
    async def get(cls, name):
        """
        Return the value at key ``name``, or None if the key doesn't exist
        """
        name = cls.__coll__ + name
        return await cls.Execute('GET', name)

    def __getitem__(self, name):
        """
        Return the value at key ``name``, raises a KeyError if the key
        doesn't exist.
        """
        value = self.get(name)
        if value is not None:
            return value
        raise KeyError(name)

    @classmethod
    async def getbit(cls, name, offset):
        "Returns a boolean indicating the value of ``offset`` in ``name``"
        return await cls.Execute('GETBIT', name, offset)


    @classmethod
    async def getrange(cls, key, start, end):
        """
        Returns the substring of the string value stored at ``key``,
        determined by the offsets ``start`` and ``end`` (both are inclusive)
        """
        return await cls.Execute('GETRANGE', key, start, end)

    @classmethod
    async def getset(cls, name, value):
        """
        Sets the value at key ``name`` to ``value``
        and returns the old value at key ``name`` atomically.
        """
        return await cls.Execute('GETSET', name, value)

    @classmethod
    async def incr(cls, name, amount=1):
        """
        Increments the value of ``key`` by ``amount``.  If no key exists,
        the value will be initialized as ``amount``
        """
        return await cls.Execute('INCRBY', name, amount)
    @classmethod
    async def incrby(cls, name, amount=1):
        """
        Increments the value of ``key`` by ``amount``.  If no key exists,
        the value will be initialized as ``amount``
        """

        # An alias for ``incr()``, because it is already implemented
        # as INCRBY redis command.
        return await cls.incr(name, amount)


    @classmethod
    async def incrbyfloat(cls, name, amount=1.0):
        """
        Increments the value at key ``name`` by floating ``amount``.
        If no key exists, the value will be initialized as ``amount``
        """
        return await cls.Execute('INCRBYFLOAT', name, amount)

    @classmethod
    async def rename(cls, src, dst):
        """
        Rename key ``src`` to ``dst``
        """
        return await cls.Execute('RENAME', src, dst)

    @classmethod
    async def renamenx(cls, src, dst):
        "Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist"
        return await cls.Execute('RENAMENX', src, dst)


    @classmethod
    async def restore(cls, name, ttl, value, replace=False):
        """
        Create a key using the provided serialized value, previously obtained
        using DUMP.
        """
        params = [name, ttl, value]
        if replace:
            params.append('REPLACE')
        return await cls.Execute('RESTORE', *params)

    @classmethod
    async def set(cls, name, value, ex=None, px=None, nx=False, xx=False):
        """
        Set the value at key ``name`` to ``value``

        ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.

        ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.

        ``nx`` if set to True, set the value at key ``name`` to ``value`` only
            if it does not exist.

        ``xx`` if set to True, set the value at key ``name`` to ``value`` only
            if it already exists.
        """
        name = cls.__coll__ + name
        pieces = [name, value]
        if ex is not None:
            pieces.append('EX')
            if isinstance(ex, datetime.timedelta):
                ex = ex.seconds + ex.days * 24 * 3600
            pieces.append(ex)
        if px is not None:
            pieces.append('PX')
            if isinstance(px, datetime.timedelta):
                ms = int(px.microseconds / 1000)
                px = (px.seconds + px.days * 24 * 3600) * 1000 + ms
            pieces.append(px)

        if nx:
            pieces.append('NX')
        if xx:
            pieces.append('XX')

        return await cls.Execute('SET', *pieces,encoding='utf-8')

    def __setitem__(self, name, value):
        self.set(name, value)


    @classmethod
    async def setbit(cls, name, offset, value):
        """
        Flag the ``offset`` in ``name`` as ``value``. Returns a boolean
        indicating the previous value of ``offset``.
        """
        value = value and 1 or 0
        return await cls.Execute('SETBIT', name, offset, value)

 

转载于:https://www.cnblogs.com/wangyuxing/articles/10417202.html