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

[Mike Pontillo]

Networking constraints refactoring (part 1).
  * Add fabrics, not_fabrics, fabric_classes, and not_fabric_classes constraints.
    * Covers nodes only, not with the ability to relate back to interfaces yet.
    * Fabric name handling only works for user-specified names currently, and must be fixed in a follow-on commit.
  * Rename methods in NodeQueriesMixin to better match Django conventions.
  * Refactor Subnets to use a new SubnetQueriesMixin class.
  * Refactor common query mixin logic to a common superclass.
  * Rename get_subnets_with_ip() to raw_subnets_containing_ip() to make it more clear that it returns a raw query.
  * Add specifier-based Subnet queries (now used for networking constraint matching).
  * Remove legacy subnet specifier handling code
    * Disable legacy subnet specifier tests dealing with multiple constraint matching
       (this logic will be moved to the interfaces= constraint, since it is specific to individual interfaces)
  * Remove legacy 'networks' form fields
    * Add backward-compatibility handling to use 'subnets' for these fields
       (we may want to remove this completely, since it behaves slightly differently)
    * No validators have been implemented yet for fabric and fabric class constraints; again, this will happen in a follow-on commit.
  * Add 'space' specifier to subnet constraints.
  * Add 'cidr' specifier to subnet constraints.
  * Change default behavior of subnet constraints to first match on CIDR, then try matching on name if no match is found.
  * Remove Fabric matching from custom query, since subnet CIDRs are "globally" unique. (within MAAS)
  * Move generic hex/decimal integer parsing code into its own utility function.
  * Add PyCharm inspection profiles for Node and Subnet query mixins.

[Gavin Panella (allenap)]

I have reformatted the commit message; it looked like there was a missing line-break.

[Gavin Panella (allenap)]

I have made loads of comments but it's all basically good. It's also too long for me to really take it all in at once, so I skipped over some bits. In other words, I could have made even MORE comments :)

Needs Fixing because parse_integer() needs tests, but also because I might have a read through the bits I skimmed before it lands.

review: Needs Fixing

[Mike Pontillo (mpontillo)]

Thanks for the review.

[Gavin Panella (allenap)]

Nice!

review: Approve

[MAAS Lander (maas-lander)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

=== added directory '.idea/inspectionProfiles'
=== added file '.idea/inspectionProfiles/Project_Default.xml'
--- .idea/inspectionProfiles/Project_Default.xml	1970-01-01 00:00:00 +0000
+++ .idea/inspectionProfiles/Project_Default.xml	2015-10-30 19:51:38 +0000
@@ -0,0 +1,16 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <option name="myLocal" value="true" />
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="maasserver.models.node.NodeQueriesMixin.filter" />
+          <option value="maasserver.models.node.NodeQueriesMixin.exclude" />
+          <option value="maasserver.models.subnet.SubnetQueriesMixin.filter" />
+          <option value="maasserver.models.subnet.SubnetQueriesMixin.exclude" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>
\ No newline at end of file

=== added file '.idea/inspectionProfiles/profiles_settings.xml'
--- .idea/inspectionProfiles/profiles_settings.xml	1970-01-01 00:00:00 +0000
+++ .idea/inspectionProfiles/profiles_settings.xml	2015-10-30 19:51:38 +0000
@@ -0,0 +1,7 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="PROJECT_PROFILE" value="Project Default" />
+    <option name="USE_PROJECT_PROFILE" value="true" />
+    <version value="1.0" />
+  </settings>
+</component>
\ No newline at end of file

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2015-10-30 12:27:37 +0000
+++ src/maasserver/models/node.py	2015-10-30 19:51:38 +0000
@@ -116,6 +116,7 @@
 from maasserver.utils.mac import get_vendor_for_mac
 from maasserver.utils.orm import (
     get_one,
+    MAASQueriesMixin,
     post_commit,
     post_commit_do,
     transactional,
@@ -168,97 +169,89 @@
     "power_parameters"))
 
 
-class NodeQueriesMixin(object):
+class NodeQueriesMixin(MAASQueriesMixin):
 
     def filter_by_spaces(self, spaces):
-        """Return the set of nodes (optionally based on the specified
-        self) with at least one interface in the specified spaces.
+        """Return the set of nodes with at least one interface in the specified
+        spaces.
         """
         return self.filter(
             interface__ip_addresses__subnet__space__in=spaces)
 
-    def filter_by_not_spaces(self, spaces):
-        """Return the set of nodes (optionally based on the specified
-        self) without any interfaces in the specified spaces.
+    def exclude_spaces(self, spaces):
+        """Return the set of nodes without any interfaces in the specified
+        spaces.
         """
         return self.exclude(
             interface__ip_addresses__subnet__space__in=spaces)
 
     def filter_by_fabrics(self, fabrics):
-        """Return the set of nodes (optionally based on the specified
-        self) with at least one interface in the specified fabrics.
+        """Return the set of nodes with at least one interface in the specified
+        fabrics.
         """
         return self.filter(
             interface__vlan__fabric__in=fabrics)
 
-    def filter_by_not_fabrics(self, fabrics):
-        """Return the set of nodes (optionally based on the specified
-        self) without any interfaces in the specified fabrics.
+    def exclude_fabrics(self, fabrics):
+        """Return the set of nodes without any interfaces in the specified
+        fabrics.
         """
         return self.exclude(
             interface__vlan__fabric__in=fabrics)
 
     def filter_by_fabric_classes(self, fabric_classes):
-        """Return the set of nodes (optionally based on the specified
-        self) with at least one interface in the specified fabric
-        classes.
+        """Return the set of nodes with at least one interface in the specified
+        fabric classes.
         """
         return self.filter(
             interface__vlan__fabric__class_type__in=fabric_classes)
 
-    def filter_by_not_fabric_classes(
+    def exclude_fabric_classes(
             self, fabric_classes):
-        """Return the set of nodes (optionally based on the specified
-        self) without any interfaces in the specified fabric
-        classes.
+        """Return the set of nodes without any interfaces in the specified
+        fabric classes.
         """
         return self.exclude(
             interface__vlan__fabric__class_type__in=fabric_classes)
 
     def filter_by_vids(self, vids):
-        """Return the set of nodes (optionally based on the specified
-        self) with at least one interface whose VLAN has one of the
-        specified VIDs.
+        """Return the set of nodes with at least one interface whose VLAN has
+        one of the specified VIDs.
         """
         return self.filter(
             interface__vlan__vid__in=vids)
 
-    def filter_by_not_vids(self, vids):
-        """Return the set of nodes (optionally based on the specified
-        self) without any interfaces whose VLAN has one of the
-        specified VIDs.
+    def exclude_vids(self, vids):
+        """Return the set of nodes without any interfaces whose VLAN has one of
+        the specified VIDs.
         """
         return self.exclude(
             interface__vlan__vid__in=vids)
 
     def filter_by_subnets(self, subnets):
-        """Return the set of nodes (optionally based on the specified
-        self) with at least one interface configured on one of the
-        specified subnets.
+        """Return the set of nodes with at least one interface configured on
+        one of the specified subnets.
         """
         return self.filter(
             interface__ip_addresses__subnet__in=subnets)
 
-    def filter_by_not_subnets(self, subnets):
-        """Return the set of nodes (optionally based on the specified
-        self) without any interfaces configured on one of the
-        specified subnets.
+    def exclude_subnets(self, subnets):
+        """Return the set of nodes without any interfaces configured on one of
+        the specified subnets.
         """
         return self.exclude(
             interface__ip_addresses__subnet__in=subnets)
 
     def filter_by_subnet_cidrs(self, subnet_cidrs):
