Merge lp:~mfoord/gomaasapi/devices into lp:gomaasapi

[Michael Foord]

Adding devices support to gomaasapi test server.

Adding devices support to gomaasapi test server.

[Dimiter Naydenov (dimitern)]

LGTM in general, apart from the one comment inline below, if I wish we had logging in places where StatusBadRequest is returned to explain the reason and make the test server a bit easier to use.

Also, as discussed on IRC we need support for op=claim_sticky_ip (or was it claim-sticky-ip?).

review: Approve

[lp:~mfoord/gomaasapi/devices]

95. By Michael Foord on 2015-07-02

Updated comments

[Michael Foord (mfoord)]

> LGTM in general, apart from the one comment inline below, if I wish we had
> logging in places where StatusBadRequest is returned to explain the reason and
> make the test server a bit easier to use.
>
> Also, as discussed on IRC we need support for op=claim_sticky_ip (or was it
> claim-sticky-ip?).

There's no logging in gomaasapi I'm afraid. The rest is now done.

[Dimiter Naydenov (dimitern)]

Looks good to land, thanks!

review: Approve

[Raphaël Badin (rvb)]

Looks good to me as well… lots of TODOs in there but I understand creating a test double is costly and you're only implementing what you need right now.

review: Approve

=== modified file 'testservice.go'
--- testservice.go	2015-06-02 02:28:04 +0000
+++ testservice.go	2015-07-02 16:26:32 +0000
@@ -5,6 +5,7 @@
 
 import (
 	"bufio"
+	"bytes"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
@@ -18,6 +19,7 @@
 	"sort"
 	"strconv"
 	"strings"
+	"text/template"
 	"time"
 
 	"gopkg.in/mgo.v2/bson"
@@ -85,6 +87,24 @@
 	// nodegroupsInterfaces is a map of nodegroup UUIDs to interface
 	// objects.
 	nodegroupsInterfaces map[string][]JSONObject
+
+	// versionJSON is the response to the /version/ endpoint listing the
+	// capabilities of the MAAS server.
+	versionJSON string
+
+	// devices is a map of device UUIDs to devices.
+	devices map[string]*device
+}
+
+type device struct {
+	IPAddresses []string
+	SystemId    string
+	MACAddress  string
+	Parent      string
+	Hostname    string
+
+	// Not part of the device definition but used by the template.
+	APIVersion string
 }
 
 func getNodesEndpoint(version string) string {
@@ -100,6 +120,19 @@
 	return regexp.MustCompile(reString)
 }
 
+func getDevicesEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/devices/", version)
+}
+
+func getDeviceURL(version, systemId string) string {
+	return fmt.Sprintf("/api/%s/devices/%s/", version, systemId)
+}
+
+func getDeviceURLRE(version string) *regexp.Regexp {
+	reString := fmt.Sprintf("^/api/%s/devices/([^/]*)/$", regexp.QuoteMeta(version))
+	return regexp.MustCompile(reString)
+}
+
 func getFilesEndpoint(version string) string {
 	return fmt.Sprintf("/api/%s/files/", version)
 }
@@ -141,10 +174,6 @@
 	return fmt.Sprintf("/api/%s/version/", version)
 }
 
-func getVersionJSON() string {
-	return `{"capabilities": ["networks-management","static-ipaddresses"]}`
-}
-
 func getNodegroupsEndpoint(version string) string {
 	return fmt.Sprintf("/api/%s/nodegroups/", version)
 }
@@ -185,6 +214,14 @@
 	server.bootImages = make(map[string][]JSONObject)
 	server.nodegroupsInterfaces = make(map[string][]JSONObject)
 	server.zones = make(map[string]JSONObject)
+	server.versionJSON = `{"capabilities": ["networks-management","static-ipaddresses"]}`
+	server.devices = make(map[string]*device)
+}
+
+// SetVersionJSON sets the JSON response (capabilities) returned from the
+// /version/ endpoint.
+func (server *TestServer) SetVersionJSON(json string) {
+	server.versionJSON = json
 }
 
 // NodesOperations returns the list of operations performed at the /nodes/
@@ -466,6 +503,11 @@
 	server := &TestServer{version: version}
 
 	serveMux := http.NewServeMux()
