Beispiel #1
0
    def test_compiled_badly(self):
        o = Header({'switch': 2, 'port': 1}) |then| Action(2, [1])
        r = BottomPolicy()
        self.assertFalse(sat.compiled_correctly(topo, o, r))

        o = Header({'switch': 2, 'port': 1}) |then| Action(2, [1])
        r = Header({'switch': 1, 'port': 1}) |then| Action(2, [1])
        self.assertFalse(sat.compiled_correctly(topo, o, r))
 def testHostsCompile(self):
     topo, combined = linear_hosts((0, 1, 2, 3), (0, 1, 2, 3))
     policies = [p for _, p in combined]
     compiled = ec.compile_slices(topo, combined)
     self.assertIsNotNone(sat.shared_io(topo, policies[0], policies[1]))
     self.assertIsNone(sat.shared_io(topo, compiled[0], compiled[1]))
     self.assertTrue(sat.compiled_correctly(topo, policies[0], compiled[0]))
     self.assertTrue(sat.compiled_correctly(topo, policies[1], compiled[1]))
    def testBasicCompile(self):
        topo, policies = linear((0, 1, 2, 3), (0, 1, 2, 3))
        slices = [slicing.ident_map_slice(topo, {}) for p in policies]
        combined = zip(slices, policies)
        compiled = cp.compile_slices(combined)
        self.assertIsNotNone(sat.shared_io(topo, policies[0], policies[1]))
        self.assertIsNone(sat.shared_io(topo, compiled[0], compiled[1]))

        self.assertTrue(sat.compiled_correctly(topo, policies[0], compiled[0]))
        self.assertTrue(sat.compiled_correctly(topo, policies[1], compiled[1]))
Beispiel #4
0
    def test_input_restriction(self):
        edge_policy = {(1, 1): Header({'dstip': 80}),
                       (3, 2): Header({'dstip': 80})}
        o = (Header({'switch': 1, 'port': 1}) |then| Action(1, [2], obs=[1]))
        r = Header({'switch': 1, 'port': 1, 'dstip': 80})\
            |then| Action(1, [2], obs=[1])
        self.assertTrue(sat.compiled_correctly(topo_host, o, r, edge_policy=edge_policy))

        o = (Header({'switch': 1, 'port': 1}) |then| Action(1, [2], obs=[1])) +\
            (Header({'switch': 3, 'port': 1}) |then| Action(3, [2], obs=[2]))
        r = (Header({'switch': 1, 'port': 1, 'dstip': 80})
             |then| Action(1, [2], {'vlan': 1}, obs=[1])) +\
            (Header({'switch': 3, 'port': 1, 'vlan': 1})
             |then| Action(3, [2], {'vlan': 0}, obs=[2]))
        self.assertTrue(sat.compiled_correctly(topo_host, o, r, edge_policy=edge_policy))
