// ServerPreferredNamespacedGroupVersionResources uses the specified client to discover the set of preferred groupVersionResources that are namespaced func ServerPreferredNamespacedGroupVersionResources(discoveryClient discovery.DiscoveryInterface) ([]unversioned.GroupVersionResource, error) { results := []unversioned.GroupVersionResource{} serverGroupList, err := discoveryClient.ServerGroups() if err != nil { return results, err } allErrs := []error{} for _, apiGroup := range serverGroupList.Groups { preferredVersion := apiGroup.PreferredVersion apiResourceList, err := discoveryClient.ServerResourcesForGroupVersion(preferredVersion.GroupVersion) if err != nil { allErrs = append(allErrs, err) continue } groupVersion := unversioned.GroupVersion{Group: apiGroup.Name, Version: preferredVersion.Version} for _, apiResource := range apiResourceList.APIResources { if !apiResource.Namespaced { continue } if strings.Contains(apiResource.Name, "/") { continue } results = append(results, groupVersion.WithResource(apiResource.Name)) } } return results, utilerrors.NewAggregate(allErrs) }
// FindAllCanonicalResources returns all resource names that map directly to their kind (Kind -> Resource -> Kind) // and are not subresources. This is the closest mapping possible from the client side to resources that can be // listed and updated. Note that this may return some virtual resources (like imagestreamtags) that can be otherwise // represented. // TODO: add a field to APIResources for "virtual" (or that points to the canonical resource). // TODO: fallback to the scheme when discovery is not possible. func FindAllCanonicalResources(d discovery.DiscoveryInterface, m meta.RESTMapper) ([]unversioned.GroupResource, error) { set := make(map[unversioned.GroupResource]struct{}) all, err := d.ServerResources() if err != nil { return nil, err } for apiVersion, v := range all { gv, err := unversioned.ParseGroupVersion(apiVersion) if err != nil { continue } for _, r := range v.APIResources { // ignore subresources if strings.Contains(r.Name, "/") { continue } // because discovery info doesn't tell us whether the object is virtual or not, perform a lookup // by the kind for resource (which should be the canonical resource) and then verify that the reverse // lookup (KindsFor) does not error. if mapping, err := m.RESTMapping(unversioned.GroupKind{Group: gv.Group, Kind: r.Kind}, gv.Version); err == nil { if _, err := m.KindsFor(mapping.GroupVersionKind.GroupVersion().WithResource(mapping.Resource)); err == nil { set[unversioned.GroupResource{Group: mapping.GroupVersionKind.Group, Resource: mapping.Resource}] = struct{}{} } } } } var groupResources []unversioned.GroupResource for k := range set { groupResources = append(groupResources, k) } sort.Sort(groupResourcesByName(groupResources)) return groupResources, nil }
func NewShortcutExpander(discoveryClient discovery.DiscoveryInterface, delegate meta.RESTMapper) ShortcutExpander { defaultMapper := ShortcutExpander{RESTMapper: delegate} // this assumes that legacy kube versions and legacy origin versions are the same, probably fair apiResources, err := discoveryClient.ServerResources() if err != nil { return defaultMapper } availableResources := []unversioned.GroupVersionResource{} for groupVersionString, resourceList := range apiResources { currVersion, err := unversioned.ParseGroupVersion(groupVersionString) if err != nil { return defaultMapper } for _, resource := range resourceList.APIResources { availableResources = append(availableResources, currVersion.WithResource(resource.Name)) } } availableAll := []string{} for _, requestedResource := range userResources { for _, availableResource := range availableResources { if requestedResource == availableResource.Resource { availableAll = append(availableAll, requestedResource) break } } } return ShortcutExpander{All: availableAll, RESTMapper: delegate} }
// GetServerSupportedSMPatchVersion takes a discoveryClient, // returns the max StrategicMergePatch version supported func GetServerSupportedSMPatchVersion(discoveryClient discovery.DiscoveryInterface) (StrategicMergePatchVersion, error) { serverVersion, err := discoveryClient.ServerVersion() if err != nil { return Unknown, err } serverGitVersion := serverVersion.GitVersion if serverGitVersion >= string(SMPatchVersion_1_5) { return SMPatchVersion_1_5, nil } if serverGitVersion >= string(SMPatchVersion_1_0) { return SMPatchVersion_1_0, nil } return Unknown, fmt.Errorf("The version is too old: %v\n", serverVersion) }
// GetThirdPartyGroupVersions returns the thirdparty "group/versions"s and // resources supported by the server. A user may delete a thirdparty resource // when this function is running, so this function may return a "NotFound" error // due to the race. func GetThirdPartyGroupVersions(discovery discovery.DiscoveryInterface) ([]unversioned.GroupVersion, []unversioned.GroupVersionKind, error) { result := []unversioned.GroupVersion{} gvks := []unversioned.GroupVersionKind{} groupList, err := discovery.ServerGroups() if err != nil { // On forbidden or not found, just return empty lists. if kerrors.IsForbidden(err) || kerrors.IsNotFound(err) { return result, gvks, nil } return nil, nil, err } for ix := range groupList.Groups { group := &groupList.Groups[ix] for jx := range group.Versions { gv, err2 := unversioned.ParseGroupVersion(group.Versions[jx].GroupVersion) if err2 != nil { return nil, nil, err } // Skip GroupVersionKinds that have been statically registered. if registered.IsRegisteredVersion(gv) { continue } result = append(result, gv) resourceList, err := discovery.ServerResourcesForGroupVersion(group.Versions[jx].GroupVersion) if err != nil { return nil, nil, err } for kx := range resourceList.APIResources { gvks = append(gvks, gv.WithKind(resourceList.APIResources[kx].Kind)) } } } return result, gvks, nil }
// TODO: In general, any controller checking this needs to be dynamic so // users don't have to restart their controller manager if they change the apiserver. func getAvailableResources(clientBuilder controller.ControllerClientBuilder) (map[schema.GroupVersionResource]bool, error) { var discoveryClient discovery.DiscoveryInterface // If apiserver is not running we should wait for some time and fail only then. This is particularly // important when we start apiserver and controller manager at the same time. err := wait.PollImmediate(time.Second, 10*time.Second, func() (bool, error) { client, err := clientBuilder.Client("controller-discovery") if err != nil { glog.Errorf("Failed to get api versions from server: %v", err) return false, nil } discoveryClient = client.Discovery() return true, nil }) if err != nil { return nil, fmt.Errorf("failed to get api versions from server: %v", err) } resourceMap, err := discoveryClient.ServerResources() if err != nil { return nil, fmt.Errorf("failed to get supported resources from server: %v", err) } allResources := map[schema.GroupVersionResource]bool{} for _, apiResourceList := range resourceMap { version, err := schema.ParseGroupVersion(apiResourceList.GroupVersion) if err != nil { return nil, err } for _, apiResource := range apiResourceList.APIResources { allResources[version.WithResource(apiResource.Name)] = true } } return allResources, nil }