Merge lp:~mpontillo/maas/networking-constraints-refactor-part2 into lp:~maas-committers/maas/trunk

[Mike Pontillo]

Network interfaces constraint refactoring, part 2.

 * Enable basic "interfaces" constraints for Node.acquire() API.
 * Does not yet support matching each constraint back to its interface.
 * Extend framework for specifier-based queries into the Interface manager.
 * Extend the generic query-by-specifiers functionality to support specifiers other than functions. (specifier aliases, Django query strings, and references to a different model object's query-by-specifiers are now supported.)
 * Make the superclass more robust to handle collaboration between filtering entities.
 * Support for (the positive form of) the following specifiers for interfaces: subnet, space, subnet_cidr, fabric, fabric_class, id, vid, and name.

Note: This branch does not yet generate the data to match the constraint labels back to a node's interfaces.

Parts 3 and 4 will be for negative constraints and interface match reporting.

[Blake Rouse (blake-rouse)]

This is really good code. Well done! Just a couple of comments, but nothing major. Very clean and very well commented.

review: Approve

[Mike Pontillo (mpontillo)]

Thanks for reviewing.

I fixed what you pointed out, and realized I needed to add a test case that checks if multiple labels are parsed okay in the form.

=== modified file '.idea/inspectionProfiles/Project_Default.xml'
--- .idea/inspectionProfiles/Project_Default.xml	2015-10-30 10:48:25 +0000
+++ .idea/inspectionProfiles/Project_Default.xml	2015-11-02 23:13:19 +0000
@@ -9,6 +9,8 @@
           <option value="maasserver.models.node.NodeQueriesMixin.exclude" />
           <option value="maasserver.models.subnet.SubnetQueriesMixin.filter" />
           <option value="maasserver.models.subnet.SubnetQueriesMixin.exclude" />
+          <option value="maasserver.utils.orm.MAASQueriesMixin.filter" />
+          <option value="maasserver.utils.orm.MAASQueriesMixin.exclude" />
         </list>
       </option>
     </inspection_tool>

=== modified file 'src/maasserver/models/interface.py'
--- src/maasserver/models/interface.py	2015-10-30 20:50:01 +0000
+++ src/maasserver/models/interface.py	2015-11-02 23:13:19 +0000
@@ -37,6 +37,7 @@
     PROTECT,
     Q,
 )
+from django.db.models.query import QuerySet
 from django.http import Http404
 from django.shortcuts import get_object_or_404
 from djorm_pgarray.fields import ArrayField
@@ -63,12 +64,15 @@
 )
 from maasserver.models.cleansave import CleanSave
 from maasserver.models.nodegroupinterface import NodeGroupInterface
-from maasserver.models.space import Space
 from maasserver.models.staticipaddress import StaticIPAddress
 from maasserver.models.timestampedmodel import TimestampedModel
-from maasserver.utils.orm import get_one
+from maasserver.utils.orm import (
+    get_one,
+    MAASQueriesMixin,
+)
 from maasserver.utils.signals import connect_to_field_change
 from netaddr import (
+    AddrFormatError,
     IPAddress,
     IPNetwork,
 )
@@ -76,6 +80,7 @@
 from provisioningserver.utils.ipaddr import (
     get_first_and_last_usable_host_in_network,
 )
+from provisioningserver.utils.network import parse_integer
 
 
 maaslog = get_maas_logger("interface")
@@ -113,7 +118,76 @@
         return None
 
 
-class InterfaceManager(Manager):
+class InterfaceQueriesMixin(MAASQueriesMixin):
+    def get_specifiers_q(self, specifiers, separator=':'):
+        """Returns a Q object for objects matching the given specifiers.
+
+        :return:django.db.models.Q
+        """
+        # Circular imports.
+        from maasserver.models import Subnet
+
+        # This dict is used by the constraints code in order to identify
+        # interfaces with particular properties. Please note that changing
+        # the keys here can impact backward compatibility, so use caution.
+        interface_specifier_types = {
+            None: self._add_default_query,
+            'id': self._add_interface_id_query,
+            # XXX mpontillo 2015-10-31 the fabric matcher should probably
+            # become a tuple, after we have specifier-based fabric queries.
+            'fabric': 'vlan__fabric__name',
+            'fabric_class': 'vlan__fabric__class_type',
+            'ip': 'ip_addresses__ip',
+            'mode': self._add_mode_query,
+            'name': '__name',
+            'subnet': (Subnet.objects, 'staticipaddress__interface'),
+            'space': 'subnet{s}space'.format(s=separator),
+            'subnet_cidr': 'subnet{s}cidr'.format(s=separator),
+            'type': '__type',
+            'vid': self._add_vlan_vid_query,
+        }
+        return super(InterfaceQueriesMixin, self).get_specifiers_q(
+            specifiers, specifier_types=interface_specifier_types,
+            separator=separator)
+
+    def _add_interface_id_query(self, current_q, op, item):
+        try:
+            item = parse_integer(item)
+        except ValueError:
+            raise ValidationError("Interface ID must be numeric.")
+        else:
+            current_q = op(current_q, Q(id=item))
+            return current_q
+
+    def _add_default_query(self, current_q, op, item):
+        # By default, search for a specific CIDR first, then
+        # fall back to the name.
+        try:
+            ip = IPNetwork(item)
+        except AddrFormatError:
+            current_q = op(current_q, Q(name=item))
+        else:
+            cidr = unicode(ip.cidr)
+            current_q = op(current_q, Q(ip_addresses__subnet__cidr=cidr))
+        return current_q
+
+    def _add_mode_query(self, current_q, op, item):
+        if item.strip().lower() != 'unconfigured':
+            raise ValidationError(
+                "The only valid value for 'mode' is 'unconfigured'.")
+        return op(
+            current_q,
+            Q(ip_addresses__ip__isnull=True) | Q(ip_addresses__ip=''))
+
+
+class InterfaceQuerySet(InterfaceQueriesMixin, QuerySet):
+    """Custom QuerySet which mixes in some additional queries specific to
+    subnets. This needs to be a mixin because an identical method is needed on
+    both the Manager and all QuerySets which result from calling the manager.
+    """
+
+
+class InterfaceManager(Manager, InterfaceQueriesMixin):
     """A Django manager managing one type of interface."""
 
     def get_queryset(self):
