@@ -7835,6 +7835,101 @@ _oc_convert()

     must_have_one_noun=()

 }

+_oc_import_docker-compose()

+{

+    last_command="oc_import_docker-compose"

+    commands=()

+

+    flags=()

+    two_word_flags=()

+    flags_with_completion=()

+    flags_completion=()

+

+    flags+=("--as-template=")

+    flags+=("--dry-run")

+    flags+=("--filename=")

+    flags_with_completion+=("--filename")

+    flags_completion+=("__handle_filename_extension_flag json|yaml|yml")

+    two_word_flags+=("-f")

+    flags_with_completion+=("-f")

+    flags_completion+=("__handle_filename_extension_flag json|yaml|yml")

+    flags+=("--generator=")

+    flags+=("--output=")

+    two_word_flags+=("-o")

+    flags+=("--output-version=")

+    flags+=("--api-version=")

+    flags+=("--as=")

+    flags+=("--certificate-authority=")

+    flags_with_completion+=("--certificate-authority")

+    flags_completion+=("_filedir")

+    flags+=("--client-certificate=")

+    flags_with_completion+=("--client-certificate")

+    flags_completion+=("_filedir")

+    flags+=("--client-key=")

+    flags_with_completion+=("--client-key")

+    flags_completion+=("_filedir")

+    flags+=("--cluster=")

+    flags+=("--config=")

+    flags_with_completion+=("--config")

+    flags_completion+=("_filedir")

+    flags+=("--context=")

+    flags+=("--google-json-key=")

+    flags+=("--insecure-skip-tls-verify")

+    flags+=("--log-flush-frequency=")

+    flags+=("--match-server-version")

+    flags+=("--namespace=")

+    two_word_flags+=("-n")

+    flags+=("--server=")

+    flags+=("--token=")

+    flags+=("--user=")

+

+    must_have_one_flag=()

+    must_have_one_flag+=("--filename=")

+    must_have_one_flag+=("-f")

+    must_have_one_noun=()

+}

+

+_oc_import()

+{

+    last_command="oc_import"

+    commands=()

+    commands+=("docker-compose")

+

+    flags=()

+    two_word_flags=()

+    flags_with_completion=()

+    flags_completion=()

+

+    flags+=("--api-version=")

+    flags+=("--as=")

+    flags+=("--certificate-authority=")

+    flags_with_completion+=("--certificate-authority")

+    flags_completion+=("_filedir")

+    flags+=("--client-certificate=")

+    flags_with_completion+=("--client-certificate")

+    flags_completion+=("_filedir")

+    flags+=("--client-key=")

+    flags_with_completion+=("--client-key")

+    flags_completion+=("_filedir")

+    flags+=("--cluster=")

+    flags+=("--config=")

+    flags_with_completion+=("--config")

+    flags_completion+=("_filedir")

+    flags+=("--context=")

+    flags+=("--google-json-key=")

+    flags+=("--insecure-skip-tls-verify")

+    flags+=("--log-flush-frequency=")

+    flags+=("--match-server-version")

+    flags+=("--namespace=")

+    two_word_flags+=("-n")

+    flags+=("--server=")

+    flags+=("--token=")

+    flags+=("--user=")

+

+    must_have_one_flag=()

+    must_have_one_noun=()

+}

+

 _oc_logout()

 {

     last_command="oc_logout"

@@ -8591,6 +8686,7 @@ _oc()

     commands+=("export")

     commands+=("policy")

     commands+=("convert")

+    commands+=("import")

     commands+=("logout")

     commands+=("config")

     commands+=("whoami")

@@ -11420,6 +11420,101 @@ _openshift_cli_convert()

     must_have_one_noun=()

 }

+_openshift_cli_import_docker-compose()

