Merge lp:~dooferlad/gomaasapi/subnets into lp:gomaasapi

[James Tunnicliffe]

Add subnets support.

[lp:~dooferlad/gomaasapi/subnets]

67. By James Tunnicliffe on 2015-11-19

Removed unused function.

[Dimiter Naydenov (dimitern)]

Most of it looks good, apart from a few concerns around marshalling/unmarshalling for numbers and reducing some duplication.

review: Needs Fixing

[James Tunnicliffe (dooferlad)]

Don't worry about the JSON stuff - it works just fine if you use structs because go can convert according to the type you give it. The de-dup stuff seems worth it though.

[lp:~dooferlad/gomaasapi/subnets]

68. By James Tunnicliffe on 2015-11-19

Tidying up subnets.

69. By James Tunnicliffe on 2015-11-20

Subnets now have statistics support.
Fixed up reserved/unreserved ranges after improving tests.
Tidied up some old tests.

70. By James Tunnicliffe on 2015-11-23

Spaces added (for the structs - may never need the API)
Subnets now can be embedded in a nodes JSON.

71. By James Tunnicliffe on 2015-11-23

Added test for node subnets mapping.

72. By James Tunnicliffe on 2015-11-24

Pretty JSON is easier to read.
Fixed api/1.0/subnets/1/?op=reserved_ip_ranges when there is 1 reserved address.

73. By James Tunnicliffe on 2015-11-24

Fixed incorrect JSON name for space

74. By James Tunnicliffe on 2015-11-24

New addresses default to having a purpose of "assigned-ip"
Added AddFixedAddressRange call.
De-duplicated some code.

75. By James Tunnicliffe on 2015-11-24

Purpose back to being an array.
Fixed possible out of range error.

76. By James Tunnicliffe on 2015-11-26

AddFixedAddressRange moved to the server rather than directly acting on a subnet.

77. By James Tunnicliffe on 2015-11-26

suite.server.SetNodeNetworkLink now takes a node.SystemID rather than a node.

78. By James Tunnicliffe on 2015-11-26

Fixed subnets/1/?op=reserved_ip_ranges when no IP addresses had been explicitly assigned.

79. By James Tunnicliffe on 2015-11-27

Ensure that all arrays in a posted subnet are non-nil.
Fix typo.
Simplify net.IP --> uint64 logic.

Unmerged revisions

=== modified file 'jsonobject.go'
--- jsonobject.go	2013-02-12 12:26:07 +0000
+++ jsonobject.go	2015-11-23 15:55:40 +0000
@@ -104,6 +104,15 @@
 	return obj, nil
 }
 
+// JSONObjectFromStruct takes a struct and converts it to a JSONObject
+func JSONObjectFromStruct(client Client, input interface{}) (JSONObject, error) {
+	j, err := json.Marshal(input)
+	if err != nil {
+		return JSONObject{}, err
+	}
+	return Parse(client, j)
+}
+
 // Return error value for failed type conversion.
 func failConversion(wantedType string, obj JSONObject) error {
 	msg := fmt.Sprintf("Requested %v, got %T.", wantedType, obj.value)

=== modified file 'testservice.go'
--- testservice.go	2015-07-02 16:26:22 +0000
+++ testservice.go	2015-11-23 15:55:40 +0000
@@ -74,6 +74,7 @@
 	// list of Values passed when performing operations at the
 	// /nodes/ level.
 	nodesOperationRequestValues []url.Values
+	nodeMetadata                map[string]Node
 	files                       map[string]MAASObject
 	networks                    map[string]MAASObject
 	networksPerNode             map[string][]string
@@ -94,6 +95,15 @@
 
 	// devices is a map of device UUIDs to devices.
 	devices map[string]*device
+
+	subnets        map[uint]Subnet
+	subnetNameToID map[string]uint
+	nextSubnet     uint
+	spaces         map[uint]Space
+	spaceNameToID  map[string]uint
+	nextSpace      uint
+	vlans          map[int]VLAN
+	nextVLAN       int
 }
 
 type device struct {
@@ -205,6 +215,7 @@
 	server.nodeOperations = make(map[string][]string)
 	server.nodesOperationRequestValues = make([]url.Values, 0)
 	server.nodeOperationRequestValues = make(map[string][]url.Values)
+	server.nodeMetadata = make(map[string]Node)
 	server.files = make(map[string]MAASObject)
 	server.networks = make(map[string]MAASObject)
 	server.networksPerNode = make(map[string][]string)
@@ -214,8 +225,16 @@
 	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.versionJSON = `{"capabilities": ["networks-management","static-ipaddresses","devices-management","network-deployment-ubuntu"]}`
 	server.devices = make(map[string]*device)
+	server.subnets = make(map[uint]Subnet)
+	server.subnetNameToID = make(map[string]uint)
+	server.nextSubnet = 1
+	server.spaces = make(map[uint]Space)
+	server.spaceNameToID = make(map[string]uint)
+	server.nextSpace = 1
+	server.vlans = make(map[int]VLAN)
+	server.nextVLAN = 1
 }
 
 // SetVersionJSON sets the JSON response (capabilities) returned from the
@@ -355,18 +374,32 @@
 }
 
 // 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)
