Merge lp:~blake-rouse/maas/fix-1441841 into lp:~maas-committers/maas/trunk

[Blake Rouse]

Fix the validation in AddDeviceController, to check that the ip address in the static range is not within the dynamic range. Modify the StaticIPAddress.allocate_new to validate that the requested_address is inside the network, instead of the static range.

This allows users to add a static ip address anywhere in the selected network except for the dynamic range.

[Andres Rodriguez (andreserl)]

Except for the static range? or except for the dynamic range?

review: Needs Information

[Blake Rouse (blake-rouse)]

Sorry meant dynamic range. Fixed commit message.

[Blake Rouse (blake-rouse)]

This required a fix in the backend not just the frontend. This now allows a requested_address to be anywhere in the network, not just within the static range.

[Raphaël Badin (rvb)]

Looks good. Can you please add an API test where the requested IP is *not* in the static range (nor in the dynamic range)?

review: Approve

[Blake Rouse (blake-rouse)]

I added that test. While doing so I noticed that I was not actually validating that the requested_address was not inside the dynamic range. I added that logic and tests as well.

=== modified file 'src/maasserver/api/ip_addresses.py'
--- src/maasserver/api/ip_addresses.py	2015-04-17 08:32:15 +0000
+++ src/maasserver/api/ip_addresses.py	2015-04-23 19:17:12 +0000
@@ -81,12 +81,14 @@
         """
         if mac is None:
             sip = StaticIPAddress.objects.allocate_new(
-                range_low=interface.static_ip_range_low,
-                range_high=interface.static_ip_range_high,
+                network=interface.network,
+                static_range_low=interface.static_ip_range_low,
+                static_range_high=interface.static_ip_range_high,
+                dynamic_range_low=interface.ip_range_low,
+                dynamic_range_high=interface.ip_range_high,
                 alloc_type=IPADDRESS_TYPE.USER_RESERVED,
                 requested_address=requested_address,
                 user=user, hostname=hostname)
-            commit_within_atomic_block()
             maaslog.info("User %s was allocated IP %s", user.username, sip.ip)
         else:
             # The user has requested a static IP linked to a MAC
 
=== modified file 'src/maasserver/api/tests/test_ipaddresses.py'
--- src/maasserver/api/tests/test_ipaddresses.py	2015-04-17 07:26:25 +0000
+++ src/maasserver/api/tests/test_ipaddresses.py	2015-04-23 19:17:12 +0000
@@ -213,6 +213,25 @@
         self.expectThat(returned_address["ip"], Equals(ip_in_network))
         self.expectThat(staticipaddress.ip, Equals(ip_in_network))
 
+    def test_POST_reserve_creates_address_outside_of_static_range(self):
+        interface = self.make_interface()
+        interface.ip_range_high = unicode(
+            IPAddress(interface.ip_range_high) - 1)
+        interface.save()
+        net = interface.network
+        ip_in_network = unicode(
+            IPAddress(interface.ip_range_high) + 1)
+        response = self.post_reservation_request(
+            net=net, requested_address=ip_in_network)
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        returned_address = json.loads(response.content)
+        [staticipaddress] = StaticIPAddress.objects.all()
+        self.expectThat(
+            returned_address["alloc_type"],
+            Equals(IPADDRESS_TYPE.USER_RESERVED))
+        self.expectThat(returned_address["ip"], Equals(ip_in_network))
+        self.expectThat(staticipaddress.ip, Equals(ip_in_network))
+
     def test_POST_reserve_requested_address_detects_in_use_address(self):
         interface = self.make_interface()
         net = interface.network
@@ -227,13 +246,11 @@
             response.content, Equals(
                 "The IP address %s is already in use." % ip_in_network))
 
-    def test_POST_reserve_requested_address_detects_out_of_range_addr(self):
+    def test_POST_reserve_requested_address_rejects_ip_in_dynamic_range(self):
         interface = self.make_interface()
         net = interface.network
-        ip_not_in_network = unicode(
-            IPAddress(interface.static_ip_range_low) - 1)
-        response = self.post_reservation_request(
-            net=net, requested_address=ip_not_in_network)
+        ip_in_network = interface.ip_range_low
+        response = self.post_reservation_request(net, ip_in_network)
         self.assertEqual(
             httplib.FORBIDDEN, response.status_code, response.content)
 
 
=== modified file 'src/maasserver/api/tests/test_node.py'
--- src/maasserver/api/tests/test_node.py	2015-04-17 08:36:07 +0000
+++ src/maasserver/api/tests/test_node.py	2015-04-23 19:17:12 +0000
@@ -1208,11 +1208,12 @@
         [observed_static_ip] = StaticIPAddress.objects.all()
         self.assertEqual(observed_static_ip.ip, requested_address)
 
-    def test_claim_sticky_ip_address_detects_out_of_range_requested_ip(self):
+    def test_claim_sticky_ip_address_detects_out_of_network_requested_ip(self):
         self.become_admin()
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
         ngi = node.get_primary_mac().cluster_interface
-        requested_address = IPAddress(ngi.static_ip_range_low) - 1
+        other_network = factory.make_ipv4_network(but_not=ngi.network)
+        requested_address = factory.pick_ip_in_network(other_network)
 
         response = self.client.post(
             self.get_node_uri(node),
@@ -1265,7 +1266,8 @@
         ngi.save()
         with transaction.atomic():
             StaticIPAddress.objects.allocate_new(
-                ngi.static_ip_range_high, ngi.static_ip_range_low)
+                ngi.network, ngi.static_ip_range_low, ngi.static_ip_range_high,
+                ngi.ip_range_low, ngi.ip_range_high)
 
         response = self.client.post(
             TestNodeAPI.get_node_uri(node), {'op': 'start'})
 
=== modified file 'src/maasserver/models/macaddress.py'
--- src/maasserver/models/macaddress.py	2015-04-08 20:14:03 +0000
+++ src/maasserver/models/macaddress.py	2015-04-23 19:17:12 +0000
@@ -238,8 +238,11 @@
             )
 
         new_sip = StaticIPAddress.objects.allocate_new(
+            cluster_interface.network,
             cluster_interface.static_ip_range_low,
             cluster_interface.static_ip_range_high,
+            cluster_interface.ip_range_low,
+            cluster_interface.ip_range_high,
             alloc_type, requested_address=requested_address,
             user=user)
         MACStaticIPAddressLink(mac_address=self, ip_address=new_sip).save()
 
=== modified file 'src/maasserver/models/staticipaddress.py'
--- src/maasserver/models/staticipaddress.py	2015-04-16 12:15:52 +0000
+++ src/maasserver/models/staticipaddress.py	2015-04-23 19:17:12 +0000
@@ -131,13 +131,24 @@
             ipaddress.save()
             return ipaddress
 
-    def allocate_new(self, range_low, range_high,
-                     alloc_type=IPADDRESS_TYPE.AUTO, user=None,
-                     requested_address=None, hostname=None):
+    def allocate_new(
+            self, network, static_range_low, static_range_high,
+            dynamic_range_low, dynamic_range_high,
+            alloc_type=IPADDRESS_TYPE.AUTO, user=None,
+            requested_address=None, hostname=None):
         """Return a new StaticIPAddress.
 
