deleted file mode 100644

@@ -1,189 +0,0 @@

-package main

-

-import (

-	"fmt"

-	"os"

-

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

-	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

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

-	"github.com/spf13/cobra"

-

-	"github.com/openshift/origin/pkg/api/latest"

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

-	"github.com/openshift/origin/pkg/cmd/util/clientcmd"

-	dh "github.com/openshift/origin/pkg/cmd/util/docker"

-	config "github.com/openshift/origin/pkg/config/api"

-	appgen "github.com/openshift/origin/pkg/generate/app"

-	gen "github.com/openshift/origin/pkg/generate/generator"

-	"github.com/openshift/origin/pkg/generate/imageinfo"

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

-)

-

-type Input struct {

-	name,

-	sourceDir,

-	sourceURL,

-	dockerContext,

-	builderImage,

-	outputImage string

-}

-

-func main() {

-	cfg := clientcmd.NewConfig()

-	dockerHelper := dh.NewHelper()

-	input := Input{}

-	cmd := &cobra.Command{

-		Use:   fmt.Sprintf("%s%s", "gen-app", clientcmd.ConfigSyntax),

-		Short: "Generate an application configuration",

-		Long:  "Generate an application configuration",

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

-			_, osClient, err := cfg.Clients()

-			if err != nil {

-				osClient = nil

-			}

-			dockerClient, _, err := dockerHelper.GetClient()

-			if err != nil {

-				osClient = nil

-			}

-			GenerateApp(input, osClient, dockerClient)

-		},

-	}

-

-	flag := cmd.Flags()

-	flag.StringVar(&input.name, "name", "", "Set name to use for generated application artifacts")

-	flag.StringVar(&input.sourceDir, "source-dir", "", "Set the source directory for the application build")

-	flag.StringVar(&input.sourceURL, "source-url", "", "Set the source URL")

-	flag.StringVar(&input.dockerContext, "context", "", "Context path for Dockerfile if creating a Docker build")

-	flag.StringVar(&input.builderImage, "builder-image", "", "Image to use for STI build")

-	flag.StringVar(&input.outputImage, "output-image", "", "Image name to use for output")

-	cfg.Bind(flag)

-	dockerHelper.InstallFlags(flag)

-	if err := cmd.Execute(); err != nil {

-		fmt.Fprintf(os.Stderr, "Error: %s", err)

-		os.Exit(1)

-	}

-}

-

