def main():
app = tornado.web.Application(
[
(r"/login", LoginHandler),
(r"/logout", LogoutHandler),
(r"/", MainHandler),
],
CONNECTION_POOL=tornadoredis.ConnectionPool(
host=options['REDIS_DB_HOST'],
port=options['REDIS_DB_PORT'],
max_connections=100,
wait_for_available=True),
cookie_secret="$1$uDOOIHw4$112sF6/JLaN6FYyAy6DmQ0",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=False,
debug=True)
# app.sentry_client = AsyncSentryClient(
# 'http://*****:*****@202.103.191.86:9000/2'
# )
app.listen(options.PORT, options.WEB_SERVER_IP)
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.start()
def redis_store_connection_pool():
return tornadoredis.ConnectionPool(
host=options.redis_hostname,
port=options.redis_port,
max_connections=250,
wait_for_available=True
)
def handle(self, *args, **options):
# connect to redis
url = urlparse.urlparse(settings.REDIS_URL)
pool = tornadoredis.ConnectionPool(host=url.hostname, port=url.port)
redis_connection = tornadoredis.Client(connection_pool=pool,
password=url.password)
redis_connection.connect()
sys.stdout.write("\nConnected to Redis ({}) \n".format(url))
redis_connection.psubscribe(
"*", lambda message: redis_connection.listen(
connections.MainConnection.pubsub_message))
# enable sockjs routing
router = SockJSRouter(
connections.MainConnection,
'/chat',
dict(disabled_transports=DISABLED_TRANSPORTS),
)
app = web.Application(
router.urls,
"0.0.0.0",
)
app.listen(IO_PORT)
sys.stdout.write("\nApp listening at port {}\n".format(IO_PORT))
sys.stdout.flush()
ioloop.IOLoop.instance().start()
def __init__(self):
handlers = URLS
settings = dict(
login_url="/",
# 服务器进程将会重新启动, 文件改变
# autoreload=True,
# 设置成调试模式
# debug=True,
xsrf_cookies=True,
# xheaders=True,
# 设定 cookie_secret, 用于 secure_cookie
cookie_secret="UqOmbxPmT5C2DdxhpL0NIkF/DhV/jkOovm9AO2s5Fy8=",
# 设定 session_secret 用于生成 session_id
template_path=TEMPLATE_PATH,
static_path=STATIC_PATH,
CONNECTION_POOL=tornadoredis.ConnectionPool(
host=options.REDIS_DB_HOST,
port=options.REDIS_DB_PORT,
max_connections=100,
wait_for_available=True),
)
tornado.web.Application.__init__(self, handlers, **settings)
self.db = torndb.Connection(host=options.mysql_host,
database=options.mysql_database,
user=options.mysql_user,
password=options.mysql_password)
def fetcher(options, fetcher_concurrent, stop_flag, use_curl=False):
"""Фетчер берёт ссылки из редиса, созданные воркерами, и выполняет запросы
к внешним ресурсам асинхронно, далее складывает их в редис на обработку воркерами.
Логирование через обработчик MongoHandler блокирует основной поток IOLoop.
Сделано так из-за маленькой задержки на логирование, создание неблокирующего
логера несет лишние накладные расходы.
"""
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_DFL)
pool = tornadoredis.ConnectionPool(fetcher_concurrent,
wait_for_available=True,
host=options.redis_host,
port=options.redis_port)
pid = os.getpid()
logger.info('Fetcher is started. Redis connection {}:{}'.format(
options.redis_host, options.redis_port))
@coroutine
def fetch(i):
tr_client = tornadoredis.Client(connection_pool=pool)
while not stop_flag.value:
try:
url = yield Task(tr_client.brpop, cns.URL_QUEUE_KEY,
cns.BLOCKING_TIMEOUT)
url = url[cns.URL_QUEUE_KEY]
logger.debug('Coroutine {} got url {}'.format(i, url))
client = AsyncHTTPClient()
response = yield client.fetch(url)
if response.body:
data_key = cns.DATA_KEY_PREFIX + url
pipeline = tr_client.pipeline(transactional=True)
pipeline.lpush(cns.DATA_QUEUE_KEY, data_key)
pipeline.set(data_key, response.body.decode())
yield Task(pipeline.execute)
logger.debug("Coroutine {} request time: {}. {}".format(
i, response.request_time, url))
except:
logger.exception('Coroutine {} error with url {}'.format(
i, url))
logger.info('Coroutine {} is stopped'.format(i))
@coroutine
def main():
logger.info('Start {} concurrent requests'.format(fetcher_concurrent))
yield [fetch(i) for i in range(1, fetcher_concurrent + 1)]
if use_curl:
AsyncHTTPClient.configure(
"tornado.curl_httpclient.CurlAsyncHTTPClient",
defaults=dict(max_clients=fetcher_concurrent,
request_timeout=cns.REQUEST_TIMEOUT,
connect_timeout=cns.CONNECT_TIMEOUT))
tornado.ioloop.IOLoop.current().run_sync(main)
logger.info('Stopped. IOloop shutdown.')
class TornadoRedisConnection(object):
CONNECTION_POOL = tornadoredis.ConnectionPool(max_connections=500,
wait_for_available=True)
_client = None
@classmethod
def load_cache(cls):
if not cls._client:
cls._client = tornadoredis.Client(
connection_pool=cls.CONNECTION_POOL, **cache_para_dict)
return cls._client
def __init__(self,
socket_path="/updates",
websockets=True,
subscriptions=None,
redis_host="127.0.0.1",
redis_port=6379,
exit_gracefully=True,
debug=False):
"""
RedisVisualization server. Servers updates from redis using websockets
and also provide static files using Tornado.
Inputs
------
@socket_path str : where should client ask for redis updates (default = '/updates')
@websockets bool : use websockets ? (default = True)
@subscriptions list<str> : what to subscribe to on Redis (default=['namespace_*', 'updates_*'])
@redis_host str : what hostname is redis server on (default='127.0.0.1')
@redis_port int : what port to listen to for redis server (default=6379)
@exit_gracefully bool : capture SIGINT event & shut down server from ioloop (default=True)
"""
self.exit_gracefully = exit_gracefully
if subscriptions is None:
subscriptions = ["updates_*"]
# 2. Start a connection pool to redis:
pool = tornadoredis.ConnectionPool(host=redis_host, port=redis_port)
self.clients = tornadoredis.Client(connection_pool=pool, password="")
init_redis(tornadoredis.Client(connection_pool=pool, password=""))
self.clients.connect()
get_redis().connect()
# make sure redis reports expiration and set events:
try:
self.clients.psubscribe(
subscriptions,
lambda msg: self.clients.listen(Connection.pubsub_message))
except tornadoredis.exceptions.ConnectionError:
print("""
Could not connect to Redis. Start server with:
> redis-server
""")
signal_handler(None, None)
try_exit()
if not websockets:
Router = SockJSRouter(Connection, socket_path,
dict(disabled_transports=['websocket']))
else:
Router = SockJSRouter(Connection, socket_path)
# 4. Creater router for http + sockets:
self.App = tornado.web.Application(
generate_routes(debug) + Router.urls)
def __init__(self):
settings = dict(cookie_secret=setting.COOKIE_STR,
template_path=setting.TEMPLATE,
static_path=setting.STATIC,
login_url="/login",
debug=setting.DEBUG)
logging.error(urls)
super(Application, self).__init__(urls, **settings)
self.db = motor.MotorClient(setting.MONGO_URI)[setting.MONGO_DB]
pool = tornadoredis.ConnectionPool(max_connections=100,
wait_for_available=True,
host='localhost',
port=6379)
self.rdc = tornadoredis.Client(connection_pool=pool)
def __init__(self, **kwargs):
kwargs["cfg"] = {
"mysql": {
'host': 'localhost',
'database': 'mysql',
'user': '******',
'password': '******'
},
"redis": {
'max_connections': cpu_count()
}
}
kwargs["redis"] = tornadoredis.ConnectionPool(
wait_for_available=True,
max_connections=kwargs["cfg"]["redis"]["max_connections"])
handlers = [(r"/", IndexHandler, kwargs), (r"/ls", CmdHandler)]
tornado.web.Application.__init__(self, handlers)
def main():
app = tornado.web.Application(
[
(r"/login", LoginHandler),
(r"/logout", LogoutHandler),
(r"/", MainHandler),
(r"/blacklist", BlackListHandler),
(r"/customer", CustomerManagerHandler),
(r"/customer/(.*)", CustomerDetailHandler),
(r"/ips", IpManagerHandler),
(r"/ips/umail", UmailHandler),
(r"/report", ReportHandler),
(r"/task", TaskHandler),
(r"/task/([0-9\.]{7,15})", TaskDetailHandler),
(r"/check", CheckHandler),
(r"/check/([0-9\.]{7,15})", CheckDetailHandler),
],
CONNECTION_POOL=tornadoredis.ConnectionPool(
host=options['REDIS_DB_HOST'],
port=options['REDIS_DB_PORT'],
max_connections=100,
wait_for_available=True),
cookie_secret="$1$uDOOIHw4$112sF6/JLaN6FYyAy6DmQ0",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=False,
debug=True)
app.sentry_client = AsyncSentryClient(
'http://*****:*****@202.103.191.86:9000/2'
)
app.listen(options.PORT, options.WEB_SERVER_IP)
ioloop = tornado.ioloop.IOLoop.instance()
#初始化数据库(注:保留客户列表和客户ips)
initialize()
# 接收邮件确认链接
email_check(ioloop)
# 调度任务
schedule(ioloop)
ioloop.start()
class AsyncRedis(object):
# 设置连接池
CONNECTION_POOL = tornadoredis.ConnectionPool(
max_connections=int(properties.get('redis', 'REDIS_MAX_CONNNECTION')),
wait_for_available=True,
host=properties.get("redis", "REDIS_HOST"),
port=int(properties.get('redis', 'REDIS_PORT')))
@tornado.gen.coroutine
def get_conn(self):
"""
获取redis客户端链接
:return:
"""
resource = tornadoredis.Client(connection_pool=self.CONNECTION_POOL)
raise tornado.gen.Return(resource)
@tornado.gen.coroutine
def set(self, key, value, second=0):
"""
存储数据
:param key:
:param value:
:param second:
:return:
"""
resource = None
try:
# 使用管道设置值
resource = yield self.get_conn()
with resource.pipeline() as pipe:
pipe.set(key, value)
if second > 0:
pipe.expire(key, int(second))
yield tornado.gen.Task(pipe.execute)
except Exception, e:
print e
finally:
import tornadoredis
CONNECTION_POOL = tornadoredis.ConnectionPool(
max_connections=100, wait_for_available=True) #使用数据库连接池
c = tornadoredis.Client(host='localhost',
port=6379,
connection_pool=CONNECTION_POOL)
c.set('name', 'femn')
print(c.get('name'))
REDIS_CHANNEL = None
define('port', default=8888, help='run on the given port', type=int)
logging.basicConfig(filename='younoty-error.log',
format='%(asctime)s %(message)s',
level=logging.DEBUG,
filemode="a+") #configurazione file log
#logging = logging.getLogger('base.tornado')
# store clients in dictionary..
clients = dict() #BISOGNA MAPPARE OGNI ATTIVITA SU UN PROCESSO
pool = tornadoredis.ConnectionPool(host=REDIS_SERVER,
port=REDIS_PORT,
max_connections=20,
wait_for_available=True)
"""
SENDER Handler
127.0.0.0.1:8888/msg?message={"client_id":"158","att_id":"13", "msg":"hello there"}
client_id = receiver id
att_id = channel id
127.0.0.0.1:8888/msg?message=eyJjbGllbnRfaWQiOiIxNTgiLCJhdHRfaWQiOiIxMyIsICJtc2ciOiJoZWxsbyB0aGVyZSJ9
if client is offline store notification into redis list
else send publish command with message to subscriber
class AsyncRedis:
# 设置连接池
CONNECTION_POOL = tornadoredis.ConnectionPool(
max_connections=REDIS_MAX_CONNECTION,
wait_for_available=True,
host=REDIS_HOST,
port=REDIS_PORT)
def get_conn(self):
"""
获取redis客户端链接
:return:
"""
resource = tornadoredis.Client(connection_pool=self.CONNECTION_POOL,
password=REDIS_PASS)
return resource
@tornado.gen.coroutine
def set(self, key, value, second=0):
"""
存储数据
:param key:
:param value:
:param second:
:return:
"""
resource = None
result = False
try:
# 使用管道设置值
resource = self.get_conn()
with resource.pipeline() as pipe:
pipe.set(key, value)
if second > 0:
pipe.expire(key, int(second))
result = yield tornado.gen.Task(pipe.execute)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def get(self, key):
"""
获取内存数据
:param key:
:return:
"""
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.get, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def exists(self, key):
"""
查询值是否存在
:param key:
:return:
"""
resource = None
value = False
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.exists, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def hmget(self, key, fields):
"""
批量获取map中指定区域的值
:param key:
:param fields
:return:
"""
resource = None
value = False
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.hmget, key, fields)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def hmset(self, key, value, second=0):
"""
:author: onlyfu
:param key:
:param value:
:param second:
:return:
"""
resource = None
result = False
try:
# 使用管道设置值
resource = self.get_conn()
with resource.pipeline() as pipe:
pipe.hmset(key, value)
if second > 0:
pipe.expire(key, int(second))
result = yield tornado.gen.Task(pipe.execute)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def hset(self, key, field, value):
"""
:author: maozhufeng
:param key: redis键值
:param field: hashmap中键值
:param value:
:return:
"""
resource = None
result = False
try:
# 使用管道设置值
resource = self.get_conn()
with resource.pipeline() as pipe:
pipe.hset(key, field, value)
result = yield tornado.gen.Task(pipe.execute)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def hget(self, key, field):
"""
:author: maozhufeng
:param key: redis键值
:param field: hashmap中键值
:return:
"""
resource = None
result = None
try:
# 使用管道设置值
resource = self.get_conn()
with resource.pipeline() as pipe:
pipe.hget(key, field)
result = yield tornado.gen.Task(pipe.execute)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
if isinstance(result, list):
result = result[0]
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def hdel(self, key, field, *args):
"""
:author: maozhufeng
:param key: redis键值
:param field: hashmap中键值
:return:
"""
resource = None
result = None
try:
# 使用管道设置值
resource = self.get_conn()
with resource.pipeline() as pipe:
pipe.hdel(key, field, args)
result = yield tornado.gen.Task(pipe.execute)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
if isinstance(result, list):
result = result[0]
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def hgetall(self, key):
"""
:author: onlyfu
:param key:
:return:
"""
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.hgetall, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def hincrby(self, key, field, increment=1):
"""
:author: onlyfu
:param key:
:return:
"""
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.hincrby, key, field,
increment)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def mget(self, key):
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.mget, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def ttl(self, key):
"""
:author: onlyfu
if key not exist return None
:param key:
:return:
"""
resource = None
value = -2
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.ttl, key)
value = -1 if value is None else value
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def expire(self, key, second=0):
"""
:author: onlyfu
:param key:
:param second:
:return:
"""
result = False
resource = None
try:
# 使用管道设置值
resource = self.get_conn()
result = yield tornado.gen.Task(resource.expire, key, int(second))
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def incr(self, key, amount=1):
resource = None
value = 0
try:
# 使用管道设置值
resource = self.get_conn()
value = yield tornado.gen.Task(resource.incrby, key, amount)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def decr(self, key, amount=1):
resource = None
value = 0
try:
# 使用管道设置值
resource = self.get_conn()
value = yield tornado.gen.Task(resource.decrby, key, amount)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def sadd(self, key, value, *args):
resource = None
# 未操作成功默认返回0，操作成功返回1
result = 0
try:
# 使用管道设置值
resource = self.get_conn()
result = yield tornado.gen.Task(resource.sadd, key, value, *args)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def scard(self, key):
resource = None
# 未操作成功默认返回0
result = 0
try:
# 使用管道设置值
resource = self.get_conn()
result = yield tornado.gen.Task(resource.scard, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def smembers(self, key):
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.smembers, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def spop(self, key):
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.spop, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def srem(self, key, value):
resource = None
result = None
try:
resource = self.get_conn()
result = yield tornado.gen.Task(resource.srem, key, value)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def delete(self, key, *args):
"""
删除内存中值
:param key:
:return:
"""
resource = None
result = False
try:
resource = self.get_conn()
with resource.pipeline() as pipe:
pipe.delete(key, *args)
result = yield tornado.gen.Task(pipe.execute)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def lpush(self, key, value, *args):
resource = None
result = 0
try:
# 使用管道设置值
resource = self.get_conn()
result = yield tornado.gen.Task(resource.lpush, key, value, *args)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def rpush(self, key, value, *args):
resource = None
result = 0
try:
resource = self.get_conn()
result = yield tornado.gen.Task(resource.rpush, key, value, *args)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(result)
@tornado.gen.coroutine
def rpop(self, key):
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.rpop, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def llen(self, key):
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.llen, key)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
@tornado.gen.coroutine
def lrange(self, key, start, end):
resource = None
value = None
try:
resource = self.get_conn()
value = yield tornado.gen.Task(resource.lrange, key, start, end)
except Exception as e:
logger.exception(e)
finally:
yield tornado.gen.Task(resource.disconnect)
raise tornado.gen.Return(value)
class BaseSocketHandler(SockJSConnection):
"""
Base client-server logic implementation.
"""
_bindings = {}
_bindings['connections_by_user_id'] = {}
_bindings['users_by_id'] = {}
_bindings['user_available_channels'] = {}
_bindings['channel_connected_users'] = {}
_bindings['online_users'] = set()
_bindings['typing'] = {}
_bindings['avatars'] = {}
_participants = set()
_pending_futures = {}
REDIS_CONNECTION_POOL = tornadoredis.ConnectionPool(
max_connections=10, wait_for_available=True)
db = db
def __init__(self, *args, **kwargs):
self.logger = logger
super(BaseSocketHandler, self).__init__(*args, **kwargs)
self.db = db
def on_open(self, request):
self.user = None
self._participants.add(self)
@gen.coroutine
def on_message(self, msg):
"""Message receiver"""
msg = self.parse_message(msg)
logging.debug(msg)
event = msg.get('event', None)
kwargs = msg.get('kwargs', {})
acknowledge = msg.get('acknowledge', None)
print BaseSocketHandler._pending_futures.keys(
), acknowledge in BaseSocketHandler._pending_futures.keys()
if event != 'ack_callback':
if not hasattr(self, event):
raise Exception
future = getattr(self, event)(**kwargs)
print acknowledge, event
complete_callback = partial(self.on_event_complete,
*(acknowledge, event))
ioloop.IOLoop.current().add_future(future, complete_callback)
elif event == 'ack_callback' and acknowledge and acknowledge in BaseSocketHandler._pending_futures.keys(
):
future = BaseSocketHandler._pending_futures.pop(acknowledge)
future.set_result(kwargs)
future.done()
def on_close(self):
"""Close socket connection to client"""
self._participants.remove(self)
if self.user:
connections_by_user_id = BaseSocketHandler._bindings[
'connections_by_user_id'].get(self.user.id, [])
if self in connections_by_user_id:
logger.debug(['Closing connection', self.user])
connections_by_user_id.remove(self)
if connections_by_user_id:
BaseSocketHandler._bindings['connections_by_user_id'][
self.user.id] = connections_by_user_id
else:
ioloop.IOLoop.current().spawn_callback(
self.propagate_user_statuses,
**{'offline': self.user.id})
@gen.coroutine
def on_event_complete(self, acknowledge, event, future):
result = future.result()
self.send({
'acknowledge': acknowledge,
'event': event,
'type': 'message',
'result': result
})
def remove_pending_future(self, acknowledge):
if acknowledge in BaseSocketHandler._pending_futures.keys():
BaseSocketHandler._pending_futures.pop(acknowledge)
@gen.coroutine
def emit(self, event, data, ack_callback=None):
acknowledge = str(uuid.uuid4())
self.send({
'acknowledge': acknowledge,
'type': 'event',
'event': event,
'data': data
})
if ack_callback:
future = gen.Future()
BaseSocketHandler._pending_futures[acknowledge] = future
ioloop.IOLoop.current().add_future(future, ack_callback)
ioloop.IOLoop.current().add_timeout(timezone.timedelta(minutes=1),
self.remove_pending_future,
*(acknowledge, ))
@gen.coroutine
def propagate_user_statuses(self, online=None, offline=None):
if online:
BaseSocketHandler._bindings['online_users'].add(online)
if offline:
try:
BaseSocketHandler._bindings['online_users'].remove(offline)
except:
pass
logging.error(BaseSocketHandler._participants)
for x in BaseSocketHandler._participants:
x.emit(
'online_statuses',
json.dumps(list(BaseSocketHandler._bindings['online_users'])))
# members_all_cursor = yield self.db.execute(QUERIES.MEMBERS_OF_ANY_CHANNEL)
# print members_all_cursor.fetchall()
def authenticate_user(self, data):
user = None
try:
backend = SocketJWTAuthentication()
user, _ = backend.authenticate(data)
except Exception as e:
raise e
return user
def render_message(self, msg):
return JSONRenderer().render(msg)
@staticmethod
def cls_render_message(msg):
return JSONRenderer().render(msg)
def parse_message(self, msg):
return JSONParser().parse(BytesIO(msg.encode('utf-8')))
import tornadoredis
import urls
from tornado import gen, web, ioloop
POOL = tornadoredis.ConnectionPool(host='127.0.0.1', port=6379)
db = tornadoredis.Client(connection_pool=POOL)
db.connect()
if __name__ == "__main__":
if gen.Task(db.exists, 'id_order'):
pass
else:
db.set('id_order', 1)
application = web.Application(urls.urls)
application.listen(8000)
ioloop.IOLoop.current().start()
import logging
import os
from tornado_mysql import pools
from tornado_mysql.cursors import DictCursor
import tornadoredis
__author__ = 'qingfeng'
pools.DEBUG = False
POOL = pools.Pool(
dict(host=os.getenv("DB_HOST", "localhost"),
port=int(os.getenv("DB_PORT", "3306")),
user=os.getenv("DB_USER", "root"),
passwd=os.getenv("DB_PASS", "toor"),
db=os.getenv("DB_NAME", "eleme"),
cursorclass=DictCursor),
max_idle_connections=2000,
max_recycle_sec=3,
max_open_connections=5000,
)
REDIS_CONNECTION_POOL = tornadoredis.ConnectionPool(max_connections=3000,
wait_for_available=True)
#!/usr/bin/env python3
import redis
import tornadoredis
from urllib.parse import urlparse
from tornado import gen
from random import random
from webtools import req_gen
from time import time
connection_pool = tornadoredis.ConnectionPool()
def redis_client():
return tornadoredis.Client(connection_pool=connection_pool)
def time_mapper(t):
'''
return 0.0 for empty value
'''
if nonetest(t) is False:
return 0.0
return float(t)
def nonetest(s):
'''
return False if s is None
'''
if s is None or s == "":
def __init__(self):
super(Chat, self).__init__(urls, **settings)
self.connection_pool = tornadoredis.ConnectionPool(**db_pool_settings)
def _new_pool(self, **connection_params):
connection_params.setdefault('io_loop', self.io_loop)
connection_params.setdefault('max_connections', 2)
return tornadoredis.ConnectionPool(**connection_params)
def __init__(self):
CONNECTION_POOL = tornadoredis.ConnectionPool(max_connections=500,
wait_for_available=True)
self.redis = tornadoredis.Client(host="127.0.0.1",
port="6379",
connection_pool=CONNECTION_POOL)
import tornado.web
import tornado.ioloop
import tornado.gen
import logging
import redis
PY3 = sys.version > '3'
if PY3:
xrange = range
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger('app')
POOL_ASYNC = tornadoredis.ConnectionPool(max_connections=500,
wait_for_available=True)
REDIS_CLIENT = redis.Redis()
class AsyncIncr(tornado.web.RequestHandler):
client_kwargs = {}
@tornado.web.asynchronous
@tornado.gen.engine
def get(self):
kk = ('f', 'b', 'z')
cc = [tornadoredis.Client(**self.client_kwargs) for __ in kk]
vals = yield [tornado.gen.Task(c.incr, k) for c, k in zip(cc, kk)]
foo, bar, zar = ['%08d' % v for v in vals]
self.set_header('Content-Type', 'text/html')