+	devicesURL := getDevicesEndpoint(server.version)
+	// Register handler for '/api/<version>/devices/*'.
+	serveMux.HandleFunc(devicesURL, func(w http.ResponseWriter, r *http.Request) {
+		devicesHandler(server, w, r)
+	})
 	nodesURL := getNodesEndpoint(server.version)
 	// Register handler for '/api/<version>/nodes/*'.
 	serveMux.HandleFunc(nodesURL, func(w http.ResponseWriter, r *http.Request) {
@@ -513,6 +555,209 @@
 	return server
 }
 
+// devicesHandler handles requests for '/api/<version>/devices/*'.
+func devicesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	values, err := url.ParseQuery(r.URL.RawQuery)
+	checkError(err)
+	op := values.Get("op")
+	deviceURLRE := getDeviceURLRE(server.version)
+	deviceURLMatch := deviceURLRE.FindStringSubmatch(r.URL.Path)
+	devicesURL := getDevicesEndpoint(server.version)
+	switch {
+	case r.URL.Path == devicesURL:
+		devicesTopLevelHandler(server, w, r, op)
+	case deviceURLMatch != nil:
+		// Request for a single device.
+		deviceHandler(server, w, r, deviceURLMatch[1], op)
+	default:
+		// Default handler: not found.
+		http.NotFoundHandler().ServeHTTP(w, r)
+	}
+}
+
+// devicesTopLevelHandler handles a request for /api/<version>/devices/
+// (with no device id following as part of the path).
+func devicesTopLevelHandler(server *TestServer, w http.ResponseWriter, r *http.Request, op string) {
+	switch {
+	case r.Method == "GET" && op == "list":
+		// Device listing operation.
+		deviceListingHandler(server, w, r)
+	case r.Method == "POST" && op == "new":
+		newDeviceHandler(server, w, r)
+	default:
+		w.WriteHeader(http.StatusBadRequest)
+	}
+}
+
+func macMatches(device *device, macs []string, hasMac bool) bool {
+	if !hasMac {
+		return true
+	}
+	return contains(macs, device.MACAddress)
+}
+
+// deviceListingHandler handles requests for '/devices/'.
+func deviceListingHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	values, err := url.ParseQuery(r.URL.RawQuery)
+	checkError(err)
+	// TODO(mfoord): support filtering by hostname and id
+	macs, hasMac := values["mac_address"]
+	var matchedDevices []string
+	for _, device := range server.devices {
+		if macMatches(device, macs, hasMac) {
+			matchedDevices = append(matchedDevices, renderDevice(device))
+		}
+	}
+	json := fmt.Sprintf("[%v]", strings.Join(matchedDevices, ", "))
+
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, json)
+}
+
+var templateFuncs = template.FuncMap{
+	"quotedList": func(items []string) string {
+		var pieces []string
+		for _, item := range items {
+			pieces = append(pieces, fmt.Sprintf("%q", item))
+		}
+		return strings.Join(pieces, ", ")
+	},
+}
+
+const (
+	// The json template for generating new devices.
+	// TODO(mfoord): set resource_uri in MAC addresses
+	deviceTemplate = `{
+	"macaddress_set": [
+	    {
+		"mac_address": "{{.MACAddress}}"
+	    }
+	],
+	"zone": {
+	    "resource_uri": "/MAAS/api/{{.APIVersion}}/zones/default/",
+	    "name": "default",
+	    "description": ""
+	},
+	"parent": "{{.Parent}}",
+	"ip_addresses": [{{.IPAddresses | quotedList }}],
+	"hostname": "{{.Hostname}}",
+	"tag_names": [],
+	"owner": "maas-admin",
+	"system_id": "{{.SystemId}}",
+	"resource_uri": "/MAAS/api/{{.APIVersion}}/devices/{{.SystemId}}/"
+}`
+)
+
+func renderDevice(device *device) string {
+	t := template.New("Device template")
+	t = t.Funcs(templateFuncs)
+	t, err := t.Parse(deviceTemplate)
+	checkError(err)
+	var buf bytes.Buffer
+	err = t.Execute(&buf, device)
+	checkError(err)
+	return buf.String()
+}
+
+func getValue(values url.Values, value string) (string, bool) {
+	result, hasResult := values[value]
+	if !hasResult || len(result) != 1 || result[0] == "" {
+		return "", false
+	}
+	return result[0], true
+}
+
+// newDeviceHandler creates, stores and returns new devices.
+func newDeviceHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	checkError(err)
+	values := r.PostForm
+
+	// TODO(mfood): generate a "proper" uuid for the system Id.
+	uuid, err := generateNonce()
+	checkError(err)
+	systemId := fmt.Sprintf("node-%v", uuid)
+	// At least one MAC address must be specified.
+	// TODO(mfoord) we only support a single MAC in the test server.
+	mac, hasMac := getValue(values, "mac_addresses")
+
+	// hostname and parent are optional.
+	// TODO(mfoord): we require both to be set in the test server.
+	hostname, hasHostname := getValue(values, "hostname")
+	parent, hasParent := getValue(values, "parent")
+	if !hasHostname || !hasMac || !hasParent {
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	device := &device{
+		MACAddress: mac,
+		APIVersion: server.version,
+		Parent:     parent,
+		Hostname:   hostname,
+		SystemId:   systemId,
+	}
+
+	deviceJSON := renderDevice(device)
+	server.devices[systemId] = device
+
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, deviceJSON)
+	return
+}
+
+// deviceHandler handles requests for '/api/<version>/devices/<system_id>/'.
+func deviceHandler(server *TestServer, w http.ResponseWriter, r *http.Request, systemId string, operation string) {
+	device, ok := server.devices[systemId]
+	if !ok {
+		http.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+	if r.Method == "GET" {
+		deviceJSON := renderDevice(device)
+		if operation == "" {
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, deviceJSON)
+			return
+		} else {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+	}
+	if r.Method == "POST" {
+		if operation == "claim_sticky_ip_address" {
+			err := r.ParseForm()
+			checkError(err)
+			values := r.PostForm
+			// TODO(mfoord): support optional mac_address parameter
+			// TODO(mfoord): requested_address should be optional
+			// and we should generate one if it isn't provided.
+			address, hasAddress := getValue(values, "requested_address")
+			if !hasAddress {
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			checkError(err)
+			device.IPAddresses = append(device.IPAddresses, address)
+			deviceJSON := renderDevice(device)
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, deviceJSON)
+			return
+		} else {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+	} else if r.Method == "DELETE" {
+		delete(server.devices, systemId)
+		w.WriteHeader(http.StatusNoContent)
+		return
+
+	}
+
+	// TODO(mfoord): support PUT method for updating device
+	http.NotFoundHandler().ServeHTTP(w, r)
+}
+
 // nodesHandler handles requests for '/api/<version>/nodes/*'.
 func nodesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
 	values, err := url.ParseQuery(r.URL.RawQuery)
@@ -1188,7 +1433,7 @@
 	}
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	w.WriteHeader(http.StatusOK)
-	fmt.Fprint(w, getVersionJSON())
+	fmt.Fprint(w, server.versionJSON)
 }
 
 // nodegroupsHandler handles requests for '/api/<version>/nodegroups/*'.

