Beispiel #1
0
class Server(object):

    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()
Beispiel #2
0
 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()
Beispiel #3
0
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()
Beispiel #4
0
class Server(object):

    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(opts.custom_list_template, 'rb') as f:
                self.handler.router.ctx.custom_list_template = json.load(f)
        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()
Beispiel #5
0
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)
Beispiel #6
0
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)
Beispiel #7
0
class Server(object):
    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
        _df = os.environ.get('CALIBRE_DEVELOP_FROM', None)
        if _df and os.path.exists(_df):
            from calibre.utils.rapydscript import compile_srv
            compile_srv()
Beispiel #8
0
 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
Beispiel #9
0
class Server(object):

    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
Beispiel #10
0
    def test_library_restrictions(self):  # {{{
        from calibre.srv.opts import Options
        from calibre.srv.handler import Handler
        from calibre.db.legacy import create_backend
        opts = Options(userdb=':memory:')
        Data = namedtuple('Data', 'username')
        with TemporaryDirectory() as base:
            l1, l2, l3 = map(lambda x: os.path.join(base, 'l' + x), '123')
            for l in (l1, l2, l3):
                create_backend(l).close()
            ctx = Handler((l1, l2, l3), opts).router.ctx
            um = ctx.user_manager

            def get_library(username=None, library_id=None):
                ans = ctx.get_library(Data(username), library_id=library_id)
                return os.path.basename(ans.backend.library_path)

            def library_info(username=None):
                lmap, defaultlib = ctx.library_info(Data(username))
                lmap = {k:os.path.basename(v) for k, v in iteritems(lmap)}
                return lmap, defaultlib

            self.assertEqual(get_library(), 'l1')
            self.assertEqual(library_info()[0], {'l%d'%i:'l%d'%i for i in range(1, 4)})
            self.assertEqual(library_info()[1], 'l1')
            self.assertRaises(HTTPForbidden, get_library, 'xxx')
            um.add_user('a', 'a')
            self.assertEqual(library_info('a')[0], {'l%d'%i:'l%d'%i for i in range(1, 4)})
            um.update_user_restrictions('a', {'blocked_library_names': ['L2']})
            self.assertEqual(library_info('a')[0], {'l%d'%i:'l%d'%i for i in range(1, 4) if i != 2})
            um.update_user_restrictions('a', {'allowed_library_names': ['l3']})
            self.assertEqual(library_info('a')[0], {'l%d'%i:'l%d'%i for i in range(1, 4) if i == 3})
            self.assertEqual(library_info('a')[1], 'l3')
            self.assertRaises(HTTPForbidden, get_library, 'a', 'l1')
            self.assertRaises(HTTPForbidden, get_library, 'xxx')
Beispiel #11
0
 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)
Beispiel #12
0
class Server(object):
    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()
Beispiel #13
0
 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)
Beispiel #14
0
 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()
Beispiel #15
0
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
        kwargs['shutdown_timeout'] = kwargs.get('shutdown_timeout', 0.1)
        kwargs['listen_on'] = kwargs.get('listen_on', 'localhost')
        kwargs['port'] = kwargs.get('port', 0)
        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)
Beispiel #16
0
 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)
     _df = os.environ.get('CALIBRE_DEVELOP_FROM', None)
     if _df and os.path.exists(_df):
         from calibre.utils.rapydscript import compile_srv
         compile_srv()
Beispiel #17
0
 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()
Beispiel #18
0
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()
Beispiel #19
0
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()