-func GenerateApp(input Input, client client.Interface, dockerClient *docker.Client) {

-	// Get a SourceRef

-	var srcRef *appgen.SourceRef

-	var err error

-	srcRefGen := gen.NewSourceRefGenerator()

-	if len(input.sourceURL) > 0 {

-		if srcRef, err = srcRefGen.FromGitURL(input.sourceURL); err != nil {

-			exitWithError(err)

-		}

-	} else {

-		if len(input.sourceDir) == 0 {

-			if input.sourceDir, err = os.Getwd(); err != nil {

-				exitWithError(err)

-			}

-		}

-		if srcRef, err = srcRefGen.FromDirectory(input.sourceDir); err != nil {

-			exitWithError(err)

-		}

-	}

-

-	// Get a BuildStrategyRef

-	var strategyRef *appgen.BuildStrategyRef

-	strategyRefGen := gen.NewBuildStrategyRefGenerator(source.DefaultDetectors)

-	imageRefGen := gen.NewImageRefGenerator()

-	if len(input.dockerContext) > 0 {

-		if strategyRef, err = strategyRefGen.FromSourceRefAndDockerContext(*srcRef, input.dockerContext); err != nil {

-			exitWithError(err)

-		}

-	} else if len(input.builderImage) > 0 {

-		builderRef, err := imageRefGen.FromName(input.builderImage)

-		if err != nil {

-			exitWithError(err)

-		}

-		if strategyRef, err = strategyRefGen.FromSTIBuilderImage(builderRef); err != nil {

-			exitWithError(err)

-		}

-	} else {

-		if strategyRef, err = strategyRefGen.FromSourceRef(*srcRef); err != nil {

-			exitWithError(err)

-		}

-	}

-

-	// Get an ImageRef for Output

-	outputImage := input.outputImage

-	if len(outputImage) == 0 {

-		var ok bool

-		if outputImage, ok = srcRef.SuggestName(); !ok {

-			exitWithError(fmt.Errorf("Cannot suggest a name for the output image, please specify one in the command line"))

-		}

-	}

-	outputRef, err := imageRefGen.FromName(outputImage)

-	if err != nil {

-		exitWithError(err)

-	}

-

-	// Get a BuildRef

-	buildRef := appgen.BuildRef{

-		Source:   srcRef,

-		Strategy: strategyRef,

-		Output:   outputRef,

-	}

-

-	// Get a DeploymentConfigRef

-	var imageInfoRetriever imageinfo.Retriever

-	if client != nil {

-		imageInfoRetriever = imageinfo.NewRetriever(

-			client.ImageRepositories(kapi.NamespaceAll),

-			client.Images(kapi.NamespaceAll),

-			dockerClient)

-	} else {

-		imageInfoRetriever = imageinfo.NewRetriever(nil, nil, dockerClient)

-	}

-	imageInfoGenerator := gen.NewImageInfoGenerator(imageInfoRetriever)

-	imageInfos := imageInfoGenerator.FromImageRefs([]appgen.ImageRef{*outputRef})

-	deployRef := appgen.DeploymentConfigRef{

-		Images: imageInfos,

-	}

-

-	// Generate OpenShift resources

-	config := config.Config{}

-	bldcfg, err := buildRef.BuildConfig()

-	if err != nil {

-		exitWithError(err)

-	}

-	imgrepo, err := outputRef.ImageRepository()

-	if err != nil {

-		exitWithError(err)

-	}

-	deploycfg, err := deployRef.DeploymentConfig()

-	if err != nil {

-		exitWithError(err)

-	}

-	addToConfig(&config, bldcfg)

-	addToConfig(&config, imgrepo)

-	addToConfig(&config, deploycfg)

-

-	if strategyRef.Base != nil {

-		baserepo, err := strategyRef.Base.ImageRepository()

-		if err == nil {

-			addToConfig(&config, baserepo)

-		}

-	}

-

-	result, err := latest.Codec.Encode(&config)

-	if err != nil {

-		exitWithError(err)

-	}

-	fmt.Println(string(result))

-}

-

-func exitWithError(err error) {

-	fmt.Fprintf(os.Stderr, "%v", err)

-	os.Exit(1)

-}

-

-func addToConfig(cfg *config.Config, object runtime.Object) {

-	json, err := latest.Codec.Encode(object)

-	if err != nil {

-		exitWithError(err)

-	}

-	cfg.Items = append(cfg.Items, runtime.RawExtension{RawJSON: json})

-}

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

 	"github.com/spf13/pflag"

 	"github.com/openshift/origin/pkg/cmd/cli/cmd"

