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

 	"net/url"

 	"os"

 	"os/exec"

-	"path"

 	"path/filepath"

 	"regexp"

 	"runtime"

@@ -131,13 +130,19 @@ func (cli *DockerCli) CmdBuild(args ...string) error {

 		return fmt.Errorf("cannot canonicalize dockerfile path %s: %v", relDockerfile, err)

 	}

-	var includes = []string{"."}

-

-	excludes, err := utils.ReadDockerIgnore(path.Join(contextDir, ".dockerignore"))

-	if err != nil {

+	f, err := os.Open(filepath.Join(contextDir, ".dockerignore"))

+	if err != nil && !os.IsNotExist(err) {

 		return err

 	}

+	var excludes []string

+	if err == nil {

+		excludes, err = utils.ReadDockerIgnore(f)

+		if err != nil {

+			return err

+		}

+	}

+

 	if err := utils.ValidateContextDirectory(contextDir, excludes); err != nil {

 		return fmt.Errorf("Error checking context: '%s'.", err)

 	}

@@ -149,6 +154,7 @@ func (cli *DockerCli) CmdBuild(args ...string) error {

 	// removed.  The deamon will remove them for us, if needed, after it

 	// parses the Dockerfile. Ignore errors here, as they will have been

 	// caught by ValidateContextDirectory above.

+	var includes = []string{"."}

 	keepThem1, _ := fileutils.Matches(".dockerignore", excludes)

 	keepThem2, _ := fileutils.Matches(relDockerfile, excludes)

 	if keepThem1 || keepThem2 {

@@ -12,13 +12,18 @@ import (

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/api/server/httputils"

 	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/builder"

 	"github.com/docker/docker/builder/dockerfile"

 	"github.com/docker/docker/cliconfig"

+	"github.com/docker/docker/daemon/daemonbuilder"

 	"github.com/docker/docker/graph"

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

 	"github.com/docker/docker/pkg/ioutils"

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

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

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

 	"github.com/docker/docker/pkg/ulimit"

+	"github.com/docker/docker/registry"

 	"github.com/docker/docker/runconfig"

 	"github.com/docker/docker/utils"

 	"golang.org/x/net/context"

@@ -56,13 +61,18 @@ func (s *router) postCommit(ctx context.Context, w http.ResponseWriter, r *http.

 		Config:  c,

 	}

-	imgID, err := dockerfile.Commit(cname, s.daemon, commitCfg)

+	container, err := s.daemon.Get(cname)

+	if err != nil {

+		return err

+	}

+

+	imgID, err := dockerfile.Commit(container, s.daemon, commitCfg)

 	if err != nil {

 		return err

 	}

 	return httputils.WriteJSON(w, http.StatusCreated, &types.ContainerCommitResponse{

-		ID: imgID,

+		ID: string(imgID),

 	})

 }

@@ -125,7 +135,7 @@ func (s *router) postImagesCreate(ctx context.Context, w http.ResponseWriter, r

 		// generated from the download to be available to the output

 		// stream processing below

 		var newConfig *runconfig.Config

-		newConfig, err = dockerfile.BuildFromConfig(s.daemon, &runconfig.Config{}, r.Form["changes"])

+		newConfig, err = dockerfile.BuildFromConfig(&runconfig.Config{}, r.Form["changes"])

 		if err != nil {

 			return err

 		}

@@ -269,7 +279,7 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 	var (

 		authConfigs        = map[string]cliconfig.AuthConfig{}

 		authConfigsEncoded = r.Header.Get("X-Registry-Config")

-		buildConfig        = dockerfile.NewBuildConfig()

+		buildConfig        = &dockerfile.Config{}

 	)

 	if authConfigsEncoded != "" {

@@ -284,6 +294,21 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 	w.Header().Set("Content-Type", "application/json")

 	version := httputils.VersionFromContext(ctx)

+	output := ioutils.NewWriteFlusher(w)

+	sf := streamformatter.NewJSONStreamFormatter()

+	errf := func(err error) error {

+		// Do not write the error in the http output if it's still empty.

+		// This prevents from writing a 200(OK) when there is an interal error.

+		if !output.Flushed() {

+			return err

+		}

+		_, err = w.Write(sf.FormatError(errors.New(utils.GetErrorMessage(err))))

+		if err != nil {

+			logrus.Warnf("could not write error response: %v", err)

+		}

+		return nil

+	}

+

 	if httputils.BoolValue(r, "forcerm") && version.GreaterThanOrEqualTo("1.12") {

 		buildConfig.Remove = true

 	} else if r.FormValue("rm") == "" && version.GreaterThanOrEqualTo("1.12") {

@@ -295,17 +320,22 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 		buildConfig.Pull = true

 	}

-	output := ioutils.NewWriteFlusher(w)

-	buildConfig.Stdout = output

-	buildConfig.Context = r.Body

+	repoName, tag := parsers.ParseRepositoryTag(r.FormValue("t"))

+	if repoName != "" {

+		if err := registry.ValidateRepositoryName(repoName); err != nil {

+			return errf(err)

+		}

+		if len(tag) > 0 {

+			if err := tags.ValidateTagName(tag); err != nil {

+				return errf(err)

+			}

+		}

+	}

-	buildConfig.RemoteURL = r.FormValue("remote")

 	buildConfig.DockerfileName = r.FormValue("dockerfile")

-	buildConfig.RepoName = r.FormValue("t")

-	buildConfig.SuppressOutput = httputils.BoolValue(r, "q")

-	buildConfig.NoCache = httputils.BoolValue(r, "nocache")

+	buildConfig.Verbose = !httputils.BoolValue(r, "q")

+	buildConfig.UseCache = !httputils.BoolValue(r, "nocache")

 	buildConfig.ForceRemove = httputils.BoolValue(r, "forcerm")

-	buildConfig.AuthConfigs = authConfigs

 	buildConfig.MemorySwap = httputils.Int64ValueOrZero(r, "memswap")

 	buildConfig.Memory = httputils.Int64ValueOrZero(r, "memory")

 	buildConfig.CPUShares = httputils.Int64ValueOrZero(r, "cpushares")

@@ -319,7 +349,7 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 	ulimitsJSON := r.FormValue("ulimits")

 	if ulimitsJSON != "" {

 		if err := json.NewDecoder(strings.NewReader(ulimitsJSON)).Decode(&buildUlimits); err != nil {

-			return err

+			return errf(err)

 		}

 		buildConfig.Ulimits = buildUlimits

 	}

@@ -328,12 +358,50 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 	buildArgsJSON := r.FormValue("buildargs")

 	if buildArgsJSON != "" {

 		if err := json.NewDecoder(strings.NewReader(buildArgsJSON)).Decode(&buildArgs); err != nil {

-			return err

+			return errf(err)

 		}

+		buildConfig.BuildArgs = buildArgs

 	}

-	buildConfig.BuildArgs = buildArgs

-	// Job cancellation. Note: not all job types support this.

+	remoteURL := r.FormValue("remote")

+

+	// Currently, only used if context is from a remote url.

+	// The field `In` is set by DetectContextFromRemoteURL.

+	// Look at code in DetectContextFromRemoteURL for more information.

+	pReader := &progressreader.Config{

+		// TODO: make progressreader streamformatter-agnostic

+		Out:       output,

+		Formatter: sf,

+		Size:      r.ContentLength,

+		NewLines:  true,

+		ID:        "Downloading context",

+		Action:    remoteURL,

+	}

+

+	var (

+		context        builder.ModifiableContext

+		dockerfileName string

+		err            error

+	)

+	context, dockerfileName, err = daemonbuilder.DetectContextFromRemoteURL(r.Body, remoteURL, pReader)

+	if err != nil {

+		return errf(err)

+	}

+	defer func() {

+		if err := context.Close(); err != nil {

+			logrus.Debugf("[BUILDER] failed to remove temporary context: %v", err)

+		}

+	}()

+

+	docker := daemonbuilder.Docker{s.daemon, output, authConfigs}

+

+	b, err := dockerfile.NewBuilder(buildConfig, docker, builder.DockerIgnoreContext{context}, nil)

+	if err != nil {

+		return errf(err)

+	}

+	b.Stdout = &streamformatter.StdoutFormatter{Writer: output, StreamFormatter: sf}

+	b.Stderr = &streamformatter.StderrFormatter{Writer: output, StreamFormatter: sf}

+

 	if closeNotifier, ok := w.(http.CloseNotifier); ok {

 		finished := make(chan struct{})

 		defer close(finished)

@@ -342,20 +410,26 @@ func (s *router) postBuild(ctx context.Context, w http.ResponseWriter, r *http.R

 			case <-finished:

 			case <-closeNotifier.CloseNotify():

 				logrus.Infof("Client disconnected, cancelling job: build")

-				buildConfig.Cancel()

+				b.Cancel()

 			}

 		}()

 	}

-	if err := dockerfile.Build(s.daemon, buildConfig); err != nil {

-		// Do not write the error in the http output if it's still empty.

-		// This prevents from writing a 200(OK) when there is an interal error.

-		if !output.Flushed() {

-			return err

+	if len(dockerfileName) > 0 {

+		b.DockerfileName = dockerfileName

+	}

+

+	imgID, err := b.Build()

+	if err != nil {

+		return errf(err)

+	}

+

+	if repoName != "" {

+		if err := s.daemon.Repositories().Tag(repoName, tag, string(imgID), true); err != nil {

+			return errf(err)

 		}

-		sf := streamformatter.NewJSONStreamFormatter()

-		w.Write(sf.FormatError(errors.New(utils.GetErrorMessage(err))))

 	}

+

 	return nil

 }

new file mode 100644

@@ -0,0 +1,139 @@

+// Package builder defines interfaces for any Docker builder to implement.

+//

+// Historically, only server-side Dockerfile interpreters existed.

+// This package allows for other implementations of Docker builders.

+package builder

+

+import (

+	"io"

+	"os"

+

+	// TODO: remove dependency on daemon

+	"github.com/docker/docker/daemon"

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

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

+)

+

+// Builder abstracts a Docker builder whose only purpose is to build a Docker image referenced by an imageID.

+type Builder interface {

+	// Build builds a Docker image referenced by an imageID string.

+	//

+	// Note: Tagging an image should not be done by a Builder, it should instead be done

+	// by the caller.

+	//

+	// TODO: make this return a reference instead of string

+	Build() (imageID string)

+}

+

+// Context represents a file system tree.

+type Context interface {

+	// Close allows to signal that the filesystem tree won't be used anymore.

+	// For Context implementations using a temporary directory, it is recommended to

+	// delete the temporary directory in Close().

+	Close() error

+	// Stat returns an entry corresponding to path if any.

+	// It is recommended to return an error if path was not found.

+	Stat(path string) (FileInfo, error)

+	// Open opens path from the context and returns a readable stream of it.

+	Open(path string) (io.ReadCloser, error)

+	// Walk walks the tree of the context with the function passed to it.

+	Walk(root string, walkFn WalkFunc) error

+}

+

+// WalkFunc is the type of the function called for each file or directory visited by Context.Walk().

+type WalkFunc func(path string, fi FileInfo, err error) error

+

+// ModifiableContext represents a modifiable Context.

+// TODO: remove this interface once we can get rid of Remove()

+type ModifiableContext interface {

+	Context

+	// Remove deletes the entry specified by `path`.

+	// It is usual for directory entries to delete all its subentries.

+	Remove(path string) error

+}

+

+// FileInfo extends os.FileInfo to allow retrieving an absolute path to the file.

+// TODO: remove this interface once pkg/archive exposes a walk function that Context can use.

+type FileInfo interface {

+	os.FileInfo

+	Path() string

+}

+

+// PathFileInfo is a convenience struct that implements the FileInfo interface.

+type PathFileInfo struct {

+	os.FileInfo

+	// FilePath holds the absolute path to the file.

+	FilePath string

+}

+

+// Path returns the absolute path to the file.

+func (fi PathFileInfo) Path() string {

+	return fi.FilePath

+}

+

+// Hashed defines an extra method intended for implementations of os.FileInfo.

+type Hashed interface {

+	// Hash returns the hash of a file.

+	Hash() string

+	SetHash(string)

+}

+

+// HashedFileInfo is a convenient struct that augments FileInfo with a field.

+type HashedFileInfo struct {

+	FileInfo

+	// FileHash represents the hash of a file.

+	FileHash string

+}

+

+// Hash returns the hash of a file.

+func (fi HashedFileInfo) Hash() string {

+	return fi.FileHash

+}

+

+// SetHash sets the hash of a file.

+func (fi *HashedFileInfo) SetHash(h string) {

+	fi.FileHash = h

+}

+

+// Docker abstracts calls to a Docker Daemon.

+type Docker interface {

+	// TODO: use digest reference instead of name

+

+	// LookupImage looks up a Docker image referenced by `name`.

+	LookupImage(name string) (*image.Image, error)

+	// Pull tells Docker to pull image referenced by `name`.

+	Pull(name string) (*image.Image, error)

+

+	// TODO: move daemon.Container to its own package

+

+	// Container looks up a Docker container referenced by `id`.

+	Container(id string) (*daemon.Container, error)

+	// Create creates a new Docker container and returns potential warnings

+	// TODO: put warnings in the error

+	Create(*runconfig.Config, *runconfig.HostConfig) (*daemon.Container, []string, error)

+	// Remove removes a container specified by `id`.

+	Remove(id string, cfg *daemon.ContainerRmConfig) error

+	// Commit creates a new Docker image from an existing Docker container.

+	Commit(*daemon.Container, *daemon.ContainerCommitConfig) (*image.Image, error)

+	// Copy copies/extracts a source FileInfo to a destination path inside a container

+	// specified by a container object.

+	// TODO: make an Extract method instead of passing `decompress`

+	// TODO: do not pass a FileInfo, instead refactor the archive package to export a Walk function that can be used

+	// with Context.Walk

+	Copy(c *daemon.Container, destPath string, src FileInfo, decompress bool) error

+

+	// Retain retains an image avoiding it to be removed or overwritten until a corresponding Release() call.

+	// TODO: remove

+	Retain(sessionID, imgID string)

+	// Release releases a list of images that were retained for the time of a build.

+	// TODO: remove

+	Release(sessionID string, activeImages []string)

+}

+

+// ImageCache abstracts an image cache store.

+// (parent image, child runconfig) -> child image

+type ImageCache interface {

+	// GetCachedImage returns a reference to a cached image whose parent equals `parent`

+	// and runconfig equals `cfg`. A cache miss is expected to return an empty ID and a nil error.

+	GetCachedImage(parentID string, cfg *runconfig.Config) (imageID string, err error)

+}

new file mode 100644

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

+package dockerfile

+

+import (

+	"bytes"

+	"fmt"

+	"io"

+	"io/ioutil"

+	"os"

+	"runtime"

+	"strings"

+	"sync"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/builder"

+	"github.com/docker/docker/builder/dockerfile/parser"

+	"github.com/docker/docker/daemon"

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

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

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

+)

+

+var validCommitCommands = map[string]bool{

+	"cmd":        true,

+	"entrypoint": true,

+	"env":        true,

+	"expose":     true,

+	"label":      true,

+	"onbuild":    true,

+	"user":       true,

+	"volume":     true,

+	"workdir":    true,

+}

+

+// BuiltinAllowedBuildArgs is list of built-in allowed build args

+var BuiltinAllowedBuildArgs = map[string]bool{

+	"HTTP_PROXY":  true,

+	"http_proxy":  true,

+	"HTTPS_PROXY": true,

+	"https_proxy": true,

+	"FTP_PROXY":   true,

+	"ftp_proxy":   true,

+	"NO_PROXY":    true,

+	"no_proxy":    true,

+}

+

+// Config constitutes the configuration for a Dockerfile builder.

+type Config struct {

+	// only used if Dockerfile has to be extracted from Context

+	DockerfileName string

+

+	Verbose     bool

+	UseCache    bool

+	Remove      bool

+	ForceRemove bool

+	Pull        bool

+	BuildArgs   map[string]string // build-time args received in build context for expansion/substitution and commands in 'run'.

+

+	// resource constraints

+	// TODO: factor out to be reused with Run ?

+

+	Memory       int64

+	MemorySwap   int64

+	CPUShares    int64

+	CPUPeriod    int64

+	CPUQuota     int64

+	CPUSetCpus   string

+	CPUSetMems   string

+	CgroupParent string

+	Ulimits      []*ulimit.Ulimit

+}

+

+// Builder is a Dockerfile builder

+// It implements the builder.Builder interface.

+type Builder struct {

+	*Config

+

+	Stdout io.Writer

+	Stderr io.Writer

+

+	docker  builder.Docker

+	context builder.Context

+

+	dockerfile       *parser.Node

+	runConfig        *runconfig.Config // runconfig for cmd, run, entrypoint etc.

+	flags            *BFlags

+	tmpContainers    map[string]struct{}

+	image            string // imageID

+	noBaseImage      bool

+	maintainer       string

+	cmdSet           bool

+	disableCommit    bool

+	cacheBusted      bool

+	cancelled        chan struct{}

+	cancelOnce       sync.Once

+	allowedBuildArgs map[string]bool // list of build-time args that are allowed for expansion/substitution and passing to commands in 'run'.

+

+	// TODO: remove once docker.Commit can receive a tag

+	id           string

+	activeImages []string

+}

+

+// NewBuilder creates a new Dockerfile builder from an optional dockerfile and a Config.

+// If dockerfile is nil, the Dockerfile specified by Config.DockerfileName,

+// will be read from the Context passed to Build().

+func NewBuilder(config *Config, docker builder.Docker, context builder.Context, dockerfile io.ReadCloser) (b *Builder, err error) {

+	if config == nil {

+		config = new(Config)

+	}

+	if config.BuildArgs == nil {

+		config.BuildArgs = make(map[string]string)

+	}

+	b = &Builder{

+		Config:           config,

+		Stdout:           os.Stdout,

+		Stderr:           os.Stderr,

+		docker:           docker,

+		context:          context,

+		runConfig:        new(runconfig.Config),

+		tmpContainers:    map[string]struct{}{},

+		cancelled:        make(chan struct{}),

+		id:               stringid.GenerateNonCryptoID(),

+		allowedBuildArgs: make(map[string]bool),

+	}

+	if dockerfile != nil {

+		b.dockerfile, err = parser.Parse(dockerfile)

+		if err != nil {

+			return nil, err

+		}

+	}

+

+	return b, nil

+}

+

+// Build runs the Dockerfile builder from a context and a docker object that allows to make calls

+// to Docker.

+//

+// This will (barring errors):

+//

+// * read the dockerfile from context

+// * parse the dockerfile if not already parsed

+// * walk the AST and execute it by dispatching to handlers. If Remove

+//   or ForceRemove is set, additional cleanup around containers happens after

+//   processing.

+// * Print a happy message and return the image ID.

+// * NOT tag the image, that is responsibility of the caller.

+//

+func (b *Builder) Build() (string, error) {

+	// TODO: remove once b.docker.Commit can take a tag parameter.

+	defer func() {

+		b.docker.Release(b.id, b.activeImages)

+	}()

+

+	// If Dockerfile was not parsed yet, extract it from the Context

+	if b.dockerfile == nil {

+		if err := b.readDockerfile(); err != nil {

+			return "", err

+		}

+	}

+

+	var shortImgID string

+	for i, n := range b.dockerfile.Children {

+		select {

+		case <-b.cancelled:

+			logrus.Debug("Builder: build cancelled!")

+			fmt.Fprintf(b.Stdout, "Build cancelled")

+			return "", fmt.Errorf("Build cancelled")

+		default:

+			// Not cancelled yet, keep going...

+		}

+		if err := b.dispatch(i, n); err != nil {

+			if b.ForceRemove {

+				b.clearTmp()

+			}

+			return "", err

+		}

+		shortImgID = stringid.TruncateID(b.image)

+		fmt.Fprintf(b.Stdout, " ---> %s\n", shortImgID)

+		if b.Remove {

+			b.clearTmp()

+		}

+	}

+

+	// check if there are any leftover build-args that were passed but not

+	// consumed during build. Return an error, if there are any.

+	leftoverArgs := []string{}

+	for arg := range b.BuildArgs {

+		if !b.isBuildArgAllowed(arg) {

+			leftoverArgs = append(leftoverArgs, arg)

+		}

+	}

+	if len(leftoverArgs) > 0 {

+		return "", fmt.Errorf("One or more build-args %v were not consumed, failing build.", leftoverArgs)

+	}

+

+	if b.image == "" {

+		return "", fmt.Errorf("No image was generated. Is your Dockerfile empty?")

+	}

+

+	fmt.Fprintf(b.Stdout, "Successfully built %s\n", shortImgID)

+	return b.image, nil

+}

+

+// Cancel cancels an ongoing Dockerfile build.

+func (b *Builder) Cancel() {

+	b.cancelOnce.Do(func() {

+		close(b.cancelled)

+	})

+}

+

+// CommitConfig contains build configs for commit operation

+type CommitConfig struct {

+	Pause   bool

+	Repo    string

+	Tag     string

+	Author  string

+	Comment string

+	Changes []string

+	Config  *runconfig.Config

+}

+

+// BuildFromConfig will do build directly from parameter 'changes', which comes

+// from Dockerfile entries, it will:

+// - call parse.Parse() to get AST root from Dockerfile entries

+// - do build by calling builder.dispatch() to call all entries' handling routines

+// TODO: remove?

+func BuildFromConfig(config *runconfig.Config, changes []string) (*runconfig.Config, error) {

+	ast, err := parser.Parse(bytes.NewBufferString(strings.Join(changes, "\n")))

+	if err != nil {

+		return nil, err

+	}

+

+	// ensure that the commands are valid

+	for _, n := range ast.Children {

+		if !validCommitCommands[n.Value] {

+			return nil, fmt.Errorf("%s is not a valid change command", n.Value)

+		}

+	}

+

+	b, err := NewBuilder(nil, nil, nil, nil)

+	if err != nil {

+		return nil, err

+	}

+	b.runConfig = config

+	b.Stdout = ioutil.Discard

+	b.Stderr = ioutil.Discard

+	b.disableCommit = true

+

+	for i, n := range ast.Children {

+		if err := b.dispatch(i, n); err != nil {

+			return nil, err

+		}

+	}

+

+	return b.runConfig, nil

+}

+

+// Commit will create a new image from a container's changes

+// TODO: remove daemon, make Commit a method on *Builder ?

+func Commit(container *daemon.Container, d *daemon.Daemon, c *CommitConfig) (string, error) {

+	// It is not possible to commit a running container on Windows

+	if runtime.GOOS == "windows" && container.IsRunning() {

+		return "", fmt.Errorf("Windows does not support commit of a running container")

+	}

+

+	if c.Config == nil {

+		c.Config = &runconfig.Config{}

+	}

+

+	newConfig, err := BuildFromConfig(c.Config, c.Changes)

+	if err != nil {

+		return "", err

+	}

+

+	if err := runconfig.Merge(newConfig, container.Config); err != nil {

+		return "", err

+	}

+

+	commitCfg := &daemon.ContainerCommitConfig{

+		Pause:   c.Pause,

+		Repo:    c.Repo,

+		Tag:     c.Tag,

+		Author:  c.Author,

+		Comment: c.Comment,

+		Config:  newConfig,

+	}

+

+	img, err := d.Commit(container, commitCfg)

+	if err != nil {

+		return "", err

+	}

+	return img.ID, nil

+}

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

 	"github.com/Sirupsen/logrus"

 	derr "github.com/docker/docker/errors"

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

 	flag "github.com/docker/docker/pkg/mflag"

 	"github.com/docker/docker/pkg/nat"

 	"github.com/docker/docker/pkg/signal"

@@ -34,7 +35,7 @@ const (

 )

 // dispatch with no layer / parsing. This is effectively not a command.

-func nullDispatch(b *builder, args []string, attributes map[string]bool, original string) error {

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

 	return nil

 }

@@ -43,7 +44,7 @@ func nullDispatch(b *builder, args []string, attributes map[string]bool, origina

 // Sets the environment variable foo to bar, also makes interpolation

 // in the dockerfile available from the next statement on via ${foo}.

 //

-func env(b *builder, args []string, attributes map[string]bool, original string) error {

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

 	if len(args) == 0 {

 		return derr.ErrorCodeAtLeastOneArg.WithArgs("ENV")

 	}

@@ -53,7 +54,7 @@ func env(b *builder, args []string, attributes map[string]bool, original string)

 		return derr.ErrorCodeTooManyArgs.WithArgs("ENV")

 	}

-	if err := b.BuilderFlags.Parse(); err != nil {

+	if err := b.flags.Parse(); err != nil {

 		return err

 	}

@@ -62,10 +63,10 @@ func env(b *builder, args []string, attributes map[string]bool, original string)

 	// context of a builder command. Will remove once we actually add

 	// a builder command to something!

 	/*

-		flBool1 := b.BuilderFlags.AddBool("bool1", false)

-		flStr1 := b.BuilderFlags.AddString("str1", "HI")

+		flBool1 := b.flags.AddBool("bool1", false)

+		flStr1 := b.flags.AddString("str1", "HI")

-		if err := b.BuilderFlags.Parse(); err != nil {

+		if err := b.flags.Parse(); err != nil {

 			return err

 		}

@@ -82,44 +83,44 @@ func env(b *builder, args []string, attributes map[string]bool, original string)

 		commitStr += " " + newVar

 		gotOne := false

-		for i, envVar := range b.Config.Env {

+		for i, envVar := range b.runConfig.Env {

 			envParts := strings.SplitN(envVar, "=", 2)

 			if envParts[0] == args[j] {

-				b.Config.Env[i] = newVar

+				b.runConfig.Env[i] = newVar

 				gotOne = true

 				break

 			}

 		}

 		if !gotOne {

-			b.Config.Env = append(b.Config.Env, newVar)

+			b.runConfig.Env = append(b.runConfig.Env, newVar)

 		}

 		j++

 	}

-	return b.commit("", b.Config.Cmd, commitStr)

+	return b.commit("", b.runConfig.Cmd, commitStr)

 }

 // MAINTAINER some text <maybe@an.email.address>

 //

 // Sets the maintainer metadata.

-func maintainer(b *builder, args []string, attributes map[string]bool, original string) error {

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

 	if len(args) != 1 {

 		return derr.ErrorCodeExactlyOneArg.WithArgs("MAINTAINER")

 	}

-	if err := b.BuilderFlags.Parse(); err != nil {

+	if err := b.flags.Parse(); err != nil {

 		return err

 	}

 	b.maintainer = args[0]

-	return b.commit("", b.Config.Cmd, fmt.Sprintf("MAINTAINER %s", b.maintainer))

+	return b.commit("", b.runConfig.Cmd, fmt.Sprintf("MAINTAINER %s", b.maintainer))

 }

 // LABEL some json data describing the image

 //

 // Sets the Label variable foo to bar,

 //

-func label(b *builder, args []string, attributes map[string]bool, original string) error {

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

 	if len(args) == 0 {

 		return derr.ErrorCodeAtLeastOneArg.WithArgs("LABEL")

 	}

@@ -128,14 +129,14 @@ func label(b *builder, args []string, attributes map[string]bool, original strin

 		return derr.ErrorCodeTooManyArgs.WithArgs("LABEL")

 	}

-	if err := b.BuilderFlags.Parse(); err != nil {

+	if err := b.flags.Parse(); err != nil {

 		return err

 	}

 	commitStr := "LABEL"

-	if b.Config.Labels == nil {

-		b.Config.Labels = map[string]string{}

+	if b.runConfig.Labels == nil {

+		b.runConfig.Labels = map[string]string{}

 	}

 	for j := 0; j < len(args); j++ {

@@ -144,10 +145,10 @@ func label(b *builder, args []string, attributes map[string]bool, original strin

 		newVar := args[j] + "=" + args[j+1] + ""

 		commitStr += " " + newVar

-		b.Config.Labels[args[j]] = args[j+1]

+		b.runConfig.Labels[args[j]] = args[j+1]

 		j++

 	}

-	return b.commit("", b.Config.Cmd, commitStr)

+	return b.commit("", b.runConfig.Cmd, commitStr)

 }

 // ADD foo /path

@@ -155,12 +156,12 @@ func label(b *builder, args []string, attributes map[string]bool, original strin

 // Add the file 'foo' to '/path'. Tarball and Remote URL (git, http) handling

 // exist here. If you do not wish to have this automatic handling, use COPY.

 //

-func add(b *builder, args []string, attributes map[string]bool, original string) error {

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

 	if len(args) < 2 {

 		return derr.ErrorCodeAtLeastTwoArgs.WithArgs("ADD")

 	}

-	if err := b.BuilderFlags.Parse(); err != nil {

+	if err := b.flags.Parse(); err != nil {

 		return err

 	}

@@ -171,12 +172,12 @@ func add(b *builder, args []string, attributes map[string]bool, original string)

 //

 // Same as 'ADD' but without the tar and remote url handling.

 //

-func dispatchCopy(b *builder, args []string, attributes map[string]bool, original string) error {

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

 	if len(args) < 2 {

 		return derr.ErrorCodeAtLeastTwoArgs.WithArgs("COPY")

 	}

-	if err := b.BuilderFlags.Parse(); err != nil {

+	if err := b.flags.Parse(); err != nil {

 		return err

 	}

@@ -187,12 +188,12 @@ func dispatchCopy(b *builder, args []string, attributes map[string]bool, origina

 //

 // This sets the image the dockerfile will build on top of.

 //

-func from(b *builder, args []string, attributes map[string]bool, original string) error {

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

 	if len(args) != 1 {

 		return derr.ErrorCodeExactlyOneArg.WithArgs("FROM")

 	}

-	if err := b.BuilderFlags.Parse(); err != nil {

+	if err := b.flags.Parse(); err != nil {

 		return err

 	}

@@ -208,25 +209,21 @@ func from(b *builder, args []string, attributes map[string]bool, original string

 		return nil

 	}

-	image, err := b.Daemon.Repositories().LookupImage(name)

-	if b.Pull {

-		image, err = b.pullImage(name)

-		if err != nil {

-			return err

-		}

+	var (

+		image *image.Image

+		err   error