@@ -123,7 +197,7 @@
         or `VLANInterface` it will filter only allow returning those
         interfaces.
         """
-        qs = super(InterfaceManager, self).get_query_set()
+        qs = InterfaceQuerySet(self.model, using=self._db)
         interface_type = self.model.get_type()
         if interface_type is None:
             # Not a specific interface type so we don't filter by the type.
@@ -321,15 +395,13 @@
         interface is connected.
         """
         # Circular imports.
-        from maasserver.models import StaticIPAddress, Subnet, Fabric
+        from maasserver.models import StaticIPAddress, Subnet
 
         # Delete all current DISCOVERED IP address on this interface. As new
         # ones are about to be added.
         StaticIPAddress.objects.filter(
             interface=self, alloc_type=IPADDRESS_TYPE.DISCOVERED).delete()
 
-        # XXX:fabric - Using the default Fabric for now.
-        fabric = Fabric.objects.get_default_fabric()
         for ip in cidr_list:
             network = IPNetwork(ip)
             cidr = unicode(network.cidr)
@@ -338,12 +410,10 @@
             # Find the Subnet for each IP address seen (will be used later
             # to create or update the Subnet)
             try:
-                subnet = Subnet.objects.get(cidr=cidr, vlan__fabric=fabric)
+                subnet = Subnet.objects.get(cidr=cidr)
             except Subnet.DoesNotExist:
-                vlan = fabric.get_default_vlan()
-                space = Space.objects.get_default_space()
-                subnet = Subnet.objects.create_from_cidr(
-                    cidr=cidr, vlan=vlan, space=space)
+                # XXX mpontillo 2015-11-01 configuration != state
+                subnet = Subnet.objects.create_from_cidr(cidr)
                 maaslog.info(
                     "Creating subnet %s connected to interface %s "
                     "of node %s.", cidr, self, self.get_node())

=== modified file 'src/maasserver/models/subnet.py'
--- src/maasserver/models/subnet.py	2015-10-31 06:47:39 +0000
+++ src/maasserver/models/subnet.py	2015-11-02 23:13:19 +0000
@@ -99,9 +99,6 @@
 
 class SubnetQueriesMixin(MAASQueriesMixin):
 
-    def __init__(self, *args, **kwargs):
-        super(SubnetQueriesMixin, self).__init__(*args, **kwargs)
-
     find_subnets_with_ip_query = """
         SELECT DISTINCT subnet.*, masklen(subnet.cidr) "prefixlen"
         FROM
@@ -175,24 +172,47 @@
         except (ValueError, AddrFormatError) as e:
             raise ValidationError(e.message)
 
-    def _get_specifiers_query(self, specifiers):
+    def get_specifiers_q(self, specifiers, separator=':'):
         """Returns a Q object for objects matching the given specifiers.
 
