Python Sentinel.slave_for方法代码示例

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
class TestApplication(Application):
    def __init__(self):
        # Call to the superclass to bootstrap.
        super(TestApplication, self).__init__(name='krux-redis-sentinel')

        self.logger.debug('Parsing sentinels from args: %r', self.args.sentinel)
        sentinels = hostports_from_args(self.args)
        self.logger.debug('Parsed sentinel host, port pairs: %r', sentinels)

        self.logger.debug('Initializing Sentinel instance...')
        self.sentinel = Sentinel(sentinels, socket_timeout=SOCKET_TIMEOUT)
        self.logger.debug('Initialized Sentinel instance: %r', self.sentinel)

    def add_cli_arguments(self, parser):
        add_sentinel_cli_arguments(parser)

    def run(self):
        master = self.sentinel.master_for(self.name)
        slave = self.sentinel.slave_for(self.name)

        try:
            self.logger.info('Ping master: %s', master.ping())
        except ConnectionError as err:
            self.logger.warning('Could not connect to master!')
            self.logger.error(err)

        try:
            self.logger.info('Ping slave: %s', slave.ping())
        except ConnectionError as err:
            self.logger.warning('Could not connect to slave!')
            self.logger.error(err)

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
 def _connection(self):
     sentinel = Sentinel(self._sentinels,
                         socket_timeout=self._socket_timeout)
     slave = sentinel.slave_for(self._sentinel_master,
                                socket_timeout=self._socket_timeout,
                                db=self._db)
     return slave

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
    def get_connection(self, is_read_only=False) -> redis.StrictRedis:
        """
        Gets a StrictRedis connection for normal redis or for redis sentinel based upon redis mode in configuration.

        :type is_read_only: bool
        :param is_read_only: In case of redis sentinel, it returns connection to slave

        :return: Returns a StrictRedis connection
        """
        if self.connection is not None:
            return self.connection

        if self.is_sentinel:
            kwargs = dict()
            if self.password:
                kwargs["password"] = self.password
            sentinel = Sentinel([(self.host, self.port)], **kwargs)
            if is_read_only:
                connection = sentinel.slave_for(self.sentinel_service, decode_responses=True)
            else:
                connection = sentinel.master_for(self.sentinel_service, decode_responses=True)
        else:
            connection = redis.StrictRedis(host=self.host, port=self.port, decode_responses=True,
                                           password=self.password)
        self.connection = connection
        return connection

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
    def _init(self, server, params):
        super(CacheClass, self).__init__(params)
        self._server = server
        self._params = params

        self.service_name = self.options.get("SERVICE_NAME", 'mymaster')
        self.slave_read = self.options.get("READ_SLAVE", False)
        if self.server:
            def _get_hosttupe(conn):
                host_lst = conn.rsplit(':', 1)
                return host_lst[0], int(host_lst[1])

            conn_list = [_get_hosttupe(conn) for conn in self.server]

        else:
            raise ImproperlyConfigured("sentinel server config error.")

        kwargs = self.connection_pool_class_kwargs
        max_connections = kwargs.pop('max_connections')
        sentinel_manager = Sentinel(conn_list, sentinel_kwargs=kwargs)

        kwargs.update({
            'db': self.db,
            'password': self.password,
            'max_connections': max_connections
        })
        self._client = sentinel_manager.master_for(self.service_name,
                                                   connection_pool_class=self.connection_pool_class,
                                                   **kwargs)

        if self.slave_read:
            self._slave_client = sentinel_manager.slave_for(self.service_name,
                                                            connection_pool_class=self.connection_pool_class,
                                                            **kwargs)

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
def redis_conn(readonly=True):
    global sentinel, master_client, slave_client
    if not sentinel:
        sentinel = Sentinel(settings.REDIS_SENTINEL, socket_timeout=1)
    if not master_client:
        master_client = sentinel.master_for(settings.REDIS_CLUSTER)
    if not slave_client:
        slave_client = sentinel.slave_for(settings.REDIS_CLUSTER)
    return slave_client if readonly else master_client

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
 def wrapper(*args, **kwargs):
     if os.environ.get('PYBOSSA_REDIS_CACHE_DISABLED') is None:
         key = "%s::%s" % (settings.REDIS_KEYPREFIX, key_prefix)
         sentinel = Sentinel(settings.REDIS_SENTINEL, socket_timeout=0.1)
         master = sentinel.master_for('mymaster')
         slave = sentinel.slave_for('mymaster')
         output = slave.get(key)
         if output:
             return pickle.loads(output)
         else:
             output = f(*args, **kwargs)
             master.setex(key, timeout, pickle.dumps(output))
             return output
     else:
         return f(*args, **kwargs)

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
                            MasterNotFoundError, SlaveNotFoundError)

