@@ -22499,7 +22499,7 @@

      },

      "generate": {

       "type": "string",

-      "description": "Generate specifies the generator to be used to generate random string from an input value specified by From field. The result string is stored into Value field. If empty, no generator is being used, leaving the result Value untouched. Optional."

+      "description": "generate specifies the generator to be used to generate random string from an input value specified by From field. The result string is stored into Value field. If empty, no generator is being used, leaving the result Value untouched. Optional.\n\nThe only supported generator is \"expression\", which accepts a \"from\" value in the form of a simple regular expression containing the range expression \"[a-zA-Z0-9]\", and the length expression \"a{length}\".\n\nExamples:\n\nfrom             | value"

      },

      "from": {

       "type": "string",

@@ -8035,11 +8035,67 @@ _oc_import_docker-compose()

     must_have_one_noun=()

 }

+_oc_import_app.json()

+{

+    last_command="oc_import_app.json"

+    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+=("--image=")

+    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")

+    commands+=("app.json")

     flags=()

     two_word_flags=()

@@ -11622,11 +11622,67 @@ _openshift_cli_import_docker-compose()

     must_have_one_noun=()

 }

+_openshift_cli_import_app.json()

+{

+    last_command="openshift_cli_import_app.json"

+    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+=("--image=")

+    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")

+    commands+=("app.json")

     flags=()

     two_word_flags=()

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

 ====

+== oc import app.json

+Import an app.json definition into OpenShift

+

+====

+

+[options="nowrap"]

+----

+  # Import a directory containing an app.json file

+  $ oc import app.json -f .

+

+  # Turn an app.json file into a template

+  $ oc import app.json -f ./app.json -o yaml --as-template

+

+----

+====

+

+

 == oc import docker-compose

 Import a docker-compose.yml project into OpenShift

new file mode 100644

@@ -0,0 +1,255 @@

+package importer

+

+import (

+	"fmt"

+	"io"

+	"io/ioutil"

+	"net/http"

+	"net/url"

+	"os"

+	"path"

+	"path/filepath"

+	"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/appjson"

+)

+

+const (

+	appJSONLong = `

+Import app.json files as OpenShift objects

+

+app.json defines the pattern of a simple, stateless web application that can be horizontally scaled.

+This command will transform a provided app.json object into its OpenShift equivalent.

+During transformation fields in the app.json 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.`

+

+	appJSONExample = `  # Import a directory containing an app.json file

+  $ %[1]s app.json -f .

+

+  # Turn an app.json file into a template

+  $ %[1]s app.json -f ./app.json -o yaml --as-template

+`

+

+	AppJSONV1GeneratorName = "app-json/v1"

+)

+

+type AppJSONOptions struct {

+	Action configcmd.BulkAction

+

+	In        io.Reader

+	Filenames []string

+

+	BaseImage  string

+	Generator  string

+	AsTemplate string

+

+	PrintObject    func(runtime.Object) error

+	OutputVersions []unversioned.GroupVersion

+

+	Namespace string

+	Client    client.TemplateConfigsNamespacer

+}

+

+// NewCmdAppJSON imports an app.json file (schema described here: https://devcenter.heroku.com/articles/app-json-schema)

+// as a template.

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

+	options := &AppJSONOptions{

+		Action: configcmd.BulkAction{

+			Out:    out,

+			ErrOut: errout,

+		},

+		In:        in,

+		Generator: AppJSONV1GeneratorName,

+	}

+	cmd := &cobra.Command{

+		Use:     "app.json -f APPJSON",

+		Short:   "Import an app.json definition into OpenShift",

+		Long:    appJSONLong,

+		Example: fmt.Sprintf(appJSONExample, 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 app.json file to use"

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

+	cmd.MarkFlagRequired("filename")

+

+	cmd.Flags().StringVar(&options.BaseImage, "image", options.BaseImage, "An optional image to use as your base Docker build (must have ONBUILD directives)")

+	cmd.Flags().String("generator", options.Generator, "The name of the generator strategy to use - specify this value to for backwards compatibility.")

+	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 *AppJSONOptions) 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 *AppJSONOptions) Validate() error {

+	if len(o.Filenames) != 1 {

+		return fmt.Errorf("you must provide the path to an app.json file or directory containing app.json")

+	}

+	switch o.Generator {

+	case AppJSONV1GeneratorName:

+	default:

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

+	}

+	return nil

+}

+

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

+	localPath, contents, err := contentsForPathOrURL(o.Filenames[0], o.In, "app.json")

+	if err != nil {

+		return err

+	}

+

+	g := &appjson.Generator{

+		LocalPath: localPath,

+		BaseImage: o.BaseImage,

+	}

+	switch {

+	case len(o.AsTemplate) > 0:

+		g.Name = o.AsTemplate

+	case len(localPath) > 0:

+		g.Name = filepath.Base(localPath)

+	default:

+		g.Name = path.Base(path.Dir(o.Filenames[0]))

+	}

+	if len(g.Name) == 0 {

+		g.Name = "app"

+	}

+

+	template, err := g.Generate(contents)

+	if err != nil {

+		return err

+	}

+

+	template.ObjectLabels = map[string]string{"app.json": template.Name}

+

+	// 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 app.json", "creating").Run(&kapi.List{Items: result.Objects}, o.Namespace); len(errs) > 0 {

+		return cmdutil.ErrExit

+	}

