+                 "enum": ["module", "json", "comps", "none"],

+             "pdc_url": {"type": "string"},

+             "pdc_develop": {"type": "boolean", "default": False},

+             "pdc_insecure": {"type": "boolean", "default": False},

+ 

+     # call modifyrepo to inject modulemd if needed

+     if variant.mmds:

+         import yaml

+         modules = {"modules": []}

+         for mmd in variant.mmds:

+             modules["modules"].append(mmd.dumps())

+         tmp_dir = compose.mkdtemp(prefix="pungi_")

+         modules_path = os.path.join(tmp_dir, "modules.yaml")

+         with open(modules_path, "w") as outfile:

+             outfile.write(yaml.safe_dump(modules))

+         cmd = repo.get_modifyrepo_cmd(os.path.join(repo_dir, "repodata"),

+                                       modules_path, mdtype="modules",

+                                       compress_type="gz")

+         log_file = compose.paths.log.log_file(

+             arch, "modifyrepo-modules-%s" % variant)

+         run(cmd, logfile=log_file, show_cmd=True)

+         shutil.rmtree(tmp_dir)

+ 

+ # -*- coding: utf-8 -*-

+ 

+ 

+ # This program is free software; you can redistribute it and/or modify

+ # it under the terms of the GNU General Public License as published by

+ # the Free Software Foundation; version 2 of the License.

+ #

+ # This program is distributed in the hope that it will be useful,

+ # but WITHOUT ANY WARRANTY; without even the implied warranty of

+ # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+ # GNU Library General Public License for more details.

+ #

+ # You should have received a copy of the GNU General Public License

+ # along with this program; if not, see <https://gnu.org/licenses/>.

+ 

+ 

+ """

+ Get a package list based on modulemd metadata loaded in pkgset phase.

+ """

+ 

+ 

+ from pungi.wrappers.comps import CompsWrapper

+ import pungi.phases.gather.source

+ import kobo.rpmlib

+ 

+ 

+ class GatherSourceModule(pungi.phases.gather.source.GatherSourceBase):

+     enabled = True

+ 

+     def __call__(self, arch, variant):

+         groups = set()

+         packages = set()

+ 

+         if variant is not None and variant.modules:

+             rpms = variant.pkgset.rpms_by_arch[arch] + \

+                 variant.pkgset.rpms_by_arch["noarch"]

+             for rpm_obj in rpms:

+                 for mmd in variant.mmds:

+                     srpm = kobo.rpmlib.parse_nvr(rpm_obj.sourcerpm)["name"]

+                     if (srpm in mmd.components.rpms.keys() and

+                             rpm_obj.name not in mmd.filter.rpms):

+                         packages.add((rpm_obj.name, None))

+ 

+         return packages, groups

+         if primary_arch:

+             exclusivearch_list = get_valid_arches(

+                 primary_arch, multilib=False, add_noarch=False, add_src=False)

+         else:

+             exclusivearch_list = None

+                 if exclusivearch_list and arch == "noarch":

+ try:

+     from pdc_client import PDCClient

+     import modulemd

+     WITH_MODULES = True

+ except:

+     WITH_MODULES = False

+ 

+ 

+ def get_pdc_client_session(compose):

+     if not WITH_MODULES:

+         compose.log_warning("pdc_client module is not installed, "

+                             "support for modules is disabled")

+         return None

+     try:

+         return PDCClient(

+             server=compose.conf['pdc_url'],

+             develop=compose.conf['pdc_develop'],

+             ssl_verify=not compose.conf['pdc_insecure'],

+         )

+     except KeyError:

+         return None

+ 

+ 

+ def variant_dict_from_str(module_str):

+     module_info = {}

+ 

+     release_start = module_str.rfind('-')

+     module_info['variant_version'] = module_str[release_start+1:]

+     module_info['variant_id'] = module_str[:release_start]

+     module_info['variant_type'] = 'module'

+ 

+     return module_info

+ 

+ 

+ def get_module(session, module_info, strict=False):

+     """

+     :param session : PDCClient instance

+     :param module_info: pdc variant_dict, str, mmd or module dict

+     :param strict: Normally this function returns None if no module can be

+            found.  If strict=True, then a ValueError is raised.

+ 

+     :return final list of module_info which pass repoclosure

+     """

+ 

+     module_info = variant_dict_from_str(module_info)

+ 

+     query = dict(

+         variant_id=module_info['variant_id'],

+         variant_version=module_info['variant_version'],

+     )

+     if module_info.get('variant_release'):

+         query['variant_release'] = module_info['variant_release']

+ 

+     retval = session['unreleasedvariants'](page_size=-1, **query)

+ 

+     # Error handling

+     if not retval:

+         if strict:

+             raise ValueError("Failed to find module in PDC %r" % query)

+         else:

+             return None

+ 

+     module = None

+     # If we specify 'variant_release', we expect only single module to be

+     # returned, but otherwise we have to pick the one with the highest

+     # release ourselves.

+     if 'variant_release' in query:

+         assert len(retval) <= 1, compose.log_error(

+             "More than one module returned from PDC: %s" % str(retval))

+         module = retval[0]

+     else:

+         module = retval[0]

+         for m in retval:

+             if int(m['variant_release']) > int(module['variant_release']):

+                 module = m

+ 

+     return module

+ 

