Registry: moved manifest schema operations to new files

Signed-off-by: Michal Minář <[email protected]>

Author: Michal Minář

pkg/dockerregistry/server/manifesthandler.go

@@ -0,0 +1,63 @@
+package server
+
+import (
+	"fmt"
+
+	"github.com/docker/distribution"
+	"github.com/docker/distribution/context"
+	"github.com/docker/distribution/manifest/schema1"
+	"github.com/docker/distribution/manifest/schema2"
+
+	imageapi "github.com/openshift/origin/pkg/image/api"
+)
+
+// A ManifestHandler defines a common set of operations on all versions of manifest schema.
+type ManifestHandler interface {
+	// FillImageMetadata fills a given image with metadata parsed from manifest. It also corrects layer sizes
+	// with blob sizes. Newer Docker client versions don't set layer sizes in the manifest schema 1 at all.
+	// Origin master needs correct layer sizes for proper image quota support. That's why we need to fill the
+	// metadata in the registry.
+	FillImageMetadata(ctx context.Context, image *imageapi.Image) error
+
+	// Manifest returns a deserialized manifest object.
+	Manifest() distribution.Manifest
+
+	// Payload returns manifest's media type, complete payload with signatures and canonical payload without
+	// signatures or an error if the information could not be fetched.
+	Payload() (mediaType string, payload []byte, canonical []byte, err error)
+}
+
+// NewManifestHandler creates a manifest handler for the given manifest.
+func NewManifestHandler(repo *repository, manifest distribution.Manifest) (ManifestHandler, error) {
+	switch t := manifest.(type) {
+	case *schema1.SignedManifest:
+		return &manifestSchema1Handler{repo: repo, manifest: t}, nil
+	case *schema2.DeserializedManifest:
+		return &manifestSchema2Handler{repo: repo, manifest: t}, nil
+	default:
+		return nil, fmt.Errorf("unsupported manifest type %T", manifest)
+	}
+}
+
+// NewManifestHandlerFromImage creates a new manifest handler for a manifest stored in the given image.
+func NewManifestHandlerFromImage(repo *repository, image *imageapi.Image) (ManifestHandler, error) {
+	var (
+		manifest distribution.Manifest
+		err      error
+	)
+
+	switch image.DockerImageManifestMediaType {
+	case "", schema1.MediaTypeManifest:
+		manifest, err = unmarshalManifestSchema1([]byte(image.DockerImageManifest), image.DockerImageSignatures)
+	case schema2.MediaTypeManifest:
+		manifest, err = unmarshalManifestSchema2([]byte(image.DockerImageManifest))
+	default:
+		return nil, fmt.Errorf("unsupported manifest media type %s", image.DockerImageManifestMediaType)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return NewManifestHandler(repo, manifest)
+}

pkg/dockerregistry/server/manifestschema1handler.go

@@ -0,0 +1,105 @@
+package server
+
+import (
+	"encoding/json"
+
+	"github.com/docker/distribution"
+	"github.com/docker/distribution/context"
+	"github.com/docker/distribution/manifest/schema1"
+	"github.com/docker/libtrust"
+
+	"k8s.io/kubernetes/pkg/util/sets"
+
+	imageapi "github.com/openshift/origin/pkg/image/api"
+)
+
+func unmarshalManifestSchema1(content []byte, signatures [][]byte) (distribution.Manifest, error) {
+	// prefer signatures from the manifest
+	if _, err := libtrust.ParsePrettySignature(content, "signatures"); err == nil {
+		sm := schema1.SignedManifest{Canonical: content}
+		if err = json.Unmarshal(content, &sm); err == nil {
+			return &sm, nil
+		}
+	}
+
+	jsig, err := libtrust.NewJSONSignature(content, signatures...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Extract the pretty JWS
+	content, err = jsig.PrettySignature("signatures")
+	if err != nil {
+		return nil, err
+	}
+
+	var sm schema1.SignedManifest
+	if err = json.Unmarshal(content, &sm); err != nil {
+		return nil, err
+	}
+	return &sm, nil
+}
+
+type manifestSchema1Handler struct {
+	repo     *repository
+	manifest *schema1.SignedManifest
+}
+
+var _ ManifestHandler = &manifestSchema1Handler{}
+
+func (h *manifestSchema1Handler) FillImageMetadata(ctx context.Context, image *imageapi.Image) error {
+	signatures, err := h.manifest.Signatures()
+	if err != nil {
+		return err
+	}
+
+	for _, signDigest := range signatures {
+		image.DockerImageSignatures = append(image.DockerImageSignatures, signDigest)
+	}
+
+	if err := imageapi.ImageWithMetadata(image); err != nil {
+		return err
+	}
+
+	refs := h.manifest.References()
+
+	blobSet := sets.NewString()
+	image.DockerImageMetadata.Size = int64(0)
+
+	blobs := h.repo.Blobs(ctx)
+	for i := range image.DockerImageLayers {
+		layer := &image.DockerImageLayers[i]
+		// DockerImageLayers represents h.manifest.Manifest.FSLayers in reversed order
+		desc, err := blobs.Stat(ctx, refs[len(image.DockerImageLayers)-i-1].Digest)
+		if err != nil {
+			context.GetLogger(ctx).Errorf("failed to stat blob %s of image %s", layer.Name, image.DockerImageReference)
+			return err
+		}
+		// The MediaType appeared in manifest schema v2. We need to fill it
+		// manually in the old images if it is not already filled.
+		if len(layer.MediaType) == 0 {
+			if len(desc.MediaType) > 0 {
+				layer.MediaType = desc.MediaType
+			} else {
+				layer.MediaType = schema1.MediaTypeManifestLayer
+			}
+		}
+		layer.LayerSize = desc.Size
+		// count empty layer just once (empty layer may actually have non-zero size)
+		if !blobSet.Has(layer.Name) {
+			image.DockerImageMetadata.Size += desc.Size
+			blobSet.Insert(layer.Name)
+		}
+	}
+
+	return nil
+}
+
+func (h *manifestSchema1Handler) Manifest() distribution.Manifest {
+	return h.manifest
+}
+
+func (h *manifestSchema1Handler) Payload() (mediaType string, payload []byte, canonical []byte, err error) {
+	mt, payload, err := h.manifest.Payload()
+	return mt, payload, h.manifest.Canonical, err
+}

pkg/dockerregistry/server/manifestschema2handler.go

@@ -0,0 +1,53 @@
+package server
+
+import (
+	"encoding/json"
+
+	"github.com/docker/distribution"
+	"github.com/docker/distribution/context"
+	"github.com/docker/distribution/manifest/schema2"
+
+	imageapi "github.com/openshift/origin/pkg/image/api"
+)
+
+func unmarshalManifestSchema2(content []byte) (distribution.Manifest, error) {
+	var deserializedManifest schema2.DeserializedManifest
+	if err := json.Unmarshal(content, &deserializedManifest); err != nil {
+		return nil, err
+	}
+
+	return &deserializedManifest, nil
+}
+
+type manifestSchema2Handler struct {
+	repo     *repository
+	manifest *schema2.DeserializedManifest
+}
+
+var _ ManifestHandler = &manifestSchema2Handler{}
+
+func (h *manifestSchema2Handler) FillImageMetadata(ctx context.Context, image *imageapi.Image) error {
+	// The manifest.Config references a configuration object for a container by its digest.
+	// It needs to be fetched in order to fill an image object metadata below.
+	configBytes, err := h.repo.Blobs(ctx).Get(ctx, h.manifest.Config.Digest)
+	if err != nil {
+		context.GetLogger(ctx).Errorf("failed to get image config %s: %v", h.manifest.Config.Digest.String(), err)
+		return err
+	}
+	image.DockerImageConfig = string(configBytes)
+
+	if err := imageapi.ImageWithMetadata(image); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *manifestSchema2Handler) Manifest() distribution.Manifest {
+	return h.manifest
+}
+
+func (h *manifestSchema2Handler) Payload() (mediaType string, payload []byte, canonical []byte, err error) {
+	mt, p, err := h.manifest.Payload()
+	return mt, p, p, err
+}