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):
        self.db = pymongo.Connection(port=settings.DB_PORT)[settings.DB_NAME]
        self.fs = GridFS(self.db)
        self.loader = Loader(
            os.path.join(ROOT_DIR, 'template'),
            autoescape=None,
            namespace={
                'static_url': lambda url: StaticFileHandler.make_static_url({'static_path': STATIC_DIR}, url),
                '_modules': ObjectDict({'Template': lambda template, **kwargs: self.loader.load(template).generate(**kwargs)}),
            },
        )

        router = TornadioRouter(ScribeConnection)
        router.app = self
        socketio = TornadoApplication(router.urls, app=self)
        self.connections = []

        class FooResource(Resource):
            def __call__(self, request):
                socketio(request)

            def __getitem__(self, name):
                return self

        Application.__init__(self, {
            '': HomeResource(self),
            'favicon.ico': StaticFileResource(os.path.join(STATIC_DIR, 'img', 'favicon.ico')),
            'sounds': EditsResource(self),
            'static': StaticFileResource(STATIC_DIR),
            'socket.io': FooResource(),
        })

 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 __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 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 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 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 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

            fileinfo = self.request.files['filearg'][0]

            fname = fileinfo['filename']
            fh = open("static/pic/" + fname, 'w')
            fh.write(fileinfo['body'])
            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)]),

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

        self.send({'action':'speed','speed':self.user.getSpeed()})
    '''
    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

    """Serve the index file"""
    def get(self):
        self.render(ROOT_DIR + '/new.html')

class RouterConnection(SocketConnection):
    __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()

    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)

  @timer('delete_plugins')
  def delete_plugins(self):
    self.tokenizer_factory.deleteInstance(self.tokenizer);
    self.tokenizer_plugin.destroy(self.tokenizer_factory)
    self.tokenizer, self.tokenizer_factory = None, None
    del self.tokenizer_plugin
  
    self.htr_factory.deleteInstance(self.htr);
    self.htr_plugin.destroy(self.htr_factory)
    self.htr, self.htr_factory = None, None
    del self.htr_plugin
  


# Create tornadio router
CasmacatRouter = TornadioRouter(RouterConnection)


if __name__ == "__main__":
    from sys import argv
    import logging
    import atexit
    import getopt 

    try:
      opts, args = getopt.getopt(sys.argv[1:], "hl:c:", ["help", "logfile=", "config="])
    except getopt.GetoptError as err:
      # print help information and exit:
      print >> sys.stderr, str(err) # will print something like "option -a not recognized"
      usage()
      sys.exit(2)