@@ -1005,20 +1005,18 @@ func postContainersWait(eng *engine.Engine, version version.Version, w http.Resp

 	if vars == nil {

 		return fmt.Errorf("Missing parameter")

 	}

-	var (

-		stdoutBuffer = bytes.NewBuffer(nil)

-		job          = eng.Job("wait", vars["name"])

-	)

-	job.Stdout.Add(stdoutBuffer)

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

-		return err

-	}

-	statusCode, err := strconv.Atoi(engine.Tail(stdoutBuffer, 1))

+

+	name := vars["name"]

+	d := getDaemon(eng)

+	cont, err := d.Get(name)

 	if err != nil {

 		return err

 	}

+

+	status, _ := cont.WaitStop(-1 * time.Second)

+

 	return writeJSON(w, http.StatusOK, &types.ContainerWaitResponse{

-		StatusCode: statusCode,

+		StatusCode: status,

 	})

 }

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

 		"restart":           daemon.ContainerRestart,

 		"start":             daemon.ContainerStart,

 		"stop":              daemon.ContainerStop,

-		"wait":              daemon.ContainerWait,

 		"execCreate":        daemon.ContainerExecCreate,

 		"execStart":         daemon.ContainerExecStart,

 		"execInspect":       daemon.ContainerExecInspect,

deleted file mode 100644

@@ -1,22 +0,0 @@

-package daemon

-

-import (

-	"fmt"

-	"time"

-

-	"github.com/docker/docker/engine"

-)

-

-func (daemon *Daemon) ContainerWait(job *engine.Job) error {

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

-		return fmt.Errorf("Usage: %s", job.Name)

-	}

-	name := job.Args[0]

-	container, err := daemon.Get(name)

-	if err != nil {

-		return fmt.Errorf("%s: %v", job.Name, err)

-	}

-	status, _ := container.WaitStop(-1 * time.Second)

-	job.Printf("%d\n", status)

-	return nil

-}

@@ -896,3 +896,44 @@ func TestDaemonwithwrongkey(t *testing.T) {

 	os.Remove("/etc/docker/key.json")

 	logDone("daemon - it should be failed to start daemon with wrong key")

 }

+

+func TestDaemonRestartKillWait(t *testing.T) {

+	d := NewDaemon(t)

+	if err := d.StartWithBusybox(); err != nil {

+		t.Fatalf("Could not start daemon with busybox: %v", err)

+	}

+	defer d.Stop()

+

+	out, err := d.Cmd("run", "-d", "busybox", "/bin/cat")

+	if err != nil {

+		t.Fatalf("Could not run /bin/cat: err=%v\n%s", err, out)

+	}

+	containerID := strings.TrimSpace(out)

+

+	if out, err := d.Cmd("kill", containerID); err != nil {

+		t.Fatalf("Could not kill %s: err=%v\n%s", containerID, err, out)

+	}

+

+	if err := d.Restart(); err != nil {

+		t.Fatalf("Could not restart daemon: %v", err)

+	}

+

+	errchan := make(chan error)

+	go func() {

+		if out, err := d.Cmd("wait", containerID); err != nil {

+			errchan <- fmt.Errorf("%v:\n%s", err, out)

+		}

+		close(errchan)

+	}()

+

+	select {

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

+		t.Fatal("Waiting on a stopped (killed) container timed out")

+	case err := <-errchan:

+		if err != nil {

+			t.Fatal(err)

+		}

+	}

+

+	logDone("wait - wait on a stopped container doesn't timeout")

+}

@@ -3,10 +3,8 @@ package docker

 import (

 	"bytes"

 	"testing"

-	"time"

 	"github.com/docker/docker/builder"

-	"github.com/docker/docker/daemon"

 	"github.com/docker/docker/engine"

 )

@@ -103,60 +101,6 @@ func TestMergeConfigOnCommit(t *testing.T) {

 	}

 }

-func TestRestartKillWait(t *testing.T) {

-	eng := NewTestEngine(t)

-	runtime := mkDaemonFromEngine(eng, t)

-	defer runtime.Nuke()

-

-	config, hostConfig, _, err := parseRun([]string{"-i", unitTestImageID, "/bin/cat"})

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	id := createTestContainer(eng, config, t)

-

-	containers, err := runtime.Containers(&daemon.ContainersConfig{All: true})

-

-	if err != nil {

-		t.Errorf("Error getting containers1: %q", err)

-	}

-

-	if len(containers) != 1 {

-		t.Errorf("Expected 1 container, %v found", len(containers))

-	}

-

-	job := eng.Job("start", id)

-	if err := job.ImportEnv(hostConfig); err != nil {

-		t.Fatal(err)

-	}

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

-		t.Fatal(err)

-	}

-

-	if err := runtime.ContainerKill(id, 0); err != nil {

-		t.Fatal(err)

-	}

-

-	eng = newTestEngine(t, false, runtime.Config().Root)

-	runtime = mkDaemonFromEngine(eng, t)

-

-	containers, err = runtime.Containers(&daemon.ContainersConfig{All: true})

-

-	if err != nil {

-		t.Errorf("Error getting containers1: %q", err)

-	}

-	if len(containers) != 1 {

-		t.Errorf("Expected 1 container, %v found", len(containers))

-	}

-

-	setTimeout(t, "Waiting on stopped container timedout", 5*time.Second, func() {

-		job = eng.Job("wait", containers[0].ID)

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

-			t.Fatal(err)

-		}

-	})

-}

-

 func TestRunWithTooLowMemoryLimit(t *testing.T) {

 	eng := NewTestEngine(t)

 	defer mkDaemonFromEngine(eng, t).Nuke()