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

 	"github.com/docker/docker/daemon/networkdriver/bridge"

 	"github.com/docker/docker/dockerversion"

 	"github.com/docker/docker/engine"

+	"github.com/docker/docker/events"

 	"github.com/docker/docker/pkg/parsers/kernel"

 	"github.com/docker/docker/registry"

 	"github.com/docker/docker/server"

@@ -20,6 +21,9 @@ func Register(eng *engine.Engine) error {

 	if err := remote(eng); err != nil {

 		return err

 	}

+	if err := events.New().Install(eng); err != nil {

+		return err

+	}

 	if err := eng.Register("version", dockerVersion); err != nil {

 		return err

 	}

@@ -168,6 +168,13 @@ func (container *Container) WriteHostConfig() error {

 	return ioutil.WriteFile(pth, data, 0666)

 }

+func (container *Container) LogEvent(action string) {

+	d := container.daemon

+	if err := d.eng.Job("log", action, container.ID, d.Repositories().ImageName(container.Image)).Run(); err != nil {

+		utils.Errorf("Error running container: %s", err)

+	}

+}

+

 func (container *Container) getResourcePath(path string) (string, error) {

 	cleanPath := filepath.Join("/", path)

 	return symlink.FollowSymlinkInScope(filepath.Join(container.basefs, cleanPath), container.basefs)

@@ -508,7 +515,7 @@ func (container *Container) monitor(callback execdriver.StartCallback) error {

 		container.stdin, container.stdinPipe = io.Pipe()

 	}

 	if container.daemon != nil && container.daemon.srv != nil {

-		container.daemon.srv.LogEvent("die", container.ID, container.daemon.repositories.ImageName(container.Image))

+		container.LogEvent("die")

 	}

 	if container.daemon != nil && container.daemon.srv != nil && container.daemon.srv.IsRunning() {

 		// FIXME: here is race condition between two RUN instructions in Dockerfile

@@ -40,7 +40,7 @@ func (daemon *Daemon) ContainerCreate(job *engine.Job) engine.Status {

 	if !container.Config.NetworkDisabled && daemon.SystemConfig().IPv4ForwardingDisabled {

 		job.Errorf("IPv4 forwarding is disabled.\n")

 	}

-	job.Eng.Job("log", "create", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+	container.LogEvent("create")

 	// FIXME: this is necessary because daemon.Create might return a nil container

 	// with a non-nil error. This should not happen! Once it's fixed we

 	// can remove this workaround.

@@ -107,6 +107,7 @@ type Daemon struct {

 func (daemon *Daemon) Install(eng *engine.Engine) error {

 	// FIXME: rename "delete" to "rm" for consistency with the CLI command

 	// FIXME: rename ContainerDestroy to ContainerRm for consistency with the CLI command

+	// FIXME: remove ImageDelete's dependency on Daemon, then move to graph/

 	for name, method := range map[string]engine.Handler{

 		"attach":            daemon.ContainerAttach,

 		"commit":            daemon.ContainerCommit,

@@ -127,6 +128,7 @@ func (daemon *Daemon) Install(eng *engine.Engine) error {

 		"top":               daemon.ContainerTop,

 		"unpause":           daemon.ContainerUnpause,

 		"wait":              daemon.ContainerWait,

+		"image_delete":      daemon.ImageDelete, // FIXME: see above

 	} {

 		if err := eng.Register(name, method); err != nil {

 			return err

@@ -70,7 +70,7 @@ func (daemon *Daemon) ContainerDestroy(job *engine.Job) engine.Status {

 		if err := daemon.Destroy(container); err != nil {

 			return job.Errorf("Cannot destroy container %s: %s", name, err)

 		}

-		job.Eng.Job("log", "destroy", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+		container.LogEvent("destroy")

 		if removeVolume {

 			var (

@@ -23,7 +23,7 @@ func (daemon *Daemon) ContainerExport(job *engine.Job) engine.Status {

 			return job.Errorf("%s: %s", name, err)

 		}

 		// FIXME: factor job-specific LogEvent to engine.Job.Run()

-		job.Eng.Job("log", "export", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+		container.LogEvent("export")

 		return engine.StatusOK

 	}

 	return job.Errorf("No such container: %s", name)

new file mode 100644

@@ -0,0 +1,156 @@

+package daemon

+

+import (

+	"fmt"

+	"strings"

+

+	"github.com/docker/docker/engine"

+	"github.com/docker/docker/graph"

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

+	"github.com/docker/docker/pkg/parsers"

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

+)

+

+func (daemon *Daemon) ImageDelete(job *engine.Job) engine.Status {

+	if n := len(job.Args); n != 1 {

+		return job.Errorf("Usage: %s IMAGE", job.Name)

+	}

+	imgs := engine.NewTable("", 0)

+	if err := daemon.DeleteImage(job.Eng, job.Args[0], imgs, true, job.GetenvBool("force"), job.GetenvBool("noprune")); err != nil {

+		return job.Error(err)

+	}

+	if len(imgs.Data) == 0 {

+		return job.Errorf("Conflict, %s wasn't deleted", job.Args[0])

+	}

+	if _, err := imgs.WriteListTo(job.Stdout); err != nil {

+		return job.Error(err)

+	}

+	return engine.StatusOK

+}

+

+// FIXME: make this private and use the job instead

+func (daemon *Daemon) DeleteImage(eng *engine.Engine, name string, imgs *engine.Table, first, force, noprune bool) error {

+	var (

+		repoName, tag string

+		tags          = []string{}

+		tagDeleted    bool

+	)

+

+	// FIXME: please respect DRY and centralize repo+tag parsing in a single central place! -- shykes

+	repoName, tag = parsers.ParseRepositoryTag(name)

+	if tag == "" {

+		tag = graph.DEFAULTTAG

+	}

+

+	img, err := daemon.Repositories().LookupImage(name)

+	if err != nil {

+		if r, _ := daemon.Repositories().Get(repoName); r != nil {

+			return fmt.Errorf("No such image: %s:%s", repoName, tag)

+		}

+		return fmt.Errorf("No such image: %s", name)

+	}

+

+	if strings.Contains(img.ID, name) {

+		repoName = ""

+		tag = ""

+	}

+

+	byParents, err := daemon.Graph().ByParent()

+	if err != nil {

+		return err

+	}

+

+	//If delete by id, see if the id belong only to one repository

+	if repoName == "" {

+		for _, repoAndTag := range daemon.Repositories().ByID()[img.ID] {

+			parsedRepo, parsedTag := parsers.ParseRepositoryTag(repoAndTag)

+			if repoName == "" || repoName == parsedRepo {

+				repoName = parsedRepo

+				if parsedTag != "" {

+					tags = append(tags, parsedTag)

+				}

+			} else if repoName != parsedRepo && !force {

+				// the id belongs to multiple repos, like base:latest and user:test,

+				// in that case return conflict

+				return fmt.Errorf("Conflict, cannot delete image %s because it is tagged in multiple repositories, use -f to force", name)

+			}

+		}

+	} else {

+		tags = append(tags, tag)

+	}

+

+	if !first && len(tags) > 0 {

+		return nil

+	}

+

+	//Untag the current image

+	for _, tag := range tags {

+		tagDeleted, err = daemon.Repositories().Delete(repoName, tag)

+		if err != nil {

+			return err

+		}

+		if tagDeleted {

+			out := &engine.Env{}

+			out.Set("Untagged", repoName+":"+tag)

+			imgs.Add(out)

+			eng.Job("log", "untag", img.ID, "").Run()

+		}

+	}

+	tags = daemon.Repositories().ByID()[img.ID]

+	if (len(tags) <= 1 && repoName == "") || len(tags) == 0 {

+		if len(byParents[img.ID]) == 0 {

+			if err := daemon.canDeleteImage(img.ID, force, tagDeleted); err != nil {

+				return err

+			}

+			if err := daemon.Repositories().DeleteAll(img.ID); err != nil {

+				return err

+			}

+			if err := daemon.Graph().Delete(img.ID); err != nil {

+				return err

+			}

+			out := &engine.Env{}

+			out.Set("Deleted", img.ID)

+			imgs.Add(out)

+			eng.Job("log", "delete", img.ID, "").Run()

+			if img.Parent != "" && !noprune {

+				err := daemon.DeleteImage(eng, img.Parent, imgs, false, force, noprune)

+				if first {

+					return err

+				}

+

+			}

+

+		}

+	}

+	return nil

+}

+

+func (daemon *Daemon) canDeleteImage(imgID string, force, untagged bool) error {

+	var message string

+	if untagged {

+		message = " (docker untagged the image)"

+	}

+	for _, container := range daemon.List() {

+		parent, err := daemon.Repositories().LookupImage(container.Image)

+		if err != nil {

+			return err

+		}

+

+		if err := parent.WalkHistory(func(p *image.Image) error {

+			if imgID == p.ID {

+				if container.State.IsRunning() {

+					if force {

+						return fmt.Errorf("Conflict, cannot force delete %s because the running container %s is using it%s, stop it and retry", utils.TruncateID(imgID), utils.TruncateID(container.ID), message)

+					}

+					return fmt.Errorf("Conflict, cannot delete %s because the running container %s is using it%s, stop it and use -f to force", utils.TruncateID(imgID), utils.TruncateID(container.ID), message)

+				} else if !force {

+					return fmt.Errorf("Conflict, cannot delete %s because the container %s is using it%s, use -f to force", utils.TruncateID(imgID), utils.TruncateID(container.ID), message)

+				}

+			}

+			return nil

+		}); err != nil {

+			return err

+		}

+	}

+	return nil

+}

@@ -44,7 +44,7 @@ func (daemon *Daemon) ContainerKill(job *engine.Job) engine.Status {

 			if err := container.Kill(); err != nil {

 				return job.Errorf("Cannot kill container %s: %s", name, err)

 			}

-			job.Eng.Job("log", "kill", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+			container.LogEvent("kill")

 		} else {

 			// Otherwise, just send the requested signal

 			if err := container.KillSig(int(sig)); err != nil {

@@ -16,7 +16,7 @@ func (daemon *Daemon) ContainerPause(job *engine.Job) engine.Status {

 	if err := container.Pause(); err != nil {

 		return job.Errorf("Cannot pause container %s: %s", name, err)

 	}

-	job.Eng.Job("log", "pause", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+	container.LogEvent("pause")

 	return engine.StatusOK

 }

@@ -32,6 +32,6 @@ func (daemon *Daemon) ContainerUnpause(job *engine.Job) engine.Status {

 	if err := container.Unpause(); err != nil {

 		return job.Errorf("Cannot unpause container %s: %s", name, err)

 	}

-	job.Eng.Job("log", "unpause", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+	container.LogEvent("unpause")

 	return engine.StatusOK

 }

@@ -19,7 +19,7 @@ func (daemon *Daemon) ContainerRestart(job *engine.Job) engine.Status {

 		if err := container.Restart(int(t)); err != nil {

 			return job.Errorf("Cannot restart container %s: %s\n", name, err)

 		}

-		job.Eng.Job("log", "restart", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+		container.LogEvent("restart")

 	} else {

 		return job.Errorf("No such container: %s\n", name)

 	}

@@ -1,10 +1,5 @@

 package daemon

-import (

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

-)

-

 type Server interface {

-	LogEvent(action, id, from string) *utils.JSONMessage

 	IsRunning() bool // returns true if the server is currently in operation

 }

@@ -36,8 +36,7 @@ func (daemon *Daemon) ContainerStart(job *engine.Job) engine.Status {

 	if err := container.Start(); err != nil {

 		return job.Errorf("Cannot start container %s: %s", name, err)

 	}

-	job.Eng.Job("log", "start", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

-

+	container.LogEvent("start")

 	return engine.StatusOK

 }

@@ -22,7 +22,7 @@ func (daemon *Daemon) ContainerStop(job *engine.Job) engine.Status {

 		if err := container.Stop(int(t)); err != nil {

 			return job.Errorf("Cannot stop container %s: %s\n", name, err)

 		}

-		job.Eng.Job("log", "stop", container.ID, daemon.Repositories().ImageName(container.Image)).Run()

+		container.LogEvent("stop")

 	} else {

 		return job.Errorf("No such container: %s\n", name)

 	}

new file mode 100644

@@ -0,0 +1,176 @@

+package events

+

+import (

+	"encoding/json"

+	"sync"

+	"time"

+

+	"github.com/docker/docker/engine"

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

+)

+

+const eventsLimit = 64

+

+type listener chan<- *utils.JSONMessage

+

+type Events struct {

+	mu          sync.RWMutex

+	events      []*utils.JSONMessage

+	subscribers []listener

+}

+

+func New() *Events {

+	return &Events{

+		events: make([]*utils.JSONMessage, 0, eventsLimit),

+	}

+}

+

+// Install installs events public api in docker engine

+func (e *Events) Install(eng *engine.Engine) error {

+	// Here you should describe public interface

+	jobs := map[string]engine.Handler{

+		"events":            e.Get,

+		"log":               e.Log,

+		"subscribers_count": e.SubscribersCount,

+	}

+	for name, job := range jobs {

+		if err := eng.Register(name, job); err != nil {

+			return err

+		}

+	}

+	return nil

+}

+

+func (e *Events) Get(job *engine.Job) engine.Status {

+	var (

+		since   = job.GetenvInt64("since")

+		until   = job.GetenvInt64("until")

+		timeout = time.NewTimer(time.Unix(until, 0).Sub(time.Now()))

+	)

+

+	// If no until, disable timeout

+	if until == 0 {

+		timeout.Stop()

+	}

+

+	listener := make(chan *utils.JSONMessage)

+	e.subscribe(listener)

+	defer e.unsubscribe(listener)

+

+	job.Stdout.Write(nil)

+

+	// Resend every event in the [since, until] time interval.

+	if since != 0 {

+		if err := e.writeCurrent(job, since, until); err != nil {

+			return job.Error(err)

+		}

+	}

+

+	for {

+		select {

+		case event, ok := <-listener:

+			if !ok {

+				return engine.StatusOK

+			}

+			if err := writeEvent(job, event); err != nil {

+				return job.Error(err)

+			}

+		case <-timeout.C:

+			return engine.StatusOK

+		}

+	}

+}

+

+func (e *Events) Log(job *engine.Job) engine.Status {

+	if len(job.Args) != 3 {

+		return job.Errorf("usage: %s ACTION ID FROM", job.Name)

+	}

+	// not waiting for receivers

+	go e.log(job.Args[0], job.Args[1], job.Args[2])

+	return engine.StatusOK

+}

+

+func (e *Events) SubscribersCount(job *engine.Job) engine.Status {

+	ret := &engine.Env{}

+	ret.SetInt("count", e.subscribersCount())

+	ret.WriteTo(job.Stdout)

+	return engine.StatusOK

+}

+

+func writeEvent(job *engine.Job, event *utils.JSONMessage) error {

+	// When sending an event JSON serialization errors are ignored, but all

+	// other errors lead to the eviction of the listener.

+	if b, err := json.Marshal(event); err == nil {

+		if _, err = job.Stdout.Write(b); err != nil {

+			return err

+		}

+	}

+	return nil

+}

+

+func (e *Events) writeCurrent(job *engine.Job, since, until int64) error {

+	e.mu.RLock()

+	for _, event := range e.events {

+		if event.Time >= since && (event.Time <= until || until == 0) {

+			if err := writeEvent(job, event); err != nil {

+				e.mu.RUnlock()

+				return err

+			}

+		}

+	}

+	e.mu.RUnlock()

+	return nil

+}

+

+func (e *Events) subscribersCount() int {

+	e.mu.RLock()

+	c := len(e.subscribers)

+	e.mu.RUnlock()

+	return c

+}

+

+func (e *Events) log(action, id, from string) {

+	e.mu.Lock()

+	now := time.Now().UTC().Unix()

+	jm := &utils.JSONMessage{Status: action, ID: id, From: from, Time: now}

+	if len(e.events) == cap(e.events) {

+		// discard oldest event

+		copy(e.events, e.events[1:])

+		e.events[len(e.events)-1] = jm

+	} else {

+		e.events = append(e.events, jm)

+	}

+	for _, s := range e.subscribers {

+		// We give each subscriber a 100ms time window to receive the event,

+		// after which we move to the next.

+		select {

+		case s <- jm:

+		case <-time.After(100 * time.Millisecond):

+		}

+	}

+	e.mu.Unlock()

+}

+

+func (e *Events) subscribe(l listener) {

+	e.mu.Lock()

+	e.subscribers = append(e.subscribers, l)

+	e.mu.Unlock()

+}

+

+// unsubscribe closes and removes the specified listener from the list of

+// previously registed ones.

+// It returns a boolean value indicating if the listener was successfully

+// found, closed and unregistered.

+func (e *Events) unsubscribe(l listener) bool {

+	e.mu.Lock()

+	for i, subscriber := range e.subscribers {

+		if subscriber == l {

+			close(l)

+			e.subscribers = append(e.subscribers[:i], e.subscribers[i+1:]...)

+			e.mu.Unlock()

+			return true

+		}

+	}

+	e.mu.Unlock()

+	return false

+}

new file mode 100644

@@ -0,0 +1,154 @@

+package events

+

+import (

+	"bytes"

+	"encoding/json"

+	"fmt"

+	"io"

+	"testing"

+	"time"

+

+	"github.com/docker/docker/engine"

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

+)

+

+func TestEventsPublish(t *testing.T) {

+	e := New()

+	l1 := make(chan *utils.JSONMessage)

+	l2 := make(chan *utils.JSONMessage)

+	e.subscribe(l1)

+	e.subscribe(l2)

+	count := e.subscribersCount()

+	if count != 2 {

+		t.Fatalf("Must be 2 subscribers, got %d", count)

+	}

+	go e.log("test", "cont", "image")

+	select {

+	case msg := <-l1:

+		if len(e.events) != 1 {

+			t.Fatalf("Must be only one event, got %d", len(e.events))

+		}

+		if msg.Status != "test" {

+			t.Fatalf("Status should be test, got %s", msg.Status)

+		}

+		if msg.ID != "cont" {

+			t.Fatalf("ID should be cont, got %s", msg.ID)

+		}

+		if msg.From != "image" {

+			t.Fatalf("From should be image, got %s", msg.From)

+		}

+	case <-time.After(1 * time.Second):

+		t.Fatal("Timeout waiting for broadcasted message")

+	}

+	select {

+	case msg := <-l2:

+		if len(e.events) != 1 {

+			t.Fatalf("Must be only one event, got %d", len(e.events))

+		}

+		if msg.Status != "test" {

+			t.Fatalf("Status should be test, got %s", msg.Status)

+		}

+		if msg.ID != "cont" {

+			t.Fatalf("ID should be cont, got %s", msg.ID)

+		}

+		if msg.From != "image" {

+			t.Fatalf("From should be image, got %s", msg.From)

+		}

+	case <-time.After(1 * time.Second):

+		t.Fatal("Timeout waiting for broadcasted message")

+	}

+}

+

+func TestEventsPublishTimeout(t *testing.T) {

+	e := New()

+	l := make(chan *utils.JSONMessage)

+	e.subscribe(l)

+

+	c := make(chan struct{})

+	go func() {

+		e.log("test", "cont", "image")

+		close(c)

+	}()

+

+	select {

+	case <-c:

+	case <-time.After(time.Second):

+		t.Fatal("Timeout publishing message")

+	}

+}

+

+func TestLogEvents(t *testing.T) {

+	e := New()

+	eng := engine.New()

+	if err := e.Install(eng); err != nil {

+		t.Fatal(err)

+	}

+

+	for i := 0; i < eventsLimit+16; i++ {

+		action := fmt.Sprintf("action_%d", i)

+		id := fmt.Sprintf("cont_%d", i)

+		from := fmt.Sprintf("image_%d", i)

+		job := eng.Job("log", action, id, from)

+		if err := job.Run(); err != nil {

+			t.Fatal(err)

+		}

+	}

+	time.Sleep(50 * time.Millisecond)

+	if len(e.events) != eventsLimit {

+		t.Fatalf("Must be %d events, got %d", eventsLimit, len(e.events))

+	}

+

+	job := eng.Job("events")

+	job.SetenvInt64("since", 1)

+	job.SetenvInt64("until", time.Now().Unix())

+	buf := bytes.NewBuffer(nil)

+	job.Stdout.Add(buf)

+	if err := job.Run(); err != nil {

+		t.Fatal(err)

+	}

+	buf = bytes.NewBuffer(buf.Bytes())

+	dec := json.NewDecoder(buf)

+	var msgs []utils.JSONMessage

+	for {

+		var jm utils.JSONMessage

+		if err := dec.Decode(&jm); err != nil {

+			if err == io.EOF {

+				break

+			}

+			t.Fatal(err)

+		}

+		msgs = append(msgs, jm)

+	}

+	if len(msgs) != eventsLimit {

+		t.Fatalf("Must be %d events, got %d", eventsLimit, len(msgs))

+	}

+	first := msgs[0]

+	if first.Status != "action_16" {

+		t.Fatalf("First action is %s, must be action_15", first.Status)

+	}

+	last := msgs[len(msgs)-1]

+	if last.Status != "action_79" {

+		t.Fatalf("First action is %s, must be action_79", first.Status)

+	}

+}

+

+func TestEventsCountJob(t *testing.T) {

+	e := New()

+	eng := engine.New()

+	if err := e.Install(eng); err != nil {

+		t.Fatal(err)

+	}

+	l1 := make(chan *utils.JSONMessage)

+	l2 := make(chan *utils.JSONMessage)

+	e.subscribe(l1)

+	e.subscribe(l2)

+	job := eng.Job("subscribers_count")

+	env, _ := job.Stdout.AddEnv()

+	if err := job.Run(); err != nil {

+		t.Fatal(err)

+	}

+	count := env.GetInt("count")

+	if count != 2 {

+		t.Fatalf("There must be 2 subscribers, got %d", count)

+	}

+}

new file mode 100644

@@ -0,0 +1,147 @@

+package graph

+

+import (

+	"encoding/json"

+	"io"

+	"io/ioutil"

+	"os"

+	"path"

+

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

+	"github.com/docker/docker/engine"

+	"github.com/docker/docker/pkg/parsers"

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

+)

+

+// CmdImageExport exports all images with the given tag. All versions

+// containing the same tag are exported. The resulting output is an

+// uncompressed tar ball.

+// name is the set of tags to export.

+// out is the writer where the images are written to.

+func (s *TagStore) CmdImageExport(job *engine.Job) engine.Status {

+	if len(job.Args) != 1 {

+		return job.Errorf("Usage: %s IMAGE\n", job.Name)

+	}

+	name := job.Args[0]

+	// get image json

+	tempdir, err := ioutil.TempDir("", "docker-export-")

+	if err != nil {

+		return job.Error(err)

+	}

+	defer os.RemoveAll(tempdir)

+

+	utils.Debugf("Serializing %s", name)

+

+	rootRepoMap := map[string]Repository{}

+	rootRepo, err := s.Get(name)

+	if err != nil {

+		return job.Error(err)

+	}

+	if rootRepo != nil {

+		// this is a base repo name, like 'busybox'

+

+		for _, id := range rootRepo {

+			if err := s.exportImage(job.Eng, id, tempdir); err != nil {

+				return job.Error(err)

+			}

+		}

+		rootRepoMap[name] = rootRepo

+	} else {

+		img, err := s.LookupImage(name)

+		if err != nil {

+			return job.Error(err)

+		}

+		if img != nil {

+			// This is a named image like 'busybox:latest'

+			repoName, repoTag := parsers.ParseRepositoryTag(name)

+			if err := s.exportImage(job.Eng, img.ID, tempdir); err != nil {

+				return job.Error(err)

+			}

+			// check this length, because a lookup of a truncated has will not have a tag

+			// and will not need to be added to this map

+			if len(repoTag) > 0 {

+				rootRepoMap[repoName] = Repository{repoTag: img.ID}

+			}

+		} else {

+			// this must be an ID that didn't get looked up just right?

+			if err := s.exportImage(job.Eng, name, tempdir); err != nil {

+				return job.Error(err)

+			}

+		}

+	}

+	// write repositories, if there is something to write

+	if len(rootRepoMap) > 0 {

+		rootRepoJson, _ := json.Marshal(rootRepoMap)

+

+		if err := ioutil.WriteFile(path.Join(tempdir, "repositories"), rootRepoJson, os.FileMode(0644)); err != nil {

+			return job.Error(err)

+		}

+	} else {

+		utils.Debugf("There were no repositories to write")

+	}

+

+	fs, err := archive.Tar(tempdir, archive.Uncompressed)

+	if err != nil {

+		return job.Error(err)

+	}

+	defer fs.Close()

+

+	if _, err := io.Copy(job.Stdout, fs); err != nil {

+		return job.Error(err)

+	}

+	utils.Debugf("End Serializing %s", name)

+	return engine.StatusOK

+}

+

+// FIXME: this should be a top-level function, not a class method

+func (s *TagStore) exportImage(eng *engine.Engine, name, tempdir string) error {

+	for n := name; n != ""; {

+		// temporary directory

+		tmpImageDir := path.Join(tempdir, n)

+		if err := os.Mkdir(tmpImageDir, os.FileMode(0755)); err != nil {

+			if os.IsExist(err) {

+				return nil

+			}

+			return err

+		}

+

+		var version = "1.0"

+		var versionBuf = []byte(version)

+

+		if err := ioutil.WriteFile(path.Join(tmpImageDir, "VERSION"), versionBuf, os.FileMode(0644)); err != nil {

+			return err

+		}

+

+		// serialize json

+		json, err := os.Create(path.Join(tmpImageDir, "json"))

+		if err != nil {

+			return err

+		}

+		job := eng.Job("image_inspect", n)

+		job.SetenvBool("raw", true)

+		job.Stdout.Add(json)

+		if err := job.Run(); err != nil {

+			return err

+		}

+

+		// serialize filesystem

+		fsTar, err := os.Create(path.Join(tmpImageDir, "layer.tar"))

+		if err != nil {

+			return err

+		}

+		job = eng.Job("image_tarlayer", n)

+		job.Stdout.Add(fsTar)

+		if err := job.Run(); err != nil {

+			return err

+		}

+

+		// find parent

+		job = eng.Job("image_get", n)

+		info, _ := job.Stdout.AddEnv()

+		if err := job.Run(); err != nil {

+			return err

+		}

+		n = info.Get("Parent")

+	}

+	return nil

+}

new file mode 100644

@@ -0,0 +1,46 @@

+package graph

+

+import (

+	"strings"

+

+	"github.com/docker/docker/engine"

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

+)

+

+func (s *TagStore) CmdHistory(job *engine.Job) engine.Status {

+	if n := len(job.Args); n != 1 {

+		return job.Errorf("Usage: %s IMAGE", job.Name)

+	}

+	name := job.Args[0]

+	foundImage, err := s.LookupImage(name)

+	if err != nil {

+		return job.Error(err)

+	}

+

+	lookupMap := make(map[string][]string)

+	for name, repository := range s.Repositories {

+		for tag, id := range repository {

+			// If the ID already has a reverse lookup, do not update it unless for "latest"

+			if _, exists := lookupMap[id]; !exists {

+				lookupMap[id] = []string{}

+			}

+			lookupMap[id] = append(lookupMap[id], name+":"+tag)

+		}

+	}

+

+	outs := engine.NewTable("Created", 0)

+	err = foundImage.WalkHistory(func(img *image.Image) error {

+		out := &engine.Env{}

+		out.Set("Id", img.ID)

+		out.SetInt64("Created", img.Created.Unix())

+		out.Set("CreatedBy", strings.Join(img.ContainerConfig.Cmd, " "))

+		out.SetList("Tags", lookupMap[img.ID])

+		out.SetInt64("Size", img.Size)

+		outs.Add(out)

+		return nil

+	})

+	if _, err := outs.WriteListTo(job.Stdout); err != nil {

+		return job.Error(err)

+	}

+	return engine.StatusOK

+}

new file mode 100644

@@ -0,0 +1,61 @@

+package graph

+

+import (

+	"net/http"

+	"net/url"

+

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

+	"github.com/docker/docker/engine"

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

+)

+

+func (s *TagStore) CmdImport(job *engine.Job) engine.Status {