class LibraryServer(TestServer): def __init__(self, library_path, libraries=(), plugins=(), specialize=lambda x: None, **kwargs): Thread.__init__(self, name='ServerMain') from calibre.srv.opts import Options from calibre.srv.loop import ServerLoop from calibre.srv.handler import Handler from calibre.srv.http_response import create_http_handler self.setup_defaults(kwargs) opts = Options(**kwargs) self.libraries = libraries or (library_path, ) self.handler = Handler(self.libraries, opts, testing=True) self.loop = ServerLoop( create_http_handler(self.handler.dispatch), opts=opts, plugins=plugins, log=ServerLog(level=ServerLog.WARN), ) self.handler.set_log(self.loop.log) specialize(self) def __exit__(self, *args): self.loop.stop() self.handler.close() self.join(self.loop.opts.shutdown_timeout)
class ReloadServer(Thread): daemon = True def __init__(self, listen_on): Thread.__init__(self, name='ReloadServer') self.reload_handler = ReloadHandler() self.loop = ServerLoop( create_http_handler(websocket_handler=self.reload_handler), opts=Options(shutdown_timeout=0.1, listen_on=(listen_on or '127.0.0.1'), port=0)) self.loop.LISTENING_MSG = None self.notify_reload = self.reload_handler.notify_reload self.ping = self.reload_handler.ping self.start() def run(self): try: self.loop.serve_forever() except KeyboardInterrupt: pass def __enter__(self): while not self.loop.ready and self.is_alive(): time.sleep(0.01) self.address = self.loop.bound_address[:2] os.environ['CALIBRE_AUTORELOAD_PORT'] = native_string_type( self.address[1]) return self def __exit__(self, *args): self.loop.stop() self.join(self.loop.opts.shutdown_timeout)
class ReloadServer(Thread): daemon = True def __init__(self, listen_on): Thread.__init__(self, name='ReloadServer') self.reload_handler = ReloadHandler() self.loop = ServerLoop( create_http_handler(websocket_handler=self.reload_handler), opts=Options(shutdown_timeout=0.1, listen_on=(listen_on or '127.0.0.1'), port=0)) self.loop.LISTENING_MSG = None self.notify_reload = self.reload_handler.notify_reload self.ping = self.reload_handler.ping self.start() def run(self): try: self.loop.serve_forever() except KeyboardInterrupt: pass def __enter__(self): while not self.loop.ready and self.is_alive(): time.sleep(0.01) self.address = self.loop.bound_address[:2] os.environ['CALIBRE_AUTORELOAD_PORT'] = str(self.address[1]) return self def __exit__(self, *args): self.loop.stop() self.join(self.loop.opts.shutdown_timeout)
class LibraryServer(TestServer): def __init__(self, library_path, libraries=(), plugins=(), **kwargs): Thread.__init__(self, name='ServerMain') from calibre.srv.opts import Options from calibre.srv.loop import ServerLoop from calibre.srv.handler import Handler from calibre.srv.http_response import create_http_handler self.setup_defaults(kwargs) opts = Options(**kwargs) self.libraries = libraries or (library_path, ) self.handler = Handler(self.libraries, opts, testing=True) self.loop = ServerLoop( create_http_handler(self.handler.dispatch), opts=opts, plugins=plugins, log=ServerLog(level=ServerLog.DEBUG), ) self.log = self.loop.log self.handler.set_log(self.log) def __exit__(self, *args): try: self.loop.stop() except Exception as e: self.log.error('Failed to stop server with error:', e) self.handler.close() self.join(self.loop.opts.shutdown_timeout) self.loop.close_control_connection()
class TestServer(Thread): daemon = True def __init__(self, handler, plugins=(), specialize=lambda srv: None, **kwargs): Thread.__init__(self, name='ServerMain') from calibre.srv.opts import Options from calibre.srv.loop import ServerLoop from calibre.srv.http_response import create_http_handler self.setup_defaults(kwargs) self.loop = ServerLoop( create_http_handler(handler), opts=Options(**kwargs), plugins=plugins, log=ServerLog(level=ServerLog.WARN), ) self.log = self.loop.log self.silence_log = self.log specialize(self) def setup_defaults(self, kwargs): kwargs['shutdown_timeout'] = kwargs.get('shutdown_timeout', 0.1) kwargs['listen_on'] = kwargs.get('listen_on', 'localhost') kwargs['port'] = kwargs.get('port', 0) kwargs['userdb'] = kwargs.get('userdb', ':memory:') def run(self): try: self.loop.serve_forever() except KeyboardInterrupt: pass def __enter__(self): self.start() while not self.loop.ready and self.is_alive(): time.sleep(0.01) self.address = self.loop.bound_address[:2] return self def __exit__(self, *args): self.loop.stop() self.join(self.loop.opts.shutdown_timeout) def connect(self, timeout=None, interface=None): if timeout is None: timeout = self.loop.opts.timeout if interface is None: interface = self.address[0] return httplib.HTTPConnection(interface, self.address[1], strict=True, timeout=timeout) def change_handler(self, handler): from calibre.srv.http_response import create_http_handler self.loop.handler = create_http_handler(handler)
class LibraryServer(TestServer): def __init__(self, library_path, libraries=(), plugins=(), specialize=lambda x:None, **kwargs): Thread.__init__(self, name='ServerMain') from calibre.srv.opts import Options from calibre.srv.loop import ServerLoop from calibre.srv.handler import Handler from calibre.srv.http_response import create_http_handler self.setup_defaults(kwargs) opts = Options(**kwargs) self.libraries = libraries or (library_path,) self.handler = Handler(self.libraries, opts, testing=True) self.loop = ServerLoop( create_http_handler(self.handler.dispatch), opts=opts, plugins=plugins, log=ServerLog(level=ServerLog.WARN), ) self.handler.set_log(self.loop.log) specialize(self) def __exit__(self, *args): self.loop.stop() self.handler.close() self.join(self.loop.opts.shutdown_timeout)
class TestServer(Thread): daemon = True def __init__(self, handler, plugins=(), **kwargs): Thread.__init__(self, name='ServerMain') from calibre.srv.opts import Options from calibre.srv.loop import ServerLoop from calibre.srv.http_response import create_http_handler self.setup_defaults(kwargs) self.loop = ServerLoop( create_http_handler(handler), opts=Options(**kwargs), plugins=plugins, log=ServerLog(level=ServerLog.DEBUG), ) self.log = self.loop.log def setup_defaults(self, kwargs): kwargs['shutdown_timeout'] = kwargs.get('shutdown_timeout', 0.1) kwargs['listen_on'] = kwargs.get('listen_on', 'localhost') kwargs['port'] = kwargs.get('port', 0) kwargs['userdb'] = kwargs.get('userdb', ':memory:') def run(self): try: self.loop.serve_forever() except KeyboardInterrupt: pass def __enter__(self): self.start() while not self.loop.ready and self.is_alive(): time.sleep(0.01) self.address = self.loop.bound_address[:2] return self def __exit__(self, *args): try: self.loop.stop() except Exception as e: self.log.error('Failed to stop server with error:', e) self.join(self.loop.opts.shutdown_timeout) self.loop.close_control_connection() def connect(self, timeout=None, interface=None): if timeout is None: timeout = self.loop.opts.timeout if interface is None: interface = self.address[0] ans = http_client.HTTPConnection(interface, self.address[1], timeout=timeout) ans.connect() return ans def change_handler(self, handler): from calibre.srv.http_response import create_http_handler self.loop.handler = create_http_handler(handler)
class TestServer(Thread): daemon = True def __init__(self, handler, plugins=(), specialize=lambda srv:None, **kwargs): Thread.__init__(self, name='ServerMain') from calibre.srv.opts import Options from calibre.srv.loop import ServerLoop from calibre.srv.http_response import create_http_handler self.setup_defaults(kwargs) self.loop = ServerLoop( create_http_handler(handler), opts=Options(**kwargs), plugins=plugins, log=ServerLog(level=ServerLog.WARN), ) self.log = self.loop.log self.silence_log = self.log specialize(self) def setup_defaults(self, kwargs): kwargs['shutdown_timeout'] = kwargs.get('shutdown_timeout', 0.1) kwargs['listen_on'] = kwargs.get('listen_on', 'localhost') kwargs['port'] = kwargs.get('port', 0) kwargs['userdb'] = kwargs.get('userdb', ':memory:') def run(self): try: self.loop.serve_forever() except KeyboardInterrupt: pass def __enter__(self): self.start() while not self.loop.ready and self.is_alive(): time.sleep(0.01) self.address = self.loop.bound_address[:2] return self def __exit__(self, *args): self.loop.stop() self.join(self.loop.opts.shutdown_timeout) def connect(self, timeout=None, interface=None): if timeout is None: timeout = self.loop.opts.timeout if interface is None: interface = self.address[0] if ispy3: return http_client.HTTPConnection(interface, self.address[1], timeout=timeout) else: return http_client.HTTPConnection(interface, self.address[1], strict=True, timeout=timeout) def change_handler(self, handler): from calibre.srv.http_response import create_http_handler self.loop.handler = create_http_handler(handler)
class TestServer(Thread): daemon = True def __init__(self, handler, **kwargs): Thread.__init__(self, name='ServerMain') from calibre.srv.opts import Options from calibre.srv.loop import ServerLoop from calibre.srv.http_response import create_http_handler kwargs['shutdown_timeout'] = kwargs.get('shutdown_timeout', 0.1) self.loop = ServerLoop( create_http_handler(handler), opts=Options(**kwargs), bind_address=('localhost', 0), log=TestLog(level=ThreadSafeLog.WARN), ) self.log = self.loop.log def run(self): try: self.loop.serve_forever() except KeyboardInterrupt: pass def __enter__(self): self.start() while not self.loop.ready and self.is_alive(): time.sleep(0.01) self.address = self.loop.bound_address[:2] return self def __exit__(self, *args): self.loop.stop() def connect(self, timeout=None): if timeout is None: timeout = self.loop.opts.timeout return httplib.HTTPConnection(self.address[0], self.address[1], strict=True, timeout=timeout) def change_handler(self, handler): from calibre.srv.http_response import create_http_handler self.loop.handler = create_http_handler(handler)
class Server: loop = current_thread = exception = None state_callback = start_failure_callback = None def __init__(self, library_broker, notify_changes): opts = server_config() lp, lap = log_paths() try: os.makedirs(cache_dir()) except OSError as err: if err.errno != errno.EEXIST: raise log_size = opts.max_log_size * 1024 * 1024 log = RotatingLog(lp, max_size=log_size) access_log = RotatingLog(lap, max_size=log_size) self.handler = Handler(library_broker, opts, notify_changes=notify_changes) plugins = self.plugins = [] if opts.use_bonjour: plugins.append(BonJour(wait_for_stop=max(0, opts.shutdown_timeout - 0.2))) self.opts = opts self.log, self.access_log = log, access_log self.handler.set_log(self.log) self.handler.router.ctx.custom_list_template = custom_list_template() self.handler.router.ctx.search_the_net_urls = search_the_net_urls() @property def ctx(self): return self.handler.router.ctx @property def user_manager(self): return self.handler.router.ctx.user_manager def start(self): if self.current_thread is None: try: self.loop = ServerLoop( create_http_handler(self.handler.dispatch), opts=self.opts, log=self.log, access_log=self.access_log, plugins=self.plugins ) self.loop.initialize_socket() except Exception as e: self.loop = None self.exception = e if self.start_failure_callback is not None: try: self.start_failure_callback(as_unicode(e)) except Exception: pass return self.handler.set_jobs_manager(self.loop.jobs_manager) self.current_thread = t = Thread( name='EmbeddedServer', target=self.serve_forever ) t.daemon = True t.start() def serve_forever(self): self.exception = None from calibre.srv.content import reset_caches try: if is_running_from_develop: from calibre.utils.rapydscript import compile_srv compile_srv() except BaseException as e: self.exception = e if self.start_failure_callback is not None: try: self.start_failure_callback(as_unicode(e)) except Exception: pass return if self.state_callback is not None: try: self.state_callback(True) except Exception: pass reset_caches() # we reset the cache as the server tdir has changed try: self.loop.serve_forever() except BaseException as e: self.exception = e if self.state_callback is not None: try: self.state_callback(False) except Exception: pass def stop(self): if self.loop is not None: self.loop.stop() self.loop = None def exit(self): if self.current_thread is not None: self.stop() self.current_thread.join() self.current_thread = None @property def is_running(self): return self.current_thread is not None and self.current_thread.is_alive()
class Server(object): loop = current_thread = exception = None state_callback = start_failure_callback = None def __init__(self, library_broker, notify_changes): opts = server_config() lp, lap = log_paths() try: os.makedirs(cache_dir()) except EnvironmentError as err: if err.errno != errno.EEXIST: raise log_size = opts.max_log_size * 1024 * 1024 log = RotatingLog(lp, max_size=log_size) access_log = RotatingLog(lap, max_size=log_size) self.handler = Handler(library_broker, opts, notify_changes=notify_changes) plugins = self.plugins = [] if opts.use_bonjour: plugins.append(BonJour()) self.opts = opts self.log, self.access_log = log, access_log self.handler.set_log(self.log) self.handler.router.ctx.custom_list_template = custom_list_template() @property def ctx(self): return self.handler.router.ctx @property def user_manager(self): return self.handler.router.ctx.user_manager def start(self): if self.current_thread is None: try: self.loop = ServerLoop( create_http_handler(self.handler.dispatch), opts=self.opts, log=self.log, access_log=self.access_log, plugins=self.plugins ) self.loop.initialize_socket() except Exception as e: self.loop = None self.exception = e if self.start_failure_callback is not None: try: self.start_failure_callback(as_unicode(e)) except Exception: pass return self.handler.set_jobs_manager(self.loop.jobs_manager) self.current_thread = t = Thread( name='EmbeddedServer', target=self.serve_forever ) t.daemon = True t.start() def serve_forever(self): self.exception = None from calibre.srv.content import reset_caches try: if is_running_from_develop: from calibre.utils.rapydscript import compile_srv compile_srv() except BaseException as e: self.exception = e if self.start_failure_callback is not None: try: self.start_failure_callback(as_unicode(e)) except Exception: pass return if self.state_callback is not None: try: self.state_callback(True) except Exception: pass reset_caches() # we reset the cache as the server tdir has changed try: self.loop.serve_forever() except BaseException as e: self.exception = e if self.state_callback is not None: try: self.state_callback(False) except Exception: pass def stop(self): if self.loop is not None: self.loop.stop() self.loop = None def exit(self): if self.current_thread is not None: self.stop() self.current_thread.join() self.current_thread = None @property def is_running(self): return self.current_thread is not None and self.current_thread.is_alive()