-        See documentation for `filter_by_specifiers()`.
+        Allows a number of types to be prefixed in front of each specifier:
+            * 'ip:' Matches the subnet that best matches the given IP address.
+            * 'cidr:' Matches a subnet with the exact given CIDR.
+            * 'name': Matches a subnet with the given name.
+            * 'vid:' Matches a subnet whose VLAN has the given VID.
+                Can be used with a hexadecimal or binary string by prefixing
+                it with '0x' or '0b'.
+            ' 'vlan:' Synonym for 'vid' for compatibility with older MAAS
+                versions.
+            * 'space:' Matches the name of this subnet's space.
+
+        If no specifier is given, the input will be treated as a CIDR. If
+        the input is not a valid CIDR, it will be treated as subnet name.
+
+        :raise:AddrFormatError:If a specific IP address or CIDR is requested,
+            but the address could not be parsed.
 
         :return:django.db.models.Q
         """
+        # Circular imports.
+        from maasserver.models import Interface
+
+        # This dict is used by the constraints code in order to identify
+        # subnets with particular properties. Please note that changing
+        # the keys here can impact backward compatibility, so use caution.
         subnet_specifier_types = {
+            None: self._add_default_query,
+            'cidr': self._add_unvalidated_cidr_query,
+            'id': self._add_subnet_id_query,
+            'interface': (Interface.objects, 'ip_addresses__subnet'),
             'ip': self._add_ip_in_subnet_query,
-            'cidr': self._add_unvalidated_cidr_query,
-            'name': self._add_subnet_name_query,
-            'vlan': self._add_vlan_vid_query,
+            'name': "__name",
             'vid': self._add_vlan_vid_query,
-            'space': self._add_space_name_query,
-            None: self._add_default_query,
+            'vlan': 'vid',
+            'space': "space__name",
         }
-        return super(SubnetQueriesMixin, self)._get_specifiers_query(
-            specifiers, specifier_types=subnet_specifier_types)
+        return super(SubnetQueriesMixin, self).get_specifiers_q(
+            specifiers, specifier_types=subnet_specifier_types, separator=':')
 
     def _add_default_query(self, current_q, op, item):
         # By default, search for a specific CIDR first, then
@@ -200,7 +220,7 @@
         try:
             ip = IPNetwork(item)
         except AddrFormatError:
-            current_q = self._add_subnet_name_query(current_q, op, item)
+            current_q = op(current_q, Q(name=item))
         else:
             cidr = unicode(ip.cidr)
             current_q = op(current_q, Q(cidr=cidr))
@@ -223,63 +243,14 @@
         current_q = op(current_q, Q(id__in=ids))
         return current_q
 
-    def _add_space_name_query(self, current_q, op, item):
-        current_q = op(current_q, Q(space__name=item))
-        return current_q
-
-    def _add_subnet_name_query(self, current_q, op, item):
-        current_q = op(current_q, Q(name=item))
-        return current_q
-
-    def _add_vlan_vid_query(self, current_q, op, item):
-        if item.lower() == 'untagged':
-            vid = 0
+    def _add_subnet_id_query(self, current_q, op, item):
+        try:
+            item = parse_integer(item)
+        except ValueError:
+            raise ValidationError("Subnet ID must be numeric.")
         else:
-            vid = parse_integer(item)
-        if vid < 0 or vid >= 0xfff:
-            raise ValidationError(
-                "VLAN tag (VID) out of range "
-                "(0-4094; 0 for untagged.)")
-        current_q = op(current_q, Q(vlan__vid=vid))
-        return current_q
-
-    def filter_by_specifiers(self, specifiers):
-        """Filters subnets by the given list of specifiers (or single
-        specifier).
-
-        Allows a number of types to be prefixed in front of each specifier:
-            * 'ip:' Matches the subnet that best matches the given IP address.
-            * 'cidr:' Matches a subnet with the exact given CIDR.
-            * 'name': Matches a subnet with the given name.
-            * 'vid:' Matches a subnet whose VLAN has the given VID.
-                Can be used with a hexadecimal or binary string by prefixing
-                it with '0x' or '0b'.
-            ' 'vlan:' Synonym for 'vid' for compatibility with older MAAS
-                versions.
-            * 'space:' Matches the name of this subnet's space.
-
-        If no specifier is given, the input will be treated as a CIDR. If
-        the input is not a valid CIDR, it will be treated as subnet name.
-
-        :raise:AddrFormatError:If a specific IP address or CIDR is requested,
-            but the address could not be parsed.
-        :return:QuerySet
-        """
-        query = self._get_specifiers_query(specifiers)
-        return self.filter(query)
-
-    def exclude_by_specifiers(self, specifiers):
-        """Excludes subnets by the given list of specifiers (or single
-        specifier).
-
-        See documentation for `filter_by_specifiers()`.
-
-        :raise:AddrFormatError:If a specific IP address or CIDR is requested,
-            but the address could not be parsed.
-        :return:QuerySet
-        """
-        query = self._get_specifiers_query(specifiers)
-        return self.exclude(query)
+            current_q = op(current_q, Q(id=item))
+            return current_q
 
 
 class SubnetQuerySet(QuerySet, SubnetQueriesMixin):
@@ -296,9 +267,14 @@
         queryset = SubnetQuerySet(self.model, using=self._db)
         return queryset
 
-    def create_from_cidr(self, cidr, vlan, space):
+    def create_from_cidr(self, cidr, vlan=None, space=None):
         """Create a subnet from the given CIDR."""
         name = "subnet-" + unicode(cidr)
+        from maasserver.models import (Space, VLAN)
+        if space is None:
+            space = Space.objects.get_default_space()
+        if vlan is None:
+            vlan = VLAN.objects.get_default_vlan()
         return self.create(name=name, cidr=cidr, vlan=vlan, space=space)
 
     def _find_fabric(self, fabric):

=== modified file 'src/maasserver/models/tests/test_interface.py'
--- src/maasserver/models/tests/test_interface.py	2015-10-30 20:50:01 +0000
+++ src/maasserver/models/tests/test_interface.py	2015-11-02 23:13:19 +0000
@@ -135,6 +135,205 @@
             user, NODE_PERMISSION.ADMIN)
 
 
+class TestInterfaceQueriesMixin(MAASServerTestCase):
+
+    def test__filter_by_specifiers_default_matches_cidr_or_name(self):
+        subnet1 = factory.make_Subnet()
+        subnet2 = factory.make_Subnet()
+        node1 = factory.make_Node_with_Interface_on_Subnet(
+            subnet=subnet1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(
+            subnet=subnet2)
+        iface1 = node1.get_boot_interface()
+        iface2 = node2.get_boot_interface()
+        iface3 = factory.make_Interface(
+            iftype=INTERFACE_TYPE.BOND, parents=[iface2], name='bond0')
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "%s" % subnet1.cidr), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "%s" % subnet2.cidr), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["%s" % subnet1.cidr,
+                 "%s" % subnet2.cidr], ), [iface1, iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(iface1.name), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(iface3.name), [iface3])
+
+    def test__filter_by_specifiers_matches_fabric_class(self):
+        fabric1 = factory.make_Fabric(class_type='10g')
+        fabric2 = factory.make_Fabric(class_type='1g')
+        vlan1 = factory.make_VLAN(vid=1, fabric=fabric1)
+        vlan2 = factory.make_VLAN(vid=2, fabric=fabric2)
+        iface1 = factory.make_Interface(vlan=vlan1)
+        iface2 = factory.make_Interface(vlan=vlan2)
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "fabric_class:10g"), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "fabric_class:1g"), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["fabric_class:1g", "fabric_class:10g"]), [iface1, iface2])
+
+    def test__filter_by_specifiers_matches_fabric(self):
+        fabric1 = factory.make_Fabric(name="fabric1")
+        fabric2 = factory.make_Fabric(name="fabric2")
+        vlan1 = factory.make_VLAN(vid=1, fabric=fabric1)
+        vlan2 = factory.make_VLAN(vid=2, fabric=fabric2)
+        iface1 = factory.make_Interface(vlan=vlan1)
+        iface2 = factory.make_Interface(vlan=vlan2)
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "fabric:fabric1"), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "fabric:fabric2"), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["fabric:fabric1", "fabric:fabric2"]), [iface1, iface2])
+
+    def test__filter_by_specifiers_matches_interface_id(self):
+        iface1 = factory.make_Interface()
+        iface2 = factory.make_Interface()
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "id:%s" % iface1.id), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "id:%s" % iface2.id), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["id:%s" % iface1.id, "id:%s" % iface2.id]), [iface1, iface2])
+
+    def test__filter_by_specifiers_matches_vid(self):
+        iface1 = factory.make_Interface()
+        iface2 = factory.make_Interface()
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "vid:%s" % iface1.vlan.vid), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "vid:%s" % iface2.vlan.vid), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["vid:%s" % iface1.vlan.vid, "vid:%s" % iface2.vlan.vid]),
+            [iface1, iface2])
+
+    def test__filter_by_specifiers_matches_subnet_specifier(self):
+        subnet1 = factory.make_Subnet()
+        subnet2 = factory.make_Subnet()
+        node1 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet2)
+        iface1 = node1.get_boot_interface()
+        iface2 = node2.get_boot_interface()
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "subnet:cidr:%s" % subnet1.cidr), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "subnet:cidr:%s" % subnet2.cidr), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["subnet:cidr:%s" % subnet1.cidr,
+                 "subnet:cidr:%s" % subnet2.cidr], ), [iface1, iface2])
+
+    def test__filter_by_specifiers_matches_subnet_cidr_alias(self):
+        subnet1 = factory.make_Subnet()
+        subnet2 = factory.make_Subnet()
+        node1 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet2)
+        iface1 = node1.get_boot_interface()
+        iface2 = node2.get_boot_interface()
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "subnet_cidr:%s" % subnet1.cidr), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "subnet_cidr:%s" % subnet2.cidr), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["subnet_cidr:%s" % subnet1.cidr,
+                 "subnet_cidr:%s" % subnet2.cidr], ), [iface1, iface2])
+
+    def test__filter_by_specifiers_matches_space(self):
+        space1 = factory.make_Space()
+        space2 = factory.make_Space()
+        subnet1 = factory.make_Subnet(space=space1)
+        subnet2 = factory.make_Subnet(space=space2)
+        node1 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet2)
+        iface1 = node1.get_boot_interface()
+        iface2 = node2.get_boot_interface()
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "space:%s" % space1.name), [iface1])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                "space:%s" % space2.name), [iface2])
+        self.assertItemsEqual(
+            Interface.objects.filter_by_specifiers(
+                ["space:%s" % space1.name,
+                 "space:%s" % space2.name], ), [iface1, iface2])
+
+    def test__filter_by_specifiers_matches_type(self):
+        physical = factory.make_Interface()
+        bond = factory.make_Interface(
+            iftype=INTERFACE_TYPE.BOND, parents=[physical])
+        vlan = factory.make_Interface(
+            iftype=INTERFACE_TYPE.VLAN, parents=[physical])
+        unknown = factory.make_Interface(iftype=INTERFACE_TYPE.UNKNOWN)
+        self.assertItemsEqual(Interface.objects.filter_by_specifiers(
+            "type:physical"), [physical])
+        self.assertItemsEqual(Interface.objects.filter_by_specifiers(
+            "type:vlan"), [vlan])
+        self.assertItemsEqual(Interface.objects.filter_by_specifiers(
+            "type:bond"), [bond])
+        self.assertItemsEqual(Interface.objects.filter_by_specifiers(
+            "type:unknown"), [unknown])
+
+    def test__filter_by_specifiers_matches_ip(self):
+        subnet1 = factory.make_Subnet(cidr='10.0.0.0/24')
+        subnet2 = factory.make_Subnet(cidr='10.0.1.0/24')
+        iface1 = factory.make_Interface()
+        iface2 = factory.make_Interface()
+        factory.make_StaticIPAddress(
+            ip='10.0.0.1', alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet1,
+            interface=iface1)
+        factory.make_StaticIPAddress(
+            ip='10.0.1.1', alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet2,
+            interface=iface2)
+        self.assertItemsEqual(Interface.objects.filter_by_specifiers(
+            "ip:10.0.0.1"), [iface1])
+        self.assertItemsEqual(Interface.objects.filter_by_specifiers(
+            "ip:10.0.1.1"), [iface2])
+
+    def test__filter_by_specifiers_matches_unconfigured_mode(self):
+        subnet1 = factory.make_Subnet(cidr='10.0.0.0/24')
+        subnet2 = factory.make_Subnet(cidr='10.0.1.0/24')
+        subnet3 = factory.make_Subnet(cidr='10.0.2.0/24')
+        iface1 = factory.make_Interface()
+        iface2 = factory.make_Interface()
+        iface3 = factory.make_Interface()
+        factory.make_StaticIPAddress(
+            ip='', alloc_type=IPADDRESS_TYPE.STICKY, subnet=subnet1,
+            interface=iface1)
+        factory.make_StaticIPAddress(
+            ip=None, alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet2,
+            interface=iface2)
+        factory.make_StaticIPAddress(
+            ip='10.0.2.1', alloc_type=IPADDRESS_TYPE.AUTO, subnet=subnet3,
+            interface=iface3)
+        self.assertItemsEqual(
+            [iface1, iface2],
+            Interface.objects.filter_by_specifiers(
+                "mode:unconfigured"))
+
+
 class InterfaceTest(MAASServerTestCase):
 
     def test_rejects_invalid_name(self):
@@ -742,7 +941,7 @@
 
         self.assertEqual(num_connections, interface.ip_addresses.count())
         for i in range(num_connections):
-            ip = interface.ip_addresses.all()[i]
+            ip = interface.ip_addresses.order_by('id')[i]
             self.assertThat(ip, MatchesStructure.byEquality(
                 alloc_type=IPADDRESS_TYPE.DISCOVERED, subnet=subnet_list[i],
                 ip=unicode(IPNetwork(cidr_list[i]).ip)))
@@ -792,7 +991,7 @@
             "Discovered IP address should have been deleted.")
         self.assertEqual(num_connections, interface.ip_addresses.count())
         for i in range(num_connections):
-            ip = interface.ip_addresses.all()[i]
+            ip = interface.ip_addresses.order_by('id')[i]
             self.assertThat(ip, MatchesStructure.byEquality(
                 alloc_type=IPADDRESS_TYPE.DISCOVERED, subnet=subnet_list[i],
                 ip=unicode(IPNetwork(cidr_list[i]).ip)))
@@ -874,7 +1073,7 @@
             "Sticky IP address should have been deleted.")
         self.assertEqual(num_connections, interface.ip_addresses.count())
         for i in range(num_connections):
-            ip = interface.ip_addresses.all()[i]
+            ip = interface.ip_addresses.order_by('id')[i]
             self.assertThat(ip, MatchesStructure.byEquality(
                 alloc_type=IPADDRESS_TYPE.DISCOVERED, subnet=subnet_list[i],
                 ip=unicode(IPNetwork(cidr_list[i]).ip)))
@@ -2126,14 +2325,12 @@
         factory.make_NodeGroupInterface(
             nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
             subnet=subnet)
-        ip = factory.pick_ip_in_network(subnet.get_ipnetwork())
-        factory.make_StaticIPAddress(
-            alloc_type=IPADDRESS_TYPE.AUTO, ip=ip,
-            subnet=subnet, interface=interface)
-        sip = factory.pick_ip_in_network(subnet.get_ipnetwork())
-        factory.make_StaticIPAddress(
-            alloc_type=IPADDRESS_TYPE.STICKY, ip=sip,
-            subnet=subnet, interface=interface)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO,
+            subnet=subnet, interface=interface)
+        sip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            subnet=subnet, interface=interface).ip
         interface.release_auto_ips()
         self.assertThat(
             mock_update_host_maps,

=== modified file 'src/maasserver/models/tests/test_subnet.py'
--- src/maasserver/models/tests/test_subnet.py	2015-10-30 10:48:25 +0000
+++ src/maasserver/models/tests/test_subnet.py	2015-11-02 23:13:19 +0000
@@ -98,7 +98,7 @@
         self.assertEqual("169.254.0.0/16", cidr)
 
 
-class TestSubnetManager(MAASServerTestCase):
+class TestSubnetQueriesMixin(MAASServerTestCase):
 
     def test__filter_by_specifiers_takes_single_item(self):
         subnet1 = factory.make_Subnet(name="subnet1")
@@ -254,6 +254,61 @@
             Subnet.objects.filter_by_specifiers("ip:1.1.1.1"),
             [])
 
+    def test__matches_interfaces(self):
+        node1 = factory.make_Node_with_Interface_on_Subnet()
+        node2 = factory.make_Node_with_Interface_on_Subnet()
+        iface1 = node1.get_boot_interface()
+        iface2 = node2.get_boot_interface()
+        subnet1 = iface1.ip_addresses.first().subnet
+        subnet2 = iface2.ip_addresses.first().subnet
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("interface:id:%s" % iface1.id),
+            [subnet1])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("interface:id:%s" % iface2.id),
+            [subnet2])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["interface:id:%s" % iface1.id,
+                 "interface:id:%s" % iface2.id]),
+            [subnet1, subnet2])
+
+    def test__craziness_works(self):
+        # This test validates that filters can be "chained" to each other
+        # in an arbitrary way.
+        node1 = factory.make_Node_with_Interface_on_Subnet()
+        node2 = factory.make_Node_with_Interface_on_Subnet()
+        iface1 = node1.get_boot_interface()
+        iface2 = node2.get_boot_interface()
+        subnet1 = iface1.ip_addresses.first().subnet
+        subnet2 = iface2.ip_addresses.first().subnet
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                "interface:subnet:id:%s" % subnet1.id),
+            [subnet1])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                "interface:subnet:id:%s" % subnet2.id),
+            [subnet2])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["interface:subnet:id:%s" % subnet1.id,
+                 "interface:subnet:id:%s" % subnet2.id]),
+            [subnet1, subnet2])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                "interface:subnet:interface:subnet:id:%s" % subnet1.id),
+            [subnet1])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                "interface:subnet:interface:subnet:id:%s" % subnet2.id),
+            [subnet2])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["interface:subnet:interface:subnet:id:%s" % subnet1.id,
+                 "interface:subnet:interface:subnet:id:%s" % subnet2.id]),
+            [subnet1, subnet2])
+
 
 class TestSubnetManagerGetSubnetOr404(MAASServerTestCase):
 

=== modified file 'src/maasserver/node_constraint_filter_forms.py'
--- src/maasserver/node_constraint_filter_forms.py	2015-10-30 19:44:05 +0000
+++ src/maasserver/node_constraint_filter_forms.py	2015-11-02 23:13:19 +0000
@@ -32,6 +32,7 @@
 )
 import maasserver.forms as maasserver_forms
 from maasserver.models import (
+    Interface,
     PhysicalBlockDevice,
     Subnet,
     Tag,
@@ -377,6 +378,40 @@
     return nodes
 
 
+def nodes_by_interface(interfaces_label_map):
+    """Determines the set of nodes that match the specified
+    LabeledConstraintMap (which must be a map of storage constraints.)
+
+    :param interfaces_label_map: LabeledConstraintMap
+    :return: set
+    """
+    node_ids = None
+    for label in interfaces_label_map:
+        specifiers = []
+        constraints = interfaces_label_map[label]
+        for specifier_type in constraints.iterkeys():
+            # Build constraints string.
+            specifiers.extend([
+                specifier_type + ":" + item
+                for item in constraints[specifier_type]
+            ])
+        if node_ids is None:
+            # The first time through the filter, build the list
+            # of candidate nodes.
+            nodes = Interface.objects.filter_by_specifiers(
+                specifiers)
+            node_ids = set(nodes.values_list('node__id', flat=True))
+        else:
+            # For subsequent labels, only match nodes that already matched a
+            # preceding label.
+            current_matching_nodes = Interface.objects.filter(
+                node__id__in=node_ids)
+            filtered_nodes = current_matching_nodes.filter_by_specifiers(
+                specifiers)
+            node_ids = filtered_nodes.values_list('node__id', flat=True)
+    return node_ids
+
+
 class LabeledConstraintMapField(Field):
 
     def __init__(self, *args, **kwargs):
@@ -765,6 +800,14 @@
             if node_ids is not None:
                 filtered_nodes = filtered_nodes.filter(id__in=node_ids)
 
+        # Filter by interfaces (networking)
+        interfaces_label_map = self.cleaned_data.get(
+            self.get_field_name('interfaces'))
+        if interfaces_label_map is not None:
+            node_ids = nodes_by_interface(interfaces_label_map)
+            if node_ids is not None:
+                filtered_nodes = filtered_nodes.filter(id__in=node_ids)
+
         # This uses a very simple procedure to compute a machine's
         # cost. This procedure is loosely based on how ec2 computes
         # the costs of machines. This is here to give a hint to let

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2015-10-30 13:20:12 +0000
+++ src/maasserver/testing/factory.py	2015-11-02 23:13:19 +0000
@@ -561,7 +561,7 @@
     def make_Node_with_Interface_on_Subnet(
             self, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
             interface_count=1, nodegroup=None, vlan=None, subnet=None,
-            cidr=None, fabric=None, **kwargs):
+            cidr=None, fabric=None, ifname=None, **kwargs):
         """Create a Node that has a Interface which is on a Subnet that has a
         NodeGroupInterface.
 
