1bit-Trie（一种二叉树）实现路由表

树的定义和基本术语

树:是n(>=0)个结点的有限集，它或为空树(n=0);或为非空树，对于非空树T：
(1)有且仅有一个称之为根的结点；
(2)除根结点以外的其余节点可分为 m(m>0)互不相交的有限集T1，T2，…,Tm,其中每一个集合本身又是一棵树，并且称为根的子树(subtree).
从树的定义中我们要知道树的固有特性，即树的定义中又用到了树的定义，是一个递归的定义.

键树的基本概念

键树又称为数字查找树，它是一颗度大于等于2的树，树中的每个结点中不是包含一个或几个关键字，而是只含有组成关键字的符号。例如，若关键字为数值，则结点中只包含一个数位；若关键字为单词，则结点中只包含一个字母字符。这种树会给某种类型关键字的表的查找带来方便。

 

1bit-Trie

代码实现

#coding=UTF-8
#使用二叉trie实现路由表，实现添加、查询、删除
#author=刘一凡
#date=20180303
#python3.4

import ipaddress            

class Node():
    def __init__(self,bit=None,network=None,prefix_len=None,next_hop=None,lchild=None,rchild=None):
        self.bit = bit
        self.next_hop = next_hop
        self.network = network
        self.prefix_len = prefix_len
        self.lchild = lchild
        self.rchild = rchild

#使用二叉trie实现路由表
class BiTrie():
    def __init__(self):
        #根节点bit和next_hop为空,可以用来存放缺省路由,目前没有支持
        self.root = Node()

    #添加路由或者修改路由的下一跳
    def add(self,network,prefix_len,next_hop):
        #parent是每次循环要操作（可能只是经过，也可能是存储路由）的结点current_node的父节点，
        #从root开始向下进行操作
        parent = self.root
        #提取前缀
        prefix = (int(ipaddress.IPv4Address(network)))>>(32-prefix_len)
        for i in range(prefix_len-1,-1,-1):
            #从高到低，逐bit处理
            #对于最高位bit不需要&0x1,但是其它bit需要
            bit = (prefix>>i)&0x1
            #print(bit)
            
            if bit==0:
                if not parent.lchild:
                    #左孩子不存在，则新建左孩子结点
                    parent.lchild = Node(bit=bit)
                #如果左孩子存在，它可能用于存储路由，也可能只是提供路径，不过这里不区分（除了i==0时）
                #即是否有掩码短，包含了当前network的路由，并不区分               
                current_node = parent.lchild
            elif bit==1:
                if not parent.rchild:
                    parent.rchild = Node(bit=bit)
                current_node = parent.rchild

            

                '''
                import sys
                #current_node size is 56
                print("current_node size is",sys.getsizeof(current_node))
                #24
                print(sys.getsizeof(current_node.bit))
                #57
                print(sys.getsizeof(current_node.network))
                #28
                print(sys.getsizeof(current_node.prefix_len))
                #56
                print(sys.getsizeof(current_node.next_hop))
                '''

            #当前结点current_node成为下次循环的parent
            parent = current_node
        
        #存储最后一个bit的结点存储路由信息，i==0时循环结束
        #虽然代码上没有区别，但是功能上实现了添加和修改下一跳的两种情况，具体是添加还是修改，取决于软件的数据状态（亦即取决于代码的执行路径）
        current_node.bit = bit
        current_node.network = network
        current_node.prefix_len = prefix_len
        current_node.next_hop = next_hop
        
        #print(node.next_hop)

    #路由查找,实现最长掩码匹配，可以根据DIP，也可以根据Dst network查询
    def search(self,network,prefix_len):
        #存储匹配到的路由的下一跳
        next_hops = []
        #parent是每次循环要操作（可能只是经过，也可能是记录路由下一跳）的结点current_node的父节点，
        #从root开始向下进行操作
        parent = self.root
        prefix = (int(ipaddress.IPv4Address(network)))>>(32-prefix_len)
        for i in range(prefix_len-1,-1,-1):
            bit = (prefix>>i)&1
            #print(bit)
            if bit==0:
                #左孩子中可能存储着路由，也可能只是为子孙节点提供路径
                if parent.lchild:
                    current_node = parent.lchild
                #可能匹配失败，或者通过next_hops[-1]可以获取到掩码最长的路由的下一跳
                else:
                    break
            elif bit==1:
                if parent.rchild:
                    current_node = parent.rchild
                else:
                    break
            #如果该结点存储了路由，则记录路由的下一跳
            if current_node.next_hop:
                next_hops.append(current_node.next_hop)
                #print(current_node.next_hop)
                
            #当前结点current_node成为下次循环的parent
            parent = current_node

        #print(next_hops)
        #如果有多个下一跳，返回掩码最长的network对应的下一跳 
        if next_hops:
            return next_hops[-1]
        else:
            return None

    #删除路由
    def delete(self,network,prefix_len):
        if not self.search(network,prefix_len):
            print("The route you want to delete dose not exist!")
            return -1
        layer_path=[]
        parent=self.root
        prefix=(int(ipaddress.IPv4Address(network)))>>(32-prefix_len)
        for i in range(prefix_len-1,-1,-1):
            bit=(prefix>>i)&1
            #因为上面已经检查了精确路由存在，所以需要的孩子结点一定存在
            if bit==0:
                node=parent.lchild
            elif bit==1:
                node=parent.rchild
                            
            layer_path.append(node)
            parent=node
        
        #这个时候i==0，node是最后一个bit对应的结点    
        node.network=None
        node.prefix_len=None
        node.next_hop=None
        
        #回溯删除不再需要的结点        
        for i in range(len(layer_path)-1,-1,-1):
            if not layer_path[i].lchild and not layer_path[i].rchild and not layer_path[i].next_hop:
                if layer_path[i].bit==0:
                    layer_path[i-1].lchild=None
                else:
                    layer_path[i-1].rchild=None
            #遇到一个结点不能删除，则停止回溯，这样可以提高性能
            else:
                break
            
    #打印路由表，先序遍历整棵树，先打印root，然后递归遍历左右子树（需要先将左右孩子转换成树）
    def PreOrderTraverse(self):
        parent=self.root
        if parent.next_hop:
            print("{0}/{1} {2}".format(parent.network,parent.prefix_len,parent.next_hop))
        if parent.lchild:
            lchild_trie=BiTrie()
            lchild_trie.root=parent.lchild
            lchild_trie.PreOrderTraverse()
        if parent.rchild:
            rchild_trie=BiTrie()
            rchild_trie.root=parent.rchild
            rchild_trie.PreOrderTraverse()            
            


