本文整理汇总了Python中redis.sentinel.Sentinel.slave_for方法的典型用法代码示例。如果您正苦于以下问题:Python Sentinel.slave_for方法的具体用法?Python Sentinel.slave_for怎么用?Python Sentinel.slave_for使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.sentinel.Sentinel
的用法示例。
在下文中一共展示了Sentinel.slave_for方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: TestApplication
# 需要导入模块: 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)
示例2: _connection
# 需要导入模块: 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
示例3: get_connection
# 需要导入模块: 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
示例4: _init
# 需要导入模块: 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)
示例5: redis_conn
# 需要导入模块: 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
示例6: wrapper
# 需要导入模块: 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)
示例7: Sentinel
# 需要导入模块: 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()
示例8: create_app
# 需要导入模块: 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
示例9: Sentinel
# 需要导入模块: 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):
示例10: BaseCache
# 需要导入模块: 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)
示例11: Sentinel
# 需要导入模块: 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"
示例12: Sentinel
# 需要导入模块: 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
示例13: RedisInfo
# 需要导入模块: 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
示例14: Sentinel
# 需要导入模块: 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')
示例15: __init__
# 需要导入模块: 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'}
#.........这里部分代码省略.........