Implement persistent volume backend (#1091)

Author: batikanu

src/app/backend/handler/apihandler.go

@@ -34,6 +34,7 @@ import (
 	"github.com/kubernetes/dashboard/src/app/backend/resource/node"
 	"github.com/kubernetes/dashboard/src/app/backend/resource/petset"
 	"github.com/kubernetes/dashboard/src/app/backend/resource/pod"
+	"github.com/kubernetes/dashboard/src/app/backend/resource/persistentvolume"
 	"github.com/kubernetes/dashboard/src/app/backend/resource/replicaset"
 	"github.com/kubernetes/dashboard/src/app/backend/resource/replicationcontroller"
 	"github.com/kubernetes/dashboard/src/app/backend/resource/secret"
@@ -366,6 +367,15 @@ func CreateHTTPAPIHandler(client *clientK8s.Client, heapsterClient client.Heapst
 	apiV1Ws.Route(
 		apiV1Ws.PUT("/{kind}/namespace/{namespace}/name/{name}").
 			To(apiHandler.handlePutResource))
+
+	apiV1Ws.Route(
+		apiV1Ws.GET("/persistentvolume").
+			To(apiHandler.handleGetPersistentVolumeList).
+			Writes(persistentvolume.PersistentVolumeList{}))
+	apiV1Ws.Route(
+		apiV1Ws.GET("/persistentvolume/{persistentvolume}").
+			To(apiHandler.handleGetPersistentVolumeDetail).
+			Writes(persistentvolume.PersistentVolumeDetail{}))
 	return wsContainer
 }
 
@@ -946,6 +956,26 @@ func (apiHandler *APIHandler) handleGetConfigMapDetail(request *restful.Request,
 	response.WriteHeaderAndEntity(http.StatusCreated, result)
 }
 
+func (apiHandler *APIHandler) handleGetPersistentVolumeList(request *restful.Request, response *restful.Response) {
+	pagination := parsePaginationPathParameter(request)
+	result, err := persistentvolume.GetPersistentVolumeList(apiHandler.client, pagination)
+	if err != nil {
+		handleInternalError(response, err)
+		return
+	}
+	response.WriteHeaderAndEntity(http.StatusOK, result)
+}
+
+func (apiHandler *APIHandler) handleGetPersistentVolumeDetail(request *restful.Request, response *restful.Response) {
+	name := request.PathParameter("persistentvolume")
+	result, err := persistentvolume.GetPersistentVolumeDetail(apiHandler.client, name)
+	if err != nil {
+		handleInternalError(response, err)
+		return
+	}
+	response.WriteHeaderAndEntity(http.StatusCreated, result)
+}
+
 // Handles log API call.
 func (apiHandler *APIHandler) handleLogs(request *restful.Request, response *restful.Response) {
 	namespace := request.PathParameter("namespace")

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

@@ -73,6 +73,9 @@ type ResourceChannels struct {
 
 	// List and error channels to PodMetrics.
 	PodMetrics PodMetricsChannel
+
+	// List and error channels to PersistentVolumes
+	PersistentVolumeList PersistentVolumeListChannel
 }
 
 // ServiceListChannel is a list and error channels to Services.
@@ -453,6 +456,31 @@ func GetConfigMapListChannel(client client.ConfigMapsNamespacer, nsQuery *Namesp
 	return channel
 }
 
+// PersistentVolumeListChannel is a list and error channels to PersistentVolumes.
+type PersistentVolumeListChannel struct {
+	List  chan *api.PersistentVolumeList
+	Error chan error
+}
+
+// GetPersistentVolumeListChannel returns a pair of channels to a PersistentVolume list and errors that
+// both must be read numReads times.
+func GetPersistentVolumeListChannel(client client.PersistentVolumesInterface, numReads int) PersistentVolumeListChannel {
+	channel := PersistentVolumeListChannel{
+		List:  make(chan *api.PersistentVolumeList, numReads),
+		Error: make(chan error, numReads),
+	}
+
+	go func() {
+		list, err := client.PersistentVolumes().List(listEverything)
+		for i := 0; i < numReads; i++ {
+			channel.List <- list
+			channel.Error <- err
+		}
+	}()
+
+	return channel
+}
+
 // PodMetricsChannel is a list and error channels to MetricsByPod.
 type PodMetricsChannel struct {
 	MetricsByPod chan *MetricsByPod

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

@@ -108,6 +108,7 @@ const (
 	ResourceKindNode                  = "node"
 	ResourceKindSecret                = "secret"
 	ResourceKindConfigMap             = "configmap"
+	ResourceKindPersistentVolume      = "persistentvolume"
 )
 
 // ClientType represents type of client that is used to perform generic operations on resources.
@@ -146,6 +147,7 @@ var kindToAPIMapping = map[string]struct {
 	ResourceKindNode:                  {"nodes", ClientTypeDefault},
 	ResourceKindSecret:                {"secrets", ClientTypeDefault},
 	ResourceKindConfigMap:             {"configmaps", ClientTypeDefault},
+	ResourceKindPersistentVolume:      {"persistentvolumes", ClientTypeDefault},
 }
 
 // IsSelectorMatching returns true when an object with the given

src/app/backend/resource/persistentvolume/persistentvolumecommon.go

@@ -0,0 +1,31 @@
+// 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 persistentvolume
+
+import (
+	"k8s.io/kubernetes/pkg/api"
+	"github.com/kubernetes/dashboard/src/app/backend/resource/common"
+)
+
+func paginate(persistentVolumes []api.PersistentVolume, pQuery *common.PaginationQuery) []api.PersistentVolume {
+	startIndex, endIndex := pQuery.GetPaginationSettings(len(persistentVolumes))
+
+	// Return all items if provided settings do not meet requirements
+	if !pQuery.CanPaginate(len(persistentVolumes), startIndex) {
+		return persistentVolumes
+	}
+
+	return persistentVolumes[startIndex:endIndex]
+}

src/app/backend/resource/persistentvolume/persistentvolumedetail.go

@@ -0,0 +1,69 @@
+// 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 persistentvolume
+
+import (
+	"log"
+
+	"github.com/kubernetes/dashboard/src/app/backend/resource/common"
+	"k8s.io/kubernetes/pkg/api"
+	client "k8s.io/kubernetes/pkg/client/unversioned"
+)
+
+// PersistentVolumeDetail provides the presentation layer view of Kubernetes Persistent Volume resource.
+type PersistentVolumeDetail struct {
+	ObjectMeta common.ObjectMeta `json:"objectMeta"`
+	TypeMeta   common.TypeMeta   `json:"typeMeta"`
+
+	Status                 api.PersistentVolumePhase         `json:"status"`
+	Claim                  string                            `json:"claim"`
+	ReclaimPolicy          api.PersistentVolumeReclaimPolicy `json:"reclaimPolicy"`
+	AccessModes            []api.PersistentVolumeAccessMode  `json:"accessModes"`
+	Capacity               api.ResourceList                  `json:"capacity"`
+	Message                string                            `json:"message"`
+	PersistentVolumeSource api.PersistentVolumeSource        `json:"persistentVolumeSource"`
+}
+
+// GetPersistentVolumeDetail returns detailed information about a persistent volume
+func GetPersistentVolumeDetail(client *client.Client, name string) (*PersistentVolumeDetail, error) {
+	log.Printf("Getting details of %s persistent volume", name)
+
+	rawPersistentVolume, err := client.PersistentVolumes().Get(name)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return getPersistentVolumeDetail(rawPersistentVolume), nil
+}
+
+func getPersistentVolumeDetail(persistentVolume *api.PersistentVolume) *PersistentVolumeDetail {
+
+	var claim string
+	if persistentVolume.Spec.ClaimRef != nil {
+		claim = persistentVolume.Spec.ClaimRef.Name
+	}
+	return &PersistentVolumeDetail{
+		ObjectMeta:             common.NewObjectMeta(persistentVolume.ObjectMeta),
+		TypeMeta:               common.NewTypeMeta(common.ResourceKindPersistentVolume),
+		Status:                 persistentVolume.Status.Phase,
+		Claim:                  claim,
+		ReclaimPolicy:          persistentVolume.Spec.PersistentVolumeReclaimPolicy,
+		AccessModes:            persistentVolume.Spec.AccessModes,
+		Capacity:               persistentVolume.Spec.Capacity,
+		Message:                persistentVolume.Status.Message,
+		PersistentVolumeSource: persistentVolume.Spec.PersistentVolumeSource,
+	}
+}

src/app/backend/resource/persistentvolume/persistentvolumelist.go

@@ -0,0 +1,82 @@
+// 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 persistentvolume
+
+import (
+	"log"
+
+	"github.com/kubernetes/dashboard/src/app/backend/resource/common"
+	"k8s.io/kubernetes/pkg/api"
+	client "k8s.io/kubernetes/pkg/client/unversioned"
+)
+
+// PersistentVolumeList contains a list of Persistent Volumes in the cluster.
+type PersistentVolumeList struct {
+	ListMeta common.ListMeta `json:"listMeta"`
+
+	// Unordered list of Config Maps
+	Items []PersistentVolume `json:"items"`
+}
+
+// PersistentVolume provides the simplified presentation layer view of Kubernetes Persistent Volume resource.
+type PersistentVolume struct {
+	ObjectMeta common.ObjectMeta `json:"objectMeta"`
+	TypeMeta   common.TypeMeta   `json:"typeMeta"`
+
+	// No additional info in the list object.
+}
+
+// GetPersistentVolumeList returns a list of all Persistent Volumes in the cluster.
+func GetPersistentVolumeList(client *client.Client, pQuery *common.PaginationQuery) (*PersistentVolumeList, error) {
+	log.Printf("Getting list persistent volumes")
+	channels := &common.ResourceChannels{
+		PersistentVolumeList: common.GetPersistentVolumeListChannel(client, 1),
+	}
+
+	return GetPersistentVolumeListFromChannels(channels, pQuery)
+}
+
+// GetPersistentVolumeListFromChannels returns a list of all Persistent Volumes in the cluster
+// reading required resource list once from the channels.
+func GetPersistentVolumeListFromChannels(channels *common.ResourceChannels, pQuery *common.PaginationQuery) (
+	*PersistentVolumeList, error) {
+
+	persistentVolumes := <-channels.PersistentVolumeList.List
+	if err := <-channels.PersistentVolumeList.Error; err != nil {
+		return nil, err
+	}
+
+	result := getPersistentVolumeList(persistentVolumes.Items, pQuery)
+
+	return result, nil
+}
+
+func getPersistentVolumeList(persistentVolumes []api.PersistentVolume, pQuery *common.PaginationQuery) *PersistentVolumeList {
+	result := &PersistentVolumeList{
+		Items:    make([]PersistentVolume, 0),
+		ListMeta: common.ListMeta{TotalItems: len(persistentVolumes)},
+	}
+	persistentVolumes = paginate(persistentVolumes, pQuery)
+
+	for _, item := range persistentVolumes {
+		result.Items = append(result.Items,
+			PersistentVolume{
+				ObjectMeta: common.NewObjectMeta(item.ObjectMeta),
+				TypeMeta:   common.NewTypeMeta(common.ResourceKindPersistentVolume),
+			})
+	}
+
+	return result
+}

src/test/backend/resource/persistentvolume/persistentvolume_test.go

@@ -0,0 +1,51 @@
+// 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 persistentvolume
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/kubernetes/dashboard/src/app/backend/resource/common"
+	"k8s.io/kubernetes/pkg/api"
+)
+
+func TestGetPersistentVolumeList(t *testing.T) {
+	cases := []struct {
+		persistentVolumes []api.PersistentVolume
+		expected          *PersistentVolumeList
+	}{
+		{nil, &PersistentVolumeList{Items: []PersistentVolume{}}},
+		{
+			[]api.PersistentVolume{
+				{ObjectMeta: api.ObjectMeta{Name: "foo"}},
+			},
+			&PersistentVolumeList{
+				ListMeta: common.ListMeta{TotalItems: 1},
+				Items: []PersistentVolume{{
+					TypeMeta:   common.TypeMeta{Kind: "persistentvolume"},
+					ObjectMeta: common.ObjectMeta{Name: "foo"},
+				}},
+			},
+		},
+	}
+	for _, c := range cases {
+		actual := getPersistentVolumeList(c.persistentVolumes, common.NoPagination)
+		if !reflect.DeepEqual(actual, c.expected) {
+			t.Errorf("getPersistentVolumeList(%#v) == \n%#v\nexpected \n%#v\n",
+				c.persistentVolumes, actual, c.expected)
+		}
+	}
+}