@@ -347,6 +347,16 @@ echo "imageRepositoryMappings: ok"

 # the local image repository takes precedence over the Docker Hub "mysql" image

 [ "$(osc new-app mysql -o yaml | grep mysql-55-centos7)" ]

 osc new-app php mysql

+# check if we can create from a stored template

+osc create -f examples/sample-app/application-template-stibuild.json

+osc get template ruby-helloworld-sample

+[ "$(osc new-app ruby-helloworld-sample -o yaml | grep MYSQL_USER)" ]

+[ "$(osc new-app ruby-helloworld-sample -o yaml | grep MYSQL_PASSWORD)" ]

+[ "$(osc new-app ruby-helloworld-sample -o yaml | grep ADMIN_USERNAME)" ]

+[ "$(osc new-app ruby-helloworld-sample -o yaml | grep ADMIN_PASSWORD)" ]

+# create from template with code explicitly set is not supported

+[ ! "$(osc new-app ruby-helloworld-sample~git@github.com/mfojtik/sinatra-app-example)" ]

+osc delete template ruby-helloworld-sample

 echo "new-app: ok"

 osc get routes

@@ -41,6 +41,7 @@ type Interface interface {

 	RootResourceAccessReviews

 	SubjectAccessReviewsNamespacer

 	TemplatesNamespacer

+	TemplateConfigsNamespacer

 }

 // Builds provides a REST client for Builds

@@ -88,6 +88,10 @@ func (c *Fake) Templates(namespace string) TemplateInterface {

 	return &FakeTemplates{Fake: c}

 }

+func (c *Fake) TemplateConfigs(namespace string) TemplateConfigInterface {

+	return &FakeTemplateConfigs{Fake: c}

+}

+

 func (c *Fake) Identities() IdentityInterface {

 	return &FakeIdentities{Fake: c}

 }

new file mode 100644

@@ -0,0 +1,18 @@

+package client

+

+import (

+	configapi "github.com/openshift/origin/pkg/config/api"

+	templateapi "github.com/openshift/origin/pkg/template/api"

+)

+

+// FakeTemplateConfigs implements TemplateConfigsInterface. Meant to be embedded into a struct to get a default

+// implementation. This makes faking out just the methods you want to test easier.

+type FakeTemplateConfigs struct {

+	Fake      *Fake

+	Namespace string

+}

+

+func (c *FakeTemplateConfigs) Create(template *templateapi.Template) (*configapi.Config, error) {

+	obj, err := c.Fake.Invokes(FakeAction{Action: "create-template-config", Value: template}, &configapi.Config{})

+	return obj.(*configapi.Config), err

+}