+{

+    last_command="openshift_cli_import_docker-compose"

+    commands=()

+

+    flags=()

+    two_word_flags=()

+    flags_with_completion=()

+    flags_completion=()

+

+    flags+=("--as-template=")

+    flags+=("--dry-run")

+    flags+=("--filename=")

+    flags_with_completion+=("--filename")

+    flags_completion+=("__handle_filename_extension_flag json|yaml|yml")

+    two_word_flags+=("-f")

+    flags_with_completion+=("-f")

+    flags_completion+=("__handle_filename_extension_flag json|yaml|yml")

+    flags+=("--generator=")

+    flags+=("--output=")

+    two_word_flags+=("-o")

+    flags+=("--output-version=")

+    flags+=("--api-version=")

+    flags+=("--as=")

+    flags+=("--certificate-authority=")

+    flags_with_completion+=("--certificate-authority")

+    flags_completion+=("_filedir")

+    flags+=("--client-certificate=")

+    flags_with_completion+=("--client-certificate")

+    flags_completion+=("_filedir")

+    flags+=("--client-key=")

+    flags_with_completion+=("--client-key")

+    flags_completion+=("_filedir")

+    flags+=("--cluster=")

+    flags+=("--config=")

+    flags_with_completion+=("--config")

+    flags_completion+=("_filedir")

+    flags+=("--context=")

+    flags+=("--google-json-key=")

+    flags+=("--insecure-skip-tls-verify")

+    flags+=("--log-flush-frequency=")

+    flags+=("--match-server-version")

+    flags+=("--namespace=")

+    two_word_flags+=("-n")

+    flags+=("--server=")

+    flags+=("--token=")

+    flags+=("--user=")

+

+    must_have_one_flag=()

+    must_have_one_flag+=("--filename=")

+    must_have_one_flag+=("-f")

+    must_have_one_noun=()

+}

+

+_openshift_cli_import()

+{

+    last_command="openshift_cli_import"

+    commands=()

+    commands+=("docker-compose")

+

+    flags=()

+    two_word_flags=()

+    flags_with_completion=()

+    flags_completion=()

+

+    flags+=("--api-version=")

+    flags+=("--as=")

+    flags+=("--certificate-authority=")

+    flags_with_completion+=("--certificate-authority")

+    flags_completion+=("_filedir")

+    flags+=("--client-certificate=")

+    flags_with_completion+=("--client-certificate")

+    flags_completion+=("_filedir")

+    flags+=("--client-key=")

+    flags_with_completion+=("--client-key")

+    flags_completion+=("_filedir")

+    flags+=("--cluster=")

+    flags+=("--config=")

+    flags_with_completion+=("--config")

+    flags_completion+=("_filedir")

+    flags+=("--context=")

+    flags+=("--google-json-key=")

+    flags+=("--insecure-skip-tls-verify")

+    flags+=("--log-flush-frequency=")

+    flags+=("--match-server-version")

+    flags+=("--namespace=")

+    two_word_flags+=("-n")

+    flags+=("--server=")

+    flags+=("--token=")

+    flags+=("--user=")

+

+    must_have_one_flag=()

+    must_have_one_noun=()

+}