-        """Return the set of nodes (optionally based on the specified
-        self) with at least one interface configured on one of the
-        specified subnet with the given CIDRs.
+        """Return the set of nodes with at least one interface configured on
+        one of the specified subnet with the given CIDRs.
         """
         return self.filter(
             interface__ip_addresses__subnet__cidr__in=subnet_cidrs)
 
-    def filter_by_not_subnet_cidrs(self, subnet_cidrs):
-        """Return the set of nodes (optionally based on the specified
-        self) without any interfaces configured on one of the
-        specified subnet with the given CIDRs.
+    def exclude_subnet_cidrs(self, subnet_cidrs):
+        """Return the set of nodes without any interfaces configured on one of
+        the specified subnet with the given CIDRs.
         """
         return self.exclude(
             interface__ip_addresses__subnet__cidr__in=subnet_cidrs)

=== modified file 'src/maasserver/models/subnet.py'
--- src/maasserver/models/subnet.py	2015-09-24 16:22:12 +0000
+++ src/maasserver/models/subnet.py	2015-10-30 19:51:38 +0000
@@ -28,7 +28,9 @@
     ForeignKey,
     Manager,
     PROTECT,
+    Q,
 )
+from django.db.models.query import QuerySet
 from django.shortcuts import get_object_or_404
 from djorm_pgarray.fields import ArrayField
 from maasserver import DefaultMeta
@@ -42,14 +44,18 @@
 )
 from maasserver.models.cleansave import CleanSave
 from maasserver.models.timestampedmodel import TimestampedModel
+from maasserver.utils.orm import MAASQueriesMixin
 from netaddr import (
+    AddrFormatError,
     IPAddress,
     IPNetwork,
 )
+from provisioningserver.utils import flatten
 from provisioningserver.utils.network import (
     MAASIPSet,
     make_ipaddress,
     make_iprange,
+    parse_integer,
 )
 
 
@@ -92,13 +98,65 @@
     return unicode(cidr)
 
 
-class SubnetManager(Manager):
-    """Manager for :class:`Subnet` model."""
-
-    def create_from_cidr(self, cidr, vlan, space):
-        """Create a subnet from the given CIDR."""
-        name = "subnet-" + unicode(cidr)
-        return self.create(name=name, cidr=cidr, vlan=vlan, space=space)
+def parse_item_operation(specifier):
+    """
+    Returns a tuple indicating the specifier string, and its related
+    operation (if one was found).
+
+    If the first character in the specifier is '|', the operator will be OR.
+
+    If the first character in the specifier is '&', the operator will be AND.
+
+    If unspecified, the default operator is OR.
+
+    :param specifier: a string containing the specifier.
+    :return: tuple
+    """
+    specifier = specifier.strip()
+
+    from operator import (
+        and_ as AND,
+        or_ as OR,
+    )
+
+    if specifier.startswith('|'):
+        op = OR
+        specifier = specifier[1:]
+    elif specifier.startswith('&'):
+        op = AND
+        specifier = specifier[1:]
+    else:
+        # Default to OR.
+        op = OR
+    return specifier, op
+
+
+def parse_item_specifier_type(specifier, types=frozenset(), separator=':'):
+    """
+    Returns a tuple that splits the string int a specifier, and its specifier
+    type.
+
+    Retruns a tuple of (specifier, specifier_type). If no specifier type could
+    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 separator: Optional specifier. Defaults to ':'.
+    :return: tuple
+    """
+    if separator in specifier:
+        tokens = specifier.split(separator, 1)
+        if tokens[0] in types:
+            specifier_type = tokens[0]
+            specifier = tokens[1].strip()
+        else:
+            specifier_type = None
+    else:
+        specifier_type = None
+    return specifier, specifier_type
+
+
+class SubnetQueriesMixin(MAASQueriesMixin):
 
     find_subnets_with_ip_query = """
         SELECT DISTINCT subnet.*, masklen(subnet.cidr) "prefixlen"
@@ -109,7 +167,7 @@
         ORDER BY prefixlen DESC
         """
 
-    def get_subnets_with_ip(self, ip):
+    def raw_subnets_containing_ip(self, ip):
         """Find the most specific Subnet the specified IP address belongs in.
         """
         return self.raw(
@@ -135,8 +193,7 @@
         LEFT OUTER JOIN maasserver_nodegroup AS nodegroup
           ON ngi.nodegroup_id = nodegroup.id
         WHERE
-            %s << subnet.cidr AND /* Specified IP is inside range */
-            vlan.fabric_id = %s
+            %s << subnet.cidr /* Specified IP is inside range */
         ORDER BY
             /* For nodegroup_status, 1=ENABLED, 2=DISABLED, and NULL
                means the outer join didn't find a related NodeGroup. */
@@ -151,27 +208,149 @@
         LIMIT 1
         """
 
-    def get_best_subnet_for_ip(self, ip, fabric=None):
+    def get_best_subnet_for_ip(self, ip):
         """Find the most-specific managed Subnet the specified IP address
         belongs to.
 
         The most-specific Subnet is a Subnet that is both referred to by
-        a managed, active NodeGroupInterface, and on the specified Fabric.
-
-        If no Fabric is specified, uses the default Fabric.
+        a managed, active NodeGroupInterface.
         """
-        # Circular imports
-        fabric = self._find_fabric(fabric)
-
         subnets = self.raw(
             self.find_best_subnet_for_ip_query,
-            params=[unicode(ip), fabric])
+            params=[unicode(ip)])
 
         for subnet in subnets:
             return subnet  # This is stable because the query is ordered.
         else:
             return None
 
+    SUBNET_SPECIFIER_TYPES = frozenset({
+        'ip',
+        'cidr',
+        'name',
+        'vlan',
+        'vid',
+        'space',
+    })
+
+    def validate_filter_specifiers(self, specifiers):
+        """Validate the given filter string."""
+        try:
+            self.filter_by_specifiers(specifiers)
+        except (ValueError, AddrFormatError) as e:
+            raise ValidationError(e.message)
+
+    def _get_specifiers_query(self, specifiers):
+        """Returns a Q object for objects matching the given specifiers.
+
+        See documentation for `filter_by_specifiers()`.
+
+        :return:django.db.models.Q
+        """
+        current_q = Q()
+        # Handle a single item, or a list.
+        specifiers = list(flatten(specifiers))
+        for item in specifiers:
+            item, op = parse_item_operation(item)
+            item, specifier_type = parse_item_specifier_type(
+                item, types=self.SUBNET_SPECIFIER_TYPES)
+
+            if specifier_type == 'ip':
+                # Try to validate this before it hits the database, since this
+                # is going to be a raw query.
+                item = unicode(IPAddress(item))
+                # This is a special case. If a specific IP filter is included,
+                # a custom query is needed to get the result. We can't chain
+                # a raw query using Q without grabbing the IDs first.
+                ids = self.get_id_list(self.raw_subnets_containing_ip(item))
+                current_q = op(current_q, Q(id__in=ids))
+            elif specifier_type == 'name':
+                current_q = op(current_q, Q(name=item))
+            elif specifier_type == 'vlan' or specifier_type == 'vid':
+                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))
+            elif specifier_type == 'cidr':
+                ip = IPNetwork(item)
+                cidr = unicode(ip.cidr)
+                current_q = op(current_q, Q(cidr=cidr))
+            elif specifier_type == 'space':
+                current_q = op(current_q, Q(space__name=item))
+            else:
+                # 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(cidr=cidr))
+        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.
+
+        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)
+
+
+class SubnetQuerySet(QuerySet, SubnetQueriesMixin):
+    """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 SubnetManager(Manager, SubnetQueriesMixin):
+    """Manager for :class:`Subnet` model."""
+
+    def get_queryset(self):
+        queryset = SubnetQuerySet(self.model, using=self._db)
+        return queryset
+
+    def create_from_cidr(self, cidr, vlan, space):
+        """Create a subnet from the given CIDR."""
+        name = "subnet-" + unicode(cidr)
+        return self.create(name=name, cidr=cidr, vlan=vlan, space=space)
+
     def _find_fabric(self, fabric):
         from maasserver.models import Fabric
 

=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2015-10-30 12:27:37 +0000
+++ src/maasserver/models/tests/test_node.py	2015-10-30 19:51:38 +0000
@@ -2703,7 +2703,7 @@
         ip = iface.ip_addresses.first()
         space = ip.subnet.space
         self.assertItemsEqual(
-            [extra_node], Node.objects.filter_by_not_spaces([space]))
+            [extra_node], Node.objects.exclude_spaces([space]))
 
     def test_filter_nodes_by_fabrics(self):
         fabric = factory.make_Fabric()
