2ff77c00ba
Add schema2 manifest implementation. Add a schema2 builder that creates a schema2 manifest from descriptors and a configuration. It will add the configuration to the blob store if necessary. Rename the original schema1 manifest builder to ReferenceBuilder, and create a ConfigBuilder variant that can build a schema1 manifest from an image configuration and set of descriptors. This will be used to translate schema2 manifests to the schema1 format for backward compatibliity, by adding the descriptors from the existing schema2 manifest to the schema1 builder. It will also be used by engine-side push code to create schema1 manifests from the new-style image configration, when necessary to push a schema1 manifest. Signed-off-by: Aaron Lehmann <aaron.lehmann@docker.com>
101 lines
3.6 KiB
Go
101 lines
3.6 KiB
Go
package distribution
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/docker/distribution/context"
|
|
"github.com/docker/distribution/digest"
|
|
)
|
|
|
|
// Manifest represents a registry object specifying a set of
|
|
// references and an optional target
|
|
type Manifest interface {
|
|
// References returns a list of objects which make up this manifest.
|
|
// The references are strictly ordered from base to head. A reference
|
|
// is anything which can be represented by a distribution.Descriptor
|
|
References() []Descriptor
|
|
|
|
// Payload provides the serialized format of the manifest, in addition to
|
|
// the mediatype.
|
|
Payload() (mediatype string, payload []byte, err error)
|
|
}
|
|
|
|
// ManifestBuilder creates a manifest allowing one to include dependencies.
|
|
// Instances can be obtained from a version-specific manifest package. Manifest
|
|
// specific data is passed into the function which creates the builder.
|
|
type ManifestBuilder interface {
|
|
// Build creates the manifest from his builder.
|
|
Build(ctx context.Context) (Manifest, error)
|
|
|
|
// References returns a list of objects which have been added to this
|
|
// builder. The dependencies are returned in the order they were added,
|
|
// which should be from base to head.
|
|
References() []Descriptor
|
|
|
|
// AppendReference includes the given object in the manifest after any
|
|
// existing dependencies. If the add fails, such as when adding an
|
|
// unsupported dependency, an error may be returned.
|
|
AppendReference(dependency Describable) error
|
|
}
|
|
|
|
// ManifestService describes operations on image manifests.
|
|
type ManifestService interface {
|
|
// Exists returns true if the manifest exists.
|
|
Exists(ctx context.Context, dgst digest.Digest) (bool, error)
|
|
|
|
// Get retrieves the manifest specified by the given digest
|
|
Get(ctx context.Context, dgst digest.Digest, options ...ManifestServiceOption) (Manifest, error)
|
|
|
|
// Put creates or updates the given manifest returning the manifest digest
|
|
Put(ctx context.Context, manifest Manifest, options ...ManifestServiceOption) (digest.Digest, error)
|
|
|
|
// Delete removes the manifest specified by the given digest. Deleting
|
|
// a manifest that doesn't exist will return ErrManifestNotFound
|
|
Delete(ctx context.Context, dgst digest.Digest) error
|
|
|
|
// Enumerate fills 'manifests' with the manifests in this service up
|
|
// to the size of 'manifests' and returns 'n' for the number of entries
|
|
// which were filled. 'last' contains an offset in the manifest set
|
|
// and can be used to resume iteration.
|
|
//Enumerate(ctx context.Context, manifests []Manifest, last Manifest) (n int, err error)
|
|
}
|
|
|
|
// Describable is an interface for descriptors
|
|
type Describable interface {
|
|
Descriptor() Descriptor
|
|
}
|
|
|
|
// ManifestMediaTypes returns the supported media types for manifests.
|
|
func ManifestMediaTypes() (mediaTypes []string) {
|
|
for t := range mappings {
|
|
mediaTypes = append(mediaTypes, t)
|
|
}
|
|
return
|
|
}
|
|
|
|
// UnmarshalFunc implements manifest unmarshalling a given MediaType
|
|
type UnmarshalFunc func([]byte) (Manifest, Descriptor, error)
|
|
|
|
var mappings = make(map[string]UnmarshalFunc, 0)
|
|
|
|
// UnmarshalManifest looks up manifest unmarshall functions based on
|
|
// MediaType
|
|
func UnmarshalManifest(mediatype string, p []byte) (Manifest, Descriptor, error) {
|
|
unmarshalFunc, ok := mappings[mediatype]
|
|
if !ok {
|
|
return nil, Descriptor{}, fmt.Errorf("unsupported manifest mediatype: %s", mediatype)
|
|
}
|
|
|
|
return unmarshalFunc(p)
|
|
}
|
|
|
|
// RegisterManifestSchema registers an UnmarshalFunc for a given schema type. This
|
|
// should be called from specific
|
|
func RegisterManifestSchema(mediatype string, u UnmarshalFunc) error {
|
|
if _, ok := mappings[mediatype]; ok {
|
|
return fmt.Errorf("manifest mediatype registration would overwrite existing: %s", mediatype)
|
|
}
|
|
mappings[mediatype] = u
|
|
return nil
|
|
}
|