Implement the function to list the documents of volumes

src/server/handler_network.go

@@ -74,7 +74,7 @@ func createNetworkHandler(ctx *web.Context) {
 }
 
 func listNetworkHandler(ctx *web.Context) {
-	as, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
+	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
 
 	var pageSize = 10
 	query := query.New(req.Request.URL.Query())
@@ -90,7 +90,7 @@ func listNetworkHandler(ctx *web.Context) {
 		return
 	}
 
-	session := as.Mongo.NewSession()
+	session := sp.Mongo.NewSession()
 	defer session.Close()
 
 	networks := []entity.Network{}
@@ -111,7 +111,8 @@ func listNetworkHandler(ctx *web.Context) {
 
 	count, err := session.Count(entity.NetworkCollectionName, bson.M{})
 	if err != nil {
-		logger.Error(err)
+		response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		return
 	}
 	totalPages := int(math.Ceil(float64(count) / float64(pageSize)))
 	resp.AddHeader("X-Total-Count", strconv.Itoa(count))
@@ -120,11 +121,11 @@ func listNetworkHandler(ctx *web.Context) {
 }
 
 func getNetworkHandler(ctx *web.Context) {
-	as, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
+	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
 
 	id := req.PathParameter("id")
 
-	session := as.Mongo.NewSession()
+	session := sp.Mongo.NewSession()
 	defer session.Close()
 	c := session.C(entity.NetworkCollectionName)
 
@@ -141,11 +142,11 @@ func getNetworkHandler(ctx *web.Context) {
 }
 
 func deleteNetworkHandler(ctx *web.Context) {
-	as, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
+	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
 
 	id := req.PathParameter("id")
 
-	session := as.Mongo.NewSession()
+	session := sp.Mongo.NewSession()
 	defer session.Close()
 
 	if err := session.Remove(entity.NetworkCollectionName, "_id", bson.ObjectIdHex(id)); err != nil {

src/server/handler_network_test.go

@@ -365,5 +365,4 @@ func (suite *NetworkTestSuite) TestListNetworkWithInvalidPage() {
 	httpWriter = httptest.NewRecorder()
 	suite.wc.Dispatch(httpWriter, httpRequest)
 	assertResponseCode(suite.T(), http.StatusInternalServerError, httpWriter)
-
 }

src/server/handler_storage_provider.go

@@ -88,7 +88,8 @@ func listStorageProvider(ctx *web.Context) {
 
 	count, err := session.Count(entity.StorageProviderCollectionName, bson.M{})
 	if err != nil {
-		logger.Error(err)
+		response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		return
 	}
 	totalPages := int(math.Ceil(float64(count) / float64(pageSize)))
 	resp.AddHeader("X-Total-Count", strconv.Itoa(count))

src/server/handler_volume.go

@@ -2,11 +2,15 @@ package server
 
 import (
 	"fmt"
+	"math"
+	"strconv"
 
 	"github.com/linkernetworks/utils/timeutils"
 	"github.com/linkernetworks/vortex/src/entity"
 	response "github.com/linkernetworks/vortex/src/net/http"
+	"github.com/linkernetworks/vortex/src/net/http/query"
 	"github.com/linkernetworks/vortex/src/web"
+
 	mgo "gopkg.in/mgo.v2"
 	"gopkg.in/mgo.v2/bson"
 )
@@ -80,3 +84,50 @@ func deleteVolume(ctx *web.Context) {
 		Message: "Delete success",
 	})
 }
+
+func listVolume(ctx *web.Context) {
+	sp, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
+
+	var pageSize = 10
+	query := query.New(req.Request.URL.Query())
+
+	page, err := query.Int("page", 1)
+	if err != nil {
+		response.BadRequest(req.Request, resp.ResponseWriter, err)
+		return
+	}
+	pageSize, err = query.Int("page_size", pageSize)
+	if err != nil {
+		response.BadRequest(req.Request, resp.ResponseWriter, err)
+		return
+	}
+
+	session := sp.Mongo.NewSession()
+	defer session.Close()
+
+	volumes := []entity.Volume{}
+	var c = session.C(entity.VolumeCollectionName)
+	var q *mgo.Query
+
+	selector := bson.M{}
+	q = c.Find(selector).Sort("_id").Skip((page - 1) * pageSize).Limit(pageSize)
+
+	if err := q.All(&volumes); err != nil {
+		if err == mgo.ErrNotFound {
+			response.NotFound(req.Request, resp.ResponseWriter, err)
+		} else {
+			response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		}
+		return
+	}
+
+	count, err := session.Count(entity.VolumeCollectionName, bson.M{})
+	if err != nil {
+		response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		return
+	}
+	totalPages := int(math.Ceil(float64(count) / float64(pageSize)))
+	resp.AddHeader("X-Total-Count", strconv.Itoa(count))
+	resp.AddHeader("X-Total-Pages", strconv.Itoa(totalPages))
+	resp.WriteEntity(volumes)
+}

src/server/handler_volume_test.go

@@ -174,3 +174,85 @@ func (suite *VolumeTestSuite) TestDeleteVolumeWithInvalidID() {
 	suite.wc.Dispatch(httpWriter, httpRequest)
 	assertResponseCode(suite.T(), http.StatusBadRequest, httpWriter)
 }
+
+func (suite *VolumeTestSuite) TestListVolume() {
+	volumes := []entity.Volume{}
+	count := 3
+	for i := 0; i < count; i++ {
+		volumes = append(volumes, entity.Volume{
+			ID:                  bson.NewObjectId(),
+			Name:                namesgenerator.GetRandomName(0),
+			StorageProviderName: namesgenerator.GetRandomName(0),
+			AccessMode:          corev1.PersistentVolumeAccessMode("ReadOnlyMany"),
+			Capacity:            "250",
+		})
+	}
+
+	for _, v := range volumes {
+		suite.session.C(entity.VolumeCollectionName).Insert(v)
+		defer suite.session.Remove(entity.VolumeCollectionName, "_id", v.ID)
+	}
+
+	testCases := []struct {
+		page       string
+		pageSize   string
+		expectSize int
+	}{
+		{"", "", count},
+		{"1", "1", count},
+		{"1", "3", count},
+	}
+
+	for _, tc := range testCases {
+		caseName := "page:pageSize" + tc.page + ":" + tc.pageSize
+		suite.T().Run(caseName, func(t *testing.T) {
+			//list data by default page and page_size
+			url := "http://localhost:7890/v1/volume/"
+			if tc.page != "" || tc.pageSize != "" {
+				url = "http://localhost:7890/v1/volume?"
+				url += "page=" + tc.page + "%" + "page_size" + tc.pageSize
+			}
+			httpRequest, err := http.NewRequest("GET", url, nil)
+			suite.NoError(err)
+
+			httpWriter := httptest.NewRecorder()
+			suite.wc.Dispatch(httpWriter, httpRequest)
+			assertResponseCode(suite.T(), http.StatusOK, httpWriter)
+
+			retVolumes := []entity.Volume{}
+			err = json.Unmarshal(httpWriter.Body.Bytes(), &retVolumes)
+			suite.NoError(err)
+			suite.Equal(tc.expectSize, len(retVolumes))
+			for i, v := range retVolumes {
+				suite.Equal(volumes[i].Name, v.Name)
+				suite.Equal(volumes[i].MetaName, v.MetaName)
+				suite.Equal(volumes[i].StorageProviderName, v.StorageProviderName)
+				suite.Equal(volumes[i].AccessMode, v.AccessMode)
+			}
+		})
+	}
+}
+
+func (suite *VolumeTestSuite) TestListVolumeWithInvalidPage() {
+	//Get data with non-exits ID
+	httpRequest, err := http.NewRequest("GET", "http://localhost:7890/v1/volume?page=asdd", nil)
+	suite.NoError(err)
+
+	httpWriter := httptest.NewRecorder()
+	suite.wc.Dispatch(httpWriter, httpRequest)
+	assertResponseCode(suite.T(), http.StatusBadRequest, httpWriter)
+
+	httpRequest, err = http.NewRequest("GET", "http://localhost:7890/v1/volume?page_size=asdd", nil)
+	suite.NoError(err)
+
+	httpWriter = httptest.NewRecorder()
+	suite.wc.Dispatch(httpWriter, httpRequest)
+	assertResponseCode(suite.T(), http.StatusBadRequest, httpWriter)
+
+	httpRequest, err = http.NewRequest("GET", "http://localhost:7890/v1/volume?page=-1", nil)
+	suite.NoError(err)
+
+	httpWriter = httptest.NewRecorder()
+	suite.wc.Dispatch(httpWriter, httpRequest)
+	assertResponseCode(suite.T(), http.StatusInternalServerError, httpWriter)
+}

src/server/route.go

@@ -55,6 +55,7 @@ func newVolumeService(sp *serviceprovider.Container) *restful.WebService {
 	webService.Path("/v1/volume").Consumes(restful.MIME_JSON, restful.MIME_JSON).Produces(restful.MIME_JSON, restful.MIME_JSON)
 	webService.Route(webService.POST("/").To(handler.RESTfulServiceHandler(sp, createVolume)))
 	webService.Route(webService.DELETE("/{id}").To(handler.RESTfulServiceHandler(sp, deleteVolume)))
+	webService.Route(webService.GET("/").To(handler.RESTfulServiceHandler(sp, listVolume)))
 	return webService
 }