Merge lp:~dimitern/gomaasapi/static-ipaddresses into lp:gomaasapi

[Dimiter Naydenov]

Static IP addresses API and capabilities for test

Added /ipaddresses/ handlers in the testservice for
GET (list) and POST (release, reserve). Also added
the "static-ipaddresses" capability to the list of
supported ones in the testservice.

All this is needed to test juju-core's MAAS provider
properly with the ongoing work to allow static IP
addresses reservations for containers.

Static IP addresses API and capabilities for test

Added /ipaddresses/ handlers in the testservice for
GET (list) and POST (release, reserve). Also added
the "static-ipaddresses" capability to the list of
supported ones in the testservice.

All this is needed to test juju-core's MAAS provider
properly with the ongoing work to allow static IP
addresses reservations for containers.

[Dimiter Naydenov (dimitern)]

Please take a look.

[Graham Binns (gmb)]

This looks okay to me; I don't have reviewer rights on this project, however.

review: Approve

=== modified file 'testservice.go'
--- testservice.go	2014-10-15 03:12:25 +0000
+++ testservice.go	2014-10-20 14:21:23 +0000
@@ -10,12 +10,15 @@
 	"fmt"
 	"io/ioutil"
 	"mime/multipart"
+	"net"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
+	"time"
 
 	"gopkg.in/mgo.v2/bson"
 )
@@ -72,6 +75,7 @@
 	files                       map[string]MAASObject
 	networks                    map[string]MAASObject
 	networksPerNode             map[string][]string
+	ipAddressesPerNetwork       map[string][]string
 	version                     string
 	macAddressesPerNetwork      map[string]map[string]JSONObject
 	nodeDetails                 map[string]string
@@ -122,6 +126,10 @@
 	return regexp.MustCompile(reString)
 }
 
+func getIPAddressesEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/ipaddresses/", version)
+}
+
 func getMACAddressURL(version, systemId, macAddress string) string {
 	return fmt.Sprintf("/api/%s/nodes/%s/macs/%s/", version, systemId, url.QueryEscape(macAddress))
 }
@@ -131,7 +139,7 @@
 }
 
 func getVersionJSON() string {
-	return `{"capabilities": ["networks-management"]}`
+	return `{"capabilities": ["networks-management","static-ipaddresses"]}`
 }
 
 func getNodegroupsEndpoint(version string) string {
@@ -163,6 +171,7 @@
 	server.files = make(map[string]MAASObject)
 	server.networks = make(map[string]MAASObject)
 	server.networksPerNode = make(map[string][]string)
+	server.ipAddressesPerNetwork = make(map[string][]string)
 	server.macAddressesPerNetwork = make(map[string]map[string]JSONObject)
 	server.nodeDetails = make(map[string]string)
 	server.bootImages = make(map[string][]JSONObject)
@@ -299,14 +308,52 @@
 	node.GetMap()[key] = maasify(server.client, value)
 }
 
