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)
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()
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 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=(), 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 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 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]
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)
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 __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 __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 __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
kwargs['shutdown_timeout'] = kwargs.get('shutdown_timeout', 0.1)
kwargs['listen_on'] = kwargs.get('listen_on', 'localhost')
kwargs['port'] = kwargs.get('port', 0)
self.loop = ServerLoop(
create_http_handler(handler),
opts=Options(**kwargs),
plugins=plugins,
log=ServerLog(level=ServerLog.WARN),
)
self.log = self.loop.log
specialize(self)
def __init__(self, libraries, opts):
log = access_log = None
log_size = opts.max_log_size * 1024 * 1024
if opts.log:
log = RotatingLog(opts.log, max_size=log_size)
if opts.access_log:
access_log = RotatingLog(opts.access_log, max_size=log_size)
self.handler = Handler(libraries, opts)
if opts.custom_list_template:
with lopen(os.path.expanduser(opts.custom_list_template), 'rb') as f:
self.handler.router.ctx.custom_list_template = json.load(f)
if opts.search_the_net_urls:
with lopen(os.path.expanduser(opts.search_the_net_urls), 'rb') as f:
self.handler.router.ctx.search_the_net_urls = json.load(f)
plugins = []
if opts.use_bonjour:
plugins.append(BonJour(wait_for_stop=max(0, opts.shutdown_timeout - 0.2)))
self.loop = ServerLoop(
create_http_handler(self.handler.dispatch),
opts=opts,
log=log,
access_log=access_log,
plugins=plugins)
self.handler.set_log(self.loop.log)
self.handler.set_jobs_manager(self.loop.jobs_manager)
self.serve_forever = self.loop.serve_forever
self.stop = self.loop.stop
if is_running_from_develop:
from calibre.utils.rapydscript import compile_srv
compile_srv()
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 __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 __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()
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)
def __init__(self, libraries, opts):
log = None
if opts.log:
log = RotatingLog(opts.log, max_size=opts.max_log_size)
self.handler = Handler(libraries, opts)
plugins = []
if opts.use_bonjour:
plugins.append(BonJour())
self.loop = ServerLoop(create_http_handler(self.handler.dispatch), opts=opts, log=log, plugins=plugins)
self.handler.set_log(self.loop.log)
self.serve_forever = self.loop.serve_forever
self.stop = self.loop.stop
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
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)
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
specialize(self)
def __init__(self, libraries, opts):
log = None
if opts.log:
log = RotatingLog(opts.log, max_size=opts.max_log_size)
self.handler = Handler(libraries, opts)
plugins = []
if opts.use_bonjour:
plugins.append(BonJour())
self.loop = ServerLoop(create_http_handler(self.handler.dispatch),
opts=opts,
log=log,
plugins=plugins)
self.handler.set_log(self.loop.log)
self.serve_forever = self.loop.serve_forever
self.stop = self.loop.stop
_df = os.environ.get('CALIBRE_DEVELOP_FROM', None)
if _df and os.path.exists(_df):
from calibre.utils.rapydscript import compile_srv
compile_srv()
def __init__(self, libraries, opts):
log = access_log = None
log_size = opts.max_log_size * 1024 * 1024
if opts.log:
log = RotatingLog(opts.log, max_size=log_size)
if opts.access_log:
access_log = RotatingLog(opts.access_log, max_size=log_size)
self.handler = Handler(libraries, opts)
plugins = []
if opts.use_bonjour:
plugins.append(BonJour())
self.loop = ServerLoop(create_http_handler(self.handler.dispatch),
opts=opts,
log=log,
access_log=access_log,
plugins=plugins)
self.handler.set_log(self.loop.log)
self.handler.set_jobs_manager(self.loop.jobs_manager)
self.serve_forever = self.loop.serve_forever
self.stop = self.loop.stop
if is_running_from_develop:
from calibre.utils.rapydscript import compile_srv
compile_srv()
def run_echo_server():
s = ServerLoop(create_http_handler(websocket_handler=EchoHandler()))
with HandleInterrupt(s.wakeup):
s.serve_forever()
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()
def run_echo_server():
s = ServerLoop(create_http_handler(websocket_handler=EchoHandler()))
with HandleInterrupt(s.wakeup):
s.serve_forever()