+	return nil

+}

+

+func contentsForPathOrURL(s string, in io.Reader, subpaths ...string) (string, []byte, error) {

+	switch {

+	case s == "-":

+		contents, err := ioutil.ReadAll(in)

+		return "", contents, err

+	case strings.Index(s, "http://") == 0 || strings.Index(s, "https://") == 0:

+		_, err := url.Parse(s)

+		if err != nil {

+			return "", nil, fmt.Errorf("the URL passed to filename %q is not valid: %v", s, err)

+		}

+		res, err := http.Get(s)

+		if err != nil {

+			return "", nil, err

+		}

+		defer res.Body.Close()

+		contents, err := ioutil.ReadAll(res.Body)

+		return "", contents, err

+	default:

+		stat, err := os.Stat(s)

+		if err != nil {

+			return s, nil, err

+		}

+		if !stat.IsDir() {

+			contents, err := ioutil.ReadFile(s)

+			return s, contents, err

+		}

+		for _, sub := range subpaths {

+			path := filepath.Join(s, sub)

+			stat, err := os.Stat(path)

+			if err != nil {

+				continue

+			}

+			if stat.IsDir() {

+				continue

+			}

+			contents, err := ioutil.ReadFile(s)

+			return path, contents, err

+		}

+		return s, nil, os.ErrNotExist

+	}

+}

@@ -29,5 +29,6 @@ func NewCmdImport(fullName string, f *clientcmd.Factory, in io.Reader, out, erro

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

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

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

 	return cmd

 }

@@ -276,13 +276,18 @@ func (r *BuildRef) BuildConfig() (*buildapi.BuildConfig, error) {

 	}, nil

 }

+type DeploymentHook struct {

+	Shell string

+}

+

 // DeploymentConfigRef is a reference to a deployment configuration

 type DeploymentConfigRef struct {

-	Name   string

-	Images []*ImageRef

-	Env    Environment

-	Labels map[string]string

-	AsTest bool

+	Name     string

+	Images   []*ImageRef

+	Env      Environment

+	Labels   map[string]string

+	AsTest   bool

+	PostHook *DeploymentHook

 }

 // DeploymentConfig creates a deploymentConfig resource from the deployment configuration reference

@@ -348,7 +353,7 @@ func (r *DeploymentConfigRef) DeploymentConfig() (*deployapi.DeploymentConfig, e

 		template.Containers[i].Env = append(template.Containers[i].Env, r.Env.List()...)

 	}

-	return &deployapi.DeploymentConfig{

+	dc := &deployapi.DeploymentConfig{

 		ObjectMeta: kapi.ObjectMeta{

 			Name: r.Name,

 		},

@@ -365,7 +370,21 @@ func (r *DeploymentConfigRef) DeploymentConfig() (*deployapi.DeploymentConfig, e

 			},

 			Triggers: triggers,

 		},

-	}, nil

