deleted file mode 100644

@@ -1,183 +0,0 @@

-package dockerfile

-

-import (

-	"fmt"

-	"strings"

-)

-

-// FlagType is the type of the build flag

-type FlagType int

-

-const (

-	boolType FlagType = iota

-	stringType

-)

-

-// BFlags contains all flags information for the builder

-type BFlags struct {

-	Args  []string // actual flags/args from cmd line

-	flags map[string]*Flag

-	used  map[string]*Flag

-	Err   error

-}

-

-// Flag contains all information for a flag

-type Flag struct {

-	bf       *BFlags

-	name     string

-	flagType FlagType

-	Value    string

-}

-

-// NewBFlags returns the new BFlags struct

-func NewBFlags() *BFlags {

-	return &BFlags{

-		flags: make(map[string]*Flag),

-		used:  make(map[string]*Flag),

-	}

-}

-

-// NewBFlagsWithArgs returns the new BFlags struct with Args set to args

-func NewBFlagsWithArgs(args []string) *BFlags {

-	flags := NewBFlags()

-	flags.Args = args

-	return flags

-}

-

-// AddBool adds a bool flag to BFlags

-// Note, any error will be generated when Parse() is called (see Parse).

-func (bf *BFlags) AddBool(name string, def bool) *Flag {

-	flag := bf.addFlag(name, boolType)

-	if flag == nil {

-		return nil

-	}

-	if def {

-		flag.Value = "true"

-	} else {

-		flag.Value = "false"

-	}

-	return flag

-}

-

-// AddString adds a string flag to BFlags

-// Note, any error will be generated when Parse() is called (see Parse).

-func (bf *BFlags) AddString(name string, def string) *Flag {

-	flag := bf.addFlag(name, stringType)

-	if flag == nil {

-		return nil

-	}

-	flag.Value = def

-	return flag

-}

-

-// addFlag is a generic func used by the other AddXXX() func

-// to add a new flag to the BFlags struct.

-// Note, any error will be generated when Parse() is called (see Parse).

-func (bf *BFlags) addFlag(name string, flagType FlagType) *Flag {

-	if _, ok := bf.flags[name]; ok {

-		bf.Err = fmt.Errorf("Duplicate flag defined: %s", name)

-		return nil

-	}

-

-	newFlag := &Flag{

-		bf:       bf,

-		name:     name,

-		flagType: flagType,

-	}

-	bf.flags[name] = newFlag

-

-	return newFlag

-}

-

-// IsUsed checks if the flag is used

-func (fl *Flag) IsUsed() bool {

-	if _, ok := fl.bf.used[fl.name]; ok {

-		return true

-	}

-	return false

-}

-

-// IsTrue checks if a bool flag is true

-func (fl *Flag) IsTrue() bool {

-	if fl.flagType != boolType {

-		// Should never get here

-		panic(fmt.Errorf("Trying to use IsTrue on a non-boolean: %s", fl.name))

-	}

-	return fl.Value == "true"

-}

-

-// Parse parses and checks if the BFlags is valid.

-// Any error noticed during the AddXXX() funcs will be generated/returned

-// here.  We do this because an error during AddXXX() is more like a

-// compile time error so it doesn't matter too much when we stop our

-// processing as long as we do stop it, so this allows the code

-// around AddXXX() to be just:

-//     defFlag := AddString("description", "")

-// w/o needing to add an if-statement around each one.

