// RunGraph contains all the necessary functionality for the OpenShift cli graph command func RunGraph(f *clientcmd.Factory, out io.Writer) error { client, kclient, err := f.Clients() if err != nil { return err } config, err := f.OpenShiftClientConfig.ClientConfig() if err != nil { return err } namespace, _, err := f.DefaultNamespace() if err != nil { return err } describer := &describe.ProjectStatusDescriber{K: kclient, C: client, Server: config.Host} g, _, err := describer.MakeGraph(namespace) if err != nil { return err } data, err := dot.Marshal(g, namespace, "", " ", false) if err != nil { return err } fmt.Fprintf(out, "%s", string(data)) return nil }
func (o *RoleModificationOptions) Complete(f *clientcmd.Factory, args []string, target *[]string, targetName string, isNamespaced bool) error { if len(args) < 2 { return fmt.Errorf("you must specify at least two arguments: <role> <%s> [%s]...", targetName, targetName) } o.RoleName = args[0] *target = append(*target, args[1:]...) osClient, _, err := f.Clients() if err != nil { return err } if isNamespaced { roleBindingNamespace, _, err := f.DefaultNamespace() if err != nil { return err } o.RoleBindingAccessor = NewLocalRoleBindingAccessor(roleBindingNamespace, osClient) } else { o.RoleBindingAccessor = NewClusterRoleBindingAccessor(osClient) } return nil }
// RunBuildLogs contains all the necessary functionality for the OpenShift cli build-logs command func RunBuildLogs(fullName string, f *clientcmd.Factory, out io.Writer, cmd *cobra.Command, opts api.BuildLogOptions, args []string) error { if len(args) != 1 { cmdNamespace := kcmdutil.GetFlagString(cmd, "namespace") var namespace string if cmdNamespace != "" { namespace = " -n " + cmdNamespace } return kcmdutil.UsageError(cmd, "A build name is required - you can run `%s get builds%s` to list builds", fullName, namespace) } 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 }
// 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 }
// Complete turns a partially defined RollbackActions into a solvent structure // which can be validated and used for a rollback. func (o *RollbackOptions) Complete(f *clientcmd.Factory, args []string, out io.Writer) error { // Extract basic flags. if len(args) == 1 { o.TargetName = args[0] } namespace, _, err := f.DefaultNamespace() if err != nil { return err } o.Namespace = namespace // Set up client based support. mapper, typer := f.Object(false) o.getBuilder = func() *resource.Builder { return resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), kapi.Codecs.UniversalDecoder()) } oClient, kClient, err := f.Clients() if err != nil { return err } o.oc = oClient o.kc = kClient o.out = out return nil }
func (o *DeployOptions) Complete(f *clientcmd.Factory, args []string, out io.Writer) error { var err error o.osClient, o.kubeClient, err = f.Clients() if err != nil { return err } o.namespace, _, err = f.DefaultNamespace() if err != nil { return err } mapper, typer := f.Object() o.builder = resource.NewBuilder(mapper, typer, f.ClientMapperForCommand()) o.out = out if len(args) > 0 { name := args[0] if strings.Index(name, "/") == -1 { name = fmt.Sprintf("dc/%s", name) } o.deploymentConfigName = name } return nil }
func (o *CreateSecretOptions) Complete(args []string, f *clientcmd.Factory) error { // Fill name from args[0] if len(args) > 0 { o.Name = args[0] } // Add sources from args[1:...] in addition to -f if len(args) > 1 { o.Sources = append(o.Sources, args[1:]...) } if f != nil { _, kubeClient, err := f.Clients() if err != nil { return err } namespace, _, err := f.Factory.DefaultNamespace() if err != nil { return err } o.SecretsInterface = kubeClient.Secrets(namespace) } return nil }
func (o *PruneOptions) Complete(whitelistFile, blacklistFile, configFile string, args []string, f *clientcmd.Factory) error { var err error o.Whitelist, err = buildOpenShiftGroupNameList(args, whitelistFile) if err != nil { return err } o.Blacklist, err = buildOpenShiftGroupNameList([]string{}, blacklistFile) if err != nil { return err } o.Config, err = decodeSyncConfigFromFile(configFile) if err != nil { return err } osClient, _, err := f.Clients() if err != nil { return err } o.GroupInterface = osClient.Groups() return nil }
func setupAppConfig(f *clientcmd.Factory, out io.Writer, 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) config.Out = out config.ErrOut = c.Out() unknown := config.AddArguments(args) if len(unknown) != 0 { return cmdutil.UsageError(c, "Did not recognize the following arguments: %v", unknown) } if config.AllowMissingImages && config.AsSearch { return cmdutil.UsageError(c, "--allow-missing-images and --search are mutually exclusive.") } return nil }
func (o *CreateUserOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string) error { switch len(args) { case 0: return fmt.Errorf("username is required") case 1: o.Name = args[0] default: return fmt.Errorf("exactly one argument (username) is supported, not: %v", args) } o.DryRun = cmdutil.GetFlagBool(cmd, "dry-run") client, _, err := f.Clients() if err != nil { return err } o.UserClient = client.Users() o.Mapper, _ = f.Object() o.OutputFormat = cmdutil.GetFlagString(cmd, "output") o.Printer = func(obj runtime.Object, out io.Writer) error { return f.PrintObject(cmd, o.Mapper, obj, out) } return nil }
func NewCmdApplication(fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { options := &NewApplicationOptions{} options.Out = out cmd := &cobra.Command{ Use: `new-application NAME [--items="KIND=KINDNAME,KIND=KINDNAME"]`, Short: "create a new application", Long: newApplicationLong, Example: fmt.Sprintf(newApplicationExample, fullName), Run: func(cmd *cobra.Command, args []string) { var err error if err = options.complete(cmd, f); err != nil { kcmdutil.CheckErr(err) return } if options.Client, _, err = f.Clients(); err != nil { kcmdutil.CheckErr(err) } if err := options.Run(f); err != nil { fmt.Printf("run err %s\n", err.Error()) } else { fmt.Printf("create application %s success.\n", options.Name) } }, } cmd.Flags().StringVar(&options.Item, "items", "", "application items") return cmd }
func (o *CreateImageStreamOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string) error { o.IS = &imageapi.ImageStream{ ObjectMeta: kapi.ObjectMeta{}, Spec: imageapi.ImageStreamSpec{}, } switch len(args) { case 0: return fmt.Errorf("image stream name is required") case 1: o.IS.Name = args[0] default: return fmt.Errorf("exactly one argument (name) is supported, not: %v", args) } var err error o.IS.Namespace, _, err = f.DefaultNamespace() if err != nil { return err } o.Client, _, err = f.Clients() if err != nil { return err } o.Mapper, _ = f.Object(false) o.OutputFormat = cmdutil.GetFlagString(cmd, "output") o.Printer = func(obj runtime.Object, out io.Writer) error { return f.PrintObject(cmd, o.Mapper, obj, out) } return nil }
func (o *RetryOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, out io.Writer, args []string) error { if len(args) == 0 && len(o.Filenames) == 0 { return kcmdutil.UsageError(cmd, cmd.Use) } o.Mapper, o.Typer = f.Object(false) o.Encoder = f.JSONEncoder() o.Out = out cmdNamespace, enforceNamespace, err := f.DefaultNamespace() if err != nil { return err } _, _, o.Clientset, err = f.Clients() if err != nil { return err } r := resource.NewBuilder(o.Mapper, o.Typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)). NamespaceParam(cmdNamespace).DefaultNamespace(). FilenameParam(enforceNamespace, o.Recursive, o.Filenames...). ResourceTypeOrNameArgs(true, args...). ContinueOnError(). Latest(). Flatten(). Do() err = r.Err() if err != nil { return err } o.Infos, err = r.Infos() return err }
func (o *CreateIdentityOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string) error { switch len(args) { case 0: return fmt.Errorf("identity name in the format <PROVIDER_NAME>:<PROVIDER_USER_NAME> is required") case 1: parts := strings.Split(args[0], ":") if len(parts) != 2 { return fmt.Errorf("identity name in the format <PROVIDER_NAME>:<PROVIDER_USER_NAME> is required") } o.ProviderName = parts[0] o.ProviderUserName = parts[1] default: return fmt.Errorf("exactly one argument (username) is supported, not: %v", args) } o.DryRun = cmdutil.GetFlagBool(cmd, "dry-run") client, _, _, err := f.Clients() if err != nil { return err } o.IdentityClient = client.Identities() o.Mapper, _ = f.Object(false) o.OutputFormat = cmdutil.GetFlagString(cmd, "output") o.Printer = func(obj runtime.Object, out io.Writer) error { return f.PrintObject(cmd, o.Mapper, obj, out) } return nil }
func (o *RolloutLatestOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string, out io.Writer) error { if len(args) != 1 { return errors.New("one deployment config name is needed as argument.") } namespace, _, err := f.DefaultNamespace() if err != nil { return err } o.oc, o.kc, err = f.Clients() if err != nil { return err } o.mapper, o.typer = f.Object(false) o.infos, err = resource.NewBuilder(o.mapper, o.typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)). ContinueOnError(). NamespaceParam(namespace). ResourceNames("deploymentconfigs", args[0]). SingleResourceType(). Do().Infos() if err != nil { return err } o.out = out o.shortOutput = kcmdutil.GetFlagString(cmd, "output") == "name" o.again = kcmdutil.GetFlagBool(cmd, "again") return nil }
func (o *SCCModificationOptions) CompleteUsers(f *clientcmd.Factory, args []string, saNames []string) error { if (len(args) < 2) && (len(saNames) == 0) { return errors.New("you must specify at least two arguments (<scc> <user> [user]...) or a service account (<scc> -z <service account name>) ") } o.SCCName = args[0] o.Subjects = authorizationapi.BuildSubjects(args[1:], []string{}, uservalidation.ValidateUserName, uservalidation.ValidateGroupName) var err error _, o.SCCInterface, err = f.Clients() if err != nil { return err } o.DefaultSubjectNamespace, _, err = f.DefaultNamespace() if err != nil { return err } for _, sa := range saNames { o.Subjects = append(o.Subjects, kapi.ObjectReference{Namespace: o.DefaultSubjectNamespace, Name: sa, Kind: "ServiceAccount"}) } 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: name + " VERB RESOURCE [NAME]", 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(f, args); err != nil { kcmdutil.CheckErr(kcmdutil.UsageError(cmd, err.Error())) } var err error options.client, _, err = f.Clients() kcmdutil.CheckErr(err) options.bindingNamespace, _, err = f.DefaultNamespace() kcmdutil.CheckErr(err) err = options.run() kcmdutil.CheckErr(err) }, } cmd.Flags().BoolVar(&options.allNamespaces, "all-namespaces", options.allNamespaces, "If present, list who can perform the specified action in all namespaces.") return cmd }
func NewCmdRequestProject(name, fullName, ocLoginName, ocProjectName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { options := &NewProjectOptions{} options.Out = out cmd := &cobra.Command{ Use: fmt.Sprintf("%s NAME [--display-name=DISPLAYNAME] [--description=DESCRIPTION]", name), Short: "Request a new project", Long: requestProjectLong, Example: fmt.Sprintf(requestProjectExample, fullName), Run: func(cmd *cobra.Command, args []string) { if err := options.complete(cmd, f); err != nil { kcmdutil.CheckErr(err) } var err error if options.Client, _, err = f.Clients(); err != nil { kcmdutil.CheckErr(err) } if err := options.Run(); err != nil { kcmdutil.CheckErr(err) } }, } cmd.Flags().StringVar(&options.DisplayName, "display-name", "", "Project display name") cmd.Flags().StringVar(&options.Description, "description", "", "Project description") return cmd }
func (o *MigrateImageReferenceOptions) Complete(f *clientcmd.Factory, c *cobra.Command, args []string) error { var remainingArgs []string for _, s := range args { if !strings.Contains(s, "=") { remainingArgs = append(remainingArgs, s) continue } mapping, err := ParseMapping(s) if err != nil { return err } o.Mappings = append(o.Mappings, mapping) } o.UpdatePodSpecFn = f.UpdatePodSpecForObject if len(remainingArgs) > 0 { return fmt.Errorf("all arguments must be valid FROM=TO mappings") } o.ResourceOptions.SaveFn = o.save if err := o.ResourceOptions.Complete(f, c); err != nil { return err } osclient, _, err := f.Clients() if err != nil { return err } o.Client = osclient return nil }
func (o *DeployOptions) Complete(f *clientcmd.Factory, args []string, out io.Writer) error { if len(args) > 1 { return errors.New("only one deployment config name is supported as argument.") } var err error o.osClient, o.kubeClient, err = f.Clients() if err != nil { return err } o.namespace, _, err = f.DefaultNamespace() if err != nil { return err } mapper, typer := f.Object(false) o.builder = resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), kapi.Codecs.UniversalDecoder()) o.out = out if len(args) > 0 { o.deploymentConfigName = args[0] } return nil }
func (o *CreateUserIdentityMappingOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string) error { switch len(args) { case 0: return fmt.Errorf("identity is required") case 1: return fmt.Errorf("user name is required") case 2: o.Identity = args[0] o.User = args[1] default: return fmt.Errorf("exactly two arguments (identity and user name) are supported, not: %v", args) } client, _, err := f.Clients() if err != nil { return err } o.UserIdentityMappingClient = client.UserIdentityMappings() o.Mapper, _ = f.Object(false) o.OutputFormat = cmdutil.GetFlagString(cmd, "output") o.Printer = func(obj runtime.Object, out io.Writer) error { return f.PrintObject(cmd, o.Mapper, obj, out) } return nil }
func (o *ReconcileClusterRolesOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string) error { oclient, _, err := f.Clients() if err != nil { return err } o.RoleClient = oclient.ClusterRoles() o.Output = kcmdutil.GetFlagString(cmd, "output") mapper, _ := f.Object() for _, resourceString := range args { resource, name, err := osutil.ResolveResource(authorizationapi.Resource("clusterroles"), resourceString, mapper) if err != nil { return err } if resource != authorizationapi.Resource("clusterroles") { return fmt.Errorf("%v is not a valid resource type for this command", resource) } if len(name) == 0 { return fmt.Errorf("%s did not contain a name", resourceString) } o.RolesToReconcile = append(o.RolesToReconcile, name) } return nil }
func (o *AppJSONOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string) error { version, _ := cmd.Flags().GetString("output-version") for _, v := range strings.Split(version, ",") { gv, err := unversioned.ParseGroupVersion(v) if err != nil { return fmt.Errorf("provided output-version %q is not valid: %v", v, err) } o.OutputVersions = append(o.OutputVersions, gv) } o.OutputVersions = append(o.OutputVersions, registered.EnabledVersions()...) o.Action.Bulk.Mapper = clientcmd.ResourceMapper(f) o.Action.Bulk.Op = configcmd.Create mapper, _ := f.Object(false) o.PrintObject = cmdutil.VersionedPrintObject(f.PrintObject, cmd, mapper, o.Action.Out) o.Generator, _ = cmd.Flags().GetString("generator") ns, _, err := f.DefaultNamespace() if err != nil { return err } o.Namespace = ns o.Client, _, err = f.Clients() return err }
func (n *NodeOptions) Complete(f *clientcmd.Factory, c *cobra.Command, args []string, out io.Writer) error { defaultNamespace, err := f.DefaultNamespace() if err != nil { return err } _, kc, err := f.Clients() if err != nil { return err } cmdPrinter, output, err := kcmdutil.PrinterForCommand(c) if err != nil { return err } mapper, typer := f.Object() n.DefaultNamespace = defaultNamespace n.Kclient = kc n.Writer = out n.Mapper = mapper n.Typer = typer n.RESTClientFactory = f.Factory.RESTClient n.Printer = f.Printer n.NodeNames = []string{} n.CmdPrinter = cmdPrinter n.CmdPrinterOutput = false if output { n.CmdPrinterOutput = true } if len(args) != 0 { n.NodeNames = append(n.NodeNames, args...) } return nil }
func (o *RoleModificationOptions) CompleteUserWithSA(f *clientcmd.Factory, args []string, saNames []string) error { if len(args) < 1 { return errors.New("you must specify a role") } o.RoleName = args[0] if len(args) > 1 { o.Users = append(o.Users, args[1:]...) } if (len(o.Users) == 0) && (len(saNames) == 0) { return errors.New("you must specify at least one user or service account") } osClient, _, err := f.Clients() if err != nil { return err } roleBindingNamespace, _, err := f.DefaultNamespace() if err != nil { return err } o.RoleBindingAccessor = NewLocalRoleBindingAccessor(roleBindingNamespace, osClient) for _, sa := range saNames { o.Subjects = append(o.Subjects, kapi.ObjectReference{Namespace: roleBindingNamespace, Name: sa, Kind: "ServiceAccount"}) } return nil }
func (o *CreatePolicyBindingOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string) error { if len(args) != 1 { return fmt.Errorf("exactly one argument (policy namespace) is supported, not: %v", args) } o.PolicyNamespace = args[0] namespace, _, err := f.DefaultNamespace() if err != nil { return err } o.BindingNamespace = namespace client, _, err := f.Clients() if err != nil { return err } o.BindingClient = client o.Mapper, _ = f.Object() o.OutputFormat = cmdutil.GetFlagString(cmd, "output") o.Printer = func(obj runtime.Object, out io.Writer) error { return f.PrintObject(cmd, o.Mapper, obj, out) } return nil }
func (o *ProjectOptions) Complete(f *clientcmd.Factory, args []string, out io.Writer) error { var err error argsLength := len(args) switch { case argsLength > 1: return errors.New("Only one argument is supported (project name or context name).") case argsLength == 1: o.ProjectName = args[0] } o.Config, err = f.OpenShiftClientConfig.RawConfig() if err != nil { return err } o.ClientConfig, err = f.OpenShiftClientConfig.ClientConfig() if err != nil { return err } o.Client, _, err = f.Clients() if err != nil { return err } o.Out = out return nil }
// Complete turns a partially defined TopImagesOptions into a solvent structure // which can be validated and used for showing limits usage. func (o *TopImagesOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string, out io.Writer) error { osClient, kClient, err := f.Clients() if err != nil { return err } namespace := cmd.Flag("namespace").Value.String() if len(namespace) == 0 { namespace = kapi.NamespaceAll } o.out = out allImages, err := osClient.Images().List(kapi.ListOptions{}) if err != nil { return err } o.Images = allImages allStreams, err := osClient.ImageStreams(namespace).List(kapi.ListOptions{}) if err != nil { return err } o.Streams = allStreams allPods, err := kClient.Pods(namespace).List(kapi.ListOptions{}) if err != nil { return err } o.Pods = allPods return nil }
func (o *ProjectsOptions) Complete(f *clientcmd.Factory, args []string, commandName string, out io.Writer) error { if len(args) > 0 { return fmt.Errorf("no arguments should be passed") } o.CommandName = commandName var err error o.Config, err = f.OpenShiftClientConfig.RawConfig() if err != nil { return err } o.ClientConfig, err = f.OpenShiftClientConfig.ClientConfig() if err != nil { return err } o.Client, _, err = f.Clients() if err != nil { return err } o.Out = out return nil }
// RunStatus contains all the necessary functionality for the OpenShift cli status command func RunStatus(f *clientcmd.Factory, out io.Writer) error { client, kclient, err := f.Clients() if err != nil { return err } config, err := f.OpenShiftClientConfig.ClientConfig() if err != nil { return err } namespace, _, err := f.DefaultNamespace() if err != nil { return err } describer := &describe.ProjectStatusDescriber{K: kclient, C: client, Server: config.Host} s, err := describer.Describe(namespace, "") if err != nil { return err } fmt.Fprintf(out, s) return nil }