@@ -2722,7 +2722,7 @@
         iface = node.get_boot_interface()
         fabric = iface.vlan.fabric
         self.assertItemsEqual(
-            [extra_node], Node.objects.filter_by_not_fabrics([fabric]))
+            [extra_node], Node.objects.exclude_fabrics([fabric]))
 
     def test_filter_nodes_by_fabric_classes(self):
         fabric1 = factory.make_Fabric(class_type="10g")
@@ -2738,7 +2738,7 @@
         factory.make_Node_with_Interface_on_Subnet(fabric=fabric1)
         node2 = factory.make_Node_with_Interface_on_Subnet(fabric=fabric2)
         self.assertItemsEqual(
-            [node2], Node.objects.filter_by_not_fabric_classes(["10g"]))
+            [node2], Node.objects.exclude_fabric_classes(["10g"]))
 
     def test_filter_nodes_by_vids(self):
         vlan1 = factory.make_VLAN(vid=1)
@@ -2754,7 +2754,7 @@
         factory.make_Node_with_Interface_on_Subnet(vlan=vlan1)
         node2 = factory.make_Node_with_Interface_on_Subnet(vlan=vlan2)
         self.assertItemsEqual(
-            [node2], Node.objects.filter_by_not_vids([1]))
+            [node2], Node.objects.exclude_vids([1]))
 
     def test_filter_nodes_by_subnet(self):
         subnet1 = factory.make_Subnet()
@@ -2770,7 +2770,7 @@
         factory.make_Node_with_Interface_on_Subnet(subnet=subnet1)
         node2 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet2)
         self.assertItemsEqual(
-            [node2], Node.objects.filter_by_not_subnets([subnet1]))
+            [node2], Node.objects.exclude_subnets([subnet1]))
 
     def test_filter_nodes_by_subnet_cidr(self):
         subnet1 = factory.make_Subnet(cidr='192.168.1.0/24')
@@ -2786,7 +2786,7 @@
         factory.make_Node_with_Interface_on_Subnet(subnet=subnet1)
         node2 = factory.make_Node_with_Interface_on_Subnet(subnet=subnet2)
         self.assertItemsEqual(
-            [node2], Node.objects.filter_by_not_subnet_cidrs(
+            [node2], Node.objects.exclude_subnet_cidrs(
                 ['192.168.1.0/24']))
 
     def test_filter_fabric_subnet_filter_chain(self):
@@ -2800,7 +2800,7 @@
         self.assertItemsEqual(
             [node2], Node.objects
                          .filter_by_fabrics([fabric1])
-                         .filter_by_not_subnet_cidrs(['192.168.1.0/24']))
+                         .exclude_subnet_cidrs(['192.168.1.0/24']))
 
     def test_get_visible_node_or_404_ok(self):
         """get_node_or_404 fetches nodes by system_id."""

=== modified file 'src/maasserver/models/tests/test_subnet.py'
--- src/maasserver/models/tests/test_subnet.py	2015-09-24 16:22:12 +0000
+++ src/maasserver/models/tests/test_subnet.py	2015-10-30 19:51:38 +0000
@@ -98,6 +98,163 @@
         self.assertEqual("169.254.0.0/16", cidr)
 
 
