package storage import ( "fmt" "strings" "time" "github.com/Sirupsen/logrus" "github.com/docker/docker-registry/digest" "github.com/docker/docker-registry/storagedriver" ) type layerStore struct { driver storagedriver.StorageDriver pathMapper *pathMapper uploadStore layerUploadStore } func (ls *layerStore) Exists(name string, digest digest.Digest) (bool, error) { // Because this implementation just follows blob links, an existence check // is pretty cheap by starting and closing a fetch. _, err := ls.Fetch(name, digest) if err != nil { if err == ErrLayerUnknown { return false, nil } return false, err } return true, nil } func (ls *layerStore) Fetch(name string, digest digest.Digest) (Layer, error) { repos, err := ls.resolveContainingRepositories(digest) if err != nil { // TODO(stevvooe): Unknown tarsum error: need to wrap. return nil, err } // TODO(stevvooe): Access control for layer pulls need to happen here: we // have a list of repos that "own" the tarsum that need to be checked // against the list of repos to which we have pull access. The argument // repos needs to be filtered against that access list. _, blobPath, err := ls.resolveBlobPath(repos, digest) if err != nil { // TODO(stevvooe): Map this error correctly, perhaps in the callee. return nil, err } p, err := ls.pathMapper.path(blobPath) if err != nil { return nil, err } fr, err := newFileReader(ls.driver, p) if err != nil { switch err := err.(type) { case storagedriver.PathNotFoundError, *storagedriver.PathNotFoundError: return nil, ErrLayerUnknown default: return nil, err } } return &layerReader{ fileReader: *fr, name: name, digest: digest, // TODO(stevvooe): Storage backend does not support modification time // queries yet. Layers "never" change, so just return the zero value // plus a nano-second. createdAt: (time.Time{}).Add(time.Nanosecond), }, nil } // Upload begins a layer upload, returning a handle. If the layer upload // is already in progress or the layer has already been uploaded, this // will return an error. func (ls *layerStore) Upload(name string) (LayerUpload, error) { // NOTE(stevvooe): Consider the issues with allowing concurrent upload of // the same two layers. Should it be disallowed? For now, we allow both // parties to proceed and the the first one uploads the layer. lus, err := ls.uploadStore.New(name) if err != nil { return nil, err } return ls.newLayerUpload(lus), nil } // Resume continues an in progress layer upload, returning the current // state of the upload. func (ls *layerStore) Resume(uuid string) (LayerUpload, error) { lus, err := ls.uploadStore.GetState(uuid) if err != nil { return nil, err } return ls.newLayerUpload(lus), nil } // newLayerUpload allocates a new upload controller with the given state. func (ls *layerStore) newLayerUpload(lus LayerUploadState) LayerUpload { return &layerUploadController{ LayerUploadState: lus, layerStore: ls, uploadStore: ls.uploadStore, } } func (ls *layerStore) resolveContainingRepositories(digest digest.Digest) ([]string, error) { // Lookup the layer link in the index by tarsum id. layerIndexLinkPath, err := ls.pathMapper.path(layerIndexLinkPathSpec{digest: digest}) if err != nil { return nil, err } layerIndexLinkContent, err := ls.driver.GetContent(layerIndexLinkPath) if err != nil { switch err := err.(type) { case storagedriver.PathNotFoundError: return nil, ErrLayerUnknown default: return nil, err } } results := strings.Split(string(layerIndexLinkContent), "\n") // clean these up for i, result := range results { results[i] = strings.TrimSpace(result) } return results, nil } // resolveBlobId lookups up the tarSum in the various repos to find the blob // link, returning the repo name and blob path spec or an error on failure. func (ls *layerStore) resolveBlobPath(repos []string, digest digest.Digest) (name string, bps blobPathSpec, err error) { for _, repo := range repos { pathSpec := layerLinkPathSpec{name: repo, digest: digest} layerLinkPath, err := ls.pathMapper.path(pathSpec) if err != nil { // TODO(stevvooe): This looks very lazy, may want to collect these // errors and report them if we exit this for loop without // resolving the blob id. logrus.Debugf("error building linkLayerPath (%V): %v", pathSpec, err) continue } layerLinkContent, err := ls.driver.GetContent(layerLinkPath) if err != nil { logrus.Debugf("error getting layerLink content (%V): %v", pathSpec, err) continue } // Yay! We've resolved our blob id and we're ready to go. parts := strings.SplitN(strings.TrimSpace(string(layerLinkContent)), ":", 2) if len(parts) != 2 { return "", bps, fmt.Errorf("invalid blob reference: %q", string(layerLinkContent)) } name = repo bp := blobPathSpec{alg: parts[0], digest: parts[1]} return repo, bp, nil } // TODO(stevvooe): Map this error to repo not found, but it basically // means we exited the loop above without finding a blob link. return "", bps, fmt.Errorf("unable to resolve blog id for repos=%v and digest=%v", repos, digest) }