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

 	"github.com/docker/docker/pkg/streamformatter"

 	"github.com/docker/docker/pkg/version"

 	"github.com/docker/docker/registry"

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

 	"github.com/docker/docker/utils"

 )

@@ -809,30 +810,23 @@ func postContainersCreate(eng *engine.Engine, version version.Version, w http.Re

 		return err

 	}

 	var (

-		job          = eng.Job("create", r.Form.Get("name"))

-		outWarnings  []string

-		stdoutBuffer = bytes.NewBuffer(nil)

-		warnings     = bytes.NewBuffer(nil)

+		warnings []string

+		name     = r.Form.Get("name")

 	)

-	if err := job.DecodeEnv(r.Body); err != nil {

+	config, hostConfig, err := runconfig.DecodeContainerConfig(r.Body)

+	if err != nil {

 		return err

 	}

-	// Read container ID from the first line of stdout

-	job.Stdout.Add(stdoutBuffer)

-	// Read warnings from stderr

-	job.Stderr.Add(warnings)

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

+

+	containerId, warnings, err := getDaemon(eng).ContainerCreate(name, config, hostConfig)

+	if err != nil {

 		return err

 	}

-	// Parse warnings from stderr

-	scanner := bufio.NewScanner(warnings)

-	for scanner.Scan() {

-		outWarnings = append(outWarnings, scanner.Text())

-	}

+

 	return writeJSON(w, http.StatusCreated, &types.ContainerCreateResponse{

-		ID:       engine.Tail(stdoutBuffer, 1),

-		Warnings: outWarnings,

+		ID:       containerId,

+		Warnings: warnings,

 	})

 }