-        :param range_low: The lowest address to allocate in a range
-        :param range_high: The highest address to allocate in a range
+        :param network: The network the address should be allocated in.
+        :param static_range_low: The lowest static address to allocate in a
+            range. Used if `requested_address` is not passed.
+        :param static_range_high: The highest static address to allocate in a
+            range. Used if `requested_address` is not passed.
+        :param dynamic_range_low: The lowest dynamic address. Used if
+            `requested_address` is passed, check that its not inside the
+            dynamic range.
+        :param dynamic_range_high: The highest dynamic address. Used if
+            `requested_address` is passed, check that its not inside the
+            dynamic range.
         :param alloc_type: What sort of IP address to allocate in the
             range of choice in IPADDRESS_TYPE.
         :param user: If providing a user, the alloc_type must be
@@ -157,15 +168,15 @@
         # taken, and so we must first eliminate all other possible causes.
         self._verify_alloc_type(alloc_type, user)
 
-        range_low = IPAddress(range_low)
-        range_high = IPAddress(range_high)
-        static_range = IPRange(range_low, range_high)
-
         if requested_address is None:
+            static_range_low = IPAddress(static_range_low)
+            static_range_high = IPAddress(static_range_high)
+            static_range = IPRange(static_range_low, static_range_high)
+
             with locks.staticip_acquire:
                 requested_address = self._async_find_free_ip(
-                    range_low, range_high, static_range, alloc_type, user,
-                    hostname=hostname).wait(30)
+                    static_range_low, static_range_high, static_range,
+                    alloc_type, user, hostname=hostname).wait(30)
                 try:
                     return self._attempt_allocation(
                         requested_address, alloc_type, user,
@@ -176,12 +187,20 @@
                     # let the retry mechanism do its thing.
                     raise make_serialization_failure()
         else:
+            dynamic_range_low = IPAddress(dynamic_range_low)
+            dynamic_range_high = IPAddress(dynamic_range_high)
+            dynamic_range = IPRange(dynamic_range_low, dynamic_range_high)
+
             requested_address = IPAddress(requested_address)
-            if requested_address not in static_range:
-                raise StaticIPAddressOutOfRange(
-                    "%s is not inside the range %s to %s" % (
-                        requested_address.format(), range_low.format(),
-                        range_high.format()))
+            if requested_address not in network:
+                raise StaticIPAddressOutOfRange(
+                    "%s is not inside the network %s" % (
+                        requested_address.format(), network))
+            if requested_address in dynamic_range:
+                raise StaticIPAddressOutOfRange(
+                    "%s is inside the dynamic range %s to %s" % (
+                        requested_address.format(), dynamic_range_low.format(),
+                        dynamic_range_high.format()))
             return self._attempt_allocation(
                 requested_address, alloc_type, user=user, hostname=hostname)
 
 
=== modified file 'src/maasserver/models/tests/test_staticipaddress.py'
--- src/maasserver/models/tests/test_staticipaddress.py	2015-04-16 12:30:02 +0000
+++ src/maasserver/models/tests/test_staticipaddress.py	2015-04-23 19:17:12 +0000
@@ -48,108 +48,164 @@
 
 class TestStaticIPAddressManager(MAASServerTestCase):
 
+    def make_ip_ranges(self, network=None):
+        interface = factory.make_NodeGroupInterface(
+            factory.make_NodeGroup(), network=network)
+        return (
+            interface.network,
+            interface.static_ip_range_low,
+            interface.static_ip_range_high,
+            interface.ip_range_low,
+            interface.ip_range_low,
+        )
+
     def test_allocate_new_returns_ip_in_correct_range(self):
-        low, high = factory.make_ip_range()
-        ipaddress = StaticIPAddress.objects.allocate_new(low, high)
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
+        ipaddress = StaticIPAddress.objects.allocate_new(
+            network, static_low, static_high, dynamic_low, dynamic_high)
         self.assertIsInstance(ipaddress, StaticIPAddress)
-        iprange = IPRange(low, high)
+        iprange = IPRange(static_low, static_high)
         self.assertIn(IPAddress(ipaddress.ip), iprange)
 
     def test_allocate_new_allocates_IPv6_address(self):
-        low, high = factory.make_ipv6_range()
-        ipaddress = StaticIPAddress.objects.allocate_new(low, high)
+        network = factory.make_ipv6_network()
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges(network))
+        ipaddress = StaticIPAddress.objects.allocate_new(
+            network, static_low, static_high, dynamic_low, dynamic_high)
         self.assertIsInstance(ipaddress, StaticIPAddress)
