Merged in phstsai/VX-55 (pull request #7)

DEV VX-55: List handler for network

Approved-by: Hung-Wei Chiu <[email protected]>

Former-commit-id: ffd7679f986048c7b8d2508dc5bfa7627f1482e4 [formerly ffd7679f986048c7b8d2508dc5bfa7627f1482e4 [formerly 4489f61]]
Former-commit-id: 6ab6dbe560fde89d9c69ee9771b70ac38e538ea5
Former-commit-id: e24cac1

src/net/http/query/query.go

@@ -0,0 +1,56 @@
+package query
+
+import (
+	"net/url"
+	"strconv"
+)
+
+type QueryUrl struct {
+	Url    url.Values    `json:"url"`
+}
+
+func New(url url.Values) *QueryUrl {
+	return &QueryUrl{
+		Url: url,
+	}
+}
+
+func (query *QueryUrl) Int(key string, defaultValue int) (int, error) {
+	values := query.Url[key]
+
+	if len(values) == 0 {
+		return defaultValue, nil
+	}
+
+	val, err := strconv.Atoi(values[0])
+	if err != nil {
+		return defaultValue, err
+	}
+
+	return int(val), nil
+}
+
+func (query *QueryUrl) Int64(key string, defaultValue int64) (int64, error) {
+	values := query.Url[key]
+
+	if len(values) == 0 {
+		return defaultValue, nil
+	}
+
+	val, err := strconv.ParseInt(values[0], 10, 64)
+	if err != nil {
+		return defaultValue, err
+	}
+
+	return int64(val), nil
+}
+
+func (query *QueryUrl) Str(key string) (string, bool) {
+	values := query.Url[key]
+
+	if len(values) == 0 {
+		return "", false
+	}
+
+	return values[0], true
+}

src/net/http/query/query_test.go

@@ -0,0 +1,103 @@
+package query
+
+import (
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"strconv"
+	"testing"
+)
+
+func TestQueryInt(t *testing.T) {
+	expectedInt := 123
+	req, err := http.NewRequest("GET", "/test?iamint="+strconv.Itoa(expectedInt), nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, err := q.Int("iamint", 0)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedInt, v)
+}
+
+func TestQueryIntByDefault(t *testing.T) {
+	defaultInt := 10
+	req, err := http.NewRequest("GET", "/test", nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, err := q.Int("notfound", defaultInt)
+	assert.NoError(t, err)
+	assert.Equal(t, defaultInt, v)
+}
+
+func TestQueryIntFail(t *testing.T) {
+	defaultInt := 10
+	req, err := http.NewRequest("GET", "/test?iamint=abc", nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, err := q.Int("iamint", defaultInt)
+	assert.Error(t, err)
+	assert.Equal(t, defaultInt, v)
+}
+
+func TestInt64(t *testing.T) {
+	expectedInt := int64(42949672951)
+	req, err := http.NewRequest("GET", "/test?iamint="+strconv.FormatInt(expectedInt, 10), nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, err := q.Int64("iamint", 0)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedInt, v)
+}
+
+func TestInt64ByDefault(t *testing.T) {
+	defaultInt := int64(21474836471)
+	req, err := http.NewRequest("GET", "/test", nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, err := q.Int64("notfound", defaultInt)
+	assert.NoError(t, err)
+	assert.Equal(t, defaultInt, v)
+}
+
+func TestInt64Fail(t *testing.T) {
+	defaultInt := int64(21474836471)
+	req, err := http.NewRequest("GET", "/test?iamint=abc", nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, err := q.Int64("iamint", defaultInt)
+	assert.Error(t, err)
+	assert.Equal(t, defaultInt, v)
+}
+
+func TestStr(t *testing.T) {
+	expectedStr := "YoYo"
+	req, err := http.NewRequest("GET", "/test?Hey="+expectedStr, nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, ok := q.Str("Hey")
+	assert.True(t, ok)
+	assert.Equal(t, expectedStr, v)
+}
+
+func TestStrByDefault(t *testing.T) {
+	req, err := http.NewRequest("GET", "/test", nil)
+	assert.NoError(t, err)
+
+	q := New(req.URL.Query())
+
+	v, ok := q.Str("notfound")
+	assert.False(t, ok)
+	assert.Equal(t, "", v)
+}

src/server/handler_network.go

@@ -2,10 +2,13 @@ package server
 
 import (
 	"fmt"
+	"math"
 	"reflect"
+	"strconv"
 
 	"bitbucket.org/linkernetworks/vortex/src/entity"
 	response "bitbucket.org/linkernetworks/vortex/src/net/http"
+	"bitbucket.org/linkernetworks/vortex/src/net/http/query"
 	"bitbucket.org/linkernetworks/vortex/src/web"
 	"github.com/linkernetworks/logger"
 	"github.com/linkernetworks/utils/timeutils"
@@ -82,6 +85,79 @@ func CreateNetworkHandler(ctx *web.Context) {
 	})
 }
 
+func ListNetworkHandler(ctx *web.Context) {
+	as, 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 {
+		logger.Error(err)
+		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 := as.Mongo.NewSession()
+	defer session.Close()
+
+	networks := []entity.Network{}
+
+	var c = session.C(entity.NetworkCollectionName)
+	var q *mgo.Query
+
+	selector := bson.M{}
+	q = c.Find(selector).Sort("_id").Skip((page - 1) * pageSize).Limit(pageSize)
+
+	err = q.All(&networks)
+	if err != nil {
+		logger.Error(err)
+		if err == mgo.ErrNotFound {
+			response.NotFound(req.Request, resp.ResponseWriter, err)
+			return
+		}
+		response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		return
+	}
+
+	count, err := session.Count(entity.NetworkCollectionName, bson.M{})
+	if err != nil {
+		logger.Error(err)
+	}
+	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(networks)
+}
+
+func GetNetworkHandler(ctx *web.Context) {
+	as, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
+
+	id := req.PathParameter("id")
+
+	session := as.Mongo.NewSession()
+	defer session.Close()
+	c := session.C(entity.NetworkCollectionName)
+
+	var network entity.Network
+	err := c.FindId(bson.ObjectIdHex(id)).One(&network)
+	if err != nil {
+		logger.Error(err)
+		if err == mgo.ErrNotFound {
+			response.NotFound(req.Request, resp.ResponseWriter, err)
+			return
+		}
+		response.InternalServerError(req.Request, resp.ResponseWriter, err)
+		return
+	}
+	resp.WriteEntity(network)
+}
+
 func DeleteNetworkHandler(ctx *web.Context) {
 	as, req, resp := ctx.ServiceProvider, ctx.Request, ctx.Response
 

src/server/handler_network_test.go

@@ -392,3 +392,51 @@ func TestWrongUpdateNetwork(t *testing.T) {
 	wcUpdate.Dispatch(httpWriterUpdate, httpRequestUpdate)
 	assertResponseCode(t, http.StatusBadRequest, httpWriterUpdate)
 }
+
+func TestGetNetwork(t *testing.T) {
+	cf := config.MustRead("../../config/testing.json")
+	sp := serviceprovider.New(cf)
+
+	network := entity.Network{
+		DisplayName: "OVS Bridge",
+		BridgeName:  "obsbr1",
+		BridgeType:  "ovs",
+		Node:        "node1",
+		Interface:   "eth3",
+		Ports:       []int32{2043, 2143, 2243},
+		MTU:         1500,
+	}
+
+	session := sp.Mongo.NewSession()
+	defer session.RemoveAll(entity.NetworkCollectionName)
+
+	bodyBytes, err := json.MarshalIndent(network, "", "  ")
+	assert.NoError(t, err)
+
+	bodyReader := strings.NewReader(string(bodyBytes))
+	httpRequest, err := http.NewRequest("POST", "http://localhost:7890/v1/networks", bodyReader)
+	assert.NoError(t, err)
+
+	httpRequest.Header.Add("Content-Type", "application/json")
+	httpWriter := httptest.NewRecorder()
+	wc := restful.NewContainer()
+	service := newNetworkService(sp)
+	wc.Add(service)
+	wc.Dispatch(httpWriter, httpRequest)
+	assertResponseCode(t, http.StatusOK, httpWriter)
+
+	network = entity.Network{}
+	q := bson.M{"displayName": "OVS Bridge"}
+	err = session.FindOne(entity.NetworkCollectionName, q, &network)
+	assert.NoError(t, err)
+
+	httpRequestGet, err := http.NewRequest("GET", "http://localhost:7890/v1/networks/"+network.ID.Hex(), nil)
+	assert.NoError(t, err)
+
+	httpWriterGet := httptest.NewRecorder()
+	wcGet := restful.NewContainer()
+	serviceGet := newNetworkService(sp)
+	wcGet.Add(serviceGet)
+	wcGet.Dispatch(httpWriterGet, httpRequestGet)
+	assertResponseCode(t, http.StatusOK, httpWriterGet)
+}

src/server/route.go

@@ -31,8 +31,10 @@ func newVersionService(sp *serviceprovider.Container) *restful.WebService {
 func newNetworkService(sp *serviceprovider.Container) *restful.WebService {
 	webService := new(restful.WebService)
 	webService.Path("/v1/networks").Consumes(restful.MIME_JSON, restful.MIME_JSON).Produces(restful.MIME_JSON, restful.MIME_JSON)
+	webService.Route(webService.GET("/").To(handler.RESTfulServiceHandler(sp, ListNetworkHandler)))
+	webService.Route(webService.GET("/{id}").To(handler.RESTfulServiceHandler(sp, GetNetworkHandler)))
 	webService.Route(webService.POST("/").To(handler.RESTfulServiceHandler(sp, CreateNetworkHandler)))
-	webService.Route(webService.DELETE("/{id}").To(handler.RESTfulServiceHandler(sp, DeleteNetworkHandler)))
 	webService.Route(webService.PUT("/{id}").To(handler.RESTfulServiceHandler(sp, UpdateNetworkHandler)))
+	webService.Route(webService.DELETE("/{id}").To(handler.RESTfulServiceHandler(sp, DeleteNetworkHandler)))
 	return webService
 }