+// NewIPAddress creates a new static IP address reservation for the
+// given network and ipAddress.
+func (server *TestServer) NewIPAddress(ipAddress, network string) {
+	if _, found := server.networks[network]; !found {
+		panic("No such network: " + network)
+	}
+	ips, found := server.ipAddressesPerNetwork[network]
+	if found {
+		ips = append(ips, ipAddress)
+	} else {
+		ips = []string{ipAddress}
+	}
+	server.ipAddressesPerNetwork[network] = ips
+}
+
+// RemoveIPAddress removes the given existing ipAddress and returns
+// whether it was actually removed.
+func (server *TestServer) RemoveIPAddress(ipAddress string) bool {
+	for network, ips := range server.ipAddressesPerNetwork {
+		for i, ip := range ips {
+			if ip == ipAddress {
+				ips = append(ips[:i], ips[i+1:]...)
+				server.ipAddressesPerNetwork[network] = ips
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// IPAddresses returns the map with network names as keys and slices
+// of IP addresses belonging to each network as values.
+func (server *TestServer) IPAddresses() map[string][]string {
+	return server.ipAddressesPerNetwork
+}
+
 // NewNetwork creates a network in the test MAAS server
 func (server *TestServer) NewNetwork(jsonText string) MAASObject {
 	var attrs map[string]interface{}
 	err := json.Unmarshal([]byte(jsonText), &attrs)
 	checkError(err)
 	nameEntry, hasName := attrs["name"]
-	if !hasName {
-		panic("The given map json string does not contain a 'name' value.")
+	_, hasIP := attrs["ip"]
+	_, hasNetmask := attrs["netmask"]
+	if !hasName || !hasIP || !hasNetmask {
+		panic("The given map json string does not contain a 'name', 'ip', or 'netmask' value.")
 	}
 	// TODO(gz): Sanity checking done on other fields
 	name := nameEntry.(string)
@@ -403,6 +450,11 @@
 	serveMux.HandleFunc(networksURL, func(w http.ResponseWriter, r *http.Request) {
 		networksHandler(server, w, r)
 	})
+	ipAddressesURL := getIPAddressesEndpoint(server.version)
+	// Register handler for '/api/<version>/ipaddresses/'.
+	serveMux.HandleFunc(ipAddressesURL, func(w http.ResponseWriter, r *http.Request) {
+		ipAddressesHandler(server, w, r)
+	})
 	versionURL := getVersionURL(server.version)
 	// Register handler for '/api/<version>/version/'.
 	serveMux.HandleFunc(versionURL, func(w http.ResponseWriter, r *http.Request) {
@@ -872,6 +924,160 @@
 	fmt.Fprint(w, string(res))
 }
 
+// ipAddressesHandler handles requests for '/api/<version>/ipaddresses/'.
+func ipAddressesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	checkError(err)
+	values := r.Form
+	op := values.Get("op")
+
+	switch r.Method {
+	case "GET":
+		if op != "" {
+			panic("expected empty op for GET, got " + op)
+		}
+		listIPAddressesHandler(server, w, r)
+		return
+	case "POST":
+		switch op {
+		case "reserve":
+			reserveIPAddressHandler(server, w, r, values.Get("network"), values.Get("requested_address"))
+			return
+		case "release":
+			releaseIPAddressHandler(server, w, r, values.Get("ip"))
+			return
+		default:
+			panic("expected op=release|reserve for POST, got " + op)
+		}
+	}
+	http.NotFoundHandler().ServeHTTP(w, r)
+}
+
+func marshalIPAddress(server *TestServer, ipAddress string) (JSONObject, error) {
+	jsonTemplate := `{"alloc_type": 4, "ip": %q, "resource_uri": %q, "created": %q}`
+	uri := getIPAddressesEndpoint(server.version)
+	now := time.Now().UTC().Format(time.RFC3339)
+	bytes := []byte(fmt.Sprintf(jsonTemplate, ipAddress, uri, now))
+	return Parse(server.client, bytes)
+}
+
+func badRequestError(w http.ResponseWriter, err error) {
+	w.WriteHeader(http.StatusBadRequest)
+	fmt.Fprint(w, err.Error())
+}
+
+func listIPAddressesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	results := []MAASObject{}
+	for _, ips := range server.IPAddresses() {
+		for _, ip := range ips {
+			jsonObj, err := marshalIPAddress(server, ip)
+			if err != nil {
+				badRequestError(w, err)
+				return
+			}
+			maasObj, err := jsonObj.GetMAASObject()
+			if err != nil {
+				badRequestError(w, err)
+				return
+			}
+			results = append(results, maasObj)
+		}
+	}
+	res, err := json.Marshal(results)
+	checkError(err)
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, string(res))
+}
+
+func reserveIPAddressHandler(server *TestServer, w http.ResponseWriter, r *http.Request, network, reqAddress string) {
+	_, ipNet, err := net.ParseCIDR(network)
+	if err != nil {
+		badRequestError(w, fmt.Errorf("Invalid network parameter %s", network))
+		return
+	}
+	if reqAddress != "" {
+		// Validate "requested_address" parameter.
+		reqIP := net.ParseIP(reqAddress)
+		if reqIP == nil {
+			badRequestError(w, fmt.Errorf("failed to detect a valid IP address from u'%s'", reqAddress))
+			return
+		}
+		if !ipNet.Contains(reqIP) {
+			badRequestError(w, fmt.Errorf("%s is not inside the range %s", reqAddress, ipNet.String()))
+			return
+		}
+	}
+	// Find the network name matching the parsed CIDR.
+	foundNetworkName := ""
+	for netName, netObj := range server.networks {
+		// Get the "ip" and "netmask" attributes of the network.
+		netIP, err := netObj.GetField("ip")
+		checkError(err)
+		netMask, err := netObj.GetField("netmask")
+		checkError(err)
+
+		// Convert the netmask string to net.IPMask.
+		parts := strings.Split(netMask, ".")
+		ipMask := make(net.IPMask, len(parts))
+		for i, part := range parts {
+			intPart, err := strconv.Atoi(part)
+			checkError(err)
+			ipMask[i] = byte(intPart)
+		}
+		netNet := &net.IPNet{IP: net.ParseIP(netIP), Mask: ipMask}
+		if netNet.String() == network {
+			// Exact match found.
+			foundNetworkName = netName
+			break
+		}
+	}
+	if foundNetworkName == "" {
+		badRequestError(w, fmt.Errorf("No network found matching %s", network))
+		return
+	}
+	ips, found := server.ipAddressesPerNetwork[foundNetworkName]
+	if !found {
+		// This will be the first address.
+		ips = []string{}
+	}
+	reservedIP := ""
+	if reqAddress != "" {
+		// Use what the user provided. NOTE: Because this is testing
+		// code, no duplicates check is done.
+		reservedIP = reqAddress
+	} else {
+		// Generate an IP in the network range by incrementing the
+		// last byte of the network's IP.
+		firstIP := ipNet.IP
+		firstIP[len(firstIP)-1] += byte(len(ips) + 1)
+		reservedIP = firstIP.String()
+	}
+	ips = append(ips, reservedIP)
+	server.ipAddressesPerNetwork[foundNetworkName] = ips
+	jsonObj, err := marshalIPAddress(server, reservedIP)
+	checkError(err)
+	maasObj, err := jsonObj.GetMAASObject()
+	checkError(err)
+	res, err := json.Marshal(maasObj)
+	checkError(err)
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, string(res))
+}
+
+func releaseIPAddressHandler(server *TestServer, w http.ResponseWriter, r *http.Request, ip string) {
+	if netIP := net.ParseIP(ip); netIP == nil {
+		http.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+	if server.RemoveIPAddress(ip) {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+	http.NotFoundHandler().ServeHTTP(w, r)
+}
+
 // versionHandler handles requests for '/api/<version>/version/'.
 func versionHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" {

=== modified file 'testservice_test.go'
--- testservice_test.go	2014-10-15 03:12:25 +0000
+++ testservice_test.go	2014-10-20 14:21:23 +0000
@@ -629,7 +629,7 @@
 func (suite *TestMAASObjectSuite) TestGetNetworks(c *C) {
 	nodeJSON := `{"system_id": "mysystemid"}`
 	suite.TestMAASObject.TestServer.NewNode(nodeJSON)
-	networkJSON := `{"name": "mynetworkname"}`
+	networkJSON := `{"name": "mynetworkname", "ip": "0.1.2.0", "netmask": "255.255.255.0"}`
 	suite.TestMAASObject.TestServer.NewNetwork(networkJSON)
 	suite.TestMAASObject.TestServer.ConnectNodeToNetwork("mysystemid", "mynetworkname")
 
@@ -647,7 +647,13 @@
 
 	networkName, err := listNetworks.GetField("name")
 	c.Assert(err, IsNil)
+	ip, err := listNetworks.GetField("ip")
+	c.Assert(err, IsNil)
+	netmask, err := listNetworks.GetField("netmask")
+	c.Assert(err, IsNil)
 	c.Check(networkName, Equals, "mynetworkname")
+	c.Check(ip, Equals, "0.1.2.0")
+	c.Check(netmask, Equals, "255.255.255.0")
 }
 
 func (suite *TestMAASObjectSuite) TestGetNetworksNone(c *C) {
@@ -667,7 +673,7 @@
 func (suite *TestMAASObjectSuite) TestListNodesWithNetworks(c *C) {
 	nodeJSON := `{"system_id": "mysystemid"}`
 	suite.TestMAASObject.TestServer.NewNode(nodeJSON)
-	networkJSON := `{"name": "mynetworkname"}`
+	networkJSON := `{"name": "mynetworkname", "ip": "0.1.2.0", "netmask": "255.255.255.0"}`
 	suite.TestMAASObject.TestServer.NewNetwork(networkJSON)
 	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("mysystemid", "mynetworkname", "aa:bb:cc:dd:ee:ff")
 
@@ -709,8 +715,12 @@
 func (suite *TestMAASObjectSuite) TestListNetworkConnectedMACAddresses(c *C) {
 	suite.TestMAASObject.TestServer.NewNode(`{"system_id": "node_1"}`)
 	suite.TestMAASObject.TestServer.NewNode(`{"system_id": "node_2"}`)
-	suite.TestMAASObject.TestServer.NewNetwork(`{"name": "net_1"}`)
-	suite.TestMAASObject.TestServer.NewNetwork(`{"name": "net_2"}`)
+	suite.TestMAASObject.TestServer.NewNetwork(
+		`{"name": "net_1", "ip": "0.1.2.0", "netmask": "255.255.255.0"}`,
+	)
+	suite.TestMAASObject.TestServer.NewNetwork(
+		`{"name": "net_2", "ip": "0.2.2.0", "netmask": "255.255.255.0"}`,
+	)
 	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("node_2", "net_2", "aa:bb:cc:dd:ee:22")
 	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("node_1", "net_1", "aa:bb:cc:dd:ee:11")
 	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("node_2", "net_1", "aa:bb:cc:dd:ee:21")
@@ -770,8 +780,141 @@
 	for _, capJSONName := range capArray {
 		capName, err := capJSONName.GetString()
 		c.Assert(err, IsNil)
-		c.Check(capName, Equals, "networks-management")
-	}
+		switch capName {
+		case "networks-management":
+		case "static-ipaddresses":
+		default:
+			c.Fatalf("unknown capability %q", capName)
+		}
+	}
+}
+
+func (suite *TestMAASObjectSuite) assertIPAmong(c *C, jsonObjIP JSONObject, expectIPs ...string) {
+	apiVersion := suite.TestMAASObject.TestServer.version
+	expectedURI := getIPAddressesEndpoint(apiVersion)
+
+	maasObj, err := jsonObjIP.GetMAASObject()
+	c.Assert(err, IsNil)
+	attrs := maasObj.GetMap()
+	uri, err := attrs["resource_uri"].GetString()
+	c.Assert(err, IsNil)
+	c.Assert(uri, Equals, expectedURI)
+	allocType, err := attrs["alloc_type"].GetFloat64()
+	c.Assert(err, IsNil)
+	c.Assert(allocType, Equals, 4.0)
+	created, err := attrs["created"].GetString()
+	c.Assert(err, IsNil)
+	c.Assert(created, Not(Equals), "")
+	ip, err := attrs["ip"].GetString()
+	c.Assert(err, IsNil)
+	if !contains(expectIPs, ip) {
+		c.Fatalf("expected IP in %v, got %q", expectIPs, ip)
+	}
+}
+
+func (suite *TestMAASObjectSuite) TestListIPAddresses(c *C) {
+	ipAddresses := suite.TestMAASObject.GetSubObject("ipaddresses")
+
+	// First try without any networks and IPs.
+	listIPObjects, err := ipAddresses.CallGet("", url.Values{})
+	c.Assert(err, IsNil)
+	items, err := listIPObjects.GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(items, HasLen, 0)
+
+	// Add two networks and some addresses to each one.
+	suite.TestMAASObject.TestServer.NewNetwork(
+		`{"name": "net_1", "ip": "0.1.2.0", "netmask": "255.255.255.0"}`,
+	)
+	suite.TestMAASObject.TestServer.NewNetwork(
+		`{"name": "net_2", "ip": "0.2.2.0", "netmask": "255.255.255.0"}`,
+	)
+	suite.TestMAASObject.TestServer.NewIPAddress("0.1.2.3", "net_1")
+	suite.TestMAASObject.TestServer.NewIPAddress("0.1.2.4", "net_1")
+	suite.TestMAASObject.TestServer.NewIPAddress("0.1.2.5", "net_1")
+	suite.TestMAASObject.TestServer.NewIPAddress("0.2.2.3", "net_2")
+	suite.TestMAASObject.TestServer.NewIPAddress("0.2.2.4", "net_2")
+
+	// List all addresses and verify the needed response fields are set.
+	listIPObjects, err = ipAddresses.CallGet("", url.Values{})
+	c.Assert(err, IsNil)
+	items, err = listIPObjects.GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(items, HasLen, 5)
+
+	for _, ipObj := range items {
+		suite.assertIPAmong(
+			c, ipObj,
+			"0.1.2.3", "0.1.2.4", "0.1.2.5", "0.2.2.3", "0.2.2.4",
+		)
+	}
+
+	// Remove all net_1 IPs.
+	removed := suite.TestMAASObject.TestServer.RemoveIPAddress("0.1.2.3")
+	c.Assert(removed, Equals, true)
+	removed = suite.TestMAASObject.TestServer.RemoveIPAddress("0.1.2.4")
+	c.Assert(removed, Equals, true)
+	removed = suite.TestMAASObject.TestServer.RemoveIPAddress("0.1.2.5")
+	c.Assert(removed, Equals, true)
+	// Remove the last IP twice, should be OK and return false.
+	removed = suite.TestMAASObject.TestServer.RemoveIPAddress("0.1.2.5")
+	c.Assert(removed, Equals, false)
+
+	// List again.
+	listIPObjects, err = ipAddresses.CallGet("", url.Values{})
+	c.Assert(err, IsNil)
+	items, err = listIPObjects.GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(items, HasLen, 2)
+	for _, ipObj := range items {
+		suite.assertIPAmong(
+			c, ipObj,
+			"0.2.2.3", "0.2.2.4",
+		)
+	}
+}
+
+func (suite *TestMAASObjectSuite) TestReserveIPAddress(c *C) {
+	suite.TestMAASObject.TestServer.NewNetwork(
+		`{"name": "net_1", "ip": "0.1.2.0", "netmask": "255.255.255.0"}`,
+	)
+	ipAddresses := suite.TestMAASObject.GetSubObject("ipaddresses")
+	// First try "reserve" with requested_address set.
+	params := url.Values{"network": []string{"0.1.2.0/24"}, "requested_address": []string{"0.1.2.42"}}
+	res, err := ipAddresses.CallPost("reserve", params)
+	c.Assert(err, IsNil)
+	suite.assertIPAmong(c, res, "0.1.2.42")
+
+	// Now try "reserve" without requested_address.
+	delete(params, "requested_address")
+	res, err = ipAddresses.CallPost("reserve", params)
+	c.Assert(err, IsNil)
+	suite.assertIPAmong(c, res, "0.1.2.2")
+}
+
+func (suite *TestMAASObjectSuite) TestReleaseIPAddress(c *C) {
+	suite.TestMAASObject.TestServer.NewNetwork(
+		`{"name": "net_1", "ip": "0.1.2.0", "netmask": "255.255.255.0"}`,
+	)
+	suite.TestMAASObject.TestServer.NewIPAddress("0.1.2.3", "net_1")
+	ipAddresses := suite.TestMAASObject.GetSubObject("ipaddresses")
+
+	// Try with non-existing address - should return 404.
+	params := url.Values{"ip": []string{"0.2.2.1"}}
+	_, err := ipAddresses.CallPost("release", params)
+	c.Assert(err, ErrorMatches, `(\n|.)*404 Not Found(\n|.)*`)
+
+	// Now with existing one - all OK.
+	params = url.Values{"ip": []string{"0.1.2.3"}}
+	_, err = ipAddresses.CallPost("release", params)
+	c.Assert(err, IsNil)
+
+	// Ensure it got removed.
+	c.Assert(suite.TestMAASObject.TestServer.ipAddressesPerNetwork["net_1"], HasLen, 0)
+
+	// Try again, should return 404.
+	_, err = ipAddresses.CallPost("release", params)
+	c.Assert(err, ErrorMatches, `(\n|.)*404 Not Found(\n|.)*`)
 }
 
 const nodeDetailsXML = `<?xml version="1.0" standalone="yes" ?>