@@ -469,6 +469,7 @@ _oc_new-build()

     flags_completion=()

     flags+=("--allow-missing-images")

+    flags+=("--binary")

     flags+=("--code=")

     flags+=("--docker-image=")

     flags+=("--dockerfile=")

@@ -2277,6 +2277,7 @@ _openshift_cli_new-build()

     flags_completion=()

     flags+=("--allow-missing-images")

+    flags+=("--binary")

     flags+=("--code=")

     flags+=("--docker-image=")

     flags+=("--dockerfile=")

@@ -49,6 +49,7 @@ You can use '%[1]s status' to check the progress.`

 // NewCmdNewBuild implements the OpenShift cli new-build command

 func NewCmdNewBuild(fullName string, f *clientcmd.Factory, in io.Reader, out io.Writer) *cobra.Command {

 	config := newcmd.NewAppConfig()

+	config.ExpectToBuild = true

 	cmd := &cobra.Command{

 		Use:        "new-build (IMAGE | IMAGESTREAM | PATH | URL ...)",

@@ -78,6 +79,7 @@ func NewCmdNewBuild(fullName string, f *clientcmd.Factory, in io.Reader, out io.

 	cmd.Flags().VarP(&config.Environment, "env", "e", "Specify key value pairs of environment variables to set into resulting image.")

 	cmd.Flags().StringVar(&config.Strategy, "strategy", "", "Specify the build strategy to use if you don't want to detect (docker|source).")

 	cmd.Flags().StringVarP(&config.Dockerfile, "dockerfile", "D", "", "Specify the contents of a Dockerfile to build directly, implies --strategy=docker. Pass '-' to read from STDIN.")

+	cmd.Flags().BoolVar(&config.BinaryBuild, "binary", false, "Instead of expecting a source URL, set the build to expect binary contents. Will disable triggers.")

 	cmd.Flags().BoolVar(&config.OutputDocker, "to-docker", false, "Have the build output push to a Docker repository.")

 	cmd.Flags().StringP("labels", "l", "", "Label to set in all generated resources.")

 	cmd.Flags().BoolVar(&config.AllowMissingImages, "allow-missing-images", false, "If true, indicates that referenced Docker images that cannot be found locally or in a registry should still be used.")

@@ -335,7 +335,7 @@ func (o TagOptions) RunTag() error {

 			}

 			target.Spec.Tags[destTag] = targetRef

-			msg = fmt.Sprintf("Tag %s set up to track tag %s/%s.", o.ref, o.destNamespace[i], destNameAndTag)

+			msg = fmt.Sprintf("Tag %s set up to track tag %s/%s.", o.ref.Exact(), o.destNamespace[i], destNameAndTag)

 		} else {

 			// The user wants to delete a spec tag.

 			if _, ok := target.Spec.Tags[destTag]; !ok {

@@ -104,6 +104,8 @@ type SourceRef struct {

 	ContextDir string

 	DockerfileContents string

+

+	Binary bool

 }

 func urlWithoutRef(url url.URL) string {

@@ -138,22 +140,23 @@ func (r *SourceRef) BuildSource() (*buildapi.BuildSource, []buildapi.BuildTrigge

 			},

 		},

 	}

-	var source *buildapi.BuildSource

-	switch {

-	case r.URL != nil:

-		source = &buildapi.BuildSource{

-			Type: buildapi.BuildSourceGit,

-			Git: &buildapi.GitBuildSource{

-				URI: urlWithoutRef(*r.URL),

-				Ref: r.Ref,

-			},

-			ContextDir: r.ContextDir,

-		}

-	case len(r.DockerfileContents) != 0:

-		source = &buildapi.BuildSource{

-			Type:       buildapi.BuildSourceDockerfile,

-			Dockerfile: &r.DockerfileContents,

+	source := &buildapi.BuildSource{}

+

+	if len(r.DockerfileContents) != 0 {

+		source.Type = buildapi.BuildSourceDockerfile

+		source.Dockerfile = &r.DockerfileContents

+	}

+	if r.URL != nil {

+		source.Type = buildapi.BuildSourceGit

+		source.Git = &buildapi.GitBuildSource{

+			URI: urlWithoutRef(*r.URL),

+			Ref: r.Ref,

 		}

+		source.ContextDir = r.ContextDir

+	}

+	if r.Binary {

+		source.Type = buildapi.BuildSourceBinary

+		source.Binary = &buildapi.BinaryBuildSource{}

 	}

 	return source, triggers

 }

@@ -405,9 +408,9 @@ func (r *BuildRef) BuildConfig() (*buildapi.BuildConfig, error) {

 		return nil, fmt.Errorf("unable to suggest a name for this BuildConfig from %q", r.Source.URL)

 	}

 	var source *buildapi.BuildSource

-	sourceTriggers := []buildapi.BuildTriggerPolicy{}

+	triggers := []buildapi.BuildTriggerPolicy{}

 	if r.Source != nil {

-		source, sourceTriggers = r.Source.BuildSource()

+		source, triggers = r.Source.BuildSource()

 	}

 	if source == nil {

 		source = &buildapi.BuildSource{}

@@ -421,12 +424,14 @@ func (r *BuildRef) BuildConfig() (*buildapi.BuildConfig, error) {

 	if err != nil {

 		return nil, err

 	}

-	configChangeTrigger := buildapi.BuildTriggerPolicy{

-		Type: buildapi.ConfigChangeBuildTriggerType,

-	}

-	triggers := append(sourceTriggers, configChangeTrigger)

-	triggers = append(triggers, strategyTriggers...)

+	if source.Binary == nil {

+		configChangeTrigger := buildapi.BuildTriggerPolicy{

+			Type: buildapi.ConfigChangeBuildTriggerType,

+		}

+		triggers = append(triggers, configChangeTrigger)

+		triggers = append(triggers, strategyTriggers...)

+	}

 	return &buildapi.BuildConfig{

 		ObjectMeta: kapi.ObjectMeta{

@@ -57,10 +57,13 @@ type AppConfig struct {

 	Dockerfile string

-	Name               string

-	Strategy           string

-	InsecureRegistry   bool

-	OutputDocker       bool

+	Name             string

+	Strategy         string

+	InsecureRegistry bool

+	OutputDocker     bool

+

+	ExpectToBuild      bool

+	BinaryBuild        bool

 	AllowMissingImages bool

 	AsSearch bool

@@ -197,11 +200,12 @@ func (c *AppConfig) AddArguments(args []string) []string {

 // individualSourceRepositories collects the list of SourceRepositories specified in the

 // command line that are not associated with a builder using a '~'.

 func (c *AppConfig) individualSourceRepositories() (app.SourceRepositories, error) {

-	first := true

 	for _, s := range c.SourceRepositories {

-		if repo, ok := c.refBuilder.AddSourceRepository(s); ok && first {

+		if repo, ok := c.refBuilder.AddSourceRepository(s); ok {

 			repo.SetContextDir(c.ContextDir)

-			first = false

+			if c.Strategy == "docker" {

+				repo.BuildWithDocker()

+			}

 		}

 	}

 	if len(c.Dockerfile) > 0 {

@@ -305,6 +309,10 @@ func (c *AppConfig) validate() (app.ComponentReferences, app.SourceRepositories,

 		errs = append(errs, fmt.Errorf("when --strategy is specified you must provide at least one source code location"))

 	}

+	if c.BinaryBuild && (len(repos) > 0 || refs.HasSource()) {

+		errs = append(errs, fmt.Errorf("specifying binary builds and source repositories at the same time is not allowed"))

+	}

+

 	env, duplicateEnv, envErrs := cmdutil.ParseEnvironmentArguments(c.Environment)

 	for _, s := range duplicateEnv {

 		glog.V(1).Infof("The environment variable %q was overwritten", s)

@@ -394,18 +402,43 @@ func (c *AppConfig) resolve(components app.ComponentReferences) error {

 			errs = append(errs, err)

 			continue

 		}

+	}

+	return errors.NewAggregate(errs)

+}

+

+// searches on all references

+func (c *AppConfig) search(components app.ComponentReferences) error {

+	errs := []error{}

+	for _, ref := range components {

+		if err := ref.Search(); err != nil {

+			errs = append(errs, err)

+			continue

+		}

+	}

+	return errors.NewAggregate(errs)

+}

+

+// inferBuildTypes infers build status and mismatches between source and docker builders

+func (c *AppConfig) inferBuildTypes(components app.ComponentReferences) error {

+	errs := []error{}

+	for _, ref := range components {

 		input := ref.Input()

-		if !input.ExpectToBuild && input.ResolvedMatch.Builder {

-			if c.Strategy != "docker" {

-				input.ExpectToBuild = true

-			}

+		// if the strategy is explicitly Docker, all repos should assume docker

+		if c.Strategy == "docker" && input.Uses != nil {

+			input.Uses.BuildWithDocker()

+		}

+

+		// if we are expecting build inputs, or get a build input when strategy is not docker, expect to build

+		if c.ExpectToBuild || (input.ResolvedMatch.Builder && c.Strategy != "docker") {

+			input.ExpectToBuild = true

 		}

+

 		switch {

 		case input.ExpectToBuild && input.ResolvedMatch.IsTemplate():

 			// TODO: harder - break the template pieces and check if source code can be attached (look for a build config, build image, etc)

 			errs = append(errs, fmt.Errorf("template with source code explicitly attached is not supported - you must either specify the template and source code separately or attach an image to the source code using the '[image]~[code]' form"))

 			continue

-		case input.ExpectToBuild && !input.ResolvedMatch.Builder && !input.Uses.IsDockerBuild():

+		case input.ExpectToBuild && !input.ResolvedMatch.Builder && input.Uses != nil && !input.Uses.IsDockerBuild():

 			if len(c.Strategy) == 0 {

 				errs = append(errs, fmt.Errorf("the resolved match %q for component %q cannot build source code - check whether this is the image you want to use, then use --strategy=source to build using source or --strategy=docker to treat this as a Docker base image and set up a layered Docker build", input.ResolvedMatch.Name, ref))

 				continue

@@ -415,18 +448,7 @@ func (c *AppConfig) resolve(components app.ComponentReferences) error {

 			continue

 		}

 	}

-	return errors.NewAggregate(errs)

-}

-// searches on all references

-func (c *AppConfig) search(components app.ComponentReferences) error {

-	errs := []error{}

-	for _, ref := range components {

-		if err := ref.Search(); err != nil {

-			errs = append(errs, err)

-			continue

-		}

-	}

 	return errors.NewAggregate(errs)

 }

@@ -455,10 +477,33 @@ func (c *AppConfig) ensureHasSource(components app.ComponentReferences, reposito

 				repositories[0].UsedBy(component)

 			}

 		default:

-			for _, component := range components {

-				component.Input().ExpectToBuild = false

+			switch {

+			case c.BinaryBuild && c.ExpectToBuild:

+				// create new "fake" binary repos for any component that doesn't already have a repo

+				// TODO: source repository should possibly be refactored to be an interface or a type that better reflects

+				//   the different types of inputs

+				for _, component := range components {

+					input := component.Input()

+					if input.Uses != nil {

+						continue

+					}

+					repo := app.NewBinarySourceRepository()

+					if c.Strategy == "docker" || len(c.Strategy) == 0 {

+						repo.BuildWithDocker()

+					}

+					input.Use(repo)

+					repo.UsedBy(input)

+					input.ExpectToBuild = true

+				}

+			case c.ExpectToBuild:

+				return fmt.Errorf("you must specify at least one source repository URL, provide a Dockerfile, or indicate you wish to use binary builds")

+			default:

+				for _, component := range components {

+					component.Input().ExpectToBuild = false

+				}

 			}

 		}

+		glog.V(4).Infof("ensureHasSource: %#v", components[0])

 	}

 	return nil

 }

@@ -512,24 +557,25 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 	pipelines := app.PipelineGroup{}

 	names := map[string]int{}

 	for _, group := range components.Group() {

-		glog.V(2).Infof("found group: %#v", group)

+		glog.V(4).Infof("found group: %#v", group)

 		common := app.PipelineGroup{}

 		for _, ref := range group {

 			var pipeline *app.Pipeline

 			var name string

 			if ref.Input().ExpectToBuild {

-				glog.V(2).Infof("will use %q as the base image for a source build of %q", ref, ref.Input().Uses)

+				glog.V(4).Infof("will use %q as the base image for a source build of %q", ref, ref.Input().Uses)

 				input, err := app.InputImageFromMatch(ref.Input().ResolvedMatch)

 				if err != nil {

 					return nil, fmt.Errorf("can't build %q: %v", ref.Input(), err)

 				}

 				if !input.AsImageStream {

-					glog.Warningf("Could not find an ImageStream match for %q. Make sure that a Docker image with that tag is available on the node for the build to succeed.", ref.Input().ResolvedMatch.Value)

+					glog.Warningf("Could not find an image stream match for %q. Make sure that a Docker image with that tag is available on the node for the build to succeed.", ref.Input().ResolvedMatch.Value)

 				}

 				strategy, source, err := app.StrategyAndSourceForRepository(ref.Input().Uses, input)

 				if err != nil {

 					return nil, fmt.Errorf("can't build %q: %v", ref.Input(), err)

 				}

+

 				// Override resource names from the cli

 				name = c.Name

 				if len(name) == 0 {

@@ -546,7 +592,7 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 				}

 				// Append any exposed ports from Dockerfile to input image

-				if ref.Input().Uses.IsDockerBuild() {

+				if ref.Input().Uses.IsDockerBuild() && ref.Input().Uses.Info() != nil {

 					node := ref.Input().Uses.Info().Dockerfile.AST()

 					ports := dockerfileutil.LastExposedPorts(node)

 					if len(ports) > 0 {

@@ -564,8 +610,9 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 				if pipeline, err = app.NewBuildPipeline(ref.Input().String(), input, c.OutputDocker, strategy, c.GetBuildEnvironment(environment), source); err != nil {

 					return nil, fmt.Errorf("can't build %q: %v", ref.Input(), err)

 				}

+

 			} else {

-				glog.V(2).Infof("will include %q", ref)

+				glog.V(4).Infof("will include %q", ref)

 				input, err := app.InputImageFromMatch(ref.Input().ResolvedMatch)

 				if err != nil {

 					return nil, fmt.Errorf("can't include %q: %v", ref.Input(), err)

@@ -587,6 +634,7 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 					return nil, fmt.Errorf("can't include %q: %v", ref.Input(), err)

 				}

 			}

+

 			if err := pipeline.NeedsDeployment(environment, c.Labels, name); err != nil {

 				return nil, fmt.Errorf("can't set up a deployment for %q: %v", ref.Input(), err)

 			}

@@ -802,19 +850,26 @@ func (c *AppConfig) run(acceptors app.Acceptors) (*AppResult, error) {

 	if err != nil {

 		return nil, err

 	}

+

 	if err := c.resolve(components); err != nil {

 		return nil, err

 	}

+	if err := c.inferBuildTypes(components); err != nil {

+		return nil, err

+	}

+

 	// Couple source with resolved builder components if possible

 	if err := c.ensureHasSource(components.NeedsSource(), repositories.NotUsed()); err != nil {

 		return nil, err

 	}

+

 	// For source repos that are not yet coupled with a component, create components

 	sourceComponents, err := c.componentsForRepos(repositories.NotUsed())

 	if err != nil {

 		return nil, err

 	}

+

 	// resolve the source repo components

 	if err := c.resolve(sourceComponents); err != nil {

 		return nil, err

@@ -67,6 +67,11 @@ func (r ComponentReferences) filter(filterFunc func(ref ComponentReference) bool

 	return refs

 }

+// HasSource returns true if there is more than one component that has a repo associated

+func (r ComponentReferences) HasSource() bool {

+	return len(r.filter(func(ref ComponentReference) bool { return ref.Input().Uses != nil })) > 0

+}

+

 // NeedsSource returns all the components that need source code in order to build

 func (r ComponentReferences) NeedsSource() (refs ComponentReferences) {

 	return r.filter(func(ref ComponentReference) bool {

@@ -82,6 +82,7 @@ type SourceRepository struct {

 	usedBy           []ComponentReference

 	buildWithDocker  bool

 	ignoreRepository bool

+	binary           bool

 }

 // NewSourceRepository creates a reference to a local or remote source code repository from

@@ -114,6 +115,15 @@ func NewSourceRepositoryForDockerfile(contents string) (*SourceRepository, error

 	}, nil

 }

+// NewBinarySourceRepository creates a source repository that is configured for binary

+// input.

+func NewBinarySourceRepository() *SourceRepository {

+	return &SourceRepository{

+		binary:           true,

+		ignoreRepository: true,

+	}

+}

+

 // UsedBy sets up which component uses the source repository

 func (r *SourceRepository) UsedBy(ref ComponentReference) {

 	r.usedBy = append(r.usedBy, ref)

@@ -345,22 +355,22 @@ func StrategyAndSourceForRepository(repo *SourceRepository, image *ImageRef) (*B

 		Base:          image,

 		IsDockerBuild: repo.IsDockerBuild(),

 	}

-	var source *SourceRef

-	switch {

-	case repo.ignoreRepository && repo.Info() != nil && repo.Info().Dockerfile != nil:

-		source = &SourceRef{

-			DockerfileContents: repo.Info().Dockerfile.Contents(),

-		}

-	default:

+	source := &SourceRef{

+		Binary: repo.binary,

+	}

+

+	if repo.ignoreRepository && repo.Info() != nil && repo.Info().Dockerfile != nil {

+		source.DockerfileContents = repo.Info().Dockerfile.Contents()

+	}

+	if !repo.ignoreRepository {

 		remoteURL, err := repo.RemoteURL()

 		if err != nil {

 			return nil, nil, fmt.Errorf("cannot obtain remote URL for repository at %s", repo.location)

 		}

-		source = &SourceRef{

-			URL:        remoteURL,

-			Ref:        remoteURL.Fragment,

-			ContextDir: repo.ContextDir(),

-		}

+		source.URL = remoteURL

+		source.Ref = remoteURL.Fragment

+		source.ContextDir = repo.ContextDir()

 	}

+

 	return strategy, source, nil

 }

@@ -82,6 +82,12 @@ oc delete template ruby-helloworld-sample

 oc new-app https://github.com/openshift/ruby-hello-world -l app=ruby

 oc delete all -l app=ruby

+# check new-build

+[ "$(oc new-build mysql -o yaml 2>&1 | grep -F 'you must specify at least one source repository URL')" ]

+[ "$(oc new-build mysql --binary -o yaml | grep -F 'type: Binary')" ]

+[ "$(oc new-build mysql https://github.com/openshift/ruby-hello-world --strategy=docker -o yaml | grep -F 'type: Docker')" ]

+[ "$(oc new-build mysql https://github.com/openshift/ruby-hello-world --binary 2>&1 | grep -F 'specifying binary builds and source repositories at the same time is not allowed')" ]

+

 # do not allow use of non-existent image (should fail)

 [ "$(oc new-app  openshift/bogusImage https://github.com/openshift/ruby-hello-world.git -o yaml 2>&1 | grep "no image or template matched")" ]

 # allow use of non-existent image (should succeed)