Implement DisruptionController.

cmd/kube-controller-manager/app/controllermanager.go

@@ -49,6 +49,7 @@ import (
 	certcontroller "k8s.io/kubernetes/pkg/controller/certificates"
 	"k8s.io/kubernetes/pkg/controller/daemon"
 	"k8s.io/kubernetes/pkg/controller/deployment"
+	"k8s.io/kubernetes/pkg/controller/disruption"
 	endpointcontroller "k8s.io/kubernetes/pkg/controller/endpoint"
 	"k8s.io/kubernetes/pkg/controller/framework/informers"
 	"k8s.io/kubernetes/pkg/controller/garbagecollector"
@@ -367,6 +368,18 @@ func StartControllers(s *options.CMServer, kubeClient *client.Client, kubeconfig
 		}
 	}
 
+	groupVersion = "policy/v1alpha1"
+	resources, found = resourceMap[groupVersion]
+	glog.Infof("Attempting to start disruption controller, full resource map %+v", resourceMap)
+	if containsVersion(versions, groupVersion) && found {
+		glog.Infof("Starting %s apis", groupVersion)
+		if containsResource(resources, "poddisruptionbudgets") {
+			glog.Infof("Starting disruption controller")
+			go disruption.NewDisruptionController(sharedInformers.Pods().Informer(), kubeClient).Run(wait.NeverStop)
+			time.Sleep(wait.Jitter(s.ControllerStartInterval.Duration, ControllerStartJitter))
+		}
+	}
+
 	groupVersion = "apps/v1alpha1"
 	resources, found = resourceMap[groupVersion]
 	glog.Infof("Attempting to start petset, full resource map %+v", resourceMap)

pkg/client/cache/listers.go

@@ -26,6 +26,7 @@ import (
 	"k8s.io/kubernetes/pkg/apis/batch"
 	"k8s.io/kubernetes/pkg/apis/certificates"
 	"k8s.io/kubernetes/pkg/apis/extensions"
+	"k8s.io/kubernetes/pkg/apis/policy"
 	"k8s.io/kubernetes/pkg/labels"
 )
 
@@ -710,3 +711,44 @@ func (i *IndexerToNamespaceLister) List(selector labels.Selector) (namespaces []
 
 	return namespaces, nil
 }
+
+type StoreToPodDisruptionBudgetLister struct {
+	Store
+}
+
+// GetPodPodDisruptionBudgets returns a list of PodDisruptionBudgets matching a pod.  Returns an error only if no matching PodDisruptionBudgets are found.
+func (s *StoreToPodDisruptionBudgetLister) GetPodPodDisruptionBudgets(pod *api.Pod) (pdbList []policy.PodDisruptionBudget, err error) {
+	var selector labels.Selector
+
+	if len(pod.Labels) == 0 {
+		err = fmt.Errorf("no PodDisruptionBudgets found for pod %v because it has no labels", pod.Name)
+		return
+	}
+
+	for _, m := range s.Store.List() {
+		pdb, ok := m.(*policy.PodDisruptionBudget)
+		if !ok {
+			glog.Errorf("Unexpected: %v is not a PodDisruptionBudget", m)
+			continue
+		}
+		if pdb.Namespace != pod.Namespace {
+			continue
+		}
+		selector, err = unversioned.LabelSelectorAsSelector(pdb.Spec.Selector)
+		if err != nil {
+			glog.Warningf("invalid selector: %v", err)
+			// TODO(mml): add an event to the PDB
+			continue
+		}
+
+		// If a PDB with a nil or empty selector creeps in, it should match nothing, not everything.
+		if selector.Empty() || !selector.Matches(labels.Set(pod.Labels)) {
+			continue
+		}
+		pdbList = append(pdbList, *pdb)
+	}
+	if len(pdbList) == 0 {
+		err = fmt.Errorf("could not find PodDisruptionBudget for pod %s in namespace %s with labels: %v", pod.Name, pod.Namespace, pod.Labels)
+	}
+	return
+}

pkg/client/unversioned/client.go

@@ -183,6 +183,10 @@ func (c *Client) Rbac() RbacInterface {
 	return c.RbacClient
 }
 
+func (c *Client) Policy() PolicyInterface {
+	return c.PolicyClient
+}
+
 func (c *Client) Discovery() discovery.DiscoveryInterface {
 	return c.DiscoveryClient
 }

test/e2e/disruption.go

+/*
+Copyright 2016 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package e2e
+
+import (
+	"fmt"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apis/policy"
+	client "k8s.io/kubernetes/pkg/client/unversioned"
+	"k8s.io/kubernetes/pkg/util/intstr"
+	"k8s.io/kubernetes/pkg/util/wait"
+	"k8s.io/kubernetes/test/e2e/framework"
+)
+
+var _ = framework.KubeDescribe("DisruptionController [Feature:PodDisruptionbudget]", func() {
+	f := framework.NewDefaultFramework("disruption")
+	var ns string
+	var c *client.Client
+
+	BeforeEach(func() {
+		c = f.Client
+		ns = f.Namespace.Name
+	})
+
+	It("should create a PodDisruptionBudget", func() {
+		pdb := policy.PodDisruptionBudget{
+			ObjectMeta: api.ObjectMeta{
+				Name:      "foo",
+				Namespace: ns,
+			},
+			Spec: policy.PodDisruptionBudgetSpec{
+				Selector:     &unversioned.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+				MinAvailable: intstr.FromString("1%"),
+			},
+		}
+		_, err := c.Policy().PodDisruptionBudgets(ns).Create(&pdb)
+		Expect(err).NotTo(HaveOccurred())
+	})
+
+	It("should update PodDisruptionBudget status", func() {
+		pdb := policy.PodDisruptionBudget{
+			ObjectMeta: api.ObjectMeta{
+				Name:      "foo",
+				Namespace: ns,
+			},
+			Spec: policy.PodDisruptionBudgetSpec{
+				Selector:     &unversioned.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}},
+				MinAvailable: intstr.FromInt(2),
+			},
+		}
+		_, err := c.Policy().PodDisruptionBudgets(ns).Create(&pdb)
+		Expect(err).NotTo(HaveOccurred())
+		for i := 0; i < 2; i++ {
+			pod := &api.Pod{
+				ObjectMeta: api.ObjectMeta{
+					Name:      fmt.Sprintf("pod-%d", i),
+					Namespace: ns,
+					Labels:    map[string]string{"foo": "bar"},
+				},
+				Spec: api.PodSpec{
+					Containers: []api.Container{
+						{
+							Name:  "busybox",
+							Image: "gcr.io/google_containers/echoserver:1.4",
+						},
+					},
+					RestartPolicy: api.RestartPolicyAlways,
+				},
+			}
+
+			_, err := c.Pods(ns).Create(pod)
+			framework.ExpectNoError(err, "Creating pod %q in namespace %q", pod.Name, ns)
+		}
+		err = wait.PollImmediate(framework.Poll, 60*time.Second, func() (bool, error) {
+			pdb, err := c.Policy().PodDisruptionBudgets(ns).Get("foo")
+			if err != nil {
+				return false, err
+			}
+			return pdb.Status.PodDisruptionAllowed, nil
+		})
+		Expect(err).NotTo(HaveOccurred())
+
+	})
+
+})