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

 	"github.com/openshift/origin/pkg/build/api"

 	"github.com/openshift/origin/pkg/build/builder/cmd/dockercfg"

+	"github.com/openshift/origin/pkg/util/docker/dockerfile"

 	s2iapi "github.com/openshift/source-to-image/pkg/api"

 	"github.com/openshift/source-to-image/pkg/scm/git"

 	"github.com/openshift/source-to-image/pkg/tar"

@@ -260,11 +261,20 @@ func (d *DockerBuilder) addBuildParameters(dir string) error {

 	}

 	labels = util.GenerateLabelsFromSourceInfo(labels, sourceInfo, api.DefaultDockerLabelNamespace)

 	newFileData = appendMetadata(Label, newFileData, labels)

-	if ioutil.WriteFile(dockerfilePath, []byte(newFileData), filePerm); err != nil {

+

+	node, err := parser.Parse(strings.NewReader(newFileData))

+	if err != nil {

 		return err

 	}

-	return nil

+	err = insertEnvAfterFrom(node, d.build.Spec.Strategy.DockerStrategy.Env)

+	if err != nil {

+		return err

+	}

+

+	instructions := dockerfile.ParseTreeToDockerfile(node)

+

+	return ioutil.WriteFile(dockerfilePath, instructions, filePerm)

 }

 // appendMetadata appends a Docker instruction that adds metadata values

@@ -416,6 +426,37 @@ func traverseAST(cmd string, node *parser.Node) int {

 	return index

 }

+// insertEnvAfterFrom inserts an ENV instruction with the environment variables

+// from env after every FROM instruction in node.

+func insertEnvAfterFrom(node *parser.Node, env []kapi.EnvVar) error {

+	if node == nil || len(env) == 0 {

+		return nil

+	}

+

+	// Build ENV instruction.

+	var m []dockerfile.KeyValue

+	for _, e := range env {

+		m = append(m, dockerfile.KeyValue{Key: e.Name, Value: e.Value})

+	}

+	buildEnv, err := dockerfile.Env(m)

+	if err != nil {

+		return err

+	}

+

+	// Insert the buildEnv after every FROM instruction.

+	// We iterate in reverse order, otherwise indices would have to be

+	// recomputed after each step, because we're changing node in-place.

+	indices := dockerfile.FindAll(node, dockercmd.From)

+	for i := len(indices) - 1; i >= 0; i-- {

+		err := dockerfile.InsertInstructions(node, indices[i]+1, buildEnv)

+		if err != nil {

+			return err

+		}

+	}

+

+	return nil

+}

