def main():
    try:
        """
        defining/parsing the options
        """
        define("port", default=8082, help="run on the given port", type=int)
        define("debug", default=False, help="run in debug mode", type=bool)
        tornado.options.parse_command_line()        
        logging.debug(options.logging)
        """
        initalising applications
        """ 
        app = MyApplication(options)

        """
        starting tornado server
        """
        http_server = tornado.httpserver.HTTPServer(app)
        http_server.listen(options.port)
        ioloop = tornado.ioloop.IOLoop.instance()
        tornado.autoreload.add_reload_hook(app.reloadTasks)
        tornado.autoreload.start(ioloop)
        ioloop.start()

    except KeyboardInterrupt:
        pass
    except:
        print traceback.format_exc()

def run():

    tornado.httpclient.AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient")

    xmpp = XMPPHandler('[email protected]', 'popcorn', 'http://localhost:8080/callback')
    xmpp.register_plugin('xep_0030')

    if xmpp.connect():
        xmpp.process(block=False)

    application = tornado.web.Application([
            tornado.web.URLSpec(r"/send", SendHandler, {'xmpp': xmpp}),
            tornado.web.URLSpec(r"/callback", CallbackProxyHandler, {'callback': "http://localhost:8080/testcallback"}),
            tornado.web.URLSpec(r"/testcallback", TestCallbackHandler),
        ],
        )

    application.listen(8080)

    ioloop = tornado.ioloop.IOLoop.instance()

    try:
        ioloop.start()
    except KeyboardInterrupt:
        print "I'm out"
        xmpp.disconnect()    

    def _actually_run(self):

        import logging
        import tornado.options

        logging.getLogger().setLevel(logging.INFO)
        tornado.options.enable_pretty_logging()

        import tornado.web
        import tornado.httpserver
        import tornado.ioloop
        import tornado.autoreload

#        import hashlib
#        import random
#        m = hashlib.md5()
#        m.update((str(random.random()) + str(random.random())).encode('utf-8'))
#        secret = m.digest()
#        print("SECRET:", secret)
        secret = random_key(100)
        secret = "reiujgerjregiuj"

        app = tornado.web.Application(self.handlers, static_path=self.static, cookie_secret=secret)

        http_server = tornado.httpserver.HTTPServer(app)
        http_server.listen(self.port)
        logging.info("waiting for requests on http://%s:%d" % (self.hostname or "localhost", self.port))
        ioloop = tornado.ioloop.IOLoop.instance()
        tornado.autoreload.start(ioloop)
        ioloop.start()

    def main(self):

        #settings passed to tornado app
        tornado_settings = {
            "template_path": settings.template_path,
            "static_path": settings.static_path,
            "cookie_secret": settings.cookie_secret,
            "login_url": settings.login_url,
        }

        #init a logger
        self.init_logging(settings.log)

        #routes
        routes = self.init_routes()

        self._application = web.Application(routes,**tornado_settings)

        http_server = httpserver.HTTPServer(self._application)
        http_server.listen(settings.port)

        Log.info("Ready and listening")

        ioloop = tornado.ioloop.IOLoop().instance()
        autoreload.start(ioloop)
        try:
            ioloop.start()
        except KeyboardInterrupt:
            pass

def main():
    pika_client = PikaClient()
    database={}
    database['g'] = 'f'
    database['gg'] = 'ff'
    database['ggg'] = 'gff'
    global g_port;
    
    application = tornado.web.Application(
    [(r'/sensor/.*', SensorHandler,dict(database=database)),(r'/.*',MainHandler,dict(database=database))],
#        [(r'/index.html',MainHandler)],
#        [(r'/tom/*',SensorHandler),(r'/index.html',MainHandler)],
#        **{'pika_client': pika_client, 'debug': True}

        #     **{'pika_client': pika_client, 'debug': True}
        #     [(r'/tom/*', Fib)],
             **{'pika_client': pika_client, 'debug': True}
    )
    try:
        port = int(sys.argv[1])  # $ python tornadoweb_pika.py 80
    except:
        port = 8000 
    g_port = port
    application.listen(port)
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.add_timeout(time.time() + .1, pika_client.connect)
    ioloop.start()

def run_service(port, address='0.0.0.0', configuration=None):
    ioloop = tornado.ioloop.IOLoop.instance()
    app = create_service()
    app.listen(port, address)
    app.logger.info('Started THC service on %s:%s', address, port)

    def discovered_service(index, fullname, host, port, txtRecord):
        app.logger.info('Found service: %[email protected]%s:%s', fullname, host, port)

    def lost_service(index, name, regtype, domain):
        app.logger.info('Lost service: %s.%[email protected]%s', name, regtype, domain)

    app.mdns = mdns_util.MDNS(ioloop)
    app.mdns.register('TurretHostController', '_thc_http._tcp', 'local', port)
    app.logger.info('Registered THC service.')

    app.mdns.discover('_thc_http._tcp', discovered_service, lost_service)
    app.logger.info('Listening for neighboring services.')

    try:
        ioloop.start()
    except KeyboardInterrupt:
        app.logger.info('Cancelling service discovery.')
        app.mdns.disable_discovery('_thc_http._tcp')
        app.logger.info('Cancelling service broadcast.')
        app.mdns.unregister('TurretHostController', '_thc_http._tcp', 'local',
                            port)

        app.logger.info('Shutting down.')

