Python Sentinel.discover_slaves方法代码示例

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
    def connect(self, index=0, write=True):
        """
        Creates a redis connection with connection pool.
        """
        master_name, sentinel_hosts, db = self.parse_connection_string(self._connection_string)

        sentinel_timeout = self._options.get('SENTINEL_TIMEOUT', 1)
        sentinel = Sentinel(sentinel_hosts, socket_timeout=sentinel_timeout)

        if write:
            host, port = sentinel.discover_master(master_name)
        else:
            host, port = random.choice([sentinel.discover_master(master_name)] + sentinel.discover_slaves(master_name))

        kwargs = {
            "db": db,
            "parser_class": self.parser_class,
            "password": self._options.get('PASSWORD', None),
        }

        kwargs.update({'host': host, 'port': port, 'connection_class': Connection})

        if 'SOCKET_TIMEOUT' in self._options:
            kwargs.update({'socket_timeout': int(self._options['SOCKET_TIMEOUT'])})

        kwargs.update(self._pool_cls_kwargs)

        connection_pool = get_or_create_connection_pool(self._pool_cls, **kwargs)
        connection = Redis(connection_pool=connection_pool)
        return connection

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
 def __init__(self, sentinels, service, **kwargs):
     sentinel = Sentinel(sentinels, **kwargs)
     try:
         master = sentinel.discover_master(service)
     except MasterNotFoundError:
         raise
     try:
         slaves = sentinel.discover_slaves(service)
     except SlaveNotFoundError:
         self._slaves = None
     if version_info[0] < 3:
         super(AutoRedisSentinel, self).__init__(master, slaves=slaves, **kwargs)
     else:
         super().__init__(master, slaves=slaves, **kwargs)

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
    def connect(self, index=0, write=True):
        """
        Creates a redis connection with connection pool.
        """
        master_name, sentinel_hosts, db = self.parse_connection_string(self._connection_string)

        sentinel_timeout = self._options.get("SENTINEL_TIMEOUT", 1)
        sentinel = Sentinel(sentinel_hosts, socket_timeout=sentinel_timeout)

        if write:
            host, port = sentinel.discover_master(master_name)
        else:
            host, port = random.choice([sentinel.discover_master(master_name)] + sentinel.discover_slaves(master_name))

        return self.connection_factory.connect(host, port, db)

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
    def connect(self, index=0, write=True):
        """
        Creates a redis connection with connection pool.
        """
        master_name, sentinel_hosts, db = self.parse_connection_string(self._connection_string)

        sentinel_timeout = self._options.get('SENTINEL_TIMEOUT', 1)
        sentinel = Sentinel(sentinel_hosts, socket_timeout=sentinel_timeout)

        if write:
            host, port = sentinel.discover_master(master_name)
        else:
            host, port = random.choice([sentinel.discover_master(master_name)] + sentinel.discover_slaves(master_name))

        sentinel_options = self._options.copy()
        sentinel_options['CONNECTION_POOL_CLASS'] = 'redis.sentinel.SentinelConnectionPool'
        sentinel_options['CONNECTION_POOL_KWARGS'] = {
            'service_name': master_name,
            'sentinel_manager': sentinel}
        self.connection_factory = get_connection_factory(options=sentinel_options)

        return self.connection_factory.connect(host, port, db)

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]

#.........这里部分代码省略.........
        # if time.time() > (self._ConnectionError_last_log_time + log_interval):
        #     self._ConnectionError_last_log_time = time.time()
        #     logger = self.logger.info
        # else:
        if self.logger:
            logger = self.logger.debug
            logger("{}".format(err_msg))

        raise self.ConnectionError(err_msg)

    def discover_master(self):
        """
        Return the master instance (host, ip)
        """

        if self.sentinel and self.master:
            attempts = 0
            while attempts < ATTEMPT_LIMIT:
                try:
                    attempts += 1
                    master = self.sentinel.discover_master(self.master)
                    break
                except redis.sentinel.MasterNotFoundError as e:
                    # Pause for specified time
                    print "try %d" % attempts
                    time.sleep(ATTEMPT_PAUSE)
            else:
                self._raise_ConnectionError(e)

            return master 
        else:
            self._raise_ConnectionError("Sentinels not properly defined")

    def discover_slaves(self):
        """
        Return the slave instances [(host, ip),]
        """

        if self.sentinel and self.master:
            attempts = 0
            while attempts < ATTEMPT_LIMIT:
                try:
                    attempts += 1
                    master = self.sentinel.discover_slaves(self.master)
                    break
                except redis.sentinel.SlaveNotFoundError as e:
                    # Pause for specified time
                    print "try %d" % attempts
                    time.sleep(ATTEMPT_PAUSE)
            else:
                self._raise_ConnectionError(e)

            return master 
        else:
            self._raise_ConnectionError("Sentinels not properly defined")
    
    #############
    # PIPELINE Methods
    #############
    
    def pipeline(self):
        """return a pipeline instance"""
        return self.redis.pipeline()

    #############
    # GET Methods

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
#!/usr/bin/python

