new file mode 100644

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

+// Package main contains the main executable for `openshift-docker-build` which performs

+// a docker build given an OpenShift build object

+package main

new file mode 100644

@@ -0,0 +1,9 @@

+package main

+

+import (

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

+)

+

+func main() {

+	cmd.RunDockerBuild()

+}

new file mode 100644

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

+// Package main contains the main executable for `openshift-sti-build` which performs

+// an STI build given an OpenShift build object

+package main

new file mode 100644

@@ -0,0 +1,9 @@

+package main

+

+import (

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

+)

+

+func main() {

+	cmd.RunSTIBuild()

+}

@@ -33,7 +33,7 @@

       }

    ],

    "head_commit":{

-      "id":"9bdc3a26ff933b32f3e558636b58aea86a69f051",

+      "id":"",

       "distinct":true,

       "message":"Added license",

       "timestamp":"2014-08-28T16:55:36+02:00",

@@ -35,6 +35,8 @@ cp -f "${imagedir}/openshift"        images/origin/bin

 cp -f "${imagedir}/openshift-deploy" images/origin/bin

 cp -f "${imagedir}/openshift-router" images/origin/bin

 cp -f "${imagedir}/openshift-router" images/router/haproxy/bin

+cp -f "${imagedir}/openshift-docker-build" images/builder/docker/docker-builder/bin

+cp -f "${imagedir}/openshift-sti-build"    images/builder/docker/sti-builder/bin

 # build hello-openshift binary

 "${OS_ROOT}/hack/build-go.sh" examples/hello-openshift

@@ -28,6 +28,8 @@ readonly OS_COMPILE_PLATFORMS=(

 readonly OS_COMPILE_TARGETS=(

   cmd/openshift-router

   cmd/openshift-deploy

+  cmd/openshift-docker-build

+  cmd/openshift-sti-build

 )

 readonly OS_COMPILE_BINARIES=("${OS_COMPILE_TARGETS[@]##*/}")

@@ -8,5 +8,4 @@ FROM centos:centos7

 # components from EPEL must be installed in a separate yum install step

 RUN yum install -y git tar wget socat hostname epel-release && \

-    yum install -y docker && \

     yum clean all

@@ -1,12 +1,8 @@

 #

-# This is the image that executes a Docker build inside Origin. It expects a set of

-# environment variables to parameterize the build:

+# This is the image that executes a Docker build inside Origin. It expects the

+# following environment variables:

 #

-#   BUILD_TAG - the tag to assign the image after it is built

-#   REGISTRY - the Docker registry URL to push this image to (optional)

-#   SOURCE_URI - a URI to fetch the build context from

-#   SOURCE_REF - a reference to pass to Git for which commit to use (optional)

-#   CONTEXT_DIR - a subdirectory of the retrieved source to run the build from

+#   BUILD - JSON string containing the openshift build object

 #

 # This image expects to have the Docker socket bind-mounted into the container.

 # If "/root/.dockercfg" is bind mounted in, it will use that as authorization to a

@@ -17,5 +13,5 @@

 FROM openshift/origin-base

 ENV HOME /root

-ADD ./build.sh /tmp/build.sh

-CMD ["/tmp/build.sh"]

+ADD bin/openshift-docker-build /usr/bin/openshift-docker-build

+CMD ["/usr/bin/openshift-docker-build"]

new file mode 100644

@@ -0,0 +1 @@

+openshift-docker-build

deleted file mode 100755

@@ -1,70 +0,0 @@

-#!/bin/bash

-set -o pipefail

-IFS=$'\n\t'

-

-DOCKER_SOCKET=/var/run/docker.sock

-

-if [ ! -e "${DOCKER_SOCKET}" ]; then

-  echo "Docker socket missing at ${DOCKER_SOCKET}"

-  exit 1

-fi

-

-TAG="${BUILD_TAG}"

-if [ -n "${REGISTRY}" ]; then

-  TAG="${REGISTRY}/${BUILD_TAG}"

-elif [ -n "${DOCKER_REGISTRY}" ]; then

-  TAG="${DOCKER_REGISTRY}/${BUILD_TAG}"

-fi

-

-# backwards compatibility for older openshift versions that passed docker context instead of source_uri

-if [ -n "${DOCKER_CONTEXT_URL}" ]; then

-  SOURCE_URI=${DOCKER_CONTEXT_URL}

-fi

-

-if [[ "${SOURCE_URI}" != "git://"* ]] && [[ "${SOURCE_URI}" != "git@"* ]]; then

-  URL="${SOURCE_URI}"

-  if [[ "${URL}" != "http://"* ]] && [[ "${URL}" != "https://"* ]]; then

-    URL="https://${URL}"

-  fi

-  curl --head --silent --fail --location --max-time 16 $URL > /dev/null

-  if [ $? != 0 ]; then

-    echo "Not found: ${SOURCE_URI}"

-    exit 1

-  fi

-fi

-

-if [ -n "${SOURCE_REF}" ] || [ -n "${CONTEXT_DIR}" ]; then

-  BUILD_DIR=$(mktemp --directory --suffix=docker-build)

-  git clone --recursive "${SOURCE_URI}" "${BUILD_DIR}"

-  if [ $? != 0 ]; then

-    echo "Error trying to fetch git source: ${SOURCE_URI}"

-    exit 1

-  fi

-  pushd "${BUILD_DIR}"

-  if [ -n "${SOURCE_REF}" ]; then

-    git checkout "${SOURCE_REF}"

-    if [ $? != 0 ]; then

-      echo "Error trying to checkout branch: ${SOURCE_REF}"

-      exit 1

-    fi

-  fi

-  if [ -n "${SOURCE_ID}" ]; then

-    git branch --contains ${SOURCE_ID} | grep ${SOURCE_REF}

-    if [ $? != 0 ]; then

-      echo "Branch '${SOURCE_REF}' does not contain commit: ${SOURCE_ID}"

-      exit 1

-    fi

-  fi

-  popd

-  if [ -n "${CONTEXT_DIR}" ] && [ ! -d "${BUILD_DIR}/${CONTEXT_DIR}" ]; then

-    echo "ContextDir does not exist in the repository: ${CONTEXT_DIR}"

-    exit 1

-  fi

-  docker build --rm -t "${TAG}" "${BUILD_DIR}/${CONTEXT_DIR}"

-else

-  docker build --rm -t "${TAG}" "${SOURCE_URI}"

-fi

-

-if [ -n "${REGISTRY}" ] || [ -n "${DOCKER_REGISTRY}" ] || [ -s "/root/.dockercfg" ]; then

-  docker push "${TAG}"

-fi

@@ -1,12 +1,8 @@

 #

-# This is the image that executes a Docker build inside Origin. It expects a set of

-# environment variables to parameterize the build:

+# This is the image that executes a STI build inside Origin. It expects the

+# following environment variables:

 #

-#   BUILD_TAG - the tag to assign the image after it is built

-#   REGISTRY - the Docker registry URL to push this image to (optional)

-#   SOURCE_URI - a URI to fetch the build context from

-#   SOURCE_REF - a reference to pass to Git for which commit to use (optional)

-#   CONTEXT_DIR - a subdirectory of the retrieved source to run the build from

+#   BUILD - JSON string containing the openshift build object

 #

 # This image expects to have the Docker socket bind-mounted into the container.

 # If "/root/.dockercfg" is bind mounted in, it will use that as authorization to a

@@ -16,17 +12,6 @@

 #

 FROM openshift/origin-base

-# TODO: When STI is vendored in OpenShift, it should be built as part of openshift/origin

-# and simply made the CMD here.

-RUN yum -y install golang golang-src golang-pkg-bin-linux-amd64 golang-pkg-linux-amd64 && \

-    yum clean all && \

-    mkdir -p /tmp/go/src/github.com/openshift && \

-    git clone git://github.com/openshift/geard /tmp/go/src/github.com/openshift/geard && \

-    export GOPATH=/tmp/go && \

-    cd /tmp/go/src/github.com/openshift/geard && \

-    ./contrib/build -n && \

-    cp /tmp/go/bin/sti /usr/bin/sti

-

 ENV HOME /root

-ADD ./build.sh /opt/build.sh

-CMD ["/opt/build.sh"]

+ADD ./bin/openshift-sti-build /usr/bin/openshift-sti-build

+CMD ["/usr/bin/openshift-sti-build"]

new file mode 100644

@@ -0,0 +1 @@

+openshift-sti-build

deleted file mode 100755

@@ -1,27 +0,0 @@

-#!/bin/bash -ex

-

-DOCKER_SOCKET=/var/run/docker.sock

-

-if [ ! -e "${DOCKER_SOCKET}" ]; then

-  echo "Docker socket missing at $DOCKER_SOCKET"

-  exit 1

-fi

-

-TAG="${BUILD_TAG}"

-if [ -n "${REGISTRY}" ]; then

-  TAG="${REGISTRY}/${BUILD_TAG}"

-elif [ -n "${DOCKER_REGISTRY}" ]; then

-  TAG="${DOCKER_REGISTRY}/${BUILD_TAG}"

-fi

-

-REF_OPTION=""

-if [ -n "${SOURCE_REF}" ]; then

-  REF_OPTION="--ref ${SOURCE_REF}"

-fi

-

-BUILD_TEMP_DIR="${TEMP_DIR-$TMPDIR}"

-TMPDIR="${BUILD_TEMP_DIR}" sti build "${SOURCE_URI}" "${BUILDER_IMAGE}" "${TAG}" "${REF_OPTION}"

-

-if [ -n "${REGISTRY}" ] || [ -n "${DOCKER_REGISTRY}" ] || [ -s "/root/.dockercfg" ]; then

-  docker push "${TAG}"

-fi

new file mode 100644

@@ -0,0 +1,58 @@

+package cmd

+

+import (

+	"encoding/json"

+	"log"

+	"os"

+

+	"github.com/fsouza/go-dockerclient"

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

+	bld "github.com/openshift/origin/pkg/build/builder"

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

+	dockerutil "github.com/openshift/origin/pkg/cmd/util/docker"

+)

+

+const DefaultDockerEndpoint = "unix:///var/run/docker.sock"

+const DockerCfgFile = ".dockercfg"

+

+type builder interface {

+	Build() error

+}

+type factoryFunc func(

+	client bld.DockerClient,

+	dockerSocket string,

+	authConfig docker.AuthConfiguration,

+	authPresent bool,

+	build *api.Build) builder

+

+func run(builderFactory factoryFunc) {

+	client, endpoint, err := dockerutil.NewHelper().GetClient()

+	if err != nil {

+		log.Fatalf("Error obtaining docker client: %v", err)

+	}

+	buildStr := os.Getenv("BUILD")

+	build := api.Build{}

+	err = json.Unmarshal([]byte(buildStr), &build)

+	if err != nil {

+		log.Fatalf("Unable to parse build: %v", err)

+	}

+	authcfg, authPresent := dockercfg.NewHelper().GetDockerAuth(build.Parameters.Output.Registry)

+	b := builderFactory(client, endpoint, authcfg, authPresent, &build)

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

+		log.Fatalf("Build error: %v", err)

+	}

+}

+

+// RunDockerBuild creates a docker builder and runs its build

+func RunDockerBuild() {

+	run(func(client bld.DockerClient, sock string, auth docker.AuthConfiguration, present bool, build *api.Build) builder {

+		return bld.NewDockerBuilder(client, auth, present, build)

+	})

+}

+

+// RunSTIBuild creates a STI builder and runs its build

+func RunSTIBuild() {

+	run(func(client bld.DockerClient, sock string, auth docker.AuthConfiguration, present bool, build *api.Build) builder {

+		return bld.NewSTIBuilder(client, sock, auth, present, build)

+	})

+}

new file mode 100644

@@ -0,0 +1,4 @@

+// Package cmd contains the main entry point for the

+// docker and STI builders

+

+package cmd

new file mode 100644

@@ -0,0 +1,112 @@

+package dockercfg

+

+import (

+	"encoding/base64"

+	"encoding/json"

+	"io/ioutil"

+	"os"

+	"os/user"

+	"path/filepath"

+	"strings"

+

+	"github.com/fsouza/go-dockerclient"

+	"github.com/spf13/pflag"

+)

+

+//TODO: Remove this code once the methods in Kubernetes kubelet/dockertools/config.go are public

+

+// Default docker registry server

+const defaultRegistryServer = "https://index.docker.io/v1/"

+

+// Helper contains all the valid config options for reading the local dockercfg file

+type Helper struct {

+}

+

+// NewHelper creates a Flags object with the default values set.

+func NewHelper() *Helper {

+	return &Helper{}

+}

+

+// InstallFlags installs the Docker flag helper into a FlagSet with the default

+// options and default values from the Helper object.

+func (_ *Helper) InstallFlags(flags *pflag.FlagSet) {

+}

+

+// GetDockerAuth returns a valid Docker AuthConfiguration entry, and whether it was read

+// from the local dockercfg file

+func (_ *Helper) GetDockerAuth(registry string) (docker.AuthConfiguration, bool) {

+	var authCfg docker.AuthConfiguration

+	dockercfgPath := getDockercfgFile("")

+	if _, err := os.Stat(dockercfgPath); err != nil {

+		return authCfg, false

+	}

+	cfg, err := readDockercfg(dockercfgPath)

+	if err != nil {

+		return authCfg, false

+	}

+	server := registry

+	if server == "" {

+		server = defaultRegistryServer

+	}

+	entry, ok := cfg[server]

+	if !ok {

+		return authCfg, false

+	}

+	uname, pass, err := getCredentials(entry.Auth)

+	if err != nil {

+		return authCfg, false

+	}

+	authCfg.Username = uname

+	authCfg.Password = pass

+	return authCfg, true

+}

+

+// getDockercfgFile returns the path to the dockercfg file

+func getDockercfgFile(path string) string {

+	var cfgPath string

+	if path != "" {

+		cfgPath = path

+	} else if os.Getenv("DOCKERCFG_PATH") != "" {

+		cfgPath = os.Getenv("DOCKERCFG_PATH")

+	} else if currentUser, err := user.Current(); err == nil {

+		cfgPath = filepath.Join(currentUser.HomeDir, ".dockercfg")

+	}

+	return cfgPath

+}

+

+// authEntry is a single entry for a given server in a

+// .dockercfg file

+type authEntry struct {

+	Auth  string `json:auth`

+	Email string `json:email`

+}

+

+// dockercfg represents the contents of a .dockercfg file

+type dockercfg map[string]authEntry

+

+// readDockercfg reads the contents of a .dockercfg file into a map

+// with server name keys and AuthEntry values

+func readDockercfg(filePath string) (cfg dockercfg, err error) {

+	content, err := ioutil.ReadFile(filePath)

+	if err != nil {

+		return

+	}

+	cfg = dockercfg{}

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

+		return nil, err

+	}

+	return

+}

