// GetDeploymentsForReplicaSet returns a list of deployments managing a replica set. Returns an error only if no matching deployments are found. func (s *StoreToDeploymentLister) GetDeploymentsForReplicaSet(rs *extensions.ReplicaSet) (deployments []extensions.Deployment, err error) { if len(rs.Labels) == 0 { err = fmt.Errorf("no deployments found for ReplicaSet %v because it has no labels", rs.Name) return } // TODO: MODIFY THIS METHOD so that it checks for the podTemplateSpecHash label dList, err := s.Deployments(rs.Namespace).List(labels.Everything()) if err != nil { return } for _, d := range dList { selector, err := unversioned.LabelSelectorAsSelector(d.Spec.Selector) if err != nil { return nil, fmt.Errorf("invalid label selector: %v", err) } // If a deployment with a nil or empty selector creeps in, it should match nothing, not everything. if selector.Empty() || !selector.Matches(labels.Set(rs.Labels)) { continue } deployments = append(deployments, d) } if len(deployments) == 0 { err = fmt.Errorf("could not find deployments set for ReplicaSet %s in namespace %s with labels: %v", rs.Name, rs.Namespace, rs.Labels) } return }
// GetDeploymentsForPods returns a list of deployments managing a pod. Returns an error only if no matching deployments are found. func (s *StoreToDeploymentLister) GetDeploymentsForPod(pod *api.Pod) (deployments []extensions.Deployment, err error) { if len(pod.Labels) == 0 { err = fmt.Errorf("no deployments found for Pod %v because it has no labels", pod.Name) return } if len(pod.Labels[extensions.DefaultDeploymentUniqueLabelKey]) == 0 { return } dList, err := s.Deployments(pod.Namespace).List(labels.Everything()) if err != nil { return } for _, d := range dList { selector, err := unversioned.LabelSelectorAsSelector(d.Spec.Selector) if err != nil { return nil, fmt.Errorf("invalid label selector: %v", err) } // If a deployment with a nil or empty selector creeps in, it should match nothing, not everything. if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) { continue } deployments = append(deployments, d) } if len(deployments) == 0 { err = fmt.Errorf("could not find deployments set for Pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels) } return }
func addDefaultingFuncs(scheme *runtime.Scheme) error { return scheme.AddDefaultingFuncs( func(obj *ListOptions) { if obj.LabelSelector == nil { obj.LabelSelector = labels.Everything() } if obj.FieldSelector == nil { obj.FieldSelector = fields.Everything() } }, ) }
func NewRootListAction(resource unversioned.GroupVersionResource, opts api.ListOptions) ListActionImpl { action := ListActionImpl{} action.Verb = "list" action.Resource = resource labelSelector := opts.LabelSelector if labelSelector == nil { labelSelector = labels.Everything() } fieldSelector := opts.FieldSelector if fieldSelector == nil { fieldSelector = fields.Everything() } action.ListRestrictions = ListRestrictions{labelSelector, fieldSelector} return action }
func NewRootWatchAction(resource unversioned.GroupVersionResource, opts api.ListOptions) WatchActionImpl { action := WatchActionImpl{} action.Verb = "watch" action.Resource = resource labelSelector := opts.LabelSelector if labelSelector == nil { labelSelector = labels.Everything() } fieldSelector := opts.FieldSelector if fieldSelector == nil { fieldSelector = fields.Everything() } action.WatchRestrictions = WatchRestrictions{labelSelector, fieldSelector, opts.ResourceVersion} return action }
func NewDeleteCollectionAction(resource unversioned.GroupVersionResource, namespace string, opts api.ListOptions) DeleteCollectionActionImpl { action := DeleteCollectionActionImpl{} action.Verb = "delete-collection" action.Resource = resource action.Namespace = namespace labelSelector := opts.LabelSelector if labelSelector == nil { labelSelector = labels.Everything() } fieldSelector := opts.FieldSelector if fieldSelector == nil { fieldSelector = fields.Everything() } action.ListRestrictions = ListRestrictions{labelSelector, fieldSelector} return action }
func (c *FakePodSecurityPolicies) List(opts api.ListOptions) (result *v1beta1.PodSecurityPolicyList, err error) { obj, err := c.Fake. Invokes(testing.NewRootListAction(podsecuritypoliciesResource, opts), &v1beta1.PodSecurityPolicyList{}) if obj == nil { return nil, err } label := opts.LabelSelector if label == nil { label = labels.Everything() } list := &v1beta1.PodSecurityPolicyList{} for _, item := range obj.(*v1beta1.PodSecurityPolicyList).Items { if label.Matches(labels.Set(item.Labels)) { list.Items = append(list.Items, item) } } return list, err }
func (c *FakeComponentStatuses) List(opts api.ListOptions) (result *v1.ComponentStatusList, err error) { obj, err := c.Fake. Invokes(testing.NewRootListAction(componentstatusesResource, opts), &v1.ComponentStatusList{}) if obj == nil { return nil, err } label := opts.LabelSelector if label == nil { label = labels.Everything() } list := &v1.ComponentStatusList{} for _, item := range obj.(*v1.ComponentStatusList).Items { if label.Matches(labels.Set(item.Labels)) { list.Items = append(list.Items, item) } } return list, err }
func (c *FakeCertificateSigningRequests) List(opts api.ListOptions) (result *v1alpha1.CertificateSigningRequestList, err error) { obj, err := c.Fake. Invokes(testing.NewRootListAction(certificatesigningrequestsResource, opts), &v1alpha1.CertificateSigningRequestList{}) if obj == nil { return nil, err } label := opts.LabelSelector if label == nil { label = labels.Everything() } list := &v1alpha1.CertificateSigningRequestList{} for _, item := range obj.(*v1alpha1.CertificateSigningRequestList).Items { if label.Matches(labels.Set(item.Labels)) { list.Items = append(list.Items, item) } } return list, err }
func (c *FakeReplicationControllers) List(opts api.ListOptions) (result *v1.ReplicationControllerList, err error) { obj, err := c.Fake. Invokes(testing.NewListAction(replicationcontrollersResource, c.ns, opts), &v1.ReplicationControllerList{}) if obj == nil { return nil, err } label := opts.LabelSelector if label == nil { label = labels.Everything() } list := &v1.ReplicationControllerList{} for _, item := range obj.(*v1.ReplicationControllerList).Items { if label.Matches(labels.Set(item.Labels)) { list.Items = append(list.Items, item) } } return list, err }
func (c *FakePodDisruptionBudgets) List(opts api.ListOptions) (result *v1alpha1.PodDisruptionBudgetList, err error) { obj, err := c.Fake. Invokes(testing.NewListAction(poddisruptionbudgetsResource, c.ns, opts), &v1alpha1.PodDisruptionBudgetList{}) if obj == nil { return nil, err } label := opts.LabelSelector if label == nil { label = labels.Everything() } list := &v1alpha1.PodDisruptionBudgetList{} for _, item := range obj.(*v1alpha1.PodDisruptionBudgetList).Items { if label.Matches(labels.Set(item.Labels)) { list.Items = append(list.Items, item) } } return list, err }
// TODO: Move this back to scheduler as a helper function that takes a Store, // rather than a method of StoreToServiceLister. func (s *StoreToServiceLister) GetPodServices(pod *api.Pod) (services []*api.Service, err error) { allServices, err := s.Services(pod.Namespace).List(labels.Everything()) if err != nil { return nil, err } for i := range allServices { service := allServices[i] if service.Spec.Selector == nil { // services with nil selectors match nothing, not everything. continue } selector := labels.Set(service.Spec.Selector).AsSelectorPreValidated() if selector.Matches(labels.Set(pod.Labels)) { services = append(services, service) } } return services, nil }
// LabelSelectorAsSelector converts the LabelSelector api type into a struct that implements // labels.Selector // Note: This function should be kept in sync with the selector methods in pkg/labels/selector.go func LabelSelectorAsSelector(ps *LabelSelector) (labels.Selector, error) { if ps == nil { return labels.Nothing(), nil } if len(ps.MatchLabels)+len(ps.MatchExpressions) == 0 { return labels.Everything(), nil } selector := labels.NewSelector() for k, v := range ps.MatchLabels { r, err := labels.NewRequirement(k, selection.Equals, sets.NewString(v)) if err != nil { return nil, err } selector = selector.Add(*r) } for _, expr := range ps.MatchExpressions { var op selection.Operator switch expr.Operator { case LabelSelectorOpIn: op = selection.In case LabelSelectorOpNotIn: op = selection.NotIn case LabelSelectorOpExists: op = selection.Exists case LabelSelectorOpDoesNotExist: op = selection.DoesNotExist default: return nil, fmt.Errorf("%q is not a valid pod selector operator", expr.Operator) } r, err := labels.NewRequirement(expr.Key, op, sets.NewString(expr.Values...)) if err != nil { return nil, err } selector = selector.Add(*r) } return selector, nil }
func TestStoreToReplicationControllerLister(t *testing.T) { testCases := []struct { description string inRCs []*api.ReplicationController list func(StoreToReplicationControllerLister) ([]*api.ReplicationController, error) outRCNames sets.String expectErr bool onlyIfIndexedByNamespace bool }{ { description: "Verify we can search all namespaces", inRCs: []*api.ReplicationController{ { ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "bar"}, }, { ObjectMeta: api.ObjectMeta{Name: "hmm", Namespace: "hmm"}, }, }, list: func(lister StoreToReplicationControllerLister) ([]*api.ReplicationController, error) { return lister.ReplicationControllers(api.NamespaceAll).List(labels.Set{}.AsSelectorPreValidated()) }, outRCNames: sets.NewString("hmm", "foo"), }, { description: "Verify we can search a specific namespace", inRCs: []*api.ReplicationController{ { ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "bar"}, }, { ObjectMeta: api.ObjectMeta{Name: "hmm", Namespace: "hmm"}, }, }, list: func(lister StoreToReplicationControllerLister) ([]*api.ReplicationController, error) { return lister.ReplicationControllers("hmm").List(labels.Set{}.AsSelectorPreValidated()) }, outRCNames: sets.NewString("hmm"), }, { description: "Basic listing with all labels and no selectors", inRCs: []*api.ReplicationController{ {ObjectMeta: api.ObjectMeta{Name: "basic"}}, }, list: func(lister StoreToReplicationControllerLister) ([]*api.ReplicationController, error) { return lister.List(labels.Everything()) }, outRCNames: sets.NewString("basic"), }, { description: "No pod labels", inRCs: []*api.ReplicationController{ { ObjectMeta: api.ObjectMeta{Name: "basic", Namespace: "ns"}, Spec: api.ReplicationControllerSpec{ Selector: map[string]string{"foo": "baz"}, }, }, }, list: func(lister StoreToReplicationControllerLister) ([]*api.ReplicationController, error) { pod := &api.Pod{ ObjectMeta: api.ObjectMeta{Name: "pod1", Namespace: "ns"}, } return lister.GetPodControllers(pod) }, outRCNames: sets.NewString(), expectErr: true, }, { description: "No RC selectors", inRCs: []*api.ReplicationController{ { ObjectMeta: api.ObjectMeta{Name: "basic", Namespace: "ns"}, }, }, list: func(lister StoreToReplicationControllerLister) ([]*api.ReplicationController, error) { pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod1", Namespace: "ns", Labels: map[string]string{"foo": "bar"}, }, } return lister.GetPodControllers(pod) }, outRCNames: sets.NewString(), expectErr: true, }, { description: "Matching labels to selectors and namespace", inRCs: []*api.ReplicationController{ { ObjectMeta: api.ObjectMeta{Name: "foo"}, Spec: api.ReplicationControllerSpec{ Selector: map[string]string{"foo": "bar"}, }, }, { ObjectMeta: api.ObjectMeta{Name: "bar", Namespace: "ns"}, Spec: api.ReplicationControllerSpec{ Selector: map[string]string{"foo": "bar"}, }, }, }, list: func(lister StoreToReplicationControllerLister) ([]*api.ReplicationController, error) { pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ Name: "pod1", Labels: map[string]string{"foo": "bar"}, Namespace: "ns", }, } return lister.GetPodControllers(pod) }, outRCNames: sets.NewString("bar"), onlyIfIndexedByNamespace: true, }, } for _, c := range testCases { for _, withIndex := range []bool{true, false} { if c.onlyIfIndexedByNamespace && !withIndex { continue } var store Indexer if withIndex { store = NewIndexer(MetaNamespaceKeyFunc, Indexers{NamespaceIndex: MetaNamespaceIndexFunc}) } else { store = NewIndexer(MetaNamespaceKeyFunc, Indexers{}) } for _, r := range c.inRCs { store.Add(r) } gotControllers, err := c.list(StoreToReplicationControllerLister{store}) if err != nil && c.expectErr { continue } else if c.expectErr { t.Errorf("(%q, withIndex=%v) Expected error, got none", c.description, withIndex) continue } else if err != nil { t.Errorf("(%q, withIndex=%v) Unexpected error %#v", c.description, withIndex, err) continue } gotNames := make([]string, len(gotControllers)) for ix := range gotControllers { gotNames[ix] = gotControllers[ix].Name } if !c.outRCNames.HasAll(gotNames...) || len(gotNames) != len(c.outRCNames) { t.Errorf("(%q, withIndex=%v) Unexpected got controllers %+v expected %+v", c.description, withIndex, gotNames, c.outRCNames) } } } }