Пример #1
0
    def setup(self, request):
        """Builds a dictionary of sr.Repository objects, keyed by the
                repository prefix, and ensures our search indexes exist."""
        def get_repo_paths():
            """Return a dictionary of repository paths, and writable
                        root directories for the repositories we're serving."""

            repo_paths = {}
            for key in request.wsgi_environ:
                if key.startswith("PKG5_REPOSITORY"):
                    prefix = key.replace("PKG5_REPOSITORY_", "")
                    repo_paths[prefix] = \
                        request.wsgi_environ[key]
                    writable_root = \
                        request.wsgi_environ.get(
                        "PKG5_WRITABLE_ROOT_{0}".format(prefix))
                    repo_paths[prefix] = \
                        (request.wsgi_environ[key],
                        writable_root)
            return repo_paths

        if repositories:
            return

        # if running the pkg5 test suite, store the correct proto area
        pkg5_test_proto = request.wsgi_environ.get("PKG5_TEST_PROTO", "")

        repository_lock.acquire()
        repo_paths = get_repo_paths()

        # We must ensure our BackgroundTask object has at least as many
        # slots available as we have repositories, to allow the indexes
        # to be refreshed. Ideally, we'd also account for a slot
        # per-publisher, per-repository, but that might be overkill on a
        # system with many repositories and many publishers that rarely
        # get 'pkgrepo refresh' requests.
        self.bgtask = BackgroundTask(
            len(repo_paths),
            busy_url="{0}/depot/depot-keepalive".format(request.base))
        self.bgtask.start()

        for prefix in repo_paths:
            path, writable_root = repo_paths[prefix]
            try:
                repo = sr.Repository(root=path,
                                     read_only=True,
                                     writable_root=writable_root)
            except sr.RepositoryError as e:
                print("Unable to load repository: {0}".format(e))
                continue

            repositories[prefix] = repo
            dconf = sd.DepotConfig()
            if writable_root is not None:
                self.bgtask.put(repo.refresh_index)

            depot = DepotBUI(repo,
                             dconf,
                             writable_root,
                             pkg5_test_proto=pkg5_test_proto)
            depot_buis[prefix] = depot

        repository_lock.release()
Пример #2
0
                        elif opt == "--writable-root":
                                ivalues["pkg"]["writable_root"] = arg

                # Set accumulated values.
                if debug_features:
                        ivalues["pkg"]["debug"] = debug_features
                if disable_ops:
                        ivalues["pkg"]["disable_ops"] = disable_ops
                if addresses:
                        ivalues["pkg"]["address"] = list(addresses)

                if DebugValues:
                        reload(pkg.digest)

                # Build configuration object.
                dconf = ds.DepotConfig(target=user_cfg, overrides=ivalues)
        except getopt.GetoptError as _e:
                usage("pkg.depotd: {0}".format(_e.msg))
        except api_errors.ApiException as _e:
                usage("pkg.depotd: {0}".format(str(_e)))
        except OptionError as _e:
                usage("pkg.depotd: option: {0} -- {1}".format(opt, _e))
        except (ArithmeticError, ValueError):
                usage("pkg.depotd: illegal option value: {0} specified " \
                    "for option: {1}".format(arg, opt))

        if show_usage:
                usage(retcode=0, full=True)

        if not dconf.get_property("pkg", "log_errors"):
                dconf.set_property("pkg", "log_errors", "stderr")