+

+// getCredentials parses an auth string inside a dockercfg file into

+// a username and password

+func getCredentials(auth string) (username, password string, err error) {

+	creds, err := base64.StdEncoding.DecodeString(auth)

+	if err != nil {

+		return

+	}

+	unamepass := strings.Split(string(creds), ":")

+	username = unamepass[0]

+	password = unamepass[1]

+	return

+}

new file mode 100644

@@ -0,0 +1,47 @@

+package dockercfg

+

+import (

+	"io/ioutil"

+	"os"

+	"testing"

+)

+

+func TestReadDockercfg(t *testing.T) {

+	content := "{\"test-server-1\":{\"auth\":\"my-auth\",\"email\":\"test@email.test.com\"}}"

+	tempfile, err := ioutil.TempFile("", "cfgtest")

+	if err != nil {

+		t.Fatalf("Unable to create temp file: %v", err)

+	}

+	defer os.Remove(tempfile.Name())

+	tempfile.WriteString(content)

+	tempfile.Close()

+

+	dockercfg, err := readDockercfg(tempfile.Name())

+	if err != nil {

+		t.Errorf("Received unexpected error reading dockercfg: %v", err)

+		return

+	}

+

+	auth, ok := dockercfg["test-server-1"]

+	if !ok {

+		t.Errorf("Expected entry test-server-1 not found in dockercfg")

+		return

+	}

+	if auth.Auth != "my-auth" {

+		t.Errorf("Unexpected Auth value: %s", auth.Auth)

+	}

+	if auth.Email != "test@email.test.com" {

+		t.Errorf("Unexpected Email value: %s", auth.Email)

+	}

+}