-        self.assertIn(IPAddress(ipaddress.ip), IPRange(low, high))
+        self.assertIn(
+            IPAddress(ipaddress.ip), IPRange(static_low, static_high))
 
     def test_allocate_new_sets_user(self):
-        low, high = factory.make_ip_range()
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
         user = factory.make_User()
         ipaddress = StaticIPAddress.objects.allocate_new(
-            low, high, alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=user)
+            network, static_low, static_high, dynamic_low, dynamic_high,
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=user)
         self.assertEqual(user, ipaddress.user)
 
     def test_allocate_new_with_user_disallows_wrong_alloc_types(self):
-        low, high = factory.make_ip_range()
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
         user = factory.make_User()
         alloc_type = factory.pick_enum(
             IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED])
         self.assertRaises(
-            AssertionError, StaticIPAddress.objects.allocate_new, low, high,
+            AssertionError, StaticIPAddress.objects.allocate_new, network,
+            static_low, static_high, dynamic_low, dynamic_high,
             user=user, alloc_type=alloc_type)
 
     def test_allocate_new_with_reserved_type_requires_a_user(self):
-        low, high = factory.make_ip_range()
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
         self.assertRaises(
-            AssertionError, StaticIPAddress.objects.allocate_new, low, high,
+            AssertionError, StaticIPAddress.objects.allocate_new, network,
+            static_low, static_high, dynamic_low, dynamic_high,
             alloc_type=IPADDRESS_TYPE.USER_RESERVED)
 
     def test_allocate_new_compares_by_IP_not_alphabetically(self):
         # Django has a bug that casts IP addresses with HOST(), which
         # results in alphabetical comparisons of strings instead of IP
         # addresses.  See https://bugs.launchpad.net/maas/+bug/1338452
-        low = "10.0.0.98"
-        high = "10.0.0.100"
+        network = "10.0.0.0/8"
+        static_low = "10.0.0.98"
+        static_high = "10.0.0.100"
+        dynamic_low = "10.0.0.101"
+        dynamic_high = "10.0.0.105"
         factory.make_StaticIPAddress("10.0.0.99")
-        ipaddress = StaticIPAddress.objects.allocate_new(low, high)
+        ipaddress = StaticIPAddress.objects.allocate_new(
+            network, static_low, static_high, dynamic_low, dynamic_high)
         self.assertEqual(ipaddress.ip, "10.0.0.98")
 
     def test_allocate_new_returns_requested_IP_if_available(self):