+

 // setupPullSecret provides a Docker authentication configuration when the

 // PullSecret is specified.

 func (d *DockerBuilder) setupPullSecret() (*docker.AuthConfigurations, error) {

@@ -3,10 +3,15 @@ package builder

 import (

 	"bytes"

 	"log"

+	"reflect"

+	"strings"

 	"testing"

 	dockercmd "github.com/docker/docker/builder/command"

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

+	kapi "k8s.io/kubernetes/pkg/api"

+

+	"github.com/openshift/origin/pkg/util/docker/dockerfile"

 )

 func TestReplaceValidCmd(t *testing.T) {

@@ -249,6 +254,73 @@ func TestAppendLabels(t *testing.T) {

 	}

 }

+func TestInsertEnvAfterFrom(t *testing.T) {

+	tests := map[string]struct {

+		original string

+		env      []kapi.EnvVar

+		want     string

+	}{

+		"no FROM instruction": {

+			original: `RUN echo "invalid Dockerfile"

+`,

+			env: []kapi.EnvVar{

+				{Name: "PATH", Value: "/bin"},

+			},

+			want: `RUN echo "invalid Dockerfile"

+`},

+		"empty env": {

+			original: `FROM busybox

+`,

+			env: []kapi.EnvVar{},

+			want: `FROM busybox

+`},

+		"single FROM instruction": {

+			original: `FROM busybox

+RUN echo "hello world"

+`,

+			env: []kapi.EnvVar{

+				{Name: "PATH", Value: "/bin"},

+			},

+			want: `FROM busybox

+ENV "PATH"="/bin"

+RUN echo "hello world"

+`},

+		"multiple FROM instructions": {

+			original: `FROM scratch

+FROM busybox

+RUN echo "hello world"

+`,

+			env: []kapi.EnvVar{

+				{Name: "PATH", Value: "/bin"},

+				{Name: "GOPATH", Value: "/go"},

+				{Name: "PATH", Value: "/go/bin:$PATH"},

+			},

+			want: `FROM scratch

+ENV "PATH"="/bin" "GOPATH"="/go" "PATH"="/go/bin:$PATH"

+FROM busybox

+ENV "PATH"="/bin" "GOPATH"="/go" "PATH"="/go/bin:$PATH"

+RUN echo "hello world"

+`},

+	}

+	for name, test := range tests {

+		got, err := parser.Parse(strings.NewReader(test.original))

+		if err != nil {

+			t.Errorf("%s: %v", name, err)

+			continue

+		}

+		want, err := parser.Parse(strings.NewReader(test.want))

+		if err != nil {

+			t.Errorf("%s: %v", name, err)

+			continue

+		}

+		insertEnvAfterFrom(got, test.env)

+		if !reflect.DeepEqual(got, want) {

+			t.Errorf("%s: insertEnvAfterFrom(node, %+v) = %+v; want %+v", name, test.env, got, want)

+			t.Logf("resulting Dockerfile:\n%s", dockerfile.ParseTreeToDockerfile(got))

+		}

+	}

+}

+

 const (

 	dockerFile = `

 FROM openshift/origin-base

new file mode 100644

@@ -0,0 +1,2 @@

+// Package docker has utilities to work with Docker.

+package docker

new file mode 100644

@@ -0,0 +1,3 @@

+// Package dockerfile has utilities that complement Docker's official Dockerfile

+// parser.

+package dockerfile

new file mode 100644

@@ -0,0 +1,64 @@

+package dockerfile

+

+import (

+	"fmt"

+	"strings"

+

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

+)

+

+// ParseTreeToDockerfile takes a Dockerfile AST node, as generated by

+// parser.Parse, and returns a new, equivalent, Dockerfile.

+func ParseTreeToDockerfile(node *parser.Node) []byte {

+	if node == nil {

+		return nil

+	}

+	buf := []byte(node.Original)

+	for _, child := range node.Children {

+		buf = append(buf, ParseTreeToDockerfile(child)...)

+	}

+	// Append a line break when needed.

+	if len(buf) > 0 && buf[len(buf)-1] != '\n' {

+		buf = append(buf, '\n')

+	}

+	return buf

+}

+

+// FindAll returns the indices of all children of node such that

+// node.Children[i].Value == cmd. Valid values for cmd are defined in the

+// package github.com/docker/docker/builder/command.

+func FindAll(node *parser.Node, cmd string) []int {

+	if node == nil {

+		return nil

+	}

+	var indices []int

+	for i, child := range node.Children {

+		if child != nil && child.Value == cmd {

+			indices = append(indices, i)

+		}

+	}

+	return indices

+}

+

+// InsertInstructions inserts instructions starting from the pos-th child of

+// node, moving other children as necessary. The instructions should be valid

+// Dockerfile instructions. InsertInstructions mutates node in-place, and the

+// final state of node is equivalent to what parser.Parse would return if the

+// original Dockerfile represented by node contained the instructions at the

+// specified position pos. If the returned error is non-nil, node is guaranteed

+// to be unchanged.

+func InsertInstructions(node *parser.Node, pos int, instructions string) error {

+	if node == nil {

+		return fmt.Errorf("cannot insert instructions in a nil node")

+	}

+	if pos < 0 || pos > len(node.Children) {

+		return fmt.Errorf("pos %d out of range [0, %d]", pos, len(node.Children)-1)

+	}

+	newChild, err := parser.Parse(strings.NewReader(instructions))

+	if err != nil {

+		return err

+	}

+	// InsertVector pattern (https://github.com/golang/go/wiki/SliceTricks)

+	node.Children = append(node.Children[:pos], append(newChild.Children, node.Children[pos:]...)...)

+	return nil

+}

new file mode 100644

@@ -0,0 +1,275 @@

+package dockerfile

+

+import (

+	"reflect"

+	"strings"

+	"testing"

+

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

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

+)

+

+// TestParseTreeToDockerfile tests calling ParseTreeToDockerfile with multiple

+// valid inputs.

+func TestParseTreeToDockerfile(t *testing.T) {

+	testCases := map[string]struct {

+		in   string

+		want string

+	}{

+		"empty input": {

+			in:   ``,

+			want: ``,

+		},

+		"only comments": {

+			in: `# This is a comment

+# and this is another comment

+	# while this is an indented comment`,

+			want: ``,

+		},

+		"simple Dockerfile": {

+			in: `FROM scratch

+LABEL version=1.0

+FROM busybox

+ENV PATH=/bin

+`,

+			want: `FROM scratch

+LABEL version=1.0

+FROM busybox

+ENV PATH=/bin

+`,

+		},

+		"Dockerfile with comments": {

+			in: `# This is a Dockerfile

+FROM scratch

+LABEL version=1.0

+# Here we start building a second image

+FROM busybox

+ENV PATH=/bin

+`,

+			want: `FROM scratch

+LABEL version=1.0

+FROM busybox

+ENV PATH=/bin

+`,

+		},

+		"all Dockerfile instructions": {

+			in: `FROM busybox:latest

+MAINTAINER nobody@example.com

+ONBUILD ADD . /app/src

+ONBUILD RUN echo "Hello universe!"

+LABEL version=1.0

+EXPOSE 8080

+VOLUME /var/run/www

+ENV PATH=/bin

+ADD file /home/

+COPY dir/ /tmp/

+RUN echo "Hello world!"

+ENTRYPOINT /bin/sh

+CMD ["-c", "env"]

+USER 1001

+WORKDIR /home

+`,

+			want: `FROM busybox:latest

+MAINTAINER nobody@example.com

+ONBUILD ADD . /app/src

+ONBUILD RUN echo "Hello universe!"

+LABEL version=1.0

+EXPOSE 8080

+VOLUME /var/run/www

+ENV PATH=/bin

+ADD file /home/

+COPY dir/ /tmp/

+RUN echo "Hello world!"

+ENTRYPOINT /bin/sh

+CMD ["-c", "env"]

+USER 1001

+WORKDIR /home

+`,

+		},

+	}

