climc: support job, statefulset, secret create

cmd/climc/shell/k8s/app.go

@@ -0,0 +1,26 @@
+package k8s
+
+import (
+	"yunion.io/x/onecloud/pkg/mcclient"
+	"yunion.io/x/onecloud/pkg/mcclient/modules/k8s"
+	o "yunion.io/x/onecloud/pkg/mcclient/options/k8s"
+)
+
+func initApp() {
+	R(
+		&o.K8sAppCreateFromFileOptions{},
+		"k8s-create",
+		"Create resource by file",
+		func(s *mcclient.ClientSession, args *o.K8sAppCreateFromFileOptions) error {
+			params, err := args.Params()
+			if err != nil {
+				return err
+			}
+			ret, err := k8s.AppFromFile.Create(s, params)
+			if err != nil {
+				return err
+			}
+			printObjectYAML(ret)
+			return nil
+		})
+}

cmd/climc/shell/k8s/cronjob.go

@@ -1,9 +1,30 @@
 package k8s
 
 import (
+	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/modules/k8s"
+	o "yunion.io/x/onecloud/pkg/mcclient/options/k8s"
 )
 
 func initCronJob() {
-	initK8sNamespaceResource("cronjob", k8s.CronJobs)
+	cmd := initK8sNamespaceResource("cronjob", k8s.CronJobs)
+	cmdN := cmd.CommandNameFactory
+	createCmd := NewCommand(
+		&o.CronJobCreateOptions{},
+		cmdN("create"),
+		"Create cronjob resource",
+		func(s *mcclient.ClientSession, args *o.JobCreateOptions) error {
+			params, err := args.Params()
+			if err != nil {
+				return err
+			}
+			ret, err := k8s.CronJobs.Create(s, params)
+			if err != nil {
+				return err
+			}
+			printObject(ret)
+			return nil
+		})
+
+	cmd.AddR(createCmd)
 }

cmd/climc/shell/k8s/deployment.go

@@ -27,22 +27,5 @@ func initDeployment() {
 			return nil
 		})
 
-	createFromFileCmd := NewCommand(
-		&o.DeploymentCreateFromFileOptions{},
-		"k8s-create",
-		"Create resource by file",
-		func(s *mcclient.ClientSession, args *o.DeploymentCreateFromFileOptions) error {
-			params, err := args.Params()
-			if err != nil {
-				return err
-			}
-			ret, err := k8s.DeployFromFile.Create(s, params)
-			if err != nil {
-				return err
-			}
-			printObjectYAML(ret)
-			return nil
-		})
-
-	cmd.AddR(createCmd, createFromFileCmd)
+	cmd.AddR(createCmd)
 }

cmd/climc/shell/k8s/job.go

@@ -1,9 +1,31 @@
 package k8s
 
 import (
+	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/modules/k8s"
+	o "yunion.io/x/onecloud/pkg/mcclient/options/k8s"
 )
 
 func initJob() {
-	initK8sNamespaceResource("job", k8s.Jobs)
+	cmd := initK8sNamespaceResource("job", k8s.Jobs)
+	cmdN := cmd.CommandNameFactory
+
+	createCmd := NewCommand(
+		&o.JobCreateOptions{},
+		cmdN("create"),
+		"Create job resource",
+		func(s *mcclient.ClientSession, args *o.JobCreateOptions) error {
+			params, err := args.Params()
+			if err != nil {
+				return err
+			}
+			ret, err := k8s.Jobs.Create(s, params)
+			if err != nil {
+				return err
+			}
+			printObject(ret)
+			return nil
+		})
+
+	cmd.AddR(createCmd)
 }

cmd/climc/shell/k8s/k8s.go

