mirror of https://github.com/docker/docs.git
142 lines
3.3 KiB
Go
142 lines
3.3 KiB
Go
package store
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"fmt"
|
|
"io"
|
|
|
|
"github.com/docker/notary"
|
|
"github.com/docker/notary/tuf/data"
|
|
"github.com/docker/notary/tuf/utils"
|
|
)
|
|
|
|
// NewMemoryStore returns a MetadataStore that operates entirely in memory.
|
|
// Very useful for testing
|
|
func NewMemoryStore(meta map[string][]byte, files map[string][]byte) *MemoryStore {
|
|
var consistent = make(map[string][]byte)
|
|
if meta == nil {
|
|
meta = make(map[string][]byte)
|
|
} else {
|
|
// add all seed meta to consistent
|
|
for name, data := range meta {
|
|
checksum := sha256.Sum256(data)
|
|
path := utils.URLFilePath(name, checksum[:], true)
|
|
consistent[path] = data
|
|
}
|
|
}
|
|
if files == nil {
|
|
files = make(map[string][]byte)
|
|
}
|
|
return &MemoryStore{
|
|
meta: meta,
|
|
consistent: consistent,
|
|
files: files,
|
|
keys: make(map[string][]data.PrivateKey),
|
|
}
|
|
}
|
|
|
|
// MemoryStore implements a mock RemoteStore entirely in memory.
|
|
// For testing purposes only.
|
|
type MemoryStore struct {
|
|
meta map[string][]byte
|
|
consistent map[string][]byte
|
|
files map[string][]byte
|
|
keys map[string][]data.PrivateKey
|
|
}
|
|
|
|
// If size is -1, this corresponds to "infinite," but we cut off at 100MB
|
|
func (m *MemoryStore) GetMeta(name string, size int64) ([]byte, error) {
|
|
d, ok := m.meta[name]
|
|
if ok {
|
|
if size == -1 {
|
|
size = notary.MaxDownloadSize
|
|
}
|
|
if int64(len(d)) < size {
|
|
return d, nil
|
|
}
|
|
return d[:size], nil
|
|
}
|
|
d, ok = m.consistent[name]
|
|
if ok {
|
|
if int64(len(d)) < size {
|
|
return d, nil
|
|
}
|
|
return d[:size], nil
|
|
}
|
|
return nil, ErrMetaNotFound{Resource: name}
|
|
}
|
|
|
|
func (m *MemoryStore) SetMeta(name string, meta []byte) error {
|
|
m.meta[name] = meta
|
|
|
|
checksum := sha256.Sum256(meta)
|
|
path := utils.URLFilePath(name, checksum[:], true)
|
|
m.consistent[path] = meta
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryStore) SetMultiMeta(metas map[string][]byte) error {
|
|
for role, blob := range metas {
|
|
m.SetMeta(role, blob)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// RemoveMeta removes the metadata for a single role - if the metadata doesn't
|
|
// exist, no error is returned
|
|
func (m *MemoryStore) RemoveMeta(name string) error {
|
|
delete(m.meta, name)
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryStore) GetTarget(path string) (io.ReadCloser, error) {
|
|
return &utils.NoopCloser{Reader: bytes.NewReader(m.files[path])}, nil
|
|
}
|
|
|
|
func (m *MemoryStore) WalkStagedTargets(paths []string, targetsFn targetsWalkFunc) error {
|
|
if len(paths) == 0 {
|
|
for path, dat := range m.files {
|
|
meta, err := data.NewFileMeta(bytes.NewReader(dat), "sha256")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err = targetsFn(path, meta); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
for _, path := range paths {
|
|
dat, ok := m.files[path]
|
|
if !ok {
|
|
return ErrMetaNotFound{Resource: path}
|
|
}
|
|
meta, err := data.NewFileMeta(bytes.NewReader(dat), "sha256")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err = targetsFn(path, meta); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryStore) Commit(map[string][]byte, bool, map[string]data.Hashes) error {
|
|
return nil
|
|
}
|
|
|
|
func (m *MemoryStore) GetKey(role string) ([]byte, error) {
|
|
return nil, fmt.Errorf("GetKey is not implemented for the MemoryStore")
|
|
}
|
|
|
|
// Clear this existing memory store by setting this store as new empty one
|
|
func (m *MemoryStore) RemoveAll() error {
|
|
m.meta = make(map[string][]byte)
|
|
m.files = make(map[string][]byte)
|
|
m.keys = make(map[string][]data.PrivateKey)
|
|
return nil
|
|
}
|