+	for name, tc := range testCases {

+		node, err := parser.Parse(strings.NewReader(tc.in))

+		if err != nil {

+			t.Errorf("%s: parse error: %v", name, err)

+			continue

+		}

+		got := ParseTreeToDockerfile(node)

+		want := []byte(tc.want)

+		if !reflect.DeepEqual(got, want) {

+			t.Errorf("ParseTreeToDockerfile: %s:\ngot:\n%swant:\n%s", name, got, want)

+		}

+	}

+}

+

+// TestParseTreeToDockerfileNilNode tests calling ParseTreeToDockerfile with a

+// nil *parser.Node.

+func TestParseTreeToDockerfileNilNode(t *testing.T) {

+	got := ParseTreeToDockerfile(nil)

+	if got != nil {

+		t.Errorf("ParseTreeToDockerfile(nil) = %#v; want nil", got)

+	}

+}

+

+// TestFindAll tests calling FindAll with multiple values of cmd.

+func TestFindAll(t *testing.T) {

+	instructions := `FROM scratch

+LABEL version=1.0

+FROM busybox

+ENV PATH=/bin

+`

+	node, err := parser.Parse(strings.NewReader(instructions))

+	if err != nil {

+		t.Fatalf("parse error: %v", err)

+	}

+	for cmd, want := range map[string][]int{

+		command.From:       {0, 2},

+		command.Label:      {1},

+		command.Env:        {3},

+		command.Maintainer: nil,

+		"UnknownCommand":   nil,

+	} {

+		got := FindAll(node, cmd)

+		if !reflect.DeepEqual(got, want) {

+			t.Errorf("FindAll(node, %q) = %#v; want %#v", cmd, got, want)

+		}

+	}

+}