+

+func TestGetCredentials(t *testing.T) {

+	testStr := "dGVzdDpwYXNzd29yZA==" // test:password

+	uname, pass, err := getCredentials(testStr)

+	if err != nil {

+		t.Errorf("Unexpected error getting credentials: %v", err)

+	}

+	if uname != "test" && pass != "password" {

+		t.Errorf("Unexpected username and password: %s,%s", uname, pass)

+	}

+}

new file mode 100644

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

+// Package dockercfg contains a command helper to read .dockercfg files

+

+package dockercfg

new file mode 100644

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

+// Package builder contains builders for STI and Docker in Openshift Origin

+

+package builder

new file mode 100644

@@ -0,0 +1,157 @@

+package builder

+

+import (

+	"fmt"

+	"io/ioutil"

+	"net"

+	"net/url"

+	"os"

+	"path/filepath"

+	"strings"

+	"time"

+

+	"github.com/fsouza/go-dockerclient"

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

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

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

+)

+

+// urlCheckTimeout is the timeout used to check the source URL

+// If fetching the URL exceeeds the timeout, then the build will

+// not proceed further and stop

+const urlCheckTimeout = 16 * time.Second

+

+// DockerBuilder builds Docker images given a git repository URL

+type DockerBuilder struct {

+	dockerClient DockerClient

+	authPresent  bool

+	auth         docker.AuthConfiguration

+	git          git.Git

+	tar          tar.Tar

+	build        *api.Build

+	urlTimeout   time.Duration

+}