=== modified file 'testservice_test.go'
--- testservice_test.go	2015-01-13 03:11:30 +0000
+++ testservice_test.go	2015-07-02 16:26:32 +0000
@@ -49,6 +49,234 @@
 	c.Check(getNodeURL("0.1", "test"), Equals, "/api/0.1/nodes/test/")
 }
 
+func (suite *TestServerSuite) TestSetVersionJSON(c *C) {
+	capabilities := `{"capabilities": ["networks-management","static-ipaddresses", "devices-management"]}`
+	suite.server.SetVersionJSON(capabilities)
+
+	url := fmt.Sprintf("/api/%s/version/", suite.server.version)
+	resp, err := http.Get(suite.server.Server.URL + url)
+	c.Assert(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusOK)
+	content, err := readAndClose(resp.Body)
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, capabilities)
+}
+
+func (suite *TestServerSuite) createDevice(c *C, mac, hostname, parent string) string {
+	devicesURL := fmt.Sprintf("/api/%s/devices/", suite.server.version) + "?op=new"
+	values := url.Values{}
+	values.Add("mac_addresses", mac)
+	values.Add("hostname", hostname)
+	values.Add("parent", parent)
+	result := suite.post(c, devicesURL, values)
+	resultMap, err := result.GetMap()
+	c.Assert(err, IsNil)
+	systemId, err := resultMap["system_id"].GetString()
+	c.Assert(err, IsNil)
+	return systemId
+}
+
+func getString(c *C, object map[string]JSONObject, key string) string {
+	value, err := object[key].GetString()
+	c.Assert(err, IsNil)
+	return value
+}
+
+func (suite *TestServerSuite) post(c *C, url string, values url.Values) JSONObject {
+	resp, err := http.Post(suite.server.Server.URL+url, "application/x-www-form-urlencoded", strings.NewReader(values.Encode()))
+	c.Assert(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusOK)
+	content, err := readAndClose(resp.Body)
+	c.Assert(err, IsNil)
+	result, err := Parse(suite.server.client, content)
+	c.Assert(err, IsNil)
+	return result
+}
+
+func (suite *TestServerSuite) get(c *C, url string) JSONObject {
+	resp, err := http.Get(suite.server.Server.URL + url)
+	c.Assert(err, IsNil)
+	c.Assert(resp.StatusCode, Equals, http.StatusOK)
+
+	content, err := readAndClose(resp.Body)
+	c.Assert(err, IsNil)
+
+	result, err := Parse(suite.server.client, content)
+	c.Assert(err, IsNil)
+	return result
+}
+
+func checkDevice(c *C, device map[string]JSONObject, mac, hostname, parent string) {
+	macArray, err := device["macaddress_set"].GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(macArray, HasLen, 1)
+	macMap, err := macArray[0].GetMap()
+	c.Assert(err, IsNil)
+
+	actualMac := getString(c, macMap, "mac_address")
+	c.Assert(actualMac, Equals, mac)
+
+	actualParent := getString(c, device, "parent")
+	c.Assert(actualParent, Equals, parent)
+	actualHostname := getString(c, device, "hostname")
+	c.Assert(actualHostname, Equals, hostname)
+}
+
+func (suite *TestServerSuite) TestNewDeviceRequiredParameters(c *C) {
+	devicesURL := fmt.Sprintf("/api/%s/devices/", suite.server.version) + "?op=new"
+	values := url.Values{}
+	values.Add("mac_addresses", "foo")
+	values.Add("hostname", "bar")
+	post := func(values url.Values) int {
+		resp, err := http.Post(suite.server.Server.URL+devicesURL, "application/x-www-form-urlencoded", strings.NewReader(values.Encode()))
+		c.Assert(err, IsNil)
+		return resp.StatusCode
+	}
+	c.Check(post(values), Equals, http.StatusBadRequest)
+	values.Del("hostname")
+	values.Add("parent", "baz")
+	c.Check(post(values), Equals, http.StatusBadRequest)
+	values.Del("mac_addresses")
+	values.Add("hostname", "bam")
+	c.Check(post(values), Equals, http.StatusBadRequest)
+}
+
+func (suite *TestServerSuite) TestNewDevice(c *C) {
+	devicesURL := fmt.Sprintf("/api/%s/devices/", suite.server.version) + "?op=new"
+
+	values := url.Values{}
+	values.Add("mac_addresses", "foo")
+	values.Add("hostname", "bar")
+	values.Add("parent", "baz")
+	result := suite.post(c, devicesURL, values)
+
+	resultMap, err := result.GetMap()
+	c.Assert(err, IsNil)
+
+	macArray, err := resultMap["macaddress_set"].GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(macArray, HasLen, 1)
+	macMap, err := macArray[0].GetMap()
+	c.Assert(err, IsNil)
+
+	mac := getString(c, macMap, "mac_address")
+	c.Assert(mac, Equals, "foo")
+
+	parent := getString(c, resultMap, "parent")
+	c.Assert(parent, Equals, "baz")
+	hostname := getString(c, resultMap, "hostname")
+	c.Assert(hostname, Equals, "bar")
+
+	addresses, err := resultMap["ip_addresses"].GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(addresses, HasLen, 0)
+
+	systemId := getString(c, resultMap, "system_id")
+	resourceURI := getString(c, resultMap, "resource_uri")
+	c.Assert(resourceURI, Equals, fmt.Sprintf("/MAAS/api/%v/devices/%v/", suite.server.version, systemId))
+}
+
+func (suite *TestServerSuite) TestGetDevice(c *C) {
+	systemId := suite.createDevice(c, "foo", "bar", "baz")
+	deviceURL := fmt.Sprintf("/api/%v/devices/%v/", suite.server.version, systemId)
+
+	result := suite.get(c, deviceURL)
+	resultMap, err := result.GetMap()
+	c.Assert(err, IsNil)
+	checkDevice(c, resultMap, "foo", "bar", "baz")
+	actualId, err := resultMap["system_id"].GetString()
+	c.Assert(actualId, Equals, systemId)
+}
+
+func (suite *TestServerSuite) TestDevicesList(c *C) {
+	firstId := suite.createDevice(c, "foo", "bar", "baz")
+	c.Assert(firstId, Not(Equals), "")
+	secondId := suite.createDevice(c, "bam", "bing", "bong")
+	c.Assert(secondId, Not(Equals), "")
+
+	devicesURL := fmt.Sprintf("/api/%s/devices/", suite.server.version) + "?op=list"
+	result := suite.get(c, devicesURL)
+
+	devicesArray, err := result.GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(devicesArray, HasLen, 2)
+
+	for _, device := range devicesArray {
+		deviceMap, err := device.GetMap()
+		c.Assert(err, IsNil)
+		systemId, err := deviceMap["system_id"].GetString()
+		c.Assert(err, IsNil)
+		switch systemId {
+		case firstId:
+			checkDevice(c, deviceMap, "foo", "bar", "baz")
+		case secondId:
+			checkDevice(c, deviceMap, "bam", "bing", "bong")
+		default:
+			c.Fatalf("unknown system id %q", systemId)
+		}
+	}
+}
+
+func (suite *TestServerSuite) TestDevicesListMacFiltering(c *C) {
+	firstId := suite.createDevice(c, "foo", "bar", "baz")
+	c.Assert(firstId, Not(Equals), "")
+	secondId := suite.createDevice(c, "bam", "bing", "bong")
+	c.Assert(secondId, Not(Equals), "")
+
+	op := fmt.Sprintf("?op=list&mac_address=%v", "foo")
+	devicesURL := fmt.Sprintf("/api/%s/devices/", suite.server.version) + op
+	result := suite.get(c, devicesURL)
+
+	devicesArray, err := result.GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(devicesArray, HasLen, 1)
+	deviceMap, err := devicesArray[0].GetMap()
+	c.Assert(err, IsNil)
+	checkDevice(c, deviceMap, "foo", "bar", "baz")
+}
+
+func (suite *TestServerSuite) TestDeviceClaimStickyIPRequiresAddress(c *C) {
+	systemId := suite.createDevice(c, "foo", "bar", "baz")
+	op := "?op=claim_sticky_ip_address"
+	deviceURL := fmt.Sprintf("/api/%s/devices/%s/%s", suite.server.version, systemId, op)
+	values := url.Values{}
+	resp, err := http.Post(suite.server.Server.URL+deviceURL, "application/x-www-form-urlencoded", strings.NewReader(values.Encode()))
+	c.Assert(err, IsNil)
+	c.Assert(resp.StatusCode, Equals, http.StatusBadRequest)
+}
+
+func (suite *TestServerSuite) TestDeviceClaimStickyIP(c *C) {
+	systemId := suite.createDevice(c, "foo", "bar", "baz")
+	op := "?op=claim_sticky_ip_address"
+	deviceURL := fmt.Sprintf("/api/%s/devices/%s/", suite.server.version, systemId)
+	values := url.Values{}
+	values.Add("requested_address", "127.0.0.1")
+	result := suite.post(c, deviceURL+op, values)
+	resultMap, err := result.GetMap()
+	c.Assert(err, IsNil)
+
+	addresses, err := resultMap["ip_addresses"].GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(addresses, HasLen, 1)
+	address, err := addresses[0].GetString()
+	c.Assert(err, IsNil)
+	c.Assert(address, Equals, "127.0.0.1")
+}
+
+func (suite *TestServerSuite) TestDeleteDevice(c *C) {
+	systemId := suite.createDevice(c, "foo", "bar", "baz")
+	deviceURL := fmt.Sprintf("/api/%s/devices/%s/", suite.server.version, systemId)
+	req, err := http.NewRequest("DELETE", suite.server.Server.URL+deviceURL, nil)
+	c.Assert(err, IsNil)
+	resp, err := http.DefaultClient.Do(req)
+	c.Assert(err, IsNil)
+	c.Assert(resp.StatusCode, Equals, http.StatusNoContent)
+
+	resp, err = http.Get(suite.server.Server.URL + deviceURL)
+	c.Assert(err, IsNil)
+	c.Assert(resp.StatusCode, Equals, http.StatusNotFound)
+}
+
 func (suite *TestServerSuite) TestInvalidOperationOnNodesIsBadRequest(c *C) {
 	badURL := getNodesEndpoint(suite.server.version) + "?op=procrastinate"