121 lines
4.4 KiB
Go
121 lines
4.4 KiB
Go
package distribution
|
|
|
|
import (
|
|
"github.com/docker/distribution/context"
|
|
"github.com/docker/distribution/digest"
|
|
"github.com/docker/distribution/manifest/schema1"
|
|
)
|
|
|
|
// Scope defines the set of items that match a namespace.
|
|
type Scope interface {
|
|
// Contains returns true if the name belongs to the namespace.
|
|
Contains(name string) bool
|
|
}
|
|
|
|
type fullScope struct{}
|
|
|
|
func (f fullScope) Contains(string) bool {
|
|
return true
|
|
}
|
|
|
|
// GlobalScope represents the full namespace scope which contains
|
|
// all other scopes.
|
|
var GlobalScope = Scope(fullScope{})
|
|
|
|
// Namespace represents a collection of repositories, addressable by name.
|
|
// Generally, a namespace is backed by a set of one or more services,
|
|
// providing facilities such as registry access, trust, and indexing.
|
|
type Namespace interface {
|
|
// Scope describes the names that can be used with this Namespace. The
|
|
// global namespace will have a scope that matches all names. The scope
|
|
// effectively provides an identity for the namespace.
|
|
Scope() Scope
|
|
|
|
// Repository should return a reference to the named repository. The
|
|
// registry may or may not have the repository but should always return a
|
|
// reference.
|
|
Repository(ctx context.Context, name string) (Repository, error)
|
|
|
|
// Repositories fills 'repos' with a lexigraphically sorted catalog of repositories
|
|
// up to the size of 'repos' and returns the value 'n' for the number of entries
|
|
// which were filled. 'last' contains an offset in the catalog, and 'err' will be
|
|
// set to io.EOF if there are no more entries to obtain.
|
|
Repositories(ctx context.Context, repos []string, last string) (n int, err error)
|
|
}
|
|
|
|
// ManifestServiceOption is a function argument for Manifest Service methods
|
|
type ManifestServiceOption func(ManifestService) error
|
|
|
|
// Repository is a named collection of manifests and layers.
|
|
type Repository interface {
|
|
// Name returns the name of the repository.
|
|
Name() string
|
|
|
|
// Manifests returns a reference to this repository's manifest service.
|
|
// with the supplied options applied.
|
|
Manifests(ctx context.Context, options ...ManifestServiceOption) (ManifestService, error)
|
|
|
|
// Blobs returns a reference to this repository's blob service.
|
|
Blobs(ctx context.Context) BlobStore
|
|
|
|
// TODO(stevvooe): The above BlobStore return can probably be relaxed to
|
|
// be a BlobService for use with clients. This will allow such
|
|
// implementations to avoid implementing ServeBlob.
|
|
|
|
// Signatures returns a reference to this repository's signatures service.
|
|
Signatures() SignatureService
|
|
}
|
|
|
|
// TODO(stevvooe): Must add close methods to all these. May want to change the
|
|
// way instances are created to better reflect internal dependency
|
|
// relationships.
|
|
|
|
// ManifestService provides operations on image manifests.
|
|
type ManifestService interface {
|
|
// Exists returns true if the manifest exists.
|
|
Exists(dgst digest.Digest) (bool, error)
|
|
|
|
// Get retrieves the identified by the digest, if it exists.
|
|
Get(dgst digest.Digest) (*schema1.SignedManifest, error)
|
|
|
|
// Delete removes the manifest, if it exists.
|
|
Delete(dgst digest.Digest) error
|
|
|
|
// Put creates or updates the manifest.
|
|
Put(manifest *schema1.SignedManifest) error
|
|
|
|
// TODO(stevvooe): The methods after this message should be moved to a
|
|
// discrete TagService, per active proposals.
|
|
|
|
// Tags lists the tags under the named repository.
|
|
Tags() ([]string, error)
|
|
|
|
// ExistsByTag returns true if the manifest exists.
|
|
ExistsByTag(tag string) (bool, error)
|
|
|
|
// GetByTag retrieves the named manifest, if it exists.
|
|
GetByTag(tag string, options ...ManifestServiceOption) (*schema1.SignedManifest, error)
|
|
|
|
// TODO(stevvooe): There are several changes that need to be done to this
|
|
// interface:
|
|
//
|
|
// 1. Allow explicit tagging with Tag(digest digest.Digest, tag string)
|
|
// 2. Support reading tags with a re-entrant reader to avoid large
|
|
// allocations in the registry.
|
|
// 3. Long-term: Provide All() method that lets one scroll through all of
|
|
// the manifest entries.
|
|
// 4. Long-term: break out concept of signing from manifests. This is
|
|
// really a part of the distribution sprint.
|
|
// 5. Long-term: Manifest should be an interface. This code shouldn't
|
|
// really be concerned with the storage format.
|
|
}
|
|
|
|
// SignatureService provides operations on signatures.
|
|
type SignatureService interface {
|
|
// Get retrieves all of the signature blobs for the specified digest.
|
|
Get(dgst digest.Digest) ([][]byte, error)
|
|
|
|
// Put stores the signature for the provided digest.
|
|
Put(dgst digest.Digest, signatures ...[]byte) error
|
|
}
|