def do_setup(_res):
self.factory = RedisClientFactory()
reactor.connectTCP(REDIS_HOST, REDIS_PORT, self.factory)
d = self.factory.deferred
def cannot_connect(_res):
raise unittest.SkipTest('Cannot connect to Redis.')
d.addErrback(cannot_connect)
return d
def __init__(self, reactor, host, port, keysPattern):
"""
@param keysPattern: Pattern of keys to poll the list length for.
"""
self.reactor = reactor
self.host = host
self.port = port
self.keysPattern = keysPattern
self.factory = RedisClientFactory()
self.connector = None
self.basePath = "redis.{}.list.".format(sanitizeMetricElement(host))
self.lc = task.LoopingCall(self.poll)
def do_setup(_res):
self.factory = RedisClientFactory()
reactor.connectTCP(REDIS_HOST, REDIS_PORT, self.factory)
d = self.factory.deferred
def cannot_connect(_res):
raise unittest.SkipTest('Cannot connect to Redis.')
d.addErrback(cannot_connect)
return d
def __init__(self, code, message, key, redis_endpoint=None,
response_channel=None):
OperationResponse.__init__(self, code, message, key)
self.response_channel = response_channel
self.redis_conn = redis_endpoint.connect(RedisClientFactory())
self.redis_conn.addCallback(self.set_redis_client)
class TestFactory(CommandsBaseTestCase):
def setUp(self):
d = CommandsBaseTestCase.setUp(self)
def do_setup(_res):
self.factory = RedisClientFactory()
reactor.connectTCP(REDIS_HOST, REDIS_PORT, self.factory)
d = self.factory.deferred
def cannot_connect(_res):
raise unittest.SkipTest('Cannot connect to Redis.')
d.addErrback(cannot_connect)
return d
d.addCallback(do_setup)
return d
def tearDown(self):
CommandsBaseTestCase.tearDown(self)
self.factory.continueTrying = 0
self.factory.stopTrying()
if self.factory.client:
self.factory.client.setTimeout(None)
self.factory.client.transport.loseConnection()
@defer.inlineCallbacks
def test_reconnect(self):
a = yield self.factory.client.info()
self.assertTrue('uptime_in_days' in a)
# teardown the connection
self.factory.client.transport.loseConnection()
# wait until reconnected
a = yield self.factory.deferred
a = yield self.factory.client.info()
self.assertTrue('uptime_in_days' in a)
timeout = 4
def __init__(self, reactor, host, port, keysPattern):
"""
@param keysPattern: Pattern of keys to poll the list length for.
"""
self.reactor = reactor
self.host = host
self.port = port
self.keysPattern = keysPattern
self.factory = RedisClientFactory()
self.connector = None
self.basePath = "redis.{}.list.".format(host.replace('.', '_'))
self.lc = task.LoopingCall(self.poll)
class TestFactory(CommandsBaseTestCase):
def setUp(self):
d = CommandsBaseTestCase.setUp(self)
def do_setup(_res):
self.factory = RedisClientFactory()
reactor.connectTCP(REDIS_HOST, REDIS_PORT, self.factory)
d = self.factory.deferred
def cannot_connect(_res):
raise unittest.SkipTest('Cannot connect to Redis.')
d.addErrback(cannot_connect)
return d
d.addCallback(do_setup)
return d
def tearDown(self):
CommandsBaseTestCase.tearDown(self)
self.factory.continueTrying = 0
self.factory.stopTrying()
if self.factory.client:
self.factory.client.setTimeout(None)
self.factory.client.transport.loseConnection()
@defer.inlineCallbacks
def test_reconnect(self):
a = yield self.factory.client.info()
self.assertTrue('uptime_in_days' in a)
# teardown the connection
self.factory.client.transport.loseConnection()
# wait until reconnected
a = yield self.factory.deferred
a = yield self.factory.client.info()
self.assertTrue('uptime_in_days' in a)
timeout = 4
def makeService(config, dispatcher):
"""
Set up Redis client services.
"""
s = service.MultiService()
factories = []
for host in config['redis-hosts']:
factory = RedisClientFactory()
factories.append(factory)
tcpClient = internet.TCPClient(host, config['redis-port'], factory)
tcpClient.setServiceParent(s)
client = RedisPushMultiClient(factories)
publisher = RedisPublisher(dispatcher, client, config['redis-key'])
publisher.setServiceParent(s)
return s
class RedisGraphiteService(service.Service):
"""
Redis list lenght poller service.
This retrieves the lists matching L{keysPattern} and retrieves the list
lenghts to post to Graphite.
"""
def __init__(self, reactor, host, port, keysPattern):
"""
@param keysPattern: Pattern of keys to poll the list length for.
"""
self.reactor = reactor
self.host = host
self.port = port
self.keysPattern = keysPattern
self.factory = RedisClientFactory()
self.connector = None
self.basePath = "redis.{}.list.".format(host.replace('.', '_'))
self.lc = task.LoopingCall(self.poll)
def startService(self):
"""
Start connecting to the Redis server and start polling.
"""
service.Service.startService(self)
self.factory.resetDelay()
self.connector = self.reactor.connectTCP(self.host, self.port,
self.factory)
self.lc.start(10)
def stopService(self):
"""
Disconnect from the Redis server and stop polling.
"""
if self.lc.running:
self.lc.stop()
if self.connector is not None:
self.factory.stopTrying()
self.connector.disconnect()
self.connector = None
def sendMetric(self, length, key):
path = self.basePath + key.replace(':', '.') + '.length'
self.protocol.sendMetric(path, length, time.time())
def getListLengths(self, keys):
dl = []
for key in keys:
d = self.factory.client.llen(key)
d.addCallback(self.sendMetric, key)
d.addErrback(log.err)
dl.append(d)
return defer.gatherResults(dl)
def poll(self):
if not self.factory.client:
return None
d = self.factory.client.keys(self.keysPattern)
d.addCallback(self.getListLengths)
return d
class RedisGraphiteService(service.Service):
"""
Redis list lenght poller service.
This retrieves the lists matching L{keysPattern} and retrieves the list
lenghts to post to Graphite.
"""
def __init__(self, reactor, host, port, keysPattern):
"""
@param keysPattern: Pattern of keys to poll the list length for.
"""
self.reactor = reactor
self.host = host
self.port = port
self.keysPattern = keysPattern
self.factory = RedisClientFactory()
self.connector = None
self.basePath = "redis.{}.list.".format(sanitizeMetricElement(host))
self.lc = task.LoopingCall(self.poll)
def startService(self):
"""
Start connecting to the Redis server and start polling.
"""
service.Service.startService(self)
self.factory.resetDelay()
self.connector = self.reactor.connectTCP(self.host, self.port,
self.factory)
self.lc.start(10)
def stopService(self):
"""
Disconnect from the Redis server and stop polling.
"""
if self.lc.running:
self.lc.stop()
if self.connector is not None:
self.factory.stopTrying()
self.connector.disconnect()
self.connector = None
def sendMetric(self, length, key):
path = self.basePath + key.replace(':', '.') + '.length'
self.protocol.sendMetric(path, length, time.time())
def getListLengths(self, keys):
dl = []
for key in keys:
d = self.factory.client.llen(key)
d.addCallback(self.sendMetric, key)
d.addErrback(log.err)
dl.append(d)
return defer.gatherResults(dl)
def poll(self):
if not self.factory.client:
return None
d = self.factory.client.keys(self.keysPattern)
d.addCallback(self.getListLengths)
return d