+	}

+	if r.PostHook != nil {

+		//dc.Spec.Strategy.Type = "Rolling"

+		if len(r.PostHook.Shell) > 0 {

+			dc.Spec.Strategy.RecreateParams = &deployapi.RecreateDeploymentStrategyParams{

+				Post: &deployapi.LifecycleHook{

+					ExecNewPod: &deployapi.ExecNewPodHook{

+						Command: []string{"/bin/sh", "-c", r.PostHook.Shell},

+					},

+				},

+			}

+		}

+	}

+

+	return dc, nil

 }

 // GenerateSecret generates a random secret string

new file mode 100644

@@ -0,0 +1,412 @@

+package appjson

+

+import (

+	"encoding/json"

+	"fmt"

+	"path/filepath"

+	"strconv"

+	"strings"

+

+	"github.com/MakeNowJust/heredoc"

+	"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"

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

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

+)

+

+type EnvVarOrString struct {

+	Value  string

+	EnvVar *EnvVar

+}

+

+type EnvVar struct {

+	Description string

+	Generator   string

+	Value       string

+	Required    bool

+	Default     interface{}

+}

+

+func (e *EnvVarOrString) UnmarshalJSON(data []byte) error {

+	if len(data) < 2 {

+		return nil

+	}

+	if data[0] == '"' {

+		e.Value = string(data[1 : len(data)-1])

+		return nil

+	}

+	e.EnvVar = &EnvVar{}

+	return json.Unmarshal(data, e.EnvVar)

+}

+

+type Formation struct {

+	Quantity int32

+	Size     string

+	Command  string

+}

+

+type Buildpack struct {

+	URL string `json:"url"`

+}

+

+type AppJSON struct {

+	Name        string

+	Description string

+	Keywords    []string

+	Repository  string

+	Website     string

+	Logo        string

+	SuccessURL  string `json:"success_url"`

+	Scripts     map[string]string

+	Env         map[string]EnvVarOrString

+	Formation   map[string]Formation

+	Image       string

+	Addons      []string

+	Buildpacks  []Buildpack

+}

+

+type Generator struct {

+	LocalPath string

+	Name      string

+	BaseImage string

+}

+

+// Generate accepts a path to an app.json file and generates a template from it