-        low, high = factory.make_ip_range()
-        requested_address = low + 1
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
+        requested_address = unicode(IPAddress(static_low) + 1)
         ipaddress = StaticIPAddress.objects.allocate_new(
-            low, high, factory.pick_enum(
+            network, static_low, static_high, dynamic_low, dynamic_high,
+            factory.pick_enum(
                 IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED]),
             requested_address=requested_address)
         self.assertEqual(requested_address.format(), ipaddress.ip)
 
     def test_allocate_new_raises_when_requested_IP_unavailable(self):
-        low, high = factory.make_ip_range()
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
         requested_address = StaticIPAddress.objects.allocate_new(
-            low, high, factory.pick_enum(
+            network, static_low, static_high, dynamic_low, dynamic_high,
+            factory.pick_enum(
                 IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED])).ip
         self.assertRaises(
             StaticIPAddressUnavailable, StaticIPAddress.objects.allocate_new,
-            low, high, requested_address=requested_address)
+            network, static_low, static_high, dynamic_low, dynamic_high,
+            requested_address=requested_address)
 
     def test_allocate_new_raises_serialization_error_if_ip_taken(self):
-        low, high = factory.make_ip_range()
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
         # Simulate a "IP already taken" error.
         mock_attempt_allocation = self.patch(
             StaticIPAddress.objects, '_attempt_allocation')
         mock_attempt_allocation.side_effect = StaticIPAddressUnavailable()
 
         error = self.assertRaises(
-            Exception, StaticIPAddress.objects.allocate_new, low, high)
+            Exception, StaticIPAddress.objects.allocate_new,
+            network, static_low, static_high, dynamic_low, dynamic_high)
         self.assertTrue(is_serialization_failure(error))
 
     def test_allocate_new_does_not_use_lock_for_requested_ip(self):
         # When requesting a specific IP address, there's no need to
         # acquire the lock.
         lock = self.patch(locks, 'staticip_acquire')
-        low, high = factory.make_ip_range()
-        requested_address = low + 1
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
+        requested_address = unicode(IPAddress(static_low) + 1)
         ipaddress = StaticIPAddress.objects.allocate_new(
-            low, high, requested_address=requested_address)
+            network, static_low, static_high, dynamic_low, dynamic_high,
+            requested_address=requested_address)
         self.assertIsInstance(ipaddress, StaticIPAddress)
         self.assertThat(lock.__enter__, MockNotCalled())
 
-    def test_allocate_new_raises_when_requested_IP_out_of_range(self):
-        low, high = factory.make_ip_range()
-        requested_address = low - 1
-        e = self.assertRaises(
-            StaticIPAddressOutOfRange, StaticIPAddress.objects.allocate_new,
-            low, high, factory.pick_enum(
-                IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED]),
-            requested_address=requested_address)
-        self.assertEqual(
-            "%s is not inside the range %s to %s" % (
-                requested_address, low, high),
+    def test_allocate_new_raises_when_requested_IP_out_of_network(self):
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
+        other_network = factory.make_ipv4_network(but_not=network)
+        requested_address = factory.pick_ip_in_network(other_network)
+        e = self.assertRaises(
+            StaticIPAddressOutOfRange, StaticIPAddress.objects.allocate_new,
+            network, static_low, static_high, dynamic_low, dynamic_high,
+            factory.pick_enum(
+                IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED]),
+            requested_address=requested_address)
+        self.assertEqual(
+            "%s is not inside the network %s" % (
+                requested_address, network),
+            e.message)
+
+    def test_allocate_new_raises_when_requested_IP_in_dynamic_range(self):
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
+        requested_address = dynamic_low
+        e = self.assertRaises(
+            StaticIPAddressOutOfRange, StaticIPAddress.objects.allocate_new,
+            network, static_low, static_high, dynamic_low, dynamic_high,
+            factory.pick_enum(
+                IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED]),
+            requested_address=requested_address)
+        self.assertEqual(
+            "%s is inside the dynamic range %s to %s" % (
+                requested_address, dynamic_low, dynamic_high),
             e.message)
 
     def test_allocate_new_raises_when_alloc_type_is_None(self):
         error = self.assertRaises(
             ValueError, StaticIPAddress.objects.allocate_new,
-            sentinel.range_low, sentinel.range_high, alloc_type=None)
+            sentinel.network, sentinel.static_range_low,
+            sentinel.static_range_low, sentinel.dynamic_range_low,
+            sentinel.dynamic_range_high, alloc_type=None)
         self.assertEqual(
             "IP address type None is not a member of IPADDRESS_TYPE.",
             unicode(error))
@@ -157,15 +213,19 @@
     def test_allocate_new_raises_when_alloc_type_is_invalid(self):
         error = self.assertRaises(
             ValueError, StaticIPAddress.objects.allocate_new,
-            sentinel.range_low, sentinel.range_high, alloc_type=12345)
+            sentinel.network, sentinel.static_range_low,
+            sentinel.static_range_low, sentinel.dynamic_range_low,
+            sentinel.dynamic_range_high, alloc_type=12345)
         self.assertEqual(
             "IP address type 12345 is not a member of IPADDRESS_TYPE.",
             unicode(error))
 
     def test_allocate_new_uses_staticip_acquire_lock(self):
         lock = self.patch(locks, 'staticip_acquire')
