def __init__(self, cacher):
router = TornadioRouter(Client)
self.server = None
self.cacher = cacher
self.reportUUID = uuid.uuid4().hex
self.app = tornado.web.Application(
router.apply_routes([
(r"/", MainHandler,
dict(template='index.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/offline\.html", MainHandler,
dict(template='offline.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/brief\.html$", MainHandler,
dict(template='brief.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/monitoring\.html$", MainHandler,
dict(template='monitoring.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/data\.json$", JsonHandler,
dict(reportUUID=self.reportUUID, cacher=cacher)),
]),
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
debug=True,
)
def handle(self, *args, **options):
if settings.DEBUG:
import logging
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
if len(args) > 1:
raise CommandError('Usage is runserver_tornadio2 %s' % self.args)
if len(args) == 1:
port = args[0]
else:
port = settings.SOCKETIO_PORT
# Setup event handlers
for Cls in load_classes(settings.SOCKETIO_CLASSES):
mixin(BaseSocket, Cls)
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
wsgi_app = get_wsgi_application()
app_handler = WSGIContainer(StaticFilesHandler(wsgi_app))
router = TornadioRouter(
BaseSocket,
{'enabled_protocols': ['websocket', 'xhr-polling', 'htmlfile']})
settings.SOCKETIO_GLOBALS['server'] = router.urls[0][2]['server']
# A map of user IDs to their active connections.
settings.SOCKETIO_GLOBALS['connections'] = defaultdict(set)
application = Application(
router.urls + [
# Uncomment next line to handle static files through Tornado rather than Django or externally.
#(r'/static/(.*)', StaticFileHandler, {'path': settings.STATICFILES_DIRS[0]}),
(r'/admin$', RedirectHandler, {
'url': '/admin/',
'permanent': True
}),
# You probably want to comment out the next line if you have a login form.
(r'/accounts/login/.*', RedirectHandler, {
'url': '/admin/',
'permanent': False
}),
(r'.*', FallbackHandler, {
'fallback': app_handler
}),
],
#flash_policy_port = 843,
#flash_policy_file = 'flashpolicy.xml', # TODO: Do we need this? TAA - 2012-03-07.
socket_io_port=port,
xsrf_cookies=False,
)
ssl_options = {
'certfile': settings.SSL_CERTFILE,
'keyfile': settings.SSL_KEYFILE,
}
SocketServer(application, ssl_options=ssl_options)
def main():
print "Server IP Address:", GetMyIPAddr()
# Create TornadIO2 router
router = TornadioRouter(ChatConnection)
# Create Tornado application with urls from router
app = web.Application(router.urls,
socket_io_port=CONFIG.PORT,
flash_policy_file='flashpolicy.xml')
SocketServer(app)
def start_warrior_server(warrior,
bind_address="",
port_number=8001,
http_username=None,
http_password=None):
SeesawConnection.warrior = warrior
warrior.on_projects_loaded += SeesawConnection.handle_projects_loaded
warrior.on_project_refresh += SeesawConnection.handle_project_refresh
warrior.on_project_installing += SeesawConnection.handle_project_installing
warrior.on_project_installed += SeesawConnection.handle_project_installed
warrior.on_project_installation_failed += SeesawConnection.handle_project_installation_failed
warrior.on_project_selected += SeesawConnection.handle_project_selected
warrior.on_status += SeesawConnection.handle_warrior_status
warrior.runner.on_pipeline_start_item += SeesawConnection.handle_start_item
warrior.runner.on_pipeline_finish_item += SeesawConnection.handle_finish_item
warrior.runner.on_status += SeesawConnection.handle_runner_status
if not http_username:
http_username = warrior.http_username
if not http_password:
http_password = warrior.http_password
ioloop.PeriodicCallback(SeesawConnection.broadcast_bandwidth, 1000).start()
router = TornadioRouter(SeesawConnection)
application = AuthenticatedApplication(
router.apply_routes([(r"/(.*\.(html|css|js|swf|png|ico))$",
web.StaticFileHandler, {"path": PUBLIC_PATH}),
("/", IndexHandler),
("/api/(.+)$", ApiHandler, {"warrior": warrior})]),
# flash_policy_port = 843,
# flash_policy_file = os.path.join(PUBLIC_PATH, "flashpolicy.xml"),
socket_io_address = bind_address,
socket_io_port = port_number,
# settings for AuthenticatedApplication
auth_enabled = lambda: (realize(http_password) or "").strip() != "",
check_auth = lambda r, username, password: \
(
password==realize(http_password) and \
(realize(http_username) or "").strip() in ["", username]
),
auth_realm = "ArchiveTeam Warrior",
skip_auth = [ r"^/socket\.io/1/websocket/[a-z0-9]+$" ]
)
SocketServer(application, auto_start=False)
def __init__(self, state):
router = TornadioRouter(Client)
self.reportUUID = uuid.uuid4().hex
self.app = tornado.web.Application(
router.apply_routes([
(r"/", MainHandler,
dict(template='index.jade',
reportUUID=self.reportUUID,
state=state)),
(r"/data\.json$", DataHandler,
dict(reportUUID=self.reportUUID, state=state)),
(r"/toplist\.json$", ResultsHandler,
dict(reportUUID=self.reportUUID, state=state)),
]),
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
debug=True,
)
def __init__(self, debug_):
settings = dict(
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
login_url="/auth/login",
debug=debug_,
socket_io_port=options.port,
enabled_protocols=['websocket', 'xhr-multipart', 'xhr-polling'],
)
handlers = [
(r"/", IndexHandler),
(r"/toggleSample", ToggleSample),
(r"/echo", EchoHandler),
(r"/socket.io.js", SocketIOHandler),
]
socketServer = TornadioRouter(RootSocketConnection, settings)
handlers.extend(socketServer.urls)
tornado.web.Application.__init__(self, handlers, **settings)
def __init__(self):
self.db = db
self.config = config
self.agent = AgentServer(application=self)
settings = dict(
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
ui_modules={
"Entry": EntryModule,
"Sidebar": SidebarModule,
},
xsrf_cookies=False,
cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
login_url="/auth/login",
debug=True,
socket_io_port=8888,
)
from bcloud.handlers.host import HostHandler
from bcloud.handlers.index import MainHandler
from bcloud.handlers.websocket import PingConnection
PingRouter = TornadioRouter(
PingConnection,
dict(enabled_protocols=[
'websocket', 'xhr-polling', 'jsonp-polling', 'htmlfile'
]))
handlers = PingRouter.apply_routes([
(r"/hh(.*)", MainHandler, dict(database="hello")),
(r"/host", HostHandler),
# (r"/websocket", BCloudSocketHandler),
# (r"/host", HostHandler),
# (r"/entry/([^/]+)", EntryHandler),
# (r"/compose", ComposeHandler),
# (r"/auth/create", AuthCreateHandler),
# (r"/auth/login", AuthLoginHandler),
# (r"/auth/logout", AuthLogoutHandler),
])
super(Application, self).__init__(handlers, **settings)
def start_runner_server(project,
runner,
bind_address="",
port_number=8001,
http_username=None,
http_password=None):
if bind_address == "0.0.0.0":
bind_address = ""
SeesawConnection.project = project
SeesawConnection.runner = runner
runner.on_pipeline_start_item += SeesawConnection.handle_start_item
runner.on_pipeline_finish_item += SeesawConnection.handle_finish_item
runner.on_status += SeesawConnection.handle_runner_status
router = TornadioRouter(SeesawConnection)
application = AuthenticatedApplication(
router.apply_routes([(r"/(.*\.(html|css|js|swf|png|ico))$",
web.StaticFileHandler, {"path": PUBLIC_PATH}),
("/", IndexHandler),
("/api/(.+)$", ApiHandler, {"runner": runner})]),
# flash_policy_port = 843,
# flash_policy_file = os.path.join(PUBLIC_PATH, "flashpolicy.xml"),
socket_io_address = bind_address,
socket_io_port = port_number,
# settings for AuthenticatedApplication
auth_enabled = (http_password or "").strip() != "",
check_auth = lambda r, username, password: \
(
password==http_password and \
(http_username or "").strip() in ["", username]
),
auth_realm = "ArchiveTeam Warrior",
skip_auth = [ r"^/socket\.io/1/websocket/[a-z0-9]+$" ]
)
SocketServer(application, auto_start=False)
def load_app(port, root):
settings = {
"static_path": path.join(root, "static"),
"template_path": path.join(root, "template"),
"globals": {
"project_name": "BAT -- Bootstrap, AngularJS, Tornado"
},
"flash_policy_port": 843,
"flash_policy_file": path.join(root, 'flashpolicy.xml'),
"socket_io_port": port,
}
routers = [(r"/", MainHandler), (r"/ajax", AjaxHandler),
(r"/signin", SigninHandler), (r"/fluid", FluidHandler),
(r"/hero", HeroHandler), (r"/sfn", SFNHandler),
(r"/sticky-footer", StickyFooterHandler),
(r"/justified-nav", JustifiedNavHandler),
(r"/carousel", CarouselHandler),
(r"/market-narrow", MarketNarrowHandler),
(r"/static-grid", StaticGridHandler),
(r"/ajax-grid", AjaxGridHandler),
(r"/angular-ui", AngularUIHandler),
(r"/gen", SocketIOGenHandler)]
try:
from tornadio2 import TornadioRouter, SocketServer
from connections import QueryConnection
# Create tornadio router
QueryRouter = TornadioRouter(QueryConnection)
# Create socket application
application = web.Application(QueryRouter.apply_routes(routers),
**settings)
#application.listen(8888)
SocketServer(application)
except ImportError:
print "Failed to load module tornadio2"
application = web.Application(routers, **settings)
application.listen(port)
tornado.ioloop.IOLoop.instance().start()
def run(project_root):
serverurls = []
servermodels = []
# add Airy static file handler
serverurls.extend([(r"/airy/form/", web.FormProcessor),
(r"/airy/(.*)", tornado.web.StaticFileHandler, {
"path": os.path.join(AIRY_ROOT, 'static')
})])
# add Airy core handler
core_router = TornadioRouter(web.AiryCoreHandler, settings.__dict__)
serverurls.extend(core_router.urls)
# add application handlers
for appname in settings.installed_apps:
# add app urls
appurls = __import__('%s.urls' % appname,
fromlist=['%s.url' % appname])
urlpatterns = getattr(appurls, 'urlpatterns')
serverurls.extend(urlpatterns)
try:
models = __import__('%s.models' % appname,
fromlist=['%s.models' % appname])
servermodels.append(models)
except ImportError:
pass
# restart on code change
for root, dirs, files in os.walk(settings.template_path):
for x in files:
if os.path.splitext(x)[1].lower() == '.html': # track templates
autoreload._watched_files.add(os.path.join(root, x))
application = tornado.web.Application(serverurls, **settings.__dict__)
settings.application = web.site.application = application
web.site.loader = template.Loader(settings.template_path)
SocketServer(application)
def main():
import threading
t = threading.Thread(target=redis_listener)
t.setDaemon(True)
t.start()
LookupsServer = TornadioRouter(LookupsConnection)
# Fill your routes here
routes = []
# Extend list of routes with Tornadio2 URLs
routes.extend(LookupsServer.urls)
tornado.options.parse_command_line()
if options.debug:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.INFO)
application = tornado.web.Application(routes, socket_io_port=options.port)
try:
SocketServer(application)
except KeyboardInterrupt:
pass
import os
import logging
from tornadio2 import TornadioRouter, SocketServer
from tornado import web
os.environ['DJANGO_SETTINGS_MODULE'] = 'example.settings'
from django_socketio_chat.tornadio_app import chat
from django.conf import settings
logging.getLogger().setLevel(logging.INFO)
# Create chat router
ChatRouter = TornadioRouter(chat.ChatConnection,
user_settings={'websocket_check': True},
namespace='chat/socket.io')
# Create application
application = web.Application(ChatRouter.apply_routes([]),
socket_io_port=8001,
debug=settings.DEBUG)
SocketServer(application)
class ChatConnection(tornadio2.conn.SocketConnection):
# Class level variable
participants = set()
def on_open(self, info):
print 'client connected'
self.participants.add(self)
def on_close(self):
print 'client disconnected'
self.participants.remove(self)
# Create chat server
ChatRouter = TornadioRouter(ChatConnection, dict(websocket_check=True))
# Create socket application
application = tornado.web.Application(ChatRouter.apply_routes([
(r"/", IndexHandler), (r"/socket.io/socket.io.js", SocketIOHandler)
]),
socket_io_port=8001)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
# Create and start tornadio server
SocketServer(application)
def on_message(self, message):
now = datetime.datetime.now()
message['server'] = [now.hour, now.minute, now.second, now.microsecond / 1000]
self.send(message)
class RouterConnection(SocketConnection):
__endpoints__ = {'/chat': ChatConnection,
'/ping': PingConnection}
def on_open(self, info):
print 'Router', repr(info)
# Create tornadio server
MyRouter = TornadioRouter(RouterConnection)
# Create socket application
application = web.Application(
MyRouter.apply_routes([(r"/", IndexHandler),
(r"/socket.io.js", SocketIOHandler)]),
flash_policy_port = 843,
flash_policy_file = op.join(ROOT, 'flashpolicy.xml'),
socket_io_port = 5000
)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
# Create and start tornadio server
"""
response = yield gen.Task(self.long_running, num)
self.emit('response', response)
@gen.sync_engine
def on_event(self, name, *args, **kwargs):
"""Wrapped ``on_event`` handler, which will queue events and will allow usage
of the ``yield`` in the event handlers.
If you want to use non-queued version, just wrap ``on_event`` with ``gen.engine``.
"""
return super(QueryConnection, self).on_event(name, *args, **kwargs)
# Create tornadio router
QueryRouter = TornadioRouter(QueryConnection)
# Create socket application
application = web.Application(
QueryRouter.apply_routes([(r"/", IndexHandler),
(r"/socket.io.js", SocketIOHandler)]),
flash_policy_port=843,
flash_policy_file=op.join(ROOT, 'flashpolicy.xml'),
socket_io_port=8001)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
# Create and start tornadio server
SocketServer(application)
class WebSocketHandler(SocketConnection):
"""
Manages the global list of subscribers.
"""
def on_open(self, *args, **kwargs):
SUBSCRIBERS.append(self)
def on_close(self):
if self in SUBSCRIBERS:
SUBSCRIBERS.remove(self)
# Create tornadio router
WSRouter = TornadioRouter(
WebSocketHandler,
dict(enabled_protocols=[
'websocket', 'xhr-polling', 'jsonp-polling', 'htmlfile'
]))
# Create socket application
application = web.Application(
WSRouter.apply_routes([(r"/step-(\d)+[/]?", StepPageHandler)]),
flash_policy_port=843,
flash_policy_file=os.path.join(ROOT, 'flashpolicy.xml'),
template_path=os.path.join(ROOT, 'templates'),
static_path=os.path.join(ROOT, 'static'),
socket_io_port=8001,
enable_pretty_logging=True)
if __name__ == '__main__':
socketio_server = SocketServer(application, auto_start=False)
from tornadio2 import TornadioRouter
from cloudtunes.realtime import frontend
from .connection import SocketConnection
ENABLED_CHANNELS = {
frontend.RemoteControlChannel,
frontend.ModelChannel,
frontend.PlayerChannel,
frontend.SyncChannel,
}
# Install endpoints.
SocketConnection.__endpoints__ = {
'/' + channel.namespace: channel
for channel in ENABLED_CHANNELS
}
router = TornadioRouter(SocketConnection)
def __init__(self,
cacher,
addr,
port,
log_dir_path,
log_level=logging.DEBUG):
def log_path(name):
path = os.path.join(log_dir_path, name)
if os.path.exists(path):
os.unlink(path)
return path
router = TornadioRouter(Client)
self.cacher = cacher
self.reportUUID = uuid.uuid4().hex
self.app = tornado.web.Application(
router.apply_routes([
(r"/", MainHandler,
dict(template='index.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/offline\.html", MainHandler,
dict(template='offline.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/brief\.html$", MainHandler,
dict(template='brief.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/monitoring\.html$", MainHandler,
dict(template='monitoring.jade',
reportUUID=self.reportUUID,
cacher=cacher)),
(r"/data\.json$", JsonHandler,
dict(reportUUID=self.reportUUID, cacher=cacher)),
]),
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
socket_io_port=port,
socket_io_address=addr,
debug=True,
autoreload=False)
self.access_log = None
self.app_log = None
self.gen_log = None
if log_dir_path:
self.access_log = logging.getLogger("tornado.access")
self.access_log.setLevel(log_level)
access_handler = logging.FileHandler(log_path("access.log"))
self.access_log.addHandler(access_handler)
self.app_log = logging.getLogger("tornado.application")
self.app_log.setLevel(log_level)
app_handler = logging.FileHandler(log_path("app.log"))
templ = "%(asctime)s: [%(levelname)s]: %(message)s"
app_handler.setFormatter(logging.Formatter(templ))
self.app_log.addHandler(app_handler)
self.gen_log = logging.getLogger("tornado.general")
self.gen_log.setLevel(log_level)
gen_handler = logging.FileHandler(log_path("general.log"))
self.gen_log.addHandler(gen_handler)
from tornado import web
from tornadio2 import SocketConnection, TornadioRouter, SocketServer
# Declare connection class
class MyConnection(SocketConnection):
def on_open(self, info):
print('Client connected')
def on_message(self, msg):
print('Got', msg)
self.send(msg)
def on_close(self):
print('Client disconnected')
# Create TornadIO2 router
router = TornadioRouter(MyConnection)
# Create Tornado application with urls from router
app = web.Application(router.urls, socket_io_port=8001)
# Start server
if __name__ == '__main__':
SocketServer(app)
if __name__ == "__main__":
try:
print('Started Freeciv-proxy. Use Control-C to exit');
if len(sys.argv) == 2:
PROXY_PORT = int(sys.argv[1]);
print('port: ' + str(PROXY_PORT));
LOG_FILENAME = '/tmp/logging' +str(PROXY_PORT) + '.out'
#logging.basicConfig(filename=LOG_FILENAME,level=logging.INFO)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("freeciv-proxy");
CivRouter = TornadioRouter(CivConnection,
dict(enabled_protocols = ['websocket']));
application = web.Application(
CivRouter.apply_routes([(r"/", IndexHandler),
(r"/status", StatusHandler, dict(router=CivRouter))]),
socket_io_port = PROXY_PORT
)
# Create and start tornadio server
SocketServer(application);
except KeyboardInterrupt:
print('Exiting...');
return data, [now.hour, now.minute, now.second, now.microsecond / 1000]
@event
def stats(self):
print self.session.server.stats.dump()
return self.session.server.stats.dump()
# Create tornadio router
PingRouter = TornadioRouter(
PingConnection,
dict(
enabled_protocols=[
'websocket',
'xhr-polling',
'jsonp-polling',
'htmlfile'
]
)
)
# Create socket application
application = web.Application(
PingRouter.apply_routes(
[
(r"/", IndexHandler),
(r"/stats", StatsHandler),
(r"/socket.io.js", SocketIOHandler)
]
),
Thread.__init__(self)
self.daemon = True
self.civcom = civcom
self.ws_connection = ws_connection
def run(self):
while 1:
if (self.civcom.stopped): return
packet = self.civcom.get_send_result_string()
if (len(packet) > 4):
self.ws_connection.send(packet)
time.sleep(WS_UPDATE_INTERVAL)
CivRouter = TornadioRouter(CivConnection)
application = web.Application(CivRouter.urls,
enabled_protocols=[
'websocket', 'flashsocket', 'xhr-multipart',
'xhr-polling'
],
flash_policy_port=843,
flash_policy_file=op.join(
ROOT, 'flashpolicy.xml'),
socket_io_port=8002)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(level=logging.INFO)
def on_close(self):
print('Disconnected')
username = self.participants[self]
del self.participants[self]
for p in self.participants:
p.send('System: %s has left' % username)
if hasattr(self, 'conn'):
cur = self.conn.cursor()
cur.execute("""DELETE FROM users WHERE username='******'""" % username)
self.conn.commit()
cur.close()
print('Inserted')
# Create tornadio router
ChatRouter = TornadioRouter(ChatConnection)
# Create socket application
application = web.Application(
ChatRouter.apply_routes([(r"/", IndexHandler),
(r"/socket.io.js", SocketIOHandler)]),
socket_io_port=8001
)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
# Create and start tornadio server
SocketServer(application)
self.render('index.html')
class SocketIOHandler(web.RequestHandler):
def get(self):
self.render('../socket.io.js')
class PingConnection(SocketConnection):
@event
def ping(self, client):
now = datetime.datetime.now()
return client, [now.hour, now.minute, now.second, now.microsecond / 1000]
# Create tornadio router
PingRouter = TornadioRouter(PingConnection)
# Create socket application
application = web.Application(
PingRouter.apply_routes([(r"/", IndexHandler),
(r"/socket.io.js", SocketIOHandler)]),
flash_policy_port = 843,
flash_policy_file = op.join(ROOT, 'flashpolicy.xml'),
socket_io_port = 8001
)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
# Create and start tornadio server
def handle(self, *args, **options):
if settings.DEBUG:
logger.setLevel(logging.DEBUG)
if len(args) > 1:
raise CommandError('Usage is runserver_tornadio2 %s' % self.args)
if len(args) == 1:
if ':' in args[0]:
addr, port = args[0].split(':')
else:
port = args[0]
else:
port = getattr(settings, 'SOCKETIO_PORT', 8000)
# Setup event handlers
for Cls in load_classes(getattr(settings,'SOCKETIO_CLASSES', [])):
mixin(BaseSocket, Cls)
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'settings')
wsgi_app = get_wsgi_application()
app_handler = WSGIContainer(StaticFilesHandler(wsgi_app))
router = TornadioRouter(BaseSocket, {
'enabled_protocols': [
'websocket',
'xhr-polling',
'htmlfile'
]})
if not hasattr(settings, 'SOCKETIO_GLOBALS'):
settings.SOCKETIO_GLOBALS = {}
settings.SOCKETIO_GLOBALS['server'] = router.urls[0][2]['server']
# A map of user IDs to their active connections.
settings.SOCKETIO_GLOBALS['connections'] = defaultdict(set)
tornado_routes = []
for url, path in getattr(settings, 'SOCKETIO_ROUTES', []):
cls = _get_class(path, object)
tornado_routes.append((url, cls))
application = Application(
router.urls + tornado_routes + [
# Uncomment next line to handle static files through Tornado rather than Django or externally.
#(r'/static/(.*)', StaticFileHandler, {'path': settings.STATICFILES_DIRS[0]}),
#(r'/admin$', RedirectHandler, {'url': '/admin/', 'permanent': True}),
# You probably want to comment out the next line if you have a login form.
#(r'/accounts/login/.*', RedirectHandler, {'url': '/admin/', 'permanent': False}),
(r'.*', FallbackHandler, {'fallback': app_handler}),
],
#flash_policy_port = 843,
#flash_policy_file = 'flashpolicy.xml', # TODO: Do we need this? TAA - 2012-03-07.
socket_io_port = port,
xsrf_cookies = False,
debug = settings.DEBUG
)
ssl_options = getattr(settings, 'SOCKETIO_SSL_OPTIONS', {})
if ssl_options:
SocketServer(application, ssl_options = ssl_options)
else:
SocketServer(application)
