def run(): """ Process command line arguments, Start dbus_api in separate thread - ideally it would be a separate daemon process, but currently this app is too tiny for 2 processes. Start the Tornado Web Server for Django """ try: define("addr", default="127.0.0.1", help="Address to listen on") define("port", default="8000", help="Port to listen on") dbus_thread = Thread(target=DBusApi.run_me) dbus_thread.daemon = False dbus_thread.start() wsgi_app = WSGIContainer(django_app) application = Application([ ( r"/static/(.*)", StaticFileHandler, {"path": PROJECT_ROOT + "/static"} ), (r".*", FallbackHandler, dict(fallback=wsgi_app)) ]) application.listen(options.port, options.addr) IOLoop.instance().start() except KeyboardInterrupt: print 'Shutting down...' DBusApi.shutdown_event.set() dbus_thread.join() print 'Exit on user demand OK'
def main() -> None: '''Runs server''' # Parse options define('production', default = False, help = 'run in production mode', type = bool) options.parse_command_line() # Set server name pname = settings.process_name if settings.process_name else None if pname: setproctitle(pname) # Register IRC server server = IRCServer(settings = ircdsettings) for address, port in ircdsettings['listen']: server.listen(port, address = address) # Start profiling if settings.profiling: import yappi yappi.start() # Setup autoreload autoreload.start() # Run application IOLoop.instance().start()
def main(): define("port", default=8080, help="run on the given port", type=int) settings = { "debug": True, "template_path": "templates", "static_path": "static", "login_url": "/api/login", "cookie_secret": "Zxz1DAVh+WTvyqpWGmOtJCQLETQYUznEuYskSF062J0Too=", #"redirect_uri": "http://fan.wandoulabs.com/api/oauth", "google_consumer_key": "36032040358.apps.googleusercontent.com", "google_consumer_secret": "7fkXd8MEaYr0DLLaO18BkiE3", #"google_permissions": "https://mail.google.com/ https://www.google.com/m8/feeds", #"google_permissions": "https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email", } tornado.options.parse_command_line() application = tornado.web.Application([ (r"/", IndexHandler), #(r"/", MainHandler), (r"/api/Googlelogin", GoogleAuthLoginHandler), (r"/api/login", LoginHandler), (r"/api/auth", AuthHandler), (r"/api/logout", LogoutHandler), (r"/api/all", AllHandler), (r"/api/order", OrderHandler), (r"/api/delorder", DelOrderHandler), (r"/api/allorder", AllOrderHandler), (r"/api/theorder", TheOrderHandler), (r"/api/orders", EachOrderHandler), (r"/api/user", UserHandler), (r"/api/notify", NotifyHandler), (r"/api/data/(.*)", DataHandler), ], **settings) http_server = tornado.httpserver.HTTPServer(application) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def config_app(config, default_options_file, replace_options): init_env() app_log.set_logging_level(app_common_const.LOG_LEVEL) with open(default_options_file, 'r') as f: default_options = json.load(f) if default_options: for option in default_options.get('global_option', {}): if option: define(option[0], default=option[1], help=option[2], type=get_builtin_type(option[3])) options.parse_config_file(config) if not check_server_config(): raise EnvironmentError('app server config') if app_common_const.OPTION_LOG_PATH in options: app_log.define_file_logging() options.template_path = str(os.path.join(app_common_const.PROJECT_BASE_FOLDER, options.template_path)) options.static_path = str(os.path.join(app_common_const.PROJECT_BASE_FOLDER, options.static_path)) if replace_options and replace_options['port']: options.port = int(replace_options['port']) config_jinja2()
def main(): define("sslcheck", default=1, help="Verify SSL hostname, on by default") define("use_simple_http_client", default=0, help="Use Tornado SimpleHTTPClient instead of CurlAsyncHTTPClient") args = parse_command_line() skip_ssl_validation = False use_simple_http_client = False if unicode(options.sslcheck) == u"0": skip_ssl_validation = True if unicode(options.use_simple_http_client) == u"1": use_simple_http_client = True # If we don't have any arguments, run the server. if not args: app = init_forwarder(skip_ssl_validation, use_simple_http_client=use_simple_http_client) try: app.run() finally: ForwarderStatus.remove_latest_status() else: usage = "%s [help|info]. Run with no commands to start the server" % (sys.argv[0]) command = args[0] if command == 'info': logging.getLogger().setLevel(logging.ERROR) return ForwarderStatus.print_latest_status() elif command == 'help': print(usage) else: print("Unknown command: %s" % command) print(usage) return -1 return 0
def main(): define("port", default=8988, help="run on the given port", type=int) tornado.options.parse_command_line() http_server = tornado.httpserver.HTTPServer(Application(), xheaders=True) http_server.listen(options.port, '127.0.0.1') logging.info('Started at http://127.0.0.1:%s'%options.port) tornado.ioloop.IOLoop.instance().start()
def __init__(self, handlers, **settings): define('poolsize', default=10, type=int) settings['session_secret'] = options.sessionsecret settings['cookie_secret'] = options.cookiesecret self.pool = database.Pool.instance() self.session_manager = session.SessionManager(session.DatabaseSessionStorage, self.pool, secret=options.sessionsecret) super(BaseApplication, self).__init__(handlers, **settings)
def main(): define("pycurl", default=1, help="Use pycurl") define("sslcheck", default=1, help="Verify SSL hostname, on by default") args = parse_command_line() skip_ssl_validation = False if unicode(options.pycurl) == u"0": os.environ['USE_SIMPLE_HTTPCLIENT'] = "1" if unicode(options.sslcheck) == u"0": skip_ssl_validation = True # If we don't have any arguments, run the server. if not args: import tornado.httpclient app = init(skip_ssl_validation) try: app.run() finally: ForwarderStatus.remove_latest_status() else: usage = "%s [help|info]. Run with no commands to start the server" % ( sys.argv[0]) command = args[0] if command == 'info': logging.getLogger().setLevel(logging.ERROR) return ForwarderStatus.print_latest_status() elif command == 'help': print usage else: print "Unknown command: %s" % command print usage return -1 return 0
def main(): define("pycurl", default=1, help="Use pycurl") args = parse_command_line() if options.pycurl == 0 or options.pycurl == "0": os.environ['USE_SIMPLE_HTTPCLIENT'] = '1' # If we don't have any arguments, run the server. if not args: import tornado.httpclient app = init() try: app.run() finally: ForwarderStatus.remove_latest_status() else: usage = "%s [help|info]. Run with no commands to start the server" % ( sys.argv[0]) command = args[0] if command == 'info': return ForwarderStatus.print_latest_status() elif command == 'help': print usage else: print "Unknown command: %s" % command print usage return -1 return 0
def main(): options.define('port', default=9005, help="Port for the REST API" ) options.define('ip', default='127.0.0.1', help="IP address for the REST API" ) options.define('host_mount', default='', help='Path where the host root is mounted in this container' ) options.define('pool_prefix', default='', help='Prefix assigned by tmpnb to its pooled containers' ) options.define('registration_key', default='', help='Registration key required to create new volumes' ) options.parse_command_line() opts = options.options # regex from docker volume create api_handlers = [ (r'/api/mounts(/([a-zA-Z0-9][a-zA-Z0-9_.-])+)?', MountsHandler), (r'/api/volumes', VolumesHander), ] api_app = web.Application(api_handlers) api_app.listen(opts.port, opts.ip, xheaders=True) app_log.info("Listening on {}:{}".format(opts.ip, opts.port)) ioloop.IOLoop.instance().start()
def init_define(): define("flag", default=False, help="when system is first time,flag should be set True", type=bool) # log define("log_file_prefix", default="./log/analysis.log") define("log_rotate_mode", default='time') # 轮询模式: time or size define("log_rotate_when", default='H') # 单位: S / M / H / D / W0 - W6 define("log_rotate_interval", default=24) # 间隔: 24小时
def main(): define("port", default=8000, help="run on the given port", type=int) tornado.options.parse_command_line() http_server = tornado.httpserver.HTTPServer(Application(), xheaders=True) http_server.listen(options.port) print("Application started. Listening on port %d." % options.port) tornado.ioloop.IOLoop.instance().start()
def main(args=None): if args is None: args = sys.argv options.define('root', default='.', help='document root') options.define('proxy', default='', help='http proxy') options.parse_command_line() log.enable_pretty_logging() main_loop = ioloop.IOLoop.instance() pool = cf.ThreadPoolExecutor(max_workers=4) application = web.Application([ (r'/(.*)', IndexHandler, { 'root': options.options.root, 'pool': pool, 'proxy': options.options.proxy, }), ], debug=True) application.listen(8000) main_loop.start() pool.shutdown() main_loop.close() return 0
def __init__(self): Configuration() DeviceManager() ThreadPoolManager() define('port', 80, None, int) define("debug", default=True, help="Debug Mode", type=bool)
def parse_config(self): """Parses the command line arguments, and assign their values to our local traits. """ if not self.command_line_options_inited: for traitlet_name, traitlet in self.traits().items(): define( traitlet_name, default=traitlet.default_value, type=type(traitlet.default_value), help=traitlet.help) self.__class__.command_line_options_inited = True tornado.options.parse_command_line() # Workaround for change in jupyterhub 0.7.0. # Args are passed with quotes, that are preserved in the arguments when # we retrieve them. We just get rid of the quotes, until a better # solution comes along. # See jupyterhub/jupyterhub#836 for details. opts = {k: remove_quotes(v) for k, v in options.as_dict().items()} set_traits_from_dict(self, opts) # Normalize the base_urlpath to end with a slash self.base_urlpath = with_end_slash(self.base_urlpath)
def main(): # pragma: no cover """ Actually fire up the web server. Listens on 4096. """ define('port', default=4096) define('style_host', default='localhost') define('style_port', default=4097) define('log_level', default='INFO') define('log_format', default='%(asctime)s %(levelname)s [%(thread)d] ' + '[%(X-Socrata-RequestId)s] %(name)s %(message)s') parse_command_line() init_logging() routes = [ web.url(r'/', web.RedirectHandler, {'url': '/version'}), web.url(r'/version', VersionHandler), web.url(r'/render', RenderHandler, { 'style_host': options.style_host, 'style_port': options.style_port, 'http_client': AsyncHTTPClient() }), ] app = web.Application(routes) app.listen(options.port) logger = get_logger() logger.info('Listening on localhost:4096...') IOLoop.instance().start()
def mainloop(): """ get options configure application and start io loop """ topt.define("alligator", default="tcp://localhost:5555", help="Alligator command server ZMQ endpoint") topt.define("port", type=int, default=4444, help="webserver port") topt.parse_command_line() port = topt.options.port application = tw.Application([ (r"/", MainHandler), (r"/workbench/(.*)", tw.StaticFileHandler, dict(path="../www")), (r"/alligator", AlligatorWsHandler, dict(endpoint=topt.options.alligator)) ]) log.info('bridge ws to alligator: %s', topt.options.alligator) application.listen(port) log.info('server listening on: %d', port) try: tio.IOLoop.instance().start() except KeyboardInterrupt as u: log.info("user interrupted") except Exception as e: log.error(e)
def start_with_options(self): """ 从命令行参数启动 """ from tornado.options import options, define define("includes", default="", help="specify tasks and tickers to run") define("excludes", default="", help="specify tasks and tickers not to run") options.parse_command_line() tasks = {} tickers = [] if options.includes: tps = options.includes.split(",") for tp in tps: pair = tp.split(":") if len(pair) == 2: tasks[pair[0]] = int(pair[1]) else: tickers.append(pair[0]) tasks[IdleTask.name] = 1 else: tasks = {name: num for name, (task_cls, num, standalone) in self.tasks_cls.items() if not standalone} tickers = self.all_tickers.keys() if options.excludes: tps = options.excludes.split(",") for tp in tps: tasks.pop(tp, None) if tp in tickers: tickers.remove(tp) self.start_all(tasks, tickers)
def run_server(): define('settings', '') tornado.options.parse_command_line() parse_config_file(options.settings) server = HTTPServer(Application(), xheaders=True) server.listen(int(options.port)) IOLoop.instance().start()
def main(): from tornado.options import define, options define("port", default=8001, help="run on the given port", type=int) define("debug", default=True, help="debug mode", type=bool) tornado.options.parse_command_line() # also send logs through syslog to get them into graylog if not options.debug: """ This will send things through syslogd, and into /var/log/syslog by default. to get them into graylog, you probably need to tinker with rsyslog or syslog-ng settings. see: http://dev.nuclearrooster.com/2011/04/05/forwarding-rsyslog-to-graylog2/ for simple examples """ import logging import logging.handlers logger = logging.getLogger() handler = logging.handlers.SysLogHandler(address='/dev/log') handler.setFormatter(tornado.log.LogFormatter(color=False)) logger.addHandler(handler) http_server = tornado.httpserver.HTTPServer( App(options.debug) ) http_server.listen(options.port) info( 'Serving on port %d' % options.port ) tornado.ioloop.IOLoop.instance().start()
def main(): define("port", default=9990, help="run on the given port", type=int) settings = {"debug": False, "template_path": "templates", "cookie_secret": "z1DAVh+WTvyqpWGmOtJCQLETQYUznEuYskSF062J0To="} tornado.options.parse_command_line() application = tornado.web.Application([ (r"/api/detail/(.*)", DetailHandler), (r"/api/url/(.*)", UrlHandler), (r"/api/downdetail/(.*)", VideoDownHandler), (r"/api/down", BackupVideoHandler), (r"/api/down/(.*)", GeturlHandler), (r"/api/set/(.*)", SeturlHandler), (r"/api/s", SearchHandler), (r"/api/ss", SHandler), (r"/api/movie/hot", MvhotHandler), (r"/api/movie/new", MvnewHandler), (r"/api/tv/new", TvnewHandler), (r"/api/tv/hot", TvhotHandler), (r"/api/cate", CateHandler), (r"/api/img/(.*)", ImgHandler), (r"/api/hot/word", WordHandler), (r"/api/mini", MiniHandler), (r"/api/proxycheck", CheckHandler), ], **settings) http_server = tornado.httpserver.HTTPServer(application) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def SvcDoRun(self): import servicemanager servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,servicemanager.PYS_SERVICE_STARTED,(self._svc_name_, '')) self.timeout = 3000 self.run = True while self.run: rc = win32event.WaitForSingleObject(self.hWaitStop, self.timeout) # Check to see if self.hWaitStop happened if rc == win32event.WAIT_OBJECT_0: # Stop signal encountered servicemanager.LogInfoMsg("Stephano_Meditech - STOPPED") break else: from tornado.options import parse_command_line, parse_config_file, define, options from application import create_db_instance define('dir') #parse_config_file('./GISMOH.conf') parse_command_line(final=True) importer = MeditechImport(create_db_instance(options.db_type, options.db_constr), options.dir) importer.scan_dir()
def start(): #tornado.options.parse_command_line() # 定义Tornado url urls = \ [ (r'/login', LoginHandler), (r'/logout', LogoutHandler), (r'/main', MainHandler), #(r'/assets[/]?(.*)', TestHandler), (r'/assets/test.html', TestHandler), (r'/assets/user_list.html', UserListHandler), (r'/assets/user_list_add.html', UserListAddHandler), (r'/getdata', API2MysqlHandler), #(r'/assets/asset_children/(.*)', tornado.web.StaticFileHandler, {"path": settings['asset_children']}), # 后台文件路径 ] #Tornado监听IP/端口 define("host", default=LISTEN_HOST, help="run on the given host", type=str) define("port", default=LISTEN_PORT, help="run on the given port", type=int) application = tornado.web.Application(urls,**settings) try: http_server = tornado.httpserver.HTTPServer(application,xheaders=True) http_server.listen(port=options.port, address=options.host) print 'Tornado load config finished,run at %s:%d; locate test url http://127.0.0.1:%d' % (LISTEN_HOST,LISTEN_PORT,LISTEN_PORT) tornado.ioloop.IOLoop.instance().start() except Exception,err: print 'Tornado 启动失败' raise err
def __init__(self, defines): for setting_define in defines: if setting_define.name.upper() != setting_define.name: raise ValueError("Setting name must be uppercase.") if setting_define.content_type not in self._setting_parsers: raise ValueError("Unknown setting content type.") if setting_define.name in self.__dict__: raise ValueError("Invalid setting name.") default = os.getenv( '{prefix}_{attr}'.format( prefix=self.ENV_PREFIX, attr=setting_define.name), setting_define.default ) parser = self._setting_parsers[setting_define.content_type] options.define( setting_define.name, type=parser.OPTIONS_TYPE, default=parser.decode(value=default), help=setting_define.description ) options.parse_command_line()
def main(): define('port', default=1013, help='run on the given port', type=int) tornado.options.parse_command_line() http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): global config global dm with open('dm-config.json', 'r') as f: config = json.load(f) logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.getLevelName(config['config']['log_level']), stream=sys.stderr) define("port", default=5000, help="run on the given port", type=int) tornado.options.parse_command_line() logging.info("Starting up...") deployer_utils.fill_hadoop_env(config['environment']) package_repository = PackageRepoRestClient(config['config']["package_repository"], config['config']['stage_root']) dm = deployment_manager.DeploymentManager(package_repository, package_registrar.HbasePackageRegistrar( config['environment']['hbase_thrift_server'], config['environment']['webhdfs_host'], 'hdfs', config['environment']['webhdfs_port'], config['config']['stage_root']), application_registrar.HbaseApplicationRegistrar( config['environment']['hbase_thrift_server']), config['environment'], config['config']) http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): define("console", default=False, type=bool) define("mongo_host", default="localhost") parse_command_line() basicConfig(options=options) db = Connection(options.mongo_host)["crunch"]["company_stats"]
def main(): define("port", default=Config.data['web']['port'], help="run on the given port", type=int) options.parse_command_line() logger.set_logger('web-{}.log'.format(options.port)) http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
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 parser(): define('script', default='/var/maple/') define('dbhost', default='localhost') define('dbuser', default='root') define('dbpass', default='') define('db', default='maple') parse_config_file('/etc/maple/default.conf')
from tornado.options import define, options import tornado.web from app.app import Application from app.model.model import ModelCRUD define("port", default=8888, help="run on the given port", type=int) define("psql_host", default="127.0.0.1", help="blog database host") define("psql_port", default="5432", help="blog database host") define("psql_database", default="tornado_blog", help="blog database name") define("psql_user", default="igor", help="blog database user") define("psql_password", default="", help="blog database password") def create_app(): application = Application() ioloop = tornado.ioloop.IOLoop.instance() application.db = ModelCRUD(options, ioloop) future = application.db.db.connect() ioloop.add_future(future, lambda f: ioloop.stop()) ioloop.start() future.result() return application, ioloop if __name__ == "__main__": tornado.options.parse_command_line() application, ioloop = create_app()
import os.path import tornado.httpserver import tornado.ioloop import tornado.options import tornado.web from lib.core.engine import scan from tornado.options import define, options define("port", default=8000, help="run on the given port", type=int) class IndexHandler(tornado.web.RequestHandler): def get(self): self.render('index.html') class FeedBackHandler(tornado.web.RequestHandler): def post(self): target = self.get_argument('target') self.render('feedback.html', target=scan(target)) if __name__ == '__main__': tornado.options.parse_command_line() app = tornado.web.Application(handlers=[(r'/', IndexHandler), (r'/feedback', FeedBackHandler)], template_path=os.path.join( os.path.dirname(__file__), "templates")) http_server = tornado.httpserver.HTTPServer(app)
from textblob import TextBlob import pandas as pd from sklearn.externals import joblib import tornado.ioloop import tornado.web import tornado.websocket from tornado.options import define, options used_features = [ 'screen_name_binary', 'name_binary', 'description_binary', 'status_binary', 'listed_count_binary', 'verified', 'followers_count', 'friends_count', 'statuses_count' ] bag_of_words_bot = 'bot', 'b0t' define("port", default=8888, type=int) websockets = [] class IndexHandler(tornado.web.RequestHandler): def data_received(self, chunk): pass def get(self): self.render("index.html") class WebSocketHandler(tornado.websocket.WebSocketHandler): def data_received(self, chunk): pass
from tornado.options import define, options from tornado.ioloop import IOLoop from app.api.token import TokenHandler from app.api.message import MessageHandler from app.api.menu import MenuHandler from app.api.event_setting import EventSettingHandler from app.views.menu import MenuViewHandler from app.views.event_setting import EventSettingViewHandler from app.provider import ServiceProvider import json import os define("address", default="127.0.0.1", type=str, help="server address to bind on") define("port", default=9001, type=int, help="server port to bind on") define("debug", default=False, help="run in debug mode", type=bool) options.parse_command_line() config_file = '{}/config.json'.format(os.path.dirname(__file__)) if not os.path.isfile(config_file): raise Exception("config file {} not found!".format(config_file)) with open(config_file) as f: config = json.load(f) _service_provider = ServiceProvider(IOLoop.current(), config)
from tornado.options import define, options, parse_command_line from tornado.httpserver import HTTPServer import tornado.gen import tornadoredis import logging logger = logging.getLogger(__name__) import heapq from config import redis_config, redis_channel from finders.flatfile import Flatfile from finders.proxyspy import ProxySpy tornado.httpclient.AsyncHTTPClient.configure( "tornado.curl_httpclient.CurlAsyncHTTPClient") define("debug", default=True, type=bool, help="debug mode?") define("port", default=1234, type=int, help="expose waldo on which port?") define("loglevel", default='INFO', type=str, help='logging level') pth = lambda x: os.path.join(os.path.dirname(__file__), x) redis_conn = tornadoredis.Client(**redis_config) redis_conn.connect() class ProxyServer(HTTPServer): http_client = tornado.httpclient.AsyncHTTPClient() fatal_error_codes = (403, 599) def __init__(self, *args, **kwargs): self.user_agents = open(pth('user_agents.txt')).readlines()
# -*- coding:utf-8-*- __author__ = 'hougd' import os.path import tornado.web import tornado.ioloop import tornado.httpserver import tornado.options from tornado.options import define, options define('port', default=7777, help='run on the given port', type=int) class IndexHandler(tornado.web.RequestHandler): def get(self): self.render('index.html') class PoemPageHandler(tornado.web.RequestHandler): def post(self): noun1 = self.get_argument('noun1') noun2 = self.get_argument('noun2') verb = self.get_argument('verb') noun3 = self.get_argument('noun3') self.render('poem.html', roads=noun1, wood=noun2, made=verb, difference=noun3)
import json import datetime import hashlib import tornado.ioloop import tornado.options import tornado.httpserver import tornado.web import tornado.template from tornado.options import options, define from collections import OrderedDict from bgmi.config import BGMI_SAVE_PATH, DB_PATH from bgmi.models import Download, Bangumi, Followed, STATUS_NORMAL, STATUS_UPDATING, STATUS_END WEEK = ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun') define('port', default=8888, help='listen on the port', type=int) define('address', default='0.0.0.0', help='binding at given address', type=str) IMAGE_URL = 'http://bangumi.redrock-team.com' def md5(_, string): return hashlib.md5(string.encode('utf-8')).hexdigest() def make_dicts(cursor, row): return dict((cursor.description[idx][0], value) for idx, value in enumerate(row))
import collections import random import base64 import hashlib import numpy as np from detect import Detector from seg import Segmentor from bodyheight import HeightCalculation from fat import FatDetector from multi_task import MultiTaskDetector from PIL import Image, ImageOps from tornado.concurrent import run_on_executor from concurrent.futures import ThreadPoolExecutor from tornado.options import define, options define("port", default=50000, help="run on the given port", type=int) define("dev", default=True, help="dev mode", type=bool) define("model", default="ret300,ret600", help="model", type=str) class ConfigHandler(tornado.web.RequestHandler): def get(self): config = { 'min_height': 600, 'jpeg_quality': 80, 'max_interval': 3200, 'delay_time': 3000,
import tornado import tornado.autoreload from tornado.ioloop import IOLoop from tornado.options import define, options from handlers import WhatsAppHookHandler, IndexHandler, SpotifyAuthHandler, SpotifyCallbackHandler from spotify import Spotify from whatsapp import WhatsApp import os define('port', default=8888, help='port to listen on') def main(): dirname = os.path.dirname(os.path.realpath(__file__)) spotify = Spotify() whatsapp = WhatsApp() app = tornado.web.Application([ ('/', IndexHandler), ('/whatsapp/hook', WhatsAppHookHandler, dict(spotify=spotify)), ('/auth/spotify/callback', SpotifyCallbackHandler, dict(spotify=spotify)), ('/auth/spotify', SpotifyAuthHandler, dict(spotify=spotify)), ], autoreload=True)
import logging import tornado.escape import tornado.ioloop import tornado.options import tornado.web import tornado.websocket import os.path import os from time import gmtime, strftime import car from tornado.options import define, options define("port", default=8081, help="run on the given port", type=int) define("image_interval", default="0.5", help="interval for image recoding") define("replay", default='', help="folder to replay") define("record", default=False, help="record frames to a folder", type=bool) the_car = None class Application(tornado.web.Application): def __init__(self): handlers = [ (r"/", MainHandler), (r"/car", CarSocketHandler), ] settings = dict( cookie_secret="1233",
# Script to run server; pass port option to change listening port # Place one level outside of directory server/ from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado.options import define, options from server import create_app from server.config import ProductionConfig define("port", default=5000, help="Port to listen on", type=int) #app = create_app(config=ProductionConfig) app = create_app() #DebugConfig http_server = HTTPServer(WSGIContainer(app)) http_server.listen(options.port) IOLoop.instance().start()
# -*- coding: utf-8 -*- import json import os import re import traceback from typing import Any import inspect import tornado.web from tornado import httputil from tornado.web import Application from tornado.options import define, options # 默认配置 define('login_url', default='/login.html', type=str) define('error_format', default='json', type=str) class BindHandler(tornado.web.RequestHandler): """ 绑定控制器,使控制器支持绑定模式 """ def get(self): self.execute_bind_handler('GET') def post(self): self.execute_bind_handler('POST') def put(self): self.execute_bind_handler('PUT')
import sys from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado.options import define, options from tornado.web import Application from server.RootHandler import RootHandler from server.LoginHandler import LoginHandler from server.MessageWebSocket import MessageWebSocket from server.FileHandler import FileHandler define("port", default=8080, help="Listener port") options.parse_command_line() application = Application([("/", RootHandler), ("/login", LoginHandler), ("/wsmessage", MessageWebSocket), ('/client/(.*)', FileHandler, { 'path': "client" })]) http_server = HTTPServer(application) http_server.listen(options.port) print("Listening on port", options.port) IOLoop.current().start()
# -*- coding:utf-8 -*- # 上传文件 import tornado.web import tornado.ioloop import tornado.httpserver from tornado.options import define, options define("port", default=8000, type=int, help="server port...") class IndexHandler(tornado.web.RequestHandler): def get(self, *args, **kwargs): self.write("get...") def post(self, *args, **kwargs): self.write() class UploadHandler(tornado.web.RequestHandler): def get(self, *args, **kwargs): self.write("get...") def post(self, *args, **kwargs): res = self.request.files.get("image1") print(type(self.request.files)) print(self.request.files.keys()) print(type(self.request.files.get("image1"))) self.write("post..upload")
on 20170721 Tornado + Tensorflow 多线程 """ import os from concurrent.futures import ThreadPoolExecutor import tornado.httpserver import tornado.ioloop import tornado.options import tornado.web from tornado.concurrent import run_on_executor from tornado.options import define os.environ["CUDA_VISIBLE_DEVICES"] = "" define("port", default=18015, help="run on the given port", type=int) import tensorflow as tf import numpy as np a = tf.placeholder(tf.float32, shape=(100, 100), name="input") asquare = tf.multiply(a, a, name="output") config = tf.ConfigProto(device_count={"CPU": 20}, inter_op_parallelism_threads=10, intra_op_parallelism_threads=10) sess = tf.Session(config=config) class IndexHandler(tornado.web.RequestHandler): executor = ThreadPoolExecutor(4)
#!/usr/bin/env python # -*- coding: utf-8 -*- import tornado.web import tornado.ioloop from tornado.web import RequestHandler from tornado.options import optins, define define("port", default=9000, type=int, help="") class IndexHandler(RequestHandler):
from gevent.monkey import patch_all patch_all() from tornado.options import define, options, parse_command_line, print_help from features.configuration import Configuration define("config", default='debug', help="run configuration settings", type=str) define("local_settings", default="true", help="enable/disable use of local settings", type=str) if __name__ == '__main__': parse_command_line() Configuration.initialize() values = Configuration.values() from features.paypal import paypal_main paypal_main.send_email_paypal_failed(to_='*****@*****.**', checkout_id=398)
import logging import tornado import tornado.template import os from tornado.options import define, options import environment import logconfig # Make filepaths relative to settings. path = lambda root, *a: os.path.join(root, *a) ROOT = os.path.dirname(os.path.abspath(__file__)) define("port", default=8888, help="run on the specified port", type=int) define("config", default=None, help="tornado config file") define("debug", default=False, help="debug mode") tornado.options.parse_command_line() MEDIA_ROOT = path(ROOT, 'media') TEMPLATE_ROOT = path(ROOT, 'template') # Deployment Configuration class DeploymentType: SOLO = "SOLO" PRODUCTION = "PRODUCTION" DEV = "DEV" STAGING = "STAGING" dict = {SOLO: 1, PRODUCTION: 2, STAGING: 3, DEV: 4}
# -*- coding: utf-8 -*- from __future__ import unicode_literals, print_function from datetime import datetime import os import tornado from tornado.options import define, options from tornado.web import RequestHandler from tornado.websocket import WebSocketHandler # 设置服务器端口 define("port", default=2222, type=int) class IndexHandler(RequestHandler): def get(self): self.render("chat-client.html") class ChatHandler(WebSocketHandler): users = set() # 用来存放在线用户的容器 def open(self): # 建立连接后添加用户到容器中 self.users.add(self) # 向已在线用户发送消息 for user in self.users: remote_ip, port = self.request.connection.context.address now = datetime.now().strftime("%H:%M:%S")
# -*- coding: UTF-8 -*- import os import tornado.web from tornado.web import url from tornado.options import define, options from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from tracer.handlers import Login, Logout, TracerManager, TracerShower, QRViewer from tracer.models import BaseModel define("debug", default=False, help="Run in debug mode", type=bool) define("db_connect_string", default="sqlite://", help="Load the givent config file") define("db_rebuild", default=False, help="Drop all database tables", type=bool) class Application(tornado.web.Application): def __init__(self): handlers = [ url(r"/login", Login, name="Login"), url(r"/logout", Logout, name="Logout"), url(r"/admin/tracer/(\blist|get|add|remove|update\b)/(\w+)", TracerManager, name="TracerManager"), url(r"/admin/qr", QRViewer, name="QRViewer"), url(r"/tracer/([0-9a-zA-Z]{8,})", TracerShower, name="TracerShower"), ] settings = dict(
# test app server for ryan import tornado.web import tornado.ioloop import tornado.options import tornado.httpserver import os from tornado.options import define define("port", default=7926, type=int) class BaseHandler(tornado.web.RequestHandler): pass class IndexHandler(BaseHandler): def get(self): self.render("index.html") def post(self): pass class AppHandler(BaseHandler): def get(self): pass def post(self): pass handlers = [ (r"/", IndexHandler),
# -*- coding: utf-8 -*- import tornado.ioloop import tornado.httpserver import tornado.web from tornado.options import define, options define('port', default=8088, type=int, help='please run this port') class Post(tornado.web.RequestHandler): def post(self): name = self.get_argument('name') city = self.get_argument('city') self.write('Hope {} in {} happy.'.format(name, city)) if __name__ == '__main__': tornado.options.parse_command_line() app = tornado.web.Application(handlers=[( r'/', Post, )], debug=True) http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
from multiprocessing.managers import BaseManager import json import sqlite3 from datetime import datetime, date, time import settings import tornado.httpserver import tornado.ioloop import tornado.web import tornado.websocket import tornado.gen from tornado.options import define, options import tornado.web as web import npbc_communication define("port", default=settings.WEB_UI_PORT, help="run on the given port", type=int) class IndexHandler(tornado.web.RequestHandler): def get(self): self.render('index.html') class GetInfoHandler(tornado.web.RequestHandler): def get(self): dbconn = sqlite3.connect(settings.DATABASE) cursor = dbconn.cursor() cursor.row_factory = sqlite3.Row cursor.execute( "SELECT [SwVer], [Power], [Flame], [Tset], [Tboiler], [State], [Status], [DHW] \
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import logging from hashlib import sha1 from pymongo import * from bson import * from pymongo.errors import * from constants import * import tornado.options from tornado.options import define, options define("apns", default=(), help="APNs address and port") define("pemdir", default="pemdir", help="Directory to store pems") define("passwordsalt", default="d2o0n1g2s0h3e1n1g", help="Being used to make password hash") define("mongohost", default="localhost", help="MongoDB host name") define("mongoport", default=27017, help="MongoDB port") define("mongodbname", default="airnotifier", help="MongoDB database name") define("masterdb", default="airnotifier", help="MongoDB DB to store information") if __name__ == "__main__": tornado.options.parse_config_file("airnotifier.conf") tornado.options.parse_command_line()
import boto3 import errno import logging import tempfile import os import shutil from abc import ABC, abstractmethod from pathlib import Path from botocore.exceptions import ClientError from tornado.options import define, options from blockserver import monitoring as mon define('s3_bucket', help='Name of S3 bucket', default='qabel') StorageObject = NamedTuple('StorageObject', [('prefix', str), ('file_path', str), ('etag', str), ('local_file', str), ('size', int), ('fd', object)]) StorageObject.__new__.__defaults__ = (None, ) * len(StorageObject._fields) def file_key(storage_object: StorageObject): return '{}/{}'.format(storage_object.prefix, storage_object.file_path) class AbstractTransfer(ABC): def __init__(self, cache):
#--**coding:utf-8**-- import os, requests, json from tornado.web import Application, RequestHandler from tornado.ioloop import IOLoop from tornado.httpserver import HTTPServer from tornado.options import options, define import whoosh.index as index from whoosh_search.config import indexdir_path from whoosh import columns, fields, index, sorting from whoosh.qparser import QueryParser, MultifieldParser, query define("port", default=8000, type=int) class IndexHandler(RequestHandler): def get(self): # 获取get方式传递的参数 # items = ["安静", "思念", "伤感",'运动','古风','浪漫'] # items = {'One':['quiet',"安静"],'Two':['miss',"思念"] ,'Three': ['sad',"伤感"],'Four':['sport','运动'],'Five':['antiquity','古风'],'Six':['romance','浪漫']} items = { 'One': ['quiet', "安静"], 'Two': ['miss', "思念"], 'Three': ['sad', "伤感"], 'Five': ['antiquity', '古风'] } self.render("section1.html", title="My title", items=items, query_result='')
#!/usr/bin/env python #-*-coding:utf-8-*- import tornado.web import tornado.options import tornado.httpserver import tornado.ioloop from tornado.options import define, options define("port", default=8888, type=int, help="run on the given port") class MainHandler(tornado.web.RequestHandler): def get(self): self.write(''' <html><body><form method="post" action="/"> <input type="text" name="message"> <input type="submit" value="Submit"> </form></body></html> ''') def post(self): self.set_header("Content-Type", "text/plain") self.write("You wrote " + self.get_argument("message", "")) if __name__ == "__main__": application = tornado.web.Application(handlers=[ (r'/', MainHandler)], debug=True)
from datetime import datetime from random import randint from pycket.session import SessionMixin import tornado.httpserver import tornado.web import tornado.websocket import tornado.ioloop import tornado.escape from tornado.options import define, options from models.connect import session from models.User import User from sqlalchemy import and_, or_,text,func ,extract,not_,exists #定义一个默认的端口 define("port", default=9000, help="run port ", type=int) define("t", default=False, help="creat tables", type=bool) define("a", default=False, help="creat tables", type=bool) class AuthError(Exception): def __init__(self, msg): super(AuthError, self).__init__(msg) class BaseHandler(tornado.web.RequestHandler, SessionMixin): def initialize(self): self.db=session def get_current_user(self): if self.session.get("user_name"): return User.by_name(self.session.get("user_name"))
settings = dict( template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "statics"), debug=True, ) cache = redis.StrictRedis("localhost", 6379) factorial = FactorialService(cache) pi = PiService(cache) if __name__ == '__main__': # 创建一个应用对象 define("port", default=8088, type=int, help="run server on the given port.") handlers = [ (r'/', IndexHandler), (r'/index', HelloTornado), (r'/api/getallblog', GetALlBlog, dict(db=mysqldb)), (r'/api/testbasicauth', BasicAuthHandler, dict(db=mysqldb)), # 适合页面请求 (r'/api/getblogbycategory/(?P<category>.+)', GetBlogByCategory, dict(db=mysqldb)), (r'/api/python/(?P<name>.+)/(?P<age>[0-9]+)', GetPython), # 适合API请求 (r'/api/getblogbyany/', GetBlogByAny), (r"/api/fact", FactorialHandler, { "factorial": factorial }),
#coding:utf-8 import os.path import torndb import tornado.httpserver import tornado.web import tornado.options import tornado.ioloop import tornado.web import datetime import config from lib.task_cache import TaskCache from tornado.options import define, options from lib.models import OfficialAccount define("port", default=config.SERVER_PORT, help="run port", type=int) define("mysql_host", default=config.MYSQL_HOST) define("mysql_database", default=config.MYSQL_DATABASE) define("mysql_user", default=config.MYSQL_USER) define("mysql_password", default=config.MYSQL_PASSWORD) TEMPLATE_PATH = os.path.join(os.path.dirname(__file__), "templates") STATIC_PATH = os.path.join(os.path.dirname(__file__), "static") REDIS_CACHE = TaskCache(db=1) class Application(tornado.web.Application): def __init__(self): handlers = [(r"/get/task", Task)] settings = dict(template_path=TEMPLATE_PATH, static_path=STATIC_PATH,