# -*- coding: utf-8 -*- # vi:si:et:sw=4:sts=4:ts=4 import os import sys import signal import time from tornado.ioloop import IOLoop from tornado.web import StaticFileHandler, Application from cache import Cache from item.handlers import EpubHandler, ReaderHandler, FileHandler from item.handlers import OMLHandler, UploadHandler from item.icons import IconHandler import db import node.server import oxtornado import downloads import settings import setup import state import tasks import websocket import ui_websocket import update import logging logger = logging.getLogger(__name__) class MainHandler(OMLHandler): def get(self, path): version = settings.MINOR_VERSION.split('-')[0] if version == 'git': version = int(time.mktime(time.gmtime())) path = os.path.join(settings.static_path, 'html', 'oml.html') with open(path) as fd: content = fd.read() content = content.replace('.js?1', '.js?%s' % version) if state.update: content = content.replace('oml.js', 'oml.update.js') self.set_header('Content-Type', 'text/html') self.set_header('Content-Length', str(len(content))) self.set_header('Cache-Control', 'no-cache, no-store, must-revalidate') self.set_header('Pragma', 'no-cache') self.set_header('Expires', '0') self.write(content) def log_request(handler): if settings.DEBUG_HTTP: if handler.get_status() < 400: log_method = logger.info elif handler.get_status() < 500: log_method = logger.warning else: log_method = logger.error request_time = 1000.0 * handler.request.request_time() log_method("%d %s %.2fms", handler.get_status(), handler._request_summary(), request_time) def shutdown(): state.shutdown = True if state.tor: state.tor._shutdown = True if state.nodes: logger.debug('shutdown nodes') state.nodes.join() if state.downloads: logger.debug('shutdown downloads') state.downloads.join() logger.debug('shutdown http_server') if state.tasks: logger.debug('shutdown tasks') state.tasks.join() if state.update: logger.debug('shutdown updates') state.update.join() if state.node: state.node.stop() if state.tor: logger.debug('shutdown tor') state.tor.shutdown() for peer in state.peers: state.peers[peer].join() if state.PID and os.path.exists(state.PID): logger.debug('remove %s', state.PID) os.unlink(state.PID) def run(): PID = sys.argv[2] if len(sys.argv) > 2 else None if len(sys.argv) > 3 and sys.argv[2] == 'debug': PID = sys.argv[3] debug = True else: debug = False log_format = '%(asctime)s:%(levelname)s:%(name)s:%(message)s' if debug: logging.basicConfig(level=logging.DEBUG, format=log_format) else: logging.basicConfig(level=logging.DEBUG, handlers=[logging.FileHandler(settings.log_path, 'w', 'utf-8')], format=log_format) options = { 'debug': False, 'log_function': log_request, 'gzip': True } common_handlers = [ (r'/(favicon.ico)', StaticFileHandler, {'path': settings.static_path}), (r'/static/oxjs/(.*)', StaticFileHandler, {'path': os.path.join(settings.base_dir, '..', 'oxjs')}), (r'/static/cbr.js/(.*)', StaticFileHandler, {'path': os.path.join(settings.base_dir, '..', 'reader', 'cbr.js')}), (r'/static/epub.js/(.*)', StaticFileHandler, {'path': os.path.join(settings.base_dir, '..', 'reader', 'epub.js')}), (r'/static/pdf.js/(.*)', StaticFileHandler, {'path': os.path.join(settings.base_dir, '..', 'reader', 'pdf.js')}), (r'/static/txt.js/(.*)', StaticFileHandler, {'path': os.path.join(settings.base_dir, '..', 'reader', 'txt.js')}), (r'/static/(.*)', StaticFileHandler, {'path': settings.static_path}), (r'/(.*)/epub/(.*)', EpubHandler), (r'/(.*?)/reader/', ReaderHandler), (r'/(.*?)/cbr/', FileHandler), (r'/(.*?)/pdf/', FileHandler), (r'/(.*?)/txt/', FileHandler), (r'/(.*?)/get/', FileHandler, { 'attachment': True }), (r'/(.*)/(cover|preview)(\d*).jpg', IconHandler), ] handlers = common_handlers + [ (r'/api/upload/', UploadHandler, dict(context=db.session)), (r'/api/', oxtornado.ApiHandler, dict(context=db.session)), (r'/ui_socket', ui_websocket.Handler), (r'/ws', websocket.Handler), (r"(.*)", MainHandler), ] public_handlers = common_handlers + [ (r'/api/', oxtornado.ApiHandler, dict(context=db.session, public=True)), (r'/ws', websocket.Handler, dict(public=True)), (r"(.*)", MainHandler), ] setup.create_db() http_server = Application(handlers, **options) max_buffer_size = 2*1024*1024*1024 http_server.listen(settings.server['port'], settings.server['address'], max_buffer_size=max_buffer_size) # public server ''' public_port = settings.server.get('public_port') public_address = settings.server['public_address'] if public_port: public_server = Application(public_handlers, **options) public_server.listen(public_port, public_address) ''' if PID: with open(PID, 'w') as pid: pid.write('%s' % os.getpid()) state.update = update.update_available() state.PID = PID state.http_server = http_server state.main = IOLoop.instance() state.cache = Cache(ttl=60) def start_node(): import nodes import tor import bandwidth state.bandwidth = bandwidth.Bandwidth() state.tor = tor.Tor() state.node = node.server.start() state.nodes = nodes.Nodes() def publish(): if not state.tor.is_online(): state.main.call_later(10, publish) else: nodes.publish_node() state.main.add_callback(publish) state.main.call_later(10, lambda: state.tasks.queue('scanimport')) if not state.update: state.downloads = downloads.Downloads() state.tasks = tasks.Tasks() state.main.add_callback(start_node) else: state.update = update.Update() if ':' in settings.server['address']: host = '[%s]' % settings.server['address'] elif not settings.server['address']: host = '127.0.0.1' else: host = settings.server['address'] url = 'http://%s:%s/' % (host, settings.server['port']) print('open browser at %s' % url) logger.debug('Starting OML %s at %s', settings.VERSION, url) signal.signal(signal.SIGTERM, shutdown) try: state.main.start() except: print('shutting down...') shutdown()