trie=BiTrie()

'''
输出为：
5.5.5.5
8.8.8.8
2.2.2.2
128.0.0.0 2.2.2.2
224.0.0.0 5.5.5.5
228.0.0.0 8.8.8.8
2.2.2.2
8.8.8.8
2.2.2.2
128.0.0.0 2.2.2.2
228.0.0.0 8.8.8.8
'''
#不考虑IP地址的分类
trie.add("224.0.0.0",3,"5.5.5.5")
trie.add("228.0.0.0",6,"8.8.8.8")
trie.add("128.0.0.0",1,"2.2.2.2")
print(trie.search("224.0.0.0",3))
print(trie.search("228.0.0.0",6))
print(trie.search("128.0.0.0",1))
trie.PreOrderTraverse()
trie.delete("224.0.0.0",3)
print(trie.search("224.0.0.0",3))
print(trie.search("228.0.0.0",6))
print(trie.search("128.0.0.0",1))
trie.PreOrderTraverse()

'''
#None
print(trie.search('126.0.0.0',8))
#讲解树的基本概念后，然后讲解键树的基本概念，然后用图讲解添加、删除、查询的过程，最后讲解代码，和演示功能、性能效果，最后讲解测试覆盖（多重条件覆盖、循环内路径覆盖、循环间路径覆盖）
trie.add('96.0.0.0',4,"1.1.1.1")
trie.add('96.0.0.0',8,"1.1.1.3")

#1.1.1.3
print(trie.search('96.0.0.1',32))
#None
print(trie.search('1.0.0.0',8))
trie.add('200.76.8.0',24,"1.1.1.2")
#1.1.1.2
print(trie.search('200.76.8.0',24))
#None
print(trie.search('200.76.9.0',24))
'''