def main():
    parse_command_line()
    http_server = tornado.httpserver.HTTPServer(Application())
    http_server.listen(options.port)
    ioloop = tornado.ioloop.IOLoop().instance()
    autoreload.start(ioloop)
    ioloop.start()

def main():
	options.parse_command_line()
	# set up database connection
	client = pymongo.MongoClient(options.dbhost, options.dbport)
	database = client[options.dbname]
	# list of handlers
	handlers = []
	# generate list
	for handler in settings.handlers:
		# import the handler we need
		handler_class = __import__(handler)
		# register the URLS with the handler
		for routes in handler_class.routes:
			# each handler exports a urls list and class
			endpoint, class_name = routes
			url = ('/api' + endpoint, class_name, dict(database=database))
			# append to our handlers list
			handlers.append(url)

	ioloop = tornado.ioloop.IOLoop.instance()
	# register our handlers with our application and give it our settings
	application = tornado.web.Application(handlers, **settings.settings)
	http_server = tornado.httpserver.HTTPServer(application)
	# listen on port defined in options
	http_server.listen(options.port)
	#start ioloop
	ioloop.start()

def run():
    logging.basicConfig(level=logging.DEBUG)
    tornado.options.parse_command_line()
    http_server = tornado.httpserver.HTTPServer(Application())
    http_server.listen(options.port)
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.start()

    def __call__(self,*args,**options):
        from thepian.conf import structure
        from os.path import join
        
        sys.path.append(structure.PROJECT_DIR)
        
        from thepian.conf import ensure_target_tree
        ensure_target_tree(structure.PROJECT_DIR)
        #TODO part add_themaestro functionality

        import logging
        LOG_FILENAME = join(structure.PROJECT_DIR,'testing.log')
        logging.basicConfig(filename=LOG_FILENAME,level=logging.DEBUG)
                
        from mediaserver import Application, HTTPServer
        import tornado.httpserver
        import tornado.ioloop
        import tornado.autoreload
        
        # print "js dir =", structure.JS_DIR
        # tornado.options.parse_command_line()
        ioloop = tornado.ioloop.IOLoop.instance()

        sock_path = join(structure.PROJECT_DIR,"mediasite.sock")
        port_no = structure.MEDIASERVER_PORT
        if port_no:
            http_server = tornado.httpserver.HTTPServer(Application(ioloop=ioloop))
            http_server.listen(port_no)
        else:
            http_server = HTTPServer(Application(ioloop=ioloop))
            http_server.listen(0,address = sock_path)
        
        tornado.autoreload.start(io_loop=ioloop)
        ioloop.start()

def run_proxy(bind, debug=False):
    #  /proxy/[?](?P<url>.*) # r'/proxy/[?](.*)' # r'/proxy/(.*)'
    handler = [(r'/proxy/', ProxyHandler, {})]
    app = tornado.web.Application(handler, debug=debug)
    app.listen(bind[1], bind[0])
    ioloop = tornado.ioloop.IOLoop.instance()
    ioloop.start()

def main():
    app = LetSpotify()
    http_server = tornado.httpserver.HTTPServer(app)
    http_server.listen(options.port)
    ioloop = tornado.ioloop.IOLoop.instance()

    app.db = momoko.Pool(
        dsn=settings['dsn'],
        size=5,
        raise_connect_errors=False,
        reconnect_interval=50,
        ioloop=ioloop,
    )

    future = app.db.connect()
    ioloop.add_future(future, lambda f: ioloop.stop())
    ioloop.start()
    future.result()  # raises exception on connection error

    Service.users = Users(app.db)
    Service.facebook = FacebookAPI(app.db)
    Service.rooms = Rooms(app.db)
    Service.login_token = LoginToken(app.db)

    ioloop.start()

 def __init__(self):
     self.handlers = routs
     ioloop = tornado.ioloop.IOLoop.instance()
     self.settings = dict(
         debug=config.debug,
         template_path=config.template_path,
         static_path=config.static_path,
         cookie_secret=config.cookie_secret,
         login_url=config.login_url
     )
     super(Application, self).__init__(self.handlers, **self.settings)
     self.db_async = momoko.Pool(
         dsn=config.get_db_url(options.db_name,
                               options.db_user_name,
                               options.db_host,
                               options.db_port,
                               options.db_password),
         size=1,
         ioloop=ioloop,
         cursor_factory=DictCursor
     )
     future = self.db_async.connect()
     ioloop.add_future(future, lambda x: ioloop.stop())
     ioloop.start()
     future.result()