-func (bf *BFlags) Parse() error {

-	// If there was an error while defining the possible flags

-	// go ahead and bubble it back up here since we didn't do it

-	// earlier in the processing

-	if bf.Err != nil {

-		return fmt.Errorf("Error setting up flags: %s", bf.Err)

-	}

-

-	for _, arg := range bf.Args {

-		if !strings.HasPrefix(arg, "--") {

-			return fmt.Errorf("Arg should start with -- : %s", arg)

-		}

-

-		if arg == "--" {

-			return nil

-		}

-

-		arg = arg[2:]

-		value := ""

-

-		index := strings.Index(arg, "=")

-		if index >= 0 {

-			value = arg[index+1:]

-			arg = arg[:index]

-		}

-

-		flag, ok := bf.flags[arg]

-		if !ok {

-			return fmt.Errorf("Unknown flag: %s", arg)

-		}

-

-		if _, ok = bf.used[arg]; ok {

-			return fmt.Errorf("Duplicate flag specified: %s", arg)

-		}

-

-		bf.used[arg] = flag

-

-		switch flag.flagType {

-		case boolType:

-			// value == "" is only ok if no "=" was specified

-			if index >= 0 && value == "" {

-				return fmt.Errorf("Missing a value on flag: %s", arg)

-			}

-

-			lower := strings.ToLower(value)

-			if lower == "" {

-				flag.Value = "true"

-			} else if lower == "true" || lower == "false" {

-				flag.Value = lower

-			} else {

-				return fmt.Errorf("Expecting boolean value for flag %s, not: %s", arg, value)

-			}

-

-		case stringType:

-			if index < 0 {

-				return fmt.Errorf("Missing a value on flag: %s", arg)

-			}

-			flag.Value = value

-

-		default:

-			panic("No idea what kind of flag we have! Should never get here!")

-		}

-

-	}

-

-	return nil

-}

deleted file mode 100644

@@ -1,187 +0,0 @@

-package dockerfile

-

-import (

-	"testing"

-)

-

-func TestBuilderFlags(t *testing.T) {

-	var expected string

-	var err error

-

-	// ---

-

-	bf := NewBFlags()

-	bf.Args = []string{}

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

-		t.Fatalf("Test1 of %q was supposed to work: %s", bf.Args, err)

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	bf.Args = []string{"--"}

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

-		t.Fatalf("Test2 of %q was supposed to work: %s", bf.Args, err)

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flStr1 := bf.AddString("str1", "")

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

-	bf.Args = []string{}

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test3 of %q was supposed to work: %s", bf.Args, err)

-	}

-

-	if flStr1.IsUsed() {

-		t.Fatal("Test3 - str1 was not used!")

-	}

-	if flBool1.IsUsed() {

-		t.Fatal("Test3 - bool1 was not used!")

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flStr1 = bf.AddString("str1", "HI")

-	flBool1 = bf.AddBool("bool1", false)

-	bf.Args = []string{}

-

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test4 of %q was supposed to work: %s", bf.Args, err)

-	}

-

-	if flStr1.Value != "HI" {

-		t.Fatal("Str1 was supposed to default to: HI")

-	}

-	if flBool1.IsTrue() {

-		t.Fatal("Bool1 was supposed to default to: false")

-	}

-	if flStr1.IsUsed() {

-		t.Fatal("Str1 was not used!")

-	}

