Redis Client

my_redis.py

# https://redis-py.readthedocs.io/en/latest/#redis.StrictRedis
import os
from functools import partial
import redis
from redlock import RedLock, RedLockFactory

#import configparser
#config = configparser.ConfigParser()
#config.read('config.ini')


class Client(object):
    def __init__(self, port=None):
        self.port = 6379
        if port:
            self.port = port
        #self.r = redis.Redis(host=config['REDIS']['HOST'],
        self.conn = redis.Redis(host=os.environ['REDIS_HOST'],
                                port=self.port,
                                charset="utf-8",
                                decode_responses=True)
        self.dlm = self.DLM(self.port)

    class DLM(object):
        def __init__(self, port):
            self.conn = [{
                'host': os.environ['BTX_REDIS_HOST'],
                'port': str(port)
            }]
            self.lock_list = {}
            self.conn_list = {
                'default': RedLockFactory(connection_details=self.conn)
            }

        def __add_lock(self, name, lock):
            if name in self.lock_list.keys():
                raise AttributeError("lock is already in use")
            self.lock_list[name] = lock

        def __gen_lock(self, name, conn):
            if conn is None:
                lock = RedLock(name, self.conn)
            else:
                lock = RedLockFactory(connection_details=self.conn + conn)
            self.__add_lock(name, lock)
            return lock

        def lock(self, name, conn=None):
            #new_lock = self.dlm.acquire(name, t)
            l = self.__gen_lock(name, conn)
            ret = l.acquire()
            if not ret:  # the function returns False if failed
                raise AssertionError("AcquireLockException")
            return l

        def unlock(self, name):
            self.lock_list[name].release()
            del self.lock_list[name]

        def clean_locks(self):
            for _, v in self.lock_list.items():
                v.release()
            self.lock_list = {}

        def save_conn(self, name, conn):
            if conn is None:
                conn = []
            dist_lock = RedLockFactory(connection_details=self.conn + conn)
            self.conn_list[name] = dist_lock

        def remove_conn(self, name):
            if name == 'default':
                raise AttributeError('cannot delete default conn')
            del self.conn_list[name]

        def exec_func(self, name, func, conn=None):
            if conn is None:
                lock = self.conn_list['default']
            else:
                lock = self.conn_list[conn]
            self.__add_lock(name, lock)
            ret = None
            with lock.create_lock(name):
                ret = func()
            del self.lock_list[name]
            return ret


#def p(a, b=2):
#    print("hello world", a, b)

#import my_redis
#c = my_redis.Client()
#dlm = c.dlm
#dlm.lock('a')
#dlm.save_conn(None)
#dlm.exec_func('print', p)