'''
#3.2G的CPU的PC添加这100万条路由需要75秒左右，占用内存大约540M，所以平均存储一条路由占用存储空间540字节
for i in range(1000000):
    trie.add(str(ipaddress.IPv4Address('1.0.0.0') + 256*i),24,str(ipaddress.IPv4Address('100.0.0.0') + i))
print("Finish add")
#100.11.250.250
print(trie.search("12.250.250.1",32))
'''


'''
trie.delete('200.76.8.0',24)
print(trie.search('200.76.8.0',24))

trie.delete('96.0.0.0',8)
print(trie.search('96.0.0.1',32))
'''

'''
#经检查，内存没有泄露
for i in range(1000000):
    trie.delete(str(ipaddress.IPv4Address('1.0.0.0') + 256*i),24)
print("Finish delete")
#None
print(trie.search("12.250.250.1",32))
            
while 1:
    pass
      
'''
        
'''
黑盒测试思路：
所有等价类都可能再细化，并不保证每一种排列或者组合都可行，也不保证无重叠，没有考虑性能，IP地址的分类
角度1：四种基本操作：添加、查询、删除、修改
覆盖所有操作顺序：12种。
角度2：分别测试操作对象存在、不存在、重复操作3种情况，可以和角度1组合，就是12种情况
角度3：考虑包含性，考虑4个目的网络，N1、N2、N3、N4
N1包含N2、N4，N2包含N3，N4和N2、N3没有包含关系
分别对4个目的网络进行4种基本操作，即角度1和角度3进行组合：16种
角度4：前缀长度覆盖：33种
角度5：前缀特点分类：01重复、10重复、11重复、00重复 4种情况。还可以尝试更大步长
如果觉得有价值，不同角度之间可以再组合。
加强对添加、删除的测试。比如可以对4个目的网络N1、N2、N3、N4逐一进行添加共12种顺序，逐一进行添加，共12种顺序。
'''    

测试思路

白盒测试：多重条件覆盖、循环内路径覆盖、循环间路径覆盖

黑盒测试思路：
所有等价类都可能再细化，并不保证每一种排列或者组合都可行，也不保证无重叠，没有考虑性能，IP地址的分类
角度1：四种基本操作：添加、查询、删除、修改
覆盖所有操作顺序：12种。
角度2：分别测试操作对象存在、不存在、重复操作3种情况，可以和角度1组合，就是12种情况
角度3：考虑包含性，考虑4个目的网络，N1、N2、N3、N4
N1包含N2、N4，N2包含N3，N4和N2、N3没有包含关系
分别对4个目的网络进行4种基本操作，即角度1和角度3进行组合：16种
角度4：前缀长度覆盖：33种
角度5：前缀特点分类：01重复、10重复、11重复、00重复 4种情况。还可以尝试更大步长
如果觉得有价值，不同角度之间可以再组合。
加强对添加、删除的测试。比如可以对4个目的网络N1、N2、N3、N4逐一进行添加共12种顺序，逐一进行添加，共12种顺序。

 

头脑风暴测试点：

IP路由表的测试
考虑添加路由、删除路由、查询、修改
不考虑路由目的网络的分类

1、不同路由来源
2、删除存在的路由
3、查询最长掩码匹配掩码长、短
4、包含关系
5、查询最大条数和统计
6、重复添加相同的路由，重复删除
7、路由出接口震荡：shutdown/no shutdown和插拔网线两种方式，下一跳IP在震荡，对其它路由器的影响、metric、distance
8、修改路由
9、不同的下一跳，metric修改
10、等价路由
11、多种路由来源
12、递归路由
13、路由容量
14、黑洞路由
15、默认路由
16、两种修改方式
17、删除路由，分这个路由正在转发数据，没有在转发数据 两种情况
18、secondary地址
19、distance
20、下一跳、出接口方式
21、重发布
22、策略路由
23、协议路由策略
24、内存泄露
25、两种来源的路由，正在转发数据，高disctance的路由被回收
26、出接口类型
27、所有前缀长度33中
28、输入检查，配置无效的路由
29、vrf
30、选择逻辑接口中哪个物理接口（震荡）
31、收敛时间（区分不同接口）
32、重启后静态路由、直连路由
33、网段非常相似
34、过载测试，过载加变化
35、路由策略（过滤、总数限制、修改属性）
36、汇总
37、组播路由
38、IPv4、IPv6双栈
39、不对称路径