def start_warrior_server(warrior, port_number=8001):
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
ioloop.PeriodicCallback(SeesawConnection.broadcast_bandwidth, 1000).start()
router = TornadioRouter(SeesawConnection)
application = web.Application(
router.apply_routes([(r"/(.*\.(html|css|js|swf|png))$",
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_port = port_number,
debug = True
)
SocketServer(application, auto_start=False)
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 __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 __init__(self):
handlers = [
(r"/", MainHandler),
(r"/auth/login", WeiboAuthHandler),
(r"/auth/logout", LogoutHandler),
(r"/vote", VoteHandler),
]
settings = dict(
static_path=os.path.join(os.path.dirname(__file__), "public"),
cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
login_url="/auth/login",
debug=True,
xsrf_cookies=True,
weibo_consumer_key='100689067',
weibo_consumer_secret='1f54eff4858b924d090833d537335bd8',
flash_policy_port = 843,
flash_policy_file = op.join(ROOT, 'flashpolicy.xml'),
socket_io_port = 8000,
)
VoteRouter = TornadioRouter(VoteConnection,
dict(enabled_protocols=['websocket', 'xhr-polling',
'jsonp-polling', 'htmlfile']))
tornado.web.Application.__init__(self, VoteRouter.apply_routes(handlers), **settings)
#self.redis = redis.StrictRedis()
self.adb = opermongo.asyncdb(database='test')
self.db = opermongo.db(database='test')
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 InitServer():
if settings.LOGGING:
logging.getLogger().setLevel(logging.DEBUG)
generate_settings()
SAHRouter = TornadioRouter(RouterConnection)
SAHApplication = web.Application(
SAHRouter.apply_routes(
[
(r"/", IndexHandler),
(r"/test/", TestHandler),
(
r"/static/(.*)",
web.StaticFileHandler,
{"path": os.path.abspath(os.path.join(os.getcwd(), "web", "static"))},
),
]
),
socket_io_port=settings.WS_PORT,
debug=settings.DEBUG,
)
SAHSocketServer = SocketServer(SAHApplication, auto_start=False)
# Add periodic callback (aka faux-thread) into the ioloop before starting
# Tornado doesn't respond well to running a thread while the IO loop is going.
cb = ioloop.PeriodicCallback(GamePulse, 1000, SAHSocketServer.io_loop)
cb.start()
SAHSocketServer.io_loop.start()
def main(args=None):
if args is None:
args = sys.argv
setup_logger()
router = TornadioRouter(RouterConnection)
bg_loop = IOLoop()
bg_thread = Thread(target=lambda: bg_loop.start())
bg_task = task.Task(bg_loop)
application = Application(
router.apply_routes([
(r"/", IndexHandler),
(r"/start", StartHandler),
(r"/start_mission", StartMissionHandler),
]),
debug=True,
)
application.listen(8000)
StartHandler.triggered.connect(bg_task.setup_api)
StartMissionHandler.triggered.connect(bg_task.start_mission)
event.api_started.connect(RouterConnection.on_api_started)
event.mission_started.connect(RouterConnection.on_mission_started)
event.mission_result.connect(RouterConnection.on_mission_result)
try:
bg_thread.start()
IOLoop.instance().start()
except KeyboardInterrupt:
bg_loop.stop()
IOLoop.instance().stop()
# api_token = args[1]
# client_ = client.Client(api_token)
# event_loop = tornado.ioloop.IOLoop()
# event_loop = task.EventLoop()
# mission = client.Mission(client=client_, event_loop=event_loop)
# mission.start(api_deck_id=2, api_mission_id=5)
# mission.start(api_deck_id=3, api_mission_id=21)
# mission.start(api_deck_id=4, api_mission_id=38)
# nyukyo = client.Nyukyo(client=client_, event_loop=event_loop)
# nyukyo.start()
# event_loop.start()
return 0
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 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"/", 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(8888)
tornado.ioloop.IOLoop.instance().start()
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 run(port, address, debug):
global ss
logging.getLogger().setLevel(logging.DEBUG)
router = TornadioRouter(ExecuteConnection)
ss = SocketServer(web.Application(
router.apply_routes([(r"/", IndexHandler),
(r"/static/(.*)", web.StaticFileHandler,
{'path':'../static'}),
]),
socket_io_port = port,
socket_io_address = address,
debug=debug),
auto_start = False)
ss.io_loop.add_handler(executor._fifo, handle_output, ss.io_loop.WRITE)
ss.io_loop.start()
def __init__(self, **settings):
params = dict(enabled_protocols=["websocket", "xhr-polling", "jsonp-polling", "htmlfile"])
router = TornadioRouter(handler.SocketIOHandler, params)
handlers = router.apply_routes(
[
(r"/api/service", handler.ServiceHandler),
(r"/api/store", handler.StoreHandler),
(r"/options", handler.OptionsHandler),
(r"/", handler.MainHandler),
]
)
tornado.web.Application.__init__(self, handlers, **settings)
self.jinja = Environment(loader=FileSystemLoader(settings["template_path"]))
tornado.locale.set_default_locale("en_US")
self.locale = tornado.locale.get(locale.getdefaultlocale()[0])
self.store = Store()
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 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):
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 start_runner_server(project, runner, bind_address="", port_number=8001):
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 = web.Application(
router.apply_routes([(r"/(.*\.(html|css|js|swf|png))$",
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
)
SocketServer(application, auto_start=False)
def run(port, address, debug):
if debug:
logging.getLogger().setLevel(logging.DEBUG)
router = TornadioRouter(ExecuteConnection)
ss = SocketServer(web.Application(
router.apply_routes([(r"/", IndexHandler),
(r"/static/(.*)", web.StaticFileHandler,
{'path':os.path.join(ROOT ,'static')}),
]),
flash_policy_port = 843,
flash_policy_file = os.path.join(ROOT, 'flashpolicy.xml'),
socket_io_port = port,
socket_io_address = address,
debug=debug),
auto_start = False)
# We do auto_start=False above and the following loop, so that SIGINT interrupts from
# the user doesn't kill the process.
while True:
try:
ss.io_loop.start()
except:
pass
url(r"/", HomeHandler, name="home"),
url(r'/accounts/login', LoginHandler, name="login"),
url(r'/accounts/register', RegisterHandler, name="register"),
url(r'/accounts/logout', LogoutHandler, name="logout"),
url(r'/accounts/check_username_availability/(.+)/',
UserNameAvailabilityHandler, name="user_name_avaliability"),
url(r'/accounts/profile', FakeHandler, name="profile"), # TODO
url(r'/accounts/settings', FakeHandler, name="settings"), # TODO
# ajax api
url(r'/v1/dropbox/get_tree/', DropboxGetTree, name="dropbox_get_path"),
url(r'/v1/dropbox/get_file/', DropboxGetFile, name="dropbox_get_file"),
url(r'/v1/dropbox/save_file/', DropboxSaveFile, name="dropbox_save_file"),
url(r'/v1/dropbox/create_dir/', DropboxCreateDir, name="dropbox_create_dir"),
url(r'/v1/dropbox/delete/', DropboxDelete, name="dropbox_delete"),
url(r'/v1/dropbox/move/', DropboxMove, name="dropbox_move"),
url(r'/v1/dropbox/copy/', DropboxSave, name="dropbox_copy"),
]
if options.debug:
url_patterns += [
url(r'/trash_debug/(.*)', RenderTrashHtml, name="trash_debug"),
]
if options.socketio:
from tornadio2 import TornadioRouter
from handlers.socketio import EdtrConnection
EdtrRouter = TornadioRouter(EdtrConnection)
url_patterns = EdtrRouter.apply_routes(url_patterns)
import views
from tornadio2 import TornadioRouter, SocketConnection
import tornadoredis
class tornadioConnection(SocketConnection):
__endpoints__ = {
'/tornado/stream': views.StreamComm,
}
socketIORouter = TornadioRouter(
tornadioConnection, {
'enabled_protocols': [
'websocket',
'xhr-polling',
'jsonp-polling'
]
}
)
urls = socketIORouter.apply_routes([])
def send_notification(self, x):
if(type(x) == dict):
self.emit('notification', json.dumps(x, cls=MongoAwareEncoder))
@gen.coroutine
@event
def notification_read(self, _id):
db = self.db
notif_coll = db["notif_" + self.get_current_user()['id']]
res = yield motor.Op(notif_coll.find_one, {'_id': objectid.ObjectId(_id)})
yield motor.Op(notif_coll.update, {'from': res['from']}, {"$set": {'read': True}}, multi=True)
@event
def disconnect(self, *args, **kwargs):
print "on_disconnect"
@event
def disconnected(self, *args, **kwargs):
print "on_disconnected"
def on_close(self, *args, **kwargs):
try:
self.notif_checker.stop()
except:
pass
MyRouter = TornadioRouter(MyConnection)
mappings = MyRouter.apply_routes(mappings)
class IndexHandler(RequestHandler):
def get(self):
self.render("static/test.html")
class SocketIOHandler(RequestHandler):
def get(self):
self.render("static/socket.io.js")
SyncRouter = TornadioRouter(BackboneConnection)
sio_application = Application(
SyncRouter.apply_routes([
(r"/socket.io.js", SocketIOHandler)
]),
socket_io_port = 8001
)
web_application = Application([
(r"/", IndexHandler),
(r"/(.*)", tornado.web.StaticFileHandler, {"path": "static"})
])
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
SocketServer(sio_application, auto_start=False)
web_application.listen(8888)
if self in ChatConnection.participants:
del ChatConnection.participants[self]
def on_message(self, msg):
print "Putting %s in correct lobby" % msg
ChatConnection.participants[msg.lower()] = self
if self in ChatConnection.no_name:
ChatConnection.no_name.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 tornado server
SocketServer(application)
"""
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)
STATS = ServerStats()
redis = brukva.Client(host='localhost', port=6379, selected_db=0)
redis.connect()
}
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),
(r"/login", GoogleHandler),
(r"/getDeck/([0-9a-f]+)", DecksListHandler),
(r"/getTokens/([0-9a-f]+)", TokenListHandler),
(r"/getCard/([0-9]+)", getCardHandler),
(r"/getAToken/([0-9]+)", getTokenHandler),
]),
#flash_policy_port = 843,
#flash_policy_file = op.join(ROOT, 'flashpolicy.xml'),
cookie_secret=my_cookie_secret,
static_path=os.path.join(os.path.dirname(__file__), "static"),
login_url="/login",
socket_io_port=5000,
debug=True,
)
if __name__ == "__main__":
import logging
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)
STATS = ServerStats()
redis = brukva.Client(host='localhost', port=6379, selected_db=0)
redis.connect()
redis.subscribe('events')
if __name__ == "__main__":
tornado.options.define('appid', default='165', help='RMonitor AppID')
tornado.options.parse_command_line()
# Create RaceMonitor client
rm = rmonitor.RMonitorClient(tornado.options.options.appid)
#rm = rmonitor.RMonitorFile('race.log')
session = Session(rm)
# Create tornadio server
MyRouter = TornadioRouter(RouterConnection)
# Create socket application
application = web.Application(MyRouter.apply_routes([
(r"/", IndexHandler),
(r"/data.json", DataHandler),
(r"/.*js", FileHandler),
(r"/.*css", FileHandler),
(r"/.*gif", FileHandler),
]),
flash_policy_port=8843,
flash_policy_file=op.join(
ROOT, 'flashpolicy.xml'),
socket_io_port=8001,
verify_remote_ip=False)
# Create and start tornadio server
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)
# Create tornadio router
MinimalRouter = TornadioRouter(RouterConnection)
### cmd-line parsing and server init ###
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--port', help='server port to bind to, default: 9999', type=int, default=9999)
parser.add_argument('--mt-host', help='host of the mt server (server.py), default '+mt_host, default=mt_host)
parser.add_argument('--mt-port', help='port of the mt server (server.py), default '+str(mt_port), type=int, default=mt_port)
parser.add_argument('--biconcor-model', help='model file for bilingual concordancer')
parser.add_argument('--biconcor-cmd', help='command binary for bilingual concordancer')
parser.add_argument('--log-dir', help='directory for log files', default=".")
settings = parser.parse_args(sys.argv[1:])
mt_host = settings.mt_host
mt_port = settings.mt_port
log_dir = settings.log_dir
biconcor_model = settings.biconcor_model
biconcor_cmd = settings.biconcor_cmd
log_file = '%s.catserver.log' %datetime.datetime.now().strftime("%Y%m%d-%H.%M.%S")
log_format = '%(asctime)s %(thread)d - %(filename)s:%(lineno)s: %(message)s'
logging.basicConfig(filename=log_dir+"/"+log_file,level=logging.DEBUG,format=log_format)
application = web.Application(
MinimalRouter.apply_routes([]),
socket_io_port = settings.port
)
SocketServer(application)
def on_message(self, message):
if not self.id:
if message.find(self.accesskey):
self.id = message
self.user=User(self.id)
self.clients.add(self)
'''
# Create tornadio router
PingRouter = TornadioRouter(PingConnection)
# Create socket application
application = web.Application(
PingRouter.apply_routes([]),
flash_policy_port = 843,
flash_policy_file = op.join(ROOT, 'flashpolicy.xml'),
socket_io_port = 8001
)
if __name__ == "__main__":
logging.getLogger().setLevel(logging.DEBUG)
# Create and start tornadio server
SocketServer(application)
__endpoints__ = {'/game': GameConnection}
def on_open(self, info):
pass
# Create tornadio server
jazzyRouter = TornadioRouter(RouterConnection)
# Create socket application
application = web.Application(
jazzyRouter.apply_routes([(r"/", IndexHandler),
(r"/(.*\.(js|html|css|ico|gif|jpe?g|png|ogg|mp3))", web.StaticFileHandler, {"path": ROOT_DIR}),
(r"/([^(socket.io)].*)", HTTPJSONHandler)]),
flash_policy_port = 843,
flash_policy_file = op.join(ROOT_DIR, '/other/flashpolicy.xml'),
socket_io_port = PORT_NUMBER,
debug=True
)
if __name__ == "__main__":
# prepare for the first games to be started
gamePool = GamePool()
mqPool = MessageQueuePool()
# create and start tornadio server
SocketServer(application)
fh.close()
im = Image.open("static/pic/" + fname)
im.save('static/pic/' + fname)
response['status'] = True
response['path'] = "pic/" + fname
self.finish(
json.dumps(response))
EventRouter = TornadioRouter(
EventConnection)
application = tornado.web.Application(
EventRouter.apply_routes([
(r"/", NotVJSHandler.Index),
(r"/pic/(.*)", tornado.web.StaticFileHandler, {
'path': path.join(static_path, "pic")}),
(r"/temp/(.*)", tornado.web.StaticFileHandler, {
'path': path.join(static_path, "temp")}),
(r"/js/(.*)", tornado.web.StaticFileHandler, {
'path': path.join(static_path, "js")}),
(r"/css/(.*)", tornado.web.StaticFileHandler, {
'path': path.join(static_path, "css")}),
(r"/upload$", NotVJSHandler.Upload)]),
flash_policy_port=843,
flash_policy_file=path.join(ROOT, 'flashpolicy.xml'),
socket_io_port=8888)
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)
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)
'/ping': PingConnection,
'/gs': GSConnection}
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),
(r"/login", GoogleHandler),
(r"/getDeck/([0-9a-f]+)", DecksListHandler),
(r"/getTokens/([0-9a-f]+)", TokenListHandler),
(r"/getCard/([0-9]+)", getCardHandler),
(r"/getAToken/([0-9]+)", getTokenHandler),
]),
#flash_policy_port = 843,
#flash_policy_file = op.join(ROOT, 'flashpolicy.xml'),
cookie_secret=my_cookie_secret,
static_path=os.path.join(os.path.dirname(__file__), "static"),
login_url="/login",
socket_io_port = 5000,
debug=True,
)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
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...');
self.set_cookie('id', token, httponly=True)
session.conn.emit("authed", {
"success": True
})
class SocketIOHandler(RequestHandler):
def get(self):
self.render("socket.io.js")
Router = TornadioRouter(SocketIOConnection)
session_store = SessionStore(Router)
application = Application(
Router.apply_routes([
(r"/socket.io.js", SocketIOHandler),
(r"/jquery-1.8.2.min.js", JQHandler),
(r"/login", LoginPageHandler),
(r"/", IndexHandler)
]),
socket_io_port = 8888
)
if __name__ == "__main__":
import logging
logging.getLogger().setLevel(logging.DEBUG)
SocketServer(application)
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)
models = Models(config_fn)
models.create_plugins()
atexit.register(models.delete_plugins)
atexit.register(gperftools.ProfilerStop)
port = 5002
try:
port = int(args[0])
except:
try:
port = models.config["server"]["port"]
except:
pass
# Create socket application
application = web.Application(
CasmacatRouter.apply_routes([]),
flash_policy_port = 843,
flash_policy_file = os.path.join(ROOT, 'flashpolicy.xml'),
socket_io_port = port
)
print >> logfd, """/*\n Casmacat HTR server started on port %d\n %s\n*/\n\n"config": %s\n\n\n""" % (port, str(datetime.datetime.now()), json.dumps(models.config, indent=2, separators=(',', ': '), encoding="utf-8"))
gperftools.ProfilerStart("output.prof")
# Create and start tornadio server
SocketServer(application)
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
SocketServer(application)
port = 3019
try:
port = int(args[0])
except:
try:
port = models.config["server"]["port"]
except:
pass
# Create socket application
application = web.Application(
CasmacatRouter.apply_routes([
(r"/", IndexHandler),
(r"/js/(.*)", JsHandler),
(r"/css/(.*)", CssHandler),
(r"/examples/(.*)", ExampleHandler)
]),
flash_policy_port = 843,
flash_policy_file = os.path.join(ROOT, 'flashpolicy.xml'),
socket_io_port = port
)
print >> get_logfd(), """/*\n Casmacat server started on port %d\n %s\n*/\n\n"config": %s\n\n\n""" % (port, str(datetime.datetime.now()), json.dumps(models.config, indent=2, separators=(',', ': '), encoding="utf-8"))
# Create and start tornadio server
SocketServer(application)