+class TestSubnetManager(MAASServerTestCase):
+
+    def test__filter_by_specifiers_takes_single_item(self):
+        subnet1 = factory.make_Subnet(name="subnet1")
+        factory.make_Subnet(name="subnet2")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("subnet1"),
+            [subnet1])
+
+    def test__filter_by_specifiers_takes_multiple_items(self):
+        subnet1 = factory.make_Subnet(name="subnet1")
+        subnet2 = factory.make_Subnet(name="subnet2")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(["subnet1", "subnet2"]),
+            [subnet1, subnet2])
+
+    def test__filter_by_specifiers_takes_multiple_cidr_or_name(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        subnet2 = factory.make_Subnet(name="subnet2")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(["8.8.8.8/24", "subnet2"]),
+            [subnet1, subnet2])
+
+    def test__filter_by_specifiers_empty_filter_matches_all(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        subnet2 = factory.make_Subnet(name="subnet2")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers([]),
+            [subnet1, subnet2])
+
+    def test__filter_by_specifiers_matches_name_if_requested(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        subnet2 = factory.make_Subnet(name="subnet2")
+        factory.make_Subnet(name="subnet3")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["name:subnet1", "name:subnet2"]),
+            [subnet1, subnet2])
+
+    def test__filter_by_specifiers_matches_space_name_if_requested(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        subnet2 = factory.make_Subnet(name="subnet2")
+        factory.make_Subnet(name="subnet3")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["space:%s" % subnet1.space.name,
+                 "space:%s" % subnet2.space.name]),
+            [subnet1, subnet2])
+
+    def test__filter_by_specifiers_matches_vid_if_requested(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24", vid=1)
+        subnet2 = factory.make_Subnet(name="subnet2", vid=2)
+        subnet3 = factory.make_Subnet(name="subnet3", vid=3)
+        factory.make_Subnet(name="subnet4", vid=4)
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["vlan:0b1", "vlan:0x2", "vlan:3"]),
+            [subnet1, subnet2, subnet3])
+
+    def test__filter_by_specifiers_matches_untagged_vlan_if_requested(self):
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        subnet1 = factory.make_Subnet(
+            name="subnet1", cidr="8.8.8.0/24", vlan=vlan)
+        subnet2 = factory.make_Subnet(name="subnet2", vid=2)
+        subnet3 = factory.make_Subnet(name="subnet3", vid=3)
+        factory.make_Subnet(name="subnet4", vid=4)
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["vid:UNTAGGED", "vid:0x2", "vid:3"]),
+            [subnet1, subnet2, subnet3])
+
+    def test__filter_by_specifiers_raises_for_invalid_vid(self):
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        factory.make_Subnet(
+            name="subnet1", cidr="8.8.8.0/24", vlan=vlan)
+        factory.make_Subnet(name="subnet2", vid=2)
+        factory.make_Subnet(name="subnet3", vid=3)
+        factory.make_Subnet(name="subnet4", vid=4)
+        with ExpectedException(ValidationError):
+            Subnet.objects.filter_by_specifiers(["vid:4095"])
+
+    def test__filter_by_specifiers_works_with_chained_filter(self):
+        factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        subnet2 = factory.make_Subnet(name="subnet2")
+        self.assertItemsEqual(
+            Subnet.objects
+                  .exclude(name="subnet1")
+                  .filter_by_specifiers(["8.8.8.8/24", "subnet2"]),
+            [subnet2])
+
+    def test__filter_by_specifiers_ip_filter_matches_specific_ip(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        subnet2 = factory.make_Subnet(name="subnet2", cidr="7.7.7.0/24")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("ip:8.8.8.8"),
+            [subnet1])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("ip:7.7.7.7"),
+            [subnet2])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("ip:1.1.1.1"),
+            [])
+
+    def test__filter_by_specifiers_ip_filter_raises_for_invalid_ip(self):
+        factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        factory.make_Subnet(name="subnet2", cidr="2001:db8::/64")
+        with ExpectedException(AddrFormatError):
+            Subnet.objects.filter_by_specifiers("ip:x8.8.8.0"),
+        with ExpectedException(AddrFormatError):
+            Subnet.objects.filter_by_specifiers("ip:x2001:db8::"),
+
+    def test__filter_by_specifiers_ip_filter_matches_specific_cidr(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        subnet2 = factory.make_Subnet(name="subnet2", cidr="2001:db8::/64")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("cidr:8.8.8.0/24"),
+            [subnet1])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("cidr:2001:db8::/64"),
+            [subnet2])
+
+    def test__filter_by_specifiers_ip_filter_raises_for_invalid_cidr(self):
+        factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        factory.make_Subnet(name="subnet2", cidr="2001:db8::/64")
+        with ExpectedException(ValueError):
+            # netaddr.IPNetwork should probably raise AddrFormatError here,
+            # but it actually raises a ValueError when it tries to parse "x8".
+            Subnet.objects.filter_by_specifiers("cidr:x8.8.8.0/24"),
+        with ExpectedException(AddrFormatError):
+            Subnet.objects.filter_by_specifiers("cidr:x2001:db8::/64"),
+
+    def test__filter_by_specifiers_ip_chained_filter_matches_specific_ip(self):
+        subnet1 = factory.make_Subnet(name="subnet1", cidr="8.8.8.0/24")
+        factory.make_Subnet(name="subnet2", cidr="7.7.7.0/24")
+        subnet3 = factory.make_Subnet(name="subnet3", cidr="6.6.6.0/24")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["ip:8.8.8.8", "name:subnet3"]), [subnet1, subnet3])
+
+    def test__filter_by_specifiers_ip_filter_matches_specific_ipv6(self):
+        subnet1 = factory.make_Subnet(
+            name="subnet1", cidr="2001:db8::/64")
+        subnet2 = factory.make_Subnet(
+            name="subnet2", cidr="2001:db8:1::/64")
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("ip:2001:db8::5"),
+            [subnet1])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("ip:2001:db8:1::5"),
+            [subnet2])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers("ip:1.1.1.1"),
+            [])
+
+
 class TestSubnetManagerGetSubnetOr404(MAASServerTestCase):
 
     def test__user_view_returns_subnet(self):
@@ -152,7 +309,7 @@
 class SubnetTest(MAASServerTestCase):
 
     def assertIPBestMatchesSubnet(self, ip, expected):
-        subnets = Subnet.objects.get_subnets_with_ip(IPAddress(ip))
+        subnets = Subnet.objects.raw_subnets_containing_ip(IPAddress(ip))
         for tmp in subnets:
             subnet = tmp
             break

=== modified file 'src/maasserver/node_constraint_filter_forms.py'
--- src/maasserver/node_constraint_filter_forms.py	2015-10-28 21:43:50 +0000
+++ src/maasserver/node_constraint_filter_forms.py	2015-10-30 19:51:38 +0000
@@ -15,10 +15,6 @@
     ]
 
 
-from abc import (
-    ABCMeta,
-    abstractmethod,
-)
 from collections import defaultdict
 import itertools
 from itertools import chain
@@ -39,17 +35,13 @@
     PhysicalBlockDevice,
     Subnet,
     Tag,
-    VLAN,
     Zone,
 )
-from maasserver.models.subnet import SUBNET_NAME_VALIDATOR
 from maasserver.models.zone import ZONE_NAME_VALIDATOR
 from maasserver.utils.orm import (
     macs_contain,
     macs_do_not_contain,
 )
-from netaddr import IPAddress
-from netaddr.core import AddrFormatError
 from provisioningserver.utils.constraints import LabeledConstraintMap
 
 # Matches the storage constraint from Juju. Format is an optional label,
@@ -100,7 +92,7 @@
     if ','.join(rendered_groups) != value:
         raise ValidationError('Malformed storage constraint, "%s".' % value)
 
-NETWORKING_CONSTRAINT_KEYS = frozenset({
+NETWORKING_CONSTRAINT_NAMES = {
     'space',
     'not_space',
     'fabric_class',
@@ -114,21 +106,21 @@
     'subnet',
     'not_subnet',
     'mode',
-})
-
-
-def networking_validator(constraint_map):
+}
+
+
+def interfaces_validator(constraint_map):
     """Validate the given LabeledConstraintMap object."""
     # At this point, the basic syntax of a labeled constraint map will have
     # already been validated by the underlying form field. However, we also
     # need to validate the specified things we're looking for in the
-    # networking domain.
+    # interfaces domain.
     for label in constraint_map:
         constraints = constraint_map[label]
         for constraint_name in constraints.iterkeys():
-            if constraint_name not in NETWORKING_CONSTRAINT_KEYS:
+            if constraint_name not in NETWORKING_CONSTRAINT_NAMES:
                 raise ValidationError(
-                    "Unknown networking constraint: '%s" % constraint_name)
+                    "Unknown interfaces constraint: '%s" % constraint_name)
 
 
 def generate_architecture_wildcards(arches):
@@ -385,169 +377,6 @@
     return nodes
 
 