Beispiel #5
0
    def test_simulates_forwards2(self):
        o = (Header({'switch': 2, 'port': 1}) |then| forward(2, 2))+\
            (Header({'switch': 3, 'port': 1}) |then| forward(3, 2))
        r = (Header({'switch': 2, 'port': 1, 'vlan': 2}) |then| forward(2, 2))+\
            (Header({'switch': 3, 'port': 1, 'vlan': 2}) |then| forward(3, 2))
        self.assertIsNone(sat.simulates_forwards2(topo, o, r))
        self.assertIsNotNone(sat.simulates_forwards2(topo, o, r, field='srcmac'))

        o = (Header({'switch': 2, 'port': 1, 'vlan': 1}) |then| forward(2, 2))+\
            (Header({'switch': 3, 'port': 1, 'vlan': 1}) |then| forward(3, 2))
        r = (Header({'switch': 2, 'port': 1, 'vlan': 2}) |then| forward(2, 2))+\
            (Header({'switch': 3, 'port': 1, 'vlan': 2}) |then| forward(3, 2))
        self.assertIsNone(sat.simulates_forwards2(topo, o, r))
        self.assertIsNotNone(sat.simulates_forwards2(topo, o, r, field='srcmac'))

        # This is the corner case that demonstrates that we need to restrict
        # compiled policies to only one vlan per slice.
        o = (Header({'switch': 2, 'port': 1}) |then| forward(2, 2))+\
            (Header({'switch': 3, 'port': 1}) |then| forward(3, 2))+\
            (Header({'switch': 4, 'port': 1}) |then| forward(4, 2))
        r = (Header({'switch': 2, 'port': 1, 'vlan': 1}) |then| forward(2, 2))+\
            (Header({'switch': 3, 'port': 1, 'vlan': 1}) |then| forward(3, 2))+\
            (Header({'switch': 3, 'port': 1, 'vlan': 2}) |then| forward(3, 2))+\
            (Header({'switch': 4, 'port': 1, 'vlan': 2}) |then| forward(4, 2))
        self.assertIsNone(sat.simulates_forwards(topo, o, r))
        # NOTE: We would really like this to be a failure, but it isn't.
        # Therefore, for compiler correctness, we also need one vlan per edge.
        self.assertIsNone(sat.simulates_forwards2(topo, o, r))
        self.assertIsNotNone(sat.simulates_forwards2(topo, o, r, field='srcmac'))

        # And verify that the compilation test finds this failure
        self.assertFalse(sat.compiled_correctly(topo, o, r))
    def edgeCompile(self, nodes, topo, combined):
        compiled = ec.compile_slices(topo, combined, verbose=verbose)

        for i in range(len(compiled)):
            self.assertTrue(sat.compiled_correctly(topo, combined[i][1],
                                                         compiled[i]))
            self.assertIsNotNone(sat.shared_io(topo, compiled[i], compiled[i]))
            for j in range(len(compiled)):
                if verbose:
                    print "testing edge compiled %d:%s with %d:%s."\
                          % (i, nodes[i], j, nodes[j])
                if i != j:
                    self.assertFalse(sat.compiled_correctly(topo, combined[i][1],
                                                                  compiled[j]))

                    self.assertIsNone(sat.shared_io(topo, compiled[i],
                                                 compiled[j]))
    def sliceCompile(self, nodes, topo, combined):
        compiled = cp.compile_slices(combined)

        for i in range(len(compiled)):
            self.assertTrue(sat.compiled_correctly(topo, combined[i][1],
                                                         compiled[i]))
            for j in range(len(compiled)):
                if verbose:
                    print "testing compiled %s with %s."\
                          % (nodes[i], nodes[j])
                result = sat.shared_io(topo, compiled[i], compiled[j])
                if i == j:
                    self.assertIsNotNone(result)
                else:
                    cc = sat.compiled_correctly(topo, combined[i][1], compiled[j])
                    self.assertIsNotNone(cc)
                    self.assertIsNone(result)
 def testHostsCompileSmall(self):
     topo, combined = linear_hosts((0, 1, 2, 3), (0, 1, 2, 3))
     slices = [s for s, _ in combined]
     policy = ((nc.inport(3, 3) |then| nc.forward(3, 1)) +
               (nc.inport(3, 3) |then| nc.forward(3, 2)) +
               (nc.inport(2, 3) |then| nc.forward(2, 2)))
     combined = [(slices[0], policy), (slices[1], nc.BottomPolicy())]
     compiled, _ = ec.compile_slices(topo, combined)
     self.assertIsNone(sat.one_per_edge(topo, compiled))
     self.assertTrue(sat.compiled_correctly(topo, policy, compiled))
Beispiel #9
0
    def test_compiled_correctly(self):
        o = Header({'switch': 2, 'port': 2, 'vlan': 2}) |then| Action(2, [1])
        r = Header({'switch': 2, 'port': 2, 'vlan': 2}) |then| Action(2, [1])
        self.assertTrue(sat.compiled_correctly(topo, o, r))

        o = Header({'switch': 2, 'port': 2}) |then| Action(2, [1])
        r = Header({'switch': 2, 'port': 2, 'vlan': 2}) |then| Action(2, [1])
        self.assertTrue(sat.compiled_correctly(topo, o, r))

        o = Header({'switch': 2, 'port': 2}) |then| forward(2, 1)
        r = Header({'switch': 2, 'port': 2, 'vlan': 2})\
            |then| Action(2, [1], {'vlan': 2})
        self.assertTrue(sat.compiled_correctly(topo, o, r))

        o = Header({'switch': 1, 'port': 1}) |then| Action(1, [1])
        r = Header({'switch': 1, 'port': 1, 'vlan': 1}) |then|\
            Action(1, [1], {'vlan': 1})
        self.assertTrue(sat.compiled_correctly(topo, o, r))

        o = Header({'switch': 1, 'port': 1, 'srcmac': 33, 'dstmac': 32})\
            |then| Action(1, [1])
        r = Header({'switch': 1, 'port': 1, 'srcmac': 33, 'dstmac': 32, 'vlan': 1})\
            |then| Action(1, [1], {'vlan': 1})
        self.assertTrue(sat.compiled_correctly(topo, o, r))