-        low, high = factory.make_ip_range()
-        ipaddress = StaticIPAddress.objects.allocate_new(low, high)
+        network, static_low, static_high, dynamic_low, dynamic_high = (
+            self.make_ip_ranges())
+        ipaddress = StaticIPAddress.objects.allocate_new(
+            network, static_low, static_high, dynamic_low, dynamic_high)
         self.assertIsInstance(ipaddress, StaticIPAddress)
         self.assertThat(lock.__enter__, MockCalledOnceWith())
         self.assertThat(
@@ -273,15 +333,19 @@
     '''
 
     def test_allocate_new_raises_when_addresses_exhausted(self):
-        low = high = "192.168.230.1"
+        network = "192.168.230.0/24"
+        static_low = static_high = "192.168.230.1"
+        dynamic_low = dynamic_high = "192.168.230.2"
         with transaction.atomic():
-            StaticIPAddress.objects.allocate_new(low, high)
+            StaticIPAddress.objects.allocate_new(
+                network, static_low, static_high, dynamic_low, dynamic_high)
         with transaction.atomic():
             e = self.assertRaises(
                 StaticIPAddressExhaustion,
-                StaticIPAddress.objects.allocate_new, low, high)
+                StaticIPAddress.objects.allocate_new,
+                network, static_low, static_high, dynamic_low, dynamic_high)
         self.assertEqual(
-            "No more IPs available in range %s-%s" % (low, high),
+            "No more IPs available in range %s-%s" % (static_low, static_high),
             unicode(e))
 
 
 
=== modified file 'src/maasserver/static/js/angular/controllers/add_device.js'
--- src/maasserver/static/js/angular/controllers/add_device.js	2015-04-03 18:35:20 +0000
+++ src/maasserver/static/js/angular/controllers/add_device.js	2015-04-23 19:17:12 +0000
@@ -139,16 +139,16 @@
             if(!ValidationService.validateIP($scope.device.ipAddress)) {
                 return true;
             }
-            var i, inRange, managedInterfaces = $scope.getManagedInterfaces();
+            var i, inNetwork, managedInterfaces = $scope.getManagedInterfaces();
             if(angular.isObject($scope.device.ipAssignment)){
                 if($scope.device.ipAssignment.name === "external") {
                     // External IP address cannot be within a managed interface
                     // on one of the clusters.
                     for(i = 0; i < managedInterfaces.length; i++) {
-                        inRange = ValidationService.validateIPInRange(
+                        inNetwork = ValidationService.validateIPInNetwork(
                             $scope.device.ipAddress,
                             managedInterfaces[i].network);
-                        if(inRange) {
+                        if(inNetwork) {
                             return true;
                         }
                     }
@@ -158,9 +158,13 @@
                     // of the selected clusterInterface.
                     var clusterInterface = getInterfaceById(
                         $scope.device.clusterInterfaceId);
-                    inRange = ValidationService.validateIPInRange(
+                    inNetwork = ValidationService.validateIPInNetwork(
                         $scope.device.ipAddress, clusterInterface.network);
-                    if(!inRange) {
+                    var inDynamicRange = ValidationService.validateIPInRange(
+                        $scope.device.ipAddress, clusterInterface.network,
+                        clusterInterface.dynamic_range.low,
+                        clusterInterface.dynamic_range.high);
+                    if(!inNetwork || inDynamicRange) {
                         return true;
                     }
                 }
 
=== modified file 'src/maasserver/static/js/angular/controllers/tests/test_add_device.js'
--- src/maasserver/static/js/angular/controllers/tests/test_add_device.js	2015-04-03 18:35:20 +0000
+++ src/maasserver/static/js/angular/controllers/tests/test_add_device.js	2015-04-23 19:17:12 +0000
@@ -403,6 +403,19 @@
             };
             expect($scope.ipHasError()).toBe(true);
         });
+
+        it("returns true if static ip in dynamic range of network", function() {
+            var controller = makeController();
+            var nic = makeManagedClusterInterface();
+            var cluster = makeCluster([nic]);
+            $scope.clusters = [cluster];
+            $scope.device.ipAddress = nic.dynamic_range.low;
+            $scope.device.clusterInterfaceId = nic.id;
+            $scope.device.ipAssignment = {
+                name: "static"
+            };
+            expect($scope.ipHasError()).toBe(true);
+        });
     });
 
     describe("deviceHasError", function() {
 
=== modified file 'src/maasserver/static/js/angular/services/tests/test_validation.js'
--- src/maasserver/static/js/angular/services/tests/test_validation.js	2015-04-03 18:26:06 +0000
+++ src/maasserver/static/js/angular/services/tests/test_validation.js	2015-04-23 19:17:12 +0000
@@ -267,51 +267,200 @@
             });
     });
 
-    describe("validateIPInRange", function() {
+    describe("validateIPInNetwork", function() {
 
         var scenarios = [
             {
                 ip: "192.168.2.1",
-                range: "192.168.1.0/24",
+                network: "192.168.1.0/24",
                 valid: false
             },
             {
                 ip: "192.168.1.1",
-                range: "192.168.1.0/24",
+                network: "192.168.1.0/24",
                 valid: true
             },
             {
                 ip: "192.168.1.1",
-                range: "172.16.0.0/16",
+                network: "172.16.0.0/16",
                 valid: false
             },
             {
                 ip: "172.17.1.1",
-                range: "172.16.0.0/16",
+                network: "172.16.0.0/16",
                 valid: false
             },
             {
                 ip: "172.16.1.1",
-                range: "172.16.0.0/16",
+                network: "172.16.0.0/16",
                 valid: true
             },
             {
                 ip: "11.1.1.1",
-                range: "10.0.0.0/8",
+                network: "10.0.0.0/8",
                 valid: false
             },
             {
                 ip: "10.1.1.1",
-                range: "10.0.0.0/8",
-                valid: true
-            }
-        ];
-
-        angular.forEach(scenarios, function(scenario) {
-            it("validates: " + scenario.ip + " in range: " + scenario.range,
+                network: "10.0.0.0/8",
+                valid: true
+            },
+            {
+                ip: "2001:67C:1562::16",
+                network: "2001:67C:1562::0/32",
+                valid: true
+            },
+            {
+                ip: "2002:67C:1562::16",
+                network: "2001:67C:1562::0/32",
+                valid: false
+            },
+            {
+                ip: "2001:67C:1561::16",
+                network: "2001:67C:1562::0/64",
+                valid: false
+            }
+        ];
+
+        angular.forEach(scenarios, function(scenario) {
+            it("validates: " + scenario.ip + " in network: " + scenario.network,
+                function() {
+                    var result = ValidationService.validateIPInNetwork(
+                        scenario.ip, scenario.network);
+                    expect(result).toBe(scenario.valid);
+                });
+        });
+    });
+
+    describe("validateIPInRange", function() {
+
+        var scenarios = [
+            {
+                ip: "192.168.1.1",
+                network: "192.168.1.0/24",
+                range: {
+                    low: "192.168.1.2",
+                    high: "192.168.1.100"
+                },
+                valid: false
+            },
+            {
+                ip: "192.168.1.2",
+                network: "192.168.1.0/24",
+                range: {
+                    low: "192.168.1.2",
+                    high: "192.168.1.100"
+                },
+                valid: true
+            },
+            {
+                ip: "192.168.1.3",
+                network: "192.168.1.0/24",
+                range: {
+                    low: "192.168.1.2",
+                    high: "192.168.1.100"
+                },
+                valid: true
+            },
+            {
+                ip: "192.168.1.100",
+                network: "192.168.1.0/24",
+                range: {
+                    low: "192.168.1.2",
+                    high: "192.168.1.100"
+                },
+                valid: true
+            },
+            {
+                ip: "192.168.1.101",
+                network: "192.168.1.0/24",
+                range: {
+                    low: "192.168.1.2",
+                    high: "192.168.1.100"
+                },
+                valid: false
+            },
+            {
+                ip: "192.168.1.2",
+                network: "192.168.2.0/24",
+                range: {
+                    low: "192.168.2.2",
+                    high: "192.168.2.100"
+                },
+                valid: false
+            },
+            {
+                ip: "2001:67C:1562::1",
+                network: "2001:67C:1562::0/32",
+                range: {
+                    low: "2001:67C:1562::2",
+                    high: "2001:67C:1562::FFFF:FFFF"
+                },
+                valid: false
+            },
+            {
+                ip: "2001:67C:1562::2",
+                network: "2001:67C:1562::0/32",
+                range: {
+                    low: "2001:67C:1562::2",
+                    high: "2001:67C:1562::FFFF:FFFF"
+                },
+                valid: true
+            },
+            {
+                ip: "2001:67C:1562::3",
+                network: "2001:67C:1562::0/32",
+                range: {
+                    low: "2001:67C:1562::2",
+                    high: "2001:67C:1562::FFFF:FFFF"
+                },
+                valid: true
+            },
+            {
+                ip: "2001:67C:1562::FFFF:FFFE",
+                network: "2001:67C:1562::0/32",
+                range: {
+                    low: "2001:67C:1562::2",
+                    high: "2001:67C:1562::FFFF:FFFF"
+                },
+                valid: true
+            },
+            {
+                ip: "2001:67C:1562::FFFF:FFFF",
+                network: "2001:67C:1562::0/32",
+                range: {
+                    low: "2001:67C:1562::2",
+                    high: "2001:67C:1562::FFFF:FFFF"
+                },
+                valid: true
+            },
+            {
+                ip: "2001:67C:1562::1:0:0",
+                network: "2001:67C:1562::0/32",
+                range: {
+                    low: "2001:67C:1562::2",
+                    high: "2001:67C:1562::FFFF:FFFF"
+                },
+                valid: false
+            },
+            {
+                ip: "2001:67C:1562::2",
+                network: "2001:67C:1563::0/64",
+                range: {
+                    low: "2001:67C:1563::2",
+                    high: "2001:67C:1563::FFFF:FFFF"
+                },
+                valid: false
+            }
+        ];
+
+        angular.forEach(scenarios, function(scenario) {
+            it("validates: " + scenario.ip + " in range: " +
+                scenario.range.low + " - " + scenario.range.high,
                 function() {
                     var result = ValidationService.validateIPInRange(
-                        scenario.ip, scenario.range);
+                        scenario.ip, scenario.network,
+                        scenario.range.low, scenario.range.high);
                     expect(result).toBe(scenario.valid);
                 });
         });
 
=== modified file 'src/maasserver/static/js/angular/services/validation.js'
--- src/maasserver/static/js/angular/services/validation.js	2015-04-03 18:26:06 +0000
+++ src/maasserver/static/js/angular/services/validation.js	2015-04-23 19:17:12 +0000
@@ -155,7 +155,7 @@
         };
 
         // Return true if the ipAddress is in the network.
-        this.validateIPInRange = function(ipAddress, network) {
+        this.validateIPInNetwork = function(ipAddress, network) {
             var networkSplit = network.split('/');
             var networkAddress = networkSplit[0];
             var cidrBits = parseInt(networkSplit[1], 10);
@@ -175,4 +175,51 @@
             }
             return false;
         };
+
+        // Return true if the ipAddress is in the network and between the
+        // lowAddress and highAddress inclusive.
+        this.validateIPInRange = function(
+            ipAddress, network, lowAddress, highAddress) {
+            // If the ip address is not even in the network then its
+            // not in the range.
+            if(!this.validateIPInNetwork(ipAddress, network)) {
+                return false;
+            }
+
+            var i, ipOctets, lowOctets, highOctets;
+            if(this.validateIPv4(ipAddress) &&
+                this.validateIPv4(lowAddress) &&
+                this.validateIPv4(highAddress)) {
+
+                // Check that each octet is of the ip address is more or equal
+                // to the low address and less or equal to the high address.
+                ipOctets = ipv4ToOctets(ipAddress);
+                lowOctets = ipv4ToOctets(lowAddress);
+                highOctets = ipv4ToOctets(highAddress);
+                for(i = 0; i < 4; i++) {
+                    if(ipOctets[i] > highOctets[i] ||
+                        ipOctets[i] < lowOctets[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            } else if(this.validateIPv6(ipAddress) &&
+                this.validateIPv6(lowAddress) &&
+                this.validateIPv6(highAddress)) {
+
+                // Check that each octet is of the ip address is more or equal
+                // to the low address and less or equal to the high address.
+                ipOctets = ipv6ToOctets(ipAddress);
+                lowOctets = ipv6ToOctets(lowAddress);
+                highOctets = ipv6ToOctets(highAddress);
+                for(i = 0; i < 8; i++) {
+                    if(ipOctets[i] > highOctets[i] ||
+                        ipOctets[i] < lowOctets[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        };
     });
 
=== modified file 'src/maasserver/tests/test_forms_nodegroupinterface.py'
--- src/maasserver/tests/test_forms_nodegroupinterface.py	2015-03-25 15:33:23 +0000
+++ src/maasserver/tests/test_forms_nodegroupinterface.py	2015-04-23 19:17:12 +0000
@@ -212,7 +212,9 @@
             network=network)
         [interface] = nodegroup.get_managed_interfaces()
         StaticIPAddress.objects.allocate_new(
-            interface.static_ip_range_low, interface.static_ip_range_high)
+            interface.network, interface.static_ip_range_low,
+            interface.static_ip_range_high, interface.ip_range_low,
+            interface.ip_range_high)
         form = NodeGroupInterfaceForm(
             data={'static_ip_range_low': '', 'static_ip_range_high': ''},
             instance=interface)
 
=== modified file 'src/maasserver/tests/test_forms_validate_new_static_ip_range.py'
--- src/maasserver/tests/test_forms_validate_new_static_ip_range.py	2015-03-25 15:33:23 +0000
+++ src/maasserver/tests/test_forms_validate_new_static_ip_range.py	2015-04-23 19:17:12 +0000
@@ -49,7 +49,8 @@
 
     def test_raises_error_when_allocated_ips_fall_outside_new_range(self):
         interface = self.make_interface()
-        StaticIPAddress.objects.allocate_new('10.1.0.56', '10.1.0.60')
+        StaticIPAddress.objects.allocate_new(
+            '10.1.0.0/16', '10.1.0.56', '10.1.0.60', '10.1.0.1', '10.1.0.10')
         error = self.assertRaises(
             ValidationError,
             validate_new_static_ip_ranges,
@@ -62,7 +63,8 @@
 
     def test_removing_static_range_raises_error_if_ips_allocated(self):
         interface = self.make_interface()
-        StaticIPAddress.objects.allocate_new('10.1.0.56', '10.1.0.60')
+        StaticIPAddress.objects.allocate_new(
+            '10.1.0.0/16', '10.1.0.56', '10.1.0.60', '10.1.0.1', '10.1.0.10')
         error = self.assertRaises(
             ValidationError,
             validate_new_static_ip_ranges,
@@ -75,7 +77,8 @@
 
     def test_allows_range_expansion(self):
         interface = self.make_interface()
-        StaticIPAddress.objects.allocate_new('10.1.0.56', '10.1.0.60')
+        StaticIPAddress.objects.allocate_new(
+            '10.1.0.0/16', '10.1.0.56', '10.1.0.60', '10.1.0.1', '10.1.0.10')
         is_valid = validate_new_static_ip_ranges(
             interface, static_ip_range_low='10.1.0.40',
             static_ip_range_high='10.1.0.100')
@@ -83,7 +86,8 @@
 
     def test_allows_allocated_ip_as_upper_bound(self):
         interface = self.make_interface()
-        StaticIPAddress.objects.allocate_new('10.1.0.55', '10.1.0.55')
+        StaticIPAddress.objects.allocate_new(
+            '10.1.0.0/16', '10.1.0.55', '10.1.0.55', '10.1.0.1', '10.1.0.10')
         is_valid = validate_new_static_ip_ranges(
             interface,
             static_ip_range_low=interface.static_ip_range_low,
@@ -92,7 +96,8 @@
 
     def test_allows_allocated_ip_as_lower_bound(self):
         interface = self.make_interface()
-        StaticIPAddress.objects.allocate_new('10.1.0.55', '10.1.0.55')
+        StaticIPAddress.objects.allocate_new(
+            '10.1.0.0/16', '10.1.0.55', '10.1.0.55', '10.1.0.1', '10.1.0.10')
         is_valid = validate_new_static_ip_ranges(
             interface, static_ip_range_low='10.1.0.55',
             static_ip_range_high=interface.static_ip_range_high)
@@ -103,7 +108,9 @@
         interface.management = NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED
         interface.save()
         StaticIPAddress.objects.allocate_new(
-            interface.static_ip_range_low, interface.static_ip_range_high)
+            interface.network, interface.static_ip_range_low,
+            interface.static_ip_range_high, interface.ip_range_low,
+            interface.ip_range_high)
         is_valid = validate_new_static_ip_ranges(
             interface, static_ip_range_low='10.1.0.57',
             static_ip_range_high='10.1.0.58')
@@ -114,7 +121,8 @@
         interface.static_ip_range_low = None
         interface.static_ip_range_high = None
         interface.save()
-        StaticIPAddress.objects.allocate_new('10.1.0.56', '10.1.0.60')
+        StaticIPAddress.objects.allocate_new(
+            '10.1.0.0/16', '10.1.0.56', '10.1.0.60', '10.1.0.1', '10.1.0.10')
         is_valid = validate_new_static_ip_ranges(
             interface, static_ip_range_low='10.1.0.57',
             static_ip_range_high='10.1.0.58')
@@ -123,7 +131,9 @@
     def test_ignores_unchanged_static_range(self):
         interface = self.make_interface()
         StaticIPAddress.objects.allocate_new(
-            interface.static_ip_range_low, interface.static_ip_range_high)
+            interface.network, interface.static_ip_range_low,
+            interface.static_ip_range_high, interface.ip_range_low,
+            interface.ip_range_high)
         is_valid = validate_new_static_ip_ranges(
             interface,
             static_ip_range_low=interface.static_ip_range_low,
 
=== modified file 'src/maasserver/tests/test_node_action.py'
--- src/maasserver/tests/test_node_action.py	2015-04-16 13:49:51 +0000
+++ src/maasserver/tests/test_node_action.py	2015-04-23 19:17:12 +0000
@@ -485,7 +485,8 @@
         ngi.save()
         with transaction.atomic():
             StaticIPAddress.objects.allocate_new(
-                ngi.static_ip_range_high, ngi.static_ip_range_low)
+                ngi.network, ngi.static_ip_range_low, ngi.static_ip_range_high,
+                ngi.ip_range_low, ngi.ip_range_high)
 
         e = self.assertRaises(NodeActionError, Deploy(node, user).execute)
         self.expectThat(