def configure(cls, **config):

        cls._pid = os.getpid()

        cls.t_wait0 = float(config.get('t_wait0', cls.t_wait0))

        cls.t_wait_no_tasks = float(config.get('t_wait_no_tasks', cls.t_wait_no_tasks))

        cls.t_wait_per_server = float(config.get('t_wait_per_server', cls.t_wait_per_server))

        # estimate the reties_per_server from the wait_time_per_server
        cls.reties_per_server = cls.calculate_reties_per_server(cls.t_wait_per_server, cls.t_wait0)

        #cls.t_reconnect_master = int(config.get('t_reconnect_master', cls.t_reconnect_master))

        servers = config.get('redis_servers')
        if servers:
            if isinstance(servers, basestring):
                servers = [s.strip() for s in servers.split(',')]
            elif not isinstance(servers, collections.Iterable):
                raise Exception("wrong servers parameter")
            cls.servers = list(servers)
            # parse all server urls to detect config errors beforehand
            [parse_redis_conn(s) for s in cls.servers]

        logger.warn('Pid=%s ==> RedisConnHandler  configured with reties_per_server(estimated)=%s, t_wait_per_server=%s, '
                    't_wait_no_tasks=%s, servers=%s', cls._pid, cls.reties_per_server, cls.t_wait_per_server,
                    cls.t_wait_no_tasks, cls.servers)
    def configure(cls, **config):

        cls.t_wait0 = float(config.get("t_wait0", cls.t_wait0))

        cls.t_wait_no_tasks = float(config.get("t_wait_no_tasks", cls.t_wait_no_tasks))

        cls.t_wait_per_server = float(config.get("t_wait_per_server", cls.t_wait_per_server))

        # estimate the retries_per_server from the wait_time_per_server
        cls.retries_per_server = cls.calculate_retries_per_server(cls.t_wait_per_server, cls.t_wait0)

        servers = config.get("redis.servers")
        if servers:
            if isinstance(servers, basestring):
                servers = [s.strip() for s in servers.split(",")]
            elif not isinstance(servers, collections.Iterable):
                raise Exception("wrong servers parameter")
            cls.servers = list(servers)
            # parse all server urls to detect config errors beforehand
            [parse_redis_conn(s) for s in cls.servers]

        logger.info(
            "Configured RedisConnHandler with retries_per_server(estimated)=%s, t_wait_per_server=%s, "
            "t_wait_no_tasks=%s, servers=%s",
            cls.retries_per_server,
            cls.t_wait_per_server,
            cls.t_wait_no_tasks,
            cls.servers,
        )
Example #3
0
    def configure(cls, **config):

        cls.t_wait0 = float(config.get('t_wait0', cls.t_wait0))

        cls.t_wait_no_tasks = float(
            config.get('t_wait_no_tasks', cls.t_wait_no_tasks))

        cls.t_wait_per_server = float(
            config.get('t_wait_per_server', cls.t_wait_per_server))

        # estimate the retries_per_server from the wait_time_per_server
        cls.retries_per_server = cls.calculate_retries_per_server(
            cls.t_wait_per_server, cls.t_wait0)

        servers = config.get('redis.servers')
        if servers:
            if isinstance(servers, basestring):
                servers = [s.strip() for s in servers.split(',')]
            elif not isinstance(servers, collections.Iterable):
                raise Exception("wrong servers parameter")
            cls.servers = list(servers)
            # parse all server urls to detect config errors beforehand
            [parse_redis_conn(s) for s in cls.servers]

        logger.info(
            'Configured RedisConnHandler with retries_per_server(estimated)=%s, t_wait_per_server=%s, '
            't_wait_no_tasks=%s, servers=%s', cls.retries_per_server,
            cls.t_wait_per_server, cls.t_wait_no_tasks, cls.servers)
    def __init__(self):
        # we could use a metaclass or some trick on __new__ for enforcing the use of get_instance()
        if not self._thread_local.can_init:
            raise AssertionError("You must use get_instance() to get an instance")

        assert len(self.servers) > 0, "Fatal Error: No servers have been configured"
        self._conn = None
        self._parsed_redis = parse_redis_conn(self.servers[self._active_index])
    def __init__(self):
        # we could use a metaclass or some trick on __new__ for enforcing the use of get_instance()
        if not self._thread_local.can_init:
            raise AssertionError('You must use get_instance() to get an instance')

        assert len(self.servers) > 0, 'Fatal Error: No servers have been configured'
        self._conn = None
        self._parsed_redis = parse_redis_conn(self.servers[self._active_index])
    def switch_active_server(self, force_master=False):
        self._active_index = (0 if force_master or self._active_index >= len(self.servers) - 1 else
                              self._active_index + 1)
        self._parsed_redis = parse_redis_conn(self.servers[self._active_index])

        prev_status = self._status
        self.mark(self.STATUS_OK)  # mark a fresh status OK for the new server

        logger.warn('Switched active Redis server to %s, prev_status=%s, force_master=%s', self.servers[self._active_index], prev_status, force_master)
    def switch_active_server(self, force_master=False):
        self._active_index = (0 if force_master or self._active_index >= len(self.servers) - 1 else
                              self._active_index + 1)
        self._parsed_redis = parse_redis_conn(self.servers[self._active_index])

        self.mark(self.STATUS_OK)  # mark a fresh status OK for the new server

        logger.warn('Pid=%s, thread_id=%s ==> Redis Active server switched to %s, force_master=%s', self._pid,
                    current_thread().name, self.servers[self._active_index], force_master)
 def get_conn(self):
     if self._conn is not None and not self.should_switch_server():
         return self._conn
     else:
         self._conn = None
         active_server = self.get_active_server()
         c = parse_redis_conn(active_server)
         logger.info("Opening new Redis connection to %s:%s/%s..", c.hostname, c.port, c.virtual_host)
         self._conn = redis.StrictRedis(host=c.hostname, port=c.port, db=c.virtual_host)
         return self._conn
 def get_conn(self):
     if self._conn is not None and not self.should_switch_server():
         return self._conn
     else:
         self._conn = None
         active_server = self.get_active_server()
         c = parse_redis_conn(active_server)
         logger.info('Opening new Redis connection to %s:%s/%s..', c.hostname, c.port, c.virtual_host)
         self._conn = redis.StrictRedis(host=c.hostname, port=c.port, db=c.virtual_host)
         return self._conn
    def switch_active_server(self, force_master=False):
        self._active_index = (0 if force_master or self._active_index >= len(self.servers) - 1 else
                              self._active_index + 1)
        self._parsed_redis = parse_redis_conn(self.servers[self._active_index])

        prev_status = self._status
        self.mark(self.STATUS_OK)  # mark a fresh status OK for the new server

        logger.warn(
            'Switched active Redis server to %s, prev_status=%s, force_master=%s',
            self.servers[self._active_index], prev_status, force_master)
 def get_conn(self):
     if self._conn is not None and not self.should_switch_server():
         return self._conn
     else:
         self._conn = None
         active_server = self.get_active_server()
         c = parse_redis_conn(active_server)
         logger.warn('Pid=%s, thread_id=%s ==> Opening new redis connection to host=%s, port=%s, db=%s', self._pid,
                     current_thread().name, c.hostname, c.port, c.virtual_host)
         self._conn = redis.StrictRedis(host=c.hostname, port=c.port, db=c.virtual_host)
         return self._conn