-	if flBool1.IsUsed() {

-		t.Fatal("Bool1 was not used!")

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flStr1 = bf.AddString("str1", "HI")

-	bf.Args = []string{"--str1"}

-

-	if err = bf.Parse(); err == nil {

-		t.Fatalf("Test %q was supposed to fail", bf.Args)

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flStr1 = bf.AddString("str1", "HI")

-	bf.Args = []string{"--str1="}

-

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test %q was supposed to work: %s", bf.Args, err)

-	}

-

-	expected = ""

-	if flStr1.Value != expected {

-		t.Fatalf("Str1 (%q) should be: %q", flStr1.Value, expected)

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flStr1 = bf.AddString("str1", "HI")

-	bf.Args = []string{"--str1=BYE"}

-

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test %q was supposed to work: %s", bf.Args, err)

-	}

-

-	expected = "BYE"

-	if flStr1.Value != expected {

-		t.Fatalf("Str1 (%q) should be: %q", flStr1.Value, expected)

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flBool1 = bf.AddBool("bool1", false)

-	bf.Args = []string{"--bool1"}

-

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test %q was supposed to work: %s", bf.Args, err)

-	}

-

-	if !flBool1.IsTrue() {

-		t.Fatal("Test-b1 Bool1 was supposed to be true")

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flBool1 = bf.AddBool("bool1", false)

-	bf.Args = []string{"--bool1=true"}

-

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test %q was supposed to work: %s", bf.Args, err)

-	}

-

-	if !flBool1.IsTrue() {

-		t.Fatal("Test-b2 Bool1 was supposed to be true")

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flBool1 = bf.AddBool("bool1", false)

-	bf.Args = []string{"--bool1=false"}

-

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test %q was supposed to work: %s", bf.Args, err)

-	}

-

-	if flBool1.IsTrue() {

-		t.Fatal("Test-b3 Bool1 was supposed to be false")

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flBool1 = bf.AddBool("bool1", false)

-	bf.Args = []string{"--bool1=false1"}

-

-	if err = bf.Parse(); err == nil {

-		t.Fatalf("Test %q was supposed to fail", bf.Args)

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flBool1 = bf.AddBool("bool1", false)

-	bf.Args = []string{"--bool2"}

-

-	if err = bf.Parse(); err == nil {

-		t.Fatalf("Test %q was supposed to fail", bf.Args)

-	}

-

-	// ---

-

-	bf = NewBFlags()

-	flStr1 = bf.AddString("str1", "HI")

-	flBool1 = bf.AddBool("bool1", false)

-	bf.Args = []string{"--bool1", "--str1=BYE"}

-

-	if err = bf.Parse(); err != nil {

-		t.Fatalf("Test %q was supposed to work: %s", bf.Args, err)

-	}

-

-	if flStr1.Value != "BYE" {

-		t.Fatalf("Test %s, str1 should be BYE", bf.Args)

-	}

-	if !flBool1.IsTrue() {

-		t.Fatalf("Test %s, bool1 should be true", bf.Args)

-	}

-}

@@ -42,6 +42,26 @@ func newBuildArgs(argsFromOptions map[string]*string) *buildArgs {

 	}

 }

+func (b *buildArgs) Clone() *buildArgs {

+	result := newBuildArgs(b.argsFromOptions)

+	for k, v := range b.allowedBuildArgs {

+		result.allowedBuildArgs[k] = v

+	}

+	for k, v := range b.allowedMetaArgs {

+		result.allowedMetaArgs[k] = v

+	}

+	for k := range b.referencedArgs {

+		result.referencedArgs[k] = struct{}{}

+	}

+	return result

+}

+

+func (b *buildArgs) MergeReferencedArgs(other *buildArgs) {

+	for k := range other.referencedArgs {

+		b.referencedArgs[k] = struct{}{}

+	}

+}

+

 // WarnOnUnusedBuildArgs checks if there are any leftover build-args that were

 // passed but not consumed during build. Print a warning, if there are any.

 func (b *buildArgs) WarnOnUnusedBuildArgs(out io.Writer) {

@@ -13,7 +13,7 @@ import (

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

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

 	"github.com/docker/docker/builder"

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

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

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

 	"github.com/docker/docker/builder/fscache"

 	"github.com/docker/docker/builder/remotecontext"

@@ -41,6 +41,10 @@ var validCommitCommands = map[string]bool{

 	"workdir":     true,

 }

+const (

+	stepFormat = "Step %d/%d : %v"

+)

+

 // SessionGetter is object used to get access to a session by uuid

 type SessionGetter interface {

 	Get(ctx context.Context, uuid string) (session.Caller, error)

@@ -176,9 +180,7 @@ type Builder struct {

 	clientCtx context.Context

 	idMappings       *idtools.IDMappings

-	buildStages      *buildStages

 	disableCommit    bool

-	buildArgs        *buildArgs

 	imageSources     *imageSources

 	pathCache        pathCache

 	containerManager *containerManager

@@ -218,8 +220,6 @@ func newBuilder(clientCtx context.Context, options builderOptions) *Builder {

 		Output:           options.ProgressWriter.Output,

 		docker:           options.Backend,

 		idMappings:       options.IDMappings,

-		buildArgs:        newBuildArgs(config.BuildArgs),

-		buildStages:      newBuildStages(),

 		imageSources:     newImageSources(clientCtx, options),

 		pathCache:        options.PathCache,

 		imageProber:      newImageProber(options.Backend, config.CacheFrom, options.Platform, config.NoCache),

@@ -237,24 +237,27 @@ func (b *Builder) build(source builder.Source, dockerfile *parser.Result) (*buil

 	addNodesForLabelOption(dockerfile.AST, b.options.Labels)

-	if err := checkDispatchDockerfile(dockerfile.AST); err != nil {

-		buildsFailed.WithValues(metricsDockerfileSyntaxError).Inc()

+	stages, metaArgs, err := instructions.Parse(dockerfile.AST)

+	if err != nil {

+		if instructions.IsUnknownInstruction(err) {

+			buildsFailed.WithValues(metricsUnknownInstructionError).Inc()

+		}

 		return nil, validationError{err}

 	}

+	if b.options.Target != "" {

+		targetIx, found := instructions.HasStage(stages, b.options.Target)

+		if !found {

+			buildsFailed.WithValues(metricsBuildTargetNotReachableError).Inc()

+			return nil, errors.Errorf("failed to reach build target %s in Dockerfile", b.options.Target)

+		}

+		stages = stages[:targetIx+1]

+	}

-	dispatchState, err := b.dispatchDockerfileWithCancellation(dockerfile, source)

+	dockerfile.PrintWarnings(b.Stderr)

+	dispatchState, err := b.dispatchDockerfileWithCancellation(stages, metaArgs, dockerfile.EscapeToken, source)

 	if err != nil {

 		return nil, err

 	}

-

-	if b.options.Target != "" && !dispatchState.isCurrentStage(b.options.Target) {

-		buildsFailed.WithValues(metricsBuildTargetNotReachableError).Inc()

-		return nil, errors.Errorf("failed to reach build target %s in Dockerfile", b.options.Target)

-	}

-

-	dockerfile.PrintWarnings(b.Stderr)

-	b.buildArgs.WarnOnUnusedBuildArgs(b.Stderr)

-

 	if dispatchState.imageID == "" {

 		buildsFailed.WithValues(metricsDockerfileEmptyError).Inc()

 		return nil, errors.New("No image was generated. Is your Dockerfile empty?")

@@ -269,61 +272,91 @@ func emitImageID(aux *streamformatter.AuxFormatter, state *dispatchState) error

 	return aux.Emit(types.BuildResult{ID: state.imageID})

 }

-func (b *Builder) dispatchDockerfileWithCancellation(dockerfile *parser.Result, source builder.Source) (*dispatchState, error) {

-	shlex := NewShellLex(dockerfile.EscapeToken)

-	state := newDispatchState()

-	total := len(dockerfile.AST.Children)

-	var err error

-	for i, n := range dockerfile.AST.Children {

-		select {

-		case <-b.clientCtx.Done():

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

-			fmt.Fprint(b.Stdout, "Build cancelled")

-			buildsFailed.WithValues(metricsBuildCanceled).Inc()

-			return nil, errors.New("Build cancelled")

-		default:

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

-		}

+func processMetaArg(meta instructions.ArgCommand, shlex *ShellLex, args *buildArgs) error {

+	// ShellLex currently only support the concatenated string format

+	envs := convertMapToEnvList(args.GetAllAllowed())

+	if err := meta.Expand(func(word string) (string, error) {

+		return shlex.ProcessWord(word, envs)

+	}); err != nil {

+		return err

+	}

+	args.AddArg(meta.Key, meta.Value)

+	args.AddMetaArg(meta.Key, meta.Value)

+	return nil

+}

-		// If this is a FROM and we have a previous image then

-		// emit an aux message for that image since it is the

-		// end of the previous stage

-		if n.Value == command.From {

-			if err := emitImageID(b.Aux, state); err != nil {

-				return nil, err

-			}

+func printCommand(out io.Writer, currentCommandIndex int, totalCommands int, cmd interface{}) int {

+	fmt.Fprintf(out, stepFormat, currentCommandIndex, totalCommands, cmd)

+	fmt.Fprintln(out)

+	return currentCommandIndex + 1

+}

+

+func (b *Builder) dispatchDockerfileWithCancellation(parseResult []instructions.Stage, metaArgs []instructions.ArgCommand, escapeToken rune, source builder.Source) (*dispatchState, error) {

+	dispatchRequest := dispatchRequest{}

+	buildArgs := newBuildArgs(b.options.BuildArgs)

+	totalCommands := len(metaArgs) + len(parseResult)

+	currentCommandIndex := 1

+	for _, stage := range parseResult {

+		totalCommands += len(stage.Commands)

+	}

+	shlex := NewShellLex(escapeToken)

+	for _, meta := range metaArgs {

+		currentCommandIndex = printCommand(b.Stdout, currentCommandIndex, totalCommands, &meta)

+

+		err := processMetaArg(meta, shlex, buildArgs)

+		if err != nil {

+			return nil, err

 		}

+	}

+

+	stagesResults := newStagesBuildResults()

-		if n.Value == command.From && state.isCurrentStage(b.options.Target) {

-			break

+	for _, stage := range parseResult {

+		if err := stagesResults.checkStageNameAvailable(stage.Name); err != nil {

+			return nil, err

 		}

+		dispatchRequest = newDispatchRequest(b, escapeToken, source, buildArgs, stagesResults)

-		opts := dispatchOptions{

-			state:   state,

-			stepMsg: formatStep(i, total),

-			node:    n,

-			shlex:   shlex,

-			source:  source,

+		currentCommandIndex = printCommand(b.Stdout, currentCommandIndex, totalCommands, stage.SourceCode)

+		if err := initializeStage(dispatchRequest, &stage); err != nil {

+			return nil, err

 		}

-		if state, err = b.dispatch(opts); err != nil {

-			if b.options.ForceRemove {

-				b.containerManager.RemoveAll(b.Stdout)

+		dispatchRequest.state.updateRunConfig()

+		fmt.Fprintf(b.Stdout, " ---> %s\n", stringid.TruncateID(dispatchRequest.state.imageID))

+		for _, cmd := range stage.Commands {

+			select {

+			case <-b.clientCtx.Done():

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

+				fmt.Fprint(b.Stdout, "Build cancelled\n")

+				buildsFailed.WithValues(metricsBuildCanceled).Inc()

+				return nil, errors.New("Build cancelled")

+			default:

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

 			}

+

+			currentCommandIndex = printCommand(b.Stdout, currentCommandIndex, totalCommands, cmd)

+

+			if err := dispatch(dispatchRequest, cmd); err != nil {

+				return nil, err

+			}

+

+			dispatchRequest.state.updateRunConfig()

+			fmt.Fprintf(b.Stdout, " ---> %s\n", stringid.TruncateID(dispatchRequest.state.imageID))

+

+		}

+		if err := emitImageID(b.Aux, dispatchRequest.state); err != nil {

 			return nil, err

 		}

-

-		fmt.Fprintf(b.Stdout, " ---> %s\n", stringid.TruncateID(state.imageID))

-		if b.options.Remove {

-			b.containerManager.RemoveAll(b.Stdout)

+		buildArgs.MergeReferencedArgs(dispatchRequest.state.buildArgs)

+		if err := commitStage(dispatchRequest.state, stagesResults); err != nil {

+			return nil, err

 		}

 	}

-

-	// Emit a final aux message for the final image

-	if err := emitImageID(b.Aux, state); err != nil {

-		return nil, err

+	if b.options.Remove {

+		b.containerManager.RemoveAll(b.Stdout)

 	}

-

-	return state, nil

+	buildArgs.WarnOnUnusedBuildArgs(b.Stdout)

+	return dispatchRequest.state, nil

 }

 func addNodesForLabelOption(dockerfile *parser.Node, labels map[string]string) {

@@ -380,39 +413,33 @@ func BuildFromConfig(config *container.Config, changes []string) (*container.Con

 	b.Stderr = ioutil.Discard

 	b.disableCommit = true

-	if err := checkDispatchDockerfile(dockerfile.AST); err != nil {

-		return nil, validationError{err}

+	commands := []instructions.Command{}

+	for _, n := range dockerfile.AST.Children {

+		cmd, err := instructions.ParseCommand(n)

+		if err != nil {

+			return nil, validationError{err}

+		}

+		commands = append(commands, cmd)

 	}

-	dispatchState := newDispatchState()

-	dispatchState.runConfig = config

-	return dispatchFromDockerfile(b, dockerfile, dispatchState, nil)

-}

-func checkDispatchDockerfile(dockerfile *parser.Node) error {

-	for _, n := range dockerfile.Children {

-		if err := checkDispatch(n); err != nil {

-			return errors.Wrapf(err, "Dockerfile parse error line %d", n.StartLine)

+	dispatchRequest := newDispatchRequest(b, dockerfile.EscapeToken, nil, newBuildArgs(b.options.BuildArgs), newStagesBuildResults())

+	dispatchRequest.state.runConfig = config

+	dispatchRequest.state.imageID = config.Image

+	for _, cmd := range commands {

+		err := dispatch(dispatchRequest, cmd)

+		if err != nil {

+			return nil, validationError{err}

 		}

+		dispatchRequest.state.updateRunConfig()

 	}

-	return nil

+

+	return dispatchRequest.state.runConfig, nil

 }

-func dispatchFromDockerfile(b *Builder, result *parser.Result, dispatchState *dispatchState, source builder.Source) (*container.Config, error) {

-	shlex := NewShellLex(result.EscapeToken)

-	ast := result.AST

-	total := len(ast.Children)

-

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

-		opts := dispatchOptions{

-			state:   dispatchState,

-			stepMsg: formatStep(i, total),

-			node:    n,

-			shlex:   shlex,

-			source:  source,

-		}

-		if _, err := b.dispatch(opts); err != nil {

-			return nil, err

-		}

+func convertMapToEnvList(m map[string]string) []string {

+	result := []string{}

+	for k, v := range m {

+		result = append(result, k+"="+v)

 	}

-	return dispatchState.runConfig, nil

+	return result

 }

@@ -10,17 +10,15 @@ package dockerfile

 import (

 	"bytes"

 	"fmt"

-	"regexp"

 	"runtime"

 	"sort"

-	"strconv"

 	"strings"

-	"time"

 	"github.com/docker/docker/api"

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

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

 	"github.com/docker/docker/builder"

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

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

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/pkg/jsonmessage"

@@ -36,32 +34,14 @@ import (

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

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

 //

-func env(req dispatchRequest) error {

-	if len(req.args) == 0 {

-		return errAtLeastOneArgument("ENV")

-	}

-

-	if len(req.args)%2 != 0 {

-		// should never get here, but just in case

-		return errTooManyArguments("ENV")

-	}

-

-	if err := req.flags.Parse(); err != nil {

-		return err

-	}

-

-	runConfig := req.state.runConfig

+func dispatchEnv(d dispatchRequest, c *instructions.EnvCommand) error {

+	runConfig := d.state.runConfig

 	commitMessage := bytes.NewBufferString("ENV")

+	for _, e := range c.Env {

+		name := e.Key

+		newVar := e.String()

-	for j := 0; j < len(req.args); j += 2 {

-		if len(req.args[j]) == 0 {

-			return errBlankCommandNames("ENV")

-		}

-		name := req.args[j]

-		value := req.args[j+1]

-		newVar := name + "=" + value

 		commitMessage.WriteString(" " + newVar)

-

 		gotOne := false

 		for i, envVar := range runConfig.Env {

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

@@ -76,64 +56,32 @@ func env(req dispatchRequest) error {

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

 		}

 	}

-

-	return req.builder.commit(req.state, commitMessage.String())

+	return d.builder.commit(d.state, commitMessage.String())

 }

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

 //

 // Sets the maintainer metadata.

-func maintainer(req dispatchRequest) error {

-	if len(req.args) != 1 {

-		return errExactlyOneArgument("MAINTAINER")

-	}

+func dispatchMaintainer(d dispatchRequest, c *instructions.MaintainerCommand) error {

-	if err := req.flags.Parse(); err != nil {

-		return err

-	}

-

-	maintainer := req.args[0]

-	req.state.maintainer = maintainer

-	return req.builder.commit(req.state, "MAINTAINER "+maintainer)

+	d.state.maintainer = c.Maintainer

+	return d.builder.commit(d.state, "MAINTAINER "+c.Maintainer)

 }

 // LABEL some json data describing the image

 //

 // Sets the Label variable foo to bar,

 //

-func label(req dispatchRequest) error {

-	if len(req.args) == 0 {

-		return errAtLeastOneArgument("LABEL")

-	}

-	if len(req.args)%2 != 0 {

-		// should never get here, but just in case

-		return errTooManyArguments("LABEL")

-	}

-

-	if err := req.flags.Parse(); err != nil {

-		return err

+func dispatchLabel(d dispatchRequest, c *instructions.LabelCommand) error {

+	if d.state.runConfig.Labels == nil {

+		d.state.runConfig.Labels = make(map[string]string)

 	}

-

 	commitStr := "LABEL"

-	runConfig := req.state.runConfig

-

-	if runConfig.Labels == nil {

-		runConfig.Labels = map[string]string{}

-	}

-

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

-		name := req.args[j]

-		if name == "" {

-			return errBlankCommandNames("LABEL")

-		}

-

-		value := req.args[j+1]

-		commitStr += " " + name + "=" + value

-

-		runConfig.Labels[name] = value

-		j++

+	for _, v := range c.Labels {

+		d.state.runConfig.Labels[v.Key] = v.Value

+		commitStr += " " + v.String()

 	}

-	return req.builder.commit(req.state, commitStr)

+	return d.builder.commit(d.state, commitStr)

 }

 // ADD foo /path

@@ -141,257 +89,172 @@ func label(req dispatchRequest) error {

 // 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(req dispatchRequest) error {

-	if len(req.args) < 2 {

-		return errAtLeastTwoArguments("ADD")

-	}

-

-	flChown := req.flags.AddString("chown", "")

-	if err := req.flags.Parse(); err != nil {

-		return err

-	}

-

-	downloader := newRemoteSourceDownloader(req.builder.Output, req.builder.Stdout)

-	copier := copierFromDispatchRequest(req, downloader, nil)

+func dispatchAdd(d dispatchRequest, c *instructions.AddCommand) error {

+	downloader := newRemoteSourceDownloader(d.builder.Output, d.builder.Stdout)

+	copier := copierFromDispatchRequest(d, downloader, nil)

 	defer copier.Cleanup()

-	copyInstruction, err := copier.createCopyInstruction(req.args, "ADD")

+

+	copyInstruction, err := copier.createCopyInstruction(c.SourcesAndDest, "ADD")

 	if err != nil {

 		return err

 	}

-	copyInstruction.chownStr = flChown.Value

+	copyInstruction.chownStr = c.Chown

 	copyInstruction.allowLocalDecompression = true

-	return req.builder.performCopy(req.state, copyInstruction)

+	return d.builder.performCopy(d.state, copyInstruction)

 }

 // COPY foo /path

 //

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

 //

-func dispatchCopy(req dispatchRequest) error {

-	if len(req.args) < 2 {

-		return errAtLeastTwoArguments("COPY")

-	}

-

-	flFrom := req.flags.AddString("from", "")

-	flChown := req.flags.AddString("chown", "")

-	if err := req.flags.Parse(); err != nil {

-		return err

-	}

-

-	im, err := req.builder.getImageMount(flFrom)

-	if err != nil {

-		return errors.Wrapf(err, "invalid from flag value %s", flFrom.Value)

+func dispatchCopy(d dispatchRequest, c *instructions.CopyCommand) error {

+	var im *imageMount

+	var err error

+	if c.From != "" {

+		im, err = d.getImageMount(c.From)

+		if err != nil {

+			return errors.Wrapf(err, "invalid from flag value %s", c.From)

+		}

 	}