+

+// TestFindAllNilNode tests calling FindAll with a nil *parser.Node.

+func TestFindAllNilNode(t *testing.T) {

+	cmd := command.From

+	got := FindAll(nil, cmd)

+	if got != nil {

+		t.Errorf("FindAll(nil, %q) = %#v; want nil", cmd, got)

+	}

+}

+

+// TestInsertInstructions tests calling InsertInstructions with multiple valid

+// combinations of input.

+func TestInsertInstructions(t *testing.T) {

+	testCases := map[string]struct {

+		original        string

+		index           int

+		newInstructions string

+		want            string

+	}{

+		"insert nothing": {

+			original: `FROM busybox

+ENV PATH=/bin

+`,

+			index:           0,

+			newInstructions: ``,

+			want: `FROM busybox

+ENV PATH=/bin

+`,

+		},

+		"insert instruction in empty file": {

+			original:        ``,

+			index:           0,

+			newInstructions: `FROM busybox`,

+			want: `FROM busybox

+`,

+		},

+		"prepend single instruction": {

+			original: `FROM busybox

+ENV PATH=/bin

+`,

+			index:           0,

+			newInstructions: `FROM scratch`,

+			want: `FROM scratch

+FROM busybox

+ENV PATH=/bin

+`,

+		},

+		"append single instruction": {

+			original: `FROM busybox

+ENV PATH=/bin

+`,

+			index:           2,

+			newInstructions: `FROM scratch`,

+			want: `FROM busybox

+ENV PATH=/bin

+FROM scratch

+`,

+		},

+		"insert single instruction in the middle": {

+			original: `FROM busybox

+ENV PATH=/bin

+`,

+			index:           1,

+			newInstructions: `LABEL version=1.0`,

+			want: `FROM busybox

+LABEL version=1.0

+ENV PATH=/bin

+`,

+		},

+	}

+	for name, tc := range testCases {

+		got, err := parser.Parse(strings.NewReader(tc.original))

+		if err != nil {

+			t.Errorf("InsertInstructions: %s: parse error: %v", name, err)

+			continue

+		}

+		err = InsertInstructions(got, tc.index, tc.newInstructions)

+		if err != nil {

+			t.Errorf("InsertInstructions: %s: %v", name, err)

+			continue

+		}

+		want, err := parser.Parse(strings.NewReader(tc.want))

+		if err != nil {

+			t.Errorf("InsertInstructions: %s: parse error: %v", name, err)

+			continue

+		}

+		if !reflect.DeepEqual(got, want) {

+			t.Errorf("InsertInstructions: %s: got %#v; want %#v", name, got, want)

+		}

+	}

+}

+

+// TestInsertInstructionsNilNode tests calling InsertInstructions with a nil

+// *parser.Node.

+func TestInsertInstructionsNilNode(t *testing.T) {

+	err := InsertInstructions(nil, 0, "")

+	if err == nil {

+		t.Errorf("InsertInstructions: got nil; want error")

+	}

+}

+

+// TestInsertInstructionsPosOutOfRange tests calling InsertInstructions with

+// invalid values for the pos argument.

+func TestInsertInstructionsPosOutOfRange(t *testing.T) {

+	original := `FROM busybox

+ENV PATH=/bin

+`

+	node, err := parser.Parse(strings.NewReader(original))

+	if err != nil {

+		t.Fatalf("parse error: %v", err)

+	}

+	for _, pos := range []int{-1, 3, 4} {

+		err := InsertInstructions(node, pos, "")

+		if err == nil {

+			t.Errorf("InsertInstructions(node, %d, \"\"): got nil; want error", pos)

+		}

+	}

+}

+

+// TestInsertInstructionsUnparseable tests calling InsertInstructions with

+// instructions that the Docker parser cannot handle.