+

 _openshift_cli_logout()

 {

     last_command="openshift_cli_logout"

@@ -12176,6 +12271,7 @@ _openshift_cli()

     commands+=("export")

     commands+=("policy")

     commands+=("convert")

+    commands+=("import")

     commands+=("logout")

     commands+=("config")

     commands+=("whoami")

@@ -1240,6 +1240,23 @@ Display one or many resources

 ====

+== oc import docker-compose

+Import a docker-compose.yml project into OpenShift

+

+====

+

+[options="nowrap"]

+----

+  # Import a docker-compose.yml file into OpenShift

+  $ oc import docker-compose -f ./docker-compose.yml

+

+	# Turn a docker-compose.yml file into a template

+  $ oc import docker-compose -f ./docker-compose.yml -o yaml --as-template

+

+----

+====

+

+

 == oc import-image

 Imports images from a Docker registry

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

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

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

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

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

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

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

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

@@ -153,6 +154,7 @@ func NewCommandCLI(name, fullName string, in io.Reader, out, errout io.Writer) *

 				cmd.NewCmdExport(fullName, f, in, out),

 				policy.NewCmdPolicy(policy.PolicyRecommendedName, fullName+" "+policy.PolicyRecommendedName, f, out),

 				cmd.NewCmdConvert(fullName, f, out),

+				importer.NewCmdImport(fullName, f, in, out, errout),

 			},

 		},

 		{

new file mode 100644

@@ -0,0 +1,182 @@

+package importer

+

+import (

+	"fmt"

+	"io"

+	"os"

+	"strings"

+

+	"github.com/spf13/cobra"

+

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

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

+	"k8s.io/kubernetes/pkg/apimachinery/registered"

+	"k8s.io/kubernetes/pkg/kubectl"

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

+	"k8s.io/kubernetes/pkg/runtime"

+

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

+	cmdutil "github.com/openshift/origin/pkg/cmd/util"

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

+	configcmd "github.com/openshift/origin/pkg/config/cmd"

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

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

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

+)

+

+const (

+	dockerComposeLong = `

+Import a Docker Compose file as OpenShift objects

+

+Docker Compose files offer a container centric build and deploy pattern for simple applications.

+This command will transform a provided docker-compose.yml application into its OpenShift equivalent.

+During transformation fields in the compose syntax that are not relevant when running on top of

+a containerized platform will be ignored and a warning printed.

+

+The command will create objects unless you pass the -o yaml or --as-template flags to generate a

+configuration file for later use.`

+

+	dockerComposeExample = `  # Import a docker-compose.yml file into OpenShift

+  $ %[1]s docker-compose -f ./docker-compose.yml

+

+	# Turn a docker-compose.yml file into a template

+  $ %[1]s docker-compose -f ./docker-compose.yml -o yaml --as-template

+`

+

+	DockerComposeV1GeneratorName = "docker-compose/v1"

+)

+

+type DockerComposeOptions struct {

+	Action configcmd.BulkAction

+

+	In        io.Reader

+	Filenames []string

+

+	Generator  string

+	AsTemplate string

+

+	PrintObject    func(runtime.Object) error

+	OutputVersions []unversioned.GroupVersion

+

+	Namespace string

+	Client    client.TemplateConfigsNamespacer

+}

+

+// NewCmdDockerCompose imports a docker-compose file as a template.

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

+	options := &DockerComposeOptions{

+		Action: configcmd.BulkAction{

+			Out:    out,

+			ErrOut: errout,

+		},

+		In:        in,

+		Generator: DockerComposeV1GeneratorName,

+	}

+	cmd := &cobra.Command{

+		Use:     "docker-compose -f COMPOSEFILE",

+		Short:   "Import a docker-compose.yml project into OpenShift",

+		Long:    dockerComposeLong,

+		Example: fmt.Sprintf(dockerComposeExample, fullName),

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

+			kcmdutil.CheckErr(options.Complete(f, cmd, args))

+			kcmdutil.CheckErr(options.Validate())

+			if err := options.Run(); err != nil {

+				// TODO: move met to kcmdutil

+				if err == cmdutil.ErrExit {

+					os.Exit(1)

+				}

+				kcmdutil.CheckErr(err)

+			}

+		},

+	}

+	usage := "Filename, directory, or URL to docker-compose.yml file to use"

+	kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage)

+	cmd.MarkFlagRequired("filename")

+

+	cmd.Flags().String("generator", options.Generator, "The name of the API generator to use.")

+	cmd.Flags().StringVar(&options.AsTemplate, "as-template", "", "If set, generate a template with the provided name")

+

+	options.Action.BindForOutput(cmd.Flags())

+	cmd.Flags().String("output-version", "", "The preferred API versions of the output objects")

+

+	return cmd

+}

+

+func (o *DockerComposeOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string) error {

+	version, _ := cmd.Flags().GetString("output-version")

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

+		gv, err := unversioned.ParseGroupVersion(v)

+		if err != nil {

+			return fmt.Errorf("provided output-version %q is not valid: %v", v, err)

+		}

+		o.OutputVersions = append(o.OutputVersions, gv)

+	}

+	o.OutputVersions = append(o.OutputVersions, registered.EnabledVersions()...)

+

+	o.Action.Bulk.Mapper = clientcmd.ResourceMapper(f)