+// given network/subnet and ipAddress. While networks is being depreicated
+// try the given name as both a netowrk and a subnet.
+func (server *TestServer) NewIPAddress(ipAddress, networkOrSubnet string) {
+	_, foundNetwork := server.networks[networkOrSubnet]
+	subnetID, foundSubnet := server.subnetNameToID[networkOrSubnet]
+
+	if (foundNetwork || foundSubnet) == false {
+		panic("No such network or subnet: " + networkOrSubnet)
 	}
-	ips, found := server.ipAddressesPerNetwork[network]
-	if found {
-		ips = append(ips, ipAddress)
+	if foundNetwork {
+		ips, found := server.ipAddressesPerNetwork[networkOrSubnet]
+		if found {
+			ips = append(ips, ipAddress)
+		} else {
+			ips = []string{ipAddress}
+		}
+		server.ipAddressesPerNetwork[networkOrSubnet] = ips
 	} else {
-		ips = []string{ipAddress}
+		subnet := server.subnets[subnetID]
+		netIp := net.ParseIP(ipAddress)
+		if netIp == nil {
+			panic(ipAddress + " is invalid")
+		}
+		subnet.InUseIPAddresses = append(subnet.InUseIPAddresses, IPFromNetIP(netIp))
+		server.subnets[subnetID] = subnet
 	}
-	server.ipAddressesPerNetwork[network] = ips
 }
 
 // RemoveIPAddress removes the given existing ipAddress and returns
@@ -545,6 +578,21 @@
 		zonesHandler(server, w, r)
 	})
 
+	subnetsURL := getSubnetsEndpoint(server.version)
+	serveMux.HandleFunc(subnetsURL, func(w http.ResponseWriter, r *http.Request) {
+		subnetsHandler(server, w, r)
+	})
+
+	spacesURL := getSpacesEndpoint(server.version)
+	serveMux.HandleFunc(spacesURL, func(w http.ResponseWriter, r *http.Request) {
+		spacesHandler(server, w, r)
+	})
+
+	vlansURL := getVLANsEndpoint(server.version)
+	serveMux.HandleFunc(vlansURL, func(w http.ResponseWriter, r *http.Request) {
+		vlansHandler(server, w, r)
+	})
+
 	newServer := httptest.NewServer(serveMux)
 	client, err := NewAnonymousClient(newServer.URL, "1.0")
 	checkError(err)
@@ -785,12 +833,27 @@
 		http.NotFoundHandler().ServeHTTP(w, r)
 		return
 	}
