kubectl run to produce deployment and job

pkg/kubectl/run.go

@@ -23,10 +23,264 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
+	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/validation"
 )
 
+type DeploymentV1Beta1 struct{}
+
+func (DeploymentV1Beta1) ParamNames() []GeneratorParam {
+	return []GeneratorParam{
+		{"labels", false},
+		{"default-name", false},
+		{"name", true},
+		{"replicas", true},
+		{"image", true},
+		{"port", false},
+		{"hostport", false},
+		{"stdin", false},
+		{"tty", false},
+		{"command", false},
+		{"args", false},
+		{"env", false},
+		{"requests", false},
+		{"limits", false},
+	}
+}
+
+func (DeploymentV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+	args, err := getArgs(genericParams)
+	if err != nil {
+		return nil, err
+	}
+
+	envs, err := getEnvs(genericParams)
+	if err != nil {
+		return nil, err
+	}
+
+	params, err := getParams(genericParams)
+	if err != nil {
+		return nil, err
+	}
+
+	name, err := getName(params)
+	if err != nil {
+		return nil, err
+	}
+
+	labels, err := getLabels(params, true, name)
+	if err != nil {
+		return nil, err
+	}
+
+	count, err := strconv.Atoi(params["replicas"])
+	if err != nil {
+		return nil, err
+	}
+
+	podSpec, err := makePodSpec(params, name)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = updatePodContainers(params, args, envs, podSpec); err != nil {
+		return nil, err
+	}
+
+	if err := updatePodPorts(params, podSpec); err != nil {
+		return nil, err
+	}
+
+	// TODO: use versioned types for generators so that we don't need to
+	// set default values manually (see issue #17384)
+	deployment := extensions.Deployment{
+		ObjectMeta: api.ObjectMeta{
+			Name:   name,
+			Labels: labels,
+		},
+		Spec: extensions.DeploymentSpec{
+			Replicas: count,
+			Selector: labels,
+			Template: api.PodTemplateSpec{
+				ObjectMeta: api.ObjectMeta{
+					Labels: labels,
+				},
+				Spec: *podSpec,
+			},
+			UniqueLabelKey: "deployment.kubernetes.io/podTemplateHash",
+		},
+	}
+	return &deployment, nil
+}
+
+func getLabels(params map[string]string, defaultRunLabel bool, name string) (map[string]string, error) {
+	labelString, found := params["labels"]
+	var labels map[string]string
+	var err error
+	if found && len(labelString) > 0 {
+		labels, err = ParseLabels(labelString)
+		if err != nil {
+			return nil, err
+		}
+	} else if defaultRunLabel {
+		labels = map[string]string{
+			"run": name,
+		}
+	}
+	return labels, nil
+}
+
+func getName(params map[string]string) (string, error) {
+	name, found := params["name"]
+	if !found || len(name) == 0 {
+		name, found = params["default-name"]
+		if !found || len(name) == 0 {
+			return "", fmt.Errorf("'name' is a required parameter.")
+		}
+	}
+	return name, nil
+}
+
+func getParams(genericParams map[string]interface{}) (map[string]string, error) {
+	params := map[string]string{}
+	for key, value := range genericParams {
+		strVal, isString := value.(string)
+		if !isString {
+			return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
+		}
+		params[key] = strVal
+	}
+	return params, nil
+}
+
+func getArgs(genericParams map[string]interface{}) ([]string, error) {
+	args := []string{}
+	val, found := genericParams["args"]
+	if found {
+		var isArray bool
+		args, isArray = val.([]string)
+		if !isArray {
+			return nil, fmt.Errorf("expected []string, found: %v", val)
+		}
+		delete(genericParams, "args")
+	}
+	return args, nil
+}
+
+func getEnvs(genericParams map[string]interface{}) ([]api.EnvVar, error) {
+	var envs []api.EnvVar
+	envStrings, found := genericParams["env"]
+	if found {
+		if envStringArray, isArray := envStrings.([]string); isArray {
+			var err error
+			envs, err = parseEnvs(envStringArray)
+			if err != nil {
+				return nil, err
+			}
+			delete(genericParams, "env")
+		} else {
+			return nil, fmt.Errorf("expected []string, found: %v", envStrings)
+		}
+	}
+	return envs, nil
+}
+
+type JobV1Beta1 struct{}
+
+func (JobV1Beta1) ParamNames() []GeneratorParam {
+	return []GeneratorParam{
+		{"labels", false},
+		{"default-name", false},
+		{"name", true},
+		{"image", true},
+		{"port", false},
+		{"hostport", false},
+		{"stdin", false},
+		{"leave-stdin-open", false},
+		{"tty", false},
+		{"command", false},
+		{"args", false},
+		{"env", false},
+		{"requests", false},
+		{"limits", false},
+		{"restart", false},
+	}
+}
+
+func (JobV1Beta1) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
+	args, err := getArgs(genericParams)
+	if err != nil {
+		return nil, err
+	}
+
+	envs, err := getEnvs(genericParams)
+	if err != nil {
+		return nil, err
+	}
+
+	params, err := getParams(genericParams)
+	if err != nil {
+		return nil, err
+	}
+
+	name, err := getName(params)
+	if err != nil {
+		return nil, err
+	}
+
+	labels, err := getLabels(params, true, name)
+	if err != nil {
+		return nil, err
+	}
+
+	podSpec, err := makePodSpec(params, name)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = updatePodContainers(params, args, envs, podSpec); err != nil {
+		return nil, err
+	}
+
+	leaveStdinOpen, err := GetBool(params, "leave-stdin-open", false)
+	if err != nil {
+		return nil, err
+	}
+	podSpec.Containers[0].StdinOnce = !leaveStdinOpen && podSpec.Containers[0].Stdin
+
+	if err := updatePodPorts(params, podSpec); err != nil {
+		return nil, err
+	}
+
+	restartPolicy := api.RestartPolicy(params["restart"])
+	if len(restartPolicy) == 0 {
+		restartPolicy = api.RestartPolicyAlways
+	}
+	podSpec.RestartPolicy = restartPolicy
+
+	job := extensions.Job{
+		ObjectMeta: api.ObjectMeta{
+			Name:   name,
+			Labels: labels,
+		},
+		Spec: extensions.JobSpec{
+			Selector: &extensions.PodSelector{
+				MatchLabels: labels,
+			},
+			Template: api.PodTemplateSpec{
+				ObjectMeta: api.ObjectMeta{
+					Labels: labels,
+				},
+				Spec: *podSpec,
+			},
+		},
+	}
+
+	return &job, nil
+}
+
 type BasicReplicationController struct{}
 
 func (BasicReplicationController) ParamNames() []GeneratorParam {
@@ -119,62 +373,31 @@ func makePodSpec(params map[string]string, name string) (*api.PodSpec, error) {
 }
 
 func (BasicReplicationController) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
-	args := []string{}
-	val, found := genericParams["args"]
-	if found {
-		var isArray bool
-		args, isArray = val.([]string)
-		if !isArray {
-			return nil, fmt.Errorf("expected []string, found: %v", val)
-		}
-		delete(genericParams, "args")
+	args, err := getArgs(genericParams)
+	if err != nil {
+		return nil, err
 	}
 
-	// TODO: abstract this logic so that multiple generators can handle env in the same way. Same for parse envs.
-	var envs []api.EnvVar
-	envStrings, found := genericParams["env"]
-	if found {
-		if envStringArray, isArray := envStrings.([]string); isArray {
-			var err error
-			envs, err = parseEnvs(envStringArray)
-			if err != nil {
-				return nil, err
-			}
-			delete(genericParams, "env")
-		} else {
-			return nil, fmt.Errorf("expected []string, found: %v", envStrings)
-		}
+	envs, err := getEnvs(genericParams)
+	if err != nil {
+		return nil, err
 	}
 
-	params := map[string]string{}
-	for key, value := range genericParams {
-		strVal, isString := value.(string)
-		if !isString {
-			return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
-		}
-		params[key] = strVal
+	params, err := getParams(genericParams)
+	if err != nil {
+		return nil, err
 	}
-	name, found := params["name"]
-	if !found || len(name) == 0 {
-		name, found = params["default-name"]
-		if !found || len(name) == 0 {
-			return nil, fmt.Errorf("'name' is a required parameter.")
-		}
+
+	name, err := getName(params)
+	if err != nil {
+		return nil, err
 	}
-	// TODO: extract this flag to a central location.
-	labelString, found := params["labels"]
-	var labels map[string]string
-	var err error
-	if found && len(labelString) > 0 {
-		labels, err = ParseLabels(labelString)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		labels = map[string]string{
-			"run": name,
-		}
+
+	labels, err := getLabels(params, true, name)
+	if err != nil {
+		return nil, err
 	}
+
 	count, err := strconv.Atoi(params["replicas"])
 	if err != nil {
 		return nil, err
@@ -184,20 +407,13 @@ func (BasicReplicationController) Generate(genericParams map[string]interface{})
 	if err != nil {
 		return nil, err
 	}
-	if len(args) > 0 {
-		command, err := GetBool(params, "command", false)
-		if err != nil {
-			return nil, err
-		}
-		if command {
-			podSpec.Containers[0].Command = args
-		} else {
-			podSpec.Containers[0].Args = args
-		}
+
+	if err = updatePodContainers(params, args, envs, podSpec); err != nil {
+		return nil, err
 	}
 
-	if len(envs) > 0 {
-		podSpec.Containers[0].Env = envs
+	if err := updatePodPorts(params, podSpec); err != nil {
+		return nil, err
 	}
 
 	controller := api.ReplicationController{
@@ -216,12 +432,28 @@ func (BasicReplicationController) Generate(genericParams map[string]interface{})
 			},
 		},
 	}
-	if err := updatePodPorts(params, &controller.Spec.Template.Spec); err != nil {
-		return nil, err
-	}
 	return &controller, nil
 }
 
+func updatePodContainers(params map[string]string, args []string, envs []api.EnvVar, podSpec *api.PodSpec) error {
+	if len(args) > 0 {
+		command, err := GetBool(params, "command", false)
+		if err != nil {
+			return err
+		}
+		if command {
+			podSpec.Containers[0].Command = args
+		} else {
+			podSpec.Containers[0].Args = args
+		}
+	}
+
+	if len(envs) > 0 {
+		podSpec.Containers[0].Env = envs
+	}
+	return nil
+}
+
 func updatePodPorts(params map[string]string, podSpec *api.PodSpec) (err error) {
 	port := -1
 	hostPort := -1
@@ -279,57 +511,31 @@ func (BasicPod) ParamNames() []GeneratorParam {
 }
 
 func (BasicPod) Generate(genericParams map[string]interface{}) (runtime.Object, error) {
-	args := []string{}
-	val, found := genericParams["args"]
-	if found {
-		var isArray bool
-		args, isArray = val.([]string)
-		if !isArray {
-			return nil, fmt.Errorf("expected []string, found: %v", val)
-		}
-		delete(genericParams, "args")
-	}
-	// TODO: abstract this logic so that multiple generators can handle env in the same way. Same for parse envs.
-	var envs []api.EnvVar
-	envStrings, found := genericParams["env"]
-	if found {
-		if envStringArray, isArray := envStrings.([]string); isArray {
-			var err error
-			envs, err = parseEnvs(envStringArray)
-			if err != nil {
-				return nil, err
-			}
-			delete(genericParams, "env")
-		} else {
-			return nil, fmt.Errorf("expected []string, found: %v", envStrings)
-		}
+	args, err := getArgs(genericParams)
+	if err != nil {
+		return nil, err
 	}
 
-	params := map[string]string{}
-	for key, value := range genericParams {
-		strVal, isString := value.(string)
-		if !isString {
-			return nil, fmt.Errorf("expected string, saw %v for '%s'", value, key)
-		}
-		params[key] = strVal
+	envs, err := getEnvs(genericParams)
+	if err != nil {
+		return nil, err
 	}
-	name, found := params["name"]
-	if !found || len(name) == 0 {
-		name, found = params["default-name"]
-		if !found || len(name) == 0 {
-			return nil, fmt.Errorf("'name' is a required parameter.")
-		}
+
+	params, err := getParams(genericParams)
+	if err != nil {
+		return nil, err
 	}
-	// TODO: extract this flag to a central location.
-	labelString, found := params["labels"]
-	var labels map[string]string
-	var err error
-	if found && len(labelString) > 0 {
-		labels, err = ParseLabels(labelString)
-		if err != nil {
-			return nil, err
-		}
+
+	name, err := getName(params)
+	if err != nil {
+		return nil, err
 	}
+
+	labels, err := getLabels(params, false, name)
+	if err != nil {
+		return nil, err
+	}
+
 	stdin, err := GetBool(params, "stdin", false)
 	if err != nil {
 		return nil, err
@@ -374,20 +580,8 @@ func (BasicPod) Generate(genericParams map[string]interface{}) (runtime.Object,
 			RestartPolicy: restartPolicy,
 		},
 	}
-	if len(args) > 0 {
-		command, err := GetBool(params, "command", false)
-		if err != nil {
-			return nil, err
-		}
-		if command {
-			pod.Spec.Containers[0].Command = args
-		} else {
-			pod.Spec.Containers[0].Args = args
-		}
-	}
-
-	if len(envs) > 0 {
-		pod.Spec.Containers[0].Env = envs
+	if err = updatePodContainers(params, args, envs, &pod.Spec); err != nil {
+		return nil, err
 	}
 
 	if err := updatePodPorts(params, &pod.Spec); err != nil {