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