# Redis 접속 기본 설정값
listSentinel = [('172.31.5.41', 26379)]
strServiceName = 'mymaster'
strRedisPass = ''
nDB = 0

nMaxUser = 1000

sentinel = Sentinel(listSentinel, socket_timeout=0.1)
try:
    #sentinel.discover_master(strServiceName) # No need for this
    #sentinel.discover_slaves(strServiceName)
    master = sentinel.master_for(strServiceName, password=strRedisPass, db=nDB, socket_timeout=0.1)
    slave = sentinel.slave_for(strServiceName, password=strRedisPass, db=nDB, socket_timeout=0.1)
    
    print master
    """
    m = sentinel.discover_master(strServiceName)
    s = sentinel.discover_slaves(strServiceName)
    """
except MasterNotFoundError:
    print 'Master not found or Sentinel instances not runnung'
    sys.exit()
except SlaveNotFoundError:
    print 'Slave not found or Sentinel instances not runnung'
    sys.exit()
except ConnectionError:
    print 'Connection Error. Check if Sentinel instances are running'
    sys.exit()

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
login_manager.login_view = 'account.signin'
login_manager.login_message = u"Please sign in to access this page."
# Configure theme
try: # pragma: no cover
    # First with local settings
    import settings_local
    theme = settings_local.THEME
except:
    # Otherwise try with default theme
    theme = settings.THEME
# Create app
app = create_app(theme=theme)

sentinel = Sentinel(app.config['REDIS_SENTINEL'], socket_timeout=0.1)
redis_master = sentinel.master_for('mymaster')
redis_slave = sentinel.slave_for('mymaster')

#toolbar = DebugToolbarExtension(app)
db = SQLAlchemy(app)
mail = Mail(app)
signer = URLSafeTimedSerializer(app.config['ITSDANGEORUSKEY'])
if app.config.get('SENTRY_DSN'): # pragma: no cover
    sentr = Sentry(app)

babel = Babel(app)


@babel.localeselector
def get_locale():
    if current_user.is_authenticated():
        lang = current_user.locale

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
from mickey.commonconf import SINGLE_MODE, REDIS_PASSWORD


if SINGLE_MODE:
    import redis
    if REDIS_PASSWORD:
        _sentinel         = redis.StrictRedis(host='localhost', port=6379, db=0, password=REDIS_PASSWORD, socket_timeout=5.0)
    else:
        _sentinel         = redis.StrictRedis(host='localhost', port=6379, db=0, socket_timeout=5.0)

    _sentinel_salve   = _sentinel
    _sentinel_master  = _sentinel
else:
    from redis.sentinel import Sentinel
    _sentinel = Sentinel([('localhost', 26379)], socket_timeout = 1)
    _sentinel_salve = _sentinel.slave_for('master', socket_timeout = 0.5)
    _sentinel_master = _sentinel.master_for('master', socket_timeout = 0.5)

def write_to_redis(key, value, expire = None):
    if not key or not value:
        return

    try:
        _sentinel_master.set(key, value)
        if expire:
            _sentinel_master.expire(key, expire)
    except Exception as e:
        logging.error("save information to redis failed {0}".format(e))


def read_from_redis(key, defaultvalue = None):

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

