major refactor of sequential composition of classifiers

Author: Joshua Reich

pyretic/core/classifier.py

@@ -176,114 +176,113 @@ def _cross(r1,r2):
 
     def __rshift__(c1, c2):
         from pyretic.core.language import match, modify, drop, identity, Controller, CountBucket, DerivedPolicy
-        def _sequence_action_classifier(act, c2):
-            # given a test b and an action p, return a test
-            # b' such that p >> b == b' >> p.
-            def _commute_test(act, pkts):
-                while isinstance(act, DerivedPolicy):
-                    act = act.policy
-                if act == identity:
-                    return pkts
-                elif act == drop:
-                    return drop
-                elif act == Controller or isinstance(act, CountBucket):
+        # given a test b and an action p, return a test
+        # b' such that p >> b == b' >> p.
+        def _commute_test(act, pkts):
+            while isinstance(act, DerivedPolicy):
+                act = act.policy
+            if act == identity:
+                return pkts
+            elif act == drop:
+                return drop
+            elif act == Controller or isinstance(act, CountBucket):
+                return identity
+            elif isinstance(act, modify):
+                new_match_dict = {}
+                if pkts == identity:
                     return identity
-                elif isinstance(act, modify):
-                    new_match_dict = {}
-                    if pkts == identity:
-                        return identity
-                    elif pkts == drop:
+                elif pkts == drop:
+                    return drop
+                for f, v in pkts.map.iteritems():
+                    if f in act.map and act.map[f] == v:
+                        continue
+                    elif f in act.map and act.map[f] != v:
                         return drop
-                    for f, v in pkts.map.iteritems():
-                        if f in act.map and act.map[f] == v:
-                            continue
-                        elif f in act.map and act.map[f] != v:
-                            return drop
-                        else:
-                            new_match_dict[f] = v
-                    if len(new_match_dict) == 0:
-                        return identity
-                    return match(**new_match_dict)
-                else:
-                    # TODO (cole) use compile error.
-                    # TODO (cole) what actions are allowable?
-                    raise TypeError
-
-            # sequentially compose actions.  a1 must be a
-            # single action.  Returns a list of actions.
-            def _sequence_actions(a1, as2):
-                while isinstance(a1, DerivedPolicy):
-                    a1 = a1.policy
-                # TODO: be uniform about returning copied or modified objects.
-                new_actions = []
-                if a1 == drop:
-                    return [drop]
-                elif a1 == identity:
-                    return as2
-                elif a1 == Controller or isinstance(a1, CountBucket):
-                    return [a1]
-                elif isinstance(a1, modify):
-                    for a2 in as2:
-                        while isinstance(a2, DerivedPolicy):
-                            a2 = a2.policy
+                    else:
+                        new_match_dict[f] = v
+                if len(new_match_dict) == 0:
+                    return identity
+                return match(**new_match_dict)
+            else:
+                # TODO (cole) use compile error.
+                # TODO (cole) what actions are allowable?
+                raise TypeError
+
+        # sequentially compose actions.  a1 must be a
+        # single action.  Returns a list of actions.
+        def _sequence_actions(a1, as2):
+            while isinstance(a1, DerivedPolicy):
+                a1 = a1.policy
+            # TODO: be uniform about returning copied or modified objects.
+            new_actions = []
+            if a1 == drop:
+                return [drop]
+            elif a1 == Controller or isinstance(a1, CountBucket):
+                return [a1]
+            elif a1 == identity:
+                return as2
+            elif isinstance(a1, modify):
+                for a2 in as2:
+                    while isinstance(a2, DerivedPolicy):
+                        a2 = a2.policy
+                    if a2 == drop:
+                        new_actions.append(drop)
+                    elif a2 == Controller or isinstance(a2, CountBucket): 
+                        new_actions.append(a2)
+                    elif a2 == identity:
+                        new_actions.append(a1)
+                    elif isinstance(a2, modify):
                         new_a1 = modify(**a1.map.copy())
-                        if a2 == drop:
-                            new_actions.append(drop)
-                        elif a2 == Controller or isinstance(a2, CountBucket): 
-                            new_actions.append(a2)
-                        elif a2 == identity:
-                            new_actions.append(new_a1)
-                        elif isinstance(a2, modify):
-                            new_a1.map.update(a2.map)
-                            new_actions.append(new_a1)
-                        else:
-                            raise TypeError
-                    return new_actions
-                else:
-                    raise TypeError
-            # END _commute_test and _sequence_actions
-
-            c3 = Classifier()
-            for r2 in c2.rules:
-                pkts = _commute_test(act, r2.match)
-                if pkts == identity:
-                    acts = _sequence_actions(act, r2.actions)
-                    c3.append(Rule(identity, acts))
-                    break
-                elif pkts == drop:
-                    continue
-                else:
-                    acts = _sequence_actions(act, r2.actions)
-                    c3.append(Rule(pkts, acts))
-            if len(c3) == 0:
-                c3.append(Rule(identity, [drop]))
-            return c3
+                        new_a1.map.update(a2.map)
+                        new_actions.append(new_a1)
+                    else:
+                        raise TypeError
+                return new_actions
+            else:
+                raise TypeError
+
+        # generates a (potentially) non-total classifier 
+        # containing a single rule, or None
+        def _cross_act(r1,act,r2):
+            m = r1.match.intersect(_commute_test(act, r2.match))
+            actions = _sequence_actions(act,r2.actions)
+            if actions == [drop]:
+                return Classifier([Rule(r1.match,actions)])
+            elif m == drop:
+                return None
+            else:
+                return Classifier([Rule(m,actions)])
 
-        # END _sequence_action_classifier
+        # returns a potentially non-total classifier
+        # suitable for concatenating w/ other potentially non-total classifiers
+        def _cross(r1,r2):
+            c = None
+            for act in r1.actions:
+                cross = _cross_act(r1,act,r2) 
+                if c is None:
+                    c = cross
+                elif not cross is None:
+                    # parallel compose to get c_tmp
+                    c_tmp = c + cross
+                    # but since both c and cross were potentially non-total
+                    # we need to append both c and cross to c_tmp
+                    c_tmp.append(c)
+                    c_tmp.append(cross)
+                    # set c to c_tmp and optimize
+                    c = c_tmp
+                    c = c.optimize()
+            return c
 
         # core __rshift__ logic begins here.
+
         # start with an empty set of rules for the output classifier
         # then for each rule in the first classifier (self)
         c3 = Classifier()
         for r1 in c1.rules:
-            # sequence the actions in second classifier c2 w/ respect to r1
-            c2_seqd = Classifier([Rule(identity, [drop])])
-            for act in r1.actions:
-                c2_seqd = c2_seqd + _sequence_action_classifier(act, c2)
-
-            # for each rule in the sequenced c2, 
-            # intersect the rule's match with r1's match
-            for r2 in c2_seqd.rules:
-                r2.match = r2.match.intersect(r1.match)
-            
-            # filter out rules that cannot match any packet
-            c_tmp = Classifier(r2 for r2 in c2_seqd.rules 
-                               if r2.match != drop)
-            c_tmp = c_tmp.optimize()
-
-            # append the optimized rules
-            c3.append(c_tmp)
-
+            for r2 in c2.rules:
+                c_tmp = _cross(r1,r2)
+                if not c_tmp is None:
+                    c3.append(c_tmp)
         # when all rules in c1 and c2 have been crossed
         # optimize c3
         c3 = c3.optimize()