@@ -592,7 +592,7 @@
             self.make_NodeGroupInterface(
                 nodegroup, vlan=vlan, management=management, subnet=subnet)
         boot_interface = self.make_Interface(
-            iftype, node=node, vlan=vlan,
+            iftype, name=ifname, node=node, vlan=vlan,
             mac_address=mac_address)
         node.boot_interface = boot_interface
         node.save()
@@ -688,7 +688,7 @@
 
     def make_Space(self, name=None):
         if name is None:
-            name = self.make_name('space')
+            name = self.make_name('space--')
         space = Space(name=name)
         space.save()
         return space

=== modified file 'src/maasserver/tests/test_node_constraint_filter_forms.py'
--- src/maasserver/tests/test_node_constraint_filter_forms.py	2015-10-30 19:51:23 +0000
+++ src/maasserver/tests/test_node_constraint_filter_forms.py	2015-11-02 23:13:19 +0000
@@ -977,7 +977,15 @@
             u'interfaces': u'label:fabric=fabric-0'})
         self.assertTrue(form.is_valid(), dict(form.errors))
 
-    @skip("XXX mpontillo 2015-10-30 need to use upcoming interfaces filter")
+    def test_interfaces_constraint_with_multiple_labels_and_values_validated(
+            self):
+        factory.make_Node_with_Interface_on_Subnet()
+        form = AcquireNodeForm({
+            u'interfaces':
+            u'label:fabric=fabric-0,fabric=fabric-1,space=default;'
+            u'label2:fabric=fabric-3,fabric=fabric-4,space=foo'})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+
     def test_interfaces_filters_by_fabric_class(self):
         fabric1 = factory.make_Fabric(class_type="1g")
         fabric2 = factory.make_Fabric(class_type="10g")
