Add: new routes for daemonsets

Author: Sebastien Coavoux

src/app/backend/handler/apihandler.go

@@ -25,6 +25,7 @@ import (
 	. "github.com/kubernetes/dashboard/client"
 	"github.com/kubernetes/dashboard/resource/common"
 	. "github.com/kubernetes/dashboard/resource/container"
+	"github.com/kubernetes/dashboard/resource/daemonset"
 	"github.com/kubernetes/dashboard/resource/deployment"
 	. "github.com/kubernetes/dashboard/resource/namespace"
 	"github.com/kubernetes/dashboard/resource/pod"
@@ -203,6 +204,23 @@ func CreateHttpApiHandler(client *client.Client, heapsterClient HeapsterClient,
 			To(apiHandler.handleGetDeployments).
 			Writes(deployment.DeploymentList{}))
 	wsContainer.Add(deploymentsWs)
+	daemonSetWs := new(restful.WebService)
+	daemonSetWs.Filter(wsLogger)
+	daemonSetWs.Path("/api/v1/daemonsets").
+		Consumes(restful.MIME_JSON).
+		Produces(restful.MIME_JSON)
+	daemonSetWs.Route(
+		daemonSetWs.GET("").
+			To(apiHandler.handleGetDaemonSetList).
+			Writes(daemonset.DaemonSetList{}))
+	daemonSetWs.Route(
+		daemonSetWs.GET("/{namespace}/{daemonSet}").
+			To(apiHandler.handleGetDaemonSetDetail).
+			Writes(daemonset.DaemonSetDetail{}))
+	daemonSetWs.Route(
+		daemonSetWs.DELETE("/{namespace}/{daemonSet}").
+			To(apiHandler.handleDeleteDaemonSet))
+	wsContainer.Add(daemonSetWs)
 
 	namespacesWs := new(restful.WebService)
 	namespacesWs.Filter(wsLogger)
@@ -660,3 +678,53 @@ func handleInternalError(response *restful.Response, err error) {
 	response.AddHeader("Content-Type", "text/plain")
 	response.WriteErrorString(http.StatusInternalServerError, err.Error()+"\n")
 }
+
+// Handles get Daemon Set list API call.
+func (apiHandler *ApiHandler) handleGetDaemonSetList(
+	request *restful.Request, response *restful.Response) {
+
+	namespace := request.PathParameter("namespace")
+	result, err := daemonset.GetDaemonSetList(apiHandler.client, namespace)
+	if err != nil {
+		handleInternalError(response, err)
+		return
+	}
+
+	response.WriteHeaderAndEntity(http.StatusCreated, result)
+}
+
+// Handles get Daemon Set detail API call.
+func (apiHandler *ApiHandler) handleGetDaemonSetDetail(
+	request *restful.Request, response *restful.Response) {
+
+	namespace := request.PathParameter("namespace")
+	daemonSet := request.PathParameter("daemonSet")
+	result, err := daemonset.GetDaemonSetDetail(apiHandler.client, apiHandler.heapsterClient, namespace, daemonSet)
+	if err != nil {
+		handleInternalError(response, err)
+		return
+	}
+
+	response.WriteHeaderAndEntity(http.StatusCreated, result)
+}
+
+// Handles delete Daemon Set API call.
+func (apiHandler *ApiHandler) handleDeleteDaemonSet(
+	request *restful.Request, response *restful.Response) {
+
+	namespace := request.PathParameter("namespace")
+	daemonSet := request.PathParameter("daemonSet")
+	deleteServices, err := strconv.ParseBool(request.QueryParameter("deleteServices"))
+	if err != nil {
+		handleInternalError(response, err)
+		return
+	}
+
+	if err := daemonset.DeleteDaemonSet(apiHandler.client, namespace,
+		daemonSet, deleteServices); err != nil {
+		handleInternalError(response, err)
+		return
+	}
+
+	response.WriteHeader(http.StatusOK)
+}

src/app/backend/resource/common/pod.go

@@ -16,6 +16,7 @@ package common
 
 import (
 	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/unversioned"
 )
 
 func FilterNamespacedPodsBySelector(pods []api.Pod, namespace string,
@@ -24,7 +25,7 @@ func FilterNamespacedPodsBySelector(pods []api.Pod, namespace string,
 	var matchingPods []api.Pod
 	for _, pod := range pods {
 		if pod.ObjectMeta.Namespace == namespace &&
-			IsLabelSelectorMatching(resourceSelector, pod.Labels) {
+			IsSelectorMatching(resourceSelector, pod.Labels) {
 			matchingPods = append(matchingPods, pod)
 		}
 	}
@@ -37,7 +38,18 @@ func FilterPodsBySelector(pods []api.Pod, resourceSelector map[string]string) []
 
 	var matchingPods []api.Pod
 	for _, pod := range pods {
-		if IsLabelSelectorMatching(resourceSelector, pod.Labels) {
+		if IsSelectorMatching(resourceSelector, pod.Labels) {
+			matchingPods = append(matchingPods, pod)
+		}
+	}
+	return matchingPods
+}
+
+func FilterPodsByLabelSelector(pods []api.Pod, labelSelector *unversioned.LabelSelector) []api.Pod {
+
+	var matchingPods []api.Pod
+	for _, pod := range pods {
+		if IsLabelSelectorMatching(pod.Labels, labelSelector) {
 			matchingPods = append(matchingPods, pod)
 		}
 	}

src/app/backend/resource/common/resourcechannels.go

@@ -43,6 +43,9 @@ type ResourceChannels struct {
 	// List and error channels to Deployments.
 	DeploymentList DeploymentListChannel
 
+	// List and error channels to Daemon Sets.
+	DaemonSetList DaemonSetListChannel
+
 	// List and error channels to Services.
 	ServiceList ServiceListChannel
 
@@ -280,3 +283,28 @@ func GetReplicaSetListChannel(client client.ReplicaSetsNamespacer, numReads int)
 
 	return channel
 }
+
+// List and error channels to Nodes.
+type DaemonSetListChannel struct {
+	List  chan *extensions.DaemonSetList
+	Error chan error
+}
+
+// Returns a pair of channels to a DaemonSet list and errors that both must be read
+// numReads times.
+func GetDaemonSetListChannel(client client.DaemonSetsNamespacer, numReads int) DaemonSetListChannel {
+	channel := DaemonSetListChannel{
+		List:  make(chan *extensions.DaemonSetList, numReads),
+		Error: make(chan error, numReads),
+	}
+
+	go func() {
+		rcs, err := client.DaemonSets(api.NamespaceAll).List(listEverything)
+		for i := 0; i < numReads; i++ {
+			channel.List <- rcs
+			channel.Error <- err
+		}
+	}()
+
+	return channel
+}

src/app/backend/resource/common/types.go

@@ -94,6 +94,7 @@ const (
 	ResourceKindPod                   = "pod"
 	ResourceKindEvent                 = "event"
 	ResourceKindReplicationController = "replicationcontroller"
+	ResourceKindDaemonSet             = "daemonset"
 )
 
 // Mapping from resource kind to K8s apiserver API path. This is mostly pluralization, because
@@ -106,24 +107,40 @@ var kindToAPIPathMapping = map[string]string{
 	ResourceKindReplicationController: "replicationcontrollers",
 	ResourceKindDeployment:            "deployments",
 	ResourceKindReplicaSet:            "replicasets",
+	ResourceKindDaemonSet:             "daemonsets",
 }
 
-// IsLabelSelectorMatching returns true when an object with the given
+// IsSelectorMatching returns true when an object with the given
 // selector targets the same Resources (or subset) that
 // the tested object with the given selector.
-func IsLabelSelectorMatching(labelSelector map[string]string,
+func IsSelectorMatching(labelSelector map[string]string,
 	testedObjectLabels map[string]string) bool {
 
-	// If there are no label selectors, then assume it targets different Resource.
+	// If service has no selectors, then assume it targets different Resource.
 	if len(labelSelector) == 0 {
 		return false
 	}
-
 	for label, value := range labelSelector {
 		if rsValue, ok := testedObjectLabels[label]; !ok || rsValue != value {
 			return false
 		}
 	}
+	return true
+}
 
+// Returns true when a resrouce (Service / Pod) with the given selector targets
+// the same Pod (or itself) that a Daemon Set with the given selector.
+func IsLabelSelectorMatching(selector map[string]string,
+	labelSelector *unversioned.LabelSelector) bool {
+
+	// If the resrouce has no selectors, then assume it targets different Pods.
+	if len(selector) == 0 {
+		return false
+	}
+	for label, value := range selector {
+		if rsValue, ok := labelSelector.MatchLabels[label]; !ok || rsValue != value {
+			return false
+		}
+	}
 	return true
 }

src/app/backend/resource/daemonset/daemonsetcommon.go

@@ -0,0 +1,119 @@
+// Copyright 2015 Google Inc. All Rights Reserved.
+//
+// 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 daemonset
+
+import (
+	"github.com/kubernetes/dashboard/resource/common"
+	//	"github.com/kubernetes/dashboard/resource/event"
+	"k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/unversioned"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	client "k8s.io/kubernetes/pkg/client/unversioned"
+	"k8s.io/kubernetes/pkg/fields"
+	"k8s.io/kubernetes/pkg/labels"
+)
+
+type DaemonSetWithPods struct {
+	DaemonSet *extensions.DaemonSet
+	Pods      *api.PodList
+}
+
+// Returns structure containing DaemonSet and Pods for the given daemon set.
+func getRawDaemonSetWithPods(client client.Interface, namespace, name string) (
+	*DaemonSetWithPods, error) {
+	daemonSet, err := client.Extensions().DaemonSets(namespace).Get(name)
+	if err != nil {
+		return nil, err
+	}
+
+	labelSelector, err := unversioned.LabelSelectorAsSelector(daemonSet.Spec.Selector)
+	if err != nil {
+		return nil, err
+	}
+
+	pods, err := client.Pods(namespace).List(
+		api.ListOptions{
+			LabelSelector: labelSelector,
+			FieldSelector: fields.Everything(),
+		})
+
+	if err != nil {
+		return nil, err
+	}
+
+	daemonSetAndPods := &DaemonSetWithPods{
+		DaemonSet: daemonSet,
+		Pods:      pods,
+	}
+	return daemonSetAndPods, nil
+}
+
+// Retrieves Pod list that belongs to a Daemon Set.
+func getRawDaemonSetPods(client client.Interface, namespace, name string) (*api.PodList, error) {
+	daemonSetAndPods, err := getRawDaemonSetWithPods(client, namespace, name)
+	if err != nil {
+		return nil, err
+	}
+	return daemonSetAndPods.Pods, nil
+}
+
+// Returns aggregate information about daemon set pods.
+func getDaemonSetPodInfo(daemonSet *extensions.DaemonSet, pods []api.Pod) common.PodInfo {
+	result := common.PodInfo{}
+	for _, pod := range pods {
+		switch pod.Status.Phase {
+		case api.PodRunning:
+			result.Running++
+		case api.PodPending:
+			result.Pending++
+		case api.PodFailed:
+			result.Failed++
+		}
+	}
+
+	return result
+}
+
+// Based on given selector returns list of services that are candidates for deletion.
+// Services are matched by daemon sets' label selector. They are deleted if given
+// label selector is targeting only 1 daemon set.
+func getServicesForDSDeletion(client client.Interface, labelSelector labels.Selector,
+	namespace string) ([]api.Service, error) {
+
+	daemonSet, err := client.Extensions().DaemonSets(namespace).List(api.ListOptions{
+		LabelSelector: labelSelector,
+		FieldSelector: fields.Everything(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// if label selector is targeting only 1 daemon set
+	// then we can delete services targeted by this label selector,
+	// otherwise we can not delete any services so just return empty list
+	if len(daemonSet.Items) != 1 {
+		return []api.Service{}, nil
+	}
+
+	services, err := client.Services(namespace).List(api.ListOptions{
+		LabelSelector: labelSelector,
+		FieldSelector: fields.Everything(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return services.Items, nil
+}