#.........这里部分代码省略.........
    @discover_instance
    def keys(self):
        return self.slave.keys()

    @discover_instance
    def lpop(self, name):
        return self.master.lpop(name)

    @discover_instance
    def rpop(self, name):
        return self.master.rpop(name)

    @discover_instance
    def lpush(self, name, *values):
        return self.master.lpush(name, *values)

    @discover_instance
    def rpush(self, name, *values):
        return self.master.rpush(name, *values)

    @discover_instance
    def expire(self, name, time):
        return self.master.expire(name, time)

    @discover_instance
    def incr(self, name, amount=1):
        return self.master.incr(name, amount)

    @discover_instance
    def sadd(self, name, *values):
        return self.master.sadd(name, *values)

    @discover_instance
    def srem(self, name, *values):
        return self.master.srem(name, *values)

    @discover_instance
    def scard(self, name):
        return self.slave.scard(name)

    @discover_instance
    def smembers(self, name):
        return self.slave.smembers(name)

    @discover_instance
    def zadd(self, name, *args, **kwargs):
        return self.master.zadd(name, *args, **kwargs)

    @discover_instance
    def zrem(self, name, *values):
        return self.master.zrem(name, *values)

    @discover_instance
    def hset(self, name, key, value):
        return self.master.hset(name, key, value)

    @discover_instance
    def hget(self, name, key):
        return self.slave.hget(name, key)

    @discover_instance
    def hdel(self, name, *keys):
        return self.master.hdel(name, *keys)

    @discover_instance
    def hgetall(self, name):
        return self.slave.hgetall(name)

    @discover_instance
    def hmget(self, name, keys, *args):
        return self.slave.hmget(name, keys, *args)

    @discover_instance
    def flushdb(self):
        return self.master.flushdb()

    @discover_instance
    def dbsize(self):
        return self.slave.dbsize()

    @discover_instance
    def zrangebyscore(self, name, min, max, start=None, num=None, withscores=False, score_cast_func=float):
        return self.slave.zrangebyscore(name, min, max, start, num, withscores, score_cast_func)

    def discover_master(self):
        try:
            self.master = self.sentinel.master_for(settings.SENTINEL_MASTER, db=self.selected_db, socket_timeout=None)
        except:
            self.logger.exception("Exception !! %s", traceback.format_exc())
            raise

    def discover_slave(self):
        try:
            self.slave = self.sentinel.slave_for(settings.SENTINEL_MASTER, db=self.selected_db, socket_timeout=None)
        except:
            self.logger.exception("Exception !! %s", traceback.format_exc())
            raise

    def __getattr__(self, name):
        return getattr(self.get_slave(), name)

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [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 slave_for [as 别名]
from bottle import route, run, static_file
from math import ceil

from redis.sentinel import Sentinel

#Slave/Master distribution
sentinel = Sentinel('TODO: Get some Redis instances in Amazons AWS')
master = sentinel.master_for('.')
slave = sentinel.slave_for('.')


@route('/')
def home():
    return static_file('index.html', '..')


@route('/get/stats')
def getStats():
    return generate_json()


@route('/<filename>')
def server_static(filename):
    return static_file(filename, root='..')


def generate_json():
    # Pipeline all the requests to the SLAVE (All read)
    pipe = slave.pipeline()
    #Pipeline returns all responses in a list

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

#r = RedisInfo()

from redis import Redis, exceptions, RedisError
from redis.sentinel import (Sentinel, SentinelConnectionPool,ConnectionError, MasterNotFoundError, SlaveNotFoundError)

# Redis 접속 기본 설정값
listSentinel = [('172.31.5.41', 26379)]
strServiceName = 'mymaster'
strRedisPass = ''
nDB = 0

sentinel = Sentinel(listSentinel)
master = sentinel.master_for(strServiceName, password=strRedisPass, db=nDB)
slave = sentinel.slave_for(strServiceName, password=strRedisPass, db=nDB)
    

rds = master
rds_pub = rds.pubsub()
rds_pub.subscribe('0_Text_0')

"""
print sys.argv[1]
"""
while True:
	try:
		for x in rds_pub.listen():
			print "Text :", x['data']
	except Exception, e:
		print "Exception :", e

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

sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.3, db=15, decode_responses=True)
master = sentinel.master_for('madeira')
slave = sentinel.slave_for('madeira')

# redis 增删改查
master.set('foo', 'bar')
slave.get('foo')
master.delete('foo')

