From 5ffdeb4649c6f74d6f678acb893fcc3e35b5eb07 Mon Sep 17 00:00:00 2001 From: Jan Kaluza Date: Fri, 4 Oct 2019 12:54:54 +0200 Subject: [PATCH] Fallback to DBResolver in KojiResolver.get_compatible_base_module_modulemds. In case KojiResolver is not enabled for the base module, fallback to DBResolver in `KojiResolver.get_compatible_base_module_modulemds`. --- module_build_service/resolver/DBResolver.py | 8 +++-- module_build_service/resolver/KojiResolver.py | 31 +++++++++++++++++-- module_build_service/resolver/MBSResolver.py | 8 +++-- module_build_service/resolver/base.py | 2 +- module_build_service/utils/mse.py | 4 +-- tests/test_resolver/test_db.py | 4 ++- tests/test_resolver/test_koji.py | 21 ++++++++++++- 7 files changed, 64 insertions(+), 14 deletions(-) diff --git a/module_build_service/resolver/DBResolver.py b/module_build_service/resolver/DBResolver.py index 30468bd3..ef6db0c8 100644 --- a/module_build_service/resolver/DBResolver.py +++ b/module_build_service/resolver/DBResolver.py @@ -95,7 +95,7 @@ class DBResolver(GenericResolver): return [build.mmd() for build in builds] def get_compatible_base_module_modulemds( - self, name, stream, stream_version_lte, virtual_streams, states + self, base_module_mmd, stream_version_lte, virtual_streams, states ): """ Returns the Modulemd metadata of base modules compatible with base module @@ -106,8 +106,7 @@ class DBResolver(GenericResolver): If `virtual_streams` are defined, the compatibility is also extended to all base module streams which share the same virtual stream. - :param name: Name of the base module. - :param stream: Stream of the base module. + :param base_module_mmd: Modulemd medatada defining the input base module. :param stream_version_lte: If True, the compatible streams are limited by the stream version computed from `stream`. If False, even the modules with higher stream version are returned. @@ -116,7 +115,10 @@ class DBResolver(GenericResolver): one of the virtual streams. :param states: List of states the returned compatible modules should be in. + :return list: List of Modulemd objects. """ + name = base_module_mmd.get_module_name() + stream = base_module_mmd.get_stream_name() builds = [] stream_version = None if stream_version_lte: diff --git a/module_build_service/resolver/KojiResolver.py b/module_build_service/resolver/KojiResolver.py index 0fe35e42..6c627cc0 100644 --- a/module_build_service/resolver/KojiResolver.py +++ b/module_build_service/resolver/KojiResolver.py @@ -170,10 +170,37 @@ class KojiResolver(DBResolver): modules = self.get_buildrequired_modules(name, stream, base_module_mmd) return [module.mmd() for module in modules] - def get_compatible_base_module_modulemds(self, *args, **kwargs): + def get_compatible_base_module_modulemds( + self, base_module_mmd, stream_version_lte, virtual_streams, states): """ - For KojiResolver, this method returns always an empty list. The compatible modules are + Returns the Modulemd metadata of base modules compatible with base module + defined by `name` and `stream`. + + For base module which enables KojiResolver feature in its XMD section, this + method always returns an empty list. The compatible modules are defined by the Koji tag inheritance, so there is no need to find out the compatible base modules on MBS side. + + If the base module does not enable KojiResolver, the compatibility is determined + using DBResolver. + + :param base_module_mmd: Modulemd medatada defining the input base module. + :param stream_version_lte: If True, the compatible streams are limited + by the stream version computed from `stream`. If False, even the + modules with higher stream version are returned. + :param virtual_streams: List of virtual streams. If set, also modules + with incompatible stream version are returned in case they share + one of the virtual streams. + :param states: List of states the returned compatible modules should + be in. + :return list: List of Modulemd objects. """ + tag = base_module_mmd.get_xmd().get("mbs", {}).get("koji_tag_with_modules") + if not tag: + log.info( + "The %s does not define 'koji_tag_with_modules'. Falling back to DBResolver." % + (base_module_mmd.get_nsvc())) + return DBResolver.get_compatible_base_module_modulemds( + self, base_module_mmd, stream_version_lte, virtual_streams, states) + return [] diff --git a/module_build_service/resolver/MBSResolver.py b/module_build_service/resolver/MBSResolver.py index e35ae99d..a311cc75 100644 --- a/module_build_service/resolver/MBSResolver.py +++ b/module_build_service/resolver/MBSResolver.py @@ -208,7 +208,7 @@ class MBSResolver(KojiResolver): return mmds def get_compatible_base_module_modulemds( - self, name, stream, stream_version_lte, virtual_streams, states + self, base_module_mmd, stream_version_lte, virtual_streams, states ): """ Returns the Modulemd metadata of base modules compatible with base module @@ -219,8 +219,7 @@ class MBSResolver(KojiResolver): If `virtual_streams` are defined, the compatibility is also extended to all base module streams which share the same virtual stream. - :param name: Name of the base module. - :param stream: Stream of the base module. + :param base_module_mmd: Modulemd medatada defining the input base module. :param stream_version_lte: If True, the compatible streams are limited by the stream version computed from `stream`. If False, even the modules with higher stream version are returned. @@ -229,7 +228,10 @@ class MBSResolver(KojiResolver): one of the virtual streams. :param states: List of states the returned compatible modules should be in. + :return list: List of Modulemd objects. """ + name = base_module_mmd.get_module_name() + stream = base_module_mmd.get_stream_name() return self.get_module_modulemds( name, stream, stream_version_lte=stream_version_lte, virtual_streams=virtual_streams, states=states) diff --git a/module_build_service/resolver/base.py b/module_build_service/resolver/base.py index b2e187e6..74e40326 100644 --- a/module_build_service/resolver/base.py +++ b/module_build_service/resolver/base.py @@ -95,7 +95,7 @@ class GenericResolver(six.with_metaclass(ABCMeta)): @abstractmethod def get_compatible_base_module_modulemds( - self, name, stream, stream_version_lte, virtual_streams, states + self, base_module_mmd, stream_version_lte, virtual_streams, states ): raise NotImplementedError() diff --git a/module_build_service/utils/mse.py b/module_build_service/utils/mse.py index b154cf6f..96da48fc 100644 --- a/module_build_service/utils/mse.py +++ b/module_build_service/utils/mse.py @@ -243,8 +243,6 @@ def get_base_module_mmds(db_session, mmd): if not virtual_streams: continue - virtual_streams = xmd["mbs"]["virtual_streams"] - if conf.allow_only_compatible_base_modules: stream_version_lte = True states = ["ready"] @@ -254,7 +252,7 @@ def get_base_module_mmds(db_session, mmd): for state in states: mmds = resolver.get_compatible_base_module_modulemds( - name, stream, stream_version_lte, virtual_streams, + stream_mmd, stream_version_lte, virtual_streams, [models.BUILD_STATES[state]]) ret_chunk = [] # Add the returned mmds to the `seen` set to avoid querying those diff --git a/tests/test_resolver/test_db.py b/tests/test_resolver/test_db.py index 6714008d..a64ded84 100644 --- a/tests/test_resolver/test_db.py +++ b/tests/test_resolver/test_db.py @@ -57,8 +57,10 @@ class TestDBModule: ): tests.init_data(1, multiple_stream_versions=True) resolver = mbs_resolver.GenericResolver.create(db_session, tests.conf, backend="db") + platform = db_session.query(ModuleBuild).filter_by(name="platform", stream="f29.1.0").one() + platform_mmd = platform.mmd() result = resolver.get_compatible_base_module_modulemds( - "platform", "f29.1.0", stream_version_lte=stream_versions, virtual_streams=["f29"], + platform_mmd, stream_version_lte=stream_versions, virtual_streams=["f29"], states=[models.BUILD_STATES["ready"]]) nsvcs = {mmd.get_nsvc() for mmd in result} if stream_versions: diff --git a/tests/test_resolver/test_koji.py b/tests/test_resolver/test_koji.py index 925420d1..eca3e178 100644 --- a/tests/test_resolver/test_koji.py +++ b/tests/test_resolver/test_koji.py @@ -216,11 +216,30 @@ class TestLocalResolverModule: "testmodule-master-20170110091357.7c29193d", "testmodule-2-20180109091357.7c29193d"} + def test_get_compatible_base_module_modulemds_fallback_to_dbresolver(self, db_session): + tests.init_data(1, multiple_stream_versions=True) + resolver = mbs_resolver.GenericResolver.create(db_session, tests.conf, backend="koji") + platform = db_session.query(ModuleBuild).filter_by(name="platform", stream="f29.1.0").one() + platform_mmd = platform.mmd() + result = resolver.get_compatible_base_module_modulemds( + platform_mmd, stream_version_lte=True, virtual_streams=["f29"], + states=[BUILD_STATES["ready"]]) + + assert len(result) == 2 + def test_get_compatible_base_module_modulemds(self, db_session): tests.init_data(1, multiple_stream_versions=True) resolver = mbs_resolver.GenericResolver.create(db_session, tests.conf, backend="koji") + + platform = db_session.query(ModuleBuild).filter_by(name="platform", stream="f29.1.0").one() + platform_mmd = platform.mmd() + platform_xmd = platform_mmd.get_xmd() + platform_xmd["mbs"]["koji_tag_with_modules"] = "module-f29-build" + platform_mmd.set_xmd(platform_xmd) + platform.modulemd = mmd_to_str(platform_mmd) + result = resolver.get_compatible_base_module_modulemds( - "platform", "f29.1.0", stream_version_lte=True, virtual_streams=["f29"], + platform_mmd, stream_version_lte=True, virtual_streams=["f29"], states=[BUILD_STATES["ready"]]) assert len(result) == 0