@@ -2,6 +2,7 @@ package cmd

 import (

 	"fmt"

+	"io"

 	"io/ioutil"

 	"os"

 	"os/exec"

@@ -11,12 +12,15 @@ import (

 	"github.com/golang/glog"

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

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

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

 	"k8s.io/kubernetes/pkg/client/restclient"

 	"k8s.io/kubernetes/pkg/runtime"

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

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

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

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

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

 	"github.com/openshift/origin/pkg/client"

@@ -30,6 +34,7 @@ type builder interface {

 }

 type builderConfig struct {

+	out             io.Writer

 	build           *api.Build

 	sourceSecretDir string

 	dockerClient    *docker.Client

@@ -37,24 +42,30 @@ type builderConfig struct {

 	buildsClient    client.BuildInterface

 }

-func newBuilderConfigFromEnvironment() (*builderConfig, error) {

+func newBuilderConfigFromEnvironment(out io.Writer) (*builderConfig, error) {

 	cfg := &builderConfig{}

 	var err error

+	cfg.out = out

+

 	// build (BUILD)

 	buildStr := os.Getenv("BUILD")

 	glog.V(4).Infof("$BUILD env var is %s \n", buildStr)

 	cfg.build = &api.Build{}

-	if err = runtime.DecodeInto(kapi.Codecs.UniversalDecoder(), []byte(buildStr), cfg.build); err != nil {

+	if err := runtime.DecodeInto(kapi.Codecs.UniversalDecoder(), []byte(buildStr), cfg.build); err != nil {

 		return nil, fmt.Errorf("unable to parse build: %v", err)

 	}

+	if errs := validation.ValidateBuild(cfg.build); len(errs) > 0 {

+		return nil, errors.NewInvalid(unversioned.GroupKind{Kind: "Build"}, cfg.build.Name, errs)

+	}

+	glog.V(4).Infof("Build: %#v", cfg.build)

 	masterVersion := os.Getenv(api.OriginVersion)

 	thisVersion := version.Get().String()

 	if len(masterVersion) != 0 && masterVersion != thisVersion {

-		glog.Warningf("Master version %q does not match Builder image version %q", masterVersion, thisVersion)

+		fmt.Fprintf(cfg.out, "warning: OpenShift server version %q differs from this image %q\n", masterVersion, thisVersion)

 	} else {

-		glog.V(2).Infof("Master version %q, Builder version %q", masterVersion, thisVersion)

+		glog.V(4).Infof("Master version %q, Builder version %q", masterVersion, thisVersion)

 	}

 	// sourceSecretsDir (SOURCE_SECRET_PATH)

@@ -64,17 +75,17 @@ func newBuilderConfigFromEnvironment() (*builderConfig, error) {

 	// usually not set, defaults to docker socket

 	cfg.dockerClient, cfg.dockerEndpoint, err = dockerutil.NewHelper().GetClient()

 	if err != nil {

-		return nil, fmt.Errorf("error obtaining docker client: %v", err)

+		return nil, fmt.Errorf("no Docker configuration defined: %v", err)

 	}

 	// buildsClient (KUBERNETES_SERVICE_HOST, KUBERNETES_SERVICE_PORT)

 	clientConfig, err := restclient.InClusterConfig()

 	if err != nil {

-		return nil, fmt.Errorf("failed to get client config: %v", err)

+		return nil, fmt.Errorf("cannot connect to the server: %v", err)

 	}

 	osClient, err := client.New(clientConfig)

 	if err != nil {

-		return nil, fmt.Errorf("error obtaining OpenShift client: %v", err)

+		return nil, fmt.Errorf("failed to get client: %v", err)

 	}

 	cfg.buildsClient = osClient.Builds(cfg.build.Namespace)

@@ -82,10 +93,8 @@ func newBuilderConfigFromEnvironment() (*builderConfig, error) {

 }

 func (c *builderConfig) setupGitEnvironment() ([]string, error) {

-

-	gitSource := c.build.Spec.Source.Git

-

 	// For now, we only handle git. If not specified, we're done

+	gitSource := c.build.Spec.Source.Git

 	if gitSource == nil {

 		return []string{}, nil

 	}

@@ -131,7 +140,6 @@ func (c *builderConfig) setupGitEnvironment() ([]string, error) {

 // execute is responsible for running a build

 func (c *builderConfig) execute(b builder) error {

-

 	gitEnv, err := c.setupGitEnvironment()

 	if err != nil {

 		return err

@@ -142,14 +150,14 @@ func (c *builderConfig) execute(b builder) error {

 	if err != nil {

 		return fmt.Errorf("failed to retrieve cgroup limits: %v", err)

 	}

-	glog.V(2).Infof("Running build with cgroup limits: %#v", *cgLimits)

+	glog.V(4).Infof("Running build with cgroup limits: %#v", *cgLimits)

 	if err := b.Build(c.dockerClient, c.dockerEndpoint, c.buildsClient, c.build, gitClient, cgLimits); err != nil {

 		return fmt.Errorf("build error: %v", err)

 	}

 	if c.build.Spec.Output.To == nil || len(c.build.Spec.Output.To.Name) == 0 {

-		glog.Warning("Build does not have an Output defined, no output image was pushed to a registry.")

+		fmt.Fprintf(c.out, "Build complete, no image push requested\n")

 	}

 	return nil

@@ -194,23 +202,20 @@ func (s2iBuilder) Build(dockerClient bld.DockerClient, sock string, buildsClient

 	return bld.NewS2IBuilder(dockerClient, sock, buildsClient, build, gitClient, cgLimits).Build()

 }

-func runBuild(builder builder) {

-	cfg, err := newBuilderConfigFromEnvironment()

+func runBuild(out io.Writer, builder builder) error {

+	cfg, err := newBuilderConfigFromEnvironment(out)

 	if err != nil {

-		glog.Fatalf("Cannot setup builder configuration: %v", err)

-	}

-	err = cfg.execute(builder)

-	if err != nil {

-		glog.Fatalf("Error: %v", err)

+		return err

 	}

+	return cfg.execute(builder)

 }

 // RunDockerBuild creates a docker builder and runs its build

-func RunDockerBuild() {

-	runBuild(dockerBuilder{})

+func RunDockerBuild(out io.Writer) error {

+	return runBuild(out, dockerBuilder{})

 }

 // RunSTIBuild creates a STI builder and runs its build

-func RunSTIBuild() {

-	runBuild(s2iBuilder{})

+func RunSTIBuild(out io.Writer) error {

+	return runBuild(out, s2iBuilder{})

 }

@@ -217,7 +217,6 @@ func (t *basicAuthTransport) RoundTrip(req *http.Request) (*http.Response, error

 }

 func startProxy(dir string, sourceURL *url.URL, username, password string) (*url.URL, error) {

-

 	// Setup the targetURL of the proxy to be the host of the original URL

 	targetURL := &url.URL{

 		Scheme: sourceURL.Scheme,

@@ -71,6 +71,10 @@ func getDockerNetworkMode() s2iapi.DockerNetworkMode {

 func GetCGroupLimits() (*s2iapi.CGroupLimits, error) {

 	byteLimit, err := readInt64("/sys/fs/cgroup/memory/memory.limit_in_bytes")

 	if err != nil {

+		// for systems without cgroups builds should succeed

+		if _, err := os.Stat("/sys/fs/cgroup"); os.IsNotExist(err) {

+			return &s2iapi.CGroupLimits{}, nil

+		}

 		return nil, fmt.Errorf("cannot determine cgroup limits: %v", err)

 	}

 	// math.MaxInt64 seems to give cgroups trouble, this value is

@@ -3,6 +3,8 @@ package builder

 import (

 	"github.com/spf13/cobra"

+	kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"

+

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

 	"github.com/openshift/origin/pkg/version"

 )

@@ -28,7 +30,8 @@ func NewCommandSTIBuilder(name string) *cobra.Command {

 		Short: "Run a Source-to-Image build",

 		Long:  stiBuilderLong,

 		Run: func(c *cobra.Command, args []string) {

-			cmd.RunSTIBuild()

+			err := cmd.RunSTIBuild(c.Out())

+			kcmdutil.CheckErr(err)

 		},

 	}

@@ -43,7 +46,8 @@ func NewCommandDockerBuilder(name string) *cobra.Command {

 		Short: "Run a Docker build",

 		Long:  dockerBuilderLong,

 		Run: func(c *cobra.Command, args []string) {

-			cmd.RunDockerBuild()

+			err := cmd.RunDockerBuild(c.Out())

+			kcmdutil.CheckErr(err)

 		},

 	}

 	cmd.AddCommand(version.NewVersionCommand(name, false))

@@ -30,7 +30,7 @@ var _ = g.Describe("[builds][Conformance] build without output image", func() {

 				fmt.Fprintln(g.GinkgoWriter, out)

 			}

 			o.Expect(err).NotTo(o.HaveOccurred())

-			o.Expect(out).Should(o.ContainSubstring(`Build does not have an Output defined, no output image was pushed to a registry.`))

+			o.Expect(out).Should(o.ContainSubstring(`Build complete, no image push requested`))

 		})

 		g.It(fmt.Sprintf("should create an image from %q S2i template without an output image reference defined", s2iImageFixture), func() {

@@ -43,7 +43,7 @@ var _ = g.Describe("[builds][Conformance] build without output image", func() {

 				fmt.Fprintln(g.GinkgoWriter, out)

 			}

 			o.Expect(err).NotTo(o.HaveOccurred())

-			o.Expect(out).Should(o.ContainSubstring(`Build does not have an Output defined, no output image was pushed to a registry.`))

+			o.Expect(out).Should(o.ContainSubstring(`Build complete, no image push requested`))

 		})

 	})

 })