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 }
// Complete sets any default behavior for the command func (o *NewAppOptions) Complete(commandName string, f *clientcmd.Factory, c *cobra.Command, args []string, out io.Writer) error { o.Out = out o.ErrOut = c.Out() o.Output = kcmdutil.GetFlagString(c, "output") // Only output="" should print descriptions of intermediate steps. Everything // else should print only some specific output (json, yaml, go-template, ...) if len(o.Output) == 0 { o.Config.Out = o.Out } else { o.Config.Out = ioutil.Discard } o.Config.ErrOut = o.ErrOut o.Action.Out, o.Action.ErrOut = o.Out, o.ErrOut o.Action.Bulk.Mapper = clientcmd.ResourceMapper(f) o.Action.Bulk.Op = configcmd.Create // Retry is used to support previous versions of the API server that will // consider the presence of an unknown trigger type to be an error. o.Action.Bulk.Retry = retryBuildConfig o.Config.DryRun = o.Action.DryRun o.CommandPath = c.CommandPath() o.CommandName = commandName mapper, _ := f.Object(false) o.PrintObject = cmdutil.VersionedPrintObject(f.PrintObject, c, mapper, out) o.LogsForObject = f.LogsForObject if err := CompleteAppConfig(o.Config, f, c, args); err != nil { return err } if err := setAppConfigLabels(c, o.Config); err != nil { return err } return nil }
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 (v *VolumeOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, out io.Writer) error { clientConfig, err := f.ClientConfig() if err != nil { return err } v.OutputVersion = kcmdutil.OutputVersion(cmd, clientConfig.Version) cmdNamespace, err := f.DefaultNamespace() if err != nil { return err } mapper, typer := f.Object() v.DefaultNamespace = cmdNamespace v.Writer = out v.Mapper = mapper v.Typer = typer v.RESTClientFactory = f.Factory.RESTClient v.UpdatePodSpecForObject = f.UpdatePodSpecForObject if v.Add && len(v.Name) == 0 { v.Name = kapi.SimpleNameGenerator.GenerateName(volumePrefix) if len(v.Output) == 0 { fmt.Fprintf(v.Writer, "Generated volume name: %s\n", v.Name) } } // In case of volume source ignore the default volume type if len(v.AddOpts.Source) > 0 { v.AddOpts.Type = "" } return nil }
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 *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 }
// ImportObjects imports objects into OpenShift from a particular location // into a given namespace func ImportObjects(f *clientcmd.Factory, ns, location string) error { mapper, typer := f.Object(false) schema, err := f.Validator(false, "") if err != nil { return err } data, err := bootstrap.Asset(location) if err != nil { return err } glog.V(8).Infof("Importing data:\n%s\n", string(data)) r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), f.Decoder(true)). Schema(schema). ContinueOnError(). NamespaceParam(ns). DefaultNamespace(). Stream(bytes.NewBuffer(data), location). Flatten(). Do() return r.Visit(func(info *resource.Info, err error) error { if err != nil { return err } glog.V(5).Infof("Creating %s/%s", info.Namespace, info.Name) if err = createAndRefresh(info); err != nil { return cmdutil.AddSourceToErr("creating", info.Source, err) } return nil }) }
// RunReconcileSCCs contains the functionality for the reconcile-sccs command for making or // previewing changes. func (o *ReconcileSCCOptions) RunReconcileSCCs(cmd *cobra.Command, f *clientcmd.Factory) error { // get sccs that need updated changedSCCs, err := o.ChangedSCCs() if err != nil { return err } if len(changedSCCs) == 0 { return nil } if !o.Confirmed { list := &kapi.List{} for _, item := range changedSCCs { list.Items = append(list.Items, item) } mapper, _ := f.Object(false) fn := cmdutil.VersionedPrintObject(f.PrintObject, cmd, mapper, o.Out) if err := fn(list); err != nil { return err } } if o.Confirmed { return o.ReplaceChangedSCCs(changedSCCs) } return nil }
func (v *VolumeOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, out io.Writer) error { clientConfig, err := f.ClientConfig() if err != nil { return err } v.OutputVersion = kcmdutil.OutputVersion(cmd, clientConfig.Version) cmdNamespace, explicit, err := f.DefaultNamespace() if err != nil { return err } mapper, typer := f.Object() v.DefaultNamespace = cmdNamespace v.ExplicitNamespace = explicit v.Writer = out v.Mapper = mapper v.Typer = typer v.RESTClientFactory = f.Factory.RESTClient v.UpdatePodSpecForObject = f.UpdatePodSpecForObject // In case of volume source ignore the default volume type if len(v.AddOpts.Source) > 0 { v.AddOpts.Type = "" } return nil }
func (o *TriggersOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, args []string) error { cmdNamespace, explicit, err := f.DefaultNamespace() if err != nil { return err } if !cmd.Flags().Lookup("from-github").Changed { o.FromGitHub = nil } if !cmd.Flags().Lookup("from-webhook").Changed { o.FromWebHook = nil } if !cmd.Flags().Lookup("from-webhook-allow-env").Changed { o.FromWebHookAllowEnv = nil } if len(o.FromImage) > 0 { ref, err := imageapi.ParseDockerImageReference(o.FromImage) if err != nil { return fmt.Errorf("the value of --from-image does not appear to be a valid reference to an image: %v", err) } if len(ref.Registry) > 0 || len(ref.ID) > 0 { return fmt.Errorf("the value of --from-image must point to an image stream tag on this server") } if len(ref.Tag) == 0 { return fmt.Errorf("the value of --from-image must include the tag you wish to pull from") } o.FromImage = ref.NameString() o.FromImageNamespace = defaultNamespace(ref.Namespace, cmdNamespace) } count := o.count() o.Reset = count == 0 && (o.Auto || o.Manual) switch { case count == 0 && !o.Remove && !o.RemoveAll && !o.Auto && !o.Manual: o.PrintTable = true case !o.RemoveAll && !o.Auto && !o.Manual: o.Auto = true } mapper, typer := f.Object(false) o.Builder = resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), kapi.Codecs.UniversalDecoder()). ContinueOnError(). NamespaceParam(cmdNamespace).DefaultNamespace(). FilenameParam(explicit, false, o.Filenames...). SelectorParam(o.Selector). ResourceTypeOrNameArgs(o.All, args...). Flatten() output := kcmdutil.GetFlagString(cmd, "output") if len(output) != 0 { o.PrintObject = func(obj runtime.Object) error { return f.PrintObject(cmd, mapper, obj, o.Out) } } o.Encoder = f.JSONEncoder() o.ShortOutput = kcmdutil.GetFlagString(cmd, "output") == "name" o.Mapper = mapper 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) } mapper, _ := f.Object() err = f.PrintObject(cmd, mapper, 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 (o *ReconcileClusterRoleBindingsOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string, excludeUsers, excludeGroups []string) error { oclient, _, err := f.Clients() if err != nil { return err } o.RoleBindingClient = oclient.ClusterRoleBindings() o.Output = kcmdutil.GetFlagString(cmd, "output") o.ExcludeSubjects = authorizationapi.BuildSubjects(excludeUsers, excludeGroups, uservalidation.ValidateUserName, uservalidation.ValidateGroupName) mapper, _ := f.Object() for _, resourceString := range args { resource, name, err := ocmdutil.ResolveResource("clusterroles", resourceString, mapper) if err != nil { return err } if resource != "clusterroles" { return fmt.Errorf("%s 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 *ReconcileClusterRoleBindingsOptions) RunReconcileClusterRoleBindings(cmd *cobra.Command, f *clientcmd.Factory) error { changedClusterRoleBindings, fetchErr := o.ChangedClusterRoleBindings() if fetchErr != nil && !IsClusterRoleBindingLookupError(fetchErr) { // we got an error that isn't due to a partial match, so we can't continue return fetchErr } if len(changedClusterRoleBindings) == 0 { return fetchErr } if (len(o.Output) != 0) && !o.Confirmed { list := &kapi.List{} for _, item := range changedClusterRoleBindings { list.Items = append(list.Items, item) } mapper, _ := f.Object(false) fn := cmdutil.VersionedPrintObject(f.PrintObject, cmd, mapper, o.Out) if err := fn(list); err != nil { return kutilerrors.NewAggregate([]error{fetchErr, err}) } } if o.Confirmed { if err := o.ReplaceChangedRoleBindings(changedClusterRoleBindings); err != nil { return kutilerrors.NewAggregate([]error{fetchErr, err}) } } return fetchErr }
// ReconcileClusterRoleBindingsOptions contains all the necessary functionality for the OpenShift cli reconcile-cluster-role-bindings command func (o *ReconcileClusterRoleBindingsOptions) RunReconcileClusterRoleBindings(cmd *cobra.Command, f *clientcmd.Factory) error { changedClusterRoleBindings, err := o.ChangedClusterRoleBindings() if err != nil { return err } if len(changedClusterRoleBindings) == 0 { return nil } if (len(o.Output) != 0) && !o.Confirmed { list := &kapi.List{} for _, item := range changedClusterRoleBindings { list.Items = append(list.Items, item) } mapper, _ := f.Object(false) fn := cmdutil.VersionedPrintObject(f.PrintObject, cmd, mapper, o.Out) if err := fn(list); err != nil { return err } } if o.Confirmed { return o.ReplaceChangedRoleBindings(changedClusterRoleBindings) } return nil }
// NewCmdNewApplication implements the OpenShift cli new-app command func NewCmdNewApplication(fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { config := newcmd.NewAppConfig() config.Deploy = true cmd := &cobra.Command{ Use: "new-app (IMAGE | IMAGESTREAM | TEMPLATE | PATH | URL ...)", Short: "Create a new application", Long: fmt.Sprintf(newAppLong, fullName), Example: fmt.Sprintf(newAppExample, fullName), SuggestFor: []string{"app", "application"}, Run: func(c *cobra.Command, args []string) { mapper, typer := f.Object() config.Mapper = mapper config.Typer = typer config.ClientMapper = resource.ClientMapperFunc(f.ClientForMapping) err := RunNewApplication(fullName, f, out, c, args, config) if err == cmdutil.ErrExit { os.Exit(1) } kcmdutil.CheckErr(err) }, } cmd.Flags().BoolVar(&config.AsTestDeployment, "as-test", config.AsTestDeployment, "If true create this application as a test deployment, which validates that the deployment succeeds and then scales down.") cmd.Flags().StringSliceVar(&config.SourceRepositories, "code", config.SourceRepositories, "Source code to use to build this application.") cmd.Flags().StringVar(&config.ContextDir, "context-dir", "", "Context directory to be used for the build.") cmd.Flags().StringSliceVarP(&config.ImageStreams, "image", "", config.ImageStreams, "Name of an image stream to use in the app. (deprecated)") cmd.Flags().MarkDeprecated("image", "use --image-stream instead") cmd.Flags().StringSliceVarP(&config.ImageStreams, "image-stream", "i", config.ImageStreams, "Name of an image stream to use in the app.") cmd.Flags().StringSliceVar(&config.DockerImages, "docker-image", config.DockerImages, "Name of a Docker image to include in the app.") cmd.Flags().StringSliceVar(&config.Templates, "template", config.Templates, "Name of a stored template to use in the app.") cmd.Flags().StringSliceVarP(&config.TemplateFiles, "file", "f", config.TemplateFiles, "Path to a template file to use for the app.") cmd.MarkFlagFilename("file", "yaml", "yml", "json") cmd.Flags().StringSliceVarP(&config.TemplateParameters, "param", "p", config.TemplateParameters, "Specify a list of key value pairs (e.g., -p FOO=BAR,BAR=FOO) to set/override parameter values in the template.") cmd.Flags().StringSliceVar(&config.Groups, "group", config.Groups, "Indicate components that should be grouped together as <comp1>+<comp2>.") cmd.Flags().StringSliceVarP(&config.Environment, "env", "e", config.Environment, "Specify key value pairs of environment variables to set into each container.") cmd.Flags().StringVar(&config.Name, "name", "", "Set name to use for generated application artifacts") cmd.Flags().StringVar(&config.Strategy, "strategy", "", "Specify the build strategy to use if you don't want to detect (docker|source).") cmd.Flags().StringP("labels", "l", "", "Label to set in all resources for this application.") cmd.Flags().BoolVar(&config.InsecureRegistry, "insecure-registry", false, "If true, indicates that the referenced Docker images are on insecure registries and should bypass certificate checking") cmd.Flags().BoolVarP(&config.AsList, "list", "L", false, "List all local templates and image streams that can be used to create.") cmd.Flags().BoolVarP(&config.AsSearch, "search", "S", false, "Search all templates, image streams, and Docker images that match the arguments provided.") cmd.Flags().BoolVar(&config.AllowMissingImages, "allow-missing-images", false, "If true, indicates that referenced Docker images that cannot be found locally or in a registry should still be used.") cmd.Flags().BoolVar(&config.AllowMissingImageStreamTags, "allow-missing-imagestream-tags", false, "If true, indicates that image stream tags that don't exist should still be used.") cmd.Flags().BoolVar(&config.AllowSecretUse, "grant-install-rights", false, "If true, a component that requires access to your account may use your token to install software into your project. Only grant images you trust the right to run with your token.") cmd.Flags().BoolVar(&config.SkipGeneration, "no-install", false, "Do not attempt to run images that describe themselves as being installable") cmd.Flags().BoolVar(&config.DryRun, "dry-run", false, "If true, do not actually create resources.") // TODO AddPrinterFlags disabled so that it doesn't conflict with our own "template" flag. // Need a better solution. // kcmdutil.AddPrinterFlags(cmd) cmd.Flags().StringP("output", "o", "", "Output format. One of: json|yaml|template|templatefile.") cmd.Flags().String("output-version", "", "Output the formatted object with the given version (default api-version).") cmd.Flags().Bool("no-headers", false, "When using the default output, don't print headers.") cmd.Flags().String("output-template", "", "Template string or path to template file to use when -o=template or -o=templatefile. The template format is golang templates [http://golang.org/pkg/text/template/#pkg-overview]") cmd.MarkFlagFilename("output-template") return cmd }
// NewCmdNewBuild implements the OpenShift cli new-build command func NewCmdNewBuild(fullName string, f *clientcmd.Factory, in io.Reader, out io.Writer) *cobra.Command { mapper, typer := f.Object() clientMapper := f.ClientMapperForCommand() config := newcmd.NewAppConfig(typer, mapper, clientMapper) cmd := &cobra.Command{ Use: "new-build (IMAGE | IMAGESTREAM | PATH | URL ...)", Short: "Create a new build configuration", Long: newBuildLong, Example: fmt.Sprintf(newBuildExample, fullName), Run: func(c *cobra.Command, args []string) { config.AddEnvironmentToBuild = true err := RunNewBuild(fullName, f, out, in, c, args, config) if err == errExit { os.Exit(1) } cmdutil.CheckErr(err) }, } cmd.Flags().Var(&config.SourceRepositories, "code", "Source code in the build configuration.") cmd.Flags().VarP(&config.ImageStreams, "image", "i", "Name of an image stream to to use as a builder.") cmd.Flags().Var(&config.DockerImages, "docker-image", "Name of a Docker image to use as a builder.") cmd.Flags().StringVar(&config.Name, "name", "", "Set name to use for generated build artifacts") cmd.Flags().VarP(&config.Environment, "env", "e", "Specify key value pairs of environment variables to set into resulting image.") cmd.Flags().StringVar(&config.Strategy, "strategy", "", "Specify the build strategy to use if you don't want to detect (docker|source).") cmd.Flags().StringVarP(&config.Dockerfile, "dockerfile", "D", "", "Specify the contents of a Dockerfile to build directly, implies --strategy=docker. Pass '-' to read from STDIN.") cmd.Flags().BoolVar(&config.OutputDocker, "to-docker", false, "Have the build output push to a Docker repository.") cmd.Flags().StringP("labels", "l", "", "Label to set in all generated resources.") cmdutil.AddPrinterFlags(cmd) return cmd }
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 }
// 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 *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 *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 *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 (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 *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 *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 }
// NewCmdNewBuild implements the OpenShift cli new-build command func NewCmdNewBuild(fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command { mapper, typer := f.Object() clientMapper := f.ClientMapperForCommand() config := newcmd.NewAppConfig(typer, mapper, clientMapper) cmd := &cobra.Command{ Use: "new-build (IMAGE | IMAGESTREAM | PATH | URL ...)", Short: "Create a new build configuration", Long: newBuildLong, Example: fmt.Sprintf(newBuildExample, fullName), Run: func(c *cobra.Command, args []string) { err := RunNewBuild(fullName, f, out, c, args, config) if err == errExit { os.Exit(1) } cmdutil.CheckErr(err) }, } cmd.Flags().Var(&config.SourceRepositories, "code", "Source code in the build configuration.") cmd.Flags().VarP(&config.ImageStreams, "image", "i", "Name of an OpenShift image stream to to use as a builder.") cmd.Flags().Var(&config.DockerImages, "docker-image", "Name of a Docker image to use as a builder.") cmd.Flags().StringVar(&config.Name, "name", "", "Set name to use for generated build artifacts") cmd.Flags().StringVar(&config.Strategy, "strategy", "", "Specify the build strategy to use if you don't want to detect (docker|source).") cmd.Flags().BoolVar(&config.OutputDocker, "to-docker", false, "Force the Build output to be DockerImage.") cmd.Flags().StringP("labels", "l", "", "Label to set in all generated resources.") cmdutil.AddPrinterFlags(cmd) return cmd }
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 }
// RunReconcileClusterRoles contains all the necessary functionality for the OpenShift cli reconcile-cluster-roles command func (o *ReconcileClusterRolesOptions) RunReconcileClusterRoles(cmd *cobra.Command, f *clientcmd.Factory) error { changedClusterRoles, skippedClusterRoles, err := o.ChangedClusterRoles() if err != nil { return err } if len(skippedClusterRoles) > 0 { fmt.Fprintf(o.ErrOut, "Skipped reconciling roles with the annotation %s=true\n", ReconcileProtectAnnotation) for _, role := range skippedClusterRoles { fmt.Fprintf(o.ErrOut, "skipped: clusterrole/%s\n", role.Name) } } if len(changedClusterRoles) == 0 { return nil } if (len(o.Output) != 0) && !o.Confirmed { list := &kapi.List{} for _, item := range changedClusterRoles { list.Items = append(list.Items, item) } mapper, _ := f.Object(false) fn := cmdutil.VersionedPrintObject(f.PrintObject, cmd, mapper, o.Out) if err := fn(list); err != nil { return err } } if o.Confirmed { return o.ReplaceChangedRoles(changedClusterRoles) } return nil }
func (o *CreateClusterQuotaOptions) Complete(cmd *cobra.Command, f *clientcmd.Factory, args []string) error { if len(args) != 1 { return fmt.Errorf("NAME is required: %v", args) } var labelSelector *unversioned.LabelSelector labelSelectorString := cmdutil.GetFlagString(cmd, "project-label-selector") if len(labelSelectorString) > 0 { var err error labelSelector, err = unversioned.ParseToLabelSelector(labelSelectorString) if err != nil { return err } } annotationSelector, err := parseAnnotationSelector(cmdutil.GetFlagString(cmd, "project-annotation-selector")) if err != nil { return err } o.ClusterQuota = "aapi.ClusterResourceQuota{ ObjectMeta: kapi.ObjectMeta{Name: args[0]}, Spec: quotaapi.ClusterResourceQuotaSpec{ Selector: quotaapi.ClusterResourceQuotaSelector{ LabelSelector: labelSelector, AnnotationSelector: annotationSelector, }, Quota: kapi.ResourceQuotaSpec{ Hard: kapi.ResourceList{}, }, }, } for _, resourceCount := range cmdutil.GetFlagStringSlice(cmd, "hard") { tokens := strings.Split(resourceCount, "=") if len(tokens) != 2 { return fmt.Errorf("%v must in the form of resource=quantity", resourceCount) } quantity, err := resource.ParseQuantity(tokens[1]) if err != nil { return err } o.ClusterQuota.Spec.Quota.Hard[kapi.ResourceName(tokens[0])] = quantity } 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 (v *VolumeOptions) Complete(f *clientcmd.Factory, cmd *cobra.Command, out, errOut io.Writer) error { clientConfig, err := f.ClientConfig() if err != nil { return err } v.OutputVersion, err = kcmdutil.OutputVersion(cmd, clientConfig.GroupVersion) if err != nil { return err } _, kc, err := f.Clients() if err != nil { return err } v.Client = kc cmdNamespace, explicit, err := f.DefaultNamespace() if err != nil { return err } mapper, typer := f.Object(false) v.DefaultNamespace = cmdNamespace v.ExplicitNamespace = explicit v.Out = out v.Err = errOut v.Mapper = mapper v.Typer = typer v.RESTClientFactory = f.Factory.ClientForMapping v.UpdatePodSpecForObject = f.UpdatePodSpecForObject v.Encoder = f.JSONEncoder() // In case of volume source ignore the default volume type if len(v.AddOpts.Source) > 0 { v.AddOpts.Type = "" } if len(v.AddOpts.ClaimSize) > 0 { v.AddOpts.CreateClaim = true if len(v.AddOpts.ClaimName) == 0 { v.AddOpts.ClaimName = kapi.SimpleNameGenerator.GenerateName("pvc-") } q, err := kresource.ParseQuantity(v.AddOpts.ClaimSize) if err != nil { return fmt.Errorf("--claim-size is not valid: %v", err) } v.AddOpts.ClaimSize = q.String() } switch strings.ToLower(v.AddOpts.ClaimMode) { case strings.ToLower(string(kapi.ReadOnlyMany)), "rom": v.AddOpts.ClaimMode = string(kapi.ReadOnlyMany) case strings.ToLower(string(kapi.ReadWriteOnce)), "rwo": v.AddOpts.ClaimMode = string(kapi.ReadWriteOnce) case strings.ToLower(string(kapi.ReadWriteMany)), "rwm": v.AddOpts.ClaimMode = string(kapi.ReadWriteMany) case "": default: return errors.New("--claim-mode must be one of ReadWriteOnce (rwo), ReadWriteMany (rwm), or ReadOnlyMany (rom)") } return nil }
// CreatePassthroughRoute implements the behavior to run the create passthrough route command. func CreatePassthroughRoute(f *clientcmd.Factory, out io.Writer, cmd *cobra.Command, args []string) error { oc, kc, err := f.Clients() if err != nil { return err } ns, _, err := f.DefaultNamespace() if err != nil { return err } serviceName, err := resolveServiceName(f, kcmdutil.GetFlagString(cmd, "service")) if err != nil { return err } routeName, err := resolveRouteName(args) if err != nil { return err } route, err := cmdutil.UnsecuredRoute(kc, ns, routeName, serviceName, kcmdutil.GetFlagString(cmd, "port")) if err != nil { return err } route.Spec.Host = kcmdutil.GetFlagString(cmd, "hostname") route.Spec.TLS = new(api.TLSConfig) route.Spec.TLS.Termination = api.TLSTerminationPassthrough dryRun := kcmdutil.GetFlagBool(cmd, "dry-run") actualRoute := route if !dryRun { actualRoute, err = oc.Routes(ns).Create(route) if err != nil { return err } } mapper, typer := f.Object(false) resourceMapper := &resource.Mapper{ ObjectTyper: typer, RESTMapper: mapper, ClientMapper: resource.ClientMapperFunc(f.ClientForMapping), } info, err := resourceMapper.InfoForObject(actualRoute, nil) if err != nil { return err } created := "created" if dryRun { created = "created (DRY RUN)" } shortOutput := kcmdutil.GetFlagString(cmd, "output") == "name" kcmdutil.PrintSuccess(mapper, shortOutput, out, info.Mapping.Resource, info.Name, created) return nil }