// WatchControllers begins watching for new, changed, or deleted controllers. func (r *Registry) WatchControllers(ctx api.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) { if !field.Empty() { return nil, fmt.Errorf("field selectors are not supported on replication controllers") } version, err := tools.ParseWatchResourceVersion(resourceVersion, "replicationControllers") if err != nil { return nil, err } key := makeControllerListKey(ctx) return r.WatchList(key, version, func(obj runtime.Object) bool { controller, ok := obj.(*api.ReplicationController) if !ok { // Must be an error: return true to propagate to upper level. return true } match := label.Matches(labels.Set(controller.Labels)) if match { pods, err := r.pods.ListPods(ctx, labels.Set(controller.Spec.Selector).AsSelector()) if err != nil { glog.Warningf("Error listing pods: %v", err) // No object that's useable so drop it on the floor return false } if pods == nil { glog.Warningf("Pods list is nil. This should never happen...") // No object that's useable so drop it on the floor return false } controller.Status.Replicas = len(pods.Items) } return match }) }
// Matchtoken returns a generic matcher for a given label and field selector. func Matcher(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { clientObj, ok := obj.(*api.OAuthClientAuthorization) if !ok { return false, fmt.Errorf("not a client authorization") } fields := SelectableFields(clientObj) return label.Matches(labels.Set(clientObj.Labels)) && field.Matches(fields), nil }) }
// Matchtoken returns a generic matcher for a given label and field selector. func Matcher(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { tokenObj, ok := obj.(*api.OAuthAccessToken) if !ok { return false, fmt.Errorf("not a token") } fields := SelectableFields(tokenObj) return label.Matches(labels.Set(tokenObj.Labels)) && field.Matches(fields), nil }) }
// MatchIdentity returns a generic matcher for a given label and field selector. func MatchIdentity(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { identityObj, ok := obj.(*api.Identity) if !ok { return false, fmt.Errorf("not an identity") } fields := IdentityToSelectableFields(identityObj) return label.Matches(labels.Set(identityObj.Labels)) && field.Matches(fields), nil }) }
// MatchPersistentVolumeClaim returns a generic matcher for a given label and field selector. func MatchPersistentVolumeClaim(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { persistentvolumeclaimObj, ok := obj.(*api.PersistentVolumeClaim) if !ok { return false, fmt.Errorf("not a persistentvolumeclaim") } fields := PersistentVolumeClaimToSelectableFields(persistentvolumeclaimObj) return label.Matches(labels.Set(persistentvolumeclaimObj.Labels)) && field.Matches(fields), nil }) }
// Matcher returns a generic matcher for a given label and field selector. func Matcher(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { sa, ok := obj.(*api.ServiceAccount) if !ok { return false, fmt.Errorf("not a serviceaccount") } fields := SelectableFields(sa) return label.Matches(labels.Set(sa.Labels)) && field.Matches(fields), nil }) }
// MatchImageStream returns a generic matcher for a given label and field selector. func MatchImageStream(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { ir, ok := obj.(*api.ImageStream) if !ok { return false, fmt.Errorf("not an ImageStream") } fields := ImageStreamToSelectableFields(ir) return label.Matches(labels.Set(ir.Labels)) && field.Matches(fields), nil }) }
// MatchResourceQuota returns a generic matcher for a given label and field selector. func MatchResourceQuota(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { resourcequotaObj, ok := obj.(*api.ResourceQuota) if !ok { return false, fmt.Errorf("not a resourcequota") } fields := ResourceQuotaToSelectableFields(resourcequotaObj) return label.Matches(labels.Set(resourcequotaObj.Labels)) && field.Matches(fields), nil }) }
// MatchNamespace returns a generic matcher for a given label and field selector. func MatchNamespace(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { namespaceObj, ok := obj.(*api.Namespace) if !ok { return false, fmt.Errorf("not a namespace") } fields := NamespaceToSelectableFields(namespaceObj) return label.Matches(labels.Set(namespaceObj.Labels)) && field.Matches(fields), nil }) }
// MatchPod returns a generic matcher for a given label and field selector. func MatchPod(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { podObj, ok := obj.(*api.Pod) if !ok { return false, fmt.Errorf("not a pod") } fields := PodToSelectableFields(podObj) return label.Matches(labels.Set(podObj.Labels)) && field.Matches(fields), nil }) }
// List obtains a list of ReplicationControllers that match selector. func (s *storage) ListControllers(ctx api.Context, label labels.Selector, field fields.Selector) (*api.ReplicationControllerList, error) { if !field.Empty() { return nil, fmt.Errorf("field selector not supported yet") } obj, err := s.List(ctx, label, field) if err != nil { return nil, err } return obj.(*api.ReplicationControllerList), err }
// Matcher returns a generic matcher for a given label and field selector. func Matcher(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { scc, ok := obj.(*api.SecurityContextConstraints) if !ok { return false, fmt.Errorf("not a securitycontextconstraint") } fields := SelectableFields(scc) return label.Matches(labels.Set(scc.Labels)) && field.Matches(fields), nil }) }
// MatchUser returns a generic matcher for a given label and field selector. func MatchUser(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { userObj, ok := obj.(*api.User) if !ok { return false, fmt.Errorf("not a user") } fields := UserToSelectableFields(userObj) return label.Matches(labels.Set(userObj.Labels)) && field.Matches(fields), nil }) }
// MatchGroup returns a generic matcher for a given label and field selector. func MatchGroup(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(func(obj runtime.Object) (bool, error) { groupObj, ok := obj.(*api.Group) if !ok { return false, fmt.Errorf("not a group") } fields := GroupToSelectableFields(groupObj) return label.Matches(labels.Set(groupObj.Labels)) && field.Matches(fields), nil }) }
func (c *readOnlyClusterPolicyCache) List(label labels.Selector, field fields.Selector) (*authorizationapi.ClusterPolicyList, error) { clusterPolicyList := &authorizationapi.ClusterPolicyList{} returnedList := c.indexer.List() for i := range returnedList { clusterPolicy, castOK := returnedList[i].(*authorizationapi.ClusterPolicy) if !castOK { return clusterPolicyList, errors.NewInvalid("ClusterPolicy", "clusterPolicy", []error{}) } if label.Matches(labels.Set(clusterPolicy.Labels)) && field.Matches(ClusterPolicyToSelectableFields(clusterPolicy)) { clusterPolicyList.Items = append(clusterPolicyList.Items, *clusterPolicy) } } return clusterPolicyList, nil }
// FieldsSelectorParam adds the given selector as a query parameter with the name paramName. func (r *Request) FieldsSelectorParam(s fields.Selector) *Request { if r.err != nil { return r } if s.Empty() { return r } s2, err := s.Transform(func(field, value string) (newField, newValue string, err error) { return fieldMappings.filterField(r.apiVersion, r.resource, field, value) }) if err != nil { r.err = err return r } return r.setParam(api.FieldSelectorQueryParam(r.apiVersion), s2.String()) }
// List obtains a list of ReplicationControllers that match selector. func (rs *REST) List(ctx api.Context, label labels.Selector, field fields.Selector) (runtime.Object, error) { if !field.Empty() { return nil, fmt.Errorf("field selector not supported yet") } controllers, err := rs.registry.ListControllers(ctx) if err != nil { return nil, err } filtered := []api.ReplicationController{} for _, controller := range controllers.Items { if label.Matches(labels.Set(controller.Labels)) { filtered = append(filtered, controller) } } controllers.Items = filtered return controllers, err }
// WatchBuildConfigs begins watching for new, changed, or deleted BuildConfigs. func (r *Etcd) WatchBuildConfigs(ctx kapi.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) { version, err := tools.ParseWatchResourceVersion(resourceVersion, "buildConfig") if err != nil { return nil, err } return r.WatchList(makeBuildConfigListKey(ctx), version, func(obj runtime.Object) bool { buildConfig, ok := obj.(*api.BuildConfig) if !ok { glog.Errorf("Unexpected object during %s/%s BuildConfig watch: %#v", buildConfig.Namespace, buildConfig.Name, obj) return false } fields := labels.Set{ "metadata.name": buildConfig.Name, } return label.Matches(labels.Set(buildConfig.Labels)) && field.Matches(fields) }) }
// WatchEndpoints begins watching for new, changed, or deleted endpoint configurations. func (r *Registry) WatchEndpoints(ctx api.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) { version, err := tools.ParseWatchResourceVersion(resourceVersion, "endpoints") if err != nil { return nil, err } if !label.Empty() { return nil, fmt.Errorf("label selectors are not supported on endpoints") } if value, found := field.RequiresExactMatch("name"); found { key, err := makeServiceEndpointsKey(ctx, value) if err != nil { return nil, err } return r.Watch(key, version), nil } if field.Empty() { return r.WatchList(makeServiceEndpointsListKey(ctx), version, tools.Everything) } return nil, fmt.Errorf("only the 'ID' and default (everything) field selectors are supported") }
// WatchBuilds begins watching for new, changed, or deleted Builds. func (r *Etcd) WatchBuilds(ctx kapi.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) { version, err := tools.ParseWatchResourceVersion(resourceVersion, "build") if err != nil { return nil, err } return r.WatchList(makeBuildListKey(ctx), version, func(obj runtime.Object) bool { build, ok := obj.(*api.Build) setDuration(build) if !ok { glog.Errorf("Unexpected object during build watch: %#v", obj) return false } fields := labels.Set{ "metadata.name": build.Name, "status": string(build.Status), "podName": buildutil.GetBuildPodName(build), } return label.Matches(labels.Set(build.Labels)) && field.Matches(fields) }) }
// WatchServices begins watching for new, changed, or deleted service configurations. func (r *Registry) WatchServices(ctx api.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) { version, err := storage.ParseWatchResourceVersion(resourceVersion, "service") if err != nil { return nil, err } if !label.Empty() { return nil, fmt.Errorf("label selectors are not supported on services") } if value, found := field.RequiresExactMatch("name"); found { key, err := makeServiceKey(ctx, value) if err != nil { return nil, err } // TODO: use generic.SelectionPredicate return r.Watch(key, version, storage.Everything) } if field.Empty() { return r.WatchList(makeServiceListKey(ctx), version, storage.Everything) } return nil, fmt.Errorf("only the 'name' and default (everything) field selectors are supported") }
func (c *readOnlyPolicyBindingCache) List(label labels.Selector, field fields.Selector, namespace string) (*authorizationapi.PolicyBindingList, error) { var returnedList []interface{} if namespace == kapi.NamespaceAll { returnedList = c.indexer.List() } else { items, err := c.indexer.Index("namespace", &authorizationapi.PolicyBinding{ObjectMeta: kapi.ObjectMeta{Namespace: namespace}}) returnedList = items if err != nil { return &authorizationapi.PolicyBindingList{}, errors.NewInvalid("PolicyBindingList", "policyBindingList", []error{err}) } } policyBindingList := &authorizationapi.PolicyBindingList{} for i := range returnedList { policyBinding, castOK := returnedList[i].(*authorizationapi.PolicyBinding) if !castOK { return policyBindingList, errors.NewInvalid("PolicyBindingList", "policyBindingList", []error{}) } if label.Matches(labels.Set(policyBinding.Labels)) && field.Matches(PolicyBindingToSelectableFields(policyBinding)) { policyBindingList.Items = append(policyBindingList.Items, *policyBinding) } } return policyBindingList, nil }
// WatchRoutes begins watching for new, changed, or deleted route configurations. func (registry *Etcd) WatchRoutes(ctx kapi.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) { if !label.Empty() { return nil, fmt.Errorf("label selectors are not supported on routes yet") } version, err := storage.ParseWatchResourceVersion(resourceVersion, "pod") if err != nil { return nil, err } if value, found := field.RequiresExactMatch("ID"); found { key, err := makeRouteKey(ctx, value) if err != nil { return nil, err } return registry.Watch(key, version, storage.Everything) } if field.Empty() { key := kubeetcd.MakeEtcdListKey(ctx, RoutePath) return registry.WatchList(key, version, storage.Everything) } return nil, fmt.Errorf("only the 'ID' and default (everything) field selectors are supported") }
// Watch begins watching for new, changed, or deleted images. func (r *REST) Watch(ctx kapi.Context, label labels.Selector, field fields.Selector, resourceVersion string) (watch.Interface, error) { if !field.Empty() { return nil, errors.New("field selectors are not supported on images") } return r.store.WatchPredicate(ctx, image.MatchImage(label, field), resourceVersion) }
// List satisfies the RESTStorage interface. func (rs *REST) List(ctx api.Context, label labels.Selector, field fields.Selector) (runtime.Object, error) { if !label.Empty() || !field.Empty() { return nil, errors.NewBadRequest("label/field selectors are not supported on endpoints") } return rs.registry.ListEndpoints(ctx) }