@@ -8,6 +8,7 @@ import (

 	"github.com/dotcloud/docker/engine"

 	"github.com/dotcloud/docker/execdriver"

 	"github.com/dotcloud/docker/graphdriver"

+	"github.com/dotcloud/docker/image"

 	"github.com/dotcloud/docker/links"

 	"github.com/dotcloud/docker/nat"

 	"github.com/dotcloud/docker/runconfig"

@@ -992,7 +993,7 @@ func (container *Container) Changes() ([]archive.Change, error) {

 	return container.runtime.Changes(container)

 }

-func (container *Container) GetImage() (*Image, error) {

+func (container *Container) GetImage() (*image.Image, error) {

 	if container.runtime == nil {

 		return nil, fmt.Errorf("Can't get image of unregistered container")

 	}

@@ -5,6 +5,7 @@ import (

 	"github.com/dotcloud/docker/archive"

 	"github.com/dotcloud/docker/dockerversion"

 	"github.com/dotcloud/docker/graphdriver"

+	"github.com/dotcloud/docker/image"

 	"github.com/dotcloud/docker/runconfig"

 	"github.com/dotcloud/docker/utils"

 	"io"

@@ -79,20 +80,20 @@ func (graph *Graph) Exists(id string) bool {

 }

 // Get returns the image with the given id, or an error if the image doesn't exist.

-func (graph *Graph) Get(name string) (*Image, error) {

+func (graph *Graph) Get(name string) (*image.Image, error) {

 	id, err := graph.idIndex.Get(name)

 	if err != nil {

 		return nil, err

 	}

 	// FIXME: return nil when the image doesn't exist, instead of an error

-	img, err := LoadImage(graph.imageRoot(id))

+	img, err := image.LoadImage(graph.ImageRoot(id))

 	if err != nil {

 		return nil, err

 	}

 	if img.ID != id {

 		return nil, fmt.Errorf("Image stored at '%s' has wrong id '%s'", id, img.ID)

 	}

-	img.graph = graph

+	img.SetGraph(graph)

 	if img.Size < 0 {

 		rootfs, err := graph.driver.Get(img.ID)

@@ -119,7 +120,7 @@ func (graph *Graph) Get(name string) (*Image, error) {

 		}

 		img.Size = size

-		if err := img.SaveSize(graph.imageRoot(id)); err != nil {

+		if err := img.SaveSize(graph.ImageRoot(id)); err != nil {

 			return nil, err

 		}

 	}

@@ -127,9 +128,9 @@ func (graph *Graph) Get(name string) (*Image, error) {

 }

 // Create creates a new image and registers it in the graph.

-func (graph *Graph) Create(layerData archive.ArchiveReader, container *Container, comment, author string, config *runconfig.Config) (*Image, error) {

-	img := &Image{

-		ID:            GenerateID(),

+func (graph *Graph) Create(layerData archive.ArchiveReader, container *Container, comment, author string, config *runconfig.Config) (*image.Image, error) {

+	img := &image.Image{

+		ID:            utils.GenerateRandomID(),

 		Comment:       comment,

 		Created:       time.Now().UTC(),

 		DockerVersion: dockerversion.VERSION,

@@ -151,7 +152,7 @@ func (graph *Graph) Create(layerData archive.ArchiveReader, container *Container

 // Register imports a pre-existing image into the graph.

 // FIXME: pass img as first argument

-func (graph *Graph) Register(jsonData []byte, layerData archive.ArchiveReader, img *Image) (err error) {

+func (graph *Graph) Register(jsonData []byte, layerData archive.ArchiveReader, img *image.Image) (err error) {

 	defer func() {

 		// If any error occurs, remove the new dir from the driver.

 		// Don't check for errors since the dir might not have been created.

@@ -160,7 +161,7 @@ func (graph *Graph) Register(jsonData []byte, layerData archive.ArchiveReader, i

 			graph.driver.Remove(img.ID)

 		}

 	}()

-	if err := ValidateID(img.ID); err != nil {

+	if err := utils.ValidateID(img.ID); err != nil {

 		return err

 	}

 	// (This is a convenience to save time. Race conditions are taken care of by os.Rename)

@@ -171,7 +172,7 @@ func (graph *Graph) Register(jsonData []byte, layerData archive.ArchiveReader, i

 	// Ensure that the image root does not exist on the filesystem

 	// when it is not registered in the graph.

 	// This is common when you switch from one graph driver to another

-	if err := os.RemoveAll(graph.imageRoot(img.ID)); err != nil && !os.IsNotExist(err) {

+	if err := os.RemoveAll(graph.ImageRoot(img.ID)); err != nil && !os.IsNotExist(err) {

 		return err

 	}

@@ -197,12 +198,12 @@ func (graph *Graph) Register(jsonData []byte, layerData archive.ArchiveReader, i

 		return fmt.Errorf("Driver %s failed to get image rootfs %s: %s", graph.driver, img.ID, err)

 	}

 	defer graph.driver.Put(img.ID)

-	img.graph = graph

-	if err := StoreImage(img, jsonData, layerData, tmp, rootfs); err != nil {

+	img.SetGraph(graph)

+	if err := image.StoreImage(img, jsonData, layerData, tmp, rootfs); err != nil {

 		return err

 	}

 	// Commit

-	if err := os.Rename(tmp, graph.imageRoot(img.ID)); err != nil {

+	if err := os.Rename(tmp, graph.ImageRoot(img.ID)); err != nil {

 		return err

 	}

 	graph.idIndex.Add(img.ID)

@@ -233,7 +234,7 @@ func (graph *Graph) TempLayerArchive(id string, compression archive.Compression,

 // Mktemp creates a temporary sub-directory inside the graph's filesystem.

 func (graph *Graph) Mktemp(id string) (string, error) {

-	dir := path.Join(graph.Root, "_tmp", GenerateID())

+	dir := path.Join(graph.Root, "_tmp", utils.GenerateRandomID())

 	if err := os.MkdirAll(dir, 0700); err != nil {

 		return "", err

 	}

@@ -320,7 +321,7 @@ func (graph *Graph) Delete(name string) error {

 		return err

 	}

 	graph.idIndex.Delete(id)

-	err = os.Rename(graph.imageRoot(id), tmp)

+	err = os.Rename(graph.ImageRoot(id), tmp)

 	if err != nil {

 		return err

 	}

@@ -331,9 +332,9 @@ func (graph *Graph) Delete(name string) error {

 }

 // Map returns a list of all images in the graph, addressable by ID.

-func (graph *Graph) Map() (map[string]*Image, error) {

-	images := make(map[string]*Image)

-	err := graph.walkAll(func(image *Image) {

+func (graph *Graph) Map() (map[string]*image.Image, error) {

+	images := make(map[string]*image.Image)

+	err := graph.walkAll(func(image *image.Image) {

 		images[image.ID] = image

 	})

 	if err != nil {

@@ -344,7 +345,7 @@ func (graph *Graph) Map() (map[string]*Image, error) {

 // walkAll iterates over each image in the graph, and passes it to a handler.

 // The walking order is undetermined.

-func (graph *Graph) walkAll(handler func(*Image)) error {

+func (graph *Graph) walkAll(handler func(*image.Image)) error {

 	files, err := ioutil.ReadDir(graph.Root)

 	if err != nil {

 		return err

@@ -364,17 +365,17 @@ func (graph *Graph) walkAll(handler func(*Image)) error {

 // If an image of id ID has 3 children images, then the value for key ID

 // will be a list of 3 images.

 // If an image has no children, it will not have an entry in the table.

-func (graph *Graph) ByParent() (map[string][]*Image, error) {

-	byParent := make(map[string][]*Image)

-	err := graph.walkAll(func(image *Image) {

-		parent, err := graph.Get(image.Parent)

+func (graph *Graph) ByParent() (map[string][]*image.Image, error) {

+	byParent := make(map[string][]*image.Image)

+	err := graph.walkAll(func(img *image.Image) {

+		parent, err := graph.Get(img.Parent)

 		if err != nil {

 			return

 		}

 		if children, exists := byParent[parent.ID]; exists {

-			byParent[parent.ID] = append(children, image)

+			byParent[parent.ID] = append(children, img)

 		} else {

-			byParent[parent.ID] = []*Image{image}

+			byParent[parent.ID] = []*image.Image{img}

 		}

 	})

 	return byParent, err

@@ -382,13 +383,13 @@ func (graph *Graph) ByParent() (map[string][]*Image, error) {

 // Heads returns all heads in the graph, keyed by id.

 // A head is an image which is not the parent of another image in the graph.

-func (graph *Graph) Heads() (map[string]*Image, error) {

-	heads := make(map[string]*Image)

+func (graph *Graph) Heads() (map[string]*image.Image, error) {

+	heads := make(map[string]*image.Image)

 	byParent, err := graph.ByParent()

 	if err != nil {

 		return nil, err

 	}

-	err = graph.walkAll(func(image *Image) {

+	err = graph.walkAll(func(image *image.Image) {

 		// If it's not in the byParent lookup table, then

 		// it's not a parent -> so it's a head!

 		if _, exists := byParent[image.ID]; !exists {

@@ -398,7 +399,7 @@ func (graph *Graph) Heads() (map[string]*Image, error) {

 	return heads, err

 }

-func (graph *Graph) imageRoot(id string) string {

+func (graph *Graph) ImageRoot(id string) string {

 	return path.Join(graph.Root, id)

 }

deleted file mode 100644

@@ -1,318 +0,0 @@

-package docker

-

-import (

-	"crypto/rand"

-	"encoding/hex"

-	"encoding/json"

-	"fmt"

-	"github.com/dotcloud/docker/archive"

-	"github.com/dotcloud/docker/graphdriver"

-	"github.com/dotcloud/docker/runconfig"

-	"github.com/dotcloud/docker/utils"

-	"io"

-	"io/ioutil"

-	"os"

-	"path"

-	"strconv"

-	"strings"

-	"time"

-)

-

-type Image struct {

-	ID              string            `json:"id"`

-	Parent          string            `json:"parent,omitempty"`

-	Comment         string            `json:"comment,omitempty"`

-	Created         time.Time         `json:"created"`

-	Container       string            `json:"container,omitempty"`

-	ContainerConfig runconfig.Config  `json:"container_config,omitempty"`

-	DockerVersion   string            `json:"docker_version,omitempty"`

-	Author          string            `json:"author,omitempty"`

-	Config          *runconfig.Config `json:"config,omitempty"`

-	Architecture    string            `json:"architecture,omitempty"`

-	OS              string            `json:"os,omitempty"`

-	graph           *Graph

-	Size            int64

-}

-

-func LoadImage(root string) (*Image, error) {

-	// Load the json data

-	jsonData, err := ioutil.ReadFile(jsonPath(root))

-	if err != nil {

-		return nil, err

-	}

-	img := &Image{}

-

-	if err := json.Unmarshal(jsonData, img); err != nil {

-		return nil, err

-	}

-	if err := ValidateID(img.ID); err != nil {

-		return nil, err

-	}

-

-	if buf, err := ioutil.ReadFile(path.Join(root, "layersize")); err != nil {

-		if !os.IsNotExist(err) {

-			return nil, err

-		}

-		// If the layersize file does not exist then set the size to a negative number

-		// because a layer size of 0 (zero) is valid

-		img.Size = -1

-	} else {

-		size, err := strconv.Atoi(string(buf))

-		if err != nil {

-			return nil, err

-		}

-		img.Size = int64(size)

-	}

-

-	return img, nil

-}

-

-func StoreImage(img *Image, jsonData []byte, layerData archive.ArchiveReader, root, layer string) error {

-	// Store the layer

-	var (

-		size   int64

-		err    error

-		driver = img.graph.driver

-	)

-	if err := os.MkdirAll(layer, 0755); err != nil {

-		return err

-	}

-

-	// If layerData is not nil, unpack it into the new layer

-	if layerData != nil {

-		if differ, ok := driver.(graphdriver.Differ); ok {

-			if err := differ.ApplyDiff(img.ID, layerData); err != nil {

-				return err

-			}

-

-			if size, err = differ.DiffSize(img.ID); err != nil {

-				return err

-			}

-		} else {

-			start := time.Now().UTC()

-			utils.Debugf("Start untar layer")

-			if err := archive.ApplyLayer(layer, layerData); err != nil {

-				return err

-			}

-			utils.Debugf("Untar time: %vs", time.Now().UTC().Sub(start).Seconds())

-

-			if img.Parent == "" {

-				if size, err = utils.TreeSize(layer); err != nil {

-					return err

-				}

-			} else {

-				parent, err := driver.Get(img.Parent)

-				if err != nil {

-					return err

-				}

-				defer driver.Put(img.Parent)

-				changes, err := archive.ChangesDirs(layer, parent)

-				if err != nil {

-					return err

-				}

-				size = archive.ChangesSize(layer, changes)

-			}

-		}

-	}

-

-	img.Size = size

-	if err := img.SaveSize(root); err != nil {

-		return err

-	}

-

-	// If raw json is provided, then use it

-	if jsonData != nil {

-		if err := ioutil.WriteFile(jsonPath(root), jsonData, 0600); err != nil {

-			return err

-		}

-	} else {

-		if jsonData, err = json.Marshal(img); err != nil {

-			return err

-		}

-		if err := ioutil.WriteFile(jsonPath(root), jsonData, 0600); err != nil {

-			return err

-		}

-	}

-	return nil

-}

-

-// SaveSize stores the current `size` value of `img` in the directory `root`.

-func (img *Image) SaveSize(root string) error {

-	if err := ioutil.WriteFile(path.Join(root, "layersize"), []byte(strconv.Itoa(int(img.Size))), 0600); err != nil {

-		return fmt.Errorf("Error storing image size in %s/layersize: %s", root, err)

-	}

-	return nil

-}

-

-func jsonPath(root string) string {

-	return path.Join(root, "json")

-}

-

-// TarLayer returns a tar archive of the image's filesystem layer.

-func (img *Image) TarLayer() (arch archive.Archive, err error) {

-	if img.graph == nil {

-		return nil, fmt.Errorf("Can't load storage driver for unregistered image %s", img.ID)

-	}

-	driver := img.graph.driver

-	if differ, ok := driver.(graphdriver.Differ); ok {

-		return differ.Diff(img.ID)

-	}

-

-	imgFs, err := driver.Get(img.ID)

-	if err != nil {

-		return nil, err

-	}

-

-	defer func() {

-		if err != nil {

-			driver.Put(img.ID)

-		}

-	}()

-

-	if img.Parent == "" {

-		archive, err := archive.Tar(imgFs, archive.Uncompressed)

-		if err != nil {

-			return nil, err

-		}

-		return utils.NewReadCloserWrapper(archive, func() error {

-			err := archive.Close()

-			driver.Put(img.ID)

-			return err

-		}), nil

-	}

-

-	parentFs, err := driver.Get(img.Parent)

-	if err != nil {

-		return nil, err

-	}

-	defer driver.Put(img.Parent)

-	changes, err := archive.ChangesDirs(imgFs, parentFs)

-	if err != nil {

-		return nil, err

-	}

-	archive, err := archive.ExportChanges(imgFs, changes)

-	if err != nil {

-		return nil, err

-	}

-	return utils.NewReadCloserWrapper(archive, func() error {

-		err := archive.Close()

-		driver.Put(img.ID)

-		return err

-	}), nil

-}

-

-func ValidateID(id string) error {

-	if id == "" {

-		return fmt.Errorf("Image id can't be empty")

-	}

-	if strings.Contains(id, ":") {

-		return fmt.Errorf("Invalid character in image id: ':'")

-	}

-	return nil

-}

-

-func GenerateID() string {

-	for {

-		id := make([]byte, 32)

-		if _, err := io.ReadFull(rand.Reader, id); err != nil {

-			panic(err) // This shouldn't happen

-		}

-		value := hex.EncodeToString(id)

-		// if we try to parse the truncated for as an int and we don't have

-		// an error then the value is all numberic and causes issues when

-		// used as a hostname. ref #3869

-		if _, err := strconv.Atoi(utils.TruncateID(value)); err == nil {

-			continue

-		}

-		return value

-	}

-}

-

-// Image includes convenience proxy functions to its graph

-// These functions will return an error if the image is not registered

-// (ie. if image.graph == nil)

-func (img *Image) History() ([]*Image, error) {

-	var parents []*Image

-	if err := img.WalkHistory(

-		func(img *Image) error {

-			parents = append(parents, img)

-			return nil

-		},

-	); err != nil {

-		return nil, err

-	}

-	return parents, nil

-}

-

-func (img *Image) WalkHistory(handler func(*Image) error) (err error) {

-	currentImg := img

-	for currentImg != nil {

-		if handler != nil {

-			if err := handler(currentImg); err != nil {

-				return err

-			}

-		}

-		currentImg, err = currentImg.GetParent()

-		if err != nil {

-			return fmt.Errorf("Error while getting parent image: %v", err)

-		}

-	}

-	return nil

-}

-

-func (img *Image) GetParent() (*Image, error) {

-	if img.Parent == "" {

-		return nil, nil

-	}

-	if img.graph == nil {

-		return nil, fmt.Errorf("Can't lookup parent of unregistered image")

-	}

-	return img.graph.Get(img.Parent)

-}

-

-func (img *Image) root() (string, error) {

-	if img.graph == nil {

-		return "", fmt.Errorf("Can't lookup root of unregistered image")

-	}

-	return img.graph.imageRoot(img.ID), nil

-}

-

-func (img *Image) getParentsSize(size int64) int64 {

-	parentImage, err := img.GetParent()

-	if err != nil || parentImage == nil {

-		return size

-	}

-	size += parentImage.Size

-	return parentImage.getParentsSize(size)

-}

-

-// Depth returns the number of parents for a

-// current image

-func (img *Image) Depth() (int, error) {

-	var (

-		count  = 0

-		parent = img

-		err    error

-	)

-

-	for parent != nil {

-		count++

-		parent, err = parent.GetParent()

-		if err != nil {

-			return -1, err

-		}

-	}

-	return count, nil

-}

-

-// Build an Image object from raw json data

-func NewImgJSON(src []byte) (*Image, error) {

-	ret := &Image{}

-

-	utils.Debugf("Json string: {%s}", src)

-	// FIXME: Is there a cleaner way to "purify" the input json?

-	if err := json.Unmarshal(src, ret); err != nil {

-		return nil, err

-	}

-	return ret, nil

-}

new file mode 100644

@@ -0,0 +1,11 @@

+package image

+

+import (

+	"github.com/dotcloud/docker/graphdriver"

+)

+

+type Graph interface {

+	Get(id string) (*Image, error)

+	ImageRoot(id string) string

+	Driver() graphdriver.Driver

+}

new file mode 100644

@@ -0,0 +1,292 @@

+package image

+

+import (

+	"encoding/json"

+	"fmt"

+	"github.com/dotcloud/docker/archive"

+	"github.com/dotcloud/docker/graphdriver"

+	"github.com/dotcloud/docker/runconfig"

+	"github.com/dotcloud/docker/utils"

+	"io/ioutil"

+	"os"

+	"path"

+	"strconv"

+	"time"

+)

+

+type Image struct {

+	ID              string            `json:"id"`

+	Parent          string            `json:"parent,omitempty"`

+	Comment         string            `json:"comment,omitempty"`

+	Created         time.Time         `json:"created"`

+	Container       string            `json:"container,omitempty"`

+	ContainerConfig runconfig.Config  `json:"container_config,omitempty"`

+	DockerVersion   string            `json:"docker_version,omitempty"`

+	Author          string            `json:"author,omitempty"`

+	Config          *runconfig.Config `json:"config,omitempty"`

+	Architecture    string            `json:"architecture,omitempty"`

+	OS              string            `json:"os,omitempty"`

+	Size            int64

+

+	graph Graph

+}

+

+func LoadImage(root string) (*Image, error) {

+	// Load the json data

+	jsonData, err := ioutil.ReadFile(jsonPath(root))

+	if err != nil {

+		return nil, err

+	}

+	img := &Image{}

+

+	if err := json.Unmarshal(jsonData, img); err != nil {

+		return nil, err

+	}

+	if err := utils.ValidateID(img.ID); err != nil {

+		return nil, err

+	}

+

+	if buf, err := ioutil.ReadFile(path.Join(root, "layersize")); err != nil {

+		if !os.IsNotExist(err) {

+			return nil, err

+		}

+		// If the layersize file does not exist then set the size to a negative number

+		// because a layer size of 0 (zero) is valid

+		img.Size = -1

+	} else {

+		size, err := strconv.Atoi(string(buf))

+		if err != nil {

+			return nil, err

+		}

+		img.Size = int64(size)

+	}

+

+	return img, nil

+}

+

+func StoreImage(img *Image, jsonData []byte, layerData archive.ArchiveReader, root, layer string) error {

+	// Store the layer

+	var (

+		size   int64

+		err    error

+		driver = img.graph.Driver()

+	)

+	if err := os.MkdirAll(layer, 0755); err != nil {

+		return err

+	}

+

+	// If layerData is not nil, unpack it into the new layer

+	if layerData != nil {

+		if differ, ok := driver.(graphdriver.Differ); ok {

+			if err := differ.ApplyDiff(img.ID, layerData); err != nil {

+				return err

+			}

+

+			if size, err = differ.DiffSize(img.ID); err != nil {

+				return err

+			}

+		} else {

+			start := time.Now().UTC()

+			utils.Debugf("Start untar layer")

+			if err := archive.ApplyLayer(layer, layerData); err != nil {

+				return err

+			}

+			utils.Debugf("Untar time: %vs", time.Now().UTC().Sub(start).Seconds())

+

+			if img.Parent == "" {

+				if size, err = utils.TreeSize(layer); err != nil {

+					return err

+				}

+			} else {

+				parent, err := driver.Get(img.Parent)

+				if err != nil {

+					return err

+				}

+				defer driver.Put(img.Parent)

+				changes, err := archive.ChangesDirs(layer, parent)

+				if err != nil {

+					return err

+				}

+				size = archive.ChangesSize(layer, changes)

+			}

+		}

+	}

+

+	img.Size = size

+	if err := img.SaveSize(root); err != nil {

+		return err

+	}

+

+	// If raw json is provided, then use it

+	if jsonData != nil {

+		if err := ioutil.WriteFile(jsonPath(root), jsonData, 0600); err != nil {

+			return err

+		}

+	} else {

+		if jsonData, err = json.Marshal(img); err != nil {

+			return err

+		}

+		if err := ioutil.WriteFile(jsonPath(root), jsonData, 0600); err != nil {

+			return err

+		}

+	}

+	return nil

+}

+

+func (img *Image) SetGraph(graph Graph) {

+	img.graph = graph

+}

+

+// SaveSize stores the current `size` value of `img` in the directory `root`.

+func (img *Image) SaveSize(root string) error {

+	if err := ioutil.WriteFile(path.Join(root, "layersize"), []byte(strconv.Itoa(int(img.Size))), 0600); err != nil {

+		return fmt.Errorf("Error storing image size in %s/layersize: %s", root, err)

+	}

+	return nil

+}

+

+func jsonPath(root string) string {

+	return path.Join(root, "json")

+}

+

+// TarLayer returns a tar archive of the image's filesystem layer.

+func (img *Image) TarLayer() (arch archive.Archive, err error) {

+	if img.graph == nil {

+		return nil, fmt.Errorf("Can't load storage driver for unregistered image %s", img.ID)

+	}

+	driver := img.graph.Driver()

+	if differ, ok := driver.(graphdriver.Differ); ok {

+		return differ.Diff(img.ID)

+	}

+

+	imgFs, err := driver.Get(img.ID)

+	if err != nil {

+		return nil, err

+	}

+

+	defer func() {

+		if err != nil {

+			driver.Put(img.ID)

+		}

+	}()

+

+	if img.Parent == "" {

+		archive, err := archive.Tar(imgFs, archive.Uncompressed)

+		if err != nil {

+			return nil, err

+		}

+		return utils.NewReadCloserWrapper(archive, func() error {

+			err := archive.Close()

+			driver.Put(img.ID)

+			return err

+		}), nil

+	}

+

+	parentFs, err := driver.Get(img.Parent)

+	if err != nil {

+		return nil, err

+	}

+	defer driver.Put(img.Parent)

+	changes, err := archive.ChangesDirs(imgFs, parentFs)

+	if err != nil {

+		return nil, err

+	}

+	archive, err := archive.ExportChanges(imgFs, changes)

+	if err != nil {

+		return nil, err

+	}

+	return utils.NewReadCloserWrapper(archive, func() error {

+		err := archive.Close()

+		driver.Put(img.ID)

+		return err

+	}), nil

+}

+

+// Image includes convenience proxy functions to its graph

+// These functions will return an error if the image is not registered

+// (ie. if image.graph == nil)

+func (img *Image) History() ([]*Image, error) {

+	var parents []*Image

+	if err := img.WalkHistory(

+		func(img *Image) error {

+			parents = append(parents, img)

+			return nil

+		},

+	); err != nil {

+		return nil, err

+	}

+	return parents, nil

+}

+

+func (img *Image) WalkHistory(handler func(*Image) error) (err error) {

+	currentImg := img

+	for currentImg != nil {

+		if handler != nil {

+			if err := handler(currentImg); err != nil {

+				return err

+			}

+		}

+		currentImg, err = currentImg.GetParent()

+		if err != nil {

+			return fmt.Errorf("Error while getting parent image: %v", err)

+		}

+	}

+	return nil

+}

+

+func (img *Image) GetParent() (*Image, error) {

+	if img.Parent == "" {

+		return nil, nil

+	}

+	if img.graph == nil {

+		return nil, fmt.Errorf("Can't lookup parent of unregistered image")

+	}

+	return img.graph.Get(img.Parent)

+}

+

+func (img *Image) root() (string, error) {

+	if img.graph == nil {

+		return "", fmt.Errorf("Can't lookup root of unregistered image")

+	}

+	return img.graph.ImageRoot(img.ID), nil

+}

+

+func (img *Image) GetParentsSize(size int64) int64 {

+	parentImage, err := img.GetParent()

+	if err != nil || parentImage == nil {

+		return size

+	}

+	size += parentImage.Size

+	return parentImage.GetParentsSize(size)

+}

+

+// Depth returns the number of parents for a

+// current image

+func (img *Image) Depth() (int, error) {

+	var (

+		count  = 0

+		parent = img

+		err    error

+	)

+

+	for parent != nil {

+		count++

+		parent, err = parent.GetParent()

+		if err != nil {

+			return -1, err

+		}

+	}

+	return count, nil

+}

+

+// Build an Image object from raw json data

+func NewImgJSON(src []byte) (*Image, error) {

+	ret := &Image{}

+

+	utils.Debugf("Json string: {%s}", src)

+	// FIXME: Is there a cleaner way to "purify" the input json?

+	if err := json.Unmarshal(src, ret); err != nil {

+		return nil, err

+	}

+	return ret, nil

+}

@@ -9,6 +9,7 @@ import (

 	"github.com/dotcloud/docker/api"

 	"github.com/dotcloud/docker/dockerversion"

 	"github.com/dotcloud/docker/engine"

+	"github.com/dotcloud/docker/image"

 	"github.com/dotcloud/docker/runconfig"

 	"github.com/dotcloud/docker/utils"

 	"github.com/dotcloud/docker/vendor/src/code.google.com/p/go/src/pkg/archive/tar"

@@ -287,7 +288,7 @@ func TestGetImagesByName(t *testing.T) {

 	}

 	assertHttpNotError(r, t)

-	img := &docker.Image{}

+	img := &image.Image{}

 	if err := json.Unmarshal(r.Body.Bytes(), img); err != nil {

 		t.Fatal(err)

 	}

@@ -5,6 +5,7 @@ import (

 	"github.com/dotcloud/docker"

 	"github.com/dotcloud/docker/archive"

 	"github.com/dotcloud/docker/engine"

+	"github.com/dotcloud/docker/image"

 	"github.com/dotcloud/docker/utils"

 	"io/ioutil"

 	"net"

@@ -350,7 +351,7 @@ func TestBuild(t *testing.T) {

 	}

 }

-func buildImage(context testContextTemplate, t *testing.T, eng *engine.Engine, useCache bool) (*docker.Image, error) {

+func buildImage(context testContextTemplate, t *testing.T, eng *engine.Engine, useCache bool) (*image.Image, error) {

 	if eng == nil {

 		eng = NewTestEngine(t)

 		runtime := mkRuntimeFromEngine(eng, t)

@@ -6,6 +6,7 @@ import (

 	"github.com/dotcloud/docker"

 	"github.com/dotcloud/docker/api"

 	"github.com/dotcloud/docker/engine"

+	"github.com/dotcloud/docker/image"

 	"github.com/dotcloud/docker/pkg/term"

 	"github.com/dotcloud/docker/utils"

 	"io"

@@ -902,7 +903,7 @@ func TestImagesTree(t *testing.T) {

 	})

 }