@@ -996,6 +1004,52 @@
         filtered_nodes, _ = form.filter_nodes(Node.nodes)
         self.assertItemsEqual([node1], filtered_nodes)
 
+    def test_interfaces_filters_work_with_multiple_labels(self):
+        fabric1 = factory.make_Fabric(class_type="1g")
+        fabric2 = factory.make_Fabric(class_type="10g")
+        vlan1 = factory.make_VLAN(vid=1, fabric=fabric1)
+        vlan2 = factory.make_VLAN(vid=2, fabric=fabric2)
+        node1 = factory.make_Node_with_Interface_on_Subnet(
+            fabric=fabric1, vlan=vlan1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(
+            fabric=fabric2, vlan=vlan2)
+
+        form = AcquireNodeForm({
+            u'interfaces': u'fabric:fabric_class=1g;vlan:vid=1'})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node1], filtered_nodes)
+
+        form = AcquireNodeForm({
+            u'interfaces': u'label:fabric_class=10g;vlan:vid=2'})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node2], filtered_nodes)
+
+    def test_interfaces_filters_multiples_treated_as_OR_operation(self):
+        fabric1 = factory.make_Fabric(class_type="1g")
+        fabric2 = factory.make_Fabric(class_type="10g")
+        vlan1 = factory.make_VLAN(vid=1, fabric=fabric1)
+        vlan2 = factory.make_VLAN(vid=2, fabric=fabric2)
+        node1 = factory.make_Node_with_Interface_on_Subnet(
+            fabric=fabric1, vlan=vlan1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(
+            fabric=fabric2, vlan=vlan2)
+
+        form = AcquireNodeForm({
+            u'interfaces':
+            u'fabric:fabric_class=1g,fabric_class=10g;vlan:vid=1'})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node1], filtered_nodes)
+
+        form = AcquireNodeForm({
+            u'interfaces':
+            u'label:fabric_class=10g,fabric_class=1g;vlan:vid=2'})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node2], filtered_nodes)
+
     def test_combined_constraints(self):
         tag_big = factory.make_Tag(name='big')
         arch = '%s/generic' % factory.make_name('arch')

