From e5f8ab6160401fb541121da5b5cbc3af4fce28b7 Mon Sep 17 00:00:00 2001 From: Solomon Hykes Date: Sun, 27 Oct 2013 19:20:00 -0700 Subject: [PATCH] Engine: 'create' creates a container and prints its ID on stdout --- api.go | 31 ++++----- api_test.go | 28 ++++---- engine/engine.go | 2 +- engine/job.go | 165 +++++++++++++++++++++++++++++++++++++++++++---- runtime_test.go | 58 ++++++----------- server.go | 35 ++++++---- server_test.go | 64 +++++++----------- utils_test.go | 16 +++++ 8 files changed, 260 insertions(+), 139 deletions(-) diff --git a/api.go b/api.go index 18251eba2f..1fc74d764a 100644 --- a/api.go +++ b/api.go @@ -526,43 +526,36 @@ func postContainersCreate(srv *Server, version float64, w http.ResponseWriter, r if err := parseForm(r); err != nil { return nil } - config := &Config{} out := &APIRun{} - name := r.Form.Get("name") - - if err := json.NewDecoder(r.Body).Decode(config); err != nil { + job := srv.Eng.Job("create", r.Form.Get("name")) + if err := job.DecodeEnv(r.Body); err != nil { return err } - resolvConf, err := utils.GetResolvConf() if err != nil { return err } - - if !config.NetworkDisabled && len(config.Dns) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) { + if !job.GetenvBool("NetworkDisabled") && len(job.Getenv("Dns")) == 0 && len(srv.runtime.config.Dns) == 0 && utils.CheckLocalDns(resolvConf) { out.Warnings = append(out.Warnings, fmt.Sprintf("Docker detected local DNS server on resolv.conf. Using default external servers: %v", defaultDns)) - config.Dns = defaultDns + job.SetenvList("Dns", defaultDns) } - - id, warnings, err := srv.ContainerCreate(config, name) - if err != nil { + // Read container ID from the first line of stdout + job.StdoutParseString(&out.ID) + // Read warnings from stderr + job.StderrParseLines(&out.Warnings, 0) + if err := job.Run(); err != nil { return err } - out.ID = id - for _, warning := range warnings { - out.Warnings = append(out.Warnings, warning) - } - - if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit { + if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.MemoryLimit { log.Println("WARNING: Your kernel does not support memory limit capabilities. Limitation discarded.") out.Warnings = append(out.Warnings, "Your kernel does not support memory limit capabilities. Limitation discarded.") } - if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit { + if job.GetenvInt("Memory") > 0 && !srv.runtime.capabilities.SwapLimit { log.Println("WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.") out.Warnings = append(out.Warnings, "Your kernel does not support memory swap capabilities. Limitation discarded.") } - if !config.NetworkDisabled && srv.runtime.capabilities.IPv4ForwardingDisabled { + if !job.GetenvBool("NetworkDisabled") && srv.runtime.capabilities.IPv4ForwardingDisabled { log.Println("Warning: IPv4 forwarding is disabled.") out.Warnings = append(out.Warnings, "IPv4 forwarding is disabled.") } diff --git a/api_test.go b/api_test.go index 50a86e3f23..7b0dfaa077 100644 --- a/api_test.go +++ b/api_test.go @@ -634,11 +634,11 @@ func TestPostCommit(t *testing.T) { } func TestPostContainersCreate(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) - srv := &Server{runtime: runtime} - configJSON, err := json.Marshal(&Config{ Image: GetTestImage(runtime).ID, Memory: 33554432, @@ -786,22 +786,18 @@ func TestPostContainersStart(t *testing.T) { runtime := srv.runtime defer nuke(runtime) - container, _, err := runtime.Create( + id := createTestContainer( + eng, &Config{ Image: GetTestImage(runtime).ID, Cmd: []string{"/bin/cat"}, OpenStdin: true, }, - "", - ) - if err != nil { - t.Fatal(err) - } - defer runtime.Destroy(container) + t) hostConfigJSON, err := json.Marshal(&HostConfig{}) - req, err := http.NewRequest("POST", "/containers/"+container.ID+"/start", bytes.NewReader(hostConfigJSON)) + req, err := http.NewRequest("POST", "/containers/"+id+"/start", bytes.NewReader(hostConfigJSON)) if err != nil { t.Fatal(err) } @@ -809,22 +805,26 @@ func TestPostContainersStart(t *testing.T) { req.Header.Set("Content-Type", "application/json") r := httptest.NewRecorder() - if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err != nil { + if err := postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err != nil { t.Fatal(err) } if r.Code != http.StatusNoContent { t.Fatalf("%d NO CONTENT expected, received %d\n", http.StatusNoContent, r.Code) } + container := runtime.Get(id) + if container == nil { + t.Fatalf("Container %s was not created", id) + } // Give some time to the process to start + // FIXME: use Wait once it's available as a job container.WaitTimeout(500 * time.Millisecond) - if !container.State.Running { t.Errorf("Container should be running") } r = httptest.NewRecorder() - if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": container.ID}); err == nil { + if err = postContainersStart(srv, APIVERSION, r, req, map[string]string{"name": id}); err == nil { t.Fatalf("A running container should be able to be started") } diff --git a/engine/engine.go b/engine/engine.go index 565c6ed4fa..428ef706c9 100644 --- a/engine/engine.go +++ b/engine/engine.go @@ -115,5 +115,5 @@ func (eng *Engine) Job(name string, args ...string) *Job { func (eng *Engine) Logf(format string, args ...interface{}) (n int, err error) { prefixedFormat := fmt.Sprintf("[%s] %s\n", eng, strings.TrimRight(format, "\n")) - return fmt.Printf(prefixedFormat, args...) + return fmt.Fprintf(os.Stderr, prefixedFormat, args...) } diff --git a/engine/job.go b/engine/job.go index b6296eb91d..ece8d8f8d6 100644 --- a/engine/job.go +++ b/engine/job.go @@ -1,11 +1,16 @@ package engine import ( + "bufio" "bytes" "io" + "io/ioutil" + "strconv" "strings" "fmt" + "sync" "encoding/json" + "os" ) // A job is the fundamental unit of work in the docker engine. @@ -26,20 +31,38 @@ type Job struct { Name string Args []string env []string - Stdin io.ReadCloser - Stdout io.WriteCloser - Stderr io.WriteCloser + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer handler func(*Job) string status string + onExit []func() } // Run executes the job and blocks until the job completes. // If the job returns a failure status, an error is returned // which includes the status. func (job *Job) Run() error { - job.Logf("{") defer func() { - job.Logf("}") + var wg sync.WaitGroup + for _, f := range job.onExit { + wg.Add(1) + go func(f func()) { + f() + wg.Done() + }(f) + } + wg.Wait() + }() + if job.Stdout != nil && job.Stdout != os.Stdout { + job.Stdout = io.MultiWriter(job.Stdout, os.Stdout) + } + if job.Stderr != nil && job.Stderr != os.Stderr { + job.Stderr = io.MultiWriter(job.Stderr, os.Stderr) + } + job.Eng.Logf("+job %s", job.CallString()) + defer func() { + job.Eng.Logf("-job %s%s", job.CallString(), job.StatusString()) }() if job.handler == nil { job.status = "command not found" @@ -52,9 +75,66 @@ func (job *Job) Run() error { return nil } -// String returns a human-readable description of `job` -func (job *Job) String() string { - s := fmt.Sprintf("%s.%s(%s)", job.Eng, job.Name, strings.Join(job.Args, ", ")) +func (job *Job) StdoutParseLines(dst *[]string, limit int) { + job.parseLines(job.StdoutPipe(), dst, limit) +} + +func (job *Job) StderrParseLines(dst *[]string, limit int) { + job.parseLines(job.StderrPipe(), dst, limit) +} + +func (job *Job) parseLines(src io.Reader, dst *[]string, limit int) { + var wg sync.WaitGroup + wg.Add(1) + go func() { + defer wg.Done() + scanner := bufio.NewScanner(src) + for scanner.Scan() { + // If the limit is reached, flush the rest of the source and return + if limit > 0 && len(*dst) >= limit { + io.Copy(ioutil.Discard, src) + return + } + line := scanner.Text() + // Append the line (with delimitor removed) + *dst = append(*dst, line) + } + }() + job.onExit = append(job.onExit, wg.Wait) +} + +func (job *Job) StdoutParseString(dst *string) { + lines := make([]string, 0, 1) + job.StdoutParseLines(&lines, 1) + job.onExit = append(job.onExit, func() { if len(lines) >= 1 { *dst = lines[0] }}) +} + +func (job *Job) StderrParseString(dst *string) { + lines := make([]string, 0, 1) + job.StderrParseLines(&lines, 1) + job.onExit = append(job.onExit, func() { *dst = lines[0]; }) +} + +func (job *Job) StdoutPipe() io.ReadCloser { + r, w := io.Pipe() + job.Stdout = w + job.onExit = append(job.onExit, func(){ w.Close() }) + return r +} + +func (job *Job) StderrPipe() io.ReadCloser { + r, w := io.Pipe() + job.Stderr = w + job.onExit = append(job.onExit, func(){ w.Close() }) + return r +} + + +func (job *Job) CallString() string { + return fmt.Sprintf("%s(%s)", job.Name, strings.Join(job.Args, ", ")) +} + +func (job *Job) StatusString() string { // FIXME: if a job returns the empty string, it will be printed // as not having returned. // (this only affects String which is a convenience function). @@ -65,9 +145,14 @@ func (job *Job) String() string { } else { okerr = "ERR" } - s = fmt.Sprintf("%s = %s (%s)", s, okerr, job.status) + return fmt.Sprintf(" = %s (%s)", okerr, job.status) } - return s + return "" +} + +// String returns a human-readable description of `job` +func (job *Job) String() string { + return fmt.Sprintf("%s.%s%s", job.Eng, job.CallString(), job.StatusString()) } func (job *Job) Getenv(key string) (value string) { @@ -104,6 +189,19 @@ func (job *Job) SetenvBool(key string, value bool) { } } +func (job *Job) GetenvInt(key string) int64 { + s := strings.Trim(job.Getenv(key), " \t") + val, err := strconv.ParseInt(s, 10, 64) + if err != nil { + return -1 + } + return val +} + +func (job *Job) SetenvInt(key string, value int64) { + job.Setenv(key, fmt.Sprintf("%d", value)) +} + func (job *Job) GetenvList(key string) []string { sval := job.Getenv(key) l := make([]string, 0, 1) @@ -137,13 +235,21 @@ func (job *Job) DecodeEnv(src io.Reader) error { return err } for k, v := range m { - if sval, ok := v.(string); ok { + // FIXME: we fix-convert float values to int, because + // encoding/json decodes integers to float64, but cannot encode them back. + // (See http://golang.org/src/pkg/encoding/json/decode.go#L46) + if fval, ok := v.(float64); ok { + job.Logf("Converted to float: %v->%v", v, fval) + job.SetenvInt(k, int64(fval)) + } else if sval, ok := v.(string); ok { + job.Logf("Converted to string: %v->%v", v, sval) job.Setenv(k, sval) } else if val, err := json.Marshal(v); err == nil { job.Setenv(k, string(val)) } else { job.Setenv(k, fmt.Sprintf("%v", v)) } + job.Logf("Decoded %s=%#v to %s=%#v", k, v, k, job.Getenv(k)) } return nil } @@ -153,10 +259,17 @@ func (job *Job) EncodeEnv(dst io.Writer) error { for k, v := range job.Environ() { var val interface{} if err := json.Unmarshal([]byte(v), &val); err == nil { + // FIXME: we fix-convert float values to int, because + // encoding/json decodes integers to float64, but cannot encode them back. + // (See http://golang.org/src/pkg/encoding/json/decode.go#L46) + if fval, isFloat := val.(float64); isFloat { + val = int(fval) + } m[k] = val } else { m[k] = v } + job.Logf("Encoded %s=%#v to %s=%#v", k, v, k, m[k]) } if err := json.NewEncoder(dst).Encode(&m); err != nil { return err @@ -165,21 +278,38 @@ func (job *Job) EncodeEnv(dst io.Writer) error { } func (job *Job) ExportEnv(dst interface{}) (err error) { + fmt.Fprintf(os.Stderr, "ExportEnv()\n") + defer func() { + if err != nil { + err = fmt.Errorf("ExportEnv %s", err) + } + }() var buf bytes.Buffer + job.Logf("ExportEnv: step 1: encode/marshal the env to an intermediary json representation") + fmt.Fprintf(os.Stderr, "Printed ExportEnv step 1\n") if err := job.EncodeEnv(&buf); err != nil { return err } + job.Logf("ExportEnv: step 1 complete: json=|%s|", buf) + job.Logf("ExportEnv: step 2: decode/unmarshal the intermediary json into the destination object") if err := json.NewDecoder(&buf).Decode(dst); err != nil { return err } + job.Logf("ExportEnv: step 2 complete") return nil } -func (job *Job) ImportEnv(src interface{}) error { +func (job *Job) ImportEnv(src interface{}) (err error) { + defer func() { + if err != nil { + err = fmt.Errorf("ImportEnv: %s", err) + } + }() var buf bytes.Buffer if err := json.NewEncoder(&buf).Encode(src); err != nil { return err } + job.Logf("ImportEnv: json=|%s|", buf) if err := job.DecodeEnv(&buf); err != nil { return err } @@ -197,5 +327,14 @@ func (job *Job) Environ() map[string]string { func (job *Job) Logf(format string, args ...interface{}) (n int, err error) { prefixedFormat := fmt.Sprintf("[%s] %s\n", job, strings.TrimRight(format, "\n")) - return fmt.Fprintf(job.Stdout, prefixedFormat, args...) + return fmt.Fprintf(job.Stderr, prefixedFormat, args...) +} + +func (job *Job) Printf(format string, args ...interface{}) (n int, err error) { + return fmt.Fprintf(job.Stdout, format, args...) +} + +func (job *Job) Errorf(format string, args ...interface{}) (n int, err error) { + return fmt.Fprintf(job.Stderr, format, args...) + } diff --git a/runtime_test.go b/runtime_test.go index 946a8ebf61..ce69465961 100644 --- a/runtime_test.go +++ b/runtime_test.go @@ -645,20 +645,17 @@ func TestReloadContainerLinks(t *testing.T) { } func TestDefaultContainerName(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) - srv := &Server{runtime: runtime} config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil) if err != nil { t.Fatal(err) } - shortId, _, err := srv.ContainerCreate(config, "some_name") - if err != nil { - t.Fatal(err) - } - container := runtime.Get(shortId) + container := runtime.Get(createNamedTestContainer(eng, config, t, "some_name")) containerID := container.ID if container.Name != "/some_name" { @@ -682,20 +679,17 @@ func TestDefaultContainerName(t *testing.T) { } func TestRandomContainerName(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) - srv := &Server{runtime: runtime} config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil) if err != nil { t.Fatal(err) } - shortId, _, err := srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } - container := runtime.Get(shortId) + container := runtime.Get(createTestContainer(eng, config, t)) containerID := container.ID if container.Name == "" { @@ -719,20 +713,17 @@ func TestRandomContainerName(t *testing.T) { } func TestLinkChildContainer(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) - srv := &Server{runtime: runtime} config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil) if err != nil { t.Fatal(err) } - shortId, _, err := srv.ContainerCreate(config, "/webapp") - if err != nil { - t.Fatal(err) - } - container := runtime.Get(shortId) + container := runtime.Get(createNamedTestContainer(eng, config, t, "/webapp")) webapp, err := runtime.GetByName("/webapp") if err != nil { @@ -748,12 +739,7 @@ func TestLinkChildContainer(t *testing.T) { t.Fatal(err) } - shortId, _, err = srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } - - childContainer := runtime.Get(shortId) + childContainer := runtime.Get(createTestContainer(eng, config, t)) if err := runtime.RegisterLink(webapp, childContainer, "db"); err != nil { t.Fatal(err) @@ -770,20 +756,17 @@ func TestLinkChildContainer(t *testing.T) { } func TestGetAllChildren(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) - srv := &Server{runtime: runtime} config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil) if err != nil { t.Fatal(err) } - shortId, _, err := srv.ContainerCreate(config, "/webapp") - if err != nil { - t.Fatal(err) - } - container := runtime.Get(shortId) + container := runtime.Get(createNamedTestContainer(eng, config, t, "/webapp")) webapp, err := runtime.GetByName("/webapp") if err != nil { @@ -799,12 +782,7 @@ func TestGetAllChildren(t *testing.T) { t.Fatal(err) } - shortId, _, err = srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } - - childContainer := runtime.Get(shortId) + childContainer := runtime.Get(createTestContainer(eng, config, t)) if err := runtime.RegisterLink(webapp, childContainer, "db"); err != nil { t.Fatal(err) diff --git a/server.go b/server.go index 0a1270bede..6196df8981 100644 --- a/server.go +++ b/server.go @@ -62,6 +62,9 @@ func jobInitApi(job *engine.Job) string { os.Exit(0) }() job.Eng.Hack_SetGlobalVar("httpapi.server", srv) + if err := job.Eng.Register("create", srv.ContainerCreate); err != nil { + return err.Error() + } if err := job.Eng.Register("start", srv.ContainerStart); err != nil { return err.Error() } @@ -1009,33 +1012,43 @@ func (srv *Server) ImageImport(src, repo, tag string, in io.Reader, out io.Write return nil } -func (srv *Server) ContainerCreate(config *Config, name string) (string, []string, error) { - if config.Memory != 0 && config.Memory < 524288 { - return "", nil, fmt.Errorf("Memory limit must be given in bytes (minimum 524288 bytes)") +func (srv *Server) ContainerCreate(job *engine.Job) string { + var name string + if len(job.Args) == 1 { + name = job.Args[0] + } else if len(job.Args) > 1 { + return fmt.Sprintf("Usage: %s ", job.Name) + } + var config Config + if err := job.ExportEnv(&config); err != nil { + return err.Error() + } + if config.Memory != 0 && config.Memory < 524288 { + return "Memory limit must be given in bytes (minimum 524288 bytes)" } - if config.Memory > 0 && !srv.runtime.capabilities.MemoryLimit { config.Memory = 0 } - if config.Memory > 0 && !srv.runtime.capabilities.SwapLimit { config.MemorySwap = -1 } - container, buildWarnings, err := srv.runtime.Create(config, name) + container, buildWarnings, err := srv.runtime.Create(&config, name) if err != nil { if srv.runtime.graph.IsNotExist(err) { - _, tag := utils.ParseRepositoryTag(config.Image) if tag == "" { tag = DEFAULTTAG } - - return "", nil, fmt.Errorf("No such image: %s (tag: %s)", config.Image, tag) + return fmt.Sprintf("No such image: %s (tag: %s)", config.Image, tag) } - return "", nil, err + return err.Error() } srv.LogEvent("create", container.ShortID(), srv.runtime.repositories.ImageName(container.Image)) - return container.ShortID(), buildWarnings, nil + job.Printf("%s\n", container.ShortID()) + for _, warning := range buildWarnings { + job.Errorf("%s\n", warning) + } + return "0" } func (srv *Server) ContainerRestart(name string, t int) error { diff --git a/server_test.go b/server_test.go index a4bfb0155f..111043eca2 100644 --- a/server_test.go +++ b/server_test.go @@ -79,20 +79,17 @@ func TestContainerTagImageDelete(t *testing.T) { } func TestCreateRm(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) - srv := &Server{runtime: runtime} - config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "echo test"}, nil) if err != nil { t.Fatal(err) } - id, _, err := srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } + id := createTestContainer(eng, config, t) if len(runtime.List()) != 1 { t.Errorf("Expected 1 container, %v found", len(runtime.List())) @@ -120,10 +117,7 @@ func TestCreateRmVolumes(t *testing.T) { t.Fatal(err) } - id, _, err := srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } + id := createTestContainer(eng, config, t) if len(runtime.List()) != 1 { t.Errorf("Expected 1 container, %v found", len(runtime.List())) @@ -152,20 +146,17 @@ func TestCreateRmVolumes(t *testing.T) { } func TestCommit(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) - srv := &Server{runtime: runtime} - config, _, _, err := ParseRun([]string{GetTestImage(runtime).ID, "/bin/cat"}, nil) if err != nil { t.Fatal(err) } - id, _, err := srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } + id := createTestContainer(eng, config, t) if _, err := srv.ContainerCommit(id, "testrepo", "testtag", "", "", config); err != nil { t.Fatal(err) @@ -183,10 +174,7 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) { t.Fatal(err) } - id, _, err := srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } + id := createTestContainer(eng, config, t) if len(runtime.List()) != 1 { t.Errorf("Expected 1 container, %v found", len(runtime.List())) @@ -232,22 +220,22 @@ func TestCreateStartRestartStopStartKillRm(t *testing.T) { } func TestRunWithTooLowMemoryLimit(t *testing.T) { - runtime := mkRuntime(t) + eng := NewTestEngine(t) + srv := mkServerFromEngine(eng, t) + runtime := srv.runtime defer nuke(runtime) // Try to create a container with a memory limit of 1 byte less than the minimum allowed limit. - if _, _, err := (*Server).ContainerCreate(&Server{runtime: runtime}, - &Config{ - Image: GetTestImage(runtime).ID, - Memory: 524287, - CpuShares: 1000, - Cmd: []string{"/bin/cat"}, - }, - "", - ); err == nil { + job := eng.Job("create") + job.Setenv("Image", GetTestImage(runtime).ID) + job.Setenv("Memory", "524287") + job.Setenv("CpuShares", "1000") + job.SetenvList("Cmd", []string{"/bin/cat"}) + var id string + job.StdoutParseString(&id) + if err := job.Run(); err == nil { t.Errorf("Memory limit is smaller than the allowed limit. Container creation should've failed!") } - } func TestContainerTop(t *testing.T) { @@ -411,10 +399,7 @@ func TestRmi(t *testing.T) { t.Fatal(err) } - containerID, _, err := srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } + containerID := createTestContainer(eng, config, t) //To remove job := eng.Job("start", containerID) @@ -435,10 +420,7 @@ func TestRmi(t *testing.T) { t.Fatal(err) } - containerID, _, err = srv.ContainerCreate(config, "") - if err != nil { - t.Fatal(err) - } + containerID = createTestContainer(eng, config, t) //To remove job = eng.Job("start", containerID) diff --git a/utils_test.go b/utils_test.go index 529af127e5..2e8c0ceb1b 100644 --- a/utils_test.go +++ b/utils_test.go @@ -38,6 +38,22 @@ func mkRuntime(f utils.Fataler) *Runtime { return r } +func createNamedTestContainer(eng *engine.Engine, config *Config, f utils.Fataler, name string) (shortId string) { + job := eng.Job("create", name) + if err := job.ImportEnv(config); err != nil { + f.Fatal(err) + } + job.StdoutParseString(&shortId) + if err := job.Run(); err != nil { + f.Fatal(err) + } + return +} + +func createTestContainer(eng *engine.Engine, config *Config, f utils.Fataler) (shortId string) { + return createNamedTestContainer(eng, config, f, "") +} + func mkServerFromEngine(eng *engine.Engine, t utils.Fataler) *Server { iSrv := eng.Hack_GetGlobalVar("httpapi.server") if iSrv == nil {