

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: sentinel.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>import random
import weakref

from redis.client import Redis
from redis.connection import ConnectionPool, Connection
from redis.exceptions import (ConnectionError, ResponseError, ReadOnlyError,
                              TimeoutError)
from redis._compat import iteritems, nativestr, xrange


class MasterNotFoundError(ConnectionError):
    pass


class SlaveNotFoundError(ConnectionError):
    pass


class SentinelManagedConnection(Connection):
    def __init__(self, **kwargs):
        self.connection_pool = kwargs.pop(&#039;connection_pool&#039;)
        super(SentinelManagedConnection, self).__init__(**kwargs)

    def __repr__(self):
        pool = self.connection_pool
        s = &#039;%s&lt;service=%s%%s&gt;&#039; % (type(self).__name__, pool.service_name)
        if self.host:
            host_info = &#039;,host=%s,port=%s&#039; % (self.host, self.port)
            s = s % host_info
        return s

    def connect_to(self, address):
        self.host, self.port = address
        super(SentinelManagedConnection, self).connect()
        if self.connection_pool.check_connection:
            self.send_command(&#039;PING&#039;)
            if nativestr(self.read_response()) != &#039;PONG&#039;:
                raise ConnectionError(&#039;PING failed&#039;)

    def connect(self):
        if self._sock:
            return  # already connected
        if self.connection_pool.is_master:
            self.connect_to(self.connection_pool.get_master_address())
        else:
            for slave in self.connection_pool.rotate_slaves():
                try:
                    return self.connect_to(slave)
                except ConnectionError:
                    continue
            raise SlaveNotFoundError  # Never be here

    def read_response(self):
        try:
            return super(SentinelManagedConnection, self).read_response()
        except ReadOnlyError:
            if self.connection_pool.is_master:
                # When talking to a master, a ReadOnlyError when likely
                # indicates that the previous master that we&#039;re still connected
                # to has been demoted to a slave and there&#039;s a new master.
                # calling disconnect will force the connection to re-query
                # sentinel during the next connect() attempt.
                self.disconnect()
                raise ConnectionError(&#039;The previous master is now a slave&#039;)
            raise


class SentinelConnectionPool(ConnectionPool):
    &quot;&quot;&quot;
    Sentinel backed connection pool.

    If ``check_connection`` flag is set to True, SentinelManagedConnection
    sends a PING command right after establishing the connection.
    &quot;&quot;&quot;

    def __init__(self, service_name, sentinel_manager, **kwargs):
        kwargs[&#039;connection_class&#039;] = kwargs.get(
            &#039;connection_class&#039;, SentinelManagedConnection)
        self.is_master = kwargs.pop(&#039;is_master&#039;, True)
        self.check_connection = kwargs.pop(&#039;check_connection&#039;, False)
        super(SentinelConnectionPool, self).__init__(**kwargs)
        self.connection_kwargs[&#039;connection_pool&#039;] = weakref.proxy(self)
        self.service_name = service_name
        self.sentinel_manager = sentinel_manager

    def __repr__(self):
        return &quot;%s&lt;service=%s(%s)&quot; % (
            type(self).__name__,
            self.service_name,
            self.is_master and &#039;master&#039; or &#039;slave&#039;,
        )

    def reset(self):
        super(SentinelConnectionPool, self).reset()
        self.master_address = None
        self.slave_rr_counter = None

    def owns_connection(self, connection):
        check = not self.is_master or \
                (self.is_master and
                 self.master_address == (connection.host, connection.port))
        parent = super(SentinelConnectionPool, self)
        return check and parent.owns_connection(connection)

    def get_master_address(self):
        master_address = self.sentinel_manager.discover_master(
            self.service_name)
        if self.is_master:
            if self.master_address != master_address:
                self.master_address = master_address
                # disconnect any idle connections so that they reconnect
                # to the new master the next time that they are used.
                self.disconnect(inuse_connections=False)
        return master_address

    def rotate_slaves(self):
        &quot;Round-robin slave balancer&quot;
        slaves = self.sentinel_manager.discover_slaves(self.service_name)
        if slaves:
            if self.slave_rr_counter is None:
                self.slave_rr_counter = random.randint(0, len(slaves) - 1)
            for _ in xrange(len(slaves)):
                self.slave_rr_counter = (
                    self.slave_rr_counter + 1) % len(slaves)
                slave = slaves[self.slave_rr_counter]
                yield slave
        # Fallback to the master connection
        try:
            yield self.get_master_address()
        except MasterNotFoundError:
            pass
        raise SlaveNotFoundError(&#039;No slave found for %r&#039; % (self.service_name))


class Sentinel(object):
    &quot;&quot;&quot;
    Redis Sentinel cluster client

    &gt;&gt;&gt; from redis.sentinel import Sentinel
    &gt;&gt;&gt; sentinel = Sentinel([(&#039;localhost&#039;, 26379)], socket_timeout=0.1)
    &gt;&gt;&gt; master = sentinel.master_for(&#039;mymaster&#039;, socket_timeout=0.1)
    &gt;&gt;&gt; master.set(&#039;foo&#039;, &#039;bar&#039;)
    &gt;&gt;&gt; slave = sentinel.slave_for(&#039;mymaster&#039;, socket_timeout=0.1)
    &gt;&gt;&gt; slave.get(&#039;foo&#039;)
    b&#039;bar&#039;

    ``sentinels`` is a list of sentinel nodes. Each node is represented by
    a pair (hostname, port).

    ``min_other_sentinels`` defined a minimum number of peers for a sentinel.
    When querying a sentinel, if it doesn&#039;t meet this threshold, responses
    from that sentinel won&#039;t be considered valid.

    ``sentinel_kwargs`` is a dictionary of connection arguments used when
    connecting to sentinel instances. Any argument that can be passed to
    a normal Redis connection can be specified here. If ``sentinel_kwargs`` is
    not specified, any socket_timeout and socket_keepalive options specified
    in ``connection_kwargs`` will be used.

    ``connection_kwargs`` are keyword arguments that will be used when
    establishing a connection to a Redis server.
    &quot;&quot;&quot;

    def __init__(self, sentinels, min_other_sentinels=0, sentinel_kwargs=None,
                 **connection_kwargs):
        # if sentinel_kwargs isn&#039;t defined, use the socket_* options from
        # connection_kwargs
        if sentinel_kwargs is None:
            sentinel_kwargs = {
                k: v
                for k, v in iteritems(connection_kwargs)
                if k.startswith(&#039;socket_&#039;)
            }
        self.sentinel_kwargs = sentinel_kwargs

        self.sentinels = [Redis(hostname, port, **self.sentinel_kwargs)
                          for hostname, port in sentinels]
        self.min_other_sentinels = min_other_sentinels
        self.connection_kwargs = connection_kwargs

    def __repr__(self):
        sentinel_addresses = []
        for sentinel in self.sentinels:
            sentinel_addresses.append(&#039;%s:%s&#039; % (
                sentinel.connection_pool.connection_kwargs[&#039;host&#039;],
                sentinel.connection_pool.connection_kwargs[&#039;port&#039;],
            ))
        return &#039;%s&lt;sentinels=[%s]&gt;&#039; % (
            type(self).__name__,
            &#039;,&#039;.join(sentinel_addresses))

    def check_master_state(self, state, service_name):
        if not state[&#039;is_master&#039;] or state[&#039;is_sdown&#039;] or state[&#039;is_odown&#039;]:
            return False
        # Check if our sentinel doesn&#039;t see other nodes
        if state[&#039;num-other-sentinels&#039;] &lt; self.min_other_sentinels:
            return False
        return True

    def discover_master(self, service_name):
        &quot;&quot;&quot;
        Asks sentinel servers for the Redis master&#039;s address corresponding
        to the service labeled ``service_name``.

        Returns a pair (address, port) or raises MasterNotFoundError if no
        master is found.
        &quot;&quot;&quot;
        for sentinel_no, sentinel in enumerate(self.sentinels):
            try:
                masters = sentinel.sentinel_masters()
            except (ConnectionError, TimeoutError):
                continue
            state = masters.get(service_name)
            if state and self.check_master_state(state, service_name):
                # Put this sentinel at the top of the list
                self.sentinels[0], self.sentinels[sentinel_no] = (
                    sentinel, self.sentinels[0])
                return state[&#039;ip&#039;], state[&#039;port&#039;]
        raise MasterNotFoundError(&quot;No master found for %r&quot; % (service_name,))

    def filter_slaves(self, slaves):
        &quot;Remove slaves that are in an ODOWN or SDOWN state&quot;
        slaves_alive = []
        for slave in slaves:
            if slave[&#039;is_odown&#039;] or slave[&#039;is_sdown&#039;]:
                continue
            slaves_alive.append((slave[&#039;ip&#039;], slave[&#039;port&#039;]))
        return slaves_alive

    def discover_slaves(self, service_name):
        &quot;Returns a list of alive slaves for service ``service_name``&quot;
        for sentinel in self.sentinels:
            try:
                slaves = sentinel.sentinel_slaves(service_name)
            except (ConnectionError, ResponseError, TimeoutError):
                continue
            slaves = self.filter_slaves(slaves)
            if slaves:
                return slaves
        return []

    def master_for(self, service_name, redis_class=Redis,
                   connection_pool_class=SentinelConnectionPool, **kwargs):
        &quot;&quot;&quot;
        Returns a redis client instance for the ``service_name`` master.

        A SentinelConnectionPool class is used to retrive the master&#039;s
        address before establishing a new connection.

        NOTE: If the master&#039;s address has changed, any cached connections to
        the old master are closed.

        By default clients will be a redis.Redis instance. Specify a
        different class to the ``redis_class`` argument if you desire
        something different.

        The ``connection_pool_class`` specifies the connection pool to use.
        The SentinelConnectionPool will be used by default.

        All other keyword arguments are merged with any connection_kwargs
        passed to this class and passed to the connection pool as keyword
        arguments to be used to initialize Redis connections.
        &quot;&quot;&quot;
        kwargs[&#039;is_master&#039;] = True
        connection_kwargs = dict(self.connection_kwargs)
        connection_kwargs.update(kwargs)
        return redis_class(connection_pool=connection_pool_class(
            service_name, self, **connection_kwargs))

    def slave_for(self, service_name, redis_class=Redis,
                  connection_pool_class=SentinelConnectionPool, **kwargs):
        &quot;&quot;&quot;
        Returns redis client instance for the ``service_name`` slave(s).

        A SentinelConnectionPool class is used to retrive the slave&#039;s
        address before establishing a new connection.

        By default clients will be a redis.Redis instance. Specify a
        different class to the ``redis_class`` argument if you desire
        something different.

        The ``connection_pool_class`` specifies the connection pool to use.
        The SentinelConnectionPool will be used by default.

        All other keyword arguments are merged with any connection_kwargs
        passed to this class and passed to the connection pool as keyword
        arguments to be used to initialize Redis connections.
        &quot;&quot;&quot;
        kwargs[&#039;is_master&#039;] = False
        connection_kwargs = dict(self.connection_kwargs)
        connection_kwargs.update(kwargs)
        return redis_class(connection_pool=connection_pool_class(
            service_name, self, **connection_kwargs))
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib/python3.6/site-packages/redis/sentinel.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2Fredis' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>