-	cmdnew "github.com/openshift/origin/pkg/cmd/cli/cmd/new"

 )

 const longDesc = `

@@ -47,7 +46,7 @@ func NewCommandCLI(name, fullName string) *cobra.Command {

 	clientcmd.DefaultCluster.Server = defaultClusterURL

 	// TODO: there should be two client configs, one for OpenShift, and one for Kubernetes

-	clientConfig := defaultClientConfig(cmds.PersistentFlags())

+	clientConfig := DefaultClientConfig(cmds.PersistentFlags())

 	f := cmd.NewFactory(clientConfig)

 	f.BindFlags(cmds.PersistentFlags())

 	out := os.Stdout

@@ -65,6 +64,7 @@ func NewCommandCLI(name, fullName string) *cobra.Command {

 	cmds.AddCommand(f.NewCmdProxy(out))

 	// Origin commands

+	// cmds.AddCommand(cmd.NewCmdNewApplication(f, out))

 	cmds.AddCommand(cmd.NewCmdProcess(f, out))

 	// Origin build commands

@@ -82,7 +82,7 @@ func NewCommandCLI(name, fullName string) *cobra.Command {

 func NewCmdKubectl(name string) *cobra.Command {

 	flags := pflag.NewFlagSet("", pflag.ContinueOnError)

 	clientcmd.DefaultCluster.Server = defaultClusterURL

-	clientConfig := defaultClientConfig(flags)

+	clientConfig := DefaultClientConfig(flags)

 	f := cmd.NewFactory(clientConfig)

 	cmd := f.NewKubectlCommand(os.Stdout)

 	cmd.Use = name

@@ -110,7 +110,7 @@ func applyToCreate(dst *cobra.Command) *cobra.Command {

 }

 // Copy of kubectl/cmd/DefaultClientConfig, using NewNonInteractiveDeferredLoadingClientConfig

-func defaultClientConfig(flags *pflag.FlagSet) clientcmd.ClientConfig {

+func DefaultClientConfig(flags *pflag.FlagSet) clientcmd.ClientConfig {

 	loadingRules := clientcmd.NewClientConfigLoadingRules()

 	loadingRules.EnvVarPath = os.Getenv(clientcmd.RecommendedConfigPathEnvVar)

 	flags.StringVar(&loadingRules.CommandLinePath, "kubeconfig", "", "Path to the kubeconfig file to use for CLI requests.")

deleted file mode 100644

@@ -1,323 +0,0 @@

-package new

-

-import (

-	"fmt"

-	"sort"

-	"strings"

-

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

-

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

-	template "github.com/openshift/origin/pkg/template/api"

-)

-

-// isComponentReference returns true if the provided string appears to be a reference to a source repository

-// on disk, at a URL, a docker image name (which might be on a Docker registry or an OpenShift image stream),

-// or a template.

-func isComponentReference(s string) bool {

-	if len(s) == 0 {

-		return false

-	}

-	all := strings.Split(s, "+")

-	_, _, _, err := componentWithSource(all[0])

-	return err == nil

-}

-

-func componentWithSource(s string) (component, repo string, builder bool, err error) {

-	if strings.Contains(s, "~") {

-		segs := strings.SplitN(s, "~", 2)

-		if len(segs) == 2 {

-			builder = true

-			switch {

-			case len(segs[0]) == 0:

-				err = fmt.Errorf("when using '[image]~[code]' form for %q, you must specify a image name", s)

-				return

-			case len(segs[1]) == 0:

-				component = segs[0]

-			default:

-				component = segs[0]

-				repo = segs[1]

-			}

-		}

-	} else {

-		component = s

-	}

-	// TODO: component must be of the form compatible with a pull spec *or* <namespace>/<name>

-	if !image.IsPullSpec(component) {

-		return "", "", false, fmt.Errorf("%q is not a valid Docker pull specification", component)

-	}

-	return

-}

-

-type ComponentReference interface {

-	Input() *ComponentInput

-	// Sets Input.Match or returns an error

-	Resolve() error

-	NeedsSource() bool

-}

-

-type ComponentReferences []ComponentReference

-

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

-	for _, ref := range r {

-		if ref.NeedsSource() {

-			refs = append(refs, ref)

-		}

-	}

-	return

-}

-

-type GroupedComponentReferences ComponentReferences

-

-func (m GroupedComponentReferences) Len() int      { return len(m) }

-func (m GroupedComponentReferences) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

-func (m GroupedComponentReferences) Less(i, j int) bool {

-	return m[i].Input().Group < m[j].Input().Group

-}

-

-func (r ComponentReferences) Group() (refs []ComponentReferences) {

-	sorted := make(GroupedComponentReferences, len(r))

-	copy(sorted, r)

-	sort.Sort(sorted)

-	group := -1

-	for _, ref := range sorted {

-		if ref.Input().Group != group {

-			refs = append(refs, ComponentReferences{})

-		}

-		group = ref.Input().Group

-		refs[len(refs)-1] = append(refs[len(refs)-1], ref)

-	}

-	return

-}

-

-type ComponentMatch struct {

-	Value       string

-	Argument    string

-	Name        string

-	Description string

-	Score       float32

-

-	Builder     bool

-	Image       *docker.Image

-	ImageStream *image.ImageRepository

-	ImageTag    string

-	Template    *template.Template

-}

-

-func (m *ComponentMatch) String() string {

-	return m.Argument

-}

-

-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

-	// perfect match, and to higher values the less adequate the match is.

-	Resolve(value string) (*ComponentMatch, error)

-}

-

-type ScoredComponentMatches []*ComponentMatch

-

-func (m ScoredComponentMatches) Len() int           { return len(m) }

-func (m ScoredComponentMatches) Swap(i, j int)      { m[i], m[j] = m[j], m[i] }

-func (m ScoredComponentMatches) Less(i, j int) bool { return m[i].Score < m[j].Score }

-

-type WeightedResolver struct {

-	Resolver

-	Weight float32

-}

-

-// PerfectMatchWeightedResolver returns only matches from resolvers that are identified as exact

-// (weight 0.0), and only matches from those resolvers that qualify as exact (score = 0.0). If no

-// perfect matches exist, an ErrMultipleMatches is returned indicating the remaining candidate(s).

-// Note that this metchod may resolve ErrMultipleMatches with a single match, indicating an error

-// (no perfect match) but with only one candidate.

-type PerfectMatchWeightedResolver []WeightedResolver

-

-func (r PerfectMatchWeightedResolver) Resolve(value string) (*ComponentMatch, error) {

-	match, err := WeightedResolvers(r).Resolve(value)

-	if err != nil {

-		if multiple, ok := err.(ErrMultipleMatches); ok {

-			sort.Sort(ScoredComponentMatches(multiple.matches))

-			if multiple.matches[0].Score == 0.0 && (len(multiple.matches) == 1 || multiple.matches[1].Score != 0.0) {

-				return multiple.matches[0], nil

-			}

-		}

-		return nil, err

-	}

-	if match.Score != 0.0 {

-		return nil, ErrMultipleMatches{value, []*ComponentMatch{match}}

-	}

-	return match, nil

-}

-

-type WeightedResolvers []WeightedResolver

-

-func (r WeightedResolvers) Resolve(value string) (*ComponentMatch, error) {

-	candidates := []*ComponentMatch{}

-	errs := []error{}

-	for _, resolver := range r {

-		match, err := resolver.Resolve(value)

-		if err != nil {

-			if multiple, ok := err.(ErrMultipleMatches); ok {

-				for _, match := range multiple.matches {

-					if resolver.Weight != 0.0 {

-						match.Score = match.Score * resolver.Weight

-					}

-					candidates = append(candidates, match)

-				}

-				continue

-			}

-			if _, ok := err.(ErrNoMatch); ok {

-				continue

-			}

-			errs = append(errs, err)

-			continue

-		}

-		candidates = append(candidates, match)

-	}

-	switch len(candidates) {

-	case 0:

-		return nil, ErrNoMatch{value: value}

-	case 1:

-		return candidates[0], nil

-	default:

-		return nil, ErrMultipleMatches{value, candidates}

-	}

-}

-

-type ReferenceBuilder struct {

-	refs  ComponentReferences

-	repos []*SourceRepository

-	errs  []error

-	group int

-}

-

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

-	for _, s := range inputs {

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

-			input, repo, err := NewComponentInput(s)

-			if err != nil {

-				r.errs = append(r.errs, err)

-				continue

-			}

-			input.Group = r.group

-			ref := fn(input)

-			if len(repo) != 0 {

-				repository, ok := r.AddSourceRepository(repo)

-				if !ok {

-					continue

-				}

-				input.Use(repository)

-				repository.UsedBy(ref)

-			}

-			r.refs = append(r.refs, ref)

-		}

-		r.group++

-	}

-}

-

-func (r *ReferenceBuilder) AddGroups(inputs []string) {

-	for _, s := range inputs {

-		groups := strings.Split(s, "+")

-		if len(groups) == 1 {

-			r.errs = append(r.errs, fmt.Errorf("group %q only contains a single name", s))

-			continue

-		}

-		to := -1

-		for _, group := range groups {

-			var match ComponentReference

-			for _, ref := range r.refs {

-				if group == ref.Input().Value {

-					match = ref

-					break

-				}

-			}

-			if match == nil {

-				r.errs = append(r.errs, fmt.Errorf("the name %q from the group definition is not in use, and can't be used", group))

-				break

-			}

-			if to == -1 {

-				to = match.Input().Group

-			} else {

-				match.Input().Group = to

-			}

-		}

-	}

-}

-

-func (r *ReferenceBuilder) AddSourceRepository(input string) (*SourceRepository, bool) {

-	for _, existing := range r.repos {

-		if input == existing.location {

-			return existing, true

-		}

-	}

-	source, err := NewSourceRepository(input)

-	if err != nil {

-		r.errs = append(r.errs, err)

-		return nil, false

-	}

-	r.repos = append(r.repos, source)

-	return source, true

-}

-

-func (r *ReferenceBuilder) Result() (ComponentReferences, []*SourceRepository, []error) {

-	return r.refs, r.repos, r.errs

-}

-

-func NewComponentInput(input string) (*ComponentInput, string, error) {

-	// check for image using [image]~ (to indicate builder) or [image]~[code] (builder plus code)

-	component, repo, builder, err := componentWithSource(input)

-	if err != nil {

-		return nil, "", err

-	}

-	return &ComponentInput{

-		From:          input,

-		Argument:      input,

-		Value:         component,

-		ExpectToBuild: builder,

-	}, repo, nil

-}

-

-type ComponentInput struct {

-	Group         int

-	From          string

-	Argument      string

-	Value         string

-	ExpectToBuild bool

-

-	Uses  *SourceRepository

-	Match *ComponentMatch

-

-	Resolver

-}

-

-func (i *ComponentInput) Input() *ComponentInput {

-	return i

-}

-

-func (i *ComponentInput) NeedsSource() bool {

-	return i.ExpectToBuild && i.Uses == nil

-}

-

-func (i *ComponentInput) Resolve() error {

-	if i.Resolver == nil {

-		return ErrNoMatch{value: i.Value, qualifier: "no resolver defined"}

-	}

-	match, err := i.Resolver.Resolve(i.Value)

-	if err != nil {

-		return err

-	}

-	i.Value = match.Value

-	i.Argument = match.Argument

-	i.Match = match

-

-	return nil

-}

-

-func (i *ComponentInput) String() string {

-	return i.Value

-}

-

-func (i *ComponentInput) Use(repo *SourceRepository) {

-	i.Uses = repo

-}

deleted file mode 100644

@@ -1,49 +0,0 @@

-package new

-

-import (

-	"bytes"

-	"fmt"

-)

-

-type ErrNoMatch struct {

-	value     string

-	qualifier string

-}

-

-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 matched %q", e.value)

-}

-

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

-	return fmt.Sprintf(`