+func (g *Generator) Generate(body []byte) (*templateapi.Template, error) {

+	appJSON := &AppJSON{}

+	if err := json.Unmarshal(body, appJSON); err != nil {

+		return nil, err

+	}

+

+	glog.V(4).Infof("app.json: %#v", appJSON)

+

+	name := g.Name

+	if len(name) == 0 && len(g.LocalPath) > 0 {

+		name = filepath.Base(g.LocalPath)

+	}

+

+	template := &templateapi.Template{}

+	template.Name = name

+	template.Annotations = make(map[string]string)

+	template.Annotations["openshift.io/website"] = appJSON.Website

+	template.Annotations["k8s.io/display-name"] = appJSON.Name

+	template.Annotations["k8s.io/description"] = appJSON.Description

+	template.Annotations["tags"] = strings.Join(appJSON.Keywords, ",")

+	template.Annotations["iconURL"] = appJSON.Logo

+

+	// create parameters and environment for containers

+	allEnv := make(app.Environment)

+	for k, v := range appJSON.Env {

+		if v.EnvVar != nil {

+			allEnv[k] = fmt.Sprintf("${%s}", k)

+		}

+	}

+	envVars := allEnv.List()

+	for _, v := range envVars {

+		env := appJSON.Env[v.Name]

+		if env.EnvVar == nil {

+			continue

+		}

+		e := env.EnvVar

+		displayName := v.Name

+		displayName = strings.Join(strings.Split(strings.ToLower(displayName), "_"), " ")

+		displayName = strings.ToUpper(displayName[:1]) + displayName[1:]

+		param := templateapi.Parameter{

+			Name:        v.Name,

+			DisplayName: displayName,

+			Description: e.Description,

+			Value:       e.Value,

+		}

+		switch e.Generator {

+		case "secret":

+			param.Generate = "expression"

+			param.From = "[a-zA-Z0-9]{14}"

+		}

+		if len(param.Value) == 0 && e.Default != nil {

+			switch t := e.Default.(type) {

+			case string:

+				param.Value = t

+			case float64, float32:

+				out, _ := json.Marshal(t)

+				param.Value = string(out)

+			}

+		}

+		template.Parameters = append(template.Parameters, param)

+	}

+

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

+

+	if len(appJSON.Formation) == 0 {

+		glog.V(4).Infof("No formation in app.json, adding a default web")

+		// TODO: read Procfile for command?

+		appJSON.Formation = map[string]Formation{

+			"web": {

+				Quantity: 1,

+			},

+		}

+		msg := "adding a default formation 'web' with scale 1"

+		warnings[msg] = append(warnings[msg], "app.json")

+	}

+

+	formations := sets.NewString()

+	for k := range appJSON.Formation {

+		formations.Insert(k)

+	}

+

+	var primaryFormation = "web"

+	if _, ok := appJSON.Formation["web"]; !ok || len(appJSON.Formation) == 1 {

+		for k := range appJSON.Formation {

+			primaryFormation = k

+			break

+		}

+	}

+

+	imageGen := app.NewImageRefGenerator()

+

+	buildPath := appJSON.Repository

+	if len(buildPath) == 0 && len(g.LocalPath) > 0 {

+		buildPath = g.LocalPath

+	}

+	if len(buildPath) == 0 {

+		return nil, fmt.Errorf("app.json did not contain a repository URL and no local path was specified")

+	}

+

+	repo, err := app.NewSourceRepository(buildPath)

+	if err != nil {

+		return nil, err

+	}

+

+	var ports []string

+

+	var pipelines app.PipelineGroup

+	baseImage := g.BaseImage

+	if len(baseImage) == 0 {

+		baseImage = appJSON.Image

+	}

+	if len(baseImage) == 0 {

+		return nil, fmt.Errorf("Docker image required: provide an --image flag or 'image' key in app.json")

+	}

+

+	fakeDockerfile := heredoc.Docf(`

+      # Generated from app.json

+      FROM %s

+    `, baseImage)

+

+	dockerfilePath := filepath.Join(buildPath, "Dockerfile")

+	if df, err := app.NewDockerfileFromFile(dockerfilePath); err == nil {

+		repo.Info().Dockerfile = df

+		repo.Info().Path = dockerfilePath

+		ports = dockerfile.LastExposedPorts(df.AST())

+	}

+	// TODO: look for procfile for more info?

+

+	repo.BuildWithDocker()

+

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

+	if err != nil {

+		return nil, err

+	}

+	image.AsImageStream = true

+	image.TagDirectly = true

+	image.ObjectName = name

+	image.Tag = "from"

+

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

+	if err != nil {

+		return nil, err

+	}

+

+	// TODO: this should not be necessary

+	pipeline.Build.Source.Name = name

+	pipeline.Build.Source.DockerfileContents = fakeDockerfile

+	pipeline.Name = name

+	pipeline.Image.ObjectName = name

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

+

+	pipelines = append(pipelines, pipeline)

+

+	var errs []error

+

+	// create deployments for each formation

+	var group app.PipelineGroup

+	for _, component := range formations.List() {

+		componentName := fmt.Sprintf("%s-%s", name, component)

+		if formations.Len() == 1 {

+			componentName = name

+		}

+		formationName := component

+		formation := appJSON.Formation[component]

+

+		inputImage := pipelines[0].Image

+

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

+			for _, s := range ports {

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

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

+				}

+			}

+			if len(formation.Command) > 0 {

+				c.Args = []string{formation.Command}

+			} else {

+				msg := "no command defined, defaulting to command in the Procfile"

+				warnings[msg] = append(warnings[msg], formationName)

+				c.Args = []string{"/bin/sh", "-c", fmt.Sprintf("$(grep %s Procfile | cut -f 2 -d :)", formationName)}

+			}

+			c.Env = append(c.Env, envVars...)

+

+			c.Resources = resourcesForProfile(formation.Size)

+		}