+

+// NewDockerBuilder creates a new instance of DockerBuilder

+func NewDockerBuilder(dockerClient DockerClient, authCfg docker.AuthConfiguration, authPresent bool, build *api.Build) *DockerBuilder {

+	return &DockerBuilder{

+		dockerClient: dockerClient,

+		authPresent:  authPresent,

+		auth:         authCfg,

+		build:        build,

+		git:          git.NewGit(),

+		tar:          tar.NewTar(false),

+		urlTimeout:   urlCheckTimeout,

+	}

+}

+

+// Build executes a Docker build

+func (d *DockerBuilder) Build() error {

+	buildDir, err := ioutil.TempDir("", "docker-build")

+	if err != nil {

+		return err

+	}

+	if err = d.fetchSource(buildDir); err != nil {

+		return err

+	}

+	if err = d.dockerBuild(buildDir); err != nil {

+		return err

+	}

+	if err = d.addImageVars(); err != nil {

+		return err

+	}

+	if d.build.Parameters.Output.Registry != "" || d.authPresent {

+		return pushImage(d.dockerClient, imageTag(d.build), d.auth)

+	}

+	return nil

+}

+

+// checkSourceURI performs a check on the URI associated with the build

+// to make sure that it is live before proceeding with the build.

+func (d *DockerBuilder) checkSourceURI() error {

+	rawurl := d.build.Parameters.Source.Git.URI

+	if !d.git.ValidCloneSpec(rawurl) {

+		return fmt.Errorf("Invalid git source url: %s", rawurl)

+	}

+	if strings.HasPrefix(rawurl, "git://") || strings.HasPrefix(rawurl, "git@") {

+		return nil

+	}

+	if !strings.HasPrefix(rawurl, "http://") && !strings.HasPrefix(rawurl, "https://") {

+		rawurl = fmt.Sprintf("https://%s", rawurl)

+	}

+	srcURL, err := url.Parse(rawurl)

+	if err != nil {

+		return err

+	}

+	host := srcURL.Host

+	if strings.Index(host, ":") == -1 {

+		switch srcURL.Scheme {

+		case "http":

+			host += ":80"

+		case "https":

+			host += ":443"

+		}

+	}

+	dialer := net.Dialer{Timeout: d.urlTimeout}

+	conn, err := dialer.Dial("tcp", host)

+	if err != nil {

+		return err

+	}

+	return conn.Close()

+

+}