=== modified file 'src/maasserver/utils/orm.py'
--- src/maasserver/utils/orm.py	2015-10-31 06:47:39 +0000
+++ src/maasserver/utils/orm.py	2015-11-02 23:13:19 +0000
@@ -48,8 +48,12 @@
 )
 import threading
 from time import sleep
+import types
 
-from django.core.exceptions import MultipleObjectsReturned
+from django.core.exceptions import (
+    MultipleObjectsReturned,
+    ValidationError,
+)
 from django.db import (
     connection,
     connections,
@@ -64,6 +68,7 @@
     exponential_growth,
     full_jitter,
 )
+from provisioningserver.utils.network import parse_integer
 from provisioningserver.utils.twisted import callOut
 import psycopg2
 from psycopg2.errorcodes import SERIALIZATION_FAILURE
@@ -703,7 +708,7 @@
     return specifier, op
 
 
-def parse_item_specifier_type(specifier, types={}, separator=':'):
+def parse_item_specifier_type(specifier, spec_types={}, separator=':'):
     """
     Returns a tuple that splits the string int a specifier, and its specifier
     type.
@@ -712,13 +717,14 @@
     be found in the set, returns None in place of the specifier_type.
 
     :param specifier: The specifier string, such as "ip:10.0.0.1".
-    :param types: A set of strings that will be recognized as specifier types.
+    :param spec_types: A dict whose keys are strings that will be recognized
+        as specifier types.
     :param separator: Optional specifier. Defaults to ':'.
     :return: tuple
     """
     if separator in specifier:
         tokens = specifier.split(separator, 1)
