Пример #1
0
def runstuff():
    NUM_SWITCHES = 20 # total number of switches in the complete graph of switch-port connectivity
    NUM_CLIENTS = 2 # number of clients on every switch. large numbers will decrease the size of sccs, because 
                    # forwarding to clients is always safe; not part of a loop.
    RULES_PER_ROUND = 350 # number of rule installs to do between gathering time statistics.
    MAX_TOTAL_RULES_INSTALLED = 450 # number of total rules to maintain in the network model, so 
                                    # that as more than these come in, we evict the oldest ones.
    TOTAL_RULE_INSTALLATIONS_BEFORE_HALT = 350 # halt after this many total rule installations.
    SHOW_TRACE = False # should we show the trace when loops are detected? This can get hectic.
    MIN_IN = 1 # minininum number of in_ports to be used in random rules.
    MAX_IN = 3 # etc.
    MIN_OUT = 1
    MAX_OUT = 2



    # the network that we'kll use to generate random valid rules
    net = TestNetwork1(NUM_SWITCHES, NUM_CLIENTS, minswitch=5555, minport=100001)

    # our model
    n = NetworkFlowruleModel() 

    # track the flow install rate in this
    timestats = StatsBuddy()
    total_installed = 0

    # track the rules in place in our NetworkFlowruleModel so we can evict them
    q = Queue.Queue() 

    while True:
        #start a timer
        t1 = time.time()

        # do some rule installations
        for r in xrange(RULES_PER_ROUND):
            if q.qsize() > MAX_TOTAL_RULES_INSTALLED:
                droprule = q.get() # get the number of the rule that's over the limit
                n.drop_flow_rule(droprule) # kill the rule
            rule = net.get_random_rule(MIN_IN, MAX_IN, MIN_OUT, MAX_OUT)
            (rnum, trace) = n.install_flow_rule(rule)
            if SHOW_TRACE and trace: NetworkFlowruleModel.explain(trace)
            q.put(rnum)
            total_installed += 1

        t2 = time.time()

        # NOTE: linux might report this in ms instead of seconds, I think, 
        # so this might give weird results
        timestats.add(RULES_PER_ROUND/(t2-t1)) 

        # how we eventually halt
        if total_installed >= TOTAL_RULE_INSTALLATIONS_BEFORE_HALT: break

        

    print timestats, 'are stats for the number of rule installs and evictions per second.'
    print n.sccsizestats, 'are stats for the average scc size of installed rules.'

    return
Пример #2
0
    def __init__(self):
        self.in_port_rules = defaultdict(lambda: [])
        self.out_port_rules = defaultdict(lambda: [])

        self.rulenum_to_rule = {}
        self.rulenum_to_inspace = {}
        self.rulenum_to_outspace = {}
        self.rulenum_to_in_ports = {}
        self.rulenum_to_out_ports = {}

        self.dscc = DynamicSCC()

        # for tracking the number of components in sccs for newly added rules
        self._collect_stats = False
        self.scc_size_stats = StatsBuddy()
        self.scc_buckets = None
        self.edges_stats = StatsBuddy()
        self.loops_detected = 0
        self.loop_detection_calls = 0

        # first installed flow rule will be number 0
        # iterated whenever a flow is installed, so no overlap is possible
        self._r = 0
