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

[Mike Pontillo]

Network interfaces constraint refactoring, part 3.

 * Implement negative constraints (via a generic way to specify inverse versions of specifier-based queries.)

[Ricardo Bánffy (rbanffy)]

Looks good. Have I mentioned how much I love docstrings?

review: Approve

[Mike Pontillo (mpontillo)]

Thanks for the review. I'll think about adding more docstrings before I land part4.

=== modified file 'src/maasserver/models/interface.py'
--- src/maasserver/models/interface.py	2015-11-02 20:24:09 +0000
+++ src/maasserver/models/interface.py	2015-11-03 01:11:53 +0000
@@ -119,6 +119,7 @@
 
 
 class InterfaceQueriesMixin(MAASQueriesMixin):
+
     def get_specifiers_q(self, specifiers, separator=':'):
         """Returns a Q object for objects matching the given specifiers.
 

=== modified file 'src/maasserver/models/tests/test_subnet.py'
--- src/maasserver/models/tests/test_subnet.py	2015-11-01 05:32:17 +0000
+++ src/maasserver/models/tests/test_subnet.py	2015-11-03 01:11:53 +0000
@@ -273,6 +273,52 @@
                  "interface:id:%s" % iface2.id]),
             [subnet1, subnet2])
 
+    def test__not_operators(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
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["interface:id:%s" % iface1.id,
+                 "!interface:id:%s" % iface2.id]),
+            [subnet1])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["interface:id:%s" % iface1.id,
+                 "not_interface:id:%s" % iface2.id]),
+            [subnet1])
+
+    def test__not_operators_order_independent(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()
+        subnet2 = iface2.ip_addresses.first().subnet
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["!interface:id:%s" % iface1.id,
+                 "interface:id:%s" % iface2.id]),
+            [subnet2])
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["not_interface:id:%s" % iface1.id,
+                 "interface:id:%s" % iface2.id]),
+            [subnet2])
+
+    def test__and_operator(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()
+        # Try to filter by two mutually exclusive conditions.
+        self.assertItemsEqual(
+            Subnet.objects.filter_by_specifiers(
+                ["interface:id:%s" % iface1.id,
+                 "&interface:id:%s" % iface2.id]),
+            [])
+
     def test__craziness_works(self):
         # This test validates that filters can be "chained" to each other
         # in an arbitrary way.

=== modified file 'src/maasserver/node_constraint_filter_forms.py'
--- src/maasserver/node_constraint_filter_forms.py	2015-11-02 22:17:02 +0000
+++ src/maasserver/node_constraint_filter_forms.py	2015-11-03 01:11:53 +0000
@@ -380,7 +380,7 @@
 
 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.)
+    LabeledConstraintMap (which must be a map of interface constraints.)
 
     :param interfaces_label_map: LabeledConstraintMap
     :return: set

=== modified file 'src/maasserver/utils/orm.py'
--- src/maasserver/utils/orm.py	2015-11-02 22:58:39 +0000
+++ src/maasserver/utils/orm.py	2015-11-03 01:11:53 +0000
@@ -684,6 +684,9 @@
 
     If the first character in the specifier is '&', the operator will be AND.
 
+    If the first character in the specifier is '!', or the specifier starts
+    with "not_", the operator will be AND(existing_query, ~(new_query)).
+
     If unspecified, the default operator is OR.
 
     :param specifier: a string containing the specifier.
@@ -693,8 +696,10 @@
 
     from operator import (
         and_ as AND,
+        inv as INV,
         or_ as OR,
     )
+    AND_NOT = lambda current, next: AND(current, INV(next))
 
     if specifier.startswith('|'):
         op = OR
@@ -702,6 +707,12 @@
     elif specifier.startswith('&'):
         op = AND
         specifier = specifier[1:]
+    elif specifier.startswith('not_'):
+        op = AND_NOT
+        specifier = specifier[4:]
+    elif specifier.startswith('!'):
+        op = AND_NOT
+        specifier = specifier[1:]
     else:
         # Default to OR.
         op = OR