def get_address(): try: address = socket.gethostbyname(socket.gethostname()) except Exception as err: logger.warning(err) address = "?" return address
def get_address(): try: address = socket.gethostname() except Exception as err: logger.warning(err) address = "?" return address
def get_host(): try: host = socket.gethostbyname(socket.gethostname()) except Exception as err: logger.warning(err) host = "?" return host
def main(): try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning("Application started without configuration file.\n" "This is normal only during development") custom_settings = {} ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "templates")), static_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "static")), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings) handlers = create_application_handlers() try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) # create references to application from SockJS handlers AdminSocketHandler.application = app Client.application = app app.initialize() # summarize run configuration writing it into logger logger.info("Tornado port: {0}".format(options.port)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info('interrupted') finally: # clean if hasattr(app, 'pub_stream'): app.pub_stream.close() if hasattr(app, 'sub_stream'): app.sub_stream.stop_on_recv() app.sub_stream.close()
def main(): try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning( "Application started without configuration file.\n" "This is normal only during development" ) custom_settings = {} ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "templates") ), static_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "static") ), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings ) handlers = create_application_handlers() try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) # create references to application from SockJS handlers AdminSocketHandler.application = app Client.application = app app.initialize() # summarize run configuration writing it into logger logger.info("Tornado port: {0}".format(options.port)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info('interrupted') finally: # clean if hasattr(app, 'pub_stream'): app.pub_stream.close() if hasattr(app, 'sub_stream'): app.sub_stream.stop_on_recv() app.sub_stream.close()
def main(): tornado.options.parse_command_line() try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning( "Application started without configuration file.\n" "This is normal only during development and if you\n" "want to use MongoDB as data storage.\n" ) custom_settings = {} database_settings = custom_settings.get('storage', {}) # detect and apply database storage module storage_module = database_settings.get( 'module', 'centrifuge.storage.mongodb' ) storage = utils.import_module(storage_module) ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "templates") ), static_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "static") ), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=custom_settings ) try: app = Application(settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) # create unique uid for this application app.uid = uuid.uuid4().hex state = State(app) centrifuge.handlers.state = state centrifuge.web.handlers.state = state centrifuge.rpc.state = state state.set_storage(storage) def run_periodic_state_update(): state.update() periodic_state_update = tornado.ioloop.PeriodicCallback( state.update, custom_settings.get('state_update_interval', 30000) ) periodic_state_update.start() ioloop_instance.add_callback( functools.partial( storage.init_db, state, database_settings.get('settings', {}), run_periodic_state_update ) ) app.zmq_pub_sub_proxy = options.zmq_pub_sub_proxy context = zmq.Context() # create PUB socket to publish instance events into it publish_socket = context.socket(zmq.PUB) # do not try to send messages after closing publish_socket.setsockopt(zmq.LINGER, 0) if app.zmq_pub_sub_proxy: # application started with XPUB/XSUB proxy app.zmq_xsub = options.zmq_xsub publish_socket.connect(app.zmq_xsub) else: # application started without XPUB/XSUB proxy if options.zmq_pub_port_shift: # calculate zmq pub port number zmq_pub_port = options.port + options.zmq_pub_port_shift else: zmq_pub_port = options.zmq_pub_port app.zmq_pub_port = zmq_pub_port publish_socket.bind( "tcp://%s:%s" % (options.zmq_pub_listen, str(app.zmq_pub_port)) ) # wrap pub socket into ZeroMQ stream app.pub_stream = ZMQStream(publish_socket) # create SUB socket listening to all events from all app instances subscribe_socket = context.socket(zmq.SUB) if app.zmq_pub_sub_proxy: # application started with XPUB/XSUB proxy app.zmq_xpub = options.zmq_xpub subscribe_socket.connect(app.zmq_xpub) else: # application started without XPUB/XSUB proxy app.zmq_sub_address = options.zmq_sub_address for address in app.zmq_sub_address: subscribe_socket.connect(address) subscribe_socket.setsockopt_string( zmq.SUBSCRIBE, six.u(create_control_channel_name()) ) def listen_control_channel(): # wrap sub socket into ZeroMQ stream and set its on_recv callback app.sub_stream = ZMQStream(subscribe_socket) handle = functools.partial(handle_control_message, app) app.sub_stream.on_recv(handle) ioloop_instance.add_callback(listen_control_channel) app.event_callbacks = [] callbacks = custom_settings.get('event_callbacks', []) for callback in callbacks: event_callback = utils.namedAny(callback) app.event_callbacks.append(event_callback) if not hasattr(app, 'admin_connections'): # initialize dict to keep admin connections app.admin_connections = {} if not hasattr(app, 'connections'): # initialize dict to keep client's connections app.connections = {} if not hasattr(app, 'back_off'): # initialize dict to keep back-off information for projects app.back_off = {} logger.info("Application started") logger.info("Tornado port: {0}".format(options.port)) if app.zmq_pub_sub_proxy: logger.info( "ZeroMQ XPUB: {0}, XSUB: {1}".format( app.zmq_xpub, app.zmq_xsub, ) ) else: logger.info( "ZeroMQ PUB - {0}; subscribed to {1}".format( app.zmq_pub_port, app.zmq_sub_address ) ) logger.info("Storage module: {0}".format(storage_module)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info('interrupted') finally: # clean if hasattr(app, 'pub_stream'): app.pub_stream.close() if hasattr(app, 'sub_stream'): app.sub_stream.on_recv(None) app.sub_stream.close()
def main(): try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning("Application started without configuration file.\n" "This is normal only during development") custom_settings = {} ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "templates")), static_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "static")), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings) sockjs_settings = custom_settings.get("sockjs_settings", {}) handlers = create_application_handlers(sockjs_settings) try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) logger.info("Engine class: {0}".format(engine_class_path)) app.engine = engine_class(app) logger.info("Storage class: {0}".format(storage_class_path)) app.storage = storage_class(options) # create references to application from SockJS handlers AdminSocketHandler.application = app Client.application = app app.initialize() max_channel_length = custom_settings.get('max_channel_length') if max_channel_length: app.MAX_CHANNEL_LENGTH = max_channel_length admin_api_message_limit = custom_settings.get('admin_api_message_limit') if admin_api_message_limit: app.ADMIN_API_MESSAGE_LIMIT = admin_api_message_limit client_api_message_limit = custom_settings.get('client_api_message_limit') if client_api_message_limit: app.CLIENT_API_MESSAGE_LIMIT = client_api_message_limit owner_api_project_id = custom_settings.get('owner_api_project_id') if owner_api_project_id: app.OWNER_API_PROJECT_ID = owner_api_project_id owner_api_project_param = custom_settings.get('owner_api_project_param') if owner_api_project_param: app.OWNER_API_PROJECT_PARAM = owner_api_project_param connection_expire_check = custom_settings.get('connection_expire_check', True) if connection_expire_check: app.CONNECTION_EXPIRE_CHECK = connection_expire_check connection_expire_collect_interval = custom_settings.get( 'connection_expire_collect_interval') if connection_expire_collect_interval: app.CONNECTION_EXPIRE_COLLECT_INTERVAL = connection_expire_collect_interval connection_expire_check_interval = custom_settings.get( 'connection_expire_check_interval') if connection_expire_check_interval: app.CONNECTION_EXPIRE_CHECK_INTERVAL = connection_expire_check_interval logger.info("Tornado port: {0}".format(options.port)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info('interrupted') finally: # cleaning if hasattr(app.engine, 'clean'): app.engine.clean()
def create_centrifuge_application(): try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning( "No configuration file found. " "In production make sure security settings provided" ) custom_settings = {} # override security related options using environment variable # value if exists for option_name in ["password", "cookie_secret", "api_secret"]: environment_var_name = "CENTRIFUGE_{0}".format(option_name.upper()) environment_value = os.environ.get(environment_var_name) if environment_value: logger.debug("using {0} environment variable for {1} option value".format( environment_var_name, option_name )) custom_settings[option_name] = environment_value if os.environ.get("CENTRIFUGE_INSECURE") == "1": custom_settings["insecure"] = True settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "templates") ), static_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "static") ), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings ) sockjs_settings = custom_settings.get("sockjs_settings", {}) if not sockjs_settings or not sockjs_settings.get("sockjs_url"): # SockJS CDN will be retired # see https://github.com/sockjs/sockjs-client/issues/198 # if no explicit SockJS url provided in configuration file # then we use jsdelivr CDN instead of default cdn.sockjs.org # this can be fixed directly in SockJS-Tornado soon sockjs_settings["sockjs_url"] = "https://cdn.jsdelivr.net/sockjs/0.3/sockjs.min.js" handlers = create_application_handlers(sockjs_settings) # custom settings to configure the tornado HTTPServer tornado_settings = custom_settings.get("tornado_settings", {}) logger.debug("tornado_settings: %s", tornado_settings) if 'io_loop' in tornado_settings: stop_running( "The io_loop in tornado_settings is not supported for now." ) try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app, **tornado_settings) server.listen(options.port, address=options.address) except Exception as e: return stop_running(str(e)) logger.info("Engine class: {0}".format(engine_class_path)) app.engine = engine_class(app) logger.info("Storage class: {0}".format(storage_class_path)) app.storage = storage_class(options) # create reference to application from SockJS handlers AdminSocketHandler.application = app # create reference to application from Client Client.application = app app.initialize() logger.info("Tornado port: {0}, address: {1}".format(options.port, options.address)) return app
def main(): # load settings from configuration file try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning( "Application started without configuration file.\n" "This is normal only during development" ) custom_settings = {} ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "templates") ), static_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "static") ), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings ) handlers = create_application_handlers() try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) # create references to application from SockJS handlers AdminSocketHandler.application = app Client.application = app # choose PUB/SUB mechanism if options.base: from centrifuge.pubsub.base import BasePubSub as PubSub elif options.redis: from centrifuge.pubsub.redis import PubSub else: from centrifuge.pubsub.zeromq import PubSub app.pubsub = PubSub(app) app.initialize() magic_project_id = custom_settings.get('magic_project_id') if magic_project_id: app.MAGIC_PROJECT_ID = magic_project_id magic_project_param = custom_settings.get('magic_project_param') if magic_project_param: app.MAGIC_PROJECT_PARAM = magic_project_param logger.info("Tornado port: {0}".format(options.port)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info('interrupted') finally: # cleaning if hasattr(app.pubsub, 'clean'): app.pubsub.clean()
def create_centrifuge_application(): try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning("No configuration file found. " "In production make sure security settings provided") custom_settings = {} # override security related options using environment variable # value if exists for option_name in ["password", "cookie_secret", "api_secret"]: environment_var_name = "CENTRIFUGE_{0}".format(option_name.upper()) environment_value = os.environ.get(environment_var_name) if environment_value: logger.debug( "using {0} environment variable for {1} option value".format( environment_var_name, option_name)) custom_settings[option_name] = environment_value if os.environ.get("CENTRIFUGE_INSECURE") == "1": custom_settings["insecure"] = True settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "templates")), static_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "static")), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings) sockjs_settings = custom_settings.get("sockjs_settings", {}) if not sockjs_settings or not sockjs_settings.get("sockjs_url"): # SockJS CDN will be retired # see https://github.com/sockjs/sockjs-client/issues/198 # if no explicit SockJS url provided in configuration file # then we use jsdelivr CDN instead of default cdn.sockjs.org # this can be fixed directly in SockJS-Tornado soon sockjs_settings[ "sockjs_url"] = "https://cdn.jsdelivr.net/sockjs/0.3/sockjs.min.js" handlers = create_application_handlers(sockjs_settings) # custom settings to configure the tornado HTTPServer tornado_settings = custom_settings.get("tornado_settings", {}) logger.debug("tornado_settings: %s", tornado_settings) if 'io_loop' in tornado_settings: stop_running( "The io_loop in tornado_settings is not supported for now.") try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app, **tornado_settings) server.listen(options.port, address=options.address) except Exception as e: return stop_running(str(e)) logger.info("Engine class: {0}".format(engine_class_path)) app.engine = engine_class(app) logger.info("Storage class: {0}".format(storage_class_path)) app.storage = storage_class(options) # create reference to application from SockJS handlers AdminSocketHandler.application = app # create reference to application from Client Client.application = app app.initialize() logger.info("Tornado port: {0}, address: {1}".format( options.port, options.address)) return app
def main(): try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning( "Application started without configuration file.\n" "This is normal only during development" ) custom_settings = {} ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "templates") ), static_path=os.path.join( os.path.dirname(__file__), os.path.join("web/frontend", "static") ), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings ) sockjs_settings = custom_settings.get("sockjs_settings", {}) handlers = create_application_handlers(sockjs_settings) try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) logger.info("Engine class: {0}".format(engine_class_path)) app.engine = engine_class(app) logger.info("Storage class: {0}".format(storage_class_path)) app.storage = storage_class(options) # create references to application from SockJS handlers AdminSocketHandler.application = app Client.application = app app.initialize() max_channel_length = custom_settings.get('max_channel_length') if max_channel_length: app.MAX_CHANNEL_LENGTH = max_channel_length admin_api_message_limit = custom_settings.get('admin_api_message_limit') if admin_api_message_limit: app.ADMIN_API_MESSAGE_LIMIT = admin_api_message_limit client_api_message_limit = custom_settings.get('client_api_message_limit') if client_api_message_limit: app.CLIENT_API_MESSAGE_LIMIT = client_api_message_limit owner_api_project_id = custom_settings.get('owner_api_project_id') if owner_api_project_id: app.OWNER_API_PROJECT_ID = owner_api_project_id owner_api_project_param = custom_settings.get('owner_api_project_param') if owner_api_project_param: app.OWNER_API_PROJECT_PARAM = owner_api_project_param connection_expire_check = custom_settings.get('connection_expire_check', True) if connection_expire_check: app.CONNECTION_EXPIRE_CHECK = connection_expire_check connection_expire_collect_interval = custom_settings.get('connection_expire_collect_interval') if connection_expire_collect_interval: app.CONNECTION_EXPIRE_COLLECT_INTERVAL = connection_expire_collect_interval connection_expire_check_interval = custom_settings.get('connection_expire_check_interval') if connection_expire_check_interval: app.CONNECTION_EXPIRE_CHECK_INTERVAL = connection_expire_check_interval logger.info("Tornado port: {0}".format(options.port)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info('interrupted') finally: # cleaning if hasattr(app.engine, 'clean'): app.engine.clean()
def main(): tornado.options.parse_command_line() try: custom_settings = json.load(open(options.config, "r")) except IOError: logger.warning( "Application started without configuration file.\n" "This is normal only during development and if you\n" "want to use MongoDB as data storage.\n" ) custom_settings = {} database_settings = custom_settings.get("storage", {}) # detect and apply database storage module storage_module = database_settings.get("module", "centrifuge.storage.mongodb") storage = utils.import_module(storage_module) ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "templates")), static_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "static")), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=custom_settings, ) try: app = Application(settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) # create unique uid for this application app.uid = uuid.uuid4().hex state = State(app) centrifuge.handlers.state = state centrifuge.web.handlers.state = state centrifuge.rpc.state = state state.set_storage(storage) def run_periodic_state_update(): state.update() periodic_state_update = tornado.ioloop.PeriodicCallback( state.update, custom_settings.get("state_update_interval", 30000) ) periodic_state_update.start() ioloop_instance.add_callback( functools.partial(storage.init_db, state, database_settings.get("settings", {}), run_periodic_state_update) ) app.zmq_pub_sub_proxy = options.zmq_pub_sub_proxy context = zmq.Context() # create PUB socket to publish instance events into it publish_socket = context.socket(zmq.PUB) # do not try to send messages after closing publish_socket.setsockopt(zmq.LINGER, 0) if app.zmq_pub_sub_proxy: # application started with XPUB/XSUB proxy app.zmq_xsub = options.zmq_xsub publish_socket.connect(app.zmq_xsub) else: # application started without XPUB/XSUB proxy if options.zmq_pub_port_shift: # calculate zmq pub port number zmq_pub_port = options.port + options.zmq_pub_port_shift else: zmq_pub_port = options.zmq_pub_port app.zmq_pub_port = zmq_pub_port publish_socket.bind("tcp://%s:%s" % (options.zmq_pub_listen, str(app.zmq_pub_port))) # wrap pub socket into ZeroMQ stream app.pub_stream = ZMQStream(publish_socket) # create SUB socket listening to all events from all app instances subscribe_socket = context.socket(zmq.SUB) if app.zmq_pub_sub_proxy: # application started with XPUB/XSUB proxy app.zmq_xpub = options.zmq_xpub subscribe_socket.connect(app.zmq_xpub) else: # application started without XPUB/XSUB proxy app.zmq_sub_address = options.zmq_sub_address for address in app.zmq_sub_address: subscribe_socket.connect(address) subscribe_socket.setsockopt_string(zmq.SUBSCRIBE, six.u(create_control_channel_name())) def listen_control_channel(): # wrap sub socket into ZeroMQ stream and set its on_recv callback app.sub_stream = ZMQStream(subscribe_socket) handle = functools.partial(handle_control_message, app) app.sub_stream.on_recv(handle) ioloop_instance.add_callback(listen_control_channel) app.event_callbacks = [] callbacks = custom_settings.get("event_callbacks", []) for callback in callbacks: event_callback = utils.namedAny(callback) app.event_callbacks.append(event_callback) if not hasattr(app, "admin_connections"): # initialize dict to keep admin connections app.admin_connections = {} if not hasattr(app, "connections"): # initialize dict to keep client's connections app.connections = {} if not hasattr(app, "back_off"): # initialize dict to keep back-off information for projects app.back_off = {} logger.info("Application started") logger.info("Tornado port: {0}".format(options.port)) if app.zmq_pub_sub_proxy: logger.info("ZeroMQ XPUB: {0}, XSUB: {1}".format(app.zmq_xpub, app.zmq_xsub)) else: logger.info("ZeroMQ PUB - {0}; subscribed to {1}".format(app.zmq_pub_port, app.zmq_sub_address)) logger.info("Storage module: {0}".format(storage_module)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info("interrupted") finally: # clean if hasattr(app, "pub_stream"): app.pub_stream.close() if hasattr(app, "sub_stream"): app.sub_stream.on_recv(None) app.sub_stream.close()
def main(): # load settings from configuration file try: custom_settings = json.load(open(options.config, 'r')) except IOError: logger.warning("Application started without configuration file.\n" "This is normal only during development") custom_settings = {} ioloop_instance = tornado.ioloop.IOLoop.instance() settings = dict( cookie_secret=custom_settings.get("cookie_secret", "bad secret"), login_url="/auth", template_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "templates")), static_path=os.path.join(os.path.dirname(__file__), os.path.join("web/frontend", "static")), xsrf_cookies=True, autoescape="xhtml_escape", debug=options.debug, options=options, config=custom_settings) handlers = create_application_handlers() try: app = Application(handlers=handlers, **settings) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) except Exception as e: return stop_running(str(e)) # create references to application from SockJS handlers AdminSocketHandler.application = app Client.application = app # choose PUB/SUB mechanism if options.base: from centrifuge.pubsub.base import BasePubSub as PubSub elif options.redis: from centrifuge.pubsub.redis import PubSub else: from centrifuge.pubsub.zeromq import PubSub app.pubsub = PubSub(app) app.initialize() magic_project_id = custom_settings.get('magic_project_id') if magic_project_id: app.MAGIC_PROJECT_ID = magic_project_id magic_project_param = custom_settings.get('magic_project_param') if magic_project_param: app.MAGIC_PROJECT_PARAM = magic_project_param logger.info("Tornado port: {0}".format(options.port)) # finally, let's go try: ioloop_instance.start() except KeyboardInterrupt: logger.info('interrupted') finally: # cleaning if hasattr(app.pubsub, 'clean'): app.pubsub.clean()