// Complete verifies command line arguments and loads data from the command environment func (p *AttachOptions) Complete(f *cmdutil.Factory, cmd *cobra.Command, argsIn []string) error { if len(argsIn) == 0 { return cmdutil.UsageError(cmd, "POD is required for attach") } if len(argsIn) > 1 { return cmdutil.UsageError(cmd, fmt.Sprintf("expected a single argument: POD, saw %d: %s", len(argsIn), argsIn)) } p.PodName = argsIn[0] namespace, _, err := f.DefaultNamespace() if err != nil { return err } p.Namespace = namespace config, err := f.ClientConfig() if err != nil { return err } p.Config = config client, err := f.Client() if err != nil { return err } p.Client = client return nil }
// NewCmdAddSecret creates a command object for adding a secret reference to a service account func NewCmdAddSecret(name, fullName string, f *cmdutil.Factory, out io.Writer) *cobra.Command { o := &AddSecretOptions{Out: out} var typeFlags util.StringList cmd := &cobra.Command{ Use: fmt.Sprintf("%s serviceaccounts/sa-name secrets/secret-name [secrets/another-secret-name]...", name), Short: "Add secrets to a ServiceAccount", Long: fmt.Sprintf(addSecretLong, fullName), Run: func(c *cobra.Command, args []string) { if err := o.Complete(f, args, typeFlags); err != nil { cmdutil.CheckErr(cmdutil.UsageError(c, err.Error())) } if err := o.Validate(); err != nil { cmdutil.CheckErr(cmdutil.UsageError(c, err.Error())) } if err := o.AddSecrets(); err != nil { cmdutil.CheckErr(err) } }, } forFlag := &pflag.Flag{ Name: "for", Usage: "type of secret to add: mount or pull", Value: &typeFlags, DefValue: "mount", } cmd.Flags().AddFlag(forFlag) return cmd }
func RunUpdate(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, filenames util.StringList) error { schema, err := f.Validator() if err != nil { return err } cmdNamespace, err := f.DefaultNamespace() if err != nil { return err } patch := cmdutil.GetFlagString(cmd, "patch") if len(filenames) == 0 && len(patch) == 0 { return cmdutil.UsageError(cmd, "Must specify --filename or --patch to update") } if len(filenames) != 0 && len(patch) != 0 { return cmdutil.UsageError(cmd, "Can not specify both --filename and --patch") } // TODO: Make patching work with -f, updating with patched JSON input files if len(filenames) == 0 { name, err := updateWithPatch(cmd, args, f, patch) if err != nil { return err } fmt.Fprintf(out, "%s\n", name) return nil } if len(filenames) == 0 { return cmdutil.UsageError(cmd, "Must specify --filename to update") } mapper, typer := f.Object() r := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand()). Schema(schema). ContinueOnError(). NamespaceParam(cmdNamespace).RequireNamespace(). FilenameParam(filenames...). Flatten(). Do() err = r.Err() if err != nil { return err } return r.Visit(func(info *resource.Info) error { data, err := info.Mapping.Codec.Encode(info.Object) if err != nil { return err } obj, err := resource.NewHelper(info.Client, info.Mapping).Update(info.Namespace, info.Name, true, data) if err != nil { return err } info.Refresh(obj, true) printObjectSpecificMessage(obj, out) fmt.Fprintf(out, "%s/%s\n", info.Mapping.Resource, info.Name) return nil }) }
// NewCmdRollback creates a CLI rollback command. func NewCmdRollback(fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { opts := &RollbackOptions{} cmd := &cobra.Command{ Use: "rollback (DEPLOYMENTCONFIG | DEPLOYMENT)", Short: "Revert part of an application back to a previous deployment", Long: rollbackLong, Example: fmt.Sprintf(rollbackExample, fullName), Run: func(cmd *cobra.Command, args []string) { if err := opts.Complete(f, args, out); err != nil { cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error())) } if err := opts.Validate(); err != nil { cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error())) } if err := opts.Run(); err != nil { cmdutil.CheckErr(err) } }, } cmd.Flags().BoolVar(&opts.IncludeTriggers, "change-triggers", false, "Include the previous deployment's triggers in the rollback") cmd.Flags().BoolVar(&opts.IncludeStrategy, "change-strategy", false, "Include the previous deployment's strategy in the rollback") cmd.Flags().BoolVar(&opts.IncludeScalingSettings, "change-scaling-settings", false, "Include the previous deployment's replicationController replica count and selector in the rollback") cmd.Flags().BoolVarP(&opts.DryRun, "dry-run", "d", false, "Instead of performing the rollback, describe what the rollback will look like in human-readable form") cmd.Flags().StringVarP(&opts.Format, "output", "o", "", "Instead of performing the rollback, print the updated deployment configuration in the specified format (json|yaml|template|templatefile)") cmd.Flags().StringVarP(&opts.Template, "template", "t", "", "Template string or path to template file to use when -o=template or -o=templatefile.") cmd.Flags().IntVar(&opts.DesiredVersion, "to-version", 0, "A config version to rollback to. Specifying version 0 is the same as omitting a version (the version will be auto-detected). This option is ignored when specifying a deployment.") return cmd }
func RunPortForward(f *Factory, cmd *cobra.Command, args []string) error { podName := util.GetFlagString(cmd, "pod") if len(podName) == 0 { return util.UsageError(cmd, "POD is required for exec") } if len(args) < 1 { return util.UsageError(cmd, "at least 1 PORT is required for port-forward") } namespace, err := f.DefaultNamespace() if err != nil { return err } client, err := f.Client() if err != nil { return err } pod, err := client.Pods(namespace).Get(podName) if err != nil { return err } if pod.Status.Phase != api.PodRunning { glog.Fatalf("Unable to execute command because pod is not running. Current status=%v", pod.Status.Phase) } config, err := f.ClientConfig() if err != nil { return err } signals := make(chan os.Signal, 1) signal.Notify(signals, os.Interrupt) defer signal.Stop(signals) stopCh := make(chan struct{}, 1) go func() { <-signals close(stopCh) }() req := client.RESTClient.Get(). Prefix("proxy"). Resource("minions"). Name(pod.Status.Host). Suffix("portForward", namespace, podName) pf, err := portforward.New(req, config, args, stopCh) if err != nil { return err } return pf.ForwardPorts() }
func Run(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) error { if len(os.Args) > 1 && os.Args[1] == "run-container" { printDeprecationWarning("run", "run-container") } if len(args) != 1 { return cmdutil.UsageError(cmd, "NAME is required for run") } namespace, _, err := f.DefaultNamespace() if err != nil { return err } client, err := f.Client() if err != nil { return err } generatorName := cmdutil.GetFlagString(cmd, "generator") generator, found := f.Generator(generatorName) if !found { return cmdutil.UsageError(cmd, fmt.Sprintf("Generator: %s not found.", generator)) } names := generator.ParamNames() params := kubectl.MakeParams(cmd, names) params["name"] = args[0] err = kubectl.ValidateParams(names, params) if err != nil { return err } controller, err := generator.Generate(params) if err != nil { return err } inline := cmdutil.GetFlagString(cmd, "overrides") if len(inline) > 0 { controller, err = cmdutil.Merge(controller, inline, "ReplicationController") if err != nil { return err } } // TODO: extract this flag to a central location, when such a location exists. if !cmdutil.GetFlagBool(cmd, "dry-run") { controller, err = client.ReplicationControllers(namespace).Create(controller.(*api.ReplicationController)) if err != nil { return err } } return f.PrintObject(cmd, controller, out) }
func RunLog(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string) error { if len(args) == 0 { return cmdutil.UsageError(cmd, "POD is required for log") } if len(args) > 2 { return cmdutil.UsageError(cmd, "log POD [CONTAINER]") } namespace, err := f.DefaultNamespace() if err != nil { return err } client, err := f.Client() if err != nil { return err } podID := args[0] pod, err := client.Pods(namespace).Get(podID) if err != nil { return err } var container string if len(args) == 1 { if len(pod.Spec.Containers) != 1 { return fmt.Errorf("POD %s has more than one container; please specify the container to print logs for", pod.ObjectMeta.Name) } container = pod.Spec.Containers[0].Name } else { container = args[1] } follow := false if cmdutil.GetFlagBool(cmd, "follow") { follow = true } readCloser, err := client.RESTClient.Get(). Prefix("proxy"). Resource("nodes"). Name(pod.Spec.Host). Suffix("containerLogs", namespace, podID, container). Param("follow", strconv.FormatBool(follow)). Stream() if err != nil { return err } defer readCloser.Close() _, err = io.Copy(out, readCloser) return err }
// RunBuildLogs contains all the necessary functionality for the OpenShift cli build-logs command func RunBuildLogs(f *clientcmd.Factory, out io.Writer, cmd *cobra.Command, opts api.BuildLogOptions, args []string) error { if len(args) != 1 { // maximum time to wait for a list of builds timeout := 800 * time.Millisecond // maximum number of builds to list maxBuildListLen := 10 ch := make(chan error) go func() { // TODO fetch via API no more than maxBuildListLen builds builds, err := getBuilds(f) if err != nil { return } if len(builds) == 0 { ch <- cmdutil.UsageError(cmd, "There are no builds in the current project") return } sort.Sort(sort.Reverse(api.ByCreationTimestamp(builds))) msg := "A build name is required. Most recent builds:" for i, b := range builds { if i == maxBuildListLen { break } msg += fmt.Sprintf("\n* %s\t%s\t%s ago", b.Name, b.Status.Phase, units.HumanDuration(time.Since(b.CreationTimestamp.Time))) } ch <- cmdutil.UsageError(cmd, msg) }() select { case <-time.After(timeout): return cmdutil.UsageError(cmd, "A build name is required") case err := <-ch: return err } } namespace, _, err := f.DefaultNamespace() if err != nil { return err } c, _, err := f.Clients() if err != nil { return err } readCloser, err := c.BuildLogs(namespace).Get(args[0], opts).Stream() if err != nil { return err } defer readCloser.Close() _, err = io.Copy(out, readCloser) return err }
func RunLog(f *Factory, out io.Writer, cmd *cobra.Command, args []string) error { if len(args) == 0 { return util.UsageError(cmd, "POD is required for log") } if len(args) > 2 { return util.UsageError(cmd, "log POD [CONTAINER]") } namespace, err := f.DefaultNamespace() if err != nil { return err } client, err := f.Client() if err != nil { return err } podID := args[0] pod, err := client.Pods(namespace).Get(podID) if err != nil { return err } var container string if len(args) == 1 { } else { container = args[1] } follow := false if util.GetFlagBool(cmd, "follow") { follow = true } readCloser, err := client.RESTClient.Get(). Prefix("proxy"). Resource("minions"). Name(pod.Status.Host). Suffix("containerLogs", namespace, podID, container). Param("follow", strconv.FormatBool(follow)). Stream() if err != nil { return err } defer readCloser.Close() _, err = io.Copy(out, readCloser) return err }
func RunLabel(f *Factory, out io.Writer, cmd *cobra.Command, args []string) error { if len(args) < 2 { return util.UsageError(cmd, "<resource> <name> is required") } if len(args) < 3 { return util.UsageError(cmd, "at least one label update is required.") } res := args[:2] cmdNamespace, err := f.DefaultNamespace() if err != nil { return err } mapper, _ := f.Object() // TODO: use resource.Builder instead mapping, namespace, name, err := util.ResourceFromArgs(cmd, res, mapper, cmdNamespace) if err != nil { return err } client, err := f.RESTClient(mapping) if err != nil { return err } labels, remove, err := parseLabels(args[2:]) if err != nil { return err } overwrite := util.GetFlagBool(cmd, "overwrite") resourceVersion := util.GetFlagString(cmd, "resource-version") obj, err := updateObject(client, mapping, namespace, name, func(obj runtime.Object) (runtime.Object, error) { outObj, err := labelFunc(obj, overwrite, resourceVersion, labels, remove) if err != nil { return nil, err } return outObj, nil }) if err != nil { return err } printer, err := f.PrinterForMapping(cmd, mapping) if err != nil { return err } printer.PrintObj(obj, out) return nil }
func NewCommandCreateBootstrapProjectTemplate(f *clientcmd.Factory, commandName string, fullName string, out io.Writer) *cobra.Command { options := &CreateBootstrapProjectTemplateOptions{} cmd := &cobra.Command{ Use: commandName, Short: "Create a bootstrap project template", Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error())) } template, err := options.CreateBootstrapProjectTemplate() if err != nil { cmdutil.CheckErr(err) } err = f.Factory.PrintObject(cmd, template, out) if err != nil { cmdutil.CheckErr(err) } }, } cmd.Flags().StringVar(&options.Name, "name", delegated.DefaultTemplateName, "The name of the template to output.") cmdutil.AddPrinterFlags(cmd) // Default to JSON if flag := cmd.Flags().Lookup("output"); flag != nil { flag.Value.Set("json") } return cmd }
func setupAppConfig(f *clientcmd.Factory, c *cobra.Command, args []string, config *newcmd.AppConfig) error { namespace, _, err := f.DefaultNamespace() if err != nil { return err } dockerClient, _, err := dockerutil.NewHelper().GetClient() if err == nil { if err = dockerClient.Ping(); err == nil { config.SetDockerClient(dockerClient) } } if err != nil { glog.V(2).Infof("No local Docker daemon detected: %v", err) } osclient, _, err := f.Clients() if err != nil { return err } config.SetOpenShiftClient(osclient, namespace) unknown := config.AddArguments(args) if len(unknown) != 0 { return cmdutil.UsageError(c, "Did not recognize the following arguments: %v", unknown) } return nil }
// NewCmdWhoCan implements the OpenShift cli who-can command func NewCmdWhoCan(name, fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { options := &whoCanOptions{} cmd := &cobra.Command{ Use: "who-can VERB RESOURCE", Short: "List who can perform the specified action on a resource", Long: "List who can perform the specified action on a resource", Run: func(cmd *cobra.Command, args []string) { if err := options.complete(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } var err error if options.client, _, err = f.Clients(); err != nil { kcmdutil.CheckErr(err) } if options.bindingNamespace, err = f.DefaultNamespace(); err != nil { kcmdutil.CheckErr(err) } if err := options.run(); err != nil { kcmdutil.CheckErr(err) } }, } return cmd }
func NewCommandCreateBootstrapPolicyFile(commandName string, fullName string, out io.Writer) *cobra.Command { options := &CreateBootstrapPolicyFileOptions{} cmd := &cobra.Command{ Use: commandName, Short: "Create the default bootstrap policy", Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } if err := options.CreateBootstrapPolicyFile(); err != nil { kcmdutil.CheckErr(err) } }, } flags := cmd.Flags() flags.StringVar(&options.File, "filename", DefaultPolicyFile, "The policy template file that will be written with roles and bindings.") flags.StringVar(&options.OpenShiftSharedResourcesNamespace, "openshift-namespace", "openshift", "Namespace for shared resources.") // autocompletion hints cmd.MarkFlagFilename("filename") return cmd }
func NewCommandCreateKubeConfig(commandName string, fullName string, out io.Writer) *cobra.Command { options := &CreateKubeConfigOptions{Output: out} cmd := &cobra.Command{ Use: commandName, Short: "Create a basic .kubeconfig file from client certs", Long: ` Create's a .kubeconfig file at <--kubeconfig> that looks like this: clusters: - cluster: certificate-authority-data: <contents of --certificate-authority> server: <--master> name: <--cluster> - cluster: certificate-authority-data: <contents of --certificate-authority> server: <--public-master> name: public-<--cluster> contexts: - context: cluster: <--cluster> user: <--user> namespace: <--namespace> name: <--context> - context: cluster: public-<--cluster> user: <--user> namespace: <--namespace> name: public-<--context> current-context: <--context> kind: Config users: - name: <--user> user: client-certificate-data: <contents of --client-certificate> client-key-data: <contents of --client-key> `, Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } if _, err := options.CreateKubeConfig(); err != nil { kcmdutil.CheckErr(err) } }, } flags := cmd.Flags() flags.StringVar(&options.APIServerURL, "master", "https://localhost:8443", "The API server's URL.") flags.StringVar(&options.PublicAPIServerURL, "public-master", "", "The API public facing server's URL (if applicable).") flags.StringVar(&options.APIServerCAFile, "certificate-authority", "openshift.local.config/master/ca.crt", "Path to the API server's CA file.") flags.StringVar(&options.CertFile, "client-certificate", "", "The client cert file.") flags.StringVar(&options.KeyFile, "client-key", "", "The client key file.") flags.StringVar(&options.ContextNamespace, "namespace", kapi.NamespaceDefault, "Namespace for this context in .kubeconfig.") flags.StringVar(&options.KubeConfigFile, "kubeconfig", ".kubeconfig", "Path for the resulting .kubeconfig file.") return cmd }
func NewCommandCreateKeyPair(commandName string, fullName string, out io.Writer) *cobra.Command { options := &CreateKeyPairOptions{Output: out} cmd := &cobra.Command{ Use: commandName, Short: "Create a public/private key pair", Long: fmt.Sprintf(createKeyPairLong, fullName), Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } err := options.CreateKeyPair() kcmdutil.CheckErr(err) }, } flags := cmd.Flags() flags.StringVar(&options.PublicKeyFile, "public-key", "", "The public key file.") flags.StringVar(&options.PrivateKeyFile, "private-key", "", "The private key file.") flags.BoolVar(&options.Overwrite, "overwrite", false, "Overwrite existing key files if found. If false, either file existing will prevent creation.") return cmd }
// RunRsh starts a remote shell session on the server func RunRsh(options *kubecmd.ExecOptions, f *clientcmd.Factory, cmd *cobra.Command, args []string) error { if len(args) != 1 { return cmdutil.UsageError(cmd, "rsh requires a single POD to connect to") } options.PodName = args[0] _, client, err := f.Clients() if err != nil { return err } options.Client = client namespace, _, err := f.DefaultNamespace() if err != nil { return nil } options.Namespace = namespace config, err := f.ClientConfig() if err != nil { return err } options.Config = config if err := options.Validate(); err != nil { return err } return options.Run() }
func NewCommandCreateServerCert(commandName string, fullName string, out io.Writer) *cobra.Command { options := &CreateServerCertOptions{GetSignerCertOptions: &GetSignerCertOptions{}, Output: out} cmd := &cobra.Command{ Use: commandName, Short: "Create a signed server certificate and key", Long: fmt.Sprintf(createServerLong, fullName), Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } if _, err := options.CreateServerCert(); err != nil { kcmdutil.CheckErr(err) } }, } flags := cmd.Flags() BindGetSignerCertOptions(options.GetSignerCertOptions, flags, "") flags.StringVar(&options.CertFile, "cert", "", "The certificate file. Choose a name that indicates what the service is.") flags.StringVar(&options.KeyFile, "key", "", "The key file. Choose a name that indicates what the service is.") flags.Var(&options.Hostnames, "hostnames", "Every hostname or IP you want server certs to be valid for. Comma delimited list") flags.BoolVar(&options.Overwrite, "overwrite", true, "Overwrite existing cert files if found. If false, any existing file will be left as-is.") return cmd }
func NewCommandOverwriteBootstrapPolicy(commandName string, fullName string, createBootstrapPolicyCommand string, out io.Writer) *cobra.Command { options := &OverwriteBootstrapPolicyOptions{Out: out} options.CreateBootstrapPolicyCommand = createBootstrapPolicyCommand cmd := &cobra.Command{ Use: commandName, Short: "Reset the policy to the default values", Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } if err := options.OverwriteBootstrapPolicy(); err != nil { kcmdutil.CheckErr(err) } }, } flags := cmd.Flags() flags.BoolVarP(&options.Force, "force", "f", false, "You must confirm you really want to reset your policy. This will delete any custom settings you may have.") flags.StringVar(&options.File, "filename", "", "The policy template file containing roles and bindings. One can be created with '"+createBootstrapPolicyCommand+"'.") flags.StringVar(&options.MasterConfigFile, "master-config", "openshift.local.config/master/master-config.yaml", "Location of the master configuration file to run from in order to connect to etcd and directly modify the policy.") // autocompletion hints cmd.MarkFlagFilename("filename") cmd.MarkFlagFilename("master-config", "yaml", "yml") return cmd }
// NewCmdNewProject implements the OpenShift cli new-project command func NewCmdNewProject(name, fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { options := &NewProjectOptions{} cmd := &cobra.Command{ Use: name + " NAME [--display-name=DISPLAYNAME] [--description=DESCRIPTION]", Short: "Create a new project", Long: newProjectLong, Run: func(cmd *cobra.Command, args []string) { if err := options.complete(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } var err error if options.Client, _, err = f.Clients(); err != nil { kcmdutil.CheckErr(err) } // We can't depend on len(options.NodeSelector) > 0 as node-selector="" is valid // and we want to populate node selector as project annotation only if explicitly set by user useNodeSelector := cmd.Flag("node-selector").Changed if err := options.Run(useNodeSelector); err != nil { kcmdutil.CheckErr(err) } }, } cmd.Flags().StringVar(&options.AdminRole, "admin-role", bootstrappolicy.AdminRoleName, "Project admin role name in the cluster policy") cmd.Flags().StringVar(&options.AdminUser, "admin", "", "Project admin username") cmd.Flags().StringVar(&options.DisplayName, "display-name", "", "Project display name") cmd.Flags().StringVar(&options.Description, "description", "", "Project description") cmd.Flags().StringVar(&options.NodeSelector, "node-selector", "", "Restrict pods onto nodes matching given label selector. Format: '<key1>=<value1>, <key2>=<value2>...'. Specifying \"\" means any node, not default. If unspecified, cluster default node selector will be used.") return cmd }
// NewCmdDeploy creates a new `deploy` command. func NewCmdDeploy(fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { options := &DeployOptions{ baseCommandName: fullName, } cmd := &cobra.Command{ Use: "deploy DEPLOYMENTCONFIG", Short: "View, start, cancel, or retry a deployment", Long: deployLong, Example: fmt.Sprintf(deployExample, fullName), Run: func(cmd *cobra.Command, args []string) { if err := options.Complete(f, args, out); err != nil { cmdutil.CheckErr(err) } if err := options.Validate(args); err != nil { cmdutil.CheckErr(cmdutil.UsageError(cmd, err.Error())) } if err := options.RunDeploy(); err != nil { cmdutil.CheckErr(err) } }, } cmd.Flags().BoolVar(&options.deployLatest, "latest", false, "Start a new deployment now.") cmd.Flags().BoolVar(&options.retryDeploy, "retry", false, "Retry the latest failed deployment.") cmd.Flags().BoolVar(&options.cancelDeploy, "cancel", false, "Cancel the in-progress deployment.") cmd.Flags().BoolVar(&options.enableTriggers, "enable-triggers", false, "Enables all image triggers for the deployment config.") return cmd }
func NewCommandCreateClient(commandName string, fullName string, out io.Writer) *cobra.Command { options := &CreateClientOptions{GetSignerCertOptions: &GetSignerCertOptions{}, Output: out} cmd := &cobra.Command{ Use: commandName, Short: "Create a config file for connecting to the server as a user", Long: createClientLong, Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } if err := options.CreateClientFolder(); err != nil { kcmdutil.CheckErr(err) } }, } flags := cmd.Flags() BindGetSignerCertOptions(options.GetSignerCertOptions, flags, "") flags.StringVar(&options.ClientDir, "client-dir", "", "The client data directory.") flags.StringVar(&options.BaseName, "basename", "", "The base filename to use for the .crt, .key, and .kubeconfig files. Defaults to the username.") flags.StringVar(&options.User, "user", "", "The scope qualified username.") flags.Var(&options.Groups, "groups", "The list of groups this user belongs to. Comma delimited list") flags.StringVar(&options.APIServerURL, "master", "https://localhost:8443", "The API server's URL.") flags.StringVar(&options.PublicAPIServerURL, "public-master", "", "The API public facing server's URL (if applicable).") flags.StringVar(&options.APIServerCAFile, "certificate-authority", "openshift.local.config/master/ca.crt", "Path to the API server's CA file.") return cmd }
func NewCommandCreateMasterCerts(commandName string, fullName string, out io.Writer) *cobra.Command { options := &CreateMasterCertsOptions{Output: out} cmd := &cobra.Command{ Use: commandName, Short: "Create certificates for an Atomic Enterprise master", Long: fmt.Sprintf(masterCertLong, fullName), Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } if err := options.CreateMasterCerts(); err != nil { kcmdutil.CheckErr(err) } }, } flags := cmd.Flags() flags.StringVar(&options.CertDir, "cert-dir", "openshift.local.config/master", "The certificate data directory.") flags.StringVar(&options.SignerName, "signer-name", DefaultSignerName(), "The name to use for the generated signer.") flags.StringVar(&options.APIServerURL, "master", "https://localhost:8443", "The API server's URL.") flags.StringVar(&options.PublicAPIServerURL, "public-master", "", "The API public facing server's URL (if applicable).") flags.Var(&options.Hostnames, "hostnames", "Every hostname or IP that server certs should be valid for (comma-delimited list)") flags.BoolVar(&options.Overwrite, "overwrite", false, "Overwrite all existing cert/key/config files (WARNING: includes signer/CA)") return cmd }
// Complete completes the required options for build-chain func (o *BuildChainOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string, out io.Writer) error { if len(args) != 1 { return cmdutil.UsageError(cmd, "Must pass an image stream name and optionally a tag. In case of an empty tag, 'latest' will be used.") } // Setup client oc, _, err := f.Clients() if err != nil { return err } o.c, o.t = oc, oc // Parse user input o.name, o.tag, err = buildChainInput(args[0]) if err != nil { return cmdutil.UsageError(cmd, err.Error()) } glog.V(4).Infof("Using '%s:%s' as the image stream tag to look dependencies for", o.name, o.tag) // Setup namespace if o.allNamespaces { // TODO: Handle different uses of build-chain; user and admin projectList, err := oc.Projects().List(labels.Everything(), fields.Everything()) if err != nil { return err } for _, project := range projectList.Items { glog.V(4).Infof("Found namespace %q", project.Name) o.namespaces.Insert(project.Name) } } namespace, _, err := f.DefaultNamespace() if err != nil { return err } o.defaultNamespace = namespace glog.V(4).Infof("Using %q as the namespace for '%s:%s'", o.defaultNamespace, o.name, o.tag) o.namespaces.Insert(namespace) glog.V(4).Infof("Will look for deps in %s", strings.Join(o.namespaces.List(), ",")) return nil }
// RunScale executes the scaling func RunScale(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []string, shortOutput bool) error { if len(os.Args) > 1 && os.Args[1] == "resize" { printDeprecationWarning("scale", "resize") } count := cmdutil.GetFlagInt(cmd, "replicas") if count < 0 { return cmdutil.UsageError(cmd, "--replicas=COUNT RESOURCE NAME") } cmdNamespace, _, err := f.DefaultNamespace() if err != nil { return err } mapper, typer := f.Object() r := resource.NewBuilder(mapper, typer, f.ClientMapperForCommand()). ContinueOnError(). NamespaceParam(cmdNamespace).DefaultNamespace(). ResourceTypeOrNameArgs(false, args...). Flatten(). Do() err = r.Err() if err != nil { return err } mapping, err := r.ResourceMapping() if err != nil { return err } infos, err := r.Infos() if err != nil { return err } if len(infos) > 1 { return fmt.Errorf("multiple resources provided: %v", args) } info := infos[0] scaler, err := f.Scaler(mapping) if err != nil { return err } resourceVersion := cmdutil.GetFlagString(cmd, "resource-version") currentSize := cmdutil.GetFlagInt(cmd, "current-replicas") precondition := &kubectl.ScalePrecondition{currentSize, resourceVersion} retry := kubectl.NewRetryParams(kubectl.Interval, kubectl.Timeout) waitForReplicas := kubectl.NewRetryParams(kubectl.Interval, kubectl.Timeout) if err := scaler.Scale(info.Namespace, info.Name, uint(count), precondition, retry, waitForReplicas); err != nil { return err } cmdutil.PrintSuccess(mapper, shortOutput, out, info.Mapping.Resource, info.Name, "scaled") return nil }
// RunImportImage contains all the necessary functionality for the OpenShift cli import-image command. func RunImportImage(f *clientcmd.Factory, out io.Writer, cmd *cobra.Command, args []string) error { if len(args) == 0 || len(args[0]) == 0 { return cmdutil.UsageError(cmd, "you must specify the name of an image stream.") } streamName := args[0] namespace, err := f.DefaultNamespace() if err != nil { return err } osClient, _, err := f.Clients() if err != nil { return err } imageStreamClient := osClient.ImageStreams(namespace) stream, err := imageStreamClient.Get(streamName) if err != nil { return err } if len(stream.Spec.DockerImageRepository) == 0 { return errors.New("only image streams with spec.dockerImageRepository set may have images imported") } if stream.Annotations == nil { stream.Annotations = make(map[string]string) } stream.Annotations[imageapi.DockerImageRepositoryCheckAnnotation] = "" updatedStream, err := imageStreamClient.Update(stream) if err != nil { return err } resourceVersion := updatedStream.ResourceVersion fmt.Fprintln(cmd.Out(), "Waiting for the import to complete, CTRL+C to stop waiting.") updatedStream, err = waitForImport(imageStreamClient, stream.Name, resourceVersion) if err != nil { return fmt.Errorf("unable to determine if the import completed successfully - please run 'oc describe -n %s imagestream/%s' to see if the tags were updated as expected: %v", stream.Namespace, stream.Name, err) } fmt.Fprintln(cmd.Out(), "The import completed successfully.\n") d := describe.ImageStreamDescriber{osClient} info, err := d.Describe(updatedStream.Namespace, updatedStream.Name) if err != nil { return err } fmt.Fprintln(out, info) return nil }
func NewCommandNodeConfig(commandName string, fullName string, out io.Writer) *cobra.Command { options := NewDefaultCreateNodeConfigOptions() options.Output = out cmd := &cobra.Command{ Use: commandName, Short: "Create a configuration bundle for a node", Run: func(cmd *cobra.Command, args []string) { if err := options.Validate(args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } if err := options.CreateNodeFolder(); err != nil { kcmdutil.CheckErr(err) } }, } flags := cmd.Flags() BindSignerCertOptions(options.SignerCertOptions, flags, "") flags.StringVar(&options.NodeConfigDir, "node-dir", "", "The client data directory.") flags.StringVar(&options.NodeName, "node", "", "The name of the node as it appears in etcd.") flags.Var(&options.Hostnames, "hostnames", "Every hostname or IP you want server certs to be valid for. Comma delimited list") flags.StringVar(&options.VolumeDir, "volume-dir", options.VolumeDir, "The volume storage directory. This path is not relativized.") flags.StringVar(&options.ImageTemplate.Format, "images", options.ImageTemplate.Format, "When fetching the network container image, use this format. The latest release will be used by default.") flags.BoolVar(&options.ImageTemplate.Latest, "latest-images", options.ImageTemplate.Latest, "If true, attempt to use the latest images for the cluster instead of the latest release.") flags.BoolVar(&options.AllowDisabledDocker, "allow-disabled-docker", options.AllowDisabledDocker, "Allow the node to start without docker being available.") flags.StringVar(&options.DNSDomain, "dns-domain", options.DNSDomain, "DNS domain for the cluster.") flags.StringVar(&options.DNSIP, "dns-ip", options.DNSIP, "DNS server IP for the cluster.") flags.Var(&options.ListenAddr, "listen", "The address to listen for connections on (scheme://host:port).") flags.StringVar(&options.ClientCertFile, "client-certificate", "", "The client cert file for the node to contact the API.") flags.StringVar(&options.ClientKeyFile, "client-key", "", "The client key file for the node to contact the API.") flags.StringVar(&options.ServerCertFile, "server-certificate", "", "The server cert file for the node to serve secure traffic.") flags.StringVar(&options.ServerKeyFile, "server-key", "", "The server key file for the node to serve secure traffic.") flags.StringVar(&options.NodeClientCAFile, "node-client-certificate-authority", options.NodeClientCAFile, "The file containing signing authorities to use to verify requests to the node. If empty, all requests will be allowed.") flags.StringVar(&options.APIServerURL, "master", options.APIServerURL, "The API server's URL.") flags.StringVar(&options.APIServerCAFile, "certificate-authority", options.APIServerCAFile, "Path to the API server's CA file.") flags.StringVar(&options.NetworkPluginName, "network-plugin", options.NetworkPluginName, "Name of the network plugin to hook to for pod networking.") // autocompletion hints cmd.MarkFlagFilename("node-dir") cmd.MarkFlagFilename("volume-dir") cmd.MarkFlagFilename("client-certificate") cmd.MarkFlagFilename("client-key") cmd.MarkFlagFilename("server-certificate") cmd.MarkFlagFilename("server-key") cmd.MarkFlagFilename("node-client-certificate-authority") cmd.MarkFlagFilename("certificate-authority") return cmd }
func validateArguments(cmd *cobra.Command, args []string) (deploymentKey, filename, image, oldName string, err error) { deploymentKey = cmdutil.GetFlagString(cmd, "deployment-label-key") filename = cmdutil.GetFlagString(cmd, "filename") image = cmdutil.GetFlagString(cmd, "image") if len(deploymentKey) == 0 { return "", "", "", "", cmdutil.UsageError(cmd, "--deployment-label-key can not be empty") } if len(filename) == 0 && len(image) == 0 { return "", "", "", "", cmdutil.UsageError(cmd, "Must specify --filename or --image for new controller") } if len(filename) != 0 && len(image) != 0 { return "", "", "", "", cmdutil.UsageError(cmd, "--filename and --image can not both be specified") } if len(args) < 1 { return "", "", "", "", cmdutil.UsageError(cmd, "Must specify the controller to update") } return deploymentKey, filename, image, args[0], nil }
func extractPodAndContainer(cmd *cobra.Command, argsIn []string, p *execParams) (podName string, containerName string, args []string, err error) { if len(p.podName) == 0 && len(argsIn) == 0 { return "", "", nil, cmdutil.UsageError(cmd, "POD is required for exec") } if len(p.podName) != 0 { printDeprecationWarning("exec POD", "-p POD") podName = p.podName if len(argsIn) < 1 { return "", "", nil, cmdutil.UsageError(cmd, "COMMAND is required for exec") } args = argsIn } else { podName = argsIn[0] args = argsIn[1:] if len(args) < 1 { return "", "", nil, cmdutil.UsageError(cmd, "COMMAND is required for exec") } } return podName, p.containerName, args, nil }
func DefaultSubCommandRun(out io.Writer) func(c *cobra.Command, args []string) { return func(c *cobra.Command, args []string) { c.SetOutput(out) if len(args) > 0 { kcmdutil.CheckErr(kcmdutil.UsageError(c, fmt.Sprintf(`unknown command "%s"`, strings.Join(args, " ")))) } c.Help() } }