# 需要导入模块: from redis.sentinel import Sentinel [as 别名]
# 或者: from redis.sentinel.Sentinel import slave_for [as 别名]
class RedisInfo:
	def __init__(self, sentinel_use=1):
		cfg = Config()
		
		self.sentinel_use = sentinel_use
		self.rmq = {}
		self.grp = {}

		# Redis master, slave Context
		#self.redis_server = redis.StrictRedis(host=str(self.host), port=int(self.port), db=int(self.dbnm)) #, socket_timeout=-1)
		#self.rdm_slave = redis.StrictRedis(host=str(self.host_slave), port=int(self.port_slave), db=int(self.dbnm_slave) ) #, socket_timeout=1)
	
		#self.redis_server = self.redis_server
		#############################################################################
		# Redis-Sentinel]
		# istSentinel = [('172.31.5.41', 26379)]
		# strServiceName = mymaster
		# strRedisPass =
		# nDB = 0
		##############################################################################
		if self.sentinel_use == 1:
			self.redis_sentinel = eval(cfg.get('Redis-Sentinel', 'istSentinel'))
			self.redis_servicename = cfg.get('Redis-Sentinel', 'strServiceName')
			self.redis_redispass = cfg.get('Redis-Sentinel', 'strRedisPass')
			self.redis_ndb = int(cfg.get('Redis-Sentinel', 'nDB'))

			self.sentinel = Sentinel(self.redis_sentinel) #socket_timeout=0.1)
			#master = self.sentinel.discover_master(self.redis_servicename)
			#slave  = self.sentinel.discover_slaves(self.redis_servicename)
		###############################################################################

		self.redis_list = eval(cfg.get('Redis-List', 'list'))
		self.redis_list_len = len(self.redis_list)

		self.rdm_server = {}
		self.redis_server = None

		self.redis_listup()
		self.redis_current()

	# Redis List Context
	def redis_listup(self):
		for x in range(self.redis_list_len):
			self.rdm_server[x] = redis.StrictRedis( host=self.redis_list[x]['hostname'], port=self.redis_list[x]['port'], db=self.redis_list[x]['db'] )
		
	# Current Live Redis Check
	# 2015-09-25 add
	# => Redis Sentinel Master Context
	def redis_current(self):
		if self.sentinel_use == 1:
			master = self.sentinel.master_for(self.redis_servicename, password=self.redis_redispass, db=self.redis_ndb) #socket_timeout=0.1)
			slave = self.sentinel.slave_for(self.redis_servicename, password=self.redis_redispass, db=self.redis_ndb) #socket_timeout=0.1)
			self.redis_server = master
			return self.redis_server
		else:
			for x in self.rdm_server:
				try:
					if self.rdm_server[x].ping(): 
						self.redis_server = self.rdm_server[x]
						break
				except:
					pass
			try:
				return self.redis_server
			except:
				self.redis_listup()
				self.redis_current()
				time.sleep(1)

	# Redis Real Time Check
	def redis_ping(self):
		l = {}
		for x in self.rdm_server:
			try:
				c = self.rdm_server[x].ping()
			except:
				c = False

			l[x] = {'hostname':self.redis_list[x]['hostname'], 'status':c}

		try:
			return l
		except:
			self.redis_listup()
			self.redis_ping()

	# Quant Default Meta Setting
	def set(self):
		#self.rdm = redis.StrictRedis(host=str(self.host), port=int(self.port), db=int(self.dbnm), socket_timeout=1)
		try:
			d = {
				0:{'hostname':'172.31.21.219', 'port':5672, 'user':'quant', 'pass':'quant1234', 'vhost':'dev-quant', 'exchange_name':'quant'},
				1:{'hostname':'172.31.16.52' , 'port':5672, 'user':'quant', 'pass':'quant1234', 'vhost':'dev-quant', 'exchange_name':'quant'}
				}
			self.redis_server.set('rabbitmq', d)

			d = {'state':{'AA':'XKRX-CS-AA', 'KR':'XKRX-CS-KR'}}
			self.redis_server.set('group', d)

			d = {'172.31.7.219':'data', '172.31.7.217':'state', '172.31.7.218':'class', '172.31.7.216':'web'}
#.........这里部分代码省略.........