from redis.sentinel import Sentinel
sentinel = Sentinel([('localhost', 19001)], socket_timeout=0.1)
master = sentinel.discover_master('redis-cluster')
slaves = sentinel.discover_slaves('redis-cluster')

print ""
print "Master(" + str(master) + ")"
print ""
print "Slaves(" + str(len(slaves)) + ") Nodes(" + str(slaves) + ")"
print ""

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
import time
from redis.sentinel import Sentinel

sentinel = Sentinel([('192.168.11.35', 26379),('192.168.11.37', 26379),('192.168.11.37', 26379)], socket_timeout=0.1)
for i in range(1,1000):
  print "ciclo " + str(i)
  try:
    print "master: " + str(sentinel.discover_master('mymaster'))
    print "slave/s: " + str(sentinel.discover_slaves('mymaster'))

    master = sentinel.master_for('mymaster', socket_timeout=0.1)
    slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
  except:
    print "sentinel eligiendo a un master"

  clave = "clave" + str(i)
  valor = "valor" + str(i)

  try:
    print "master.set " + clave + " " + valor 
    master.set(clave, valor)

    print "master.get " + clave + " = " + str(master.get(clave))

    print "master.set " + clave + " = " + str(slave.get(clave))

    print "master.delete " + clave
    master.delete(clave)
  except:
    print "cluster en modo solo lectura"

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
sentinel = Sentinel([('localhost', 55511)], socket_timeout=0.1)
if sentinel.discover_master(NAME)[1] != 33311:
    print 'unexpected situation: expecting port 33311 to be the master'
    sys.exit(99)

print """>> Getting an High Availability connection through the sentinel.
"""
mha = sentinel.master_for(NAME)
if int(mha.config_get()['port']) != 33311:
    print 'unexpected master. expecting master to be on port 33311.'
    sys.exit(99)

assert mha.ping() and a.ping()

print """>> Currently: (MASTER:{})<==(SLAVES:{})""".format(sentinel.discover_master(NAME),
                                                           sentinel.discover_slaves(NAME))

print """>> Stopping A instance (current master)
"""
# err = subprocess.call('./stop-master.sh')
# if err:
#     print 'error stopping master instance.'
#     sys.exit(99)
raw_input('./stop-master.sh')
print ">> waiting for A to stop."

try:
    while a.ping():
        pass
except ConnectionError:
    print '>> instance A stopped.'

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import discover_slaves [as 别名]
# 3.配置文件 bind 不能为127.0.0.1 应该是 0.0.0.0
from redis.sentinel import Sentinel

# 连接哨兵服务器(主机名也可以用域名)
sentinel = Sentinel([('192.168.56.101', 26379)], socket_timeout=0.5)



# 获取主服务器地址
master = sentinel.discover_master('mymaster')
print(master)
# 输出：('172.31.0.2', 5001)


# 获取从服务器地址
slave = sentinel.discover_slaves('mymaster')
print(slave)
# 输出：[('172.31.3', 5001), ('172.31.0.4', 5001), ('172.31.0.5', 5001)]



# 获取主服务器进行写入
master = sentinel.master_for('mymaster', socket_timeout=0.5, db=15)
w_ret = master.set('foo', 'bar')
# 输出：True


# # 获取从服务器进行读取（默认是round-roubin）
slave = sentinel.slave_for('mymaster', socket_timeout=0.5, db=15)
r_ret = slave.get('foo')
print(r_ret)