| package image // import "github.com/docker/docker/image" |
| |
| import ( |
| "fmt" |
| "io/ioutil" |
| "os" |
| "path/filepath" |
| "sync" |
| |
| "github.com/docker/docker/pkg/ioutils" |
| "github.com/opencontainers/go-digest" |
| "github.com/pkg/errors" |
| "github.com/sirupsen/logrus" |
| ) |
| |
| // DigestWalkFunc is function called by StoreBackend.Walk |
| type DigestWalkFunc func(id digest.Digest) error |
| |
| // StoreBackend provides interface for image.Store persistence |
| type StoreBackend interface { |
| Walk(f DigestWalkFunc) error |
| Get(id digest.Digest) ([]byte, error) |
| Set(data []byte) (digest.Digest, error) |
| Delete(id digest.Digest) error |
| SetMetadata(id digest.Digest, key string, data []byte) error |
| GetMetadata(id digest.Digest, key string) ([]byte, error) |
| DeleteMetadata(id digest.Digest, key string) error |
| } |
| |
| // fs implements StoreBackend using the filesystem. |
| type fs struct { |
| sync.RWMutex |
| root string |
| } |
| |
| const ( |
| contentDirName = "content" |
| metadataDirName = "metadata" |
| ) |
| |
| // NewFSStoreBackend returns new filesystem based backend for image.Store |
| func NewFSStoreBackend(root string) (StoreBackend, error) { |
| return newFSStore(root) |
| } |
| |
| func newFSStore(root string) (*fs, error) { |
| s := &fs{ |
| root: root, |
| } |
| if err := os.MkdirAll(filepath.Join(root, contentDirName, string(digest.Canonical)), 0700); err != nil { |
| return nil, errors.Wrap(err, "failed to create storage backend") |
| } |
| if err := os.MkdirAll(filepath.Join(root, metadataDirName, string(digest.Canonical)), 0700); err != nil { |
| return nil, errors.Wrap(err, "failed to create storage backend") |
| } |
| return s, nil |
| } |
| |
| func (s *fs) contentFile(dgst digest.Digest) string { |
| return filepath.Join(s.root, contentDirName, string(dgst.Algorithm()), dgst.Hex()) |
| } |
| |
| func (s *fs) metadataDir(dgst digest.Digest) string { |
| return filepath.Join(s.root, metadataDirName, string(dgst.Algorithm()), dgst.Hex()) |
| } |
| |
| // Walk calls the supplied callback for each image ID in the storage backend. |
| func (s *fs) Walk(f DigestWalkFunc) error { |
| // Only Canonical digest (sha256) is currently supported |
| s.RLock() |
| dir, err := ioutil.ReadDir(filepath.Join(s.root, contentDirName, string(digest.Canonical))) |
| s.RUnlock() |
| if err != nil { |
| return err |
| } |
| for _, v := range dir { |
| dgst := digest.NewDigestFromHex(string(digest.Canonical), v.Name()) |
| if err := dgst.Validate(); err != nil { |
| logrus.Debugf("skipping invalid digest %s: %s", dgst, err) |
| continue |
| } |
| if err := f(dgst); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| // Get returns the content stored under a given digest. |
| func (s *fs) Get(dgst digest.Digest) ([]byte, error) { |
| s.RLock() |
| defer s.RUnlock() |
| |
| return s.get(dgst) |
| } |
| |
| func (s *fs) get(dgst digest.Digest) ([]byte, error) { |
| content, err := ioutil.ReadFile(s.contentFile(dgst)) |
| if err != nil { |
| return nil, errors.Wrapf(err, "failed to get digest %s", dgst) |
| } |
| |
| // todo: maybe optional |
| if digest.FromBytes(content) != dgst { |
| return nil, fmt.Errorf("failed to verify: %v", dgst) |
| } |
| |
| return content, nil |
| } |
| |
| // Set stores content by checksum. |
| func (s *fs) Set(data []byte) (digest.Digest, error) { |
| s.Lock() |
| defer s.Unlock() |
| |
| if len(data) == 0 { |
| return "", fmt.Errorf("invalid empty data") |
| } |
| |
| dgst := digest.FromBytes(data) |
| if err := ioutils.AtomicWriteFile(s.contentFile(dgst), data, 0600); err != nil { |
| return "", errors.Wrap(err, "failed to write digest data") |
| } |
| |
| return dgst, nil |
| } |
| |
| // Delete removes content and metadata files associated with the digest. |
| func (s *fs) Delete(dgst digest.Digest) error { |
| s.Lock() |
| defer s.Unlock() |
| |
| if err := os.RemoveAll(s.metadataDir(dgst)); err != nil { |
| return err |
| } |
| return os.Remove(s.contentFile(dgst)) |
| } |
| |
| // SetMetadata sets metadata for a given ID. It fails if there's no base file. |
| func (s *fs) SetMetadata(dgst digest.Digest, key string, data []byte) error { |
| s.Lock() |
| defer s.Unlock() |
| if _, err := s.get(dgst); err != nil { |
| return err |
| } |
| |
| baseDir := filepath.Join(s.metadataDir(dgst)) |
| if err := os.MkdirAll(baseDir, 0700); err != nil { |
| return err |
| } |
| return ioutils.AtomicWriteFile(filepath.Join(s.metadataDir(dgst), key), data, 0600) |
| } |
| |
| // GetMetadata returns metadata for a given digest. |
| func (s *fs) GetMetadata(dgst digest.Digest, key string) ([]byte, error) { |
| s.RLock() |
| defer s.RUnlock() |
| |
| if _, err := s.get(dgst); err != nil { |
| return nil, err |
| } |
| bytes, err := ioutil.ReadFile(filepath.Join(s.metadataDir(dgst), key)) |
| if err != nil { |
| return nil, errors.Wrap(err, "failed to read metadata") |
| } |
| return bytes, nil |
| } |
| |
| // DeleteMetadata removes the metadata associated with a digest. |
| func (s *fs) DeleteMetadata(dgst digest.Digest, key string) error { |
| s.Lock() |
| defer s.Unlock() |
| |
| return os.RemoveAll(filepath.Join(s.metadataDir(dgst), key)) |
| } |