+	o.Action.Bulk.Op = configcmd.Create

+	mapper, _ := f.Object(false)

+	o.PrintObject = cmdutil.VersionedPrintObject(f.PrintObject, cmd, mapper, o.Action.Out)

+

+	o.Generator, _ = cmd.Flags().GetString("generator")

+

+	ns, _, err := f.DefaultNamespace()

+	if err != nil {

+		return err

+	}

+	o.Namespace = ns

+

+	o.Client, _, err = f.Clients()

+	return err

+}

+

+func (o *DockerComposeOptions) Validate() error {

+	if len(o.Filenames) == 0 {

+		return fmt.Errorf("you must provide the paths to one or more docker-compose.yml files")

+	}

+	switch o.Generator {

+	case DockerComposeV1GeneratorName:

+	default:

+		return fmt.Errorf("the generator %q is not supported, use: %s", o.Generator, DockerComposeV1GeneratorName)

+	}

+	return nil

+}

+

+func (o *DockerComposeOptions) Run() error {

+	template, err := dockercompose.Generate(o.Filenames...)

+	if err != nil {

+		return err

+	}

+

+	// all the types generated into the template should be known

+	if errs := app.AsVersionedObjects(template.Objects, kapi.Scheme, kapi.Scheme, o.OutputVersions...); len(errs) > 0 {

+		for _, err := range errs {

+			fmt.Fprintf(o.Action.ErrOut, "error: %v\n", err)

+		}

+	}

+

+	if o.Action.ShouldPrint() || (o.Action.Output == "name" && len(o.AsTemplate) > 0) {

+		var out runtime.Object

+		if len(o.AsTemplate) > 0 {

+			template.Name = o.AsTemplate

+			out = template

+		} else {

+			out = &kapi.List{Items: template.Objects}

+		}

+		return o.PrintObject(out)

+	}

+

+	result, err := appcmd.TransformTemplate(template, o.Client, o.Namespace, nil)

+	if err != nil {

+		return err

+	}

+

+	if o.Action.Verbose() {

+		appcmd.DescribeGeneratedTemplate(o.Action.Out, "", result, o.Namespace)

+	}

+

+	if errs := o.Action.WithMessage("Importing compose file", "creating").Run(&kapi.List{Items: result.Objects}, o.Namespace); len(errs) > 0 {

+		return cmdutil.ErrExit

+	}

+	return nil

+}

new file mode 100644

@@ -0,0 +1,33 @@

+package importer

+

+import (

+	"fmt"

+	"io"

+

+	"github.com/spf13/cobra"

+

+	cmdutil "github.com/openshift/origin/pkg/cmd/util"

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

+)

+

+const (

+	importLong = `

+Import outside applications into OpenShift

+

+These commands assist in bringing existing applications into OpenShift.`

+)

+

+// NewCmdImport exposes commands for modifying objects.

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

+	cmd := &cobra.Command{

+		Use:   "import COMMAND",

+		Short: "Commands that import applications",

+		Long:  importLong,

+		Run:   cmdutil.DefaultSubCommandRun(out),

+	}

+

+	name := fmt.Sprintf("%s import", fullName)

+

+	cmd.AddCommand(NewCmdDockerCompose(name, f, in, out, errout))

+	return cmd

+}

@@ -289,10 +289,10 @@ func AddComponentInputsToRefBuilder(b *app.ReferenceBuilder, r *Resolvers, c *Co

 	})

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

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

-		input.Searcher = r.TemplateFileSearcher

 		if r.TemplateFileSearcher != nil {

 			input.Resolver = app.FirstMatchResolver{Searcher: r.TemplateFileSearcher}

 		}

+		input.Searcher = r.TemplateFileSearcher

 		return input

 	})

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

new file mode 100644

@@ -0,0 +1,562 @@

+package dockercompose

+

