package client import ( "bytes" "errors" "fmt" "io" "io/ioutil" "sync" "github.com/docker/docker-registry" ) var ( // ErrLayerAlreadyExists is returned when attempting to create a layer with // a tarsum that is already in use. ErrLayerAlreadyExists = errors.New("Layer already exists") // ErrLayerLocked is returned when attempting to write to a layer which is // currently being written to. ErrLayerLocked = errors.New("Layer locked") ) // ObjectStore is an interface which is designed to approximate the docker // engine storage. This interface is subject to change to conform to the // future requirements of the engine. type ObjectStore interface { // Manifest retrieves the image manifest stored at the given repository name // and tag Manifest(name, tag string) (*registry.ImageManifest, error) // WriteManifest stores an image manifest at the given repository name and // tag WriteManifest(name, tag string, manifest *registry.ImageManifest) error // Layer returns a handle to a layer for reading and writing Layer(blobSum string) (Layer, error) } // Layer is a generic image layer interface. // A Layer may only be written to once type Layer interface { // Reader returns an io.ReadCloser which reads the contents of the layer Reader() (io.ReadCloser, error) // Writer returns an io.WriteCloser which may write the contents of the // layer. This method may only be called once per Layer, and the contents // are made available on Close Writer() (io.WriteCloser, error) // Wait blocks until the Layer can be read from Wait() error } // memoryObjectStore is an in-memory implementation of the ObjectStore interface type memoryObjectStore struct { mutex *sync.Mutex manifestStorage map[string]*registry.ImageManifest layerStorage map[string]Layer } func (objStore *memoryObjectStore) Manifest(name, tag string) (*registry.ImageManifest, error) { objStore.mutex.Lock() defer objStore.mutex.Unlock() manifest, ok := objStore.manifestStorage[name+":"+tag] if !ok { return nil, fmt.Errorf("No manifest found with Name: %q, Tag: %q", name, tag) } return manifest, nil } func (objStore *memoryObjectStore) WriteManifest(name, tag string, manifest *registry.ImageManifest) error { objStore.mutex.Lock() defer objStore.mutex.Unlock() objStore.manifestStorage[name+":"+tag] = manifest return nil } func (objStore *memoryObjectStore) Layer(blobSum string) (Layer, error) { objStore.mutex.Lock() defer objStore.mutex.Unlock() layer, ok := objStore.layerStorage[blobSum] if !ok { layer = &memoryLayer{cond: sync.NewCond(new(sync.Mutex))} objStore.layerStorage[blobSum] = layer } return layer, nil } type memoryLayer struct { cond *sync.Cond buffer *bytes.Buffer written bool } func (ml *memoryLayer) Writer() (io.WriteCloser, error) { ml.cond.L.Lock() defer ml.cond.L.Unlock() if ml.buffer != nil { if !ml.written { return nil, ErrLayerLocked } return nil, ErrLayerAlreadyExists } ml.buffer = new(bytes.Buffer) return &memoryLayerWriter{cond: ml.cond, buffer: ml.buffer, done: &ml.written}, nil } func (ml *memoryLayer) Reader() (io.ReadCloser, error) { ml.cond.L.Lock() defer ml.cond.L.Unlock() if ml.buffer == nil { return nil, fmt.Errorf("Layer has not been written to yet") } if !ml.written { return nil, ErrLayerLocked } return ioutil.NopCloser(bytes.NewReader(ml.buffer.Bytes())), nil } func (ml *memoryLayer) Wait() error { ml.cond.L.Lock() defer ml.cond.L.Unlock() if ml.buffer == nil { return fmt.Errorf("No writer to wait on") } for !ml.written { ml.cond.Wait() } return nil } type memoryLayerWriter struct { cond *sync.Cond buffer *bytes.Buffer done *bool } func (mlw *memoryLayerWriter) Write(p []byte) (int, error) { return mlw.buffer.Write(p) } func (mlw *memoryLayerWriter) Close() error { *mlw.done = true mlw.cond.Broadcast() return nil }