-def strip_type_tag(type_tag, specifier):
-    """Return a network specifier minus its type tag."""
-    prefix = type_tag + ':'
-    assert specifier.startswith(prefix)
-    return specifier[len(prefix):]
-
-
-class SubnetSpecifier:
-    """A :class:`SubnetSpecifier` identifies a :class:`Subnet`.
-
-    For example, in placement constraints, a user may specify that a node
-    must be attached to a certain subnet.  They identify the subnet through
-    a subnet specifier, which may be its name (`dmz`), an IP address
-    (`ip:10.12.0.0`), or a VLAN tag (`vlan:15` or `vlan:0xf`).
-
-    Each type of subnet specifier has its own `SubnetSpecifier`
-    implementation class.  The class constructor validates and parses a
-    subnet specifier of its type, and the object knows how to retrieve
-    whatever subnet it identifies from the database.
-    """
-    __metaclass__ = ABCMeta
-
-    # Most subnet specifiers start with a type tag followed by a colon, e.g.
-    # "ip:10.1.0.0".
-    type_tag = None
-
-    @abstractmethod
-    def find_subnet(self):
-        """Load the identified :class:`Subnet` from the database.
-
-        :raise Subnet.DoesNotExist: If no subnet matched the specifier.
-        :return: The :class:`Subnet`.
-        """
-
-
-class NameSpecifier(SubnetSpecifier):
-    """Identify a subnet by its name.
-
-    This type of subnet specifier has no type tag; it's just the name.  A
-    subnet name cannot contain colon (:) characters.
-    """
-
-    def __init__(self, spec):
-        SUBNET_NAME_VALIDATOR(spec)
-        self.name = spec
-
-    def find_subnet(self):
-        return Subnet.objects.get(name=self.name)
-
-
-class IPSpecifier(SubnetSpecifier):
-    """Identify a subnet by any IP address it contains.
-
-    The IP address is prefixed with a type tag `ip:`, e.g. `ip:10.1.1.0`.
-    It can name any IP address within the subnet, including its base address,
-    its broadcast address, or any host address that falls in its IP range.
-    """
-    type_tag = 'ip'
-
-    def __init__(self, spec):
-        ip_string = strip_type_tag(self.type_tag, spec)
-        try:
-            self.ip = IPAddress(ip_string)
-        except AddrFormatError as e:
-            raise ValidationError("Invalid IP address: %s." % e)
-
-    def find_subnet(self):
-        subnets = list(Subnet.objects.get_subnets_with_ip(self.ip))
-        if len(subnets) > 0:
-            return subnets[0]
-        raise Subnet.DoesNotExist()
-
-
-class VLANSpecifier(SubnetSpecifier):
-    """Identify a subnet by its (nonzero) VLAN tag.
-
-    This only applies to VLANs.  The VLAN tag is a numeric value prefixed with
-    a type tag of `vlan:`, e.g. `vlan:12`.  Tags may also be given in
-    hexadecimal form: `vlan:0x1a`.  This is case-insensitive.
-    """
-    type_tag = 'vlan'
-
-    def __init__(self, spec):
-        vlan_string = strip_type_tag(self.type_tag, spec)
-        if vlan_string.lower().startswith('0x'):
-            # Hexadecimal.
-            base = 16
-        else:
-            # Decimal.
-            base = 10
-        try:
-            self.vlan_tag = int(vlan_string, base)
-        except ValueError:
-            raise ValidationError("Invalid VLAN tag: '%s'." % vlan_string)
-        if self.vlan_tag <= 0 or self.vlan_tag >= 0xfff:
-            raise ValidationError("VLAN tag out of range (1-4094).")
-
-    def find_subnet(self):
-        # The best we can do since we now support a more complex model is
-        # get the first VLAN with the VID and the first subnet in that VLAN.
-        vlans = VLAN.objects.filter(vid=self.vlan_tag)
-        if len(vlans) > 0:
-            subnet = vlans[0].subnet_set.first()
-            if subnet is not None:
-                return subnet
-        raise Subnet.DoesNotExist()
-
-
-SPECIFIER_CLASSES = [NameSpecifier, IPSpecifier, VLANSpecifier]
-
-SPECIFIER_TAGS = {
-    spec_class.type_tag: spec_class
-    for spec_class in SPECIFIER_CLASSES
-}
-
-
-def get_specifier_type(specifier):
-    """Obtain the specifier class that knows how to parse `specifier`.
-
-    :raise ValidationError: If `specifier` does not match any accepted type of
-        network specifier.
-    :return: A concrete `NetworkSpecifier` subclass that knows how to parse
-        `specifier`.
-    """
-    if ':' in specifier:
-        type_tag, _ = specifier.split(':', 1)
-    else:
-        type_tag = None
-    specifier_class = SPECIFIER_TAGS.get(type_tag)
-    if specifier_class is None:
-        raise ValidationError(
-            "Invalid network specifier type: '%s'." % type_tag)
-    return specifier_class
-
-
-def parse_subnet_spec(spec):
-    """Parse a network specifier; return it as a `NetworkSpecifier` object.
-
-    :raise ValidationError: If `spec` is malformed.
-    """
-    specifier_class = get_specifier_type(spec)
-    return specifier_class(spec)
-
-
-def get_subnet_from_spec(spec):
-    """Find a single `Subnet` from a given network specifier.
-
-    Note: This exists for a backward compatability layer for how MAAS used to
-    do networking. It might not always be correct since the model is now more
-    complex, but it will atleast still work.
-
-    :raise ValidationError: If `spec` is malformed.
-    :raise Subnet.DoesNotExist: If the subnet specifier does not match
-        any known subnet.
-    :return: The one `Subnet` matching `spec`.
-    """
-    specifier = parse_subnet_spec(spec)
-    try:
-        return specifier.find_subnet()
-    except Subnet.DoesNotExist:
-        raise Subnet.DoesNotExist("No subnet matching '%s'." % spec)
-
-
 class LabeledConstraintMapField(Field):
 
     def __init__(self, *args, **kwargs):
@@ -584,16 +413,49 @@
     not_tags = UnconstrainedMultipleChoiceField(
         label="Not having tags", required=False)
 
+    # XXX mpontillo 2015-10-30 need validators for fabric constraints
+    fabrics = ValidatorMultipleChoiceField(
+        validator=lambda x: True, label="Attached to fabrics",
+        required=False, error_messages={
+            'invalid_list': "Invalid parameter: list of fabrics required.",
+            })
+
+    not_fabrics = ValidatorMultipleChoiceField(
+        validator=lambda x: True, label="Not attached to fabrics",
+        required=False, error_messages={
+            'invalid_list': "Invalid parameter: list of fabrics required.",
+            })
+
+    fabric_classes = ValidatorMultipleChoiceField(
+        validator=lambda x: True,
+        label="Attached to fabric with specified classes",
+        required=False, error_messages={
+            'invalid_list':
+            "Invalid parameter: list of fabric classes required.",
+        })
+
+    not_fabric_classes = ValidatorMultipleChoiceField(
+        validator=lambda x: True,
+        label="Not attached to fabric with specified classes",
+        required=False, error_messages={
+            'invalid_list':
+            "Invalid parameter: list of fabric classes required."
+        })
+
     networks = ValidatorMultipleChoiceField(
-        validator=parse_subnet_spec, label="Attached to networks",
+        validator=Subnet.objects.validate_filter_specifiers,
+        label="Attached to subnets",
         required=False, error_messages={
-            'invalid_list': "Invalid parameter: list of networks required.",
+            'invalid_list':
+            "Invalid parameter: list of subnet specifiers required.",
             })
 
     not_networks = ValidatorMultipleChoiceField(
-        validator=parse_subnet_spec, label="Not attached to networks",
+        validator=Subnet.objects.validate_filter_specifiers,
+        label="Not attached to subnets",
         required=False, error_messages={
-            'invalid_list': "Invalid parameter: list of networks required.",
+            'invalid_list':
+            "Invalid parameter: list of subnet specifiers required.",
             })
 
     connected_to = ValidatorMultipleChoiceField(
@@ -619,8 +481,8 @@
     storage = forms.CharField(
         validators=[storage_validator], label="Storage", required=False)
 
-    networking = LabeledConstraintMapField(
-        validators=[networking_validator], label="Networking", required=False)
+    interfaces = LabeledConstraintMapField(
+        validators=[interfaces_validator], label="Interfaces", required=False)
 
     ignore_unknown_constraints = True
 
@@ -696,23 +558,24 @@
                 {self.get_field_name('not_in_zone'): [error_msg]})
         return value
 