+func TestInsertInstructionsUnparseable(t *testing.T) {

+	original := `FROM busybox

+ENV PATH=/bin

+`

+	node, err := parser.Parse(strings.NewReader(original))

+	if err != nil {

+		t.Fatalf("parse error: %v", err)

+	}

+	for name, instructions := range map[string]string{

+		"env without value": `ENV PATH`,

+		"nested json":       `CMD [ "echo", [ "nested json" ] ]`,

+	} {

+		err = InsertInstructions(node, 1, instructions)

+		if err == nil {

+			t.Errorf("InsertInstructions: %s: got nil; want error", name)

+		}

+	}

+}

new file mode 100644

@@ -0,0 +1,44 @@

+package dockerfile

+

+import (

+	"encoding/json"

+	"fmt"

+	"strings"

+

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

+)

+

+// A KeyValue can be used to build ordered lists of key-value pairs.

+type KeyValue struct {

+	Key   string

+	Value string

+}

+

+// Env builds an ENV Dockerfile instruction from the mapping m. Keys and values

+// are serialized as JSON strings to ensure compatibility with the Dockerfile

+// parser.

+func Env(m []KeyValue) (string, error) {

+	return keyValueInstruction(command.Env, m)

+}

+

+// keyValueInstruction builds a Dockerfile instruction from the mapping m. Keys

+// and values are serialized as JSON strings to ensure compatibility with the

+// Dockerfile parser. Syntax:

+//   COMMAND "KEY"="VALUE" "may"="contain spaces"

+func keyValueInstruction(cmd string, m []KeyValue) (string, error) {

+	s := []string{strings.ToUpper(cmd)}

+	for _, kv := range m {

+		// Marshal kv.Key and kv.Value as JSON strings to cover cases

+		// like when the values contain spaces or special characters.

+		k, err := json.Marshal(kv.Key)

+		if err != nil {

+			return "", err

+		}

+		v, err := json.Marshal(kv.Value)

+		if err != nil {

+			return "", err

+		}

+		s = append(s, fmt.Sprintf("%s=%s", k, v))

+	}

+	return strings.Join(s, " "), nil

+}

new file mode 100644

@@ -0,0 +1,66 @@

+package dockerfile

+

+import "testing"

+

+// TestEnv tests calling Env with multiple inputs.

+func TestEnv(t *testing.T) {

+	testCases := []struct {

+		in   []KeyValue

+		want string

+	}{

+		{

+			in:   nil,

+			want: `ENV`,

+		},

+		{

+			in:   []KeyValue{},

+			want: `ENV`,

+		},

+		{

+			in: []KeyValue{

+				{"", ""},

+				{"", "ABC"},

+				{"ABC", ""},

+			},

+			want: `ENV ""="" ""="ABC" "ABC"=""`,

+		},

+		{

+			in: []KeyValue{

+				{"GOPATH", "/go"},

+				{"MSG", "Hello World!"},

+			},

+			want: `ENV "GOPATH"="/go" "MSG"="Hello World!"`,

+		},

+		{

+			in: []KeyValue{

+				{"PATH", "/bin"},

+				{"GOPATH", "/go"},

+				{"PATH", "$GOPATH/bin:$PATH"},

+			},

+			want: `ENV "PATH"="/bin" "GOPATH"="/go" "PATH"="$GOPATH/bin:$PATH"`,

+		},

+		{

+			in: []KeyValue{

+				{"你好", "我会说汉语"},

+			},

+			want: `ENV "你好"="我会说汉语"`,

+		},

+		{

+			// This tests handling an string encoding edge case.

+			// Example input taken from Docker parser's test suite.

+			in: []KeyValue{

+				{"☃", "'\" \\ / \b \f \n \r \t \x00"},

+			},

+			want: `ENV "☃"="'\" \\ / \u0008 \u000c \n \r \t \u0000"`,

+		},

+	}

+	for _, tc := range testCases {

+		got, err := Env(tc.in)

+		if err != nil {

+			t.Fatal(err)

+		}

+		if got != tc.want {

+			t.Errorf("Env(%v) = %q; want %q", tc.in, got, tc.want)

+		}

+	}

+}