+     pkgset_global = populate_global_pkgset(compose, koji_wrapper, path_prefix, event_info)

+ def populate_global_pkgset(compose, koji_wrapper, path_prefix, event_id):

+     # List of compose tags from which we create this compose

+     compose_tags = []

+ 

+     # List of compose_tags per variant

+     variant_tags = {}

+ 

+     session = get_pdc_client_session(compose)

+     for variant in compose.all_variants.values():

+         variant.pkgset = pungi.phases.pkgset.pkgsets.KojiPackageSet(

+             koji_wrapper, compose.conf["sigkeys"], logger=compose._logger,

+             arches=all_arches)

+         variant_tags[variant] = []

+ 

+         # Find out all modules in every variant and add their compose tags

+         # to compose_tags list.

+         if session:

+             for module in variant.get_modules():

+                 pdc_module = get_module(session, module["name"])

+                 mmd = modulemd.ModuleMetadata()

+                 mmd.loads(pdc_module["modulemd"])

+                 tag = pdc_module["koji_tag"]

+                 variant.mmds.append(mmd)

+                 variant_tags[variant].append(tag)

+                 if tag not in compose_tags:

+                     compose_tags.append(tag)

+ 

+         if not variant_tags[variant]:

+             variant_tags[variant].append(compose.conf["pkgset_koji_tag"])

+ 

+     # In case we have no compose tag from module, use the default

+     # one from config.

+     if not compose_tags:

+         compose_tags.append(compose.conf["pkgset_koji_tag"])

+ 

+     global_pkgset_path = os.path.join(

+         compose.paths.work.topdir(arch="global"), "pkgset_global.pickle")

+         msg = "Populating the global package set from tag '%s'" % compose_tags

+         global_pkgset = pickle.load(open(global_pkgset_path, "r"))

+         global_pkgset = pungi.phases.pkgset.pkgsets.KojiPackageSet(

+             koji_wrapper, compose.conf["sigkeys"], logger=compose._logger,

+             arches=all_arches)

+         # Get package set for each compose tag and merge it to global package

+         # list. Also prepare per-variant pkgset, because we do not have list

+         # of binary RPMs in module definition - there is just list of SRPMs.

+         for compose_tag in compose_tags:

+             compose.log_info("Populating the global package set from tag "

+                              "'%s'" % compose_tag)

+             pkgset = pungi.phases.pkgset.pkgsets.KojiPackageSet(

+                 koji_wrapper, compose.conf["sigkeys"], logger=compose._logger,

+                 arches=all_arches)

+             pkgset.populate(compose_tag, event_id, inherit=inherit)

+             for variant in compose.all_variants.values():

+                 if compose_tag in variant_tags[variant]:

+                     # Optimization for case where we have just single compose

+                     # tag - we do not have to merge in this case...

+                     if len(compose_tags) == 1:

+                         variant.pkgset = pkgset

+                     else:

+                         variant.pkgset.merge(pkgset, None, list(all_arches))

+             # Optimization for case where we have just single compose

+             # tag - we do not have to merge in this case...

+             if len(compose_tags) == 1:

+                 global_pkgset = pkgset

+             else:

+                 global_pkgset.merge(pkgset, None, list(all_arches))

+             f.write(pickle.dumps(global_pkgset))

+     global_pkgset.save_file_list(

+         compose.paths.work.package_list(arch="global"),

+         remove_path_prefix=path_prefix)

+     return global_pkgset

+             "modules": [],

+         for modulelist_node in variant_node.xpath("modules"):

+             for module_node in modulelist_node.xpath("module"):

+                 module = {

+                     "name": str(module_node.text),

+                     "glob": self._is_true(module_node.attrib.get("glob", "false"))

+                 }

+ 

+                 variant_dict["modules"].append(module)

+ 

+                  buildinstallpackages=None, is_empty=False, parent=None,

+                  modules=None):

+         modules = modules or []

+         self.modules = sorted(copy.deepcopy(modules),

+                               lambda x, y: cmp(x["name"], y["name"]))

+         self.pkgset = None

+         self.mmds = []

+ 

+     def get_modules(self, arch=None, types=None, recursive=False):

+         """Return list of groups, default types is ["self"]"""

+ 

+         types = types or ["self"]

+         result = copy.deepcopy(self.modules)

+         for variant in self.get_variants(arch=arch, types=types,

+                                          recursive=recursive):

+             if variant == self:

+                 # XXX

+                 continue

+             for module in variant.get_modules(arch=arch, types=types,

+                                               recursive=recursive):

+                 if module not in result:

+                     result.append(module)

+         return result

+ 

+             for module in i.modules:

+                 print("    MODULE:  %(name)-40s GLOB: %(glob)-5s DEFAULT: %(default)-5s USERVISIBLE: %(uservisible)-5s" % module)

+ <!ELEMENT variant (release?,arches,groups?,environments*,variants*,buildinstallpackages?,modules?)?>

+ <!ELEMENT modules (module)+>

+ 

+ <!ELEMENT module (#PCDATA)>

+ <!ATTLIST module

+     glob (true|false) #IMPLIED

+ >

+ 

+         self.mmds = []

+             self.compose, self.koji_wrapper, '/prefix', 123456)

+                 self.compose, self.koji_wrapper, '/prefix', 123456)

+             [mock.call.getLastEvent()]

+ 

+                                     EVENT_INFO)])