+    def _clean_subnet_specifiers(self, specifiers):
+        if not specifiers:
+            return None
+        subnets = set(Subnet.objects.filter_by_specifiers(specifiers))
+        if len(subnets) == 0:
+            raise ValidationError("No matching subnets found.")
+        return subnets
+
     def clean_networks(self):
         value = self.cleaned_data[self.get_field_name('networks')]
-        if value is None:
-            return None
-        try:
-            return [get_subnet_from_spec(spec) for spec in value]
-        except Subnet.DoesNotExist as e:
-            raise ValidationError(e.message)
+        return self._clean_subnet_specifiers(value)
 
     def clean_not_networks(self):
         value = self.cleaned_data[self.get_field_name('not_networks')]
-        if value is None:
-            return None
-        try:
-            return [get_subnet_from_spec(spec) for spec in value]
-        except Subnet.DoesNotExist as e:
-            raise ValidationError(e.message)
+        return self._clean_subnet_specifiers(value)
+
+    def __init__(self, *args, **kwargs):
+        super(AcquireNodeForm, self).__init__(*args, **kwargs)
 
     def clean(self):
         if not self.ignore_unknown_constraints:
@@ -829,21 +692,51 @@
             not_in_zones = Zone.objects.filter(name__in=not_in_zone)
             filtered_nodes = filtered_nodes.exclude(zone__in=not_in_zones)
 
-        # Filter by networks.
+        # Filter by subnet.
         subnets = self.cleaned_data.get(self.get_field_name('networks'))
-        if subnets is not None:
+        if subnets is not None and len(subnets) > 0:
             for subnet in set(subnets):
                 filtered_nodes = filtered_nodes.filter(
                     interface__ip_addresses__subnet=subnet)
 
-        # Filter by not_networks.
+        # Filter by not_subnets.
         not_subnets = self.cleaned_data.get(
             self.get_field_name('not_networks'))
-        if not_subnets is not None:
+        if not_subnets is not None and len(not_subnets) > 0:
             for not_subnet in set(not_subnets):
                 filtered_nodes = filtered_nodes.exclude(
                     interface__ip_addresses__subnet=not_subnet)
 
+        # Filter by fabrics.
+        fabrics = self.cleaned_data.get(self.get_field_name('fabrics'))
+        if fabrics is not None and len(fabrics) > 0:
+            # XXX mpontillo 2015-10-30 need to also handle fabrics whose name
+            # is null (fabric-<id>).
+            filtered_nodes = filtered_nodes.filter(
+                interface__vlan__fabric__name__in=fabrics)
+
+        # Filter by not_fabrics.
+        not_fabrics = self.cleaned_data.get(self.get_field_name('not_fabrics'))
+        if not_fabrics is not None and len(not_fabrics) > 0:
+            # XXX mpontillo 2015-10-30 need to also handle fabrics whose name
+            # is null (fabric-<id>).
+            filtered_nodes = filtered_nodes.exclude(
+                interface__vlan__fabric__name__in=not_fabrics)
+
+        # Filter by fabric classes.
+        fabric_classes = self.cleaned_data.get(self.get_field_name(
+            'fabric_classes'))
+        if fabric_classes is not None and len(fabric_classes) > 0:
+            filtered_nodes = filtered_nodes.filter(
+                interface__vlan__fabric__class_type__in=fabric_classes)
+
+        # Filter by not_fabric_classes.
+        not_fabric_classes = self.cleaned_data.get(self.get_field_name(
+            'not_fabric_classes'))
+        if not_fabric_classes is not None and len(not_fabric_classes) > 0:
+            filtered_nodes = filtered_nodes.exclude(
+                interface__vlan__fabric__class_type__in=not_fabric_classes)
+
         # Filter by connected_to.
         connected_to = self.cleaned_data.get(
             self.get_field_name('connected_to'))

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2015-10-30 12:27:37 +0000
+++ src/maasserver/testing/factory.py	2015-10-30 19:51:38 +0000
@@ -277,7 +277,7 @@
             routers=None, zone=None, networks=None, boot_type=None,
             sortable_name=False, power_type=None, power_parameters=None,
             power_state=None, power_state_updated=undefined, disable_ipv4=None,
