def main():
define("port", default=8000, help="run on the port", type=int)
define("debug", default=False, help="run in debug mode", type=bool)
options.parse_command_line()
# =====
global_scope = globals()
handlers = []
for key in global_scope:
if key.endswith("_handlers"):
handlers.extend(global_scope[key])
# =====
class Main(tornado.web.Application):
def __init__(self, *args, **kwargs):
super(Main, self).__init__(*args, **kwargs)
self.config = config
@property
def db(self):
return DbHelper()
app = Main(
handlers,
cookie_secret="config.COOKIE_SECRET",
login_url="/login",
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=True,
debug=options.debug,
gzip=True,
)
server = HTTPServer(app)
server.listen(options.port)
print "tornado launched!"
IOLoop.current().start()
def run_app():
options.parse_command_line()
# 1. Create sync router
sync_router = sockjs.tornado.SockJSRouter(SyncConnection, '/sync')
# 2. Create Tornado application
app = Application(
[
(r'/', IndexHandler),
(r'/(?P<pad_id>[0-9a-z\-]+)', PadHandler),
(r'/static/(.*)', tornado.web.StaticFileHandler, {'path': STATIC_ROOT})
] + sync_router.urls,
cookie_secret=options.cookie_secret,
static_url_prefix='/static/',
template_path=TEMPLATES_ROOT,
pad_lifetime=options.pad_lifetime,
)
# 3. Make Tornado app listen on port 8080
app.listen(options.port)
logging.info("App started, visit http://localhost:%s" % options.port)
logging.info("App started with options: %r" % options.as_dict())
# 4. Start IOLoop
tornado.ioloop.IOLoop.instance().start()
def main():
print("starting web.py on port %s" % options.port)
options.parse_command_line()
application = _create_tornado_app()
server = HTTPServer(application)
server.listen(options.port)
IOLoop.instance().start()
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 run():
define('day', help="The base date",default=None)
define('f', help="From date", default=None)
define('t', help="To date", default=None)
options.parse_command_line()
bday = options.day and datetime.strptime(options.day, config.DATE_FORMAT) or datetime.today()
fday = options.f and datetime.strptime(options.f, config.DATE_FORMAT) or 0
tday = options.t and datetime.strptime(options.t, config.DATE_FORMAT) or 0
redis_cli = get_redis_client()
filters = dwarf.daux.Filter(redis_cli).expand(gender=1).overlap(regu=2)
filters = filters.filter(dwarf.daux.Filter(redis_cli).expand(gender=2).overlap(regu=2))
filters = None
au = dwarf.daux.AUstat(bday, redis_cli, filters= filters)
print "baseDay:", bday , "from:" , fday, "to:", tday
# s = time.time()
# print "dau:", au.get_dau(), time.time()-s
# s = time.time()
# print "dnu:", au.get_dnu(bday), time.time()-s
# s = time.time()
# print "listdau:", au.list_dau(fday=fday, tday=tday), time.time()-s
s = time.time()
print "listdnu:", au.list_dnu(fday=fday, tday=tday), time.time()-s
# s = time.time()
# print "mau:", au.mau(fday=fday, tday=tday), time.time()-s
# s = time.time()
# print "retained:" , au.get_month_retained(fday=fday, tday=tday), time.time()-s
s = time.time()
print "new user retained:", au.get_retained_nu(fday=fday, tday=tday), time.time()-s
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 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():
options.define("port", default="8888")
options.define("watch", type=str, multiple=True, default=".",
help="watch file or directory")
options.define("htdoc", type=str, default=".", help="root directory of HTML documents")
options.define("command", type=str, multiple=True, metavar="COMMAND",
help="run COMMAND when file or directory is changed")
options.parse_command_line()
mypath = os.path.dirname(os.path.abspath(__file__))
assets_path = os.path.join(mypath, 'assets')
for f in options.watch:
watcher.watch(f)
watcher.add_hook(_run_cmd)
watcher.start()
application = tornado.web.Application([
(r"/ws", WebSocketHandler),
(r"/assets/(.*)", tornado.web.StaticFileHandler, {"path": assets_path}),
(r"/(.*\.html)", MainHandler),
(r"/(.*)", tornado.web.StaticFileHandler, {"path": options.htdoc}),
])
application.listen(8888)
logging.info('starting application')
try:
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
logging.info('bye')
def boreas():
from tornado.options import define, options
from boreas import server
define("config", help="Configuration module", type=str)
define("debug", default=True, help="Enable debugging urls", type=bool)
define("api_port", default=8001, help="API port", type=int)
define("api_host", default='127.0.0.1', help="API host", type=str)
define("ws_port", default=8002, help="Websocket port", type=int)
define("ws_host", default='127.0.0.1', help="Websocket host", type=str)
define("token_provider", default='boreas.utils.tokens:no_tokens', help="Function providing initial tokens", type=str)
define("require_auth", default=True, help="Flag indicating if user has to authenticate", type=bool)
options.parse_command_line()
if options.config is None:
# assume boreas.conf in working directory
conf_file = 'boreas.conf'
try:
options.parse_config_file(conf_file)
except IOError:
pass # just use defaults
else:
conf_file = options.config
options.parse_config_file(conf_file)
server.run(options)
def run():
options.parse_command_line()
http_server = HTTPServer(SiteApplication())
http_server.listen(options.port)
print "running on %s:%d" % (options.host, options.port)
IOLoop.instance().start()
def __init__(self, extra_handlers):
'''Expects a list of tuple handlers like:
[(r"/", MainHandler), (r"/chatsocket", ChatSocketHandler),]
'''
url = settings._server_str % (settings.PROTOCOL, settings.HOSTNAME, settings.AUTHSERVERPORT)
app_settings = {
"cookie_secret": settings.COOKIE_SECRET,
"login_url": ''.join((url, "/login")),
}
handlers = []
handlers.append((r"/version", VersionHandler))
handlers.append((r"/source", SelfServe))
handlers.append((r"/ping", PingHandler))
handlers.append((r"/", PingHandler))
handlers.extend(extra_handlers)
options.parse_command_line()
dburi = options.dburi
# Connect to the elixir db
setup(db_uri=dburi)
Application.__init__(self, handlers, debug=True, **app_settings)
def main():
options.parse_command_line()
App().listen(options.port, options.host, xheaders=True)
print "VANELLOPE running on %s:%d" % (options.host, options.port)
schedule = ioloop.PeriodicCallback(scan_session_store, 1000 * 5)
schedule.start()
ioloop.IOLoop.instance().start()
def main():
global NODES_DATABASE
###--log_file_prefix=./server.log
###--logging=debug
enable_pretty_logging()
options.parse_command_line()
cur_dir = os.path.split(os.path.realpath(__file__))[0]
if options.mode == 'online':
fetch_node_info()
else:
db_file_path = '%s/nodes_db_lean.json' % cur_dir
if not os.path.exists(db_file_path):
fetch_node_info()
else:
NODES_DATABASE = json.load(open(db_file_path))
gen_log.info('load nodes database from json done!')
gen_log.debug(NODES_DATABASE)
app = myApplication()
http_server = HTTPServer(app)
http_server.listen(8080)
tcp_server = DeviceServer()
tcp_server.listen(8000)
gen_log.info("server's running in lean mode ...")
ioloop.IOLoop.current().start()
def main():
server_path = path.dirname(__file__)
template_path = path.join(server_path, 'templates')
static_path = path.normpath(path.join(server_path, '..', 'client'))
settings = {
'static_path': static_path,
'template_path': template_path,
'xsrf_cookies': False, # TODO: Enable
'login_url': '/',
'db': motor.MotorClient().chessrank,
}
app_settings = load_app_settings()
settings.update(app_settings)
handlers = [
(r'/api/tournaments(?:/([0-9a-fA-F]{24}))?.*', TournamentHandler),
(r'/api/sections(?:/([0-9a-fA-F]{24}))?.*', SectionHandler),
(r'/api/players(?:/([0-9a-fA-F]{24}))?.*', PlayerHandler),
(r'/api/users(?:/([0-9a-fA-F]{24}))?.*', UserHandler),
(r'/api/session', SessionHandler),
(r'/api/lookups', LookupsHandler),
(r'/api.*', ApiHandler),
(r'/verify/(.+)', VerifyPageHandler),
(r'/', IndexPageHandler)
]
options.parse_command_line()
app = CustomApp(handlers, 'localhost', **settings)
app.listen(options.port)
IOLoop.instance().start()
def main():
define('listen', metavar='IP', default='127.0.0.1', help='listen on IP address (default 127.0.0.1)')
define('port', metavar='PORT', default=8888, type=int, help='listen on PORT (default 8888)')
define('debug', metavar='True|False', default=False, type=bool,
help='enable Tornado debug mode: templates will not be cached '
'and the app will watch for changes to its source files '
'and reload itself when anything changes')
options.parse_command_line()
settings = dict(
template_path=rel('templates'),
static_path=rel('static'),
debug=options.debug
)
application = Application([
(r'/', MainHandler),
(r'/ws', EchoWebSocket),
(r'/websocket', SignallingHandler),
(r'/webrtc', WebRTCHandler)
], **settings)
#application.listen(address=options.listen, port=options.port)
application.listen(7080)
IOLoop.instance().start()
def run_server():
parse_configure_file(options, define, join_path(__file__, './chat.conf'))
options.parse_command_line()
http_server = tornado.httpserver.HTTPServer(
Application(), xheaders=options.xheaders)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
def main():
# Get the Port and Debug mode from command line options or default in settings.py
options.parse_command_line()
# logging.config.dictConfig(LOG_SETTINGS)
logger = logging.getLogger("app")
# Load ML Models
logger.info("Loading IRIS Prediction Model...")
MODELS["iris"] = load_model(os.path.join(MODEL_DIR, "iris", "model.pkl"))
urls = [
(r"/live$", handler.LiveHandler),
(r"/api/iris/(?P<action>[a-zA-Z]+)?",
handler.IrisPredictionHandler, { "model": MODELS["iris"]}),
]
application = tornado.web.Application(
urls,
debug=options.debug,
autoreload=options.debug)
logger.info("Starting App on Port: {} with Debug Mode: {}".format(options.port, options.debug))
application.listen(options.port)
tornado.ioloop.IOLoop.current().start()
def main():
# Defines
define("port", default=8082, help="run on the given port", type=int)
define("log_level", default="INFO", type=str,
help="[NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL]")
define("dbconf", default="sqlite:///vanzilla.db", type=str,
help="sqlalchemy db config string")
define("mail_server", default="localhost", help="server mail", type=str)
define("mail_from", default="", help="sender address for mail error reports", type=str)
define("mail_to", default="", help="recipient addresses for mail error reports", type=str)
define("root_ips", default=[], help="IPs with global access", type=list)
define("promiscuous_load", default=False,
help="load all apps, whether they are enabled or not", type=bool)
options.parse_config_file("vanzilla.conf")
options.parse_command_line()
logging.debug(options.logging)
# Initalising applications
apps = AppsLoader(options)
# Starting tornado server
http_server = tornado.httpserver.HTTPServer(apps)
http_server.listen(options.port)
ioloop = tornado.ioloop.IOLoop.instance()
tornado.autoreload.add_reload_hook(apps.reload_tasks)
tornado.autoreload.start(ioloop)
ioloop.start()
def main():
options.parse_command_line()
app = Application()
server = tornado.httpserver.HTTPServer(app, xheaders=True)
server.bind(options.port)
server.start()
tornado.ioloop.IOLoop.current().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 parse_options(args, err_func):
define('ports', multiple=True, type=int, help='listen ports (one or more)', metavar='PORT[,PORT,...]',
default=[8001])
define('config', type=str, help='zaglushka config path')
define('watch', type=bool, help='watch config and stubs for changes', default=True)
from tornado.options import options
options.logging = 'debug'
enable_pretty_logging(options)
script_name = args[0]
simple_args = list(takewhile(lambda i: not i.startswith('--'), args[1:]))
other_args = args[len(simple_args) + 1:]
other_args.insert(0, script_name)
if simple_args:
if len(simple_args) > 2:
err_func('More than two simple args')
return None
elif len(simple_args) == 2:
config, ports = simple_args
else:
config = simple_args[0]
ports = None
options.config = config
if ports:
ports = (i.strip() for i in ports.split(','))
try:
ports = map(int, ports)
except (TypeError, ValueError):
err_func('Wrong port value')
return None
options.ports = ports
options.logging = 'debug'
options.parse_command_line(args=other_args)
return options
def main():
router = [
(r'/', HomeHandler),
]
options.parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application(router, My404, debug=(options.env == 'dev')))
http_server.listen(options.port)
tornado.ioloop.IOLoop.current().start()
def main():
options.parse_command_line()
app = App()
server = HTTPServer(app)
server.listen(options.port)
ioloop.IOLoop.instance().start()
def main():
options.parse_command_line()
handlers = [(r"/send_mail/", MainHandler)]
application = tornado.web.Application(handlers)
application.listen(options.port, options.host)
tornado.ioloop.IOLoop.instance().start()
def main():
options.parse_command_line()
# 实例化一个httpserver对象
http_server = tornado.httpserver.HTTPServer(CustomApplication())
# 监听8888 套接字端口
http_server.listen(options.port)
# 启动事件循环
tornado.ioloop.IOLoop.instance().start()
def main():
tornado.web.Application(debug=env)
http_server = HTTPServer(WSGIContainer(app))
enable_pretty_logging()
options.parse_command_line()
http_server.listen(options.port)
IOLoop.instance().start()
print('Quit the server with CONTROL-C')
def run():
define("host", default=settings.HOST, help="Served host")
define("port", default=settings.PORT, help="Served port", type=int)
options.parse_command_line()
http_server = HTTPServer(MyApplication())
http_server.listen(address=options.host, port=options.port)
IOLoop.instance().start()
def main():
options.parse_command_line()
app = Application()
http_server = HTTPServer(app)
http_server.listen(options.port)
#print app_path
tornado.ioloop.IOLoop.instance().start()
print "Quit the server with CONTORL-C"
def run(self):
options.log_file_prefix = "/opt/f5backup/log/api.log"
options.log_file_num_backups = 3
options.log_file_max_size = 10485760
options.parse_command_line()
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(5380, address="127.0.0.1")
IOLoop.instance().start()
def main():
define('port', default=8080, type=int, help='run on the given port')
options.parse_command_line()
app = BlogApp(options)
http_server = httpserver.HTTPServer(app)
http_server.listen(options.port)
ioloop.IOLoop.instance().start()
print('-->initialize()')
self.title = title
def get(self):
self.write('你正在查看文章：%s' %self.title)
class RegistHandler(RequestHandler):
def initialize(self, title):
self.title = title
def get(self, *args, **kwargs):
self.write("注册业务处理：" + str(self.title))
class LoginHandler(RequestHandler):
def get(self, *args, **kwargs):
self.write("用户登录页面展示")
def post(self, *args, **kwargs):
self.post("用户登录功能处理")
if __name__ == '__main__':
options.parse_command_line() # 命令行参数转换
app = Application([
(r'/', MainHandler),
(r'/article', ArticleHandler,{'title':'你希望自己成为什么样的人，最终就会成为那样的人。'}),
(r'/regist', RegistHandler, {'title':'会员注册'}),
url(r'/login', LoginHandler, name="login"),
], debug=True)
#Application 路由器设置 url(r'', handler, {k,v}, name='')
http_server = HTTPServer(app)
http_server.bind(options.port)
http_server.start(1)
IOLoop.current().start()#current() 返回当前线程的IOLoop实力对象，start() 启动IOLoop实例对象的IO循环，开启监听
def main():
options.parse_command_line()
app = Application()
app.listen(config.localport)
IOLoop.instance().start()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
from tornado.wsgi import WSGIApplication
from tornado.options import options
# 解析tornado启动参数, 设置日志debug级别
options.parse_command_line(['', '--logging=debug'])
game_env = os.getenv('game_env')
server_name = os.getenv('server_name')
print 'game_env: %s, server_name: %s' % (game_env, server_name)
import settings
settings.set_evn(game_env, server_name)
settings.ENVPROCS = 'wsgi'
from handlers import APIRequestHandler
from handlers import ConfigHandler
from handlers import AdminHandler
from handlers import Login
from handlers import Pay, PayCallBack
from handlers import AdClick
from handlers import ZhiChong360Handler
from handlers import CMGEHandler
from handlers import AdvertHandler
class Application(WSGIApplication):
from tornado.options import define, options
from config import settings
from handlers.main.main_urls import handlers
from models.account.account_user_model import User
from models.files.upload_file_model import Files
from models.article import article_model
from libs.db import create_talbes
from libs.db.dbsession import dbSession
#定义一个默认的端口
define("port", default=8000, help="run port ", type=int)
define("runserver", default=False, help="start server", type=bool)
define("t", default=False, help="create table", type=bool)
define("u", default=False, help="create user", type=bool)
if __name__ == "__main__":
options.parse_command_line()
if options.t:
create_talbes.run()
if options.u:
user = User()
user.name = 'zhangsan'
user.password = '******'
dbSession.add(user)
dbSession.commit()
if options.runserver:
app = tornado.web.Application(handlers, **settings) #创建应用实例
http_server = tornado.httpserver.HTTPServer(app) #通过应用实例创建服务器实例
http_server.listen(options.port) #监听9000端口
print 'start server...'
tornado.ioloop.IOLoop.instance().start() #启动服务器
# # logfile = 'log/debug.log'
#
# #启动的进程数
# workers = multiprocessing.cpu_count() * 2 + 1
# worker_class = 'gunicorn.workers.ggevent.GeventWorker'
#
# x_forwarded_for_header = 'X-FORWARDED-FOR'
# from gevent.wsgi import WSGIServer
# from index import app
# http_server = WSGIServer(('', 5058), app)
# http_server.serve_forever()
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from index import app
from tornado.options import options
if __name__ == '__main__':
args = options.parse_command_line()
if len(args) == 0:
port = 5098
else:
port = args[0]
http_server = HTTPServer(WSGIContainer(app), xheaders=True)
http_server.listen(port)
IOLoop.instance().start()
loglevel = 'info'
elif libiisi.m_config.getData('log_level') == '30':
loglevel = 'warring'
elif libiisi.m_config.getData('log_level') == '40':
loglevel = 'error'
else:
loglevel = 'info'
opt_args = [
'', '--logging={0}'.format(loglevel),
'--log_file_prefix={0}'.format(
os.path.join(libiisi.m_logdir, 'iisi{0}.debug.log'.format(
libiisi.cfg_bind_port)))
]
if results.debug:
opt_args.append('--log_to_stderr')
options.parse_command_line(args=opt_args, final=True)
if results.hp:
tornado.process.fork_processes(0)
libiisi.m_debug = results.debug
libiisi.m_sql = MXMariadb(
host=libiisi.m_config.getData('db_host').split(':')[0],
port=3306 if len(libiisi.m_config.getData('db_host').split(':')) == 1
else int(libiisi.m_config.getData('db_host').split(':')[1]),
user=libiisi.m_config.getData('db_user'),
pwd=mx.decode_string(libiisi.m_config.getData('db_pwd')),
maxconn=int(libiisi.m_config.getData('max_db_conn')))
libiisi.m_sql.set_debug(results.debug)
# 开启后台线程
import json
import sys
import logging
from tornado.options import define, options
from griotte.websocket import WebSocket
from griotte.config import Config
import tornado.ioloop
Config("DEFAULT")
define("watchdog", default=0.1, help="Watchdog interval")
if __name__ == "__main__":
def on_message(channel, message):
logging.info(" >>> On channel \"%s\" : %s" % (channel, message))
channels = ()
channels = options.parse_command_line()
if not channels:
logging.warning("No channel specified, watching meta.presence")
channels.append("meta.presence")
ws = WebSocket()
for chan in channels:
ws.add_listener(chan, on_message)
ws.start(detach=False, watchdog_interval=options.watchdog)
def main():
options.parse_command_line()
IOLoop().start(Application(), options.port)
def main():
options.parse_command_line()
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(options.port)
logging.warn("[UOP] App is running on: localhost:%d", options.port)
IOLoop.instance().start()
import sys
import time
import tornado.ioloop
from tornado.options import define, options
from config import PORT_COUNT, TCP_PORT, WS_PORT
# For displaying throughput
processed_requests, processed_bytes = 0, 0
last_display_time = time.time()
# Ports for TCP and WS (8001~8200, 8501~8700)
define("tcpport", default=TCP_PORT, help="TCP port", type=int)
define("wsport", default=WS_PORT, help="WebSocket port", type=int)
options.parse_command_line(sys.argv)
from socket_connection import WebSocketApp, TCPSockServer
tcpserver = None
webapp = None
# Just notifies reloading
def reload_main():
logging.warn("")
logging.warn("Reload...")
def display_stats():
global tcpserver
global webapp
def main(port, host =''):
print('start listen port is {}'.format(port))
options.parse_command_line()
Application().listen(port)
tornado.ioloop.IOLoop.instance().start()
__author__ = 'grigory51'
CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
def parse_config(path):
try:
options.parse_config_file(path=path, final=False)
except IOError:
print('[WARNING] File no readable, run with default settings')
define('host',
type=str,
group='Server',
default='127.0.0.1',
help='Listen host')
define('port', type=int, group='Server', default=8080, help='Listen port')
define('server_name',
type=str,
group='Server',
default='https://bot.team.ktsstudio.ru')
define('debug', default=False, help='Tornado debug mode')
define('config', type=str, help='Path to config file', callback=parse_config)
define('runtime', type=str, help='Data dir', default=CURRENT_DIR + '/runtime/')
options.parse_command_line(final=True)
def main():
options.parse_command_line()
app = App()
app.listen(options.port)
IOLoop.current().start()
def put(filenames):
client = httpclient.AsyncHTTPClient()
for filename in filenames:
mtype = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
headers = {'Content-Type': mtype}
producer = partial(raw_producer, filename)
url_path = quote(os.path.basename(filename))
response = yield client.fetch('http://localhost:8888/%s' % url_path,
method='PUT',
headers=headers,
body_producer=producer,
timeout=18000)
print(response.body)
define("put", type=bool, help="Use PUT instead of POST", group="file uploader")
# Tornado configures logging from command line opts and returns remaining args.
filenames = options.parse_command_line()
if not filenames:
print("Provide a list of filenames to upload.", file=sys.stderr)
sys.exit(1)
for filename in filenames:
with open(filename) as f:
content = f.read()
method = put if options.put else post
name = 'pdf'
ioloop.IOLoop.current().run_sync(lambda: method(content, name))
def main():
options.parse_command_line()
print "Starting tornado web server on http://127.0.0.1:%s" % options.port
print 'Quit the server with CONTROL-C'
app.listen(options.port, xheaders=True)
tornado.ioloop.IOLoop.instance().start()
def run():
options.parse_command_line()
if options.config:
options.parse_config_file(options.config)
options.storage = os.path.abspath(options.storage)
if os.getuid() == 0 and options.user:
pw = pwd.getpwnam(options.user)
uid, gid = pw.pw_uid, pw.pw_gid
log.info("Changind user to %s [%s:%s]", options.user, uid, gid)
os.setgid(uid)
os.setuid(uid)
try:
if not all(f(options.storage) for f in (os.path.exists, os.path.isdir)):
log.info('Creating new package storage directory: "%s"', options.storage)
os.makedirs(options.storage)
def on_interrupt(*args):
log.warning("Receiving interrupt signal. Application will be stopped.")
exit(errno.EINTR)
log.debug("Preparing signal handling")
for sig in (signal.SIGINT, signal.SIGTERM, signal.SIGQUIT):
signal.signal(sig, on_interrupt)
def handle_pdb(sig, frame):
import pdb
pdb.Pdb().set_trace(frame)
if options.debug:
signal.signal(signal.SIGUSR2, handle_pdb)
log.debug("Creating application instance")
app = create_app(
options.debug,
options.secret,
options.gzip,
)
log.debug("Creating IOLoop instance.")
io_loop = IOLoop.current()
io_loop.run_sync(lambda: init_db(options.database))
if not (os.path.exists(options.cache_dir) and os.path.isdir(options.cache_dir)):
os.makedirs(options.cache_dir)
Cache.CACHE_DIR = options.cache_dir
log.info("Init thread pool with %d threads", options.pool_size)
handlers.base.BaseHandler.THREAD_POOL = futures.ThreadPoolExecutor(options.pool_size)
AsyncHTTPClient.configure(None, max_clients=options.max_http_clients)
proxy_url = URL(os.getenv('{0}_proxy'.format(options.pypi_server.scheme)))
if proxy_url:
log.debug("Configuring for proxy: %s", proxy_url)
AsyncHTTPClient.configure(
'tornado.curl_httpclient.CurlAsyncHTTPClient',
defaults={
'proxy_host': proxy_url.host,
'proxy_port': proxy_url.port,
'proxy_username': proxy_url.user,
'proxy_password': proxy_url.password,
}
)
PYPIClient.configure(
options.pypi_server,
handlers.base.BaseHandler.THREAD_POOL
)
if options.pypi_proxy:
pypi_updater = PeriodicCallback(PYPIClient.packages, HOUR * 1000, io_loop)
io_loop.add_callback(PYPIClient.packages)
io_loop.add_callback(pypi_updater.start)
log.info("Starting server http://%s:%d/", options.address, options.port)
http_server = HTTPServer(app, xheaders=options.proxy_mode)
http_server.listen(options.port, address=options.address)
log.debug('Setting "%s" as storage', options.storage)
PackageFile.set_storage(options.storage)
log.debug("Starting main loop")
io_loop.start()
except Exception as e:
log.fatal("Exception on main loop:")
log.exception(e)
exit(1)
else:
exit(0)
def load_app_options():
load_default_options()
options.parse_command_line(final=False) # 读取命令行参数
options.parse_config_file(os.path.join(
os.path.dirname(os.path.abspath(__file__)), options.conf_file),
final=True) # 读取文件配置
def main():
options.parse_command_line()
print("Starting tornado web server on http://127.0.0.1:%s" % options.port)
print("Quit the server with CONTROL-C")
svr.listen(options.port, xheaders=True)
tornado.ioloop.IOLoop.current().start()
def main():
options.parse_command_line()
app = Application()
app.listen(options.server_port, address=options.server_address)
ioloop.IOLoop.instance().start()
def main(*args, **kwargs):
options.parse_command_line()
app = Application()
app.listen(options.port)
ioloop.IOLoop.instance().start()
def main():
options.parse_command_line()
app = Application()
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
tornado.ioloop.IOLoop.current().start()
def main():
options.parse_command_line()
Application().start()
def on_disconnect(self):
pass
def on_peers(self, data):
print("peers", data)
if __name__ == "__main__":
define("ip",
default='127.0.0.1',
help="Server IP to connect to, default 127.0.0.1")
define("verbose", default=False, help="verbose")
options.parse_command_line(
final=False
) # final False is required or it activates the client logger.
if options.ip != '127.0.0.1':
URL = "ws://{}:{}/chat/".format(options.ip, DEFAULT_PORT)
print("Using {}".format(URL))
# See options https://python-socketio.readthedocs.io/en/latest/api.html
sio = Client(logger=False)
sio.register_namespace(ChatNamespace('/chat'))
sio.connect('http://{}:{}'.format(options.ip, DEFAULT_PORT),
namespaces=['/chat'])
sleep(1) # not needed
# We have to id ourselve first of all
sio.emit('hello',
def parse_arguments(argv):
if len(argv) == 2 and not argv[1].startswith('--'):
options.parse_config_file(argv[1])
else:
options.parse_command_line()
def main():
options.parse_command_line() # 读取命令行参数 且自动开启log
app = Application(urls, **settings) # 生成application对象
http_server = tornado.httpserver.HTTPServer(app) # 生成http_server对象
http_server.listen(options.port, address="127.0.0.1") # 定义监听端口
tornado.ioloop.IOLoop.current().start() # 启动服务器 开启监听
import tornado.ioloop
import tornado.web
from app.settings import SETTINGS, APP_PATH
from app.routes import ROUTES
import sys
from tornado.options import options, define
from os.path import join, dirname
import logging
logging.basicConfig(filename=join(dirname(APP_PATH), 'logs', 'server.log'),
level=logging.INFO)
define('port', 8888)
def make_app():
return tornado.web.Application(ROUTES, **SETTINGS)
if __name__ == "__main__":
args = sys.argv
options.parse_command_line(args)
app = make_app()
app.listen(options.port)
tornado.ioloop.IOLoop.current().start()
required_options = [
'address',
'port',
'database_engine',
'database_name',
]
required_options_without_default = [
'database_engine',
'database_name',
]
# Parse
options.parse_command_line(final=False)
if options.config:
try:
parse_config_file(options, options.config, 'JET', final=False)
except IOError as e:
if options.config != DEFAULT_CONFIG_PATH:
raise e
parse_environment(options, final=True)
missing_options = list(
filter(lambda x: x not in options or options[x] is None, required_options))
# Settings
def main():
options.parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application())
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
def main():
ws_app = make_app()
options.parse_command_line()
server = httpserver.HTTPServer(ws_app)
server.listen(options.port)
ioloop.IOLoop.current().start()
def main():
options.parse_command_line()
app = create_app()
server = HTTPServer(app)
server.listen(options.port)
IOLoop.instance().start()