+

+// fetchSource retrieves the git source from the repository. If a commit ID

+// is included in the build revision, that commit ID is checked out. Otherwise

+// if a ref is included in the source definition, that ref is checked out.

+func (d *DockerBuilder) fetchSource(dir string) error {

+	if err := d.checkSourceURI(); err != nil {

+		return err

+	}

+	if err := d.git.Clone(d.build.Parameters.Source.Git.URI, dir); err != nil {

+		return err

+	}

+	if d.build.Parameters.Source.Git.Ref == "" &&

+		(d.build.Parameters.Revision == nil ||

+			d.build.Parameters.Revision.Git == nil ||

+			d.build.Parameters.Revision.Git.Commit == "") {

+		return nil

+	}

+	if d.build.Parameters.Revision != nil &&

+		d.build.Parameters.Revision.Git != nil &&

+		d.build.Parameters.Revision.Git.Commit != "" {

+		return d.git.Checkout(dir, d.build.Parameters.Revision.Git.Commit)

+	}

+	return d.git.Checkout(dir, d.build.Parameters.Source.Git.Ref)

+}

+

+// dockerBuild performs a docker build on the source that has been retrieved

+func (d *DockerBuilder) dockerBuild(dir string) error {

+	if d.build.Parameters.Strategy.DockerStrategy != nil &&

+		d.build.Parameters.Strategy.DockerStrategy.ContextDir != "" {

+		dir = filepath.Join(dir, d.build.Parameters.Strategy.DockerStrategy.ContextDir)

+	}

+	return buildImage(d.dockerClient, dir, imageTag(d.build), d.tar)

+}