def main():
    try:
        # create an api for the webserver
        api = HotTubAPI();
        app = tornado.web.Application(
            handlers=[
                (r"/images/(.*)", tornado.web.StaticFileHandler, {"path":"./images"}),
                (r"/css/(.*)", tornado.web.StaticFileHandler, {"path":"./css"}),
                (r"/js/(.*)", tornado.web.StaticFileHandler, {"path":"./js"}),
                (r"/*", IndexHandler),
                (r"/twilio.api", TwilioHandler, dict(api=api)),
                (r"/ws", WebSocketHandler, dict(api=api))
            ]
        )
        server = tornado.httpserver.HTTPServer(app)
        port = 9999
        server.listen(port,address="0.0.0.0")
        print "Tornado listening on port: %s" % port

        ioloop = tornado.ioloop.IOLoop.instance()
        set_ping(ioloop, timedelta(seconds=2))
        ioloop.start()
    except KeyboardInterrupt:
        print '^C received, shutting down server'
        api.close()
        server.stop();

def start_server(args):
    app = Flask(__name__)
    app.config['SECRET_KEY'] = 'secret'
    app.jinja_env.globals['static'] = static

    blueprint.url_prefix = args.url_prefix
    app.register_blueprint(blueprint)

    # app.run(port=args.port, debug=args.debug)

    wsgi_app = tornado.wsgi.WSGIContainer(app)
    condajs_ws = sockjs.tornado.SockJSRouter(views.CondaJsWebSocketRouter, '/condajs_ws')
    routes = condajs_ws.urls
    routes.append((r".*", tornado.web.FallbackHandler, dict(fallback=wsgi_app)))
    application = tornado.web.Application(routes, debug=args.debug)

    try:
        application.listen(args.port)
    except OSError as e:
        print("There was an error starting the server:")
        print(e)
        return

    ioloop = tornado.ioloop.IOLoop.instance()
    if not args.debug:
        callback = lambda: webbrowser.open_new_tab('http://localhost:%s' % args.port)
        ioloop.add_callback(callback)
    ioloop.start()

    def __init__(self):
        handlers = [
            (r"/", AllLists),
            (r"/create/", CreateLists),
        ]
        settings = dict(
            todo_title=u"ToDo",
            template_path=os.path.join(os.path.dirname(__file__), "templates"),
            static_path=os.path.join(os.path.dirname(__file__), "static"),
            xsrf_cookies=True,
            cookie_secret=base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes),
            login_url="/auth/login",
            debug=True,
        )

        super(Application, self).__init__(handlers, **settings)

        ioloop = tornado.ioloop.IOLoop.instance()
        self.db = momoko.Pool(
            dsn='dbname=todo user={0} password={1} '
                'host=localhost port=5432'.format(USERNAME, PASSWORD),
            size=1,
            ioloop=ioloop,
            cursor_factory=psycopg2.extras.RealDictCursor
        )

        future = self.db.connect()
        ioloop.add_future(future, lambda f: ioloop.stop())
        ioloop.start()
        future.result()

 def serve(self):
     self.app.listen(8888)
     ioloop = tornado.ioloop.IOLoop.instance()
     update_cb = tornado.ioloop.PeriodicCallback(
         self.update_status, 100, ioloop)
     update_cb.start()
     ioloop.start()

def main():
    global server_state

    parse_command_line()

    ioloop = tornado.ioloop.IOLoop.instance()

    application = ExproxymentApplication()

    if options.soft_sticky and options.hard_sticky:
        raise Exception("can't be both soft_sticky and hard_sticky")

    if options.backends:
        backends = parse_backends(options.backends)
        backends = [Backend(host['host'], host['port'])
                    for host in backends]
        server_state.set_backends(backends)

    if options.weights:
        weights = parse_weights(options.weights)
        server_state.weights = weights

    HealthDaemon(ioloop).start()
    application.listen(options.port)

    logger.info("Starting on :%d", options.port)
    ioloop.start()

def main():
    tornado.options.parse_command_line()
    ioloop = tornado.ioloop.IOLoop.instance()
    http_server = tornado.httpserver.HTTPServer(GovLove(ioloop))
    http_server.listen(options.port)
    tornado.autoreload.start()
    ioloop.start()

def main():
    """ main program, start local server """
    app = make_app()
    app.listen(8080)
    ioloop = tornado.ioloop.IOLoop.instance()
    signal.signal(signal.SIGINT, lambda sig, frame: ioloop.add_callback_from_signal(on_shutdown))
    ioloop.start()