-        if tokens[0] in types:
+        if tokens[0] in spec_types:
             specifier_type = tokens[0]
             specifier = tokens[1].strip()
         else:
@@ -751,7 +757,78 @@
         ids = self.get_id_list(raw_query)
         return self.filter(id__in=ids)
 
-    def _get_specifiers_query(self, specifiers, specifier_types=None):
+    def get_filter_function(
+            self, specifier_type, spec_types, item, separator=':'):
+        """Returns a function that must return a Q() based on some pervious
+        Q(), an operation function (which will manipulate it), and the data
+        that will be used as an argument to the filter operation function.
+
+        :param:specifier_type: a string which will be used as a key to get
+            the specifier from the spec_types dictionary.
+        :param:spec_types: the dictionary of valid specifier types.
+        :param:item: the string that will be used to filter by
+        :param:separator: a string that must separate specifiers from their
+            values. (for example, the default of ':' would be used if you
+            wanted specifiers to look like "id:42".)
+
+        :return: types.FunctionType or types.MethodType
+        """
+        query = spec_types.get(specifier_type, None)
+        while True:
+            if isinstance(query, (types.FunctionType, types.MethodType)):
+                # Found a function or method that will appending the filter
+                # string for us. Parameters must be in the format:
+                # (<current_Q()>, <operation_function>, <item>), where
+                # the operation_function must be a function that takes action
+                # on the current_Q() to append a new query object (Q()).
+                return query
+            elif isinstance(query, types.TupleType):
+                # Specifies a query to a subordinate specifier function.
+                # This will be a tuple in the format:
+                # (manager_object, filter_from_object)
+                # That is, filter_from_object defines how to relate the object
+                # we're querying back to the object that we care about, and
+                # manager_object is a Django Manager instance.
+                (manager_object, filter_from_object) = query
+                sub_ids = manager_object.filter_by_specifiers(
+                    item).values_list(filter_from_object + '__id', flat=True)
+                # Return a function to filter the current object based on
+                # its IDs (as gathered from the query above to the related
+                # object).
+                kwargs = {"id__in": sub_ids}
+                return lambda cq, op, i: op(cq, Q(**kwargs))
+            elif isinstance(query, unicode):
+                if separator in query:
+                    # We got a string like "subnet:space". This means we want
+                    # to actually use the query specifier at the 'subnet' key,
+                    # but we want to convert the item from (for example)
+                    # "space1" to "space:space1". When we loop back around,
+                    # "subnet" will resolve to a tuple, and we'll query the
+                    # specifier-based filter for Subnet.
+                    query, subordinate = query.split(separator, 1)
+                    item = subordinate + separator + item
+                elif '__' in query:
+                    # If the value for this query specifier contains the string
+                    # '__', assume it's a Django filter expression, and return
+                    # the appropriate query. Disambiguate what could be an
+                    # 'alias expression' by allowing the __ to appear before
+                    # the filter. (that is, prefix the filter string with __
+                    # to query the current object.)
+                    if query.startswith('__'):
+                        query = query[2:]
+                    kwargs = {query: item}
+                    return lambda cq, op, i: op(cq, Q(**kwargs))
+                else:
+                    query = spec_types.get(query, None)
+            elif query is None:
+                # The None key is for the default query for this specifier.
+                query = spec_types[None]
+            else:
+                break
+        return None
+
+    def get_specifiers_q(
+            self, specifiers, specifier_types=None, separator=':'):
         """Returns a Q object for objects matching the given specifiers.
 
         See documentation for `filter_by_specifiers()`.
@@ -766,7 +843,37 @@
         for item in specifiers:
             item, op = parse_item_operation(item)
             item, specifier_type = parse_item_specifier_type(
-                item, types=specifier_types)
-            query = specifier_types.get(specifier_type)
+                item, spec_types=specifier_types, separator=separator)
+            query = self.get_filter_function(
+                specifier_type, specifier_types, item, separator=separator)
             current_q = query(current_q, op, item)
         return current_q
+
+    def filter_by_specifiers(self, specifiers, separator=':'):
+        query = self.get_specifiers_q(specifiers, separator=separator)
+        return self.filter(query)
+
+    def exclude_by_specifiers(self, specifiers):
+        """Excludes subnets by the given list of specifiers (or single
+        specifier).
+
+        See documentation for `filter_by_specifiers()`.
+
+        :raise:AddrFormatError:If a specific IP address or CIDR is requested,
+            but the address could not be parsed.
+        :return:QuerySet
+        """
+        query = self.get_specifiers_q(specifiers)
+        return self.exclude(query)
+
+    def _add_vlan_vid_query(self, current_q, op, item):
+        if item.lower() == 'untagged':
+            vid = 0
+        else:
+            vid = parse_integer(item)
+        if vid < 0 or vid >= 0xfff:
+            raise ValidationError(
+                "VLAN tag (VID) out of range "
+                "(0-4094; 0 for untagged.)")
+        current_q = op(current_q, Q(vlan__vid=vid))
+        return current_q