+

+// addImageVars creates a new Dockerfile which adds certain environment

+// variables to the previously tagged image

+func (d *DockerBuilder) addImageVars() error {

+	envVars := getBuildEnvVars(d.build)

+	tempDir, err := ioutil.TempDir("", "overlay")

+	if err != nil {

+		return err

+	}

+	overlay, err := os.Create(filepath.Join(tempDir, "Dockerfile"))

+	if err != nil {

+		return err

+	}

+	overlay.WriteString(fmt.Sprintf("FROM %s\n", imageTag(d.build)))

+	for k, v := range envVars {

+		overlay.WriteString(fmt.Sprintf("ENV %s %s\n", k, v))

+	}

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

+		return err

+	}

+	return buildImage(d.dockerClient, tempDir, imageTag(d.build), d.tar)

+}

new file mode 100644

@@ -0,0 +1,46 @@

+package builder

+

+import (

+	"os"

+

+	"github.com/fsouza/go-dockerclient"

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

+)

+

+// DockerClient is an interface to the Docker client that contains

+// the methods used by the common builder

+type DockerClient interface {

+	BuildImage(opts docker.BuildImageOptions) error

+	PushImage(opts docker.PushImageOptions, auth docker.AuthConfiguration) error

+}

+

+// pushImage pushes a docker image to the registry specified in its tag

+func pushImage(client DockerClient, name string, authConfig docker.AuthConfiguration) error {

+	repository, tag := docker.ParseRepositoryTag(name)

+	opts := docker.PushImageOptions{

+		Name:         repository,

+		Tag:          tag,

+		OutputStream: os.Stdout,

+	}

+	return client.PushImage(opts, authConfig)

+}

+

+// buildImage invokes a docker build on a particular directory

+func buildImage(client DockerClient, dir string, tag string, tar tar.Tar) error {

+	tarFile, err := tar.CreateTarFile("", dir)

+	if err != nil {

+		return err

+	}

+	tarStream, err := os.Open(tarFile)

+	if err != nil {

+		return err

+	}

+	defer tarStream.Close()

+	opts := docker.BuildImageOptions{

+		Name:           tag,

+		RmTmpContainer: true,

+		OutputStream:   os.Stdout,

+		InputStream:    tarStream,

+	}

+	return client.BuildImage(opts)

+}

new file mode 100644

@@ -0,0 +1,37 @@

+package builder

+

+import (

+	"testing"

+

+	"github.com/fsouza/go-dockerclient"

+)

+

+type FakeDocker struct {

+	pushImageFunc  func(opts docker.PushImageOptions, auth docker.AuthConfiguration) error

+	buildImageFunc func(opts docker.BuildImageOptions) error

+}

+

+func (d *FakeDocker) BuildImage(opts docker.BuildImageOptions) error {

+	if d.pushImageFunc != nil {

+		return d.buildImageFunc(opts)

+	}

+	return nil

+}

+

+func (d *FakeDocker) PushImage(opts docker.PushImageOptions, auth docker.AuthConfiguration) error {

+	if d.pushImageFunc != nil {

+		return d.pushImageFunc(opts, auth)

+	}

+	return nil

+}

+

+func TestDockerPush(t *testing.T) {

+	verifyFunc := func(opts docker.PushImageOptions, auth docker.AuthConfiguration) error {

+		if opts.Name != "test/image" {

+			t.Errorf("Unexpected image name: %s", opts.Name)

+		}

+		return nil

+	}

+	fd := &FakeDocker{pushImageFunc: verifyFunc}

+	pushImage(fd, "test/image", docker.AuthConfiguration{})

+}