+

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

+		if err != nil {

+			errs = append(errs, err)

+			break

+		}

+

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

+			return nil, err

+		}

+

+		if cmd, ok := appJSON.Scripts["postdeploy"]; ok && primaryFormation == component {

+			pipeline.Deployment.PostHook = &app.DeploymentHook{Shell: cmd}

+			delete(appJSON.Scripts, "postdeploy")

+		}

+

+		group = append(group, pipeline)

+	}

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

+		return nil, err

+	}

+	pipelines = append(pipelines, group...)

+

+	if len(errs) > 0 {

+		return nil, utilerrs.NewAggregate(errs)

+	}

+

+	acceptors := app.Acceptors{app.NewAcceptUnique(kapi.Scheme), app.AcceptNew}

+	objects := app.Objects{}

+	accept := app.NewAcceptFirst()

+	for _, p := range pipelines {

+		accepted, err := p.Objects(accept, acceptors)

+		if err != nil {

+			return nil, fmt.Errorf("can't setup %q: %v", p.From, err)

+		}

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

+	}

+

+	// create services for each object with a name based on alias.

+	var services []*kapi.Service

+	for _, obj := range objects {

+		switch t := obj.(type) {

+		case *deployapi.DeploymentConfig:

+			ports := app.UniqueContainerToServicePorts(app.AllContainerPorts(t.Spec.Template.Spec.Containers...))

+			if len(ports) == 0 {

+				continue

+			}

+			svc := app.GenerateService(t.ObjectMeta, t.Spec.Selector)

+			svc.Spec.Ports = ports

+			services = append(services, svc)

+		}

+	}

+	for _, svc := range services {

+		objects = append(objects, svc)

+	}

+

+	template.Objects = objects

+

+	// generate warnings

+	warnUnusableAppJSONElements("app.json", appJSON, warnings)

+	if len(warnings) > 0 {

+		allWarnings := sets.NewString()

+		for msg, services := range warnings {

+			allWarnings.Insert(fmt.Sprintf("%s: %s", strings.Join(services, ","), msg))

+		}

+		if template.Annotations == nil {

+			template.Annotations = make(map[string]string)

+		}

+		template.Annotations[app.GenerationWarningAnnotation] = fmt.Sprintf("not all app.json fields were honored:\n* %s", strings.Join(allWarnings.List(), "\n* "))

+	}

+

+	return template, nil

+}

+

+// warnUnusableAppJSONElements add warnings for unsupported elements in the provided service config

+func warnUnusableAppJSONElements(k string, v *AppJSON, warnings map[string][]string) {

+	fn := func(msg string) {

+		warnings[msg] = append(warnings[msg], k)

+	}

+	if len(v.Buildpacks) > 0 {

+		fn("buildpacks are not handled")

+	}

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

+		fn(fmt.Sprintf("addon %q is not supported and must be added separately", s))

+	}

+	if len(v.SuccessURL) > 0 {

+		fn("success_url is not handled")

+	}

+	for k, v := range v.Scripts {

+		fn(fmt.Sprintf("script directive %q for %q is not handled", v, k))

+	}

+}

+

+func checkForPorts(repo *app.SourceRepository) []string {

+	info := repo.Info()

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

+		return nil

+	}

+	node := info.Dockerfile.AST()

+	return dockerfile.LastExposedPorts(node)

+}

+

+// resourcesForProfile takes standard Heroku sizes described here:

+// https://devcenter.heroku.com/articles/dyno-types#available-dyno-types and turns them into

+// Kubernetes resource requests.

+func resourcesForProfile(profile string) kapi.ResourceRequirements {

+	profile = strings.ToLower(profile)

+	switch profile {

+	case "standard-2x":

+		return kapi.ResourceRequirements{

+			Limits: kapi.ResourceList{

+				kapi.ResourceCPU:    resource.MustParse("200m"),

+				kapi.ResourceMemory: resource.MustParse("1Gi"),

+			},

+		}

+	case "performance-m":

+		return kapi.ResourceRequirements{