Beispiel #10
0
def main():
    parser = argparse.ArgumentParser(description='Compile netcore programs.')
    parser.add_argument('--waxman', action='store_const', const=waxman,
                        dest='topo_gen', help='Generate a waxman topology')
    parser.add_argument('--smallworld', action='store_const', const=smallworld,
                        dest='topo_gen', help='Generate a smallworld topology')
    parser.add_argument('--fattree', action='store_const', const=fattree,
                        dest='topo_gen', help='Generate a fattree topology')
    parser.add_argument('--flood', action='store_const', const=flood,
                        dest='policy_gen', help='Use a flood routing policy')
    parser.add_argument('--flood_observe', action='store_const',
                        const=flood_observe, dest='policy_gen',
                        help='Use a flood and observe routing policy')
    parser.add_argument('--shortest_path', action='store_const',
                        const=shortest_path, dest='policy_gen',
                        help='Use a shortest path routing policy')
    parser.add_argument('--multicast', action='store_const',
                        const=multicast, dest='policy_gen',
                        help='Use a multicast routing policy')
    parser.add_argument('-e', '--edge', action='store_true', default=False,
                        help='Use the per-edge compiler.')
    parser.add_argument('--hosts', action='store', type=int, default=20,
                        help='Number of hosts on network (approximate for '
                        'fattree).')
    parser.add_argument('--ast', action='store_true', default=False, help=
                        'Print out AST size statistics.')
    parser.add_argument('--ctime', action='store_true', default=False, help=
                        'Print out compilation timing information.')
    parser.add_argument('--vtime', action='store_true', default=False, help=
                        'Print out validation timing information.')
    args = parser.parse_args()
    init = time.time()
    topo = args.topo_gen(args.hosts)
    topo_time = time.time()
    policy = args.policy_gen(topo)
    policy_time = time.time()
    combined = build_slices(topo, policy)
    slice_time = time.time()
    compiled = do_compile(topo, combined, edge=args.edge)
    compile_time = time.time()
    if args.ast:
        ast_orig = policy.size()
        ast_final = compiled[0].size()
        print 'AST Nodes: %5d -> %5d' % (ast_orig, ast_final)
    if args.ctime:
        t = topo_time - init
        p = policy_time - topo_time
        s = slice_time - policy_time
        c = compile_time - slice_time
        print '\n'.join([
                         'Time to compile:        %f' % c,
                        ])
    if args.vtime:
        policy1 = compiled[0]
        policy2 = compiled[1]
        init = time.time()
        assert sat.shared_io(topo, policy1, policy2) is None
        assert sat.shared_io(topo, policy2, policy1) is None
        assert sat.shared_inputs(policy1, policy2) is None
        assert sat.shared_inputs(policy2, policy1) is None
        # Not None because we're not doing output restrictions
        assert sat.shared_outputs(policy1, policy2) is not None
        assert sat.shared_outputs(policy2, policy1) is not None
        assert verification.disjoint_observations(policy1, policy2)
        # Not None because we're not doing output restrictions
        assert sat.shared_transit(topo, policy1, policy2) is not None
        iso_t = time.time()
        print 'Time to check isolation:   %f' % (iso_t - init)

        init = time.time()
        assert sat.compiled_correctly(topo, policy, compiled[0], edge_policy=combined[0][0].edge_policy)
        comp_t = time.time()
        print 'Time to check compilation: %f' % (comp_t - init)