import os
from tornado.web import Application, RequestHandler
from tornado.ioloop import IOLoop
from tornado.httpserver import HTTPServer
class IndexHandler(RequestHandler):
def get(self):
choose = self.get_query_argument("choose")
if choose == 'q_on':
print(choose)
os.system('./run.sh')
elif choose == 'q_off':
print(choose)
os.system('./stop.sh')
elif choose == 'k_close':
print(choose)
os.system('shutdown -h now')
elif choose == 'k_restart':
print(choose)
os.system('reboot')
if __name__ == "__main__":
app = Application([(r"/", IndexHandler)])
app.listen(8000)
IOLoop.current().start()
def get_app(self):
class LargeBody(RequestHandler):
def get(self):
self.write("a" * 1024 * 100)
return Application([('/large', LargeBody)])
def get_app(self):
self.app = Application(self.get_handlers(), **self.get_app_kwargs())
return self.app
def _make_app(self):
app = Application([
(r"/.*", MainHandler, dict(server=self)),
])
app.listen(self.my_port)
return app
def get_app(self):
return Application([('/', HelloHandler)])
#!/usr/bin/env python
# -*- coding:utf-8 -*-
###===========================###
# File Name: __init__.py
# Author: 030
# Site: 030.io
# Created Time: 2015/04/16 21:55
###===========================###
__version__ = '0.0.2'
from tornado.web import Application
try:
#if 1:
from .handler import handlers, settings
from .config import configs
app = Application(handlers=handlers, **settings)
except Exception as e:
print(e)
def make_app():
urls = [("/",CovidIndia)]
return Application(urls)
from models import Models
from processing import ProcessingMethods
from ml_module import MLModule
from controller import Controller
import os
models_object = Models()
processing_object = ProcessingMethods()
MLModule.models = models_object
MLModule.processing = processing_object
Controller.ml_module = MLModule
html_path = os.path.join(os.path.dirname(__file__), "static/html")
css_path = os.path.join(os.path.dirname(__file__), "static/css")
js_path = os.path.join(os.path.dirname(__file__), "static/js")
img_path = os.path.join(os.path.dirname(__file__), "static/img")
assets_path = os.path.join(os.path.dirname(__file__), "static/assets")
application = Application(
[(r'(favicon.ico)', StaticFileHandler, {
"path": img_path
}), ("/", MainHandler), ("/upload_file", FileHandler)],
template_path=html_path,
static_path=os.path.join(os.path.dirname(__file__), "static"),
)
server = HTTPServer(application)
server.listen(7000)
print("Server was started on port ", 7000)
IOLoop.current().start()
def make_application(settings):
return Application([
(r"/", PostReceiveHandler)
], **settings)
idx = sys.argv.index("--max_message_size") + 1
if idx < len(sys.argv):
value = sys.argv[idx]
if value == "None":
RosbridgeWebSocket.max_message_size = None
else:
RosbridgeWebSocket.max_message_size = int(value)
else:
print "--max_message_size argument provided without a value. (can be None or <Integer>)"
sys.exit(-1)
##################################################
# Done with parameter handling #
##################################################
application = Application([(r"/", RosbridgeWebSocket), (r"", RosbridgeWebSocket)])
connected = False
while not connected and not rospy.is_shutdown():
try:
if certfile is not None and keyfile is not None:
application.listen(port, address, ssl_options={ "certfile": certfile, "keyfile": keyfile})
else:
application.listen(port, address)
rospy.loginfo("Rosbridge WebSocket server started on port %d", port)
connected = True
except error as e:
rospy.logwarn("Unable to start server: " + str(e) +
" Retrying in " + str(retry_startup_delay) + "s.")
rospy.sleep(retry_startup_delay)
from os import getenv
from logzero import logger
from tornado.ioloop import IOLoop
from tornado.web import Application
from tornado.options import options, define, parse_command_line
from route import route
from settings import settings
from blockchain import Blockchain
from api.base import NotFoundHandler
define(
"port",
default=8888 if getenv('STG') != 'test' else 8889,
help="app port",
type=int,
)
if __name__ == "__main__":
parse_command_line()
app = Application(route, default_handler_class=NotFoundHandler, **settings)
app.objects = settings['objects']
app.blockchain = Blockchain()
logger.warning('Running on port: %s', options.port)
app.listen(options.port)
try:
IOLoop.current().start()
except KeyboardInterrupt:
IOLoop.current().stop()
def start_web_server(self):
""" Prepare request handlers and start server """
root = os.getcwd()
app = Application([(r"/()", StaticFileHandler, {
"path": root,
"default_filename": "index.html"
}),
(r"/web/client/(.*)", StaticFileHandler, {
"path": root + "/web/client"
}),
(r"/font/(.*)", StaticFileHandler, {
"path": root + "/font"
}),
(r"/icon/(.*)", StaticFileHandler, {
"path": root + "/icons"
}),
(r"/flag/(.*)", StaticFileHandler, {
"path": root + "/languages"
}),
(r"/backgrounds/(.*)", StaticFileHandler, {
"path": root + "/backgrounds"
}),
(r"/ws", WebSocketHandler, {
"redraw_web_ui": self.redraw_web_ui,
"web_clients": self.web_clients
}),
(r"/config/()", StaticFileHandler, {
"path": root + "/web/client/config",
"default_filename": "index.html"
}),
(r"/config/icon/(.*)", StaticFileHandler, {
"path": root + "/languages"
}),
(r"/config/default/(.*)", StaticFileHandler, {
"path": root + "/icons"
}),
(r"/static/js/(.*)", StaticFileHandler, {
"path": root + "/web/client/config/static/js"
}),
(r"/static/css/(.*)", StaticFileHandler, {
"path": root + "/web/client/config/static/css"
}),
(r"/static/media/(.*)", StaticFileHandler, {
"path": root + "/web/client/config/static/media"
}),
(r"/parameters", ParametersHandler, {
"config_class": self.config_class
}),
(r"/players", PlayersHandler, {
"config_class": self.config_class
}),
(r"/savers", ScreensaversHandler, {
"config": self.config
}),
(r"/podcasts", PodcastsHandler, {
"util": self.util
}),
(r"/streams", StreamsHandler, {
"util": self.util
}),
(r"/streamimage/(.*)", StaticFileHandler, {
"path": root + "/streams"
}),
(r"/playlists", PlaylistsHandler, {
"util": self.util
}), (r"/labels", LabelsHandler, {
"util": self.util
}),
(r"/command/(.*)", CommandHandler, {
"peppy": self.peppy
}), (r"/upload", UploadHandler, {
"path": root
}),
(r"/bgr", BgrHandler, {
"config_class": self.config_class
})])
if self.config[WEB_SERVER][HTTPS]:
http_server = tornado.httpserver.HTTPServer(app,
ssl_options={
"certfile": "cert",
"keyfile": "key"
})
else:
http_server = tornado.httpserver.HTTPServer(app)
port = self.config[WEB_SERVER][HTTP_PORT]
asyncio.set_event_loop(asyncio.new_event_loop())
http_server.listen(port)
self.instance = tornado.ioloop.IOLoop.instance()
logging.debug("Web Server Started")
self.instance.start()
from tornado.web import Application, url
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.options import options, define, parse_command_line
import config
define('port', default=9000, help='input port')
from common import BaseHandler
class IndexHandler(BaseHandler):
def get(self, *args, **kwargs):
self.render('upload.html')
def post(self, *args, **kwargs):
files = self.request.files.get('image', None) # 获取所有文件
message = self.upload_file(files)
self.write(message)
if __name__ == '__main__':
app = Application([
(r'/upload/', IndexHandler),
], **config.settings)
http_server = HTTPServer(app)
http_server.bind(options.port)
http_server.start()
IOLoop.current().start()
def make_app():
urls = [("/api/checkloan", CheckLoan)]
return Application(urls, debug=True)
from tornado.wsgi import WSGIContainer
from tornado.ioloop import IOLoop
from tornado.web import FallbackHandler, RequestHandler, Application
from app import app
from cassandra.auth import PlainTextAuthProvider
class MainHandler(RequestHandler):
def get(self):
self.write("This message comes from Tornado ^_^")
tr = WSGIContainer(app)
application = Application([
(r"/tornado", MainHandler),
(r".*", FallbackHandler, dict(fallback=tr)),
])
if __name__ == "__main__":
CASSANDRA_SETUP_KWARGS = {'protocol_version': 3, "auth_provider": PlainTextAuthProvider(username='******', password='******')}
application.listen(80)
IOLoop.instance().start()
# coding=utf-8
from tornado.web import RequestHandler, Application, StaticFileHandler
from tornado.ioloop import IOLoop
import os
class IndexHandler(RequestHandler):
def get(self, *args, **kwargs):
self.render('readImg.html')
app = Application(
[
(r'^/$', IndexHandler),
# (r"/static/(.*)", StaticFileHandler, {"path": os.path.join(os.getcwd(),'static','images')}),
],
template_path=os.path.join(os.getcwd(), 'templates'),
static_path=os.path.join(os.getcwd(), 'static', 'images'))
app.listen(8000)
IOLoop.instance().start()
def main():
tornado.options.parse_command_line()
app = Application(ApiServer.urls, **SETTINGS)
[i.setFormatter(LogFormatter()) for i in logging.getLogger().handlers]
app.listen(PORT, xheaders=True)
tornado.ioloop.IOLoop.current().start()
def make_app():
return Application(handlers())
log_method("%d %s %.2fms", handler.get_status(),
handler._request_summary(), request_time)
application = Application(
[
(r'^/$', handlers.MainHandler),
(r'^/config/main/(?P<op>set|get)/?$', handlers.ConfigHandler),
(r'^/config/(?P<camera_id>\d+)/(?P<op>get|set|rem|set_preview)/?$', handlers.ConfigHandler),
(r'^/config/(?P<op>add|list|backup|restore)/?$', handlers.ConfigHandler),
(r'^/picture/(?P<camera_id>\d+)/(?P<op>current|list|frame)/?$', handlers.PictureHandler),
(r'^/picture/(?P<camera_id>\d+)/(?P<op>download|preview|delete)/(?P<filename>.+?)/?$', handlers.PictureHandler),
(r'^/picture/(?P<camera_id>\d+)/(?P<op>zipped|timelapse|delete_all)/(?P<group>.+?)/?$', handlers.PictureHandler),
(r'^/movie/(?P<camera_id>\d+)/(?P<op>list)/?$', handlers.MovieHandler),
(r'^/movie/(?P<camera_id>\d+)/(?P<op>download|preview|delete)/(?P<filename>.+?)/?$', handlers.MovieHandler),
(r'^/movie/(?P<camera_id>\d+)/(?P<op>delete_all)/(?P<group>.+?)/?$', handlers.MovieHandler),
(r'^/_relay_event/?$', handlers.RelayEventHandler),
(r'^/log/(?P<name>\w+)/?$', handlers.LogHandler),
(r'^/update/?$', handlers.UpdateHandler),
(r'^/power/(?P<op>shutdown|reboot)/?$', handlers.PowerHandler),
(r'^/version/?$', handlers.VersionHandler),
(r'^/login/?$', handlers.LoginHandler),
(r'^.*$', handlers.NotFoundHandler),
],
debug=False,
log_function=_log_request,
static_path=settings.STATIC_PATH,
static_url_prefix=settings.STATIC_URL
)
template.add_context('STATIC_URL', settings.STATIC_URL)
'Sent a request that should procude an additional child span'
})
class ServerLogHandler(RequestHandler):
@tracing.trace()
def get(self):
# Alternatively, TornadoTracing.get_span(self.request)
# can be used to fetch this request's Span.
tracing.tracer.active_span.log_event('Hello, world!')
self.write({})
class ServerChildSpanHandler(RequestHandler):
@tracing.trace()
def get(self):
# Will implicitly be child of the incoming request Span.
with tracing.tracer.start_active_span('extra_child_span'):
self.write({})
if __name__ == '__main__':
app = Application([
(r'/client/log', ClientLogHandler),
(r'/client/childspan', ClientChildSpanHandler),
(r'/server/log', ServerLogHandler),
(r'/server/childspan', ServerChildSpanHandler),
], )
app.listen(8080)
IOLoop.current().start()
def get_app(self):
return Application()
from tornado.web import Application
from tornado.ioloop import IOLoop
from tornado.web import RequestHandler
class IndexHanderler(RequestHandler):
def get(self):
# 向客户端响应数据
self.write('<h3>Hello,Tornado</h3>')
if __name__ == '__main__':
# 创建WEB应用
app = Application([('/', IndexHanderler)])
# 绑定端口
app.listen(7000) # 端口 < 65535
# 启动WEB端口
print('starting http://localhost:%s' % 7000)
IOLoop.current().start()
def get_app(self):
return Application(self._settings.generate_app_list())
def make_app():
urls = route_init.list_url
urls.append((r"/data/(.*)", StaticFileHandler, {
"path": os.path.join(os.path.dirname(__file__), 'data')
}), )
return Application(urls, debug=False)
def get_app(self):
return Application([
url("/hello", HelloWorldHandler),
])
def runCouchPotato(options,
base_path,
args,
data_dir=None,
log_dir=None,
Env=None,
desktop=None):
try:
locale.setlocale(locale.LC_ALL, "")
encoding = locale.getpreferredencoding()
except (locale.Error, IOError):
encoding = None
# for OSes that are poorly configured I'll just force UTF-8
if not encoding or encoding in ('ANSI_X3.4-1968', 'US-ASCII', 'ASCII'):
encoding = 'UTF-8'
Env.set('encoding', encoding)
# Do db stuff
db_path = sp(os.path.join(data_dir, 'database'))
old_db_path = os.path.join(data_dir, 'couchpotato.db')
# Remove database folder if both exists
if os.path.isdir(db_path) and os.path.isfile(old_db_path):
db = SuperThreadSafeDatabase(db_path)
db.open()
db.destroy()
# Check if database exists
db = SuperThreadSafeDatabase(db_path)
db_exists = db.exists()
if db_exists:
# Backup before start and cleanup old backups
backup_path = sp(os.path.join(data_dir, 'db_backup'))
backup_count = 5
existing_backups = []
if not os.path.isdir(backup_path): os.makedirs(backup_path)
for root, dirs, files in os.walk(backup_path):
# Only consider files being a direct child of the backup_path
if root == backup_path:
for backup_file in sorted(files):
ints = re.findall('\d+', backup_file)
# Delete non zip files
if len(ints) != 1:
try:
os.remove(os.path.join(root, backup_file))
except:
pass
else:
existing_backups.append((int(ints[0]), backup_file))
else:
# Delete stray directories.
shutil.rmtree(root)
# Remove all but the last 5
for eb in existing_backups[:-backup_count]:
os.remove(os.path.join(backup_path, eb[1]))
# Create new backup
new_backup = sp(
os.path.join(backup_path, '%s.tar.gz' % int(time.time())))
zipf = tarfile.open(new_backup, 'w:gz')
for root, dirs, files in os.walk(db_path):
for zfilename in files:
zipf.add(os.path.join(root, zfilename),
arcname='database/%s' %
os.path.join(root[len(db_path) + 1:], zfilename))
zipf.close()
# Open last
db.open()
else:
db.create()
# Force creation of cachedir
log_dir = sp(log_dir)
cache_dir = sp(os.path.join(data_dir, 'cache'))
python_cache = sp(os.path.join(cache_dir, 'python'))
if not os.path.exists(cache_dir):
os.mkdir(cache_dir)
if not os.path.exists(python_cache):
os.mkdir(python_cache)
session = requests.Session()
session.max_redirects = 5
# Register environment settings
Env.set('app_dir', sp(base_path))
Env.set('data_dir', sp(data_dir))
Env.set('log_path', sp(os.path.join(log_dir, 'CouchPotato.log')))
Env.set('db', db)
Env.set('http_opener', session)
Env.set('cache_dir', cache_dir)
Env.set('cache', FileSystemCache(python_cache))
Env.set('console_log', options.console_log)
Env.set('quiet', options.quiet)
Env.set('desktop', desktop)
Env.set('daemonized', options.daemon)
Env.set('args', args)
Env.set('options', options)
# Determine debug
debug = options.debug or Env.setting('debug', default=False, type='bool')
Env.set('debug', debug)
# Development
development = Env.setting('development', default=False, type='bool')
Env.set('dev', development)
# Disable logging for some modules
for logger_name in [
'enzyme', 'guessit', 'subliminal', 'apscheduler', 'tornado',
'requests'
]:
logging.getLogger(logger_name).setLevel(logging.ERROR)
for logger_name in ['gntp']:
logging.getLogger(logger_name).setLevel(logging.WARNING)
# Disable SSL warning
disable_warnings()
# Use reloader
reloader = debug is True and development and not Env.get(
'desktop') and not options.daemon
# Logger
logger = logging.getLogger()
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s',
'%m-%d %H:%M:%S')
level = logging.DEBUG if debug else logging.INFO
logger.setLevel(level)
logging.addLevelName(19, 'INFO')
# To screen
if (debug or
options.console_log) and not options.quiet and not options.daemon:
hdlr = logging.StreamHandler(sys.stderr)
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
# To file
hdlr2 = handlers.RotatingFileHandler(Env.get('log_path'),
'a',
500000,
10,
encoding=Env.get('encoding'))
hdlr2.setFormatter(formatter)
logger.addHandler(hdlr2)
# Start logging & enable colors
# noinspection PyUnresolvedReferences
import color_logs
from couchpotato.core.logger import CPLog
log = CPLog(__name__)
log.debug('Started with options %s', options)
# Check soft-chroot dir exists:
try:
# Load Soft-Chroot
soft_chroot = Env.get('softchroot')
soft_chroot_dir = Env.setting('soft_chroot',
section='core',
default=None,
type='unicode')
soft_chroot.initialize(soft_chroot_dir)
except SoftChrootInitError as exc:
log.error(exc)
return
except:
log.error('Unable to check whether SOFT-CHROOT is defined')
return
# Check available space
try:
total_space, available_space = getFreeSpace(data_dir)
if available_space < 100:
log.error(
'Shutting down as CP needs some space to work. You\'ll get corrupted data otherwise. Only %sMB left',
available_space)
return
except:
log.error('Failed getting diskspace: %s', traceback.format_exc())
def customwarn(message, category, filename, lineno, file=None, line=None):
log.warning('%s %s %s line:%s', (category, message, filename, lineno))
warnings.showwarning = customwarn
# Create app
from couchpotato import WebHandler
web_base = ('/' + Env.setting('url_base').lstrip('/') +
'/') if Env.setting('url_base') else '/'
Env.set('web_base', web_base)
api_key = Env.setting('api_key')
if not api_key:
api_key = uuid4().hex
Env.setting('api_key', value=api_key)
api_base = r'%sapi/%s/' % (web_base, api_key)
Env.set('api_base', api_base)
# Basic config
host = Env.setting('host', default='0.0.0.0')
host6 = Env.setting('host6', default='::')
config = {
'use_reloader': reloader,
'port': tryInt(Env.setting('port', default=5050)),
'host': host if host and len(host) > 0 else '0.0.0.0',
'host6': host6 if host6 and len(host6) > 0 else '::',
'ssl_cert': Env.setting('ssl_cert', default=None),
'ssl_key': Env.setting('ssl_key', default=None),
}
# Load the app
application = Application(
[],
log_function=lambda x: None,
debug=config['use_reloader'],
gzip=True,
cookie_secret=api_key,
login_url='%slogin/' % web_base,
)
Env.set('app', application)
# Request handlers
application.add_handlers(
".*$",
[
(r'%snonblock/(.*)(/?)' % api_base, NonBlockHandler),
# API handlers
(r'%s(.*)(/?)' % api_base, ApiHandler), # Main API handler
(r'%sgetkey(/?)' % web_base, KeyHandler), # Get API key
(r'%s' % api_base, RedirectHandler, {
"url": web_base + 'docs/'
}), # API docs
# Login handlers
(r'%slogin(/?)' % web_base, LoginHandler),
(r'%slogout(/?)' % web_base, LogoutHandler),
# Catch all webhandlers
(r'%s(.*)(/?)' % web_base, WebHandler),
(r'(.*)', WebHandler),
])
# Static paths
static_path = '%sstatic/' % web_base
for dir_name in ['fonts', 'images', 'scripts', 'style']:
application.add_handlers(
".*$",
[('%s%s/(.*)' % (static_path, dir_name), StaticFileHandler, {
'path':
sp(os.path.join(base_path, 'couchpotato', 'static', dir_name))
})])
Env.set('static_path', static_path)
# Load configs & plugins
loader = Env.get('loader')
loader.preload(root=sp(base_path))
loader.run()
# Fill database with needed stuff
fireEvent('database.setup')
if not db_exists:
fireEvent('app.initialize', in_order=True)
fireEvent('app.migrate')
# Go go go!
from tornado.ioloop import IOLoop
from tornado.autoreload import add_reload_hook
loop = IOLoop.current()
# Reload hook
def reload_hook():
fireEvent('app.shutdown')
add_reload_hook(reload_hook)
# Some logging and fire load event
try:
log.info('Starting server on port %(port)s', config)
except:
pass
fireEventAsync('app.load')
ssl_options = None
if config['ssl_cert'] and config['ssl_key']:
ssl_options = {
'certfile': config['ssl_cert'],
'keyfile': config['ssl_key'],
}
server = HTTPServer(application,
no_keep_alive=True,
ssl_options=ssl_options)
try_restart = True
restart_tries = 5
while try_restart:
try:
server.listen(config['port'], config['host'])
if Env.setting('ipv6', default=False):
try:
server.listen(config['port'], config['host6'])
except:
log.info2('Tried to bind to IPV6 but failed')
loop.start()
server.close_all_connections()
server.stop()
loop.close(all_fds=True)
except Exception as e:
log.error('Failed starting: %s', traceback.format_exc())
try:
nr, msg = e
if nr == 48:
log.info(
'Port (%s) needed for CouchPotato is already in use, try %s more time after few seconds',
(config.get('port'), restart_tries))
time.sleep(1)
restart_tries -= 1
if restart_tries > 0:
continue
else:
return
except ValueError:
return
except:
pass
raise
try_restart = False
# -*- coding: utf-8 -*-
# @File : run.py
# @Date : 2018-08-25
# @Author : Peng Shiyu
# 应用启动入口
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.web import Application
import config
from urls import handlers
if __name__ == '__main__':
app = Application(handlers, **config.settings) # 实例web应用
# app.listen(8080) # 绑定服务器端口 二选一
http_server = HTTPServer(app) # 实例HTTP服务器
http_server.listen(config.PORT)
IOLoop.current().start() # 启动当前线程的IOLoop
# http://localhost:8080/
from tornado.websocket import WebSocketHandler
from tornado.web import Application
from tornado.ioloop import IOLoop
class EchoWebSocket(WebSocketHandler):
def data_received(self, chunk: bytes) -> Optional[Awaitable[None]]:
pass
def on_message(self, message):
print("メッセージ受信")
def reply():
self.write_reply(message)
IOLoop.instance().call_later(3, reply)
def write_reply(self, original_message: Union[str, bytes]):
print("クライアントに変身")
self.write_message("サーバーからの応答" + original_message)
def on_close(self):
print("クライアントが切断")
app = Application(handlers=[(r"/ws/echo", EchoWebSocket)])
if __name__ == '__main__':
app.listen(12349)
IOLoop.current().start()
def background_task(self, tid):
time.sleep(10) # 传递参数 10 秒。
_result[tid] = {"finish"}
@gen.coroutine
def get(self):
tid = str(int(time.time() * 10000))
self.background_task(tid)
self.write(tid)
class JobCheckHandler(RequestHandler):
def get(self):
tid = self.get_argument("tid")
if tid in _result.keys():
out = _result[tid] # 结果
del _result[tid] # 删除tid的数据。
self.write(str(out))
else:
self.write("")
# main 启动。
if __name__ == "__main__":
HTTPServer(
Application([("/", MainPage), ("/add_job", AddJobHandler),
("/job_check", JobCheckHandler)],
debug=True)).listen(8888)
print("start web .")
IOLoop.instance().start()
def get_app(self):
return Application([("/api/v1/live", FakeLiveHandler)])