+	UUID, UUIDError := node.values["system_id"].GetString()
+
 	if r.Method == "GET" {
 		if operation == "" {
 			w.WriteHeader(http.StatusOK)
+			if UUIDError == nil {
+				i, err := JSONObjectFromStruct(server.client, server.nodeMetadata[UUID].Interfaces)
+				checkError(err)
+				if err == nil {
+					node.values["interface_set"] = i
+				}
+			}
 			fmt.Fprint(w, marshalNode(node))
 			return
 		} else if operation == "details" {
+			if UUIDError == nil {
+				i, err := JSONObjectFromStruct(server.client, server.nodeMetadata[UUID].Interfaces)
+				if err == nil {
+					node.values["interface_set"] = i
+				}
+			}
 			nodeDetailsHandler(server, w, r, systemId)
 			return
 		} else {
@@ -811,10 +874,10 @@
 			w.WriteHeader(http.StatusOK)
 			fmt.Fprint(w, marshalNode(node))
 			return
-		} else {
-			w.WriteHeader(http.StatusBadRequest)
-			return
 		}
+
+		w.WriteHeader(http.StatusBadRequest)
+		return
 	}
 	if r.Method == "DELETE" {
 		delete(server.nodes, systemId)

=== added file 'testservice_spaces.go'
--- testservice_spaces.go	1970-01-01 00:00:00 +0000
+++ testservice_spaces.go	2015-11-23 15:55:40 +0000
@@ -0,0 +1,81 @@
+// Copyright 2015 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"regexp"
+)
+
+func getSpacesEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/spaces/", version)
+}
+
+// Space is the MAAS API space representation
+type Space struct {
+	Name        string   `json:"name"`
+	Subnets     []Subnet `json:"subnets"`
+	ResourceURI string   `json:"resource_uri"`
+	ID          uint     `json:"id"`
+}
+
+// spacesHandler handles requests for '/api/<version>/spaces/'.
+func spacesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	var err error
+	spacesURLRE := regexp.MustCompile(`/spaces/(.+?)/`)
+	spacesURLMatch := spacesURLRE.FindStringSubmatch(r.URL.Path)
+	spacesURL := getSpacesEndpoint(server.version)
+
+	var ID uint
+	var gotID bool
+	if spacesURLMatch != nil {
+		ID, err = NameOrIDToID(spacesURLMatch[1], server.spaceNameToID, 1, uint(len(server.spaces)))
+
+		if err != nil {
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		gotID = true
+	}
+
+	switch r.Method {
+	case "GET":
+		w.Header().Set("Content-Type", "application/vnd.api+json")
+		if len(server.spaces) == 0 {
+			// Until a space is registered, behave as if the endpoint
+			// does not exist. This way we can simulate older MAAS
+			// servers that do not support spaces.
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		if r.URL.Path == spacesURL {
+			var spaces []Space
+			for i := uint(1); i < server.nextSpace; i++ {
+				s, ok := server.spaces[i]
+				if ok {
+					spaces = append(spaces, s)
+				}
+			}
+			err = json.NewEncoder(w).Encode(spaces)
+		} else if gotID == false {
+			w.WriteHeader(http.StatusBadRequest)
+		} else {
+			err = json.NewEncoder(w).Encode(server.spaces[ID])
+		}
+		checkError(err)
+	case "POST":
+		//server.NewSpace(r.Body)
+	case "PUT":
+		//server.UpdateSpace(r.Body)
+	case "DELETE":
+		delete(server.spaces, ID)
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.WriteHeader(http.StatusBadRequest)
+	}
+}

=== added file 'testservice_subnets.go'
--- testservice_subnets.go	1970-01-01 00:00:00 +0000
+++ testservice_subnets.go	2015-11-23 15:55:40 +0000
@@ -0,0 +1,362 @@
+// Copyright 2015 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+func getSubnetsEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/subnets/", version)
+}
+
+// CreateSubnet is used to receive new subnets via the MAAS API
+type CreateSubnet struct {
+	DNSServers []string `json:"dns_servers"`
+	Name       string   `json:"name"`
+	Space      string   `json:"space"`
+	GatewayIP  string   `json:"gateway_ip"`
+	CIDR       string   `json:"cidr"`
+
+	// VLAN this subnet belongs to. Currently ignored.
+	// TODO: Defaults to the default VLAN
+	// for the provided fabric or defaults to the default VLAN
+	// in the default fabric.
+	VLAN *uint `json:"vlan"`
+
+	// Fabric for the subnet. Currently ignored.
+	// TODO: Defaults to the fabric the provided
+	// VLAN belongs to or defaults to the default fabric.
+	Fabric *uint `json:"fabric"`
+
+	// VID of the VLAN this subnet belongs to. Currently ignored.
+	// TODO: Only used when vlan
+	// is not provided. Picks the VLAN with this VID in the provided
+	// fabric or the default fabric if one is not given.
+	VID *uint `json:"vid"`
+
+	// This is used for updates (PUT) and is ignored by create (POST)
+	ID uint `json:"id"`
+}
+
+// Subnet is the MAAS API subnet representation
+type Subnet struct {
+	DNSServers []string `json:"dns_servers"`
+	Name       string   `json:"name"`
+	Space      string   `json:"string"`
+	VLAN       VLAN     `json:"vlan"`
+	GatewayIP  string   `json:"gateway_ip"`
+	CIDR       string   `json:"cidr"`
+
+	ResourceURI      string `json:"resource_uri"`
+	ID               uint   `json:"id"`
+	InUseIPAddresses []IP   `json:"-"`
+}
+
+// subnetsHandler handles requests for '/api/<version>/subnets/'.
+func subnetsHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	var err error
+	values, err := url.ParseQuery(r.URL.RawQuery)
+	checkError(err)
+	op := values.Get("op")
+	includeRangesString := strings.ToLower(values.Get("include_ranges"))
+	subnetsURLRE := regexp.MustCompile(`/subnets/(.+?)/`)
+	subnetsURLMatch := subnetsURLRE.FindStringSubmatch(r.URL.Path)
+	subnetsURL := getSubnetsEndpoint(server.version)
+
+	var ID uint
+	var gotID bool
+	if subnetsURLMatch != nil {
+		ID, err = NameOrIDToID(subnetsURLMatch[1], server.subnetNameToID, 1, uint(len(server.subnets)))
+
+		if err != nil {
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		gotID = true
+	}
+
+	var includeRanges bool
+	switch includeRangesString {
+	case "true", "yes", "1":
+		includeRanges = true
+	}
+
+	switch r.Method {
+	case "GET":
+		w.Header().Set("Content-Type", "application/vnd.api+json")
+		if len(server.subnets) == 0 {
+			// Until a subnet is registered, behave as if the endpoint
+			// does not exist. This way we can simulate older MAAS
+			// servers that do not support subnets.
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		if r.URL.Path == subnetsURL {
+			var subnets []Subnet
+			for i := uint(1); i < server.nextSubnet; i++ {
+				s, ok := server.subnets[i]
+				if ok {
+					subnets = append(subnets, s)
+				}
+			}
+			err = json.NewEncoder(w).Encode(subnets)
+		} else if gotID == false {
+			w.WriteHeader(http.StatusBadRequest)
+		} else {
+			switch op {
+			case "unreserved_ip_ranges":
+				err = json.NewEncoder(w).Encode(
+					server.subnetUnreservedIPRanges(server.subnets[ID]))
+			case "reserved_ip_ranges":
+				err = json.NewEncoder(w).Encode(
+					server.subnetReservedIPRanges(server.subnets[ID]))
+			case "statistics":
+				err = json.NewEncoder(w).Encode(
+					server.subnetStatistics(server.subnets[ID], includeRanges))
+			default:
+				err = json.NewEncoder(w).Encode(server.subnets[ID])
+			}
+		}
+		checkError(err)
+	case "POST":
+		server.NewSubnet(r.Body)
+	case "PUT":
+		server.UpdateSubnet(r.Body)
+	case "DELETE":
+		delete(server.subnets, ID)
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.WriteHeader(http.StatusBadRequest)
+	}
+}
+
+type addressList []IP
+
+func (a addressList) Len() int           { return len(a) }
+func (a addressList) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a addressList) Less(i, j int) bool { return a[i].UInt64() < a[j].UInt64() }
+
+// AddressRange is used to generate reserved IP address range lists
+type AddressRange struct {
+	Start        string `json:"start"`
+	startUint    uint64
+	End          string `json:"end"`
+	endUint      uint64
+	Purpose      []string `json:"purpose,omitempty"`
+	NumAddresses uint     `json:"num_addresses"`
+}
+
+func (server *TestServer) subnetUnreservedIPRanges(subnet Subnet) []AddressRange {
+	// Make a sorted copy of subnet.InUseIPAddresses
+	ipAddresses := make([]IP, len(subnet.InUseIPAddresses))
+	copy(ipAddresses, subnet.InUseIPAddresses)
+	sort.Sort(addressList(ipAddresses))
+
+	// We need the first and last address in the subnet
+	var ranges []AddressRange
+	var i AddressRange
+	var startIP, endIP, lastUsableIP IP
+
+	_, ipNet, err := net.ParseCIDR(subnet.CIDR)
+	checkError(err)
+	startIP = IPFromNetIP(ipNet.IP)
+	// Start with the lowest usable address in the range, which is 1 above
+	// what net.ParseCIDR will give back.
+	startIP.SetUInt64(startIP.UInt64() + 1)
+
+	ones, bits := ipNet.Mask.Size()
+	set := ^((^uint64(0)) << uint(bits-ones))
+
+	// The last usable address is one below the broadcast address, which is
+	// what you get by bitwise ORing 'set' with any IP address in the subnet.
+	lastUsableIP.SetUInt64((startIP.UInt64() | set) - 1)
+
+	for _, endIP = range ipAddresses {
+		end := endIP.UInt64()
+
+		if endIP.UInt64() == startIP.UInt64() {
+			if endIP.UInt64() != lastUsableIP.UInt64() {
+				startIP.SetUInt64(end + 1)
+			}
+			continue
+		}
+
+		if end == lastUsableIP.UInt64() {
+			continue
+		}
+
+		endIP.SetUInt64(end - 1)
+		i.Start, i.End = startIP.String(), endIP.String()
+		i.startUint, i.endUint = startIP.UInt64(), endIP.UInt64()
+		i.NumAddresses = uint(1 + endIP.UInt64() - startIP.UInt64())
+		ranges = append(ranges, i)
+		startIP.SetUInt64(end + 1)
+	}
+
+	if startIP.UInt64() != lastUsableIP.UInt64() {
+		i.Start, i.End = startIP.String(), lastUsableIP.String()
+		i.startUint, i.endUint = startIP.UInt64(), lastUsableIP.UInt64()
+		i.NumAddresses = uint(1 + lastUsableIP.UInt64() - startIP.UInt64())
+		ranges = append(ranges, i)
+	}
+
+	return ranges
+}
+
+func (server *TestServer) subnetReservedIPRanges(subnet Subnet) []AddressRange {
+	// Make a sorted copy of subnet.InUseIPAddresses
+	ipAddresses := make([]IP, len(subnet.InUseIPAddresses))
+	copy(ipAddresses, subnet.InUseIPAddresses)
+	sort.Sort(addressList(ipAddresses))
+
+	var ranges []AddressRange
+	var i AddressRange
+	var startIP, thisIP IP
+	startIP = ipAddresses[0]
+	lastIP := ipAddresses[0].UInt64()
+
+	for _, thisIP = range ipAddresses {
+		ip := thisIP.UInt64()
+		if ip != lastIP && ip != lastIP+1 {
+			thisIP.SetUInt64(lastIP)
+			i.Start, i.End = startIP.String(), thisIP.String()
+			i.startUint, i.endUint = startIP.UInt64(), thisIP.UInt64()
+			i.NumAddresses = uint(1 + thisIP.UInt64() - startIP.UInt64())
+			ranges = append(ranges, i)
+			startIP.SetUInt64(ip)
+		}
+		lastIP = ip
+	}
+	if ranges[len(ranges)-1].endUint != lastIP {
+		thisIP.SetUInt64(lastIP)
+		i.Start, i.End = startIP.String(), thisIP.String()
+		i.startUint, i.endUint = startIP.UInt64(), thisIP.UInt64()
+		i.NumAddresses = uint(1 + thisIP.UInt64() - startIP.UInt64())
+		ranges = append(ranges, i)
+	}
+
+	return ranges
+}
+
+// SubnetStats holds statistics about a subnet
+type SubnetStats struct {
+	NumAvailable     uint           `json:"num_available"`
+	LargestAvailable uint           `json:"largest_available"`
+	NumUnavailable   uint           `json:"num_unavailable"`
+	TotalAddresses   uint           `json:"total_addresses"`
+	Usage            float32        `json:"usage"`
+	UsageString      string         `json:"usage_string"`
+	Ranges           []AddressRange `json:"ranges"`
+}
+
+func (server *TestServer) subnetStatistics(subnet Subnet, includeRanges bool) SubnetStats {
+	var stats SubnetStats
+	_, ipNet, err := net.ParseCIDR(subnet.CIDR)
+	checkError(err)
+
+	ones, bits := ipNet.Mask.Size()
+	stats.TotalAddresses = (1 << uint(bits-ones)) - 2
+	stats.NumUnavailable = uint(len(subnet.InUseIPAddresses))
+	stats.NumAvailable = stats.TotalAddresses - stats.NumUnavailable
+	stats.Usage = float32(stats.NumUnavailable) / float32(stats.TotalAddresses)
+	stats.UsageString = fmt.Sprintf("%0.1f%%", stats.Usage*100)
+
+	// Calculate stats.LargestAvailable - the largest contiguous block of IP addresses available
+	reserved := server.subnetUnreservedIPRanges(subnet)
+	for _, addressRange := range reserved {
+		if addressRange.NumAddresses > stats.LargestAvailable {
+			stats.LargestAvailable = addressRange.NumAddresses
+		}
+	}
+
+	if includeRanges {
+		stats.Ranges = reserved
+	}
+
+	return stats
+}
+
+func decodePostedSubnet(subnetJSON io.Reader) CreateSubnet {
+	var postedSubnet CreateSubnet
+	decoder := json.NewDecoder(subnetJSON)
+	err := decoder.Decode(&postedSubnet)
+	checkError(err)
+	return postedSubnet
+}
+
+// UpdateSubnet creates a subnet in the test server
+func (server *TestServer) UpdateSubnet(subnetJSON io.Reader) Subnet {
+	postedSubnet := decodePostedSubnet(subnetJSON)
+	updatedSubnet := subnetFromCreateSubnet(postedSubnet)
+	server.subnets[updatedSubnet.ID] = updatedSubnet
+	return updatedSubnet
+}
+
+// NewSubnet creates a subnet in the test server
+func (server *TestServer) NewSubnet(subnetJSON io.Reader) *Subnet {
+	postedSubnet := decodePostedSubnet(subnetJSON)
+	newSubnet := subnetFromCreateSubnet(postedSubnet)
+	newSubnet.ID = server.nextSubnet
+	server.subnets[server.nextSubnet] = newSubnet
+	server.subnetNameToID[newSubnet.Name] = newSubnet.ID
+
+	server.nextSubnet++
+	return &newSubnet
+}
+
+// NodeNetworkInterface represents a network interface attached to a node
+type NodeNetworkInterface struct {
+	Name  string        `json:"name"`
+	Links []NetworkLink `json:"links"`
+}
+
+// Node represents a node
+type Node struct {
+	SystemID   string                 `json:"system_id"`
+	Interfaces []NodeNetworkInterface `json:"interface_set"`
+}
+
+// NetworkLink represents a MAAS network link
+type NetworkLink struct {
+	ID     uint    `json:"id"`
+	Mode   string  `json:"mode"`
+	Subnet *Subnet `json:"subnet"`
+}
+
+// SetNodeNetworkLink recordds that the given node + interface are in subnet
+func (server *TestServer) SetNodeNetworkLink(node Node, nodeNetworkInterface NodeNetworkInterface) {
+	for i, ni := range server.nodeMetadata[node.SystemID].Interfaces {
+		if ni.Name == nodeNetworkInterface.Name {
+			server.nodeMetadata[node.SystemID].Interfaces[i] = nodeNetworkInterface
+			return
+		}
+	}
+	n := server.nodeMetadata[node.SystemID]
+	n.Interfaces = append(n.Interfaces, nodeNetworkInterface)
+	server.nodeMetadata[node.SystemID] = n
+}
+
+// subnetFromCreateSubnet creates a subnet in the test server
+func subnetFromCreateSubnet(postedSubnet CreateSubnet) Subnet {
+	var newSubnet Subnet
+	newSubnet.DNSServers = postedSubnet.DNSServers
+	newSubnet.Name = postedSubnet.Name
+	newSubnet.Space = postedSubnet.Space
+	//TODO: newSubnet.VLAN = server.postedSubnetVLAN
+	newSubnet.GatewayIP = postedSubnet.GatewayIP
+	newSubnet.CIDR = postedSubnet.CIDR
+	newSubnet.ID = postedSubnet.ID
+	return newSubnet
+}

