Removed deprecated docker/image package

image/image.go

@@ -1,342 +0,0 @@
-package image
-
-import (
-	"encoding/json"
-	"errors"
-	"github.com/dotcloud/docker/future"
-	"io"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"sort"
-	"strings"
-	"time"
-)
-
-type Store struct {
-	*Index
-	Root   string
-	Layers *LayerStore
-}
-
-func New(root string) (*Store, error) {
-	abspath, err := filepath.Abs(root)
-	if err != nil {
-		return nil, err
-	}
-	if err := os.MkdirAll(abspath, 0700); err != nil && !os.IsExist(err) {
-		return nil, err
-	}
-	layers, err := NewLayerStore(path.Join(root, "layers"))
-	if err != nil {
-		return nil, err
-	}
-	if err := layers.Init(); err != nil {
-		return nil, err
-	}
-	return &Store{
-		Root:   abspath,
-		Index:  NewIndex(path.Join(root, "index.json")),
-		Layers: layers,
-	}, nil
-}
-
-type Compression uint32
-
-const (
-	Uncompressed Compression = iota
-	Bzip2
-	Gzip
-)
-
-func (store *Store) Import(name string, archive io.Reader, stderr io.Writer, parent *Image, compression Compression) (*Image, error) {
-	layer, err := store.Layers.AddLayer(archive, stderr, compression)
-	if err != nil {
-		return nil, err
-	}
-	layers := []string{layer}
-	if parent != nil {
-		layers = append(layers, parent.Layers...)
-	}
-	var parentId string
-	if parent != nil {
-		parentId = parent.Id
-	}
-	return store.Create(name, parentId, layers...)
-}
-
-func (store *Store) Create(name string, source string, layers ...string) (*Image, error) {
-	image, err := NewImage(name, layers, source)
-	if err != nil {
-		return nil, err
-	}
-	if err := store.Index.Add(name, image); err != nil {
-		return nil, err
-	}
-	return image, nil
-}
-
-// Index
-
-type Index struct {
-	Path   string
-	ByName map[string]*History
-	ById   map[string]*Image
-}
-
-func NewIndex(path string) *Index {
-	return &Index{
-		Path:   path,
-		ByName: make(map[string]*History),
-		ById:   make(map[string]*Image),
-	}
-}
-
-func (index *Index) Exists(id string) bool {
-	_, exists := index.ById[id]
-	return exists
-}
-
-func (index *Index) Find(idOrName string) *Image {
-	// Load
-	if err := index.load(); err != nil {
-		return nil
-	}
-	// Lookup by ID
-	if image, exists := index.ById[idOrName]; exists {
-		return image
-	}
-	// Lookup by name
-	if history, exists := index.ByName[idOrName]; exists && history.Len() > 0 {
-		return (*history)[0]
-	}
-	return nil
-}
-
-func (index *Index) Add(name string, image *Image) error {
-	// Load
-	if err := index.load(); err != nil {
-		return err
-	}
-	if _, exists := index.ByName[name]; !exists {
-		index.ByName[name] = new(History)
-	} else {
-		// If this image is already the latest version, don't add it.
-		if (*index.ByName[name])[0].Id == image.Id {
-			return nil
-		}
-	}
-	index.ByName[name].Add(image)
-	index.ById[image.Id] = image
-	// Save
-	if err := index.save(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (index *Index) Copy(srcNameOrId, dstName string) (*Image, error) {
-	if srcNameOrId == "" || dstName == "" {
-		return nil, errors.New("Illegal image name")
-	}
-	// Load
-	if err := index.load(); err != nil {
-		return nil, err
-	}
-	src := index.Find(srcNameOrId)
-	if src == nil {
-		return nil, errors.New("No such image: " + srcNameOrId)
-	}
-	dst, err := NewImage(dstName, src.Layers, src.Id)
-	if err != nil {
-		return nil, err
-	}
-	if err := index.Add(dstName, dst); err != nil {
-		return nil, err
-	}
-	// Save
-	if err := index.save(); err != nil {
-		return nil, err
-	}
-	return dst, nil
-}
-
-func (index *Index) Rename(oldName, newName string) error {
-	// Load
-	if err := index.load(); err != nil {
-		return err
-	}
-	if _, exists := index.ByName[oldName]; !exists {
-		return errors.New("Can't rename " + oldName + ": no such image.")
-	}
-	if _, exists := index.ByName[newName]; exists {
-		return errors.New("Can't rename to " + newName + ": name is already in use.")
-	}
-	index.ByName[newName] = index.ByName[oldName]
-	delete(index.ByName, oldName)
-	// Change the ID of all images, since they include the name
-	for _, image := range *index.ByName[newName] {
-		if id, err := generateImageId(newName, image.Layers); err != nil {
-			return err
-		} else {
-			oldId := image.Id
-			image.Id = id
-			index.ById[id] = image
-			delete(index.ById, oldId)
-		}
-	}
-	// Save
-	if err := index.save(); err != nil {
-		return err
-	}
-	return nil
-}
-
-// Delete deletes all images with the name `name`
-func (index *Index) Delete(name string) error {
-	// Load
-	if err := index.load(); err != nil {
-		return err
-	}
-	if _, exists := index.ByName[name]; !exists {
-		return errors.New("No such image: " + name)
-	}
-	// Remove from index lookup
-	for _, image := range *index.ByName[name] {
-		delete(index.ById, image.Id)
-	}
-	// Remove from name lookup
-	delete(index.ByName, name)
-	// Save
-	if err := index.save(); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (index *Index) Names() []string {
-	if err := index.load(); err != nil {
-		return []string{}
-	}
-	var names []string
-	for name := range index.ByName {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	return names
-}
-
-func (index *Index) load() error {
-	jsonData, err := ioutil.ReadFile(index.Path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		return err
-	}
-	path := index.Path
-	if err := json.Unmarshal(jsonData, index); err != nil {
-		return err
-	}
-	index.Path = path
-	return nil
-}
-
-func (index *Index) save() error {
-	jsonData, err := json.Marshal(index)
-	if err != nil {
-		return err
-	}
-	if err := ioutil.WriteFile(index.Path, jsonData, 0600); err != nil {
-		return err
-	}
-	return nil
-}
-
-// History wraps an array of images so they can be sorted by date (most recent first)
-
-type History []*Image
-
-func (history *History) Len() int {
-	return len(*history)
-}
-
-func (history *History) Less(i, j int) bool {
-	images := *history
-	return images[j].Created.Before(images[i].Created)
-}
-
-func (history *History) Swap(i, j int) {
-	images := *history
-	tmp := images[i]
-	images[i] = images[j]
-	images[j] = tmp
-}
-
-func (history *History) Add(image *Image) {
-	*history = append(*history, image)
-	sort.Sort(history)
-}
-
-func (history *History) Del(id string) {
-	for idx, image := range *history {
-		if image.Id == id {
-			*history = append((*history)[:idx], (*history)[idx+1:]...)
-		}
-	}
-}
-
-type Image struct {
-	Id      string   // Globally unique identifier
-	Layers  []string // Absolute paths
-	Created time.Time
-	Parent  string
-}
-
-func (image *Image) IdParts() (string, string) {
-	if len(image.Id) < 8 {
-		return "", image.Id
-	}
-	hash := image.Id[len(image.Id)-8 : len(image.Id)]
-	name := image.Id[:len(image.Id)-9]
-	return name, hash
-}
-
-func (image *Image) IdIsFinal() bool {
-	return len(image.Layers) == 1
-}
-
-func generateImageId(name string, layers []string) (string, error) {
-	if len(layers) == 0 {
-		return "", errors.New("No layers provided.")
-	}
-	var hash string
-	if len(layers) == 1 {
-		hash = path.Base(layers[0])
-	} else {
-		var ids string
-		for _, layer := range layers {
-			ids += path.Base(layer)
-		}
-		if h, err := future.ComputeId(strings.NewReader(ids)); err != nil {
-			return "", err
-		} else {
-			hash = h
-		}
-	}
-	return name + ":" + hash, nil
-}
-
-func NewImage(name string, layers []string, parent string) (*Image, error) {
-	id, err := generateImageId(name, layers)
-	if err != nil {
-		return nil, err
-	}
-	return &Image{
-		Id:      id,
-		Layers:  layers,
-		Created: time.Now(),
-		Parent:  parent,
-	}, nil
-}