Make the resolver functions less PDC specific

module_build_service/resolver/PDCResolver.py

@@ -220,13 +220,20 @@ class PDCResolver(GenericResolver):
         assert len(results) <= 1, pprint.pformat(retval)
         return results[0]
 
-    def get_module_tag(self, module_info, strict=False):
+    def get_module_tag(self, name, stream, version, strict=False):
         """
-        :param module_info: list of module_info dicts
+        :param name: a module's name
+        :param stream: a module's stream
+        :param version: a module's version
         :param strict: Normally this function returns None if no module can be
                found.  If strict=True, then an UnprocessableEntity is raised.
         :return: koji tag string
         """
+        module_info = {
+            'name': name,
+            'version': stream,
+            'release': str(version)
+        }
         return self._get_module(module_info, strict=strict)['koji_tag']
 
     def _get_module_modulemd(self, module_info, strict=False):
@@ -381,33 +388,40 @@ class PDCResolver(GenericResolver):
         # Return the union of all rpms in all profiles of the given keys.
         return results
 
-    def get_module_build_dependencies(self, module_info, strict=False):
+    def get_module_build_dependencies(self, name=None, stream=None, version=None, mmd=None,
+                                      strict=False):
         """
-        :param module_info : a dict containing filters for pdc or ModuleMetadata
-        instance.
+        :param name: a module's name (required if mmd is not set)
+        :param stream: a module's stream (required if mmd is not set)
+        :param version: a module's version (required if mmd is not set)
+        :param mmd: uses the mmd instead of the name, stream, version to query PDC
         :param strict: Normally this function returns None if no module can be
-               found.  If strict=True, then an UnprocessableEntity is raised.
+            found.  If strict=True, then an UnprocessableEntity is raised.
         :return dict with koji_tag as a key and ModuleMetadata object as value.
-
-        Example minimal module_info:
-            {
-                'variant_id': module_name,
-                'variant_version': module_version,
-                'variant_type': 'module'
-            }
         """
-        log.debug("get_module_build_dependencies(%r, strict=%r)" % (module_info, strict))
-        # XXX get definitive list of modules
+        if mmd:
+            log.debug("get_module_build_dependencies(mmd=%r strict=%r)" % (mmd, strict))
+        elif any(x is None for x in [name, stream, version]):
+            raise RuntimeError('The name, stream, and version weren\'t specified')
+        else:
+            version = str(version)
+            log.debug("get_module_build_dependencies(%s, strict=%r)"
+                      % (', '.join([name, stream, str(version)]), strict))
 
         # This is the set we're going to build up and return.
         module_tags = {}
 
-        if not isinstance(module_info, Modulemd.Module):
+        if mmd:
+            queried_mmd = mmd
+        else:
+            module_info = {
+                'name': name,
+                'version': stream,
+                'release': str(version)
+            }
             queried_module = self._get_module(module_info, strict=strict)
             yaml = queried_module['modulemd']
             queried_mmd = self.extract_modulemd(yaml, strict=strict)
-        else:
-            queried_mmd = module_info
 
         if (not queried_mmd or not queried_mmd.get_xmd().get('mbs') or
                 'buildrequires' not in queried_mmd.get_xmd()['mbs'].keys()):

module_build_service/resolver/base.py

@@ -98,7 +98,7 @@ class GenericResolver(six.with_metaclass(ABCMeta)):
         return mmd
 
     @abstractmethod
-    def get_module_tag(self, module_info, strict=False):
+    def get_module_tag(self, name, stream, version, strict=False):
         raise NotImplementedError()
 
     @abstractmethod
@@ -106,7 +106,8 @@ class GenericResolver(six.with_metaclass(ABCMeta)):
         raise NotImplementedError()
 
     @abstractmethod
-    def get_module_build_dependencies(self, module_info, strict=False):
+    def get_module_build_dependencies(self, name=None, stream=None, version=None, mmd=None,
+                                      strict=False):
         raise NotImplementedError()
 
     @abstractmethod

module_build_service/scheduler/handlers/modules.py

@@ -222,7 +222,7 @@ def wait(config, session, msg):
             # local build is not stored in PDC and therefore we cannot query
             # it using the `query` as for Koji below.
             dependencies = resolver.get_module_build_dependencies(
-                build.mmd(), strict=True).keys()
+                mmd=build.mmd(), strict=True).keys()
 
             # We also don't want to get the tag name from the PDC, but just
             # generate it locally instead.
@@ -232,14 +232,11 @@ def wait(config, session, msg):
         else:
             # For Koji backend, query for the module we are going to
             # build to get the koji_tag and deps from it.
-            query = {
-                'name': module_info['name'],
-                'version': module_info['stream'],
-                'release': module_info['version'],
-            }
-            log.info("Getting %s deps (query %r)" % (module_info['name'], query))
-            deps_dict = resolver.get_module_build_dependencies(
-                query, strict=True)
+            name = module_info['name']
+            stream = module_info['stream']
+            version = str(module_info['version'])
+            log.info("Getting deps for %s" % (':'.join([name, stream, version])))
+            deps_dict = resolver.get_module_build_dependencies(name, stream, version, strict=True)
             dependencies = set(deps_dict.keys())
 
             # Find out the name of Koji tag to which the module's Content
@@ -252,9 +249,8 @@ def wait(config, session, msg):
                         module_names_streams[base_module_name])
                     break
 
-            log.info("Getting %s tag (query %r)" % (module_info['name'], query))
-            tag = resolver.get_module_tag(
-                query, strict=True)
+            log.info('Getting tag for {0}'.format(':'.join([name, stream, version])))
+            tag = resolver.get_module_tag(name, stream, version, strict=True)
 
         return dependencies, tag, cg_build_koji_tag
 

tests/test_resolver/test_pdc.py

@@ -88,13 +88,9 @@ class TestPDCModule:
                 'modulemd': mmd.dumps(),
                 'build_deps': []
             })
-        query = {
-            'name': 'testmodule',
-            'version': 'master',
-            'release': '20180205135154',
-        }
         resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='pdc')
-        result = resolver.get_module_build_dependencies(query).keys()
+        result = resolver.get_module_build_dependencies(
+            'testmodule', 'master', '20180205135154').keys()
         assert set(result) == expected
 
     def test_get_module_build_dependencies_recursive(self, pdc_module_active):
@@ -134,7 +130,8 @@ class TestPDCModule:
             'release': '20180123171545',
         }
         resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='pdc')
-        result = resolver.get_module_build_dependencies(query).keys()
+        result = resolver.get_module_build_dependencies(
+            'testmodule2', 'master', '20180123171545').keys()
         assert set(result) == set(['module-f28-build'])
 
     @patch("module_build_service.config.Config.system",
@@ -155,7 +152,7 @@ class TestPDCModule:
             build = module_build_service.models.ModuleBuild.local_modules(
                 db.session, "child", "master")
             resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='pdc')
-            result = resolver.get_module_build_dependencies(build[0].mmd()).keys()
+            result = resolver.get_module_build_dependencies(mmd=build[0].mmd()).keys()
 
             local_path = os.path.join(base_dir, 'staged_data', "local_builds")
 

tests/test_scheduler/test_module_wait.py

@@ -61,7 +61,7 @@ class TestModuleWait:
         mocked_module_build = mock.Mock()
         mocked_module_build.json.return_value = {
             'name': 'foo',
-            'stream': 1,
+            'stream': '1',
             'version': 1,
             'state': 'some state',
             'id': 1