Пример #3
0
class NetworkFlowruleModel(object):
    '''
    Build an object that can tell us whether the ruleset can permit looping in the network.
    Flow rules are to be provided in the form of the result of a call to 
    TF.create_standard_rule(in_ports, match, out_ports, mask, rewrite,file_name,lines)
    where all referenced port numbers refer model distinct unidirectional physical connections
    between switches. This class does not necessarily check that the rules are sane. That 
    is, you can (unsafely) add flow rules that are not physically possible, 
    for instance redirecting packets that arrive on more than one switch or 
    that do not have the in ports and out ports on the same physical router.
    '''
    def __init__(self):
        self.in_port_rules = defaultdict(lambda: [])
        self.out_port_rules = defaultdict(lambda: [])

        self.rulenum_to_rule = {}
        self.rulenum_to_inspace = {}
        self.rulenum_to_outspace = {}
        self.rulenum_to_in_ports = {}
        self.rulenum_to_out_ports = {}

        self.dscc = DynamicSCC()

        # for tracking the number of components in sccs for newly added rules
        self._collect_stats = False
        self.scc_size_stats = StatsBuddy()
        self.scc_buckets = None
        self.edges_stats = StatsBuddy()
        self.loops_detected = 0
        self.loop_detection_calls = 0

        # first installed flow rule will be number 0
        # iterated whenever a flow is installed, so no overlap is possible
        self._r = 0



    def install_flow_rule(self, rule):
        # we use the flow rule number (assigned from 0 as rules are entered) as the vertex
        newrnum = self._r
        self._r += 1

        self.rulenum_to_rule[newrnum] = rule
        
        # update the in/out_port_rules dictionaries ,so we can easily detect 
        # who we have to test for intersection with this rule later
        # HACK. This uses a poorly understood backdoor into the TF class
        # by asking for in/outport_to_rule.keys(), when there may be situations
        # (I'm not sure, OK?) when it doesn't provide the right answers
        inports =  [int(p) for p in rule.inport_to_rule.keys()]
        self.rulenum_to_in_ports[newrnum] = inports
        outports = [int(p) for p in rule.outport_to_rule.keys()]
        self.rulenum_to_out_ports[newrnum] = outports

        for port in inports: self.in_port_rules[port].append(newrnum)
        for port in outports: self.out_port_rules[port].append(newrnum)

        # these are lists of pairs (headerspace, portlist)
        outspace = [item for port in inports for item in rule.T(HEADERSPACE_ALL, port)]
        inspace = [item for port in outports for item in rule.T_inv(HEADERSPACE_ALL, port)]

        self.rulenum_to_inspace[newrnum] = inspace
        self.rulenum_to_outspace[newrnum] = outspace
      
        # add this rule into the dynamic graph structure
        self.dscc.insert_vertices([newrnum])

        # cases where there might be an edge (newrnum, ?) and below, (?, newrnum), since they in/out on the same port
        possible_to_rules = [r for outport in outports for r in self.in_port_rules[outport]]
        possible_from_rules = [r for inport in inports for r in self.out_port_rules[inport]]

        # cases where there is a headerspace intersection in the inputs and outputs
        real_to_rules = filter(lambda r: NetworkFlowruleModel.rule_spaces_intersect(outspace, self.rulenum_to_inspace[r]), possible_to_rules)
        #if len(real_to_rules) > 0: print real_to_rules
        real_from_rules = filter(lambda r: NetworkFlowruleModel.rule_spaces_intersect(inspace, self.rulenum_to_outspace[r]), possible_from_rules)
        #if len(real_from_rules) > 0: print real_from_rules

        # the real edges to insert
        newedges = set([(newrnum, to) for to in real_to_rules])
        newedges.update(set([(frum, newrnum) for frum in real_from_rules]))

        #print "New edges are:", newedges
        
        # add the edges to our SCC detecting graph
        self.dscc.insert_edges(newedges)

        # how big is the scc we're in?
        newscc = self.dscc.getSCC(newrnum)
        sccsize = len(newscc)

        # process SCC statistics
        if self._collect_stats: 
            self.edges_stats.add(len(newedges))
            self.scc_size_stats.add(sccsize) 
            self.scc_buckets.add(sccsize)
        
        if sccsize == 1: 
            return (newrnum, False)

        
        '''
        print newscc, 'is a set of rules that could loop'
        for rnum in newscc:
            print self.rulenum_to_rule[rnum]
            print self.rulenum_to_inspace[rnum]
            print self.rulenum_to_outspace[rnum]
        raise Exception("Quick Break")
        '''

        # return the number of the inserted rule and some info
        info = self.find_loop_in_scc(newscc, newrnum)
        return (newrnum, info)
    ## end install_flow_rule

    def collect_stats(self, bool): 
        '''
        Turn collecting of SCC size statistics on or off
        '''
        self._collect_stats = bool
        # collect scc buckets on the assumption that the current number of rules is about the most we'll see, unless we have none yet
        bmax = len(self.rulenum_to_rule) if len(self.rulenum_to_rule) > 20 else 200
        self.scc_buckets = Buckets(0, bmax)

    def find_loop_in_scc(self, scc, rnum):
        q = Queue()
        # collect stats, it we should be doing so
        if self._collect_stats: self.loop_detection_calls += 1
        # this was set when the rule was added
        initial_spaces = self.rulenum_to_outspace[rnum]

        # queue items look like ([(hs, [ports])], [visited_rules])
        # we start with the full header space on the ports that the rule of interest outputs
        q.put( (initial_spaces, [rnum]) )
        while not q.empty():
            current_places, visited_rules = q.get()
            # this is to help reduce the depth of the recursion here
            if TRY_EFFICIENCY_TWEAK: current_places = rewrite_space(current_places)

            for space, ports in current_places:
                # sometimes empty spaces can be here. we can ignore them
                if space.is_empty(): continue
                for port in ports:
                    for nextrule in scc:
                        # if the current space routes into another rule in the scc
                        if nextrule in self.in_port_rules[port]:
                            currpath = visited_rules + [nextrule]
                            # process space, port through nextrule
                            out = self.rulenum_to_rule[nextrule].T(space, port)
                            if len(out) == 0: continue
                            # check if we have a loop here
                            if nextrule in visited_rules:
                                # we've visited this rule before, if we have a nonempty header left, we've found a loop
                                for outspace, outports in out:
                                    if not outspace.is_empty():
                                        # collect stats, it we should be doing so
                                        if self._collect_stats: self.loops_detected += 1

                                        # backtrace this, ignoring the other possible loops
                                        original_space = self.backtrace([(outspace, outports)], currpath)

                                        ret = {'rule_path': currpath, 'headers_in': original_space, 'headers_out': [(outspace, outports)]}
                                        return ret
                                        
                                continue
                            # register another node to check
                            q.put( (out, currpath) )
        return False
    ## end find_loop_in_scc

    
    @staticmethod
    def explain(info):
        path = info['rule_path']
        print '---Backtrace shows that packets can loop in your network:'
        for hs, ports in info['headers_in']:
            print '-- Port(s)', ports, 'with headers', hs
        print '-- They take the path of rules', path, 'in a loop.'
        print '-- And are emitted by rule', path[-1], 'at the end of the above loop as:'
        for hs, ports in info['headers_out']:
            print '-- Port(s)', ports, 'with headers', hs
        print '-- Other packets may also loop.'


    def backtrace(self, hspaces, rulelist):
        '''
        Trace the behaviour of hspace travelling through rulelist _in reverse_,
        returning the original set of (hspace,ports) that could have caused the
        hspaces arg to have been emitted.
        '''        
        for rnum in reversed(rulelist):
            # trace hspace backwards through rule rnum
            rule = self.rulenum_to_rule[rnum]
            nextgen = []
            for (hspace, ports) in hspaces:
                for port in ports:
                    nextgen.extend(rule.T_inv(hspace, port))
            hspaces = nextgen
        # hspaces is now the original ingress packets that had eventually 
        # called the original hspaces to be ejected from the last rule in rulelist
        return hspaces
    ## end backtrace


    @staticmethod
    def rule_spaces_intersect(a, b):
        '''
        Detemine whether there is a nonempty intersection between 2 (headerspace, portlist) lists
        '''
        for (hs1, ports1) in a:
            sports1 = set(ports1)
            for (hs2, ports2) in b:
                sports2 = set(ports2)
                if len(sports1.intersection(sports2)) == 0: continue
                if not hs1.copy_intersect(hs2).is_empty(): 
                    return True
        return False



    def drop_flow_rule(self, rnum):
        '''Update all of the stored data to a state as if rule rnum never existed'''
        rule = self.rulenum_to_rule[rnum]
        del self.rulenum_to_rule[rnum]
        for port in self.rulenum_to_in_ports[rnum]: self.in_port_rules[port].remove(rnum)
        for port in self.rulenum_to_out_ports[rnum]: self.out_port_rules[port].remove(rnum)
        del self.rulenum_to_in_ports[rnum]
        del self.rulenum_to_out_ports[rnum]
        del self.rulenum_to_inspace[rnum]
        del self.rulenum_to_outspace[rnum]
        self.dscc.delete_vertex(rnum)