=== modified file 'testservice_test.go'
--- testservice_test.go	2015-07-02 16:05:11 +0000
+++ testservice_test.go	2015-11-23 15:55:40 +0000
@@ -9,10 +9,13 @@
 	"encoding/json"
 	"fmt"
 	"io"
+	"math/rand"
 	"mime/multipart"
+	"net"
 	"net/http"
 	"net/url"
 	"sort"
+	"strconv"
 	"strings"
 
 	"gopkg.in/mgo.v2/bson"
@@ -603,6 +606,315 @@
 	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
 }
 
+func defaultSubnet() CreateSubnet {
+	var s CreateSubnet
+	s.DNSServers = []string{"192.168.1.2"}
+	s.Name = "maas-eth0"
+	s.Space = "space-0"
+	s.GatewayIP = "192.168.1.1"
+	s.CIDR = "192.168.1.0/24"
+	s.ID = 1
+	return s
+}
+
+func (suite *TestServerSuite) subnetJSON(subnet CreateSubnet) *bytes.Buffer {
+	var out bytes.Buffer
+	err := json.NewEncoder(&out).Encode(subnet)
+	if err != nil {
+		panic(err)
+	}
+	return &out
+}
+
+func (suite *TestServerSuite) subnetURL(ID int) string {
+	return suite.subnetsURL() + strconv.Itoa(ID) + "/"
+}
+
+func (suite *TestServerSuite) subnetsURL() string {
+	return suite.server.Server.URL + getSubnetsEndpoint(suite.server.version)
+}
+
+func (suite *TestServerSuite) getSubnets(c *C) []Subnet {
+	resp, err := http.Get(suite.subnetsURL())
+
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusOK)
+
+	var subnets []Subnet
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&subnets)
+	c.Check(err, IsNil)
+	return subnets
+}
+
+func (suite *TestServerSuite) TestSubnetAdd(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	s := subnets[0]
+	c.Check(s.DNSServers, DeepEquals, []string{"192.168.1.2"})
+	c.Check(s.Name, Equals, "maas-eth0")
+	c.Check(s.Space, Equals, "space-0")
+	c.Check(s.VLAN.ID, Equals, uint(0))
+	c.Check(s.CIDR, Equals, "192.168.1.0/24")
+}
+
+func (suite *TestServerSuite) TestSubnetGet(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	subnet2 := defaultSubnet()
+	subnet2.Name = "maas-eth1"
+	subnet2.CIDR = "192.168.2.0/24"
+	suite.server.NewSubnet(suite.subnetJSON(subnet2))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 2)
+	c.Check(subnets[0].CIDR, Equals, "192.168.1.0/24")
+	c.Check(subnets[1].CIDR, Equals, "192.168.2.0/24")
+}
+
+func (suite *TestServerSuite) TestSubnetPut(c *C) {
+	subnet1 := defaultSubnet()
+	suite.server.NewSubnet(suite.subnetJSON(subnet1))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	c.Check(subnets[0].DNSServers, DeepEquals, []string{"192.168.1.2"})
+
+	subnet1.DNSServers = []string{"192.168.1.2", "192.168.1.3"}
+	suite.server.UpdateSubnet(suite.subnetJSON(subnet1))
+
+	subnets = suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	c.Check(subnets[0].DNSServers, DeepEquals, []string{"192.168.1.2", "192.168.1.3"})
+}
+
+func (suite *TestServerSuite) TestSubnetDelete(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	c.Check(subnets[0].DNSServers, DeepEquals, []string{"192.168.1.2"})
+
+	req, err := http.NewRequest("DELETE", suite.subnetURL(1), nil)
+	c.Check(err, IsNil)
+	resp, err := http.DefaultClient.Do(req)
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusOK)
+
+	resp, err = http.Get(suite.subnetsURL())
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
+}
+
+func (suite *TestServerSuite) reserveSomeAddresses() map[int]bool {
+	reserved := make(map[int]bool)
+	rand.Seed(6)
+
+	// Insert some random test data
+	for i := 0; i < 200; i++ {
+		r := rand.Intn(253) + 1
+		_, ok := reserved[r]
+		for ok == true {
+			r++
+			if r == 255 {
+				r = 1
+			}
+			_, ok = reserved[r]
+		}
+		reserved[r] = true
+		addr := fmt.Sprintf("192.168.1.%d", r)
+		suite.server.NewIPAddress(addr, "maas-eth0")
+	}
+
+	return reserved
+}
+
+func (suite *TestServerSuite) TestSubnetReservedIPRanges(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+	reserved := suite.reserveSomeAddresses()
+
+	// Fetch from the server
+	reservedIPRangeURL := suite.subnetURL(1) + "?op=reserved_ip_ranges"
+	resp, err := http.Get(reservedIPRangeURL)
+	c.Check(err, IsNil)
+
+	var reservedFromAPI []AddressRange
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&reservedFromAPI)
+	c.Check(err, IsNil)
+
+	// Check that anything in a reserved range was an address we allocated
+	// with NewIPAddress
+	for _, addressRange := range reservedFromAPI {
+		var start, end int
+		fmt.Sscanf(addressRange.Start, "192.168.1.%d", &start)
+		fmt.Sscanf(addressRange.End, "192.168.1.%d", &end)
+		c.Check(addressRange.NumAddresses, Equals, uint(1+end-start))
+		c.Check(start <= end, Equals, true)
+		c.Check(start < 255, Equals, true)
+		c.Check(end < 255, Equals, true)
+		for i := start; i <= end; i++ {
+			_, ok := reserved[int(i)]
+			c.Check(ok, Equals, true)
+			delete(reserved, int(i))
+		}
+	}
+	c.Check(reserved, HasLen, 0)
+}
+
+func (suite *TestServerSuite) TestSubnetUnreservedIPRanges(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+	reserved := suite.reserveSomeAddresses()
+	unreserved := make(map[int]bool)
+
+	// Fetch from the server
+	reservedIPRangeURL := suite.subnetURL(1) + "?op=unreserved_ip_ranges"
+	resp, err := http.Get(reservedIPRangeURL)
+	c.Check(err, IsNil)
+
+	var unreservedFromAPI []AddressRange
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&unreservedFromAPI)
+	c.Check(err, IsNil)
+
+	// Check that anything in an unreserved range wasn't an address we allocated
+	// with NewIPAddress
+	for _, addressRange := range unreservedFromAPI {
+		var start, end int
+		fmt.Sscanf(addressRange.Start, "192.168.1.%d", &start)
+		fmt.Sscanf(addressRange.End, "192.168.1.%d", &end)
+		c.Check(addressRange.NumAddresses, Equals, uint(1+end-start))
+		c.Check(start <= end, Equals, true)
+		c.Check(start < 255, Equals, true)
+		c.Check(end < 255, Equals, true)
+		for i := start; i <= end; i++ {
+			_, ok := reserved[int(i)]
+			c.Check(ok, Equals, false)
+			unreserved[int(i)] = true
+		}
+	}
+	for i := 1; i < 255; i++ {
+		_, r := reserved[i]
+		_, u := unreserved[i]
+		if (r || u) == false {
+			fmt.Println(i, r, u)
+		}
+		c.Check(r || u, Equals, true)
+	}
+	c.Check(len(reserved)+len(unreserved), Equals, 254)
+}
+
+func (suite *TestServerSuite) getSubnetStats(c *C, subnetID int) SubnetStats {
+	URL := suite.subnetURL(1) + "?op=statistics"
+	resp, err := http.Get(URL)
+	c.Check(err, IsNil)
+
+	var s SubnetStats
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&s)
+	c.Check(err, IsNil)
+	return s
+}
+
+func (suite *TestServerSuite) TestSubnetStats(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	stats := suite.getSubnetStats(c, 1)
+	// There are 254 usable addresses in a class C subnet, so these
+	// stats are fixed
+	expected := SubnetStats{
+		NumAvailable:     254,
+		LargestAvailable: 254,
+		NumUnavailable:   0,
+		TotalAddresses:   254,
+		Usage:            0,
+		UsageString:      "0.0%",
+		Ranges:           nil,
+	}
+	c.Check(stats, DeepEquals, expected)
+
+	suite.reserveSomeAddresses()
+	stats = suite.getSubnetStats(c, 1)
+	// We have reserved 200 addresses so parts of these
+	// stats are fixed.
+	expected = SubnetStats{
+		NumAvailable:   54,
+		NumUnavailable: 200,
+		TotalAddresses: 254,
+		Usage:          0.787401556968689,
+		UsageString:    "78.7%",
+		Ranges:         nil,
+	}
+
+	reserved := suite.server.subnetUnreservedIPRanges(suite.server.subnets[1])
+	var largestAvailable uint
+	for _, addressRange := range reserved {
+		if addressRange.NumAddresses > largestAvailable {
+			largestAvailable = addressRange.NumAddresses
+		}
+	}
+
+	expected.LargestAvailable = largestAvailable
+	c.Check(stats, DeepEquals, expected)
+}
+
+func (suite *TestServerSuite) TestSubnetsInNodes(c *C) {
+	// Create a subnet
+	subnet := suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	// Create a node
+	var node Node
+	node.SystemID = "node-89d832ca-8877-11e5-b5a5-00163e86022b"
+	suite.server.NewNode(fmt.Sprintf(`{"system_id": "%s"}`, "node-89d832ca-8877-11e5-b5a5-00163e86022b"))
+
+	// Put the node in the subnet
+	var nni NodeNetworkInterface
+	nni.Name = "eth0"
+	nni.Links = append(nni.Links, NetworkLink{uint(1), "auto", subnet})
+	suite.server.SetNodeNetworkLink(node, nni)
+
+	// Fetch the node details
+	URL := suite.server.Server.URL + getNodesEndpoint(suite.server.version) + node.SystemID + "/"
+	resp, err := http.Get(URL)
+	c.Check(err, IsNil)
+
+	var n Node
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&n)
+	c.Check(err, IsNil)
+	c.Check(n.SystemID, Equals, node.SystemID)
+	c.Check(n.Interfaces, HasLen, 1)
+	i := n.Interfaces[0]
+	c.Check(i.Name, Equals, "eth0")
+	c.Check(i.Links, HasLen, 1)
+	c.Check(i.Links[0].ID, Equals, uint(1))
+	c.Check(i.Links[0].Subnet.Name, Equals, "maas-eth0")
+}
+
+type IPSuite struct {
+}
+
+var _ = Suite(&IPSuite{})
+
+func (suite *IPSuite) TestIPFromNetIP(c *C) {
+	ip := IPFromNetIP(net.ParseIP("1.2.3.4"))
+	c.Check(ip.String(), Equals, "1.2.3.4")
+}
+
+func (suite *IPSuite) TestIPUInt64(c *C) {
+	ip := IPFromNetIP(net.ParseIP("1.2.3.4"))
+	v := ip.UInt64()
+	c.Check(v, Equals, uint64(0x01020304))
+}
+
+func (suite *IPSuite) TestIPSetUInt64(c *C) {
+	var ip IP
+	ip.SetUInt64(0x01020304)
+	c.Check(ip.String(), Equals, "1.2.3.4")
+}
+
 // TestMAASObjectSuite validates that the object created by
 // NewTestMAAS can be used by the gomaasapi library as if it were a real
 // MAAS server.