@@ -40,6 +40,8 @@ func init() {
 	initPVC()
 	initJob()
 	initCronJob()
+
+	initApp()
 }
 
 var (
@@ -110,15 +112,19 @@ func (c *ShellCommands) AddR(rs ...*Cmd) *ShellCommands {
 }
 
 func initK8sClusterResource(kind string, manager modules.Manager) *ShellCommands {
-	cmdN := func(suffix string) string {
-		return resourceCmdN(kind, suffix)
-	}
+	cmdN := NewCmdNameFactory(kind)
+	return NewShellCommands(cmdN.Do).AddR(
+		NewK8sResourceListCmd(cmdN, manager),
+		NewK8sResourceGetCmd(cmdN, manager),
+		NewK8sResourceDeleteCmd(cmdN, manager),
+	)
+}
 
-	// List resource
-	listCmd := NewCommand(
+func NewK8sResourceListCmd(cmdN CmdNameFactory, manager modules.Manager) *Cmd {
+	return NewCommand(
 		&o.ResourceListOptions{},
-		cmdN("list"),
-		fmt.Sprintf("List k8s %s", kind),
+		cmdN.Do("list"),
+		fmt.Sprintf("List k8s %s", cmdN.Kind),
 		func(s *mcclient.ClientSession, args *o.ResourceListOptions) error {
 			ret, err := manager.List(s, args.Params())
 			if err != nil {
@@ -128,47 +134,27 @@ func initK8sClusterResource(kind string, manager modules.Manager) *ShellCommands
 			return nil
 		},
 	)
-
-	// Get resource details
-	getCmd := NewCommand(
-		&o.ResourceGetOptions{},
-		cmdN("show"),
-		fmt.Sprintf("Show k8s %s", kind),
-		func(s *mcclient.ClientSession, args *o.ResourceGetOptions) error {
-			ret, err := manager.Get(s, args.NAME, args.Params())
-			if err != nil {
-				return err
-			}
-			printObjectYAML(ret)
-			return nil
-		},
-	)
-
-	// Delete resource
-	deleteCmd := NewCommand(
-		&o.ResourceDeleteOptions{},
-		cmdN("delete"),
-		fmt.Sprintf("Delete k8s %s", kind),
-		func(s *mcclient.ClientSession, args *o.ResourceDeleteOptions) error {
-			ret := manager.BatchDelete(s, args.NAME, args.Params())
-			printBatchResults(ret, manager.GetColumns(s))
-			return nil
-		},
-	)
-
-	return NewShellCommands(cmdN).AddR(listCmd, getCmd, deleteCmd)
 }
 
-func initK8sNamespaceResource(kind string, manager modules.Manager) *ShellCommands {
-	cmdN := func(suffix string) string {
-		return resourceCmdN(kind, suffix)
-	}
+type CmdNameFactory struct {
+	Kind string
+	Do   func(string) string
+}
 
-	// List resource
-	listCmd := NewCommand(
+func NewCmdNameFactory(kind string) CmdNameFactory {
+	return CmdNameFactory{
+		Kind: kind,
+		Do: func(suffix string) string {
+			return resourceCmdN(kind, suffix)
+		},
+	}
+}
+
+func NewK8sNsResourceListCmd(cmdN CmdNameFactory, manager modules.Manager) *Cmd {
+	return NewCommand(
 		&o.NamespaceResourceListOptions{},
-		cmdN("list"),
-		fmt.Sprintf("List k8s %s", kind),
+		cmdN.Do("list"),
+		fmt.Sprintf("List k8s %s", cmdN.Kind),
 		func(s *mcclient.ClientSession, args *o.NamespaceResourceListOptions) error {
 			ret, err := manager.List(s, args.Params())
 			if err != nil {
@@ -178,12 +164,29 @@ func initK8sNamespaceResource(kind string, manager modules.Manager) *ShellComman
 			return nil
 		},
 	)
+}
 
-	// Get resource details
-	getCmd := NewCommand(
+func NewK8sResourceGetCmd(cmdN CmdNameFactory, manager modules.Manager) *Cmd {
+	return NewCommand(
+		&o.ResourceGetOptions{},
+		cmdN.Do("show"),
+		fmt.Sprintf("Show k8s %s", cmdN.Kind),
+		func(s *mcclient.ClientSession, args *o.ResourceGetOptions) error {
+			ret, err := manager.Get(s, args.NAME, args.Params())
+			if err != nil {
+				return err
+			}
+			printObjectYAML(ret)
+			return nil
+		},
+	)
+}
+
+func NewK8sNsResourceGetCmd(cmdN CmdNameFactory, manager modules.Manager) *Cmd {
+	return NewCommand(
 		&o.NamespaceResourceGetOptions{},
-		cmdN("show"),
-		fmt.Sprintf("Show k8s %s", kind),
+		cmdN.Do("show"),
+		fmt.Sprintf("Show k8s %s", cmdN.Kind),
 		func(s *mcclient.ClientSession, args *o.NamespaceResourceGetOptions) error {
 			ret, err := manager.Get(s, args.NAME, args.Params())
 			if err != nil {
@@ -193,17 +196,40 @@ func initK8sNamespaceResource(kind string, manager modules.Manager) *ShellComman
 			return nil
 		},
 	)
+}
 
-	// Delete resource
+func NewK8sResourceDeleteCmd(cmdN CmdNameFactory, manager modules.Manager) *Cmd {
+	return NewCommand(
+		&o.ResourceDeleteOptions{},
+		cmdN.Do("delete"),
+		fmt.Sprintf("Delete k8s %s", cmdN.Kind),
+		func(s *mcclient.ClientSession, args *o.ResourceDeleteOptions) error {
+			ret := manager.BatchDelete(s, args.NAME, args.Params())
+			printBatchResults(ret, manager.GetColumns(s))
+			return nil
+		},
+	)
+}
+
+func NewK8sNsResourceDeleteCmd(cmdN CmdNameFactory, manager modules.Manager) *Cmd {
 	deleteCmd := NewCommand(
 		&o.NamespaceResourceDeleteOptions{},
-		cmdN("delete"),
-		fmt.Sprintf("Delete k8s %s", kind),
+		cmdN.Do("delete"),
+		fmt.Sprintf("Delete k8s %s", cmdN.Kind),
 		func(s *mcclient.ClientSession, args *o.NamespaceResourceDeleteOptions) error {
 			ret := manager.BatchDelete(s, args.NAME, args.Params())
 			printBatchResults(ret, manager.GetColumns(s))
 			return nil
 		},
 	)
-	return NewShellCommands(cmdN).AddR(listCmd, getCmd, deleteCmd)
+	return deleteCmd
+}
+
+func initK8sNamespaceResource(kind string, manager modules.Manager) *ShellCommands {
+	cmdN := NewCmdNameFactory(kind)
+	return NewShellCommands(cmdN.Do).AddR(
+		NewK8sNsResourceListCmd(cmdN, manager),
+		NewK8sNsResourceGetCmd(cmdN, manager),
+		NewK8sNsResourceDeleteCmd(cmdN, manager),
+	)
 }

cmd/climc/shell/k8s/secret.go

@@ -1,9 +1,47 @@
 package k8s
 
 import (
+	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/modules/k8s"
+	o "yunion.io/x/onecloud/pkg/mcclient/options/k8s"
 )
 
 func initSecret() {
-	initK8sNamespaceResource("secret", k8s.Secrets)
+	cmdN := NewCmdNameFactory("secret")
+	secretCmd := NewShellCommands(cmdN.Do).AddR(
+		NewK8sNsResourceGetCmd(cmdN, k8s.Secrets),
+		NewK8sNsResourceDeleteCmd(cmdN, k8s.Secrets),
+	)
+	listCmd := NewCommand(
+		&o.SecretListOptions{},
+		cmdN.Do("list"),
+		"List secret resource",
+		func(s *mcclient.ClientSession, args *o.SecretListOptions) error {
+			ret, err := k8s.Secrets.List(s, args.Params())
+			if err != nil {
+				return err
+			}
+			PrintListResultTable(ret, k8s.Secrets, s)
+			return nil
+		})
+	secretCmd.AddR(listCmd)
+
+	registryCmd := initK8sNamespaceResource("registrysecret", k8s.RegistrySecrets)
+	createCmd := NewCommand(
+		&o.RegistrySecretCreateOptions{},
+		resourceCmdN("registrysecret", "create"),
+		"Create docker registry secret resource",
+		func(s *mcclient.ClientSession, args *o.RegistrySecretCreateOptions) error {
+			params, err := args.Params()
+			if err != nil {
+				return err
+			}
+			ret, err := k8s.RegistrySecrets.Create(s, params)
+			if err != nil {
+				return err
+			}
+			printObject(ret)
+			return nil
+		})
+	registryCmd.AddR(createCmd)
 }

cmd/climc/shell/k8s/statefulset.go

@@ -1,9 +1,31 @@
 package k8s
 
 import (
+	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/modules/k8s"
+	o "yunion.io/x/onecloud/pkg/mcclient/options/k8s"
 )
 
 func initStatefulset() {
-	initK8sNamespaceResource("statefulset", k8s.StatefulSets)
+	cmd := initK8sNamespaceResource("statefulset", k8s.StatefulSets)
+	cmdN := cmd.CommandNameFactory
+
+	createCmd := NewCommand(
+		&o.StatefulSetCreateOptions{},
+		cmdN("create"),
+		"Create statefulset resource",
+		func(s *mcclient.ClientSession, args *o.StatefulSetCreateOptions) error {
+			params, err := args.Params()
+			if err != nil {
+				return err
+			}
+			ret, err := k8s.StatefulSets.Create(s, params)
+			if err != nil {
+				return err
+			}
+			printObject(ret)
+			return nil
+		})
+
+	cmd.AddR(createCmd)
 }

pkg/mcclient/modules/k8s/app.go

@@ -0,0 +1,31 @@
+package k8s
+
+import (
+	"yunion.io/x/onecloud/pkg/mcclient/modules"
+)
+
+var (
+	Apps        *AppManager
+	AppFromFile *AppFromFileManager
+)
+
+type AppManager struct {
+	*NamespaceResourceManager
+}
+
+type AppFromFileManager struct {
+	*NamespaceResourceManager
+}
+
+func init() {
+	Apps = &AppManager{
+		NewNamespaceResourceManager("app", "apps",
+			NewNamespaceCols(), NewColumns())}
+
+	AppFromFile = &AppFromFileManager{
+		NewNamespaceResourceManager("appfromfile", "appfromfiles",
+			NewNamespaceCols(), NewColumns())}
+
+	modules.Register(Apps)
+	modules.Register(AppFromFile)
+}

pkg/mcclient/modules/k8s/deployment.go

@@ -5,27 +5,17 @@ import (
 )
 
 var (
-	Deployments    *DeploymentManager
-	DeployFromFile *DeployFromFileManager
+	Deployments *DeploymentManager
 )
 
 type DeploymentManager struct {
 	*NamespaceResourceManager
 }
 
-type DeployFromFileManager struct {
-	*NamespaceResourceManager
-}
-
 func init() {
 	Deployments = &DeploymentManager{
 		NewNamespaceResourceManager("deployment", "deployments",
 			NewNamespaceCols(), NewColumns())}
 
-	DeployFromFile = &DeployFromFileManager{
-		NewNamespaceResourceManager("deployfromfile", "deployfromfiles",
-			NewNamespaceCols(), NewColumns())}
-
 	modules.Register(Deployments)
-	modules.Register(DeployFromFile)
 }

pkg/mcclient/modules/k8s/secret.go

@@ -6,17 +6,31 @@ import (
 	"yunion.io/x/onecloud/pkg/mcclient/modules"
 )
 
-var Secrets *SecretManager
+var (
+	Secrets         *SecretManager
+	RegistrySecrets *RegistrySecretManager
+)
 
 type SecretManager struct {
 	*NamespaceResourceManager
 }
 
+type RegistrySecretManager struct {
+	*SecretManager
+}
+
 func init() {
 	Secrets = &SecretManager{
 		NewNamespaceResourceManager("secret", "secrets",
 			NewNamespaceCols("Type"), NewColumns())}
+
+	RegistrySecrets = &RegistrySecretManager{
+		SecretManager: &SecretManager{
+			NewNamespaceResourceManager("registrysecret", "registrysecrets", NewNamespaceCols(), NewColumns())},
+	}
+
 	modules.Register(Secrets)
+	modules.Register(RegistrySecrets)
 }
 
 func (m SecretManager) GetType(obj jsonutils.JSONObject) interface{} {

pkg/mcclient/options/k8s/app.go

@@ -0,0 +1,188 @@
+package k8s
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strconv"
+	"strings"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/pkg/util/regutils"
+	"yunion.io/x/pkg/util/sets"
+)
+
+type K8sAppBaseCreateOptions struct {
+	NamespaceWithClusterOptions
+	NAME            string   `help:"Name of deployment"`
+	Image           string   `help:"The image for the container to run" required:"true"`
+	Replicas        int64    `help:"Number of replicas for pods in this deployment"`
+	RunAsPrivileged bool     `help:"Whether to run the container as privileged user"`
+	RegistrySecret  string   `help:"Docker registry secret"`
+	Label           []string `help:"Labels to apply to the pod(s), e.g. 'env=prod'"`
+	Env             []string `help:"Environment variables to set in container"`
+	Port            []string `help:"Port for the service that is created, format is <protocol>:<service_port>:<container_port> e.g. tcp:80:3000"`
+	Net             string   `help:"Network config, e.g. net1, net1:10.168.222.171"`
+	Mem             int      `help:"Memory request MB size"`
+	Cpu             float64  `help:"Cpu request cores"`
+	Command         string   `help:"Container start command"`
+	CommandArgs     string   `help:"Container start command args"`
+}
+
+func (o K8sAppBaseCreateOptions) Params() (*jsonutils.JSONDict, error) {
+	params := o.NamespaceWithClusterOptions.Params()
+	params.Add(jsonutils.NewString(o.NAME), "name")
+	if len(o.Image) == 0 {
+		return nil, fmt.Errorf("Image must provided")
+	}
+	params.Add(jsonutils.NewString(o.Image), "containerImage")
+	if o.Replicas > 1 {
+		params.Add(jsonutils.NewInt(o.Replicas), "replicas")
+	}
+	if o.RunAsPrivileged {
+		params.Add(jsonutils.JSONTrue, "runAsPrivileged")
+	}
+	if len(o.Port) != 0 {
+		portMappings, err := parsePortMappings(o.Port)
+		if err != nil {
+			return nil, err
+		}
+		params.Add(portMappings, "portMappings")
+	}
+	envList := jsonutils.NewArray()
+	for _, env := range o.Env {
+		parts := strings.Split(env, "=")
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("Bad env value: %v", env)
+		}
+		envObj := jsonutils.NewDict()
+		envObj.Add(jsonutils.NewString(parts[0]), "name")
+		envObj.Add(jsonutils.NewString(parts[1]), "value")
+		envList.Add(envObj)
+	}
+	params.Add(envList, "variables")
+	if o.Net != "" {
+		net, err := parseNetConfig(o.Net)
+		if err != nil {
+			return nil, err
+		}
+		params.Add(net, "networkConfig")
+	}
+	labels := jsonutils.NewArray()
+	for _, label := range o.Label {
+		label, err := parseLabel(label)
+		if err != nil {
+			return nil, err
+		}
+		labels.Add(label)
+	}
+	params.Add(labels, "labels")
+
+	if o.Cpu > 0 {
+		params.Add(jsonutils.NewString(fmt.Sprintf("%dm", int64(o.Cpu*1000))), "cpuRequirement")
+	}
+	if o.Mem > 0 {
+		params.Add(jsonutils.NewString(fmt.Sprintf("%dMi", o.Mem)), "memoryRequirement")
+	}
+	if o.RegistrySecret != "" {
+		params.Add(jsonutils.NewString(o.RegistrySecret), "imagePullSecret")
+	}
+	if o.Command != "" {
+		params.Add(jsonutils.NewString(o.Command), "containerCommand")
+	}
+	if o.CommandArgs != "" {
+		params.Add(jsonutils.NewString(o.CommandArgs), "containerCommandArgs")
+	}
+	return params, nil
+}
+
+type portMapping struct {
+	Port       int32  `json:"port"`
+	TargetPort int32  `json:"targetPort"`
+	Protocol   string `json:"protocol"`
+}
+
+func parsePortMapping(port string) (*portMapping, error) {
+	if len(port) == 0 {
+		return nil, fmt.Errorf("empty port mapping desc string")
+	}
+	parts := strings.Split(port, ":")
+	mapping := &portMapping{}
+	for _, part := range parts {
+		if sets.NewString("tcp", "udp").Has(strings.ToLower(part)) {
+			mapping.Protocol = strings.ToUpper(part)
+		}
+		if port, err := strconv.Atoi(part); err != nil {
+			continue
+		} else {
+			if mapping.Port == 0 {
+				mapping.Port = int32(port)
+			} else {
+				mapping.TargetPort = int32(port)
+			}
+		}
+	}
+	if mapping.Protocol == "" {
+		mapping.Protocol = "TCP"
+	}
+	if mapping.Port <= 0 {
+		return nil, fmt.Errorf("Service port not provided")
+	}
+	if mapping.TargetPort < 0 {
+		return nil, fmt.Errorf("Container invalid targetPort %d", mapping.TargetPort)
+	}
+	if mapping.TargetPort == 0 {
+		mapping.TargetPort = mapping.Port
+	}
+	return mapping, nil
+}
+
+func parsePortMappings(ports []string) (*jsonutils.JSONArray, error) {
+	ret := jsonutils.NewArray()
+	for _, port := range ports {
+		mapping, err := parsePortMapping(port)
+		if err != nil {
+			return nil, fmt.Errorf("Port %q error: %v", port, err)
+		}
+		ret.Add(jsonutils.Marshal(mapping))
+	}
+	return ret, nil
+}
+
+func parseNetConfig(net string) (*jsonutils.JSONDict, error) {
+	ret := jsonutils.NewDict()
+	for _, p := range strings.Split(net, ":") {
+		if regutils.MatchIP4Addr(p) {
+			ret.Add(jsonutils.NewString(p), "address")
+		} else {
+			ret.Add(jsonutils.NewString(p), "network")
+		}
+	}
+	return ret, nil
+}
+
+type K8sAppCreateFromFileOptions struct {
+	NamespaceResourceGetOptions
+	FILE string `help:"K8s resource YAML or JSON file"`
+}
+
+func (o K8sAppCreateFromFileOptions) Params() (*jsonutils.JSONDict, error) {
+	params := o.NamespaceResourceGetOptions.Params()
+	params.Add(jsonutils.NewString(o.NAME), "name")
+	content, err := ioutil.ReadFile(o.FILE)
+	if err != nil {
+		return nil, err
+	}
+	params.Add(jsonutils.NewString(string(content)), "content")
+	return params, nil
+}
+
+func parseLabel(str string) (jsonutils.JSONObject, error) {
+	parts := strings.Split(str, "=")
+	if len(parts) != 2 {
+		return nil, fmt.Errorf("Invalid label string: %s", str)
+	}
+	label := jsonutils.NewDict()
+	label.Add(jsonutils.NewString(parts[0]), "key")
+	label.Add(jsonutils.NewString(parts[1]), "value")
+	return label, nil
+}

pkg/mcclient/options/k8s/deployment.go

@@ -1,176 +1,51 @@
 package k8s
 
 import (
-	"fmt"
-	"io/ioutil"
-	"strconv"
-	"strings"
-
 	"yunion.io/x/jsonutils"
-	"yunion.io/x/pkg/util/regutils"
-	"yunion.io/x/pkg/util/sets"
 )
 
 type DeploymentCreateOptions struct {
-	NamespaceWithClusterOptions
-	NAME            string   `help:"Name of deployment"`
-	Image           string   `help:"The image for the container to run"`
-	Replicas        int64    `help:"Number of replicas for pods in this deployment"`
-	RunAsPrivileged bool     `help:"Whether to run the container as privileged user"`
-	Label           []string `help:"Labels to apply to the pod(s), e.g. 'env=prod'"`
-	Env             []string `help:"Environment variables to set in container"`
-	Port            []string `help:"Port for the service that is created, format is <protocol>:<service_port>:<container_port> e.g. tcp:80:3000"`
-	Net             string   `help:"Network config, e.g. net1, net1:10.168.222.171"`
-	Mem             int      `help:"Memory request MB size"`
-	Cpu             float64  `help:"Cpu request cores"`
+	K8sAppBaseCreateOptions
 }
 
 func (o DeploymentCreateOptions) Params() (*jsonutils.JSONDict, error) {
-	params := o.NamespaceWithClusterOptions.Params()
-	params.Add(jsonutils.NewString(o.NAME), "name")
-	if len(o.Image) == 0 {
-		return nil, fmt.Errorf("Image must provided")
-	}
-	params.Add(jsonutils.NewString(o.Image), "containerImage")
-	if o.Replicas > 1 {
-		params.Add(jsonutils.NewInt(o.Replicas), "replicas")
-	}
-	if o.RunAsPrivileged {
-		params.Add(jsonutils.JSONTrue, "runAsPrivileged")
-	}
-	if len(o.Port) != 0 {
-		portMappings, err := parsePortMappings(o.Port)
-		if err != nil {
-			return nil, err
-		}
-		params.Add(portMappings, "portMappings")
-	}
-	envList := jsonutils.NewArray()
-	for _, env := range o.Env {
-		parts := strings.Split(env, "=")
-		if len(parts) != 2 {
-			return nil, fmt.Errorf("Bad env value: %v", env)
-		}
-		envObj := jsonutils.NewDict()
-		envObj.Add(jsonutils.NewString(parts[0]), "name")
-		envObj.Add(jsonutils.NewString(parts[1]), "value")
-		envList.Add(envObj)
-	}
-	params.Add(envList, "variables")
-	if o.Net != "" {
-		net, err := parseNetConfig(o.Net)
-		if err != nil {
-			return nil, err
-		}
-		params.Add(net, "networkConfig")
-	}
-	labels := jsonutils.NewArray()
-	for _, label := range o.Label {
-		label, err := parseLabel(label)
-		if err != nil {
-			return nil, err
-		}
-		labels.Add(label)
-	}
-	params.Add(labels, "labels")
-
-	if o.Cpu > 0 {
-		params.Add(jsonutils.NewString(fmt.Sprintf("%dm", int64(o.Cpu*1000))), "cpuRequirement")
-	}
-	if o.Mem > 0 {
-		params.Add(jsonutils.NewString(fmt.Sprintf("%dMi", o.Mem)), "memoryRequirement")
-	}
-	return params, nil
-}
-
-type portMapping struct {
-	Port       int32  `json:"port"`
-	TargetPort int32  `json:"targetPort"`
-	Protocol   string `json:"protocol"`
-}
-
-func parsePortMapping(port string) (*portMapping, error) {
-	if len(port) == 0 {
-		return nil, fmt.Errorf("empty port mapping desc string")
-	}
-	parts := strings.Split(port, ":")
-	mapping := &portMapping{}
-	for _, part := range parts {
-		if sets.NewString("tcp", "udp").Has(strings.ToLower(part)) {
-			mapping.Protocol = strings.ToUpper(part)
-		}
-		if port, err := strconv.Atoi(part); err != nil {
-			continue
-		} else {
-			if mapping.Port == 0 {
-				mapping.Port = int32(port)
-			} else {
-				mapping.TargetPort = int32(port)
-			}
-		}
-	}
-	if mapping.Protocol == "" {
-		mapping.Protocol = "TCP"
-	}
-	if mapping.Port <= 0 {
-		return nil, fmt.Errorf("Service port not provided")
-	}
-	if mapping.TargetPort < 0 {
-		return nil, fmt.Errorf("Container invalid targetPort %d", mapping.TargetPort)
-	}
-	if mapping.TargetPort == 0 {
-		mapping.TargetPort = mapping.Port
-	}
-	return mapping, nil
-}
-
-func parsePortMappings(ports []string) (*jsonutils.JSONArray, error) {
-	ret := jsonutils.NewArray()
-	for _, port := range ports {
-		mapping, err := parsePortMapping(port)
-		if err != nil {
-			return nil, fmt.Errorf("Port %q error: %v", port, err)
-		}
-		ret.Add(jsonutils.Marshal(mapping))
-	}
-	return ret, nil
-}
-
-func parseNetConfig(net string) (*jsonutils.JSONDict, error) {
-	ret := jsonutils.NewDict()
-	for _, p := range strings.Split(net, ":") {
-		if regutils.MatchIP4Addr(p) {
-			ret.Add(jsonutils.NewString(p), "address")
-		} else {
-			ret.Add(jsonutils.NewString(p), "network")
-		}
-	}
-	return ret, nil
-}
-
-type DeploymentCreateFromFileOptions struct {
-	NamespaceResourceGetOptions
-	FILE string `help:"K8s resource YAML or JSON file"`
-}
-
-func (o DeploymentCreateFromFileOptions) Params() (*jsonutils.JSONDict, error) {
-	params := o.NamespaceResourceGetOptions.Params()
-	params.Add(jsonutils.NewString(o.NAME), "name")
-	content, err := ioutil.ReadFile(o.FILE)
+	params, err := o.K8sAppBaseCreateOptions.Params()
 	if err != nil {
 		return nil, err
 	}
-	params.Add(jsonutils.NewString(string(content)), "content")
 	return params, nil
 }
 
-func parseLabel(str string) (jsonutils.JSONObject, error) {
-	parts := strings.Split(str, "=")
-	if len(parts) != 2 {
-		return nil, fmt.Errorf("Invalid label string: %s", str)
+type StatefulSetCreateOptions struct {
+	K8sAppBaseCreateOptions
+}
+
+type JobCreateOptions struct {
+	K8sAppBaseCreateOptions
+	Parallelism int64 `help:"Specifies the maximum desired number of pods the job should run at any given time"`
+}
+
+func (o JobCreateOptions) Params() (*jsonutils.JSONDict, error) {
+	params, err := o.K8sAppBaseCreateOptions.Params()
+	if err != nil {
+		return nil, err
 	}
-	label := jsonutils.NewDict()
-	label.Add(jsonutils.NewString(parts[0]), "key")
-	label.Add(jsonutils.NewString(parts[1]), "value")
-	return label, nil
+	if o.Parallelism > 0 {
+		params.Add(jsonutils.NewInt(o.Parallelism), "parallelism")
+	}
+	return params, nil
+}
+
+type CronJobCreateOptions struct {
+	JobCreateOptions
+	Schedule string `help:"The chedule in Cron format, e.g. '*/10 * * * *'" required:"true"`
+}
+
+func (o CronJobCreateOptions) Params() (*jsonutils.JSONDict, error) {
+	params, err := o.JobCreateOptions.Params()
+	if err != nil {
+		return nil, err
+	}
+	params.Add(jsonutils.NewString(o.Schedule), "schedule")
+	return params, nil
 }

pkg/mcclient/options/k8s/secret.go

@@ -0,0 +1,39 @@
+package k8s
+
+import (
+	"yunion.io/x/jsonutils"
+)
+
+type SecretListOptions struct {
+	NamespaceResourceListOptions
+	Type string `help:"Secret type"`
+}
+
+func (o SecretListOptions) Params() *jsonutils.JSONDict {
+	params := o.NamespaceResourceListOptions.Params()
+	if o.Type != "" {
+		params.Add(jsonutils.NewString(o.Type), "type")
+	}
+	return params
+}
+
+type RegistrySecretCreateOptions struct {
+	NamespaceWithClusterOptions
+	NAME     string `help:"Name of secret"`
+	Server   string `help:"Docker registry server, e.g. 'https://index.docker.io/v1/'" required:"true"`
+	User     string `help:"Docker registry user" required:"true"`
+	Password string `help:"Docker registry password" required:"true"`
+	Email    string `help:"Docker registry user email"`
+}
+
+func (o RegistrySecretCreateOptions) Params() (*jsonutils.JSONDict, error) {
+	params := o.NamespaceWithClusterOptions.Params()
+	params.Add(jsonutils.NewString(o.NAME), "name")
+	params.Add(jsonutils.NewString(o.Server), "server")
+	params.Add(jsonutils.NewString(o.User), "user")
+	params.Add(jsonutils.NewString(o.Password), "password")
+	if o.Email != "" {
+		params.Add(jsonutils.NewString(o.Email), "email")
+	}
+	return params, nil
+}