@@ -924,10 +918,6 @@ func postContainersStart(eng *engine.Engine, version version.Version, w http.Res

 	if vars == nil {

 		return fmt.Errorf("Missing parameter")

 	}

-	var (

-		name = vars["name"]

-		job  = eng.Job("start", name)

-	)

 	// If contentLength is -1, we can assumed chunked encoding

 	// or more technically that the length is unknown

@@ -935,17 +925,21 @@ func postContainersStart(eng *engine.Engine, version version.Version, w http.Res

 	// net/http otherwise seems to swallow any headers related to chunked encoding

 	// including r.TransferEncoding

 	// allow a nil body for backwards compatibility

+	var hostConfig *runconfig.HostConfig

 	if r.Body != nil && (r.ContentLength > 0 || r.ContentLength == -1) {

 		if err := checkForJson(r); err != nil {

 			return err

 		}

-		if err := job.DecodeEnv(r.Body); err != nil {

+		c, err := runconfig.DecodeHostConfig(r.Body)

+		if err != nil {

 			return err

 		}

+

+		hostConfig = c

 	}

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

+	if err := getDaemon(eng).ContainerStart(vars["name"], hostConfig); err != nil {

 		if err.Error() == "Container already started" {

 			w.WriteHeader(http.StatusNotModified)

 			return nil

@@ -262,7 +262,7 @@ func run(b *Builder, args []string, attributes map[string]bool, original string)

 	b.Config.Cmd = config.Cmd

 	runconfig.Merge(b.Config, config)

-	defer func(cmd []string) { b.Config.Cmd = cmd }(cmd)

+	defer func(cmd *runconfig.Command) { b.Config.Cmd = cmd }(cmd)

 	logrus.Debugf("[BUILDER] Command to be executed: %v", b.Config.Cmd)

@@ -301,13 +301,15 @@ func run(b *Builder, args []string, attributes map[string]bool, original string)

 // Argument handling is the same as RUN.

 //

 func cmd(b *Builder, args []string, attributes map[string]bool, original string) error {

-	b.Config.Cmd = handleJsonArgs(args, attributes)

+	cmdSlice := handleJsonArgs(args, attributes)

 	if !attributes["json"] {

-		b.Config.Cmd = append([]string{"/bin/sh", "-c"}, b.Config.Cmd...)

+		cmdSlice = append([]string{"/bin/sh", "-c"}, cmdSlice...)

 	}

-	if err := b.commit("", b.Config.Cmd, fmt.Sprintf("CMD %q", b.Config.Cmd)); err != nil {

+	b.Config.Cmd = runconfig.NewCommand(cmdSlice...)

+

+	if err := b.commit("", b.Config.Cmd, fmt.Sprintf("CMD %q", cmdSlice)); err != nil {

 		return err

 	}

@@ -332,13 +334,13 @@ func entrypoint(b *Builder, args []string, attributes map[string]bool, original

 	switch {

 	case attributes["json"]:

 		// ENTRYPOINT ["echo", "hi"]

-		b.Config.Entrypoint = parsed

+		b.Config.Entrypoint = runconfig.NewEntrypoint(parsed...)

 	case len(parsed) == 0:

 		// ENTRYPOINT []

 		b.Config.Entrypoint = nil

 	default:

 		// ENTRYPOINT echo hi

-		b.Config.Entrypoint = []string{"/bin/sh", "-c", parsed[0]}

+		b.Config.Entrypoint = runconfig.NewEntrypoint("/bin/sh", "-c", parsed[0])

 	}

 	// when setting the entrypoint if a CMD was not explicitly set then

@@ -61,7 +61,7 @@ func (b *Builder) readContext(context io.Reader) error {

 	return nil

 }

-func (b *Builder) commit(id string, autoCmd []string, comment string) error {

+func (b *Builder) commit(id string, autoCmd *runconfig.Command, comment string) error {

 	if b.disableCommit {

 		return nil

 	}

@@ -71,8 +71,8 @@ func (b *Builder) commit(id string, autoCmd []string, comment string) error {

 	b.Config.Image = b.image

 	if id == "" {

 		cmd := b.Config.Cmd

-		b.Config.Cmd = []string{"/bin/sh", "-c", "#(nop) " + comment}

-		defer func(cmd []string) { b.Config.Cmd = cmd }(cmd)

+		b.Config.Cmd = runconfig.NewCommand("/bin/sh", "-c", "#(nop) "+comment)

+		defer func(cmd *runconfig.Command) { b.Config.Cmd = cmd }(cmd)

 		hit, err := b.probeCache()

 		if err != nil {

@@ -182,8 +182,8 @@ func (b *Builder) runContextCommand(args []string, allowRemote bool, allowDecomp

 	}

 	cmd := b.Config.Cmd

-	b.Config.Cmd = []string{"/bin/sh", "-c", fmt.Sprintf("#(nop) %s %s in %s", cmdName, srcHash, dest)}

-	defer func(cmd []string) { b.Config.Cmd = cmd }(cmd)

+	b.Config.Cmd = runconfig.NewCommand("/bin/sh", "-c", fmt.Sprintf("#(nop) %s %s in %s", cmdName, srcHash, dest))

+	defer func(cmd *runconfig.Command) { b.Config.Cmd = cmd }(cmd)

 	hit, err := b.probeCache()

 	if err != nil {

@@ -560,12 +560,13 @@ func (b *Builder) create() (*daemon.Container, error) {

 	b.TmpContainers[c.ID] = struct{}{}

 	fmt.Fprintf(b.OutStream, " ---> Running in %s\n", stringid.TruncateID(c.ID))

-	if len(config.Cmd) > 0 {

+	if config.Cmd.Len() > 0 {

 		// override the entry point that may have been picked up from the base image

-		c.Path = config.Cmd[0]

-		c.Args = config.Cmd[1:]

+		s := config.Cmd.Slice()

+		c.Path = s[0]

+		c.Args = s[1:]

 	} else {

-		config.Cmd = []string{}

+		config.Cmd = runconfig.NewCommand()

 	}

 	return c, nil

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

 	"fmt"

 	"strings"

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

 	"github.com/docker/docker/graph"

 	"github.com/docker/docker/image"

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

@@ -12,36 +11,28 @@ import (

 	"github.com/docker/libcontainer/label"

 )

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

-	var name string

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

-		name = job.Args[0]

-	} else if len(job.Args) > 1 {

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

-	}

-

-	config := runconfig.ContainerConfigFromJob(job)

-	hostConfig := runconfig.ContainerHostConfigFromJob(job)

+func (daemon *Daemon) ContainerCreate(name string, config *runconfig.Config, hostConfig *runconfig.HostConfig) (string, []string, error) {

+	var warnings []string

-	if len(hostConfig.LxcConf) > 0 && !strings.Contains(daemon.ExecutionDriver().Name(), "lxc") {

-		return fmt.Errorf("Cannot use --lxc-conf with execdriver: %s", daemon.ExecutionDriver().Name())

+	if hostConfig.LxcConf.Len() > 0 && !strings.Contains(daemon.ExecutionDriver().Name(), "lxc") {

+		return "", warnings, fmt.Errorf("Cannot use --lxc-conf with execdriver: %s", daemon.ExecutionDriver().Name())

 	}

 	if hostConfig.Memory != 0 && hostConfig.Memory < 4194304 {

-		return fmt.Errorf("Minimum memory limit allowed is 4MB")

+		return "", warnings, fmt.Errorf("Minimum memory limit allowed is 4MB")

 	}

 	if hostConfig.Memory > 0 && !daemon.SystemConfig().MemoryLimit {

-		job.Errorf("Your kernel does not support memory limit capabilities. Limitation discarded.\n")

+		warnings = append(warnings, "Your kernel does not support memory limit capabilities. Limitation discarded.\n")

 		hostConfig.Memory = 0

 	}

 	if hostConfig.Memory > 0 && hostConfig.MemorySwap != -1 && !daemon.SystemConfig().SwapLimit {

-		job.Errorf("Your kernel does not support swap limit capabilities. Limitation discarded.\n")

+		warnings = append(warnings, "Your kernel does not support swap limit capabilities. Limitation discarded.\n")

 		hostConfig.MemorySwap = -1

 	}

 	if hostConfig.Memory > 0 && hostConfig.MemorySwap > 0 && hostConfig.MemorySwap < hostConfig.Memory {

-		return fmt.Errorf("Minimum memoryswap limit should be larger than memory limit, see usage.\n")

+		return "", warnings, fmt.Errorf("Minimum memoryswap limit should be larger than memory limit, see usage.\n")

 	}

 	if hostConfig.Memory == 0 && hostConfig.MemorySwap > 0 {

-		return fmt.Errorf("You should always set the Memory limit when using Memoryswap limit, see usage.\n")

+		return "", warnings, fmt.Errorf("You should always set the Memory limit when using Memoryswap limit, see usage.\n")

 	}

 	container, buildWarnings, err := daemon.Create(config, hostConfig, name)

@@ -51,22 +42,18 @@ func (daemon *Daemon) ContainerCreate(job *engine.Job) error {

 			if tag == "" {

 				tag = graph.DEFAULTTAG

 			}

-			return fmt.Errorf("No such image: %s (tag: %s)", config.Image, tag)

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

 		}

-		return err

+		return "", warnings, err

 	}

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

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

+		warnings = append(warnings, "IPv4 forwarding is disabled.\n")

 	}

-	container.LogEvent("create")

-	job.Printf("%s\n", container.ID)

-

-	for _, warning := range buildWarnings {

-		job.Errorf("%s\n", warning)

-	}

+	container.LogEvent("create")

+	warnings = append(warnings, buildWarnings...)

-	return nil

+	return container.ID, warnings, nil

 }

 // Create creates a new container from the given configuration with a given name.

@@ -119,10 +119,8 @@ type Daemon struct {

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

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

 		"container_inspect": daemon.ContainerInspect,

-		"create":            daemon.ContainerCreate,

 		"info":              daemon.CmdInfo,

 		"restart":           daemon.ContainerRestart,

-		"start":             daemon.ContainerStart,

 		"execCreate":        daemon.ContainerExecCreate,

 		"execStart":         daemon.ContainerExecStart,

 	} {

@@ -483,7 +481,7 @@ func (daemon *Daemon) mergeAndVerifyConfig(config *runconfig.Config, img *image.

 			return nil, err

 		}

 	}

-	if len(config.Entrypoint) == 0 && len(config.Cmd) == 0 {

+	if config.Entrypoint.Len() == 0 && config.Cmd.Len() == 0 {

 		return nil, fmt.Errorf("No command specified")

 	}

 	return warnings, nil

@@ -575,17 +573,20 @@ func (daemon *Daemon) generateHostname(id string, config *runconfig.Config) {

 	}

 }

-func (daemon *Daemon) getEntrypointAndArgs(configEntrypoint, configCmd []string) (string, []string) {

+func (daemon *Daemon) getEntrypointAndArgs(configEntrypoint *runconfig.Entrypoint, configCmd *runconfig.Command) (string, []string) {

 	var (

 		entrypoint string

 		args       []string

 	)

-	if len(configEntrypoint) != 0 {

-		entrypoint = configEntrypoint[0]

-		args = append(configEntrypoint[1:], configCmd...)

+

+	cmdSlice := configCmd.Slice()

+	if configEntrypoint.Len() != 0 {

+		eSlice := configEntrypoint.Slice()

+		entrypoint = eSlice[0]

+		args = append(eSlice[1:], cmdSlice...)

 	} else {

-		entrypoint = configCmd[0]

-		args = configCmd[1:]

+		entrypoint = cmdSlice[0]

+		args = cmdSlice[1:]

 	}

 	return entrypoint, args

 }

@@ -132,7 +132,8 @@ func (d *Daemon) ContainerExecCreate(job *engine.Job) error {

 		return err

 	}

-	entrypoint, args := d.getEntrypointAndArgs(nil, config.Cmd)

+	cmd := runconfig.NewCommand(config.Cmd...)

+	entrypoint, args := d.getEntrypointAndArgs(runconfig.NewEntrypoint(), cmd)

 	processConfig := execdriver.ProcessConfig{

 		Tty:        config.Tty,

@@ -3,18 +3,10 @@ package daemon

 import (

 	"fmt"

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

 	"github.com/docker/docker/runconfig"

 )

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

-	if len(job.Args) < 1 {

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

-	}

-	var (

-		name = job.Args[0]

-	)

-

+func (daemon *Daemon) ContainerStart(name string, hostConfig *runconfig.HostConfig) error {

 	container, err := daemon.Get(name)

 	if err != nil {

 		return err

@@ -28,15 +20,14 @@ func (daemon *Daemon) ContainerStart(job *engine.Job) error {

 		return fmt.Errorf("Container already started")

 	}

-	// If no environment was set, then no hostconfig was passed.

 	// This is kept for backward compatibility - hostconfig should be passed when

 	// creating a container, not during start.

-	if len(job.Environ()) > 0 {

-		hostConfig := runconfig.ContainerHostConfigFromJob(job)

+	if hostConfig != nil {

 		if err := daemon.setHostConfig(container, hostConfig); err != nil {

 			return err

 		}

 	}

+

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

 		container.LogEvent("die")

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

@@ -42,7 +42,8 @@ func mergeLxcConfIntoOptions(hostConfig *runconfig.HostConfig) ([]string, error)

 	// merge in the lxc conf options into the generic config map

 	if lxcConf := hostConfig.LxcConf; lxcConf != nil {

-		for _, pair := range lxcConf {

+		lxSlice := lxcConf.Slice()

+		for _, pair := range lxSlice {

 			// because lxc conf gets the driver name lxc.XXXX we need to trim it off

 			// and let the lxc driver add it back later if needed

 			if !strings.Contains(pair.Key, ".") {

@@ -7,10 +7,11 @@ import (

 )

 func TestMergeLxcConfig(t *testing.T) {

+	kv := []runconfig.KeyValuePair{

+		{"lxc.cgroups.cpuset", "1,2"},

+	}

 	hostConfig := &runconfig.HostConfig{

-		LxcConf: []runconfig.KeyValuePair{

-			{Key: "lxc.cgroups.cpuset", Value: "1,2"},

-		},

+		LxcConf: runconfig.NewLxcConfig(kv),

 	}

 	out, err := mergeLxcConfIntoOptions(hostConfig)

@@ -31,7 +31,7 @@ func (s *TagStore) History(name string) ([]*types.ImageHistory, error) {

 		history = append(history, &types.ImageHistory{

 			ID:        img.ID,

 			Created:   img.Created.Unix(),

-			CreatedBy: strings.Join(img.ContainerConfig.Cmd, " "),

+			CreatedBy: strings.Join(img.ContainerConfig.Cmd.Slice(), " "),

 			Tags:      lookupMap[img.ID],

 			Size:      img.Size,

 			Comment:   img.Comment,

@@ -91,7 +91,7 @@ func TestGetContainersTop(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/sh", "-c", "cat"},

+			Cmd:       runconfig.NewCommand("/bin/sh", "-c", "cat"),

 			OpenStdin: true,

 		},

 		t,

@@ -168,7 +168,7 @@ func TestPostCommit(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image: unitTestImageID,

-			Cmd:   []string{"touch", "/test"},

+			Cmd:   runconfig.NewCommand("touch", "/test"),

 		},

 		t,

 	)

@@ -201,9 +201,8 @@ func TestPostContainersCreate(t *testing.T) {

 	defer mkDaemonFromEngine(eng, t).Nuke()

 	configJSON, err := json.Marshal(&runconfig.Config{

-		Image:  unitTestImageID,

-		Memory: 33554432,

-		Cmd:    []string{"touch", "/test"},

+		Image: unitTestImageID,

+		Cmd:   runconfig.NewCommand("touch", "/test"),

 	})

 	if err != nil {

 		t.Fatal(err)

@@ -242,9 +241,8 @@ func TestPostJsonVerify(t *testing.T) {

 	defer mkDaemonFromEngine(eng, t).Nuke()

 	configJSON, err := json.Marshal(&runconfig.Config{

-		Image:  unitTestImageID,

-		Memory: 33554432,

-		Cmd:    []string{"touch", "/test"},

+		Image: unitTestImageID,

+		Cmd:   runconfig.NewCommand("touch", "/test"),

 	})

 	if err != nil {

 		t.Fatal(err)

@@ -330,8 +328,8 @@ func TestPostCreateNull(t *testing.T) {

 	containerAssertExists(eng, containerID, t)

 	c, _ := daemon.Get(containerID)

-	if c.Config.Cpuset != "" {

-		t.Fatalf("Cpuset should have been empty - instead its:" + c.Config.Cpuset)

+	if c.HostConfig().CpusetCpus != "" {

+		t.Fatalf("Cpuset should have been empty - instead its:" + c.HostConfig().CpusetCpus)

 	}

 }

@@ -342,7 +340,7 @@ func TestPostContainersKill(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/cat"},

+			Cmd:       runconfig.NewCommand("/bin/cat"),

 			OpenStdin: true,

 		},

 		t,

@@ -379,7 +377,7 @@ func TestPostContainersRestart(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/top"},

+			Cmd:       runconfig.NewCommand("/bin/top"),

 			OpenStdin: true,

 		},

 		t,

@@ -423,7 +421,7 @@ func TestPostContainersStart(t *testing.T) {

 		eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/cat"},

+			Cmd:       runconfig.NewCommand("/bin/cat"),

 			OpenStdin: true,

 		},

 		t,

@@ -473,7 +471,7 @@ func TestPostContainersStop(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/top"},

+			Cmd:       runconfig.NewCommand("/bin/top"),

 			OpenStdin: true,

 		},

 		t,

@@ -525,7 +523,7 @@ func TestPostContainersWait(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/sleep", "1"},

+			Cmd:       runconfig.NewCommand("/bin/sleep", "1"),

 			OpenStdin: true,

 		},

 		t,

@@ -561,7 +559,7 @@ func TestPostContainersAttach(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/cat"},

+			Cmd:       runconfig.NewCommand("/bin/cat"),

 			OpenStdin: true,

 		},

 		t,

@@ -637,7 +635,7 @@ func TestPostContainersAttachStderr(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image:     unitTestImageID,

-			Cmd:       []string{"/bin/sh", "-c", "/bin/cat >&2"},

+			Cmd:       runconfig.NewCommand("/bin/sh", "-c", "/bin/cat >&2"),

 			OpenStdin: true,

 		},

 		t,

@@ -818,7 +816,7 @@ func TestPostContainersCopy(t *testing.T) {

 	containerID := createTestContainer(eng,

 		&runconfig.Config{

 			Image: unitTestImageID,

-			Cmd:   []string{"touch", "/test.txt"},

+			Cmd:   runconfig.NewCommand("touch", "/test.txt"),

 		},

 		t,

 	)

@@ -14,7 +14,7 @@ func TestRestartStdin(t *testing.T) {

 	defer nuke(daemon)

 	container, _, err := daemon.Create(&runconfig.Config{

 		Image: GetTestImage(daemon).ID,

-		Cmd:   []string{"cat"},

+		Cmd:   runconfig.NewCommand("cat"),

 		OpenStdin: true,

 	},

@@ -79,7 +79,7 @@ func TestStdin(t *testing.T) {

 	defer nuke(daemon)

 	container, _, err := daemon.Create(&runconfig.Config{

 		Image: GetTestImage(daemon).ID,

-		Cmd:   []string{"cat"},

+		Cmd:   runconfig.NewCommand("cat"),

 		OpenStdin: true,

 	},

@@ -119,7 +119,7 @@ func TestTty(t *testing.T) {

 	defer nuke(daemon)

 	container, _, err := daemon.Create(&runconfig.Config{

 		Image: GetTestImage(daemon).ID,

-		Cmd:   []string{"cat"},

+		Cmd:   runconfig.NewCommand("cat"),

 		OpenStdin: true,

 	},

@@ -160,7 +160,7 @@ func BenchmarkRunSequential(b *testing.B) {

 	for i := 0; i < b.N; i++ {

 		container, _, err := daemon.Create(&runconfig.Config{

 			Image: GetTestImage(daemon).ID,

-			Cmd:   []string{"echo", "-n", "foo"},

+			Cmd:   runconfig.NewCommand("echo", "-n", "foo"),

 		},

 			&runconfig.HostConfig{},

 			"",

@@ -194,7 +194,7 @@ func BenchmarkRunParallel(b *testing.B) {

 		go func(i int, complete chan error) {

 			container, _, err := daemon.Create(&runconfig.Config{

 				Image: GetTestImage(daemon).ID,

-				Cmd:   []string{"echo", "-n", "foo"},

+				Cmd:   runconfig.NewCommand("echo", "-n", "foo"),

 			},

 				&runconfig.HostConfig{},

 				"",

@@ -255,7 +255,7 @@ func TestDaemonCreate(t *testing.T) {

 	container, _, err := daemon.Create(&runconfig.Config{

 		Image: GetTestImage(daemon).ID,

-		Cmd:   []string{"ls", "-al"},

+		Cmd:   runconfig.NewCommand("ls", "-al"),

 	},

 		&runconfig.HostConfig{},

 		"",

@@ -296,15 +296,16 @@ func TestDaemonCreate(t *testing.T) {

 	}

 	// Test that conflict error displays correct details

+	cmd := runconfig.NewCommand("ls", "-al")

 	testContainer, _, _ := daemon.Create(

 		&runconfig.Config{

 			Image: GetTestImage(daemon).ID,

-			Cmd:   []string{"ls", "-al"},

+			Cmd:   cmd,

 		},

 		&runconfig.HostConfig{},

 		"conflictname",

 	)

-	if _, _, err := daemon.Create(&runconfig.Config{Image: GetTestImage(daemon).ID, Cmd: []string{"ls", "-al"}}, &runconfig.HostConfig{}, testContainer.Name); err == nil || !strings.Contains(err.Error(), stringid.TruncateID(testContainer.ID)) {

+	if _, _, err := daemon.Create(&runconfig.Config{Image: GetTestImage(daemon).ID, Cmd: cmd}, &runconfig.HostConfig{}, testContainer.Name); err == nil || !strings.Contains(err.Error(), stringid.TruncateID(testContainer.ID)) {

 		t.Fatalf("Name conflict error doesn't include the correct short id. Message was: %v", err)

 	}

@@ -316,7 +317,7 @@ func TestDaemonCreate(t *testing.T) {

 	if _, _, err := daemon.Create(

 		&runconfig.Config{

 			Image: GetTestImage(daemon).ID,

-			Cmd:   []string{},

+			Cmd:   runconfig.NewCommand(),

 		},

 		&runconfig.HostConfig{},

 		"",

@@ -326,7 +327,7 @@ func TestDaemonCreate(t *testing.T) {

 	config := &runconfig.Config{

 		Image:     GetTestImage(daemon).ID,

-		Cmd:       []string{"/bin/ls"},

+		Cmd:       runconfig.NewCommand("/bin/ls"),

 		PortSpecs: []string{"80"},

 	}

 	container, _, err = daemon.Create(config, &runconfig.HostConfig{}, "")

@@ -339,7 +340,7 @@ func TestDaemonCreate(t *testing.T) {

 	// test expose 80:8000

 	container, warnings, err := daemon.Create(&runconfig.Config{

 		Image:     GetTestImage(daemon).ID,

-		Cmd:       []string{"ls", "-al"},

+		Cmd:       runconfig.NewCommand("ls", "-al"),

 		PortSpecs: []string{"80:8000"},

 	},

 		&runconfig.HostConfig{},

@@ -359,7 +360,7 @@ func TestDestroy(t *testing.T) {

 	container, _, err := daemon.Create(&runconfig.Config{

 		Image: GetTestImage(daemon).ID,

-		Cmd:   []string{"ls", "-al"},

+		Cmd:   runconfig.NewCommand("ls", "-al"),

 	},

 		&runconfig.HostConfig{},

 		"")

@@ -422,14 +423,13 @@ func TestGet(t *testing.T) {

 func startEchoServerContainer(t *testing.T, proto string) (*daemon.Daemon, *daemon.Container, string) {

 	var (

-		err          error

-		id           string

-		outputBuffer = bytes.NewBuffer(nil)

-		strPort      string

-		eng          = NewTestEngine(t)

-		daemon       = mkDaemonFromEngine(eng, t)

-		port         = 5554

-		p            nat.Port

+		err     error

+		id      string

+		strPort string

+		eng     = NewTestEngine(t)

+		daemon  = mkDaemonFromEngine(eng, t)

+		port    = 5554

+		p       nat.Port

 	)

 	defer func() {

 		if err != nil {

@@ -452,16 +452,14 @@ func startEchoServerContainer(t *testing.T, proto string) (*daemon.Daemon, *daem

 		p = nat.Port(fmt.Sprintf("%s/%s", strPort, proto))

 		ep[p] = struct{}{}

-		jobCreate := eng.Job("create")

-		jobCreate.Setenv("Image", unitTestImageID)

-		jobCreate.SetenvList("Cmd", []string{"sh", "-c", cmd})

-		jobCreate.SetenvList("PortSpecs", []string{fmt.Sprintf("%s/%s", strPort, proto)})

-		jobCreate.SetenvJson("ExposedPorts", ep)

-		jobCreate.Stdout.Add(outputBuffer)

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

-			t.Fatal(err)

+		c := &runconfig.Config{

+			Image:        unitTestImageID,

+			Cmd:          runconfig.NewCommand("sh", "-c", cmd),

+			PortSpecs:    []string{fmt.Sprintf("%s/%s", strPort, proto)},

+			ExposedPorts: ep,

 		}

-		id = engine.Tail(outputBuffer, 1)

+

+		id, _, err = daemon.ContainerCreate(unitTestImageID, c, &runconfig.HostConfig{})

 		// FIXME: this relies on the undocumented behavior of daemon.Create

 		// which will return a nil error AND container if the exposed ports

 		// are invalid. That behavior should be fixed!

@@ -472,15 +470,7 @@ func startEchoServerContainer(t *testing.T, proto string) (*daemon.Daemon, *daem

 	}

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

-	portBindings := make(map[nat.Port][]nat.PortBinding)

-	portBindings[p] = []nat.PortBinding{

-		{},

-	}

-	if err := jobStart.SetenvJson("PortsBindings", portBindings); err != nil {

-		t.Fatal(err)

-	}

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

+	if err := daemon.ContainerStart(id, &runconfig.HostConfig{}); err != nil {

 		t.Fatal(err)

 	}

@@ -731,20 +721,15 @@ func TestContainerNameValidation(t *testing.T) {

 			t.Fatal(err)

 		}

-		var outputBuffer = bytes.NewBuffer(nil)

-		job := eng.Job("create", test.Name)

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

-			t.Fatal(err)

-		}

-		job.Stdout.Add(outputBuffer)

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

+		containerId, _, err := daemon.ContainerCreate(test.Name, config, &runconfig.HostConfig{})

+		if err != nil {

 			if !test.Valid {

 				continue

 			}

 			t.Fatal(err)

 		}

-		container, err := daemon.Get(engine.Tail(outputBuffer, 1))

+		container, err := daemon.Get(containerId)

 		if err != nil {

 			t.Fatal(err)

 		}

@@ -759,7 +744,6 @@ func TestContainerNameValidation(t *testing.T) {

 			t.Fatalf("Container /%s has ID %s instead of %s", test.Name, c.ID, container.ID)

 		}

 	}

-

 }

 func TestLinkChildContainer(t *testing.T) {

@@ -876,7 +860,7 @@ func TestDestroyWithInitLayer(t *testing.T) {

 	container, _, err := daemon.Create(&runconfig.Config{

 		Image: GetTestImage(daemon).ID,

-		Cmd:   []string{"ls", "-al"},

+		Cmd:   runconfig.NewCommand("ls", "-al"),

 	},

 		&runconfig.HostConfig{},

 		"")

@@ -44,16 +44,11 @@ func mkDaemon(f Fataler) *daemon.Daemon {

 }

 func createNamedTestContainer(eng *engine.Engine, config *runconfig.Config, f Fataler, name string) (shortId string) {

-	job := eng.Job("create", name)

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

-		f.Fatal(err)

-	}

-	var outputBuffer = bytes.NewBuffer(nil)

-	job.Stdout.Add(outputBuffer)

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

+	containerId, _, err := getDaemon(eng).ContainerCreate(name, config, &runconfig.HostConfig{})

+	if err != nil {

 		f.Fatal(err)

 	}

-	return engine.Tail(outputBuffer, 1)

+	return containerId

 }

 func createTestContainer(eng *engine.Engine, config *runconfig.Config, f Fataler) (shortId string) {

@@ -61,8 +56,7 @@ func createTestContainer(eng *engine.Engine, config *runconfig.Config, f Fataler

 }

 func startContainer(eng *engine.Engine, id string, t Fataler) {

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

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

+	if err := getDaemon(eng).ContainerStart(id, &runconfig.HostConfig{}); err != nil {

 		t.Fatal(err)

 	}

 }

@@ -10,25 +10,25 @@ func Compare(a, b *Config) bool {

 	if a.AttachStdout != b.AttachStdout ||

 		a.AttachStderr != b.AttachStderr ||

 		a.User != b.User ||

-		a.Memory != b.Memory ||

-		a.MemorySwap != b.MemorySwap ||

-		a.CpuShares != b.CpuShares ||

 		a.OpenStdin != b.OpenStdin ||

 		a.Tty != b.Tty {

 		return false

 	}

-	if len(a.Cmd) != len(b.Cmd) ||

+

+	if a.Cmd.Len() != b.Cmd.Len() ||

 		len(a.Env) != len(b.Env) ||

 		len(a.Labels) != len(b.Labels) ||

 		len(a.PortSpecs) != len(b.PortSpecs) ||

 		len(a.ExposedPorts) != len(b.ExposedPorts) ||

-		len(a.Entrypoint) != len(b.Entrypoint) ||

+		a.Entrypoint.Len() != b.Entrypoint.Len() ||

 		len(a.Volumes) != len(b.Volumes) {

 		return false

 	}

-	for i := 0; i < len(a.Cmd); i++ {

-		if a.Cmd[i] != b.Cmd[i] {

+	aCmd := a.Cmd.Slice()

+	bCmd := b.Cmd.Slice()

+	for i := 0; i < len(aCmd); i++ {

+		if aCmd[i] != bCmd[i] {

 			return false

 		}

 	}

@@ -52,8 +52,11 @@ func Compare(a, b *Config) bool {

 			return false

 		}

 	}

-	for i := 0; i < len(a.Entrypoint); i++ {

-		if a.Entrypoint[i] != b.Entrypoint[i] {

+

+	aEntrypoint := a.Entrypoint.Slice()

+	bEntrypoint := b.Entrypoint.Slice()

+	for i := 0; i < len(aEntrypoint); i++ {

+		if aEntrypoint[i] != bEntrypoint[i] {

 			return false

 		}

 	}

@@ -1,10 +1,103 @@

 package runconfig

 import (

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

+	"encoding/json"

+	"io"

+

 	"github.com/docker/docker/nat"

 )

+// Entrypoint encapsulates the container entrypoint.

+// It might be represented as a string or an array of strings.

+// We need to override the json decoder to accept both options.

+// The JSON decoder will fail if the api sends an string and

+//  we try to decode it into an array of string.

+type Entrypoint struct {

+	parts []string

+}

+

+func (e *Entrypoint) MarshalJSON() ([]byte, error) {

+	if e == nil {

+		return []byte{}, nil

+	}

+	return json.Marshal(e.Slice())

+}

+

+// UnmarshalJSON decoded the entrypoint whether it's a string or an array of strings.

+func (e *Entrypoint) UnmarshalJSON(b []byte) error {

+	if len(b) == 0 {

+		return nil

+	}

+

+	p := make([]string, 0, 1)

+	if err := json.Unmarshal(b, &p); err != nil {

+		p = append(p, string(b))

+	}

+	e.parts = p

+	return nil

+}

+

+func (e *Entrypoint) Len() int {

+	if e == nil {

+		return 0

+	}

+	return len(e.parts)

+}

+

+func (e *Entrypoint) Slice() []string {

+	if e == nil {

+		return nil

+	}

+	return e.parts

+}

+

+func NewEntrypoint(parts ...string) *Entrypoint {

+	return &Entrypoint{parts}

+}

+

+type Command struct {

+	parts []string

+}

+

+func (e *Command) MarshalJSON() ([]byte, error) {

+	if e == nil {

+		return []byte{}, nil

+	}

+	return json.Marshal(e.Slice())

+}

+

+// UnmarshalJSON decoded the entrypoint whether it's a string or an array of strings.

+func (e *Command) UnmarshalJSON(b []byte) error {