// ResourceFromArgsOrFile expects two arguments or a valid file with a given type, and extracts // the fields necessary to uniquely locate a resource. Displays a usageError if that contract is // not satisfied, or a generic error if any other problems occur. func ResourceFromArgsOrFile(cmd *cobra.Command, args []string, filename string, typer runtime.ObjectTyper, mapper meta.RESTMapper) (mapping *meta.RESTMapping, namespace, name string) { // If command line args are passed in, use those preferentially. if len(args) > 0 && len(args) != 2 { usageError(cmd, "If passing in command line parameters, must be resource and name") } if len(args) == 2 { resource := kubectl.ExpandResourceShortcut(args[0]) namespace = getKubeNamespace(cmd) name = args[1] if len(name) == 0 || len(resource) == 0 { usageError(cmd, "Must specify filename or command line params") } version, kind, err := mapper.VersionAndKindForResource(resource) checkErr(err) mapping, err = mapper.RESTMapping(version, kind) checkErr(err) return } if len(filename) == 0 { usageError(cmd, "Must specify filename or command line params") } mapping, namespace, name, _ = ResourceFromFile(filename, typer, mapper) if len(name) == 0 { checkErr(fmt.Errorf("The resource in the provided file has no name (or ID) defined")) } return }
// ResourceFromArgs expects two arguments with a given type, and extracts the fields necessary // to uniquely locate a resource. Displays a usageError if that contract is not satisfied, or // a generic error if any other problems occur. func ResourceOrTypeFromArgs(cmd *cobra.Command, args []string, mapper meta.RESTMapper) (mapping *meta.RESTMapping, namespace, name string) { if len(args) == 0 || len(args) > 2 { usageError(cmd, "Must provide resource or a resource and name as command line params") } resource := kubectl.ExpandResourceShortcut(args[0]) if len(resource) == 0 { usageError(cmd, "Must provide resource or a resource and name as command line params") } namespace = getKubeNamespace(cmd) if len(args) == 2 { name = args[1] if len(name) == 0 { usageError(cmd, "Must provide resource or a resource and name as command line params") } } version, kind, err := mapper.VersionAndKindForResource(resource) checkErr(err) mapping, err = mapper.RESTMapping(version, kind) checkErr(err) return }
// ObjectReaction returns a ReactionFunc that takes a generic action string of the form // <verb>-<resource> or <verb>-<subresource>-<resource> and attempts to return a runtime // Object or error that matches the requested action. For instance, list-replicationControllers // should attempt to return a list of replication controllers. This method delegates to the // ObjectRetriever interface to satisfy retrieval of lists or retrieval of single items. // TODO: add support for sub resources func ObjectReaction(o ObjectRetriever, mapper meta.RESTMapper) ReactionFunc { return func(action FakeAction) (runtime.Object, error) { segments := strings.Split(action.Action, "-") var verb, resource string switch len(segments) { case 3: verb, _, resource = segments[0], segments[1], segments[2] case 2: verb, resource = segments[0], segments[1] default: return nil, fmt.Errorf("unrecognized action, need two or three segments <verb>-<resource> or <verb>-<subresource>-<resource>: %s", action.Action) } _, kind, err := mapper.VersionAndKindForResource(resource) if err != nil { return nil, fmt.Errorf("unrecognized action %s: %v", resource, err) } // TODO: have mapper return a Kind for a subresource? switch verb { case "list", "search": return o.Kind(kind+"List", "") case "get", "create", "update", "delete": // TODO: handle sub resources if s, ok := action.Value.(string); ok && action.Value != nil { return o.Kind(kind, s) } return o.Kind(kind, "unknown") default: return nil, fmt.Errorf("no reaction implemented for %s", action.Action) } return nil, nil } }
// ResourceFromArgs expects two arguments with a given type, and extracts the fields necessary // to uniquely locate a resource. Displays a usageError if that contract is not satisfied, or // a generic error if any other problems occur. func ResourceOrTypeFromArgs(cmd *cobra.Command, args []string, mapper meta.RESTMapper) (mapping *meta.RESTMapping, namespace, name string) { if len(args) == 0 || len(args) > 2 { usageError(cmd, "Must provide resource or a resource and name as command line params") } resource := args[0] if len(resource) == 0 { usageError(cmd, "Must provide resource or a resource and name as command line params") } namespace = GetKubeNamespace(cmd) if len(args) == 2 { name = args[1] if len(name) == 0 { usageError(cmd, "Must provide resource or a resource and name as command line params") } } defaultVersion, kind, err := mapper.VersionAndKindForResource(resource) checkErr(err) version := GetFlagString(cmd, "api-version") mapping, err = mapper.RESTMapping(kind, version, defaultVersion) checkErr(err) return }
// ObjectReaction returns a ReactionFunc that takes a generic action string of the form // <verb>-<resource> or <verb>-<subresource>-<resource> and attempts to return a runtime // Object or error that matches the requested action. For instance, list-replicationControllers // should attempt to return a list of replication controllers. This method delegates to the // ObjectRetriever interface to satisfy retrieval of lists or retrieval of single items. // TODO: add support for sub resources func ObjectReaction(o ObjectRetriever, mapper meta.RESTMapper) ReactionFunc { return func(action Action) (runtime.Object, error) { _, kind, err := mapper.VersionAndKindForResource(action.GetResource()) if err != nil { return nil, fmt.Errorf("unrecognized action %s: %v", action.GetResource(), err) } // TODO: have mapper return a Kind for a subresource? switch castAction := action.(type) { case ListAction: return o.Kind(kind+"List", "") case GetAction: return o.Kind(kind, castAction.GetName()) case DeleteAction: return o.Kind(kind, castAction.GetName()) case CreateAction: meta, err := api.ObjectMetaFor(castAction.GetObject()) if err != nil { return nil, err } return o.Kind(kind, meta.Name) case UpdateAction: meta, err := api.ObjectMetaFor(castAction.GetObject()) if err != nil { return nil, err } return o.Kind(kind, meta.Name) default: return nil, fmt.Errorf("no reaction implemented for %s", action) } return nil, nil } }
// ResourceFromArgsOrFile expects two arguments or a valid file with a given type, and extracts // the fields necessary to uniquely locate a resource. Displays a usageError if that contract is // not satisfied, or a generic error if any other problems occur. func ResourceFromArgsOrFile(cmd *cobra.Command, args []string, filename string, typer runtime.ObjectTyper, mapper meta.RESTMapper, schema validation.Schema, cmdNamespace, cmdVersion string) (mapping *meta.RESTMapping, namespace, name string) { // If command line args are passed in, use those preferentially. if len(args) > 0 && len(args) != 2 { usageError(cmd, "If passing in command line parameters, must be resource and name") } if len(args) == 2 { resource := args[0] namespace = cmdNamespace name = args[1] if len(name) == 0 || len(resource) == 0 { usageError(cmd, "Must specify filename or command line params") } defaultVersion, kind, err := mapper.VersionAndKindForResource(resource) if err != nil { // The error returned by mapper is "no resource defined", which is a usage error usageError(cmd, err.Error()) } mapping, err = mapper.RESTMapping(kind, cmdVersion, defaultVersion) checkErr(err) return } if len(filename) == 0 { usageError(cmd, "Must specify filename or command line params") } mapping, namespace, name, _ = ResourceFromFile(filename, typer, mapper, schema, cmdVersion) if len(name) == 0 { checkErr(fmt.Errorf("the resource in the provided file has no name (or ID) defined")) } return }
// ResourcesFromArgsOrFile computes a list of Resources by extracting info from filename or args. It will // handle label selectors provided. func ResourcesFromArgsOrFile( cmd *cobra.Command, args []string, filename, selector string, typer runtime.ObjectTyper, mapper meta.RESTMapper, clientBuilder func(cmd *cobra.Command, mapping *meta.RESTMapping) (resource.RESTClient, error), schema validation.Schema, requireNames bool, cmdNamespace, cmdVersion string, ) resource.Visitor { // handling filename & resource id if len(selector) == 0 { if requireNames || len(filename) > 0 { mapping, namespace, name := ResourceFromArgsOrFile(cmd, args, filename, typer, mapper, schema, cmdNamespace, cmdVersion) client, err := clientBuilder(cmd, mapping) checkErr(err) return resource.NewInfo(client, mapping, namespace, name) } if len(args) == 2 { mapping, namespace, name := ResourceOrTypeFromArgs(cmd, args, mapper, cmdNamespace, cmdVersion) client, err := clientBuilder(cmd, mapping) checkErr(err) return resource.NewInfo(client, mapping, namespace, name) } } labelSelector, err := labels.ParseSelector(selector) checkErr(err) namespace := cmdNamespace visitors := resource.VisitorList{} if len(args) < 1 { usageError(cmd, "Must specify the type of resource") } if len(args) > 1 { usageError(cmd, "Too many arguments") } types := SplitResourceArgument(args[0]) for _, arg := range types { resourceName := arg if len(resourceName) == 0 { usageError(cmd, "Unknown resource %s", resourceName) } version, kind, err := mapper.VersionAndKindForResource(resourceName) checkErr(err) mapping, err := mapper.RESTMapping(kind, version) checkErr(err) client, err := clientBuilder(cmd, mapping) checkErr(err) visitors = append(visitors, resource.NewSelector(client, mapping, namespace, labelSelector)) } return visitors }
// ResourceFromArgs expects two arguments with a given type, and extracts the fields necessary // to uniquely locate a resource. Displays a usageError if that contract is not satisfied, or // a generic error if any other problems occur. func ResourceFromArgs(cmd *cobra.Command, args []string, mapper meta.RESTMapper) (mapping *meta.RESTMapping, namespace, name string) { if len(args) != 2 { usageError(cmd, "Must provide resource and name command line params") } resource := args[0] namespace = GetKubeNamespace(cmd) name = args[1] if len(name) == 0 || len(resource) == 0 { usageError(cmd, "Must provide resource and name command line params") } version, kind, err := mapper.VersionAndKindForResource(resource) checkErr(err) mapping, err = mapper.RESTMapping(kind, version) checkErr(err) return }
// ResourceFromArgs expects two arguments with a given type, and extracts the fields necessary // to uniquely locate a resource. Displays a UsageError if that contract is not satisfied, or // a generic error if any other problems occur. // DEPRECATED: Use resource.Builder func ResourceFromArgs(cmd *cobra.Command, args []string, mapper meta.RESTMapper, cmdNamespace string) (mapping *meta.RESTMapping, namespace, name string, err error) { if len(args) != 2 { err = UsageError(cmd, "Must provide resource and name command line params") return } resource := args[0] namespace = cmdNamespace name = args[1] if len(name) == 0 || len(resource) == 0 { err = UsageError(cmd, "Must provide resource and name command line params") return } version, kind, err := mapper.VersionAndKindForResource(resource) if err != nil { return } mapping, err = mapper.RESTMapping(kind, version) return }