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