Enhancements for Docker schema implementations in preparing for supporting schema 2 in the OCI model

This adds additional required properties and methods to the Docker schema interface to allow us to treat both schema1 and schema2 manifests and lists logically equivalent from the OCI mode perspective

image/docker/schema2/list.py

@@ -3,6 +3,8 @@ import json
 from cachetools import lru_cache
 from jsonschema import validate as validate_schema, ValidationError
 
+from digest import digest_tools
+from image.docker.interfaces import ManifestInterface
 from image.docker.schema1 import DOCKER_SCHEMA1_MANIFEST_CONTENT_TYPE
 from image.docker.schema1 import DockerSchema1Manifest
 from image.docker.schema2 import (DOCKER_SCHEMA2_MANIFESTLIST_CONTENT_TYPE,
@@ -50,6 +52,9 @@ class LazyManifestLoader(object):
     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)
+    if manifest_bytes is None:
+      raise MalformedSchema2ManifestList('Could not find child manifest with digest `%s`' % digest)
+
     if len(manifest_bytes) != size:
       raise MalformedSchema2ManifestList('Size of manifest does not match that retrieved: %s vs %s',
                                          len(manifest_bytes), size)
@@ -64,7 +69,7 @@ class LazyManifestLoader(object):
     raise MalformedSchema2ManifestList('Unknown manifest content type')
 
 
-class DockerSchema2ManifestList(object):
+class DockerSchema2ManifestList(ManifestInterface):
   METASCHEMA = {
     'type': 'object',
     'properties': {
@@ -161,6 +166,7 @@ class DockerSchema2ManifestList(object):
 
   def __init__(self, manifest_bytes):
     self._layers = None
+    self._manifest_bytes = manifest_bytes
 
     try:
       self._parsed = json.loads(manifest_bytes)
@@ -172,6 +178,42 @@ class DockerSchema2ManifestList(object):
     except ValidationError as ve:
       raise MalformedSchema2ManifestList('manifest data does not match schema: %s' % ve)
 
+  @property
+  def digest(self):
+    """ The digest of the manifest, including type prefix. """
+    return digest_tools.sha256_digest(self._manifest_bytes)
+
+  @property
+  def media_type(self):
+    """ The media type of the schema. """
+    return self._parsed[DOCKER_SCHEMA2_MANIFESTLIST_MEDIATYPE_KEY]
+
+  @property
+  def manifest_dict(self):
+    """ Returns the manifest as a dictionary ready to be serialized to JSON. """
+    return self._parsed
+
+  @property
+  def bytes(self):
+    return self._manifest_bytes
+
+  @property
+  def layers(self):
+    return None
+
+  @property
+  def leaf_layer_v1_image_id(self):
+    return None
+
+  @property
+  def legacy_image_ids(self):
+    return None
+
+  @property
+  def blob_digests(self):
+    manifests = self._parsed[DOCKER_SCHEMA2_MANIFESTLIST_MANIFESTS_KEY]
+    return [m[DOCKER_SCHEMA2_MANIFESTLIST_DIGEST_KEY] for m in manifests]
+
   @lru_cache(maxsize=1)
   def manifests(self, lookup_manifest_fn):
     """ Returns the manifests in the list. The `lookup_manifest_fn` is a function
@@ -180,6 +222,12 @@ class DockerSchema2ManifestList(object):
     manifests = self._parsed[DOCKER_SCHEMA2_MANIFESTLIST_MANIFESTS_KEY]
     return [LazyManifestLoader(m, lookup_manifest_fn) for m in manifests]
 
+  def child_manifests(self, lookup_manifest_fn):
+    return self.manifests(lookup_manifest_fn)
+
+  def get_manifest_labels(self, lookup_config_fn):
+    return None
+
   def get_v1_compatible_manifest(self, lookup_manifest_fn):
     """ Returns the manifest that is compatible with V1, by virtue of being `amd64` and `linux`.
         If none, returns None.
@@ -192,3 +240,48 @@ class DockerSchema2ManifestList(object):
         return manifest
 
     return None
+
+  def unsigned(self):
+    return self
+
+  def generate_legacy_layers(self, images_map, lookup_config_fn):
+    return None
+
+
+class DockerSchema2ManifestListBuilder(object):
+  """
+  A convenient abstraction around creating new DockerSchema2ManifestList's.
+  """
+  def __init__(self):
+    self.manifests = []
+
+  def add_manifest(self, manifest, architecture, os):
+    """ Adds a manifest to the list. """
+    manifest = manifest.unsigned() # Make sure we add the unsigned version to the list.
+    self.add_manifest_digest(manifest.digest, len(manifest.bytes), manifest.media_type,
+                             architecture, os)
+
+  def add_manifest_digest(self, manifest_digest, manifest_size, media_type, architecture, os):
+    """ Adds a manifest to the list. """
+    self.manifests.append((manifest_digest, manifest_size, media_type, {
+      DOCKER_SCHEMA2_MANIFESTLIST_ARCHITECTURE_KEY: architecture,
+      DOCKER_SCHEMA2_MANIFESTLIST_OS_KEY: os,
+    }))
+
+  def build(self):
+    """ Builds and returns the DockerSchema2ManifestList. """
+    assert self.manifests
+
+    manifest_list_dict = {
+      DOCKER_SCHEMA2_MANIFESTLIST_VERSION_KEY: 2,
+      DOCKER_SCHEMA2_MANIFESTLIST_MEDIATYPE_KEY: DOCKER_SCHEMA2_MANIFESTLIST_CONTENT_TYPE,
+      DOCKER_SCHEMA2_MANIFESTLIST_MANIFESTS_KEY: [
+        {
+          DOCKER_SCHEMA2_MANIFESTLIST_MEDIATYPE_KEY: manifest[2],
+          DOCKER_SCHEMA2_MANIFESTLIST_DIGEST_KEY: manifest[0],
+          DOCKER_SCHEMA2_MANIFESTLIST_SIZE_KEY: manifest[1],
+          DOCKER_SCHEMA2_MANIFESTLIST_PLATFORM_KEY: manifest[3],
+        } for manifest in self.manifests
+      ],
+    }
+    return DockerSchema2ManifestList(json.dumps(manifest_list_dict, indent=3))