Fix all tests.

ognibuild/resolver/__init__.py

@@ -34,11 +34,14 @@ class Resolver(object):
         raise NotImplementedError(self.met)
 
 
-class CPANResolver(object):
+class CPANResolver(Resolver):
 
     def __init__(self, session):
         self.session = session
 
+    def __str__(self):
+        return "cpan"
+
     def install(self, requirements):
         from ..requirements import PerlModuleRequirement
         missing = []
@@ -61,11 +64,42 @@ class CPANResolver(object):
         raise NotImplementedError(self.met)
 
 
-class PypiResolver(object):
+class CargoResolver(Resolver):
 
     def __init__(self, session):
         self.session = session
 
+    def __str__(self):
+        return "cargo"
+
+    def install(self, requirements):
+        from ..requirements import CargoCrateRequirement
+        missing = []
+        for requirement in requirements:
+            if not isinstance(requirement, CargoCrateRequirement):
+                missing.append(requirement)
+                continue
+            self.session.check_call(
+                ["cargo", "install", requirement.crate],
+                user="root")
+        if missing:
+            raise MissingDependencies(missing)
+
+    def explain(self, requirements):
+        raise NotImplementedError(self.explain)
+
+    def met(self, requirement):
+        raise NotImplementedError(self.met)
+
+
+class PypiResolver(Resolver):
+
+    def __init__(self, session):
+        self.session = session
+
+    def __str__(self):
+        return "pypi"
+
     def install(self, requirements):
         from ..requirements import PythonPackageRequirement
         missing = []
@@ -89,11 +123,14 @@ NPM_COMMAND_PACKAGES = {
 }
 
 
-class NpmResolver(object):
+class NpmResolver(Resolver):
 
     def __init__(self, session):
         self.session = session
 
+    def __str__(self):
+        return "npm"
+
     def install(self, requirements):
         from ..requirements import NodePackageRequirement
         missing = []
@@ -121,6 +158,9 @@ class StackedResolver(Resolver):
     def __init__(self, subs):
         self.subs = subs
 
+    def __str__(self):
+        return "[" + ", ".join(map(str, self.subs)) + "]"
+
     def install(self, requirements):
         for sub in self.subs:
             try:
@@ -135,7 +175,8 @@ def native_resolvers(session):
     return StackedResolver([
         CPANResolver(session),
         PypiResolver(session),
-        NpmResolver(session)])
+        NpmResolver(session),
+        CargoResolver(session)])
 
 
 class ExplainResolver(Resolver):
@@ -150,19 +191,17 @@ class ExplainResolver(Resolver):
         raise MissingDependencies(requirements)
 
 
-class AutoResolver(Resolver):
-    """Automatically find out the most appropriate way to install dependencies.
-    """
-
-    def __init__(self, session):
-        self.session = session
-
-    @classmethod
-    def from_session(cls, session):
-        return cls(session)
-
-    def install(self, requirements):
-        raise NotImplementedError(self.install)
-
-    def explain(self, requirements):
-        raise NotImplementedError(self.explain)
+def auto_resolver(session):
+    # TODO(jelmer): if session is SchrootSession or if we're root, use apt
+    from .apt import AptResolver
+    from ..session.schroot import SchrootSession
+    user = session.check_output(['echo', '$USER']).decode().strip()
+    resolvers = []
+    if isinstance(session, SchrootSession) or user == 'root':
+        resolvers.append(AptResolver.from_session(session))
+    resolvers.extend([
+        CPANResolver(session),
+        PypiResolver(session),
+        NpmResolver(session),
+        CargoResolver(session)])
+    return StackedResolver(resolvers)

ognibuild/resolver/apt.py

@@ -53,10 +53,6 @@ from ..requirements import (
     )
 
 
-class NoAptPackage(Exception):
-    """No apt package."""
-
-
 class AptRequirement(object):
 
     def __init__(self, package, minimum_version=None):
@@ -161,15 +157,13 @@ def resolve_binary_req(apt_mgr, req):
 def resolve_pkg_config_req(apt_mgr, req):
     package = apt_mgr.get_package_for_paths(
         [posixpath.join("/usr/lib/pkgconfig", req.module + ".pc")],
-        req.minimum_version
     )
     if package is None:
         package = apt_mgr.get_package_for_paths(
             [posixpath.join("/usr/lib", ".*", "pkgconfig", req.module + ".pc")],
-            regex=True,
-            minimum_version=req.minimum_version)
+            regex=True)
     if package is not None:
-        return AptRequirement(package)
+        return AptRequirement(package, minimum_version=req.minimum_version)
     return None
 
 
@@ -502,10 +496,7 @@ APT_REQUIREMENT_RESOLVERS = [
 def resolve_requirement_apt(apt_mgr, req: UpstreamRequirement) -> AptRequirement:
     for rr_class, rr_fn in APT_REQUIREMENT_RESOLVERS:
         if isinstance(req, rr_class):
-            deb_req = rr_fn(apt_mgr, req)
-            if deb_req is None:
-                raise NoAptPackage(req)
-            return deb_req
+            return rr_fn(apt_mgr, req)
     raise NotImplementedError(type(req))
 
 
@@ -514,6 +505,9 @@ class AptResolver(Resolver):
     def __init__(self, apt):
         self.apt = apt
 
+    def __str__(self):
+        return "apt"
+
     @classmethod
     def from_session(cls, session):
         return cls(AptManager(session))
@@ -530,10 +524,11 @@ class AptResolver(Resolver):
             still_missing = []
             apt_requirements = []
             for m in missing:
-                try:
-                    apt_requirements.append(self.resolve(m))
-                except NoAptPackage:
+                apt_req = self.resolve(m)
+                if apt_req is None:
                     still_missing.append(m)
+                else:
+                    apt_requirements.append(m)
             self.apt.install(
                 [req.package for req in apt_requirements])
             if still_missing: