Example #1
0
    def load_part(self, part_name, plugin_name, part_properties):
        plugin = pluginhandler.load_plugin(
            plugin_name=plugin_name,
            part_name=part_name,
            properties=part_properties,
            project_options=self._project,
            part_schema=self._validator.part_schema,
            definitions_schema=self._validator.definitions_schema,
        )

        logger.debug(
            "Setting up part {!r} with plugin {!r} and "
            "properties {!r}.".format(part_name, plugin_name, part_properties)
        )

        sources = getattr(plugin, "PLUGIN_STAGE_SOURCES", None)
        keyrings = getattr(plugin, "PLUGIN_STAGE_KEYRINGS", None)
        stage_packages_repo = repo.Repo(
            plugin.osrepodir,
            sources=sources,
            keyrings=keyrings,
            project_options=self._project,
        )

        grammar_processor = grammar_processing.PartGrammarProcessor(
            plugin=plugin,
            properties=part_properties,
            project=self._project,
            repo=stage_packages_repo,
        )

        part = pluginhandler.PluginHandler(
            plugin=plugin,
            part_properties=part_properties,
            project_options=self._project,
            part_schema=self._validator.part_schema,
            definitions_schema=self._validator.definitions_schema,
            stage_packages_repo=stage_packages_repo,
            grammar_processor=grammar_processor,
            snap_base_path=path.join("/", "snap", self._project.info.name, "current"),
            base=self._project.info.base,
            confinement=self._project.info.confinement,
            snap_type=self._snap_type,
            soname_cache=self._soname_cache,
        )

        self.build_snaps |= grammar_processor.get_build_snaps()
        self.build_tools |= grammar_processor.get_build_packages()

        # TODO: this should not pass in command but the required package,
        #       where the required package is to be determined by the
        #       source handler.
        if part.source_handler and part.source_handler.command:
            # TODO get_packages_for_source_type should not be a thing.
            self.build_tools |= repo.Repo.get_packages_for_source_type(
                part.source_handler.command
            )
        self.all_parts.append(part)

        return part
    def load_part(self, part_name, plugin_name, part_properties):
        # Some legacy parts can have a '/' in them to separate the main project
        # part with the subparts. This is rather unfortunate as it affects the
        # the layout of parts inside the parts directory causing collisions
        # between the main project part and its subparts.
        part_name = part_name.replace("/", "\N{BIG SOLIDUS}")

        plugin = pluginhandler.load_plugin(
            plugin_name=plugin_name,
            part_name=part_name,
            properties=part_properties,
            project_options=self._project,
            part_schema=self._validator.part_schema,
            definitions_schema=self._validator.definitions_schema,
        )

        logger.debug("Setting up part {!r} with plugin {!r} and "
                     "properties {!r}.".format(part_name, plugin_name,
                                               part_properties))

        sources = getattr(plugin, "PLUGIN_STAGE_SOURCES", None)
        stage_packages_repo = repo.Repo(plugin.osrepodir,
                                        sources=sources,
                                        project_options=self._project)

        grammar_processor = grammar_processing.PartGrammarProcessor(
            plugin=plugin,
            properties=part_properties,
            project=self._project,
            repo=stage_packages_repo,
        )

        part = pluginhandler.PluginHandler(
            plugin=plugin,
            part_properties=part_properties,
            project_options=self._project,
            part_schema=self._validator.part_schema,
            definitions_schema=self._validator.definitions_schema,
            stage_packages_repo=stage_packages_repo,
            grammar_processor=grammar_processor,
            snap_base_path=path.join("/", "snap", self._snap_name, "current"),
            base=self._base,
            confinement=self._confinement,
            snap_type=self._snap_type,
            soname_cache=self._soname_cache,
        )

        self.build_snaps |= grammar_processor.get_build_snaps()
        self.build_tools |= grammar_processor.get_build_packages()

        # TODO: this should not pass in command but the required package,
        #       where the required package is to be determined by the
        #       source handler.
        if part.source_handler and part.source_handler.command:
            # TODO get_packages_for_source_type should not be a thing.
            self.build_tools |= repo.Repo.get_packages_for_source_type(
                part.source_handler.command)
        self.all_parts.append(part)

        return part
Example #3
0
    def _repo(self):
        if not self.__repo:
            self.__repo = repo.Repo(self._cache_dir,
                                    sources=self._sources,
                                    project_options=self._project_options)

        return self.__repo
Example #4
0
    def load_part(self, part_name, plugin_name, part_properties):
        # Some legacy parts can have a '/' in them to separate the main project
        # part with the subparts. This is rather unfortunate as it affects the
        # the layout of parts inside the parts directory causing collisions
        # between the main project part and its subparts.
        part_name = part_name.replace('/', '\N{BIG SOLIDUS}')

        plugin = pluginhandler.load_plugin(
            plugin_name=plugin_name,
            part_name=part_name,
            properties=part_properties,
            project_options=self._project_options,
            part_schema=self._validator.part_schema,
            definitions_schema=self._validator.definitions_schema)

        logger.debug('Setting up part {!r} with plugin {!r} and '
                     'properties {!r}.'.format(part_name,
                                               plugin_name,
                                               part_properties))

        sources = getattr(plugin, 'PLUGIN_STAGE_SOURCES', None)
        stage_packages_repo = repo.Repo(
            plugin.osrepodir, sources=sources,
            project_options=self._project_options)

        grammar_processor = grammar_processing.PartGrammarProcessor(
            plugin=plugin,
            properties=part_properties,
            project_options=self._project_options,
            repo=stage_packages_repo)

        part = pluginhandler.PluginHandler(
            plugin=plugin,
            part_properties=part_properties,
            project_options=self._project_options,
            part_schema=self._validator.part_schema,
            definitions_schema=self._validator.definitions_schema,
            stage_packages_repo=stage_packages_repo,
            grammar_processor=grammar_processor,
            snap_base_path=path.join('/', 'snap', self._snap_name, 'current'),
            confinement=self._confinement)

        self.build_snaps |= grammar_processor.get_build_snaps()
        self.build_tools |= grammar_processor.get_build_packages()

        if part.source_handler and part.source_handler.command:
            self.build_tools |= repo.Repo.get_packages_for_source_type(
                part.source_handler.command)
        self.all_parts.append(part)

        return part