@@ -612,16 +924,16 @@
 
 var _ = Suite(&TestMAASObjectSuite{})
 
-func (s *TestMAASObjectSuite) SetUpSuite(c *C) {
-	s.TestMAASObject = NewTestMAAS("1.0")
-}
-
-func (s *TestMAASObjectSuite) TearDownSuite(c *C) {
-	s.TestMAASObject.Close()
-}
-
-func (s *TestMAASObjectSuite) TearDownTest(c *C) {
-	s.TestMAASObject.TestServer.Clear()
+func (suite *TestMAASObjectSuite) SetUpSuite(c *C) {
+	suite.TestMAASObject = NewTestMAAS("1.0")
+}
+
+func (suite *TestMAASObjectSuite) TearDownSuite(c *C) {
+	suite.TestMAASObject.Close()
+}
+
+func (suite *TestMAASObjectSuite) TearDownTest(c *C) {
+	suite.TestMAASObject.TestServer.Clear()
 }
 
 func (suite *TestMAASObjectSuite) TestListNodes(c *C) {
@@ -1019,6 +1331,8 @@
 		switch capName {
 		case "networks-management":
 		case "static-ipaddresses":
+		case "devices-management":
+		case "network-deployment-ubuntu":
 		default:
 			c.Fatalf("unknown capability %q", capName)
 		}

=== added file 'testservice_utils.go'
--- testservice_utils.go	1970-01-01 00:00:00 +0000
+++ testservice_utils.go	2015-11-23 15:55:40 +0000
@@ -0,0 +1,105 @@
+// Copyright 2015 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"net"
+	"strconv"
+)
+
+// NameOrIDToID takes a string that contains eiter an integer ID or the
+// name of a thing. It returns the integer ID contained or mapped to or panics.
+func NameOrIDToID(v string, nameToID map[string]uint, minID, maxID uint) (ID uint, err error) {
+	ID, ok := nameToID[v]
+	if !ok {
+		intID, err := strconv.Atoi(v)
+		if err != nil {
+			return 0, err
+		}
+		ID = uint(intID)
+	}
+
+	if ID < minID || ID > maxID {
+		return 0, errors.New("ID out of range")
+	}
+
+	return ID, nil
+}
+
+// IP is an enhanced net.IP
+type IP struct {
+	netIP net.IP
+}
+
+// IPFromNetIP creates a IP from a net.IP.
+func IPFromNetIP(netIP net.IP) IP {
+	var ip IP
+	ip.netIP = netIP
+	return ip
+}
+
+// To4 converts the IPv4 address ip to a 4-byte representation. If ip is not
+// an IPv4 address, To4 returns nil.
+func (ip IP) To4() net.IP {
+	return ip.netIP.To4()
+}
+
+// To16 converts the IP address ip to a 16-byte representation. If ip is not
+// an IP address (it is the wrong length), To16 returns nil.
+func (ip IP) To16() net.IP {
+	return ip.netIP.To16()
+}
+
+func (ip IP) String() string {
+	return ip.netIP.String()
+}
+
+// UInt64 returns a uint64 holding the IP address
+func (ip IP) UInt64() uint64 {
+	if len(ip.netIP) == 0 {
+		return uint64(0)
+	}
+
+	var bb *bytes.Reader
+	if ip.To4() != nil {
+		var v uint32
+		bb = bytes.NewReader(ip.To4())
+		err := binary.Read(bb, binary.BigEndian, &v)
+		checkError(err)
+		return uint64(v)
+	}
+
+	var v uint64
+	bb = bytes.NewReader(ip.To16())
+	err := binary.Read(bb, binary.BigEndian, &v)
+	checkError(err)
+	return v
+}
+
+// SetUInt64 sets the IP value to v
+func (ip *IP) SetUInt64(v uint64) {
+	if len(ip.netIP) == 0 {
+		// If we don't have allocated storage make an educated guess
+		// at if the address we received is an IPv4 or IPv6 address.
+		if v == (v & 0x00000000ffffFFFF) {
+			// Guessing IPv4
+			ip.netIP = net.ParseIP("0.0.0.0")
+		} else {
+			ip.netIP = net.ParseIP("2001:4860:0:2001::68")
+		}
+	}
+
+	bb := new(bytes.Buffer)
+	var first int
+	if ip.To4() != nil {
+		binary.Write(bb, binary.BigEndian, uint32(v))
+		first = len(ip.netIP) - 4
+	} else {
+		binary.Write(bb, binary.BigEndian, v)
+	}
+	copy(ip.netIP[first:], bb.Bytes())
+}

=== added file 'testservice_vlan.go'
--- testservice_vlan.go	1970-01-01 00:00:00 +0000
+++ testservice_vlan.go	2015-11-23 15:55:40 +0000
@@ -0,0 +1,33 @@
+// Copyright 2015 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func getVLANsEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/vlans/", version)
+}
+
+// VLAN is the MAAS API VLAN representation
+type VLAN struct {
+	Name   string `json:"name"`
+	Fabric string `json:"fabric"`
+	VID    uint   `json:"vid"`
+
+	ResourceURI string `json:"resource_uri"`
+	ID          uint   `json:"id"`
+}
+
+// PostedVLAN is the MAAS API posted VLAN representation
+type PostedVLAN struct {
+	Name string `json:"name"`
+	VID  uint   `json:"vid"`
+}
+
+func vlansHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	//TODO
+}