new file mode 100644

@@ -0,0 +1,55 @@

+package builder

+

+import (

+	"github.com/fsouza/go-dockerclient"

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

+	"github.com/openshift/source-to-image/pkg/sti"

+)

+

+// STIBuilder performs an STI build given the build object

+type STIBuilder struct {

+	dockerClient DockerClient

+	dockerSocket string

+	authPresent  bool

+	auth         docker.AuthConfiguration

+	build        *api.Build

+}

+

+// NewSTIBuilder creates a new STIBuilder instance

+func NewSTIBuilder(client DockerClient, dockerSocket string, authCfg docker.AuthConfiguration, authPresent bool, build *api.Build) *STIBuilder {

+	return &STIBuilder{

+		dockerClient: client,

+		dockerSocket: dockerSocket,

+		authPresent:  authPresent,

+		auth:         authCfg,

+		build:        build,

+	}

+}

+

+// Build executes the STI build

+func (s *STIBuilder) Build() error {

+	request := &sti.STIRequest{

+		BaseImage:    s.build.Parameters.Strategy.STIStrategy.BuilderImage,

+		DockerSocket: s.dockerSocket,

+		Source:       s.build.Parameters.Source.Git.URI,

+		Tag:          imageTag(s.build),

+		Environment:  getBuildEnvVars(s.build),

+	}

+	if s.build.Parameters.Revision != nil && s.build.Parameters.Revision.Git != nil &&

+		s.build.Parameters.Revision.Git.Commit != "" {

+		request.Ref = s.build.Parameters.Revision.Git.Commit

+	} else if s.build.Parameters.Source.Git.Ref != "" {

+		request.Ref = s.build.Parameters.Source.Git.Ref

+	}

+	builder, err := sti.NewBuilder(request)

+	if err != nil {

+		return err

+	}

+	if _, err = builder.Build(); err != nil {

+		return err

+	}

+	if s.build.Parameters.Output.Registry != "" || s.authPresent {

+		return pushImage(s.dockerClient, imageTag(s.build), s.auth)

+	}

+	return nil

+}

new file mode 100644

@@ -0,0 +1,40 @@

+package builder

+

+import (

+	"fmt"

+	"strings"

+

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

+)

+

+type Builder interface {

+	Build() error

+}

+

+// imageTag returns the tag to be used for the build. If a registry has been

+// specified, it will prepend the registry to the name

+func imageTag(build *api.Build) string {

+	tag := build.Parameters.Output.ImageTag

+	if !strings.HasPrefix(tag, build.Parameters.Output.Registry) {

+		tag = fmt.Sprintf("%s/%s", build.Parameters.Output.Registry, tag)

+	}

+	return tag

+}

+

+// getBuildEnvVars returns a map with the environment variables that should be added

+// to the built image

+func getBuildEnvVars(build *api.Build) map[string]string {

+	envVars := map[string]string{

+		"OPENSHIFT_BUILD_NAME":   build.ID,

+		"OPENSHIFT_BUILD_SOURCE": build.Parameters.Source.Git.URI,

+	}

+	if build.Parameters.Source.Git.Ref != "" {

+		envVars["OPENSHIFT_BUILD_REFERENCE"] = build.Parameters.Source.Git.Ref

+	}

+	if build.Parameters.Revision != nil &&

+		build.Parameters.Revision.Git != nil &&

+		build.Parameters.Revision.Git.Commit != "" {

+		envVars["OPENSHIFT_BUILD_COMMIT"] = build.Parameters.Revision.Git.Commit

+	}

+	return envVars

+}

new file mode 100644

@@ -0,0 +1,90 @@

+package builder

+

+import (

+	"testing"

+

+	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

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

+)

+

+func TestImageTag(t *testing.T) {

+	type tagTest struct {

+		build    api.Build

+		expected string

+	}

+	tests := []tagTest{

+		{

+			build: api.Build{

+				Parameters: api.BuildParameters{

+					Output: api.BuildOutput{

+						ImageTag: "test/tag",

+					},

+				},

+			},

+			expected: "test/tag",

+		},

+		{