// NewCmdScale returns a cobra command with the appropriate configuration and flags to run scale func NewCmdScale(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &ScaleOptions{} cmd := &cobra.Command{ Use: "scale [--resource-version=version] [--current-replicas=count] --replicas=COUNT (-f FILENAME | TYPE NAME)", // resize is deprecated Aliases: []string{"resize"}, Short: "Set a new size for a Deployment, ReplicaSet, Replication Controller, or Job.", Long: scale_long, Example: scale_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(cmdutil.ValidateOutputArgs(cmd)) shortOutput := cmdutil.GetFlagString(cmd, "output") == "name" err := RunScale(f, out, cmd, args, shortOutput, options) cmdutil.CheckErr(err) }, } cmd.Flags().String("resource-version", "", "Precondition for resource version. Requires that the current resource version match this value in order to scale.") cmd.Flags().Int("current-replicas", -1, "Precondition for current size. Requires that the current size of the resource match this value in order to scale.") cmd.Flags().Int("replicas", -1, "The new desired number of replicas. Required.") cmd.MarkFlagRequired("replicas") cmd.Flags().Duration("timeout", 0, "The length of time to wait before giving up on a scale operation, zero means don't wait.") cmdutil.AddOutputFlagsForMutation(cmd) cmdutil.AddRecordFlag(cmd) cmdutil.AddInclude3rdPartyFlags(cmd) usage := "Filename, directory, or URL to a file identifying the resource to set a new size" kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage) cmdutil.AddRecursiveFlag(cmd, &options.Recursive) return cmd }
func NewCmdImage(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &ImageOptions{ Out: out, } cmd := &cobra.Command{ Use: "image (-f FILENAME | TYPE NAME) CONTAINER_NAME_1=CONTAINER_IMAGE_1 ... CONTAINER_NAME_N=CONTAINER_IMAGE_N", Short: "Update image of a pod template", Long: image_long, Example: image_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(options.Complete(f, cmd, args)) cmdutil.CheckErr(options.Validate()) cmdutil.CheckErr(options.Run()) }, } cmdutil.AddPrinterFlags(cmd) usage := "Filename, directory, or URL to a file identifying the resource to get from a server." kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage) cmd.Flags().BoolVar(&options.All, "all", false, "select all resources in the namespace of the specified resource types") cmd.Flags().StringVarP(&options.Selector, "selector", "l", "", "Selector (label query) to filter on") cmd.Flags().BoolVar(&options.Local, "local", false, "If true, set image will NOT contact api-server but run locally.") cmdutil.AddRecordFlag(cmd) cmdutil.AddRecursiveFlag(cmd, &options.Recursive) return cmd }
func NewCmdApply(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &ApplyOptions{} cmd := &cobra.Command{ Use: "apply -f FILENAME", Short: "Apply a configuration to a resource by filename or stdin", Long: apply_long, Example: apply_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(validateArgs(cmd, args)) cmdutil.CheckErr(cmdutil.ValidateOutputArgs(cmd)) cmdutil.CheckErr(RunApply(f, cmd, out, options)) }, } usage := "Filename, directory, or URL to file that contains the configuration to apply" kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage) cmd.MarkFlagRequired("filename") cmdutil.AddValidateFlags(cmd) cmdutil.AddRecursiveFlag(cmd, &options.Recursive) cmdutil.AddOutputFlagsForMutation(cmd) cmdutil.AddRecordFlag(cmd) cmdutil.AddInclude3rdPartyFlags(cmd) return cmd }
func setupOutputWriter(cmd *cobra.Command, defaultWriter io.Writer, filename string) io.Writer { dir := cmdutil.GetFlagString(cmd, "output-directory") if len(dir) == 0 || dir == "-" { return defaultWriter } fullFile := path.Join(dir, filename) parent := path.Dir(fullFile) cmdutil.CheckErr(os.MkdirAll(parent, 0755)) file, err := os.Create(path.Join(dir, filename)) cmdutil.CheckErr(err) return file }
func NewCmdCordon(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &DrainOptions{factory: f, out: out} cmd := &cobra.Command{ Use: "cordon NODE", Short: "Mark node as unschedulable", Long: cordon_long, Example: cordon_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(options.SetupDrain(cmd, args)) cmdutil.CheckErr(options.RunCordonOrUncordon(true)) }, } return cmd }
// NewCmdCreateSecretDockerRegistry is a macro command for creating secrets to work with Docker registries func NewCmdCreateSecretDockerRegistry(f *cmdutil.Factory, cmdOut io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "docker-registry NAME --docker-username=user --docker-password=password --docker-email=email [--docker-server=string] [--from-literal=key1=value1] [--dry-run]", Short: "Create a secret for use with a Docker registry.", Long: secretForDockerRegistryLong, Example: secretForDockerRegistryExample, Run: func(cmd *cobra.Command, args []string) { err := CreateSecretDockerRegistry(f, cmdOut, cmd, args) cmdutil.CheckErr(err) }, } cmdutil.AddApplyAnnotationFlags(cmd) cmdutil.AddValidateFlags(cmd) cmdutil.AddPrinterFlags(cmd) cmdutil.AddGeneratorFlags(cmd, cmdutil.SecretForDockerRegistryV1GeneratorName) cmd.Flags().String("docker-username", "", "Username for Docker registry authentication") cmd.MarkFlagRequired("docker-username") cmd.Flags().String("docker-password", "", "Password for Docker registry authentication") cmd.MarkFlagRequired("docker-password") cmd.Flags().String("docker-email", "", "Email for Docker registry") cmd.MarkFlagRequired("docker-email") cmd.Flags().String("docker-server", "https://index.docker.io/v1/", "Server location for Docker registry") cmdutil.AddInclude3rdPartyFlags(cmd) return cmd }
func NewCmdRolloutPause(f *cmdutil.Factory, out io.Writer) *cobra.Command { opts := &PauseConfig{} cmd := &cobra.Command{ Use: "pause RESOURCE", Short: "Mark the provided resource as paused", Long: pause_long, Example: pause_example, Run: func(cmd *cobra.Command, args []string) { allErrs := []error{} err := opts.CompletePause(f, cmd, out, args) if err != nil { allErrs = append(allErrs, err) } err = opts.RunPause() if err != nil { allErrs = append(allErrs, err) } cmdutil.CheckErr(utilerrors.Flatten(utilerrors.NewAggregate(allErrs))) }, } usage := "Filename, directory, or URL to a file identifying the resource to get from a server." kubectl.AddJsonFilenameFlag(cmd, &opts.Filenames, usage) cmdutil.AddRecursiveFlag(cmd, &opts.Recursive) return cmd }
func NewCmdRollingUpdate(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &RollingUpdateOptions{} cmd := &cobra.Command{ Use: "rolling-update OLD_CONTROLLER_NAME ([NEW_CONTROLLER_NAME] --image=NEW_CONTAINER_IMAGE | -f NEW_CONTROLLER_SPEC)", // rollingupdate is deprecated. Aliases: []string{"rollingupdate"}, Short: "Perform a rolling update of the given ReplicationController.", Long: rollingUpdate_long, Example: rollingUpdate_example, Run: func(cmd *cobra.Command, args []string) { err := RunRollingUpdate(f, out, cmd, args, options) cmdutil.CheckErr(err) }, } cmd.Flags().Duration("update-period", updatePeriod, `Time to wait between updating pods. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".`) cmd.Flags().Duration("poll-interval", pollInterval, `Time delay between polling for replication controller status after the update. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".`) cmd.Flags().Duration("timeout", timeout, `Max time to wait for a replication controller to update before giving up. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".`) usage := "Filename or URL to file to use to create the new replication controller." kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage) cmd.MarkFlagRequired("filename") cmd.Flags().String("image", "", "Image to use for upgrading the replication controller. Must be distinct from the existing image (either new image or new image tag). Can not be used with --filename/-f") cmd.MarkFlagRequired("image") cmd.Flags().String("deployment-label-key", "deployment", "The key to use to differentiate between two different controllers, default 'deployment'. Only relevant when --image is specified, ignored otherwise") cmd.Flags().String("container", "", "Container name which will have its image upgraded. Only relevant when --image is specified, ignored otherwise. Required when using --image on a multi-container pod") cmd.Flags().String("image-pull-policy", "", "Explicit policy for when to pull container images. Required when --image is same as existing image, ignored otherwise.") cmd.Flags().Bool("rollback", false, "If true, this is a request to abort an existing rollout that is partially rolled out. It effectively reverses current and next and runs a rollout") cmdutil.AddDryRunFlag(cmd) cmdutil.AddValidateFlags(cmd) cmdutil.AddPrinterFlags(cmd) cmdutil.AddInclude3rdPartyFlags(cmd) return cmd }
func NewCmdDrain(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &DrainOptions{factory: f, out: out} cmd := &cobra.Command{ Use: "drain NODE", Short: "Drain node in preparation for maintenance", Long: drain_long, Example: drain_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(options.SetupDrain(cmd, args)) cmdutil.CheckErr(options.RunDrain()) }, } cmd.Flags().BoolVar(&options.Force, "force", false, "Continue even if there are pods not managed by a ReplicationController, ReplicaSet, Job, or DaemonSet.") cmd.Flags().BoolVar(&options.IgnoreDaemonsets, "ignore-daemonsets", false, "Ignore DaemonSet-managed pods.") cmd.Flags().BoolVar(&options.DeleteLocalData, "delete-local-data", false, "Continue even if there are pods using emptyDir (local data that will be deleted when the node is drained).") cmd.Flags().IntVar(&options.GracePeriodSeconds, "grace-period", -1, "Period of time in seconds given to each pod to terminate gracefully. If negative, the default value specified in the pod will be used.") return cmd }
func NewCmdDelete(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &DeleteOptions{} // retrieve a list of handled resources from printer as valid args validArgs, argAliases := []string{}, []string{} p, err := f.Printer(nil, false, false, false, false, false, false, []string{}) cmdutil.CheckErr(err) if p != nil { validArgs = p.HandledResources() argAliases = kubectl.ResourceAliases(validArgs) } cmd := &cobra.Command{ Use: "delete ([-f FILENAME] | TYPE [(NAME | -l label | --all)])", Short: "Delete resources by filenames, stdin, resources and names, or by resources and label selector.", Long: delete_long, Example: delete_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(cmdutil.ValidateOutputArgs(cmd)) err := RunDelete(f, out, cmd, args, options) cmdutil.CheckErr(err) }, SuggestFor: []string{"rm"}, ValidArgs: validArgs, ArgAliases: argAliases, } usage := "Filename, directory, or URL to a file containing the resource to delete." kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage) cmdutil.AddRecursiveFlag(cmd, &options.Recursive) cmd.Flags().StringP("selector", "l", "", "Selector (label query) to filter on.") cmd.Flags().Bool("all", false, "[-all] to select all the specified resources.") cmd.Flags().Bool("ignore-not-found", false, "Treat \"resource not found\" as a successful delete. Defaults to \"true\" when --all is specified.") cmd.Flags().Bool("cascade", true, "If true, cascade the deletion of the resources managed by this resource (e.g. Pods created by a ReplicationController). Default true.") cmd.Flags().Int("grace-period", -1, "Period of time in seconds given to the resource to terminate gracefully. Ignored if negative.") cmd.Flags().Bool("now", false, "If true, resources are force terminated without graceful deletion (same as --grace-period=0).") cmd.Flags().Duration("timeout", 0, "The length of time to wait before giving up on a delete, zero means determine a timeout from the size of the object") cmdutil.AddOutputFlagsForMutation(cmd) cmdutil.AddInclude3rdPartyFlags(cmd) return cmd }
// NewCmdCreateSecret groups subcommands to create various types of secrets func NewCmdClusterInfoDump(f *cmdutil.Factory, cmdOut io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "dump", Short: "Dump lots of relevant info for debugging and diagnosis.", Long: dumpLong, Example: dumpExample, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(dumpClusterInfo(f, cmd, args, cmdOut)) }, } cmd.Flags().String("output-directory", "", "Where to output the files. If empty or '-' uses stdout, otherwise creates a directory hierarchy in that directory") cmd.Flags().StringSlice("namespaces", []string{}, "A comma separated list of namespaces to dump.") cmd.Flags().Bool("all-namespaces", false, "If true, dump all namespaces. If true, --namespaces is ignored.") return cmd }
func NewCmdClusterInfo(f *cmdutil.Factory, out io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "cluster-info", // clusterinfo is deprecated. Aliases: []string{"clusterinfo"}, Short: "Display cluster info", Long: longDescr, Run: func(cmd *cobra.Command, args []string) { err := RunClusterInfo(f, out, cmd) cmdutil.CheckErr(err) }, } cmdutil.AddInclude3rdPartyFlags(cmd) cmd.AddCommand(NewCmdClusterInfoDump(f, out)) return cmd }
func NewCmdConfigCurrentContext(out io.Writer, configAccess clientcmd.ConfigAccess) *cobra.Command { options := &CurrentContextOptions{ConfigAccess: configAccess} cmd := &cobra.Command{ Use: "current-context", Short: "Displays the current-context", Long: current_context_long, Example: current_context_example, Run: func(cmd *cobra.Command, args []string) { err := RunCurrentContext(out, args, options) cmdutil.CheckErr(err) }, } return cmd }
func NewCmdRolloutStatus(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &StatusOptions{} cmd := &cobra.Command{ Use: "status (TYPE NAME | TYPE/NAME) [flags]", Short: "Watch rollout status until it's done", Long: status_long, Example: status_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(RunStatus(f, cmd, out, args, options)) }, } usage := "Filename, directory, or URL to a file identifying the resource to get from a server." kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage) cmdutil.AddRecursiveFlag(cmd, &options.Recursive) return cmd }
// NewCmdCreateServiceAccount is a macro command to create a new service account func NewCmdCreateServiceAccount(f *cmdutil.Factory, cmdOut io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "serviceaccount NAME [--dry-run]", Aliases: []string{"sa"}, Short: "Create a service account with the specified name.", Long: serviceAccountLong, Example: serviceAccountExample, Run: func(cmd *cobra.Command, args []string) { err := CreateServiceAccount(f, cmdOut, cmd, args) cmdutil.CheckErr(err) }, } cmdutil.AddApplyAnnotationFlags(cmd) cmdutil.AddValidateFlags(cmd) cmdutil.AddPrinterFlags(cmd) cmdutil.AddInclude3rdPartyFlags(cmd) cmdutil.AddGeneratorFlags(cmd, cmdutil.ServiceAccountV1GeneratorName) return cmd }
func NewCmdRolloutHistory(f *cmdutil.Factory, out io.Writer) *cobra.Command { options := &HistoryOptions{} cmd := &cobra.Command{ Use: "history (TYPE NAME | TYPE/NAME) [flags]", Short: "view rollout history", Long: history_long, Example: history_example, Run: func(cmd *cobra.Command, args []string) { cmdutil.CheckErr(RunHistory(f, cmd, out, args, options)) }, } cmd.Flags().Int64("revision", 0, "See the details, including podTemplate of the revision specified") usage := "Filename, directory, or URL to a file identifying the resource to get from a server." kubectl.AddJsonFilenameFlag(cmd, &options.Filenames, usage) cmdutil.AddRecursiveFlag(cmd, &options.Recursive) return cmd }
// NewCmdCreateSecretTLS is a macro command for creating secrets to work with Docker registries func NewCmdCreateSecretTLS(f *cmdutil.Factory, cmdOut io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "tls NAME --cert=path/to/cert/file --key=path/to/key/file [--dry-run]", Short: "Create a TLS secret.", Long: secretForTLSLong, Example: secretForTLSExample, Run: func(cmd *cobra.Command, args []string) { err := CreateSecretTLS(f, cmdOut, cmd, args) cmdutil.CheckErr(err) }, } cmdutil.AddApplyAnnotationFlags(cmd) cmdutil.AddValidateFlags(cmd) cmdutil.AddPrinterFlags(cmd) cmdutil.AddGeneratorFlags(cmd, cmdutil.SecretForTLSV1GeneratorName) cmd.Flags().String("cert", "", "Path to PEM encoded public key certificate.") cmd.Flags().String("key", "", "Path to private key associated with given certificate.") return cmd }
// ConfigMap is a command to ease creating ConfigMaps. func NewCmdCreateConfigMap(f *cmdutil.Factory, cmdOut io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "configmap NAME [--from-file=[key=]source] [--from-literal=key1=value1] [--dry-run]", Short: "Create a configMap from a local file, directory or literal value.", Long: configMapLong, Example: configMapExample, Run: func(cmd *cobra.Command, args []string) { err := CreateConfigMap(f, cmdOut, cmd, args) cmdutil.CheckErr(err) }, } cmdutil.AddApplyAnnotationFlags(cmd) cmdutil.AddValidateFlags(cmd) cmdutil.AddPrinterFlags(cmd) cmdutil.AddGeneratorFlags(cmd, cmdutil.ConfigMapV1GeneratorName) cmd.Flags().StringSlice("from-file", []string{}, "Key files can be specified using their file path, in which case a default name will be given to them, or optionally with a name and file path, in which case the given name will be used. Specifying a directory will iterate each named file in the directory that is a valid configmap key.") cmd.Flags().StringSlice("from-literal", []string{}, "Specify a key and literal value to insert in configmap (i.e. mykey=somevalue)") return cmd }
func NewCmdRun(f *cmdutil.Factory, cmdIn io.Reader, cmdOut, cmdErr io.Writer) *cobra.Command { cmd := &cobra.Command{ Use: "run NAME --image=image [--env=\"key=value\"] [--port=port] [--replicas=replicas] [--dry-run=bool] [--overrides=inline-json] [--command] -- [COMMAND] [args...]", // run-container is deprecated Aliases: []string{"run-container"}, Short: "Run a particular image on the cluster.", Long: run_long, Example: run_example, Run: func(cmd *cobra.Command, args []string) { argsLenAtDash := cmd.ArgsLenAtDash() err := Run(f, cmdIn, cmdOut, cmdErr, cmd, args, argsLenAtDash) cmdutil.CheckErr(err) }, } cmdutil.AddPrinterFlags(cmd) addRunFlags(cmd) cmdutil.AddApplyAnnotationFlags(cmd) cmdutil.AddRecordFlag(cmd) cmdutil.AddInclude3rdPartyFlags(cmd) return cmd }