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,