-%[3]s - you can try to search for images or templates that may match this name with:

-

-    $ %[2]s -S %[1]q

-

-`, e.value, commandName, e.Error())

-}

-

-type ErrMultipleMatches struct {

-	image   string

-	matches []*ComponentMatch

-}

-

-func (e ErrMultipleMatches) Error() string {

-	return fmt.Sprintf("multiple images 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, "* %[1]s (use %[2]s)\n", match.Name, match.Argument)

-		fmt.Fprintf(buf, "  %s\n\n", match.Description)

-	}

-	return fmt.Sprintf(`

-The argument %[1]q could apply to the following images or templates:

-

-%[2]s

-`, e.image, buf.String())

-}

deleted file mode 100644

@@ -1,239 +0,0 @@

-package new

-

-import (

-	"fmt"

-	"strings"

-

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

-

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

-	"github.com/golang/glog"

-

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

-	"github.com/openshift/origin/pkg/dockerregistry"

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

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

-)

-

-type dockerClientResolver struct {

-	client *docker.Client

-}

-

-func (r dockerClientResolver) Resolve(value string) (*ComponentMatch, error) {

-	image, err := r.client.InspectImage(value)

-	switch {

-	case err == docker.ErrNoSuchImage:

-		return nil, ErrNoMatch{value: value}

-	case err != nil:

-		return nil, err

-	}

-	return &ComponentMatch{

-		Value:       value,

-		Argument:    fmt.Sprintf("--docker-image=%q", value),

-		Name:        value,

-		Description: fmt.Sprintf("Docker image %q by %s\n%s", value, image.Author, image.Comment),

-		Builder:     false,

-		Score:       0,

-	}, nil

-}

-

-type dockerRegistryResolver struct {

-	client dockerregistry.Client

-}

-

-func (r dockerRegistryResolver) Resolve(value string) (*ComponentMatch, error) {

-	registry, namespace, name, tag, err := image.SplitDockerPullSpec(value)

-	if err != nil {

-		return nil, err

-	}

-	connection, err := r.client.Connect(registry)

-	if err != nil {

-		if dockerregistry.IsRegistryNotFound(err) {

-			return nil, ErrNoMatch{value: value}

-		}

-		return nil, ErrNoMatch{value: value, qualifier: fmt.Sprintf("can't connect to %q: %v", registry, err)}

-	}

-	image, err := connection.ImageByTag(namespace, name, tag)

-	if err != nil {

-		if dockerregistry.IsNotFound(err) {

-			return nil, ErrNoMatch{value: value, qualifier: err.Error()}

-		}

-		return nil, ErrNoMatch{value: value, qualifier: fmt.Sprintf("can't connect to %q: %v", registry, err)}

-	}

-	if len(tag) == 0 {

-		tag = "latest"

-	}

-	glog.V(4).Infof("found image: %#v", image)

-	return &ComponentMatch{

-		Value:       value,

-		Argument:    fmt.Sprintf("--docker-image=%q", value),

-		Name:        value,

-		Description: fmt.Sprintf("Docker image %q (%q)", value, image.ID),

-		Builder:     app.IsBuilderImage(image),

-		Score:       0,

-

-		Image:    image,

-		ImageTag: tag,

-	}, nil

-}

-

-type imageStreamResolver struct {

-	client     client.ImageRepositoriesNamespacer

-	images     client.ImagesNamespacer

-	namespaces []string

-}

-

-func (r imageStreamResolver) Resolve(value string) (*ComponentMatch, error) {

-	registry, namespace, name, tag, err := image.SplitOpenShiftPullSpec(value)

-	if err != nil || len(registry) != 0 {

-		return nil, fmt.Errorf("image repositories must be of the form [<namespace>/]<name>[:<tag>]")

-	}

-	namespaces := r.namespaces

-	if len(namespace) != 0 {

-		namespaces = []string{namespace}

-	}

-	for _, namespace := range namespaces {

-		glog.V(4).Infof("checking image stream %s/%s with tag %q", namespace, name, tag)

-		repo, err := r.client.ImageRepositories(namespace).Get(name)

-		if err != nil {

-			if errors.IsNotFound(err) {

-				continue

-			}

-			return nil, err

-		}

-		searchTag := tag

-		// TODO: move to a lookup function on repo, or better yet, have the repo.Status.Tags field automatically infer latest

-		if len(searchTag) == 0 {

-			searchTag = "latest"

-		}

-		id, ok := repo.Tags[searchTag]

-		if !ok {

-			if len(tag) == 0 {

-				return nil, ErrNoMatch{value: value, qualifier: fmt.Sprintf("the default tag %q has not been set", searchTag)}

-			}

-			return nil, ErrNoMatch{value: value, qualifier: fmt.Sprintf("tag %q has not been set", tag)}

-		}

-		imageData, err := r.images.Images(namespace).Get(id)

-		if err != nil {

-			if errors.IsNotFound(err) {

-				return nil, ErrNoMatch{value: value, qualifier: fmt.Sprintf("tag %q is set, but image %q has been removed", tag, id)}

-			}

-			return nil, err

-		}

-

-		spec := image.JoinDockerPullSpec("", namespace, name, tag)

-		return &ComponentMatch{

-			Value:       spec,

-			Argument:    fmt.Sprintf("--image=%q", spec),

-			Name:        name,

-			Description: fmt.Sprintf("Image stream %s (tag %q) in namespace %s, tracks %q", name, searchTag, namespace, repo.Status.DockerImageRepository),

-			Builder:     app.IsBuilderImage(&imageData.DockerImageMetadata),

-			Score:       0,

-

-			ImageStream: repo,

-			Image:       &imageData.DockerImageMetadata,

-			ImageTag:    searchTag,

-		}, nil

-	}

-	return nil, ErrNoMatch{value: value}

-}

-

-type mockResolver struct{}

-

-func (mockResolver) Resolve(value string) (*ComponentMatch, error) {

-	matches, err := mockSearcher{}.Search([]string{value})

-	switch {

-	case err != nil:

-		return nil, err

-	case len(matches) > 1:

-		return nil, ErrMultipleMatches{value, matches}

-	case len(matches) == 0:

-		return nil, ErrNoMatch{value: value}

-	default:

-		return matches[0], nil

-	}

-}

-

-type Searcher interface {

-	Search(terms []string) ([]*ComponentMatch, error)

-}

-

-type mockSearcher struct{}

-

-func (mockSearcher) Search(terms []string) ([]*ComponentMatch, error) {

-	for _, term := range terms {

-		term = strings.ToLower(term)

-		switch term {

-		case "redhat/mysql:5.6":

-			return []*ComponentMatch{

-				{

-					Value:       term,

-					Argument:    "redhat/mysql:5.6",

-					Name:        "MySQL 5.6",

-					Description: "The Open Source SQL database",

-				},

-			}, nil

-		case "mysql", "mysql5", "mysql-5", "mysql-5.x":

-			return []*ComponentMatch{

-				{

-					Value:       term,

-					Argument:    "redhat/mysql:5.6",

-					Name:        "MySQL 5.6",

-					Description: "The Open Source SQL database",

-				},

-				{

-					Value:       term,

-					Argument:    "mysql",

-					Name:        "MySQL 5.X",

-					Description: "Something out there on the Docker Hub.",

-				},

-			}, nil

-		case "php", "php-5", "php5", "redhat/php:5", "redhat/php-5":

-			return []*ComponentMatch{

-				{

-					Value:       term,

-					Argument:    "redhat/php:5",

-					Name:        "PHP 5.5",

-					Description: "A fast and easy to use scripting language for building websites.",

-					Builder:     true,

-				},

-			}, nil

-		case "ruby":

-			return []*ComponentMatch{

-				{

-					Value:       term,

-					Argument:    "redhat/ruby:2",

-					Name:        "Ruby 2.0",

-					Description: "A fast and easy to use scripting language for building websites.",

-					Builder:     true,

-				},

-			}, nil

-		}

-	}

-	return []*ComponentMatch{}, nil

-}

-

-func InputImageFromMatch(match *ComponentMatch) (*app.ImageRef, error) {

-	switch {

-	case match.ImageStream != nil:

-		input, err := app.ImageFromRepository(match.ImageStream, match.ImageTag)

-		if err != nil {

-			return nil, err

-		}

-		input.AsImageRepository = true

-		input.Info = match.Image

-		return input, nil

-

-	case match.Image != nil:

-		input, err := app.ImageFromName(match.Value, match.ImageTag)

-		if err != nil {

-			return nil, err

-		}

-		input.AsImageRepository = false

-		input.Info = match.Image

-		return input, nil

-

-	default:

-		return nil, fmt.Errorf("no image or image stream, can't setup a build")

-	}

-}

deleted file mode 100644

@@ -1,383 +0,0 @@

-package new

-

-import (

-	"fmt"

-	"io"

-

-	"github.com/golang/glog"

-	"github.com/spf13/cobra"

-

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

-	"github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl"

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

-