-            with_boot_disk=True, vlan=None, **kwargs):
+            with_boot_disk=True, vlan=None, fabric=None, **kwargs):
         """Make a :class:`Node`.
 
         :param sortable_name: If `True`, use a that will sort consistently
@@ -327,7 +327,8 @@
         if networks is not None:
             node.networks.add(*networks)
         if interface:
-            self.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node, vlan=vlan)
+            self.make_Interface(
+                INTERFACE_TYPE.PHYSICAL, node=node, vlan=vlan, fabric=fabric)
         if installable and with_boot_disk:
             self.make_PhysicalBlockDevice(node=node)
 
@@ -578,7 +579,7 @@
             iftype = kwargs['iftype']
             del kwargs['iftype']
         node = self.make_Node(
-            nodegroup=nodegroup, **kwargs)
+            nodegroup=nodegroup, fabric=fabric, **kwargs)
         if vlan is None:
             vlan = self.make_VLAN(fabric=fabric)
         if subnet is None:
@@ -694,11 +695,11 @@
 
     def make_Subnet(self, name=None, vlan=None, space=None, cidr=None,
                     gateway_ip=None, dns_servers=None, host_bits=None,
-                    fabric=None):
+                    fabric=None, vid=None):
         if name is None:
             name = factory.make_name('name')
         if vlan is None:
-            vlan = factory.make_VLAN(fabric=fabric)
+            vlan = factory.make_VLAN(fabric=fabric, vid=vid)
         if space is None:
             space = factory.make_Space()
         if cidr is None:
@@ -759,13 +760,13 @@
     def make_Interface(
             self, iftype=INTERFACE_TYPE.PHYSICAL, node=None, mac_address=None,
             vlan=None, parents=None, name=None, cluster_interface=None,
-            ip=None, enabled=True):
+            ip=None, enabled=True, fabric=None):
         if name is None and iftype != INTERFACE_TYPE.VLAN:
             name = self.make_name('name')
         if iftype is None:
             iftype = INTERFACE_TYPE.PHYSICAL
         if vlan is None:
-            vlan = self.make_VLAN()
+            vlan = self.make_VLAN(fabric=fabric)
         if (mac_address is None and
                 iftype in [
                     INTERFACE_TYPE.PHYSICAL,

=== modified file 'src/maasserver/tests/test_node_constraint_filter_forms.py'
--- src/maasserver/tests/test_node_constraint_filter_forms.py	2015-10-28 17:09:26 +0000
+++ src/maasserver/tests/test_node_constraint_filter_forms.py	2015-10-30 19:51:38 +0000
@@ -233,7 +233,7 @@
 
     def assertConstrainedNodes(self, nodes, data):
         form = AcquireNodeForm(data=data)
-        self.assertTrue(form.is_valid(), form.errors)
+        self.assertTrue(form.is_valid(), dict(form.errors))
         filtered_nodes, _ = form.filter_nodes(Node.objects.all())
         self.assertItemsEqual(nodes, filtered_nodes)
 
@@ -299,6 +299,22 @@
             (False, {'mem': ["Invalid memory: number of MiB required."]}),
             (form.is_valid(), form.errors))
 
+    def test_legacy_networks_field_falls_back_to_subnets_query(self):
+        subnets = [
+            factory.make_Subnet()
+            for _ in range(3)
+            ]
+        nodes = [
+            factory.make_Node_with_Interface_on_Subnet(subnet=subnet)
+            for subnet in subnets
+            ]
+        # Filter for this subnet.  Take one in the middle to avoid
+        # coincidental success based on ordering.
+        pick = 1
+        self.assertConstrainedNodes(
+            {nodes[pick]},
+            {'networks': [subnets[pick].name]})
+
     def test_networks_filters_by_name(self):
         subnets = [
             factory.make_Subnet()
@@ -310,11 +326,27 @@
             ]
         # Filter for this subnet.  Take one in the middle to avoid
         # coincidental success based on ordering.
-        pick = 2
+        pick = 1
         self.assertConstrainedNodes(
             {nodes[pick]},
             {'networks': [subnets[pick].name]})
 
+    def test_networks_filters_by_space(self):
+        subnets = [
+            factory.make_Subnet()
+            for _ in range(3)
+            ]
+        nodes = [
+            factory.make_Node_with_Interface_on_Subnet(subnet=subnet)
+            for subnet in subnets
+            ]
+        # Filter for this subnet.  Take one in the middle to avoid
+        # coincidental success based on ordering.
+        pick = 1
+        self.assertConstrainedNodes(
+            {nodes[pick]},
+            {'networks': ["space:%s" % subnets[pick].space.name]})
+
     def test_networks_filters_by_ip(self):
         subnets = [
             factory.make_Subnet()
@@ -326,7 +358,7 @@
             ]
         # Filter for this subnet.  Take one in the middle to avoid
         # coincidental success based on ordering.
-        pick = 2
+        pick = 1
         self.assertConstrainedNodes(
             {nodes[pick]},
             {'networks': [
@@ -345,7 +377,7 @@
             ]
         # Filter for this network.  Take one in the middle to avoid
         # coincidental success based on ordering.
-        pick = 2
+        pick = 1
         self.assertConstrainedNodes(
             {nodes[pick]},
             {'networks': ['vlan:%d' % vlan_tags[pick]]})
@@ -371,14 +403,15 @@
             {node},
             {'networks': [subnets[1].name]})
 
-    def test_invalid_networks(self):
+    def test_invalid_subnets(self):
         form = AcquireNodeForm(data={'networks': 'ip:10.0.0.0'})
         self.assertEquals(
             (
                 False,
                 {
                     'networks': [
-                        "Invalid parameter: list of networks required.",
+                        "Invalid parameter: "
+                        "list of subnet specifiers required.",
                         ],
                 },
             ),
@@ -388,7 +421,8 @@
         # is being consulted.
         form = AcquireNodeForm(data={'networks': ['vlan:-1']})
         self.assertEquals(
-            (False, {'networks': ["VLAN tag out of range (1-4094)."]}),
+            (False, {'networks': [
+                "VLAN tag (VID) out of range (0-4094; 0 for untagged.)"]}),
             (form.is_valid(), form.errors))
 
     def test_networks_combines_filters(self):
@@ -430,6 +464,17 @@
             [node],
             {'networks': [this_subnet.name]})
 
+    def test_legacy_not_networks_falls_back_to_not_networks_query(self):
+        [not_subnet, subnet] = [
+            factory.make_Subnet()
+            for _ in range(2)
+        ]
+        factory.make_Node_with_Interface_on_Subnet(subnet=not_subnet)
+        node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet)
+        self.assertConstrainedNodes(
+            {node},
+            {'not_networks': [not_subnet.name]})
+
     def test_not_networks_filters_by_name(self):
         [subnet, not_subnet] = [
             factory.make_Subnet()
@@ -474,7 +519,7 @@
             {interfaceless_node, unconnected_node},
             {'not_networks': [factory.make_Subnet().name]})
 
-    def test_not_networks_exclude_node_with_any_interface_on_not_subnets(self):
+    def test_not_networks_exclude_node_with_any_interface(self):
         subnet = factory.make_Subnet()
         node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet)
         other_subnet = factory.make_Subnet()
@@ -497,7 +542,8 @@
                 False,
                 {
                     'not_networks': [
-                        "Invalid parameter: list of networks required.",
+                        "Invalid parameter: "
+                        "list of subnet specifiers required.",
                         ],
                 },
             ),
@@ -507,7 +553,8 @@
         # is being consulted.
         form = AcquireNodeForm(data={'not_networks': ['vlan:-1']})
         self.assertEquals(
-            (False, {'not_networks': ["VLAN tag out of range (1-4094)."]}),
+            (False, {'not_networks': [
+                "VLAN tag (VID) out of range (0-4094; 0 for untagged.)"]}),
             (form.is_valid(), form.errors))
 
     def test_not_networks_combines_filters(self):
@@ -866,25 +913,88 @@
             id=constraint_map[node.id].keys()[1])  # 2nd constraint with name
         self.assertGreaterEqual(disk1.size, 5 * 1000 ** 3)
 
-    def test_networking_constraint_rejected_if_syntax_is_invalid(self):
-        factory.make_Node_with_Interface_on_Subnet()
-        form = AcquireNodeForm({
-            u'networking': u'label:x'})
-        self.assertFalse(form.is_valid(), dict(form.errors))
-        self.assertThat(form.errors, Contains('networking'))
-
-    def test_networking_constraint_rejected_if_key_is_invalid(self):
-        factory.make_Node_with_Interface_on_Subnet()
-        form = AcquireNodeForm({
-            u'networking': u'label:chirp_chirp_thing=silenced'})
-        self.assertFalse(form.is_valid(), dict(form.errors))
-        self.assertThat(form.errors, Contains('networking'))
-
-    def test_networking_constraint_validated(self):
-        factory.make_Node_with_Interface_on_Subnet()
-        form = AcquireNodeForm({
-            u'networking': u'label:fabric=fabric-0'})
-        self.assertTrue(form.is_valid(), dict(form.errors))
+    def test_fabrics_constraint(self):
+        fabric1 = factory.make_Fabric(name="fabric1")
+        fabric2 = factory.make_Fabric(name="fabric2")
+        factory.make_Node_with_Interface_on_Subnet(fabric=fabric1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(fabric=fabric2)
+        form = AcquireNodeForm({
+            u'fabrics': [u'fabric2']})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node2], filtered_nodes)
+
+    def test_not_fabrics_constraint(self):
+        fabric1 = factory.make_Fabric(name="fabric1")
+        fabric2 = factory.make_Fabric(name="fabric2")
+        factory.make_Node_with_Interface_on_Subnet(fabric=fabric1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(fabric=fabric2)
+        form = AcquireNodeForm({
+            u'not_fabrics': [u'fabric1']})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node2], filtered_nodes)
+
+    def test_fabric_classes_constraint(self):
+        fabric1 = factory.make_Fabric(class_type="10g")
+        fabric2 = factory.make_Fabric(class_type="1g")
+        factory.make_Node_with_Interface_on_Subnet(fabric=fabric1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(fabric=fabric2)
+        form = AcquireNodeForm({
+            u'fabric_classes': [u'1g']})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node2], filtered_nodes)
+
+    def test_not_fabric_classes_constraint(self):
+        fabric1 = factory.make_Fabric(class_type="10g")
+        fabric2 = factory.make_Fabric(class_type="1g")
+        factory.make_Node_with_Interface_on_Subnet(fabric=fabric1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(fabric=fabric2)
+        form = AcquireNodeForm({
+            u'not_fabric_classes': [u'10g']})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node2], filtered_nodes)
+
+    def test_interfaces_constraint_rejected_if_syntax_is_invalid(self):
+        factory.make_Node_with_Interface_on_Subnet()
+        form = AcquireNodeForm({
+            u'interfaces': u'label:x'})
+        self.assertFalse(form.is_valid(), dict(form.errors))
+        self.assertThat(form.errors, Contains('interfaces'))
+
+    def test_interfaces_constraint_rejected_if_key_is_invalid(self):
+        factory.make_Node_with_Interface_on_Subnet()
+        form = AcquireNodeForm({
+            u'interfaces': u'label:chirp_chirp_thing=silenced'})
+        self.assertFalse(form.is_valid(), dict(form.errors))
+        self.assertThat(form.errors, Contains('interfaces'))
+
+    def test_interfaces_constraint_validated(self):
+        factory.make_Node_with_Interface_on_Subnet()
+        form = AcquireNodeForm({
+            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_filters_by_fabric_class(self):
+        fabric1 = factory.make_Fabric(class_type="1g")
+        fabric2 = factory.make_Fabric(class_type="10g")
+        node1 = factory.make_Node_with_Interface_on_Subnet(fabric=fabric1)
+        node2 = factory.make_Node_with_Interface_on_Subnet(fabric=fabric2)
+
+        form = AcquireNodeForm({
+            u'interfaces': u'label:fabric_class=10g'})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node2], filtered_nodes)
+
+        form = AcquireNodeForm({
+            u'interfaces': u'label:fabric_class=1g'})
+        self.assertTrue(form.is_valid(), dict(form.errors))
+        filtered_nodes, _ = form.filter_nodes(Node.nodes)
+        self.assertItemsEqual([node1], filtered_nodes)
 
     def test_combined_constraints(self):
         tag_big = factory.make_Tag(name='big')
@@ -985,7 +1095,13 @@
             'zone': factory.make_Zone(),
             'not_in_zone': [factory.make_Zone().name],
             'storage': '0(ssd),10(ssd)',
-            'networking': 'label:fabric=fabric-0',
+            'interfaces': 'label:fabric=fabric-0',
+            'fabrics': [factory.make_Fabric().name],
+            'not_fabrics': [factory.make_Fabric().name],
+            'fabric_classes': [
+                factory.make_Fabric(class_type="10g").class_type],
+            'not_fabric_classes': [
+                factory.make_Fabric(class_type="1g").class_type],
             }
         form = AcquireNodeForm(data=constraints)
         self.assertTrue(form.is_valid(), form.errors)

=== modified file 'src/maasserver/utils/orm.py'
--- src/maasserver/utils/orm.py	2015-10-06 23:55:25 +0000
+++ src/maasserver/utils/orm.py	2015-10-30 19:51:38 +0000
@@ -666,3 +666,27 @@
         """Close database connections in the current thread."""
         for alias in connections:
             connections[alias].close()
+
+
+class MAASQueriesMixin(object):
+    """Contains utility functions that any mixin for model object manager
+    queries may need to make use of."""
+
+    def get_id_list(self, raw_query):
+        """Returns a list of IDs for each row in the specified raw query.
+
+        This can be used to create additional filters to chain from a raw
+        query, which would not otherwise be possible.
+
+        Note that using this method risks a race condition, since a row
+        could be inserted after the raw query runs.
+        """
+        ids = [row.id for row in raw_query]
+        return self.filter(id__in=ids)
+
+    def get_id_filter(self, raw_query):
+        """Returns a `QuerySet` for the specified raw query, by executing it
+        and adding an 'in' filter with the ID of each object in the raw query.
+        """
+        ids = self.get_id_list(raw_query)
+        return self.filter(id__in=ids)

=== modified file 'src/provisioningserver/utils/network.py'
--- src/provisioningserver/utils/network.py	2015-10-05 00:12:27 +0000
+++ src/provisioningserver/utils/network.py	2015-10-30 19:51:38 +0000
@@ -505,3 +505,25 @@
     """Convert IPv4 and IPv6 addresses from binary to text form.
     (See also inet_ntop(3), the C function with the same name and function.)"""
     return unicode(IPAddress(value))
+
+
+def parse_integer(value_string):
+    """Convert the specified `value_string` into a decimal integer.
+
+    Strips whitespace, and handles hexadecimal or binary format strings,
+    if the string is prefixed with '0x' or '0b', respectively.
+
+    :raise:ValueError if the conversion to int fails
+    :return:int
+    """
+    value_string = value_string.strip()
+    if value_string.lower().startswith('0x'):
+        # Hexadecimal.
+        base = 16
+    elif value_string.lower().startswith('0b'):
+        # Binary
+        base = 2
+    else:
+        # When all else fails, assume decimal.
+        base = 10
+    return int(value_string, base)

=== modified file 'src/provisioningserver/utils/tests/test_network.py'
--- src/provisioningserver/utils/tests/test_network.py	2015-10-05 00:12:27 +0000
+++ src/provisioningserver/utils/tests/test_network.py	2015-10-30 19:51:38 +0000
@@ -52,6 +52,7 @@
     MAASIPSet,
     make_iprange,
     make_network,
+    parse_integer,
     resolve_hostname,
 )
 from testtools.matchers import (
@@ -733,3 +734,25 @@
         self.assertThat(json['inefficiency_string'], Equals("TBD"))
         self.assertThat(json, Contains('ranges'))
         self.assertThat(json['ranges'], Equals(stats.ranges.render_json()))
+
+
+class TestParseInteger(MAASTestCase):
+
+    def test__parses_decimal_integer(self):
+        self.assertThat(parse_integer("0"), Equals(0))
+        self.assertThat(parse_integer("1"), Equals(1))
+        self.assertThat(parse_integer("-1"), Equals(-1))
+        self.assertThat(parse_integer("1000"), Equals(1000))
+        self.assertThat(parse_integer("10000000"), Equals(10000000))
+
+    def test__parses_hexadecimal_integer(self):
+        self.assertThat(parse_integer("0x0"), Equals(0))
+        self.assertThat(parse_integer("0x1"), Equals(1))
+        self.assertThat(parse_integer("0x1000"), Equals(0x1000))
+        self.assertThat(parse_integer("0x10000000"), Equals(0x10000000))
+
+    def test__parses_binary_integer(self):
+        self.assertThat(parse_integer("0b0"), Equals(0))
+        self.assertThat(parse_integer("0b1"), Equals(1))
+        self.assertThat(parse_integer("0b1000"), Equals(0b1000))
+        self.assertThat(parse_integer("0b10000000"), Equals(0b10000000))