Switch content retrieval in manifests to be behind an interface

This allows for easy separation of retrieval of config blobs vs manifests

image/docker/schema2/list.py

@@ -40,9 +40,9 @@ class MalformedSchema2ManifestList(Exception):
 
 
 class LazyManifestLoader(object):
-  def __init__(self, manifest_data, lookup_manifest_fn):
+  def __init__(self, manifest_data, content_retriever):
     self._manifest_data = manifest_data
-    self._lookup_manifest_fn = lookup_manifest_fn
+    self._content_retriever = content_retriever
     self._loaded_manifest = None
 
   @property
@@ -56,7 +56,7 @@ class LazyManifestLoader(object):
   def _load_manifest(self):
     digest = self._manifest_data[DOCKER_SCHEMA2_MANIFESTLIST_DIGEST_KEY]
     size = self._manifest_data[DOCKER_SCHEMA2_MANIFESTLIST_SIZE_KEY]
-    manifest_bytes = self._lookup_manifest_fn(digest)
+    manifest_bytes = self._content_retriever.get_manifest_bytes_with_digest(digest)
     if manifest_bytes is None:
       raise MalformedSchema2ManifestList('Could not find child manifest with digest `%s`' % digest)
 
@@ -237,24 +237,23 @@ class DockerSchema2ManifestList(ManifestInterface):
     return None
 
   @lru_cache(maxsize=1)
-  def manifests(self, lookup_manifest_fn):
-    """ Returns the manifests in the list. The `lookup_manifest_fn` is a function
-        that returns the manifest bytes for the specified digest.
+  def manifests(self, content_retriever):
+    """ Returns the manifests in the list.
     """
     manifests = self._parsed[DOCKER_SCHEMA2_MANIFESTLIST_MANIFESTS_KEY]
-    return [LazyManifestLoader(m, lookup_manifest_fn) for m in manifests]
+    return [LazyManifestLoader(m, content_retriever) for m in manifests]
 
-  def child_manifests(self, lookup_manifest_fn):
-    return self.manifests(lookup_manifest_fn)
+  def child_manifests(self, content_retriever):
+    return self.manifests(content_retriever)
 
-  def get_manifest_labels(self, lookup_config_fn):
+  def get_manifest_labels(self, content_retriever):
     return None
 
-  def get_v1_compatible_manifest(self, namespace_name, repo_name, tag_name, lookup_fn):
+  def get_v1_compatible_manifest(self, namespace_name, repo_name, tag_name, content_retriever):
     """ Returns the manifest that is compatible with V1, by virtue of being `amd64` and `linux`.
         If none, returns None.
     """
-    for manifest_ref in self.manifests(lookup_fn):
+    for manifest_ref in self.manifests(content_retriever):
       platform = manifest_ref._manifest_data[DOCKER_SCHEMA2_MANIFESTLIST_PLATFORM_KEY]
       architecture = platform[DOCKER_SCHEMA2_MANIFESTLIST_ARCHITECTURE_KEY]
       os = platform[DOCKER_SCHEMA2_MANIFESTLIST_OS_KEY]
@@ -263,21 +262,19 @@ class DockerSchema2ManifestList(ManifestInterface):
 
       try:
         manifest = manifest_ref.manifest_obj
-      except ManifestException:
-        logger.exception('Could not load child manifest')
-        return None
-      except IOError:
+      except (ManifestException, IOError):
         logger.exception('Could not load child manifest')
         return None
 
-      return manifest.get_v1_compatible_manifest(namespace_name, repo_name, tag_name, lookup_fn)
+      return manifest.get_v1_compatible_manifest(namespace_name, repo_name, tag_name,
+                                                 content_retriever)
 
     return None
 
   def unsigned(self):
     return self
 
-  def generate_legacy_layers(self, images_map, lookup_config_fn):
+  def generate_legacy_layers(self, images_map, content_retriever):
     return None