@@ -30,9 +30,9 @@ var errExit = fmt.Errorf("exit directly")

 const newAppLongDesc = `

 Create a new application in OpenShift by specifying source code, templates, and/or images.

-This command will try to build up the components of an application using images or code

-located on your system. It will lookup the images on the local Docker installation (if

-available), a Docker registry, or an OpenShift image stream. If you specify a source

+This command will try to build up the components of an application using images, templates, 

+or code located on your system. It will lookup the images on the local Docker installation 

+(if available), a Docker registry, or an OpenShift image stream. If you specify a source

 code URL, it will set up a build that takes your source code and converts it into an

 image that can run inside of a pod. The images will be deployed via a deployment

 configuration, and a service will be hooked up to the first public port of the app.

@@ -51,6 +51,9 @@ Examples:

 	# Create an application from the remote repository using the specified label

 	$ %[1]s new-app https://github.com/openshift/ruby-hello-world -l name=hello-world

+	# Create an application based on a stored template, explicitly setting a parameter value

+	$ %[1]s new-app ruby-helloworld-sample --env=MYSQL_USER=admin

+

 If you specify source code, you may need to run a build with 'start-build' after the

 application is created.

@@ -80,12 +83,20 @@ func NewCmdNewApplication(fullName string, f *clientcmd.Factory, out io.Writer)

 	cmd.Flags().Var(&config.SourceRepositories, "code", "Source code to use to build this application.")

 	cmd.Flags().VarP(&config.ImageStreams, "image", "i", "Name of an OpenShift image stream to use in the app.")

 	cmd.Flags().Var(&config.DockerImages, "docker-image", "Name of a Docker image to include in the app.")

+	cmd.Flags().Var(&config.Templates, "template", "Name of an OpenShift stored template to use in the app.")

+	cmd.Flags().VarP(&config.TemplateParameters, "param", "p", "Specify a list of key value pairs (eg. -p FOO=BAR,BAR=FOO) to set/override parameter values in the template.")

 	cmd.Flags().Var(&config.Groups, "group", "Indicate components that should be grouped together as <comp1>+<comp2>.")

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

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

-	cmd.Flags().StringP("labels", "l", "", "Label to set in all resources for this application")

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

+	cmd.Flags().StringP("labels", "l", "", "Label to set in all resources for this application.")

-	cmdutil.AddPrinterFlags(cmd)

+	// TODO AddPrinterFlags disabled so that it doesn't conflict with our own "template" flag.

+	// Need a better solution.

+	// cmdutil.AddPrinterFlags(cmd)

+	cmd.Flags().StringP("output", "o", "", "Output format. One of: json|yaml|template|templatefile.")

+	cmd.Flags().String("output-version", "", "Output the formatted object with the given version (default api-version).")

+	cmd.Flags().Bool("no-headers", false, "When using the default output, don't print headers.")

+	cmd.Flags().String("output-template", "", "Template string or path to template file to use when -o=template or -o=templatefile.  The template format is golang templates [http://golang.org/pkg/text/template/#pkg-overview]")

 	return cmd

 }

@@ -126,7 +137,7 @@ func RunNewApplication(f *clientcmd.Factory, out io.Writer, c *cobra.Command, ar

 		}

 		if err == newcmd.ErrNoInputs {

 			// TODO: suggest things to the user

-			return cmdutil.UsageError(c, "You must specify one or more images, image streams, or source code locations to create an application.")

+			return cmdutil.UsageError(c, "You must specify one or more images, image streams, templates or source code locations to create an application.")

 		}

 		return err

 	}

@@ -20,27 +20,34 @@ import (

 	"github.com/openshift/origin/pkg/generate/dockerfile"

 	"github.com/openshift/origin/pkg/generate/source"

 	imageapi "github.com/openshift/origin/pkg/image/api"

+	"github.com/openshift/origin/pkg/template"

 )

 // AppConfig contains all the necessary configuration for an application

 type AppConfig struct {

 	SourceRepositories util.StringList

-	Components   util.StringList

-	ImageStreams util.StringList

-	DockerImages util.StringList

-	Groups       util.StringList

-	Environment  util.StringList

+	Components         util.StringList

+	ImageStreams       util.StringList

+	DockerImages       util.StringList

+	Templates          util.StringList

+	TemplateParameters util.StringList

+	Groups             util.StringList

+	Environment        util.StringList

 	TypeOfBuild string

 	dockerResolver      app.Resolver

 	imageStreamResolver app.Resolver

+	templateResolver    app.Resolver

 	searcher app.Searcher

 	detector app.Detector

 	typer runtime.ObjectTyper

+

+	osclient        client.Interface

+	originNamespace string

 }

 // UsageError is an interface for printing usage errors

@@ -70,19 +77,25 @@ func NewAppConfig(typer runtime.ObjectTyper) *AppConfig {

 // SetDockerClient sets the passed Docker client in the application configuration

 func (c *AppConfig) SetDockerClient(dockerclient *docker.Client) {

 	c.dockerResolver = app.DockerClientResolver{

-		Client: dockerclient,

-

+		Client:           dockerclient,

 		RegistryResolver: c.dockerResolver,

 	}

 }

 // SetOpenShiftClient sets the passed OpenShift client in the application configuration

 func (c *AppConfig) SetOpenShiftClient(osclient client.Interface, originNamespace string) {

+	c.osclient = osclient

+	c.originNamespace = originNamespace

 	c.imageStreamResolver = app.ImageStreamResolver{

 		Client:            osclient,

 		ImageStreamImages: osclient,

 		Namespaces:        []string{originNamespace, "default"},

 	}

+	c.templateResolver = app.TemplateResolver{

+		Client: osclient,

+		TemplateConfigsNamespacer: osclient,

+		Namespaces:                []string{originNamespace, "openshift", "default"},

+	}

 }

 // AddArguments converts command line arguments into the appropriate bucket based on what they look like

@@ -107,41 +120,54 @@ func (c *AppConfig) AddArguments(args []string) []string {

 }

 // validate converts all of the arguments on the config into references to objects, or returns an error

-func (c *AppConfig) validate() (app.ComponentReferences, []*app.SourceRepository, cmdutil.Environment, error) {

+func (c *AppConfig) validate() (app.ComponentReferences, []*app.SourceRepository, cmdutil.Environment, cmdutil.Environment, error) {

 	b := &app.ReferenceBuilder{}

 	for _, s := range c.SourceRepositories {

 		b.AddSourceRepository(s)

 	}

-	b.AddImages(c.DockerImages, func(input *app.ComponentInput) app.ComponentReference {

+	b.AddComponents(c.DockerImages, func(input *app.ComponentInput) app.ComponentReference {

 		input.Argument = fmt.Sprintf("--docker-image=%q", input.From)

 		input.Resolver = c.dockerResolver

 		return input

 	})

-	b.AddImages(c.ImageStreams, func(input *app.ComponentInput) app.ComponentReference {

+	b.AddComponents(c.ImageStreams, func(input *app.ComponentInput) app.ComponentReference {

 		input.Argument = fmt.Sprintf("--image=%q", input.From)

 		input.Resolver = c.imageStreamResolver

 		return input

 	})

-	b.AddImages(c.Components, func(input *app.ComponentInput) app.ComponentReference {

+	b.AddComponents(c.Templates, func(input *app.ComponentInput) app.ComponentReference {

+		input.Argument = fmt.Sprintf("--template=%q", input.From)

+		input.Resolver = c.templateResolver

+		return input

+	})

+	b.AddComponents(c.Components, func(input *app.ComponentInput) app.ComponentReference {

 		input.Resolver = app.PerfectMatchWeightedResolver{

 			app.WeightedResolver{Resolver: c.imageStreamResolver, Weight: 0.0},

+			app.WeightedResolver{Resolver: c.templateResolver, Weight: 0.0},

 			app.WeightedResolver{Resolver: c.dockerResolver, Weight: 2.0},

 		}

 		return input

 	})

 	b.AddGroups(c.Groups)

 	refs, repos, errs := b.Result()

+

 	if len(c.TypeOfBuild) != 0 && len(repos) == 0 {

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

 	}

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

-	for _, s := range duplicate {

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

+	for _, s := range duplicateEnv {

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

 	}

 	errs = append(errs, envErrs...)

-	return refs, repos, env, errors.NewAggregate(errs)

+	parms, duplicateParms, parmsErrs := cmdutil.ParseEnvironmentArguments(c.TemplateParameters)

+	for _, s := range duplicateParms {

+		glog.V(1).Infof("The template parameter %q was overwritten", s)

+	}

+	errs = append(errs, parmsErrs...)

+

+	return refs, repos, env, parms, errors.NewAggregate(errs)

 }

 // resolve the references to ensure they are all valid, and identify any images that don't match user input.

@@ -158,6 +184,10 @@ func (c *AppConfig) resolve(components app.ComponentReferences) error {

 				glog.Infof("Image %q is a builder, so a repository will be expected unless you also specify --build=docker", input)

 				input.ExpectToBuild = true

 			}

+		case input.ExpectToBuild && input.Match.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.Match.Builder:

 			if len(c.TypeOfBuild) == 0 {

 				errs = append(errs, fmt.Errorf("none of the images that match %q can build source code - check whether this is the image you want to use, then use --build=source to build using source or --build=docker to treat this as a Docker base image and set up a layered Docker build", ref))

@@ -283,7 +313,9 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

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

 		common := app.PipelineGroup{}

 		for _, ref := range group {

-

+			if !ref.Input().Match.IsImage() {

+				continue

+			}

 			var pipeline *app.Pipeline

 			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)

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

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

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

 				}

-

 			} else {

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

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

@@ -309,7 +340,6 @@ 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); err != nil {

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

 			}

@@ -324,6 +354,39 @@ func (c *AppConfig) buildPipelines(components app.ComponentReferences, environme

 	return pipelines, nil

 }

+// buildTemplates converts a set of resolved, valid references into references to template objects.

+func (c *AppConfig) buildTemplates(components app.ComponentReferences, environment app.Environment) ([]runtime.Object, error) {

+	objects := []runtime.Object{}

+

+	for _, ref := range components {

+		if !ref.Input().Match.IsTemplate() {

+			continue

+		}

+

+		tpl := ref.Input().Match.Template

+

+		glog.V(4).Infof("processing template %s/%s", c.originNamespace, tpl.Name)

+		for _, env := range environment.List() {

+			// only set environment values that match what's expected by the template.

+			if v := template.GetParameterByName(tpl, env.Name); v != nil {

+				v.Value = env.Value

+				v.Generate = ""

+				template.AddParameter(tpl, *v)

+			} else {

+				return nil, fmt.Errorf("unexpected parameter name %q", env.Name)

+			}

+		}

+

+		result, err := c.osclient.TemplateConfigs(c.originNamespace).Create(tpl)

+		if err != nil {

+			return nil, fmt.Errorf("error processing template %s/%s: %v", c.originNamespace, tpl.Name, err)

+		}

+

+		objects = append(objects, result.Items...)

+	}

+	return objects, nil

+}

+

 // ErrNoInputs is returned when no inputs are specified

 var ErrNoInputs = fmt.Errorf("no inputs provided")

@@ -337,14 +400,15 @@ type AppResult struct {

 // Run executes the provided config.

 func (c *AppConfig) Run(out io.Writer) (*AppResult, error) {

-	components, repositories, environment, err := c.validate()

+	components, repositories, environment, parameters, err := c.validate()

 	if err != nil {

 		return nil, err

 	}

 	hasSource := len(repositories) != 0

-	hasImages := len(components) != 0

-	if !hasSource && !hasImages {

+	hasComponents := len(components) != 0

+

+	if !hasSource && !hasComponents {

 		return nil, ErrNoInputs

 	}

@@ -357,7 +421,7 @@ func (c *AppConfig) Run(out io.Writer) (*AppResult, error) {

 	}

 	glog.V(4).Infof("Code %v", repositories)

-	glog.V(4).Infof("Images %v", components)

+	glog.V(4).Infof("Components %v", components)

 	// TODO: Source detection needs to happen before components

 	//       are validated and resolved.

@@ -386,6 +450,12 @@ func (c *AppConfig) Run(out io.Writer) (*AppResult, error) {

 	objects = app.AddServices(objects)

+	templateObjects, err := c.buildTemplates(components, app.Environment(parameters))

+	if err != nil {

+		return nil, err

+	}

+	objects = append(objects, templateObjects...)

+

 	buildNames := []string{}

 	for _, obj := range objects {

 		switch t := obj.(type) {

@@ -1,16 +1,20 @@

 package cmd

 import (

+	"fmt"

 	"reflect"

 	"testing"

 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"

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

+	"github.com/openshift/origin/pkg/generate/app"

 )

 func TestAddArguments(t *testing.T) {

 	tests := map[string]struct {

 		args       []string

 		env        util.StringList

+		parms      util.StringList

 		repos      util.StringList

 		components util.StringList

 		unknown    []string

@@ -31,9 +35,9 @@ func TestAddArguments(t *testing.T) {

 			unknown: []string{},

 		},

 		"mix 1": {

-			args:       []string{"git://server/repo.git", "mysql+ruby~git@test.server/repo.git", "env1=test"},

+			args:       []string{"git://server/repo.git", "mysql+ruby~git@test.server/repo.git", "env1=test", "ruby-helloworld-sample"},

 			repos:      util.StringList{"git://server/repo.git"},

-			components: util.StringList{"mysql+ruby~git@test.server/repo.git"},

+			components: util.StringList{"mysql+ruby~git@test.server/repo.git", "ruby-helloworld-sample"},

 			env:        util.StringList{"env1=test"},

 			unknown:    []string{},

 		},

@@ -64,6 +68,7 @@ func TestValidate(t *testing.T) {

 		componentValues     []string

 		sourceRepoLocations []string

 		env                 map[string]string

+		parms               map[string]string

 	}{

 		"components": {

 			cfg: AppConfig{

@@ -72,6 +77,7 @@ func TestValidate(t *testing.T) {

 			componentValues:     []string{"one", "two", "three/four"},

 			sourceRepoLocations: []string{},

 			env:                 map[string]string{},

+			parms:               map[string]string{},

 		},

 		"sourcerepos": {

 			cfg: AppConfig{

@@ -80,6 +86,7 @@ func TestValidate(t *testing.T) {

 			componentValues:     []string{},

 			sourceRepoLocations: []string{".", "/test/var/src", "https://server/repo.git"},

 			env:                 map[string]string{},

+			parms:               map[string]string{},

 		},

 		"envs": {

 			cfg: AppConfig{

@@ -88,6 +95,7 @@ func TestValidate(t *testing.T) {

 			componentValues:     []string{},

 			sourceRepoLocations: []string{},

 			env:                 map[string]string{"one": "first", "two": "second", "three": "third"},

+			parms:               map[string]string{},

 		},

 		"component+source": {

 			cfg: AppConfig{

@@ -96,6 +104,7 @@ func TestValidate(t *testing.T) {

 			componentValues:     []string{"one"},

 			sourceRepoLocations: []string{"https://server/repo.git"},

 			env:                 map[string]string{},

+			parms:               map[string]string{},

 		},

 		"components+source": {

 			cfg: AppConfig{

@@ -104,15 +113,17 @@ func TestValidate(t *testing.T) {

 			componentValues:     []string{"mysql", "ruby"},

 			sourceRepoLocations: []string{"git://github.com/namespace/repo.git"},

 			env:                 map[string]string{},

+			parms:               map[string]string{},

 		},

-		"components+env": {

+		"components+parms": {

 			cfg: AppConfig{

-				Components:  util.StringList{"mysql+php"},

-				Environment: util.StringList{"one=first", "two=second"},

+				Components:         util.StringList{"ruby-helloworld-sample"},

+				TemplateParameters: util.StringList{"one=first", "two=second"},

 			},

-			componentValues:     []string{"mysql", "php"},

+			componentValues:     []string{"ruby-helloworld-sample"},

 			sourceRepoLocations: []string{},

-			env: map[string]string{

+			env:                 map[string]string{},

+			parms: map[string]string{

 				"one": "first",

 				"two": "second",

 			},

@@ -120,7 +131,7 @@ func TestValidate(t *testing.T) {

 	}

 	for n, c := range tests {

-		cr, repos, env, err := c.cfg.validate()

+		cr, repos, env, parms, err := c.cfg.validate()

 		if err != nil {

 			t.Errorf("%s: Unexpected error: %v", n, err)

 		}

@@ -147,5 +158,69 @@ func TestValidate(t *testing.T) {

 				break

 			}

 		}

+		if len(parms) != len(c.parms) {

+			t.Errorf("%s: Template parameters don't match. Expected: %v, Got: %v", n, c.parms, parms)

+		}

+		for p, v := range parms {

+			if c.parms[p] != v {

+				t.Errorf("%s: Template parameters don't match. Expected: %v, Got: %v", n, c.parms, parms)

+				break

+			}

+		}

+	}

+}

+

+func TestBuildTemplates(t *testing.T) {

+	tests := map[string]struct {

+		templateName string

+		namespace    string

+		parms        map[string]string

+	}{

+		"simple": {

+			templateName: "first-stored-template",

+			namespace:    "default",

+			parms:        map[string]string{},

+		},

+	}

+

+	for n, c := range tests {

+		appCfg := AppConfig{}

+		appCfg.SetOpenShiftClient(&client.Fake{}, c.namespace)

+		appCfg.AddArguments([]string{c.templateName})

+		appCfg.TemplateParameters = util.StringList{}

+		for k, v := range c.parms {

+			appCfg.TemplateParameters.Set(fmt.Sprintf("%v=%v", k, v))

+		}

+

+		components, _, _, parms, err := appCfg.validate()

+		if err != nil {

+			t.Errorf("%s: Unexpected error: %v", n, err)

+		}

+		err = appCfg.resolve(components)

+		if err != nil {

+			t.Errorf("%s: Unexpected error: %v", n, err)

+		}

+		_, err = appCfg.buildTemplates(components, app.Environment(parms))

+		if err != nil {

+			t.Errorf("%s: Unexpected error: %v", n, err)

+		}

+		for _, component := range components {

+			match := component.Input().Match

+			if !match.IsTemplate() {

+				t.Errorf("%s: Expected template match, got: %v", n, match)

+			}

+			if c.templateName != match.Name {

+				t.Errorf("%s: Expected template name %q, got: %q", n, c.templateName, match.Name)

+			}

+			if len(parms) != len(c.parms) {

+				t.Errorf("%s: Template parameters don't match. Expected: %v, Got: %v", n, c.parms, parms)

+			}

+			for p, v := range parms {

+				if c.parms[p] != v {

+					t.Errorf("%s: Template parameters don't match. Expected: %v, Got: %v", n, c.parms, parms)

+					break

+				}

+			}

+		}

 	}

 }

@@ -108,6 +108,14 @@ func (m *ComponentMatch) String() string {

 	return m.Argument

 }

+func (m *ComponentMatch) IsImage() bool {

+	return m.Image != nil || m.ImageStream != nil

+}

+

+func (m *ComponentMatch) IsTemplate() bool {

+	return m.Template != nil

+}

+

 type Resolver interface {

 	// resolvers should return ErrMultipleMatches when more than one result could

 	// be construed as a match. Resolvers should set the score to 0.0 if this is a

@@ -240,7 +248,7 @@ type ReferenceBuilder struct {

 	group int

 }

-func (r *ReferenceBuilder) AddImages(inputs []string, fn func(*ComponentInput) ComponentReference) {

+func (r *ReferenceBuilder) AddComponents(inputs []string, fn func(*ComponentInput) ComponentReference) {

 	for _, s := range inputs {

 		for _, s := range strings.Split(s, "+") {

 			input, repo, err := NewComponentInput(s)

@@ -12,9 +12,9 @@ type ErrNoMatch struct {

 func (e ErrNoMatch) Error() string {

 	if len(e.qualifier) != 0 {

-		return fmt.Sprintf("no image matched %q: %s", e.value, e.qualifier)

+		return fmt.Sprintf("no image or template matched %q: %s", e.value, e.qualifier)

 	}

-	return fmt.Sprintf("no image matched %q", e.value)

+	return fmt.Sprintf("no image or template matched %q", e.value)

 }

 func (e ErrNoMatch) UsageError(commandName string) string {

@@ -34,14 +34,14 @@ type ErrMultipleMatches struct {

 }

 func (e ErrMultipleMatches) Error() string {

-	return fmt.Sprintf("multiple images matched %q: %d", e.Image, len(e.Matches))

+	return fmt.Sprintf("multiple images or templates matched %q: %d", e.Image, len(e.Matches))

 }

 func (e ErrMultipleMatches) UsageError(commandName string) string {

 	buf := &bytes.Buffer{}

 	for _, match := range e.Matches {

 		fmt.Fprintf(buf, "* %s %f\n", match.Description, match.Score)

-		fmt.Fprintf(buf, "  Use %[1]s to specify this image\n\n", match.Argument)

+		fmt.Fprintf(buf, "  Use %[1]s to specify this image or template\n\n", match.Argument)

 	}

 	return fmt.Sprintf(`

 The argument %[1]q could apply to the following Docker images or OpenShift image repositories:

new file mode 100644

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

+package app

+

+import (

+	"fmt"

+

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

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"

+	"github.com/golang/glog"

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

+)

+

+type TemplateResolver struct {

+	Client                    client.TemplatesNamespacer

+	TemplateConfigsNamespacer client.TemplateConfigsNamespacer

+	Namespaces                []string

+}

+

+func (r TemplateResolver) Resolve(value string) (*ComponentMatch, error) {

+	checked := util.NewStringSet()

+

+	for _, namespace := range r.Namespaces {

+		if checked.Has(namespace) {

+			continue

+		}

+

+		checked.Insert(namespace)

+

+		glog.V(4).Infof("checking template %s/%s", namespace, value)

+		repo, err := r.Client.Templates(namespace).Get(value)

+		if err != nil {

+			if errors.IsNotFound(err) {

+				continue

+			}

+			return nil, err

+		}

+

+		return &ComponentMatch{

+			Value:       value,

+			Argument:    fmt.Sprintf("--template=%q", value),

+			Name:        value,

+			Description: fmt.Sprintf("Template %s in project %s", repo.Name, repo.Namespace),

+			Score:       0,

+			Template:    repo,

+		}, nil

+	}

+	return nil, ErrNoMatch{value: value}

+}