def __init__(self, *args, **kwargs):
super(Engine, self).__init__(*args, **kwargs)
self.api_key = "{0}.{1}".format(self.prefix, self.API_KEY)
if not self.options.redis_url:
self.host = self.options.redis_host
self.port = self.options.redis_port
self.password = self.options.redis_password
self.db = self.options.redis_db
else:
# according to https://devcenter.heroku.com/articles/redistogo
parsed_url = urlparse.urlparse(self.options.redis_url)
self.host = parsed_url.hostname
self.port = int(parsed_url.port)
self.db = 0
self.password = parsed_url.password
self.connection_check = PeriodicCallback(self.check_connection, 1000)
self._need_reconnect = False
self.subscriber = toredis.Client(io_loop=self.io_loop)
self.publisher = toredis.Client(io_loop=self.io_loop)
self.worker = toredis.Client(io_loop=self.io_loop)
if self.options.redis_api:
self.listener = toredis.Client(io_loop=self.io_loop)
self.subscriptions = {}
def __init__(self, application):
super(PubSub, self).__init__(application)
self.subscriber = toredis.Client()
self.publisher = toredis.Client()
self._need_reconnect = False
self.host = None
self.port = None
self.db = None
self.connection_check = None
def initialize(self):
settings = self.config.get('settings', {})
self.host = settings.get("host", "localhost")
self.port = settings.get("port", 6379)
self.db = settings.get("db", 0)
self.client = toredis.Client(io_loop=self.io_loop)
self.client.state = self
self.connection_check = PeriodicCallback(self.check_connection, 1000)
self.connect()
logger.info("Redis State initialized")
def __init__(self, *args, **kwargs):
super(MessageHandler, self).__init__(*args, **kwargs)
# The redis server
self.r_client = r_client
# The toredis server that allows event-based message handling
self.toredis = toredis.Client()
self.toredis.connect()
self.channel = None
self.channel_messages = None
def __init__(self,
host="localhost",
port=6379,
io_loop=None,
fake=False,
presence_timeout=60,
history_size=20):
self.host = host
self.port = port
self.io_loop = io_loop
self.fake = fake
self.client = None
self.presence_timeout = presence_timeout
self.history_size = history_size
self.client = toredis.Client(io_loop=self.io_loop)
self.client.state = self
self.connection_check = PeriodicCallback(self.check_connection, 1000)
def __init__(self, group, forwarder=None):
self.toredis = toredis.Client()
self.toredis.connect()
self._listening_to = {}
self.group = group
self.group_children = _children_key(group)
self.group_pubsub = _pubsub_key(group)
if forwarder is None:
self.forwarder = lambda x: None
else:
self.forwarder = forwarder
self.listen_for_updates()
for node in self.traverse(self.group):
self.listen_to_node(node['id'])
def redis_connect(self,
redis_host,
redis_port,
redis_password,
redis_db,
callback=None,
io_loop=None):
self.redis = toredis.Client(io_loop=io_loop)
redis_select = partial(self.redis.select,
index=redis_db,
callback=partial(callback, self))
if redis_password:
redis_auth = partial(self.redis.auth,
password=redis_password,
callback=redis_select)
else:
redis_auth = redis_select
self.redis.connect(host=redis_host,
port=redis_port,
callback=redis_auth)
def prepare_redis(self):
self.client = toredis.Client()
self.client.connect(host=REDIS_HOST,
callback=lambda: log.debug(f"Connected to Redis"))
def __init__(self,
api_key,
api_secret,
domain='rest.nexmo.com',
endpoint='sms/json',
ssl=False,
long_virtual_number=None,
dlr_url=None,
development_mode=False,
message=None,
sender=None,
request_path='/message/',
limit_amount=10,
limit_expires=3600,
guess_country=True,
default_country='DE',
redis_host='localhost',
redis_port=6379,
redis_password='',
redis_db=0,
callback=None,
io_loop=None):
# Handlers defining the URL scheme.
handlers = [
(r"/validate_number/",
type(
'ConfiguredNumberValidationHandler',
(handler.NumberValidationHandler, ), {
'limit_amount': limit_amount,
'limit_expires': limit_expires,
'guess_country': guess_country,
'default_country': default_country
})),
] + self.parse_handler_from_config(limit_amount, limit_expires,
guess_country, default_country)
if dlr_url:
handlers += [(urlparse(dlr_url).path, handler.DLRHandler)]
if message and sender and request_path and not request_path in configuration.SIMPLE_MESSAGE_HANDLERS:
handlers += [
self.get_default_handler(message, sender, request_path,
limit_amount, limit_expires,
guess_country, default_country)
]
logging.debug('Registered handler: {}'.format(handlers))
# Setup Nexmo client.
self.nexmo_client = nexmoclient.AsyncNexmoClient(
api_key, api_secret, domain, endpoint, ssl, long_virtual_number,
dlr_url, development_mode)
# Load GeoIP database.
self.geo_ip = pygeoip.GeoIP('GeoIP.dat', pygeoip.MEMORY_CACHE)
self.geo_ipv6 = pygeoip.GeoIP('GeoIPv6.dat', pygeoip.MEMORY_CACHE)
# Configure application settings.
settings = {'gzip': True}
# Call super constructor to initiate a Tornado Application.
tornado.web.Application.__init__(self, handlers, **settings)
# Set members for later access.
self.limit_amount = limit_amount
self.limit_expires = limit_expires
# Create db connection.
self.redis_host = redis_host
self.redis_port = redis_port
self.redis_password = redis_password
self.redis_db = redis_db
self.io_loop = io_loop
self.redis = toredis.Client(io_loop=io_loop)
self.redis_connect(redis_host,
redis_port,
redis_password,
redis_db,
callback=callback,
io_loop=io_loop)
