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')