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

@@ -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:

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 []

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)

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()
 

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

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:

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