463 lines
19 KiB
Python
463 lines
19 KiB
Python
|
import json
|
||
|
|
import logging
|
||
|
|
import hashlib
|
||
|
|
|
||
|
|
from collections import namedtuple
|
||
|
|
from jsonschema import validate as validate_schema, ValidationError
|
||
|
|
|
||
|
|
from digest import digest_tools
|
||
|
|
from image.docker import ManifestException
|
||
|
|
from image.docker.interfaces import ManifestInterface
|
||
|
|
from image.docker.types import ManifestImageLayer
|
||
|
|
from image.docker.schema2 import (DOCKER_SCHEMA2_MANIFEST_CONTENT_TYPE,
|
||
|
|
DOCKER_SCHEMA2_CONFIG_CONTENT_TYPE,
|
||
|
|
DOCKER_SCHEMA2_LAYER_CONTENT_TYPE,
|
||
|
|
DOCKER_SCHEMA2_REMOTE_LAYER_CONTENT_TYPE,
|
||
|
|
EMPTY_LAYER_BLOB_DIGEST, EMPTY_LAYER_SIZE)
|
||
|
|
from image.docker.schema1 import DockerSchema1ManifestBuilder
|
||
|
|
from image.docker.schema2.config import DockerSchema2Config
|
||
|
|
from util.bytes import Bytes
|
||
|
|
|
||
|
|
# Keys.
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_VERSION_KEY = 'schemaVersion'
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY = 'mediaType'
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_CONFIG_KEY = 'config'
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_SIZE_KEY = 'size'
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY = 'digest'
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_LAYERS_KEY = 'layers'
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_URLS_KEY = 'urls'
|
||
|
|
|
||
|
|
# Named tuples.
|
||
|
|
DockerV2ManifestConfig = namedtuple('DockerV2ManifestConfig', ['size', 'digest'])
|
||
|
|
DockerV2ManifestLayer = namedtuple('DockerV2ManifestLayer', ['index', 'digest',
|
||
|
|
'is_remote', 'urls',
|
||
|
|
'compressed_size'])
|
||
|
|
|
||
|
|
DockerV2ManifestImageLayer = namedtuple('DockerV2ManifestImageLayer', ['history', 'blob_layer',
|
||
|
|
'v1_id', 'v1_parent_id',
|
||
|
|
'compressed_size',
|
||
|
|
'blob_digest'])
|
||
|
|
|
||
|
|
logger = logging.getLogger(__name__)
|
||
|
|
|
||
|
|
class MalformedSchema2Manifest(ManifestException):
|
||
|
|
"""
|
||
|
|
Raised when a manifest fails an assertion that should be true according to the Docker Manifest
|
||
|
|
v2.2 Specification.
|
||
|
|
"""
|
||
|
|
pass
|
||
|
|
|
||
|
|
|
||
|
|
class DockerSchema2Manifest(ManifestInterface):
|
||
|
|
METASCHEMA = {
|
||
|
|
'type': 'object',
|
||
|
|
'properties': {
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_VERSION_KEY: {
|
||
|
|
'type': 'number',
|
||
|
|
'description': 'The version of the schema. Must always be `2`.',
|
||
|
|
'minimum': 2,
|
||
|
|
'maximum': 2,
|
||
|
|
},
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY: {
|
||
|
|
'type': 'string',
|
||
|
|
'description': 'The media type of the schema.',
|
||
|
|
'enum': [DOCKER_SCHEMA2_MANIFEST_CONTENT_TYPE],
|
||
|
|
},
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_CONFIG_KEY: {
|
||
|
|
'type': 'object',
|
||
|
|
'description': 'The config field references a configuration object for a container, ' +
|
||
|
|
'by digest. This configuration item is a JSON blob that the runtime ' +
|
||
|
|
'uses to set up the container.',
|
||
|
|
'properties': {
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY: {
|
||
|
|
'type': 'string',
|
||
|
|
'description': 'The MIME type of the referenced object. This should generally be ' +
|
||
|
|
'application/vnd.docker.container.image.v1+json',
|
||
|
|
'enum': [DOCKER_SCHEMA2_CONFIG_CONTENT_TYPE],
|
||
|
|
},
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_SIZE_KEY: {
|
||
|
|
'type': 'number',
|
||
|
|
'description': 'The size in bytes of the object. This field exists so that a ' +
|
||
|
|
'client will have an expected size for the content before ' +
|
||
|
|
'validating. If the length of the retrieved content does not ' +
|
||
|
|
'match the specified length, the content should not be trusted.',
|
||
|
|
},
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY: {
|
||
|
|
'type': 'string',
|
||
|
|
'description': 'The content addressable digest of the config in the blob store',
|
||
|
|
},
|
||
|
|
},
|
||
|
|
'required': [DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY, DOCKER_SCHEMA2_MANIFEST_SIZE_KEY,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY],
|
||
|
|
},
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_LAYERS_KEY: {
|
||
|
|
'type': 'array',
|
||
|
|
'description': 'The layer list is ordered starting from the base ' +
|
||
|
|
'image (opposite order of schema1).',
|
||
|
|
'items': {
|
||
|
|
'type': 'object',
|
||
|
|
'properties': {
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY: {
|
||
|
|
'type': 'string',
|
||
|
|
'description': 'The MIME type of the referenced object. This should generally be ' +
|
||
|
|
'application/vnd.docker.image.rootfs.diff.tar.gzip. Layers of type ' +
|
||
|
|
'application/vnd.docker.image.rootfs.foreign.diff.tar.gzip may be ' +
|
||
|
|
'pulled from a remote location but they should never be pushed.',
|
||
|
|
'enum': [DOCKER_SCHEMA2_LAYER_CONTENT_TYPE, DOCKER_SCHEMA2_REMOTE_LAYER_CONTENT_TYPE],
|
||
|
|
},
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_SIZE_KEY: {
|
||
|
|
'type': 'number',
|
||
|
|
'description': 'The size in bytes of the object. This field exists so that a ' +
|
||
|
|
'client will have an expected size for the content before ' +
|
||
|
|
'validating. If the length of the retrieved content does not ' +
|
||
|
|
'match the specified length, the content should not be trusted.',
|
||
|
|
},
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY: {
|
||
|
|
'type': 'string',
|
||
|
|
'description': 'The content addressable digest of the layer in the blob store',
|
||
|
|
},
|
||
|
|
},
|
||
|
|
'required': [
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY, DOCKER_SCHEMA2_MANIFEST_SIZE_KEY,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY,
|
||
|
|
],
|
||
|
|
},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
'required': [DOCKER_SCHEMA2_MANIFEST_VERSION_KEY, DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_CONFIG_KEY, DOCKER_SCHEMA2_MANIFEST_LAYERS_KEY],
|
||
|
|
}
|
||
|
|
|
||
|
|
def __init__(self, manifest_bytes):
|
||
|
|
assert isinstance(manifest_bytes, Bytes)
|
||
|
|
|
||
|
|
self._payload = manifest_bytes
|
||
|
|
|
||
|
|
self._filesystem_layers = None
|
||
|
|
self._cached_built_config = None
|
||
|
|
|
||
|
|
try:
|
||
|
|
self._parsed = json.loads(self._payload.as_unicode())
|
||
|
|
except ValueError as ve:
|
||
|
|
raise MalformedSchema2Manifest('malformed manifest data: %s' % ve)
|
||
|
|
|
||
|
|
try:
|
||
|
|
validate_schema(self._parsed, DockerSchema2Manifest.METASCHEMA)
|
||
|
|
except ValidationError as ve:
|
||
|
|
raise MalformedSchema2Manifest('manifest data does not match schema: %s' % ve)
|
||
|
|
|
||
|
|
for layer in self.filesystem_layers:
|
||
|
|
if layer.is_remote and not layer.urls:
|
||
|
|
raise MalformedSchema2Manifest('missing `urls` for remote layer')
|
||
|
|
|
||
|
|
def validate(self, content_retriever):
|
||
|
|
""" Performs validation of required assertions about the manifest. Raises a ManifestException
|
||
|
|
on failure.
|
||
|
|
"""
|
||
|
|
# Nothing to validate.
|
||
|
|
|
||
|
|
@property
|
||
|
|
def is_manifest_list(self):
|
||
|
|
return False
|
||
|
|
|
||
|
|
@property
|
||
|
|
def schema_version(self):
|
||
|
|
return 2
|
||
|
|
|
||
|
|
@property
|
||
|
|
def manifest_dict(self):
|
||
|
|
return self._parsed
|
||
|
|
|
||
|
|
@property
|
||
|
|
def media_type(self):
|
||
|
|
return self._parsed[DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY]
|
||
|
|
|
||
|
|
@property
|
||
|
|
def digest(self):
|
||
|
|
return digest_tools.sha256_digest(self._payload.as_encoded_str())
|
||
|
|
|
||
|
|
@property
|
||
|
|
def config(self):
|
||
|
|
config = self._parsed[DOCKER_SCHEMA2_MANIFEST_CONFIG_KEY]
|
||
|
|
return DockerV2ManifestConfig(size=config[DOCKER_SCHEMA2_MANIFEST_SIZE_KEY],
|
||
|
|
digest=config[DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY])
|
||
|
|
|
||
|
|
@property
|
||
|
|
def filesystem_layers(self):
|
||
|
|
""" Returns the file system layers of this manifest, from base to leaf. """
|
||
|
|
if self._filesystem_layers is None:
|
||
|
|
self._filesystem_layers = list(self._generate_filesystem_layers())
|
||
|
|
return self._filesystem_layers
|
||
|
|
|
||
|
|
@property
|
||
|
|
def leaf_filesystem_layer(self):
|
||
|
|
""" Returns the leaf file system layer for this manifest. """
|
||
|
|
return self.filesystem_layers[-1]
|
||
|
|
|
||
|
|
@property
|
||
|
|
def layers_compressed_size(self):
|
||
|
|
return sum(layer.compressed_size for layer in self.filesystem_layers)
|
||
|
|
|
||
|
|
@property
|
||
|
|
def has_remote_layer(self):
|
||
|
|
for layer in self.filesystem_layers:
|
||
|
|
if layer.is_remote:
|
||
|
|
return True
|
||
|
|
|
||
|
|
return False
|
||
|
|
|
||
|
|
@property
|
||
|
|
def blob_digests(self):
|
||
|
|
return [str(layer.digest) for layer in self.filesystem_layers] + [str(self.config.digest)]
|
||
|
|
|
||
|
|
@property
|
||
|
|
def local_blob_digests(self):
|
||
|
|
return ([str(layer.digest) for layer in self.filesystem_layers if not layer.urls] +
|
||
|
|
[str(self.config.digest)])
|
||
|
|
|
||
|
|
def get_blob_digests_for_translation(self):
|
||
|
|
return self.blob_digests
|
||
|
|
|
||
|
|
def get_manifest_labels(self, content_retriever):
|
||
|
|
return self._get_built_config(content_retriever).labels
|
||
|
|
|
||
|
|
def get_layers(self, content_retriever):
|
||
|
|
""" Returns the layers of this manifest, from base to leaf or None if this kind of manifest
|
||
|
|
does not support layers. """
|
||
|
|
for image_layer in self._manifest_image_layers(content_retriever):
|
||
|
|
is_remote = image_layer.blob_layer.is_remote if image_layer.blob_layer else False
|
||
|
|
urls = image_layer.blob_layer.urls if image_layer.blob_layer else None
|
||
|
|
yield ManifestImageLayer(layer_id=image_layer.v1_id,
|
||
|
|
compressed_size=image_layer.compressed_size,
|
||
|
|
is_remote=is_remote,
|
||
|
|
urls=urls,
|
||
|
|
command=image_layer.history.command,
|
||
|
|
blob_digest=image_layer.blob_digest,
|
||
|
|
created_datetime=image_layer.history.created_datetime,
|
||
|
|
author=image_layer.history.author,
|
||
|
|
comment=image_layer.history.comment,
|
||
|
|
internal_layer=image_layer)
|
||
|
|
|
||
|
|
@property
|
||
|
|
def bytes(self):
|
||
|
|
return self._payload
|
||
|
|
|
||
|
|
def child_manifests(self, content_retriever):
|
||
|
|
return None
|
||
|
|
|
||
|
|
def _manifest_image_layers(self, content_retriever):
|
||
|
|
# Retrieve the configuration for the manifest.
|
||
|
|
config = self._get_built_config(content_retriever)
|
||
|
|
history = list(config.history)
|
||
|
|
if len(history) < len(self.filesystem_layers):
|
||
|
|
raise MalformedSchema2Manifest('Found less history than layer blobs')
|
||
|
|
|
||
|
|
digest_history = hashlib.sha256()
|
||
|
|
v1_layer_parent_id = None
|
||
|
|
v1_layer_id = None
|
||
|
|
blob_index = 0
|
||
|
|
|
||
|
|
for history_index, history_entry in enumerate(history):
|
||
|
|
if not history_entry.is_empty and blob_index >= len(self.filesystem_layers):
|
||
|
|
raise MalformedSchema2Manifest('Missing history entry #%s' % blob_index)
|
||
|
|
|
||
|
|
v1_layer_parent_id = v1_layer_id
|
||
|
|
blob_layer = None if history_entry.is_empty else self.filesystem_layers[blob_index]
|
||
|
|
blob_digest = EMPTY_LAYER_BLOB_DIGEST if blob_layer is None else str(blob_layer.digest)
|
||
|
|
compressed_size = EMPTY_LAYER_SIZE if blob_layer is None else blob_layer.compressed_size
|
||
|
|
|
||
|
|
# Create a new synthesized V1 ID for the history layer by hashing its content and
|
||
|
|
# the blob associated with it.
|
||
|
|
digest_history.update(json.dumps(history_entry.raw_entry))
|
||
|
|
digest_history.update("|")
|
||
|
|
digest_history.update(str(history_index))
|
||
|
|
digest_history.update("|")
|
||
|
|
digest_history.update(blob_digest)
|
||
|
|
digest_history.update("||")
|
||
|
|
|
||
|
|
v1_layer_id = digest_history.hexdigest()
|
||
|
|
yield DockerV2ManifestImageLayer(history=history_entry,
|
||
|
|
blob_layer=blob_layer,
|
||
|
|
blob_digest=blob_digest,
|
||
|
|
v1_id=v1_layer_id,
|
||
|
|
v1_parent_id=v1_layer_parent_id,
|
||
|
|
compressed_size=compressed_size)
|
||
|
|
|
||
|
|
if not history_entry.is_empty:
|
||
|
|
blob_index += 1
|
||
|
|
|
||
|
|
@property
|
||
|
|
def has_legacy_image(self):
|
||
|
|
return not self.has_remote_layer
|
||
|
|
|
||
|
|
def generate_legacy_layers(self, images_map, content_retriever):
|
||
|
|
assert not self.has_remote_layer
|
||
|
|
|
||
|
|
# NOTE: We use the DockerSchema1ManifestBuilder here because it already contains
|
||
|
|
# the logic for generating the DockerV1Metadata. All of this will go away once we get
|
||
|
|
# rid of legacy images in the database, so this is a temporary solution.
|
||
|
|
v1_builder = DockerSchema1ManifestBuilder('', '', '')
|
||
|
|
self._populate_schema1_builder(v1_builder, content_retriever)
|
||
|
|
return v1_builder.build().generate_legacy_layers(images_map, content_retriever)
|
||
|
|
|
||
|
|
def get_leaf_layer_v1_image_id(self, content_retriever):
|
||
|
|
# NOTE: If there exists a layer with remote content, then we consider this manifest
|
||
|
|
# to not support legacy images.
|
||
|
|
if self.has_remote_layer:
|
||
|
|
return None
|
||
|
|
|
||
|
|
return self.get_legacy_image_ids(content_retriever)[-1].v1_id
|
||
|
|
|
||
|
|
def get_legacy_image_ids(self, content_retriever):
|
||
|
|
if self.has_remote_layer:
|
||
|
|
return None
|
||
|
|
|
||
|
|
return [l.v1_id for l in self._manifest_image_layers(content_retriever)]
|
||
|
|
|
||
|
|
def convert_manifest(self, allowed_mediatypes, namespace_name, repo_name, tag_name,
|
||
|
|
content_retriever):
|
||
|
|
if self.media_type in allowed_mediatypes:
|
||
|
|
return self
|
||
|
|
|
||
|
|
# If this manifest is not on the allowed list, try to convert the schema 1 version (if any)
|
||
|
|
schema1 = self.get_schema1_manifest(namespace_name, repo_name, tag_name, content_retriever)
|
||
|
|
if schema1 is None:
|
||
|
|
return None
|
||
|
|
|
||
|
|
return schema1.convert_manifest(allowed_mediatypes, namespace_name, repo_name, tag_name,
|
||
|
|
content_retriever)
|
||
|
|
|
||
|
|
def get_schema1_manifest(self, namespace_name, repo_name, tag_name, content_retriever):
|
||
|
|
if self.has_remote_layer:
|
||
|
|
return None
|
||
|
|
|
||
|
|
v1_builder = DockerSchema1ManifestBuilder(namespace_name, repo_name, tag_name)
|
||
|
|
self._populate_schema1_builder(v1_builder, content_retriever)
|
||
|
|
return v1_builder.build()
|
||
|
|
|
||
|
|
def unsigned(self):
|
||
|
|
return self
|
||
|
|
|
||
|
|
def get_requires_empty_layer_blob(self, content_retriever):
|
||
|
|
schema2_config = self._get_built_config(content_retriever)
|
||
|
|
if schema2_config is None:
|
||
|
|
return None
|
||
|
|
|
||
|
|
return schema2_config.has_empty_layer
|
||
|
|
|
||
|
|
def _populate_schema1_builder(self, v1_builder, content_retriever):
|
||
|
|
""" Populates a DockerSchema1ManifestBuilder with the layers and config from
|
||
|
|
this schema.
|
||
|
|
"""
|
||
|
|
assert not self.has_remote_layer
|
||
|
|
schema2_config = self._get_built_config(content_retriever)
|
||
|
|
layers = list(self._manifest_image_layers(content_retriever))
|
||
|
|
|
||
|
|
for index, layer in enumerate(reversed(layers)): # Schema 1 layers are in reverse order
|
||
|
|
v1_compatibility = schema2_config.build_v1_compatibility(layer.history,
|
||
|
|
layer.v1_id,
|
||
|
|
layer.v1_parent_id,
|
||
|
|
index == 0,
|
||
|
|
layer.compressed_size)
|
||
|
|
v1_builder.add_layer(str(layer.blob_digest), json.dumps(v1_compatibility))
|
||
|
|
|
||
|
|
return v1_builder
|
||
|
|
|
||
|
|
def _get_built_config(self, content_retriever):
|
||
|
|
if self._cached_built_config:
|
||
|
|
return self._cached_built_config
|
||
|
|
|
||
|
|
config_bytes = content_retriever.get_blob_bytes_with_digest(self.config.digest)
|
||
|
|
if config_bytes is None:
|
||
|
|
raise MalformedSchema2Manifest('Could not load config blob for manifest')
|
||
|
|
|
||
|
|
if len(config_bytes) != self.config.size:
|
||
|
|
msg = 'Size of config does not match that retrieved: %s vs %s' % (len(config_bytes),
|
||
|
|
self.config.size)
|
||
|
|
raise MalformedSchema2Manifest(msg)
|
||
|
|
|
||
|
|
self._cached_built_config = DockerSchema2Config(Bytes.for_string_or_unicode(config_bytes))
|
||
|
|
return self._cached_built_config
|
||
|
|
|
||
|
|
def _generate_filesystem_layers(self):
|
||
|
|
for index, layer in enumerate(self._parsed[DOCKER_SCHEMA2_MANIFEST_LAYERS_KEY]):
|
||
|
|
content_type = layer[DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY]
|
||
|
|
is_remote = content_type == DOCKER_SCHEMA2_REMOTE_LAYER_CONTENT_TYPE
|
||
|
|
|
||
|
|
try:
|
||
|
|
digest = digest_tools.Digest.parse_digest(layer[DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY])
|
||
|
|
except digest_tools.InvalidDigestException:
|
||
|
|
raise MalformedSchema2Manifest('could not parse manifest digest: %s' %
|
||
|
|
layer[DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY])
|
||
|
|
|
||
|
|
yield DockerV2ManifestLayer(index=index,
|
||
|
|
compressed_size=layer[DOCKER_SCHEMA2_MANIFEST_SIZE_KEY],
|
||
|
|
digest=digest,
|
||
|
|
is_remote=is_remote,
|
||
|
|
urls=layer.get(DOCKER_SCHEMA2_MANIFEST_URLS_KEY))
|
||
|
|
|
||
|
|
|
||
|
|
class DockerSchema2ManifestBuilder(object):
|
||
|
|
"""
|
||
|
|
A convenient abstraction around creating new DockerSchema2Manifests.
|
||
|
|
"""
|
||
|
|
def __init__(self):
|
||
|
|
self.config = None
|
||
|
|
self.filesystem_layers = []
|
||
|
|
|
||
|
|
def set_config(self, schema2_config):
|
||
|
|
""" Sets the configuration for the manifest being built. """
|
||
|
|
self.set_config_digest(schema2_config.digest, schema2_config.size)
|
||
|
|
|
||
|
|
def set_config_digest(self, config_digest, config_size):
|
||
|
|
""" Sets the digest and size of the configuration layer. """
|
||
|
|
self.config = DockerV2ManifestConfig(size=config_size, digest=config_digest)
|
||
|
|
|
||
|
|
def add_layer(self, digest, size, urls=None):
|
||
|
|
""" Adds a filesystem layer to the manifest. """
|
||
|
|
self.filesystem_layers.append(DockerV2ManifestLayer(index=len(self.filesystem_layers),
|
||
|
|
digest=digest,
|
||
|
|
compressed_size=size,
|
||
|
|
urls=urls,
|
||
|
|
is_remote=bool(urls)))
|
||
|
|
|
||
|
|
def build(self, ensure_ascii=True):
|
||
|
|
""" Builds and returns the DockerSchema2Manifest. """
|
||
|
|
assert self.filesystem_layers
|
||
|
|
assert self.config
|
||
|
|
|
||
|
|
def _build_layer(layer):
|
||
|
|
if layer.urls:
|
||
|
|
return {
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY: DOCKER_SCHEMA2_REMOTE_LAYER_CONTENT_TYPE,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_SIZE_KEY: layer.compressed_size,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY: str(layer.digest),
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_URLS_KEY: layer.urls,
|
||
|
|
}
|
||
|
|
|
||
|
|
return {
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY: DOCKER_SCHEMA2_LAYER_CONTENT_TYPE,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_SIZE_KEY: layer.compressed_size,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY: str(layer.digest),
|
||
|
|
}
|
||
|
|
|
||
|
|
manifest_dict = {
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_VERSION_KEY: 2,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY: DOCKER_SCHEMA2_MANIFEST_CONTENT_TYPE,
|
||
|
|
|
||
|
|
# Config
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_CONFIG_KEY: {
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_MEDIATYPE_KEY: DOCKER_SCHEMA2_CONFIG_CONTENT_TYPE,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_SIZE_KEY: self.config.size,
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_DIGEST_KEY: str(self.config.digest),
|
||
|
|
},
|
||
|
|
|
||
|
|
# Layers
|
||
|
|
DOCKER_SCHEMA2_MANIFEST_LAYERS_KEY: [
|
||
|
|
_build_layer(layer) for layer in self.filesystem_layers
|
||
|
|
],
|
||
|
|
}
|
||
|
|
|
||
|
|
json_str = json.dumps(manifest_dict, ensure_ascii=ensure_ascii, indent=3)
|
||
|
|
return DockerSchema2Manifest(Bytes.for_string_or_unicode(json_str))
|