+import (

+	"fmt"

+	"net"

+	"path/filepath"

+	"strconv"

+	"strings"

+

+	"github.com/golang/glog"

+

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

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

+	utilerrs "k8s.io/kubernetes/pkg/util/errors"

+	"k8s.io/kubernetes/pkg/util/sets"

+

+	deployapi "github.com/openshift/origin/pkg/deploy/api"

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

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

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

+	dockerfileutil "github.com/openshift/origin/pkg/util/docker/dockerfile"

+	"github.com/openshift/origin/third_party/github.com/docker/libcompose/project"

+)

+

+func IsPossibleDockerCompose(path string) bool {

+	switch base := filepath.Base(path); {

+	case base == "docker-compose.yaml", base == "docker-compose.yml":

+		return true

+	default:

+		return false

+	}

+}

+

+// Generate accepts a set of Docker compose project paths and converts them in an

+// OpenShift template definition.

+func Generate(paths ...string) (*templateapi.Template, error) {

+	for i := range paths {

+		path, err := filepath.Abs(paths[i])

+		if err != nil {

+			return nil, err

+		}

+		paths[i] = path

+	}

+	var bases []string

+	for _, s := range paths {

+		bases = append(bases, filepath.Dir(s))

+	}

+

+	context := &project.Context{

+		ComposeFiles: paths,

+	}

+	p := project.NewProject(context)

+	if err := p.Parse(); err != nil {

+		return nil, err

+	}

+	template := &templateapi.Template{}

+	template.Name = p.Name

+

+	serviceOrder := sets.NewString()

+	warnings := make(map[string][]string)

+	for k, v := range p.Configs {

+		serviceOrder.Insert(k)

+		warnUnusableComposeElements(k, v, warnings)

+	}

+

+	g := app.NewImageRefGenerator()

+

+	var errs []error

+	var pipelines app.PipelineGroup

+	builds := make(map[string]*app.Pipeline)

+

+	// identify colocated components due to shared volumes

+	joins := make(map[string]sets.String)

+	volumesFrom := make(map[string][]string)

+	for _, k := range serviceOrder.List() {

+		if joins[k] == nil {

+			joins[k] = sets.NewString(k)

+		}

+		v := p.Configs[k]

+		for _, from := range v.VolumesFrom {

+			switch parts := strings.Split(from, ":"); len(parts) {

+			case 1:

+				joins[k].Insert(parts[0])

+				volumesFrom[k] = append(volumesFrom[k], parts[0])

+			case 2:

+				target := parts[1]

+				if parts[1] == "ro" || parts[1] == "rw" {

+					target = parts[0]

+				}

+				joins[k].Insert(target)

+				volumesFrom[k] = append(volumesFrom[k], target)

+			case 3:

+				joins[k].Insert(parts[1])

+				volumesFrom[k] = append(volumesFrom[k], parts[1])

+			}

+		}

+	}

+	joinOrder := sets.NewString()

+	for k := range joins {

+		joinOrder.Insert(k)

+	}

+	var colocated []sets.String

+	for _, k := range joinOrder.List() {

+		set := joins[k]

+		matched := -1

+		for i, existing := range colocated {

+			if set.Intersection(existing).Len() == 0 {

+				continue

+			}

+			if matched != -1 {

+				return nil, fmt.Errorf("%q belongs with %v, but %v also contains some overlapping elements", k, set, colocated[matched])

+			}

+			existing.Insert(set.List()...)

+			matched = i

+			continue

+		}

+		if matched == -1 {

+			colocated = append(colocated, set)

+		}

+	}

+

+	// identify service aliases

+	aliases := make(map[string]sets.String)

+	for _, v := range p.Configs {

+		for _, s := range v.Links.Slice() {

+			parts := strings.SplitN(s, ":", 2)

+			if len(parts) != 2 || parts[0] == parts[1] {

+				continue

+			}

+			set := aliases[parts[0]]

+			if set == nil {

+				set = sets.NewString()

+				aliases[parts[0]] = set

+			}

+			set.Insert(parts[1])

+		}

+	}

+

+	// find and define build pipelines

+	for _, k := range serviceOrder.List() {

+		v := p.Configs[k]

+		if len(v.Build) == 0 {

+			continue

+		}

+		if _, ok := builds[v.Build]; ok {

+			continue

+		}

+		var base, relative string

+		for _, s := range bases {

+			if !strings.HasPrefix(v.Build, s) {

+				continue

+			}

+			base = s

+			path, err := filepath.Rel(base, v.Build)

+			if err != nil {

+				return nil, fmt.Errorf("path is not relative to base: %v", err)

+			}

+			relative = path

+			break

+		}

+		if len(base) == 0 {

+			return nil, fmt.Errorf("build path outside of the compose file: %s", v.Build)

+		}

+

+		// if this is a Git repository, make the path relative

+		if root, err := git.NewRepository().GetRootDir(base); err == nil {

+			if relative, err = filepath.Rel(root, filepath.Join(base, relative)); err != nil {

+				return nil, fmt.Errorf("unable to find relative path for Git repository: %v", err)

+			}

+			base = root

+		}

+		buildPath := filepath.Join(base, relative)

+

+		// TODO: what if there is no origin for this repo?

+

+		glog.V(4).Infof("compose service: %#v", v)

+		repo, err := app.NewSourceRepositoryWithDockerfile(buildPath, "")

+		if err != nil {

+			errs = append(errs, err)

+			continue

+		}

+		repo.BuildWithDocker()

+

+		info := repo.Info()

+		if info == nil || info.Dockerfile == nil {

+			errs = append(errs, fmt.Errorf("unable to locate a Dockerfile in %s", v.Build))

+			continue

+		}

+		node := info.Dockerfile.AST()

+		baseImage := dockerfileutil.LastBaseImage(node)

+		if len(baseImage) == 0 {

+			errs = append(errs, fmt.Errorf("the Dockerfile in the repository %q has no FROM instruction", info.Path))

+			continue

+		}

+

+		var ports []string

+		for _, s := range v.Ports {

+			container, _ := extractFirstPorts(s)

+			ports = append(ports, container)

+		}

+

+		image, err := g.FromNameAndPorts(baseImage, ports)

+		if err != nil {

+			errs = append(errs, err)

+			continue

+		}

+		image.AsImageStream = true

+		image.TagDirectly = true

+		image.ObjectName = k

+		image.Tag = "from"

+

+		pipeline, err := app.NewPipelineBuilder(k, nil, false).To(k).NewBuildPipeline(k, image, repo)

+		if err != nil {

+			errs = append(errs, err)

+			continue

+		}

+		if len(relative) > 0 {

+			pipeline.Build.Source.ContextDir = relative

+		}

+		// TODO: this should not be necessary

+		pipeline.Build.Source.Name = k

+		pipeline.Name = k

+		pipeline.Image.ObjectName = k

+		glog.V(4).Infof("created pipeline %+v", pipeline)

+

+		builds[v.Build] = pipeline

+		pipelines = append(pipelines, pipeline)

+	}

+

+	if len(errs) > 0 {

+		return nil, utilerrs.NewAggregate(errs)

+	}

+

+	// create deployment groups

+	for _, pod := range colocated {

+		var group app.PipelineGroup

+		commonMounts := make(map[string]string)

+		for _, k := range pod.List() {

+			v := p.Configs[k]

+			var inputImage *app.ImageRef

+			if len(v.Image) != 0 {

+				image, err := g.FromName(v.Image)

+				if err != nil {

+					errs = append(errs, err)

+					continue

+				}

+				image.AsImageStream = true

+				image.TagDirectly = true

+				image.ObjectName = k

+

+				inputImage = image

+			}

+			if inputImage == nil {

+				if previous, ok := builds[v.Build]; ok {

+					inputImage = previous.Image

+				}

+			}

+			if inputImage == nil {

+				errs = append(errs, fmt.Errorf("could not find an input image for %q", k))

+				continue

+			}

+

+			inputImage.ContainerFn = func(c *kapi.Container) {

+				if len(v.ContainerName) > 0 {

+					c.Name = v.ContainerName

+				}

+				for _, s := range v.Ports {

+					container, _ := extractFirstPorts(s)

+					if port, err := strconv.Atoi(container); err == nil {

+						c.Ports = append(c.Ports, kapi.ContainerPort{ContainerPort: port})

+					}

+				}

+				c.Args = v.Command.Slice()

+				if len(v.Entrypoint.Slice()) > 0 {

+					c.Command = v.Entrypoint.Slice()

+				}

+				if len(v.WorkingDir) > 0 {

+					c.WorkingDir = v.WorkingDir

+				}

+				c.Env = append(c.Env, app.ParseEnvironment(v.Environment.Slice()...).List()...)

+				if uid, err := strconv.Atoi(v.User); err == nil {

+					uid64 := int64(uid)

+					if c.SecurityContext == nil {

+						c.SecurityContext = &kapi.SecurityContext{}

+					}

+					c.SecurityContext.RunAsUser = &uid64

+				}

+				c.TTY = v.Tty

+				if v.StdinOpen {

+					c.StdinOnce = true

+					c.Stdin = true

+				}

+				if v.Privileged {

+					if c.SecurityContext == nil {

+						c.SecurityContext = &kapi.SecurityContext{}

+					}

+					t := true

+					c.SecurityContext.Privileged = &t

+				}

+				if v.ReadOnly {

+					if c.SecurityContext == nil {

+						c.SecurityContext = &kapi.SecurityContext{}

+					}

+					t := true

+					c.SecurityContext.ReadOnlyRootFilesystem = &t

+				}

+				if v.MemLimit > 0 {

+					q := resource.NewQuantity(v.MemLimit, resource.DecimalSI)

+					if c.Resources.Limits == nil {

+						c.Resources.Limits = make(kapi.ResourceList)

+					}

+					c.Resources.Limits[kapi.ResourceMemory] = *q

+				}

+

+				if quota := v.CPUQuota; quota > 0 {

+					if quota < 1000 {

+						quota = 1000 // minQuotaPeriod

+					}

+					milliCPU := quota * 1000     // milliCPUtoCPU

+					milliCPU = milliCPU / 100000 // quotaPeriod

+					q := resource.NewMilliQuantity(milliCPU, resource.DecimalSI)

+					if c.Resources.Limits == nil {

+						c.Resources.Limits = make(kapi.ResourceList)

+					}

+					c.Resources.Limits[kapi.ResourceCPU] = *q

+				}

+				if shares := v.CPUShares; shares > 0 {

+					if shares < 2 {

+						shares = 2 // minShares

+					}

+					milliCPU := shares * 1000  // milliCPUtoCPU

+					milliCPU = milliCPU / 1024 // sharesPerCPU

+					q := resource.NewMilliQuantity(milliCPU, resource.DecimalSI)

+					if c.Resources.Requests == nil {

+						c.Resources.Requests = make(kapi.ResourceList)

+					}

+					c.Resources.Requests[kapi.ResourceCPU] = *q

+				}

+

+				mountPoints := make(map[string][]string)

+				for _, s := range v.Volumes {

+					switch parts := strings.SplitN(s, ":", 3); len(parts) {

+					case 1:

+						mountPoints[""] = append(mountPoints[""], parts[0])

+

+					case 2:

+						fallthrough

+					default:

+						mountPoints[parts[0]] = append(mountPoints[parts[0]], parts[1])

+					}

+				}

+				for from, at := range mountPoints {

+					name, ok := commonMounts[from]

+					if !ok {

+						name = fmt.Sprintf("dir-%d", len(commonMounts)+1)

+						commonMounts[from] = name

+					}

+					for _, path := range at {

+						c.VolumeMounts = append(c.VolumeMounts, kapi.VolumeMount{Name: name, MountPath: path})

+					}

+				}

+			}

+

+			pipeline, err := app.NewPipelineBuilder(k, nil, true).To(k).NewImagePipeline(k, inputImage)

+			if err != nil {

+				errs = append(errs, err)

+				break

+			}

+

+			if err := pipeline.NeedsDeployment(nil, nil, false); err != nil {

+				return nil, err

+			}

+

+			group = append(group, pipeline)

+		}

+		if err := group.Reduce(); err != nil {

+			return nil, err

+		}