本次大赛以提交报告书的形式进行初赛，参赛队伍须根据题目要求写出报告书文档，在初赛截止日期之前在线提交。

初赛基本要求：初赛共三大题，满分100分。必答题的总得分在60%（即18分）或以上的，方可获得参赛证明，并获得算法题和设计题的评分资格。以三大题的总分计算，排出入围决赛的名单。 参赛队伍在线提交时，要提供一个list.txt文件，内容是所提交的文件名列表，每个文件名对应一句话的简要说明。同一参赛队伍可以多次提交，以最后一次提交的文件为准。 第一题：必答题（搭建SDN网络环境）——30分 必答题一共三小题，根据每小题的完成程度和报告质量来评分，主要考察以下三个方面： 1.能否成功搭建SDN网络环境（基于物理设备或者虚拟化技术都是允许的）； 2.能否通过集中式的控制来控制整个网络（主要通过能否集中式的控制流表或者路由信息来评判）； 3.能否给出详细的实验报告（包括方案描述、操作步骤以及实验结果，每小题一份报告）。

第1小题：简单网络（5分）

说明：由于对于SDN架构的理解在学界和业界并没有统一，为了方便参赛队员选择，对于初学者，大赛推荐OpenFlow作为南向接口来实现SDN环境，以下给出分别针对采用OpenFlow和采用其他接口的具体要求（分A、B两种情况）。

A. 针对采用OpenFlow作为南向接口的参赛队伍的要求：

参赛队伍首先需要搭建一个SDN架构的网络环境，初学者可以参照图1所示的一个最简单的拓扑结构，熟练的参赛队员可以自定义复杂一点的拓扑结构，两者并不影响评委评分。

B. 针对不是采用OpenFlow作为南向接口的参赛队伍的要求：

拓扑结构自定，所用设备、软件等自选，只要能够实现SDN架构的网络环境即可。

图1：简单的示例拓扑

1.搭建环境要求：图1中控制器可以自主选择，既可选择各种开源的控制器（例如：Floodlight、Ryu、Nox、Beacon、Trema、OpenDaylight等），也可选择由本次大赛设备提供商所提供的闭源控制器。拓扑中各网络部件既可以是仿真环境实现（例如mininet， OpenvSwtich），有条件的队伍也可以通过物理设备实现，两种方案不影响必答题的评分。

2.操作要求：对流表进行操作使得Host1和Host2能够互相ping通，然后再修改流表使得它们不能ping通。 3.报告书要求：报告书的主要内容需要包含以下几点： (1)详细描述实验网络环境的搭建思路，给出搭建出来的结构拓扑图，列举选择的具体设备或者仿真软件、工具软件，并说明其在实验中的作用。 (2)给出实现2中操作要求的具体操作步骤，以截图或者文本方式展示，要求给出初始以及前后两次对流表操作后流表内容的截图。 (3)给出实验数据（界面截图、表格等都可）来说明实现了(2)中的要求。 说明：以上列举的为硬性要求，在报告书中必须给出。但报告书内容的组织可以灵活处理，自由发挥，不限于上述要求的内容。

第一小题：

建立拓扑：

sudo mn –topo single,3 –mac –switch ovsk –controller=remote,ip=192.168.43.128,port=6633

Pingall都能ping通

控制器web界面显示

现在修改流表让主机相互ping 不通

查看端口：ovs-vsctl show

先pingall

通了

来改流表：ovs-ofctl add-flow s1 priority=1,in_port=2,actions=drop

到port 2的流量全部drop

H1的端口port2 不能ping通H2 H3主机

成功！

第2小题：逻辑隔离（10分）

1. 背景：云平台服务器上的不同虚拟服务器，分属于不同的用户。用户远程登录自己的虚拟服务器之后，安全上不允许直接访问同一局域网的其他虚拟服务器。 2. 场景：设有一台PC机，两台服务器A、B与同一交换机直连，服务器A和B都提供远程桌面登录服务。（这里的PC机、服务器、交换机可以选择物理设备或者虚拟机实现）。 3. 目的：通过控制层对网络的控制，实现PC机可以分别登录服务器A和B，但是A和B之间相互访问不了（无论是在实际环境还是在仿真环境实现目的均可，不影响评分）。 4. 针对采用OpenFlow的参考示例：（具体方案可自由发挥）参考的网络拓扑如图2所示，通过对流表的修改与编辑，使得访问A、B的流能够被区分出来，如果是A访问B或者B访问A的流则自动丢弃，否则正常处理。 5. 报告书要求： (1) 简要描述网络拓扑，给出拓扑图，若有前面小题中没有提及的设备、软件等构件，则在此详细说明。 (2) 给出操作步骤。 (3) 给出实验数据（界面截图、表格等都可），证明目的已经实现。

图2：参考示例网络拓扑

Mininet上搭建拓扑

如第一小题做A到B的drop B到A的drop

第3小题：岗位轮换（15分）

1. 背景：虚拟服务器防入侵、防篡改攻击，让虚拟服务器轮流承担同一岗位的任务，轮换下去的虚拟机做快速系统还原。 2. 设有一台PC机，两台Web服务器A和B提供简单的静态网页访问服务，服务器A和B直连在同一交换机上。两台服务器所显示的网页有显著差别，可以是不同的网页内容或者不同颜色，能够区分彼此即可。（这里的PC机、Web服务器、交换机可以选择物理设备或者虚拟机实现） 3. 目的：当PC机不停的发出访问请求时，控制层能够控制网络自动交替轮流将访问请求转发到两个服务器上。 4. 报告书要求： (1) 简要描述网络拓扑，给出拓扑图，若有前面小题中没有提及的设备、软件等构件，则在此详细说明。 (2) 给出操作步骤。 (3) 给出实验数据，证明目的已经实现。

用mininet的Python接口创建自定义拓扑

mn –custom /home/ubuntu/mininet/custom/topo-2sw-2host.py –topo mytopo –switch ovsk –controller=remote,ip=192.168.43.128,port=6633

H3 和H4都开httpserver

H1和H2去wget H3和H4的服务都成功了

轮转ping一个共有的10.0.0.100IP成功，其中10.0.0.3,10.0.0.4轮转响应

WWW服务轮转成功

第二题：算法题（SDN算法设计）——20分（）

要求：写出如下路由算法程序，并且进一步将算法做成SDN控制器中的一个APP路由功能。给出程序代码以及加入SDN控制器中的具体步骤，并给出实验数据，证明目的已实现。

第1步：路由算法编程（8分）

下面为示例拓扑图，我们要用算法计算出id为1设备到id为7的设备和设备id为2到id为8设备的最优路线。

图3：组网拓扑

说明：此处拓扑图仅作为一个举例，路由算法程序应该能够处理各种拓扑情况，只要输入数据符合格式要求。程序应能够处理不同的Input.txt数据，并且可以处理带宽资源约束（input第一段最后属性）和路径需求（input第二段最后属性）。

1. 输入：
   图3拓扑的输入文件为input.txt，本算法为双向线，来回只需输入一个即可
   Input.txt：
   leftnodeID,rightnodeID,bandwidth
   1,3,100
   1,4,100
   2,3,100
   2,4,100
   3,4,100
   3,5,100
   3,6,100
   4,5,100
   4,6,100
   5,6,100
   5,7,100
   5,8,100
   6,7,100
   6,8,100

;

srcNodeID,dstNodeID,bandwidth 1,7,90 1,8,90

其中leftnodeID为左节点（字段名固定），rightnodeID右节点（字段名固定），bandwidth带宽，srcNodeID源节点（字段名固定）,dstNodeID目的节点（字段名固定），根据算法不同，字段名可以按需增加。

1. 运算：
   C:\Users\xwx202247>算法.exe input.txt output.txt
2. 输出：
   经算法计算后的计算结果输出文件output.txt
   Output.txt:
   1,3,6,7
   2,4,5,8

代码如下：

import java.io.*;import java.util.*;public class RouteDesign {    final static int maxnum = 100;    final static int minint = 0;    final static int maxint = 999999;    static int dist [] = new int [maxnum];   //当前路径中的最小带宽    static int mprev[] = new int [maxnum];   //当前节点的前一跳节点    static int c[][] = new int [maxnum][maxnum]; // 两个节点之间的带宽    static int hop[] = new int [maxnum]; //当前节点到源节点的跳数    public static void Dijkstra(int n,int v,int b,int dist[],int mprev[],int c[][]){        boolean s[] = new boolean[maxnum];        for(int i=1;i<=n;i++){            dist[i] = c[v][i];                  //这个循环用来说明当前链路到源节点的带宽，寻找源节点可以到达的所有节点            s[i]=false;            if(dist[i]==minint)                mprev[i] = 0;               //当前节点的前一跳节点为0            else{                mprev[i] = v;               //否则前一跳为源节点                             hop[i]=1;                   //重置跳数            }        }        dist[v] = maxint;                                   s[v] = true;                                //源节点s[v]为true        for(int i=2;i<=n;i++){            int tmp = b;                        //tmp为所要求的带宽            int u = v;                          //u为源节点            for(int j=1;j<=n;j++){                                      if(!s[j]&&dist[j]>=tmp){       //s[j]为0并且当前带宽大于要求带宽                      u=j;                   //源节点等于当前节点                    tmp=dist[j];           //保证带宽不会减小                }            }            s[u]=true;            for(int j=1;j<=n;j++){                int least = dist[u];           //least为u的带宽                       if(c[u][j]
           
            //最得u到其他节点最小带宽值                
            if((!s[j])&&(least>dist[j])){ 
            //如果当前节点到源点的路径中的带宽过小，更新当前节点最小带宽及路径                    hop[j]=hop[u]+
            1;                    mprev[j]=u;                    dist[j]=least;                }                
            else 
            if(!s[j]&&(least == dist[j])){ 
            //如果相等则比较跳数，跳数小者成为当前节点的路径                    
            if(hop[j]>hop[u]+
            1){                        hop[j]=hop[u]+
            1;                        mprev[j]= u;                        dist[j]=least;                    }                }            }        }    }        
            public 
            static 
            void 
            searchPath(
            int mprev[],
            int v,
            int u,String output) throws FileNotFoundException{            OutputStream 
            out = 
            new FileOutputStream(output,
            true);            
            int que[] = 
            new 
            int[maxnum];            
            int tot=
            1;            que[tot]=u;            tot++;            
            int tmp = mprev[u];                
            //tmp为目的节点之前的节点            
            while(tmp!=v){                     
            //目的节点与源节点v不相等                que[tot] =tmp;                                             tot++;                tmp=mprev[tmp];            
            //从目的节点回溯             }            que[tot]=v;                        
            //tot的值为回溯的次数                               
            for(
            int i = tot;i>=i;i--){                
            if(i!=
            1){                                                                              
            int num=que[i];                    
            try{                        
            out.write(String.valueOf(num).getBytes());        
            //一个字符串转化为一个字节数组                        
            out.write(
            ",".getBytes());                    }
            catch (IOException e){                        e.printStackTrace();                           
            //打印堆栈内容                    }                }                
            else{                    
            try{                        
            out.write(String.valueOf(que[i]).getBytes());                        
            out.write(
            "\r\n".getBytes());                    }
            catch(IOException e){                        e.printStackTrace();                    }                }            }            
            try{                
            out.close();            }
            catch(IOException e){                e.printStackTrace();            }        }    
            public 
            static 
            void 
            main(String[] args) throws IOException {        
            // TODO Auto-generated method stub       String input = args[
            0];     
            //而这个main方法有所不同的是：它是所有方法中最先运行的一个，所以没有其他方法给它传递参数，所以需要靠运行时命令行输入参数，所以String args,接收的是命令行的输入       String output = args[
            1];         BufferedReader 
            in = 
            new BufferedReader(
            new InputStreamReader(
            new FileInputStream(
            new File(input))) );       String str = 
            new String ();       
            int NodeNum=
            0;       
            int LineNum=
            0;       Vector
            
             vstr = 
             new Vector
             
              ();       Vector
              
               dstr = 
               new Vector
               
                (); 
                // java 中可以实现自动增长的对象数组 str = 
                in.readLine(); 
                //读取一个文本行  
                while(
                true){ str=
                in.readLine(); 
                if(str.isEmpty()){ 
                break; } vstr.add(str); 
                // 把读入的对象加在vstr中 LineNum++; } 
                in.readLine(); 
                in.readLine(); 
                while(
                true){ str=
                in.readLine(); 
                if(str==
                null) 
                break; 
                else 
                if(str.isEmpty()) 
                break; dstr.add(str); 
                // 把目的读入的对象加在dstr中 } String LastLine = (String)vstr.lastElement(); String[] strdata = LastLine.split(
                "\\,"); 
                int firststr = Integer.parseInt(strdata[
                0]); 
                int secondstr = Integer.parseInt(strdata[
                1]); 
                //根据，分割录入信息 
                if(firststr
                
                 else NodeNum = firststr; 
                 for(
                 int i=
                 1;i
                 
                  for(
                  int j=
                  1;j
                  
                   //建立整个拓扑 } } 
                   for(
                   int i=
                   1;i<=LineNum;i++){ String Readvstr = (String)vstr.
                   get(i-
                   1); 
                   //get一个数字 String [] vstrdata = Readvstr.split(
                   "\\,"); 
                   int firstvstr = Integer.parseInt(vstrdata[
                   0]); 
                   int secondvstr = Integer.parseInt(vstrdata[
                   1]); 
                   int thirdvstr = Integer.parseInt(vstrdata[
                   2]); 
                   if(thirdvstr>c[firstvstr][secondvstr]){ c[firstvstr][secondvstr]=thirdvstr; 
                   //取最小带宽  c[secondvstr][firstvstr]=thirdvstr; } } 
                   for(
                   int i=
                   1;i
                   
                    int src,dst,bdw; OutputStream 
                    out = 
                    new FileOutputStream(output,
                    false); 
                    out.write(
                    "".getBytes()); 
                    out.close(); 
                    for(
                    int i=
                    1;i<=dstr.size();i++){ String Readvstr = (String)dstr.
                    get(i-
                    1); String sdstr[] =Readvstr.split(
                    ","); src = Integer.parseInt(sdstr[
                    0]); dst = Integer.parseInt(sdstr[
                    1]); bdw = Integer.parseInt(sdstr[
                    2]); Dijkstra(NodeNum,src,bdw,dist,mprev,c); searchPath(mprev,src,dst,output); } }}
                   
                  
                 
                
               
              
             
            
           

第2步：控制器路由功能（12分）

把路由算法作为APP加入到控制器中，使SDN网络实现根据拓扑情况自动选择路由的功能。 报告书要求： (1) 简要描述实现思路，给出系统设计图，若有前面小题中没有提及的设备、软件等构件，则在此详细说明。 (2) 给出操作步骤。 (3) 给出实验数据，证明目的已经实现。

由于floodlight控制器本身的路由策略就是基于迪杰斯特拉算法的，因此就不加入此算法了。

详情见fl的topology模块的topologyinstanc.java

protected BroadcastTree dijkstra(Cluster c, Long root,                                     Map
           
             linkCost,                                     boolean isDstRooted) {        HashMap
            
              nexthoplinks = 
             new HashMap
             
              ();        
              //HashMap
               
                 nexthopnodes = new HashMap
                
                 ();
                
                       HashMap
              
                cost = 
               new HashMap
               
                (); 
                int w; 
                for (Long node: c.links.keySet()) { nexthoplinks.put(node, 
                null); 
                //nexthopnodes.put(node, null); cost.put(node, MAX_PATH_WEIGHT); } HashMap
                
                  seen = 
                 new HashMap
                 
                  (); PriorityQueue
                  
                    nodeq = 
                   new PriorityQueue
                   
                    (); nodeq.add(
                    new NodeDist(root, 
                    0)); cost.put(root, 
                    0); 
                    while (nodeq.peek() != 
                    null) { NodeDist n = nodeq.poll(); Long cnode = n.getNode(); 
                    int cdist = n.getDist(); 
                    if (cdist >= MAX_PATH_WEIGHT) 
                    break; 
                    if (seen.containsKey(cnode)) 
                    continue; seen.put(cnode, 
                    true); 
                    for (Link link: c.links.
                    get(cnode)) { Long neighbor; 
                    if (isDstRooted == 
                    true) neighbor = link.getSrc(); 
                    else neighbor = link.getDst(); 
                    // links directed toward cnode will result in this condition 
                    if (neighbor.equals(cnode)) 
                    continue; 
                    if (seen.containsKey(neighbor)) 
                    continue; 
                    if (linkCost == 
                    null || linkCost.
                    get(link)==
                    null) w = 
                    1; 
                    else w = linkCost.
                    get(link); 
                    int ndist = cdist + w; 
                    // the weight of the link, always 1 in current version of floodlight. 
                    if (ndist < cost.
                    get(neighbor)) { cost.put(neighbor, ndist); nexthoplinks.put(neighbor, link); 
                    //nexthopnodes.put(neighbor, cnode); NodeDist ndTemp = 
                    new NodeDist(neighbor, ndist); 
                    // Remove an object that's already in there. 
                    // Note that the comparison is based on only the node id, 
                    // and not node id and distance. nodeq.remove(ndTemp); 
                    // add the current object to the queue. nodeq.add(ndTemp); } } } BroadcastTree ret = 
                    new BroadcastTree(nexthoplinks, cost); 
                    return ret; }
                   
                  
                 
                
               
              
             
            
           

第三题：设计题（SDN应用方案设计）——50分

初赛提供5种SDN应用方案（见附录），参赛队伍可以选择其中之一来搭建SDN网络，实现应用功能。并且鼓励参赛队伍对方案进行优化和创新性改进（不偏离原方案的目标）。 要求： 1.按照课程设计报告的形式，分别从选题背景介绍（选题依据，对本领域的意义），设计方案和实现方法（可以分为几个章节），验证实验设计和实验结果（初赛给出实验方案设计及仿真实验结果），结论这几个方面详述。 2.在提交的方案中需要给出实验的网络拓扑，并给出主要核心的操作步骤。对技术实现及其可行性需要作一定的论证，能给出理论分析、仿真结果等论据材料则更佳。 3.进入复赛的参赛队伍需要对开放题的方案作适当改进，并采用大赛提供的SDN平台来实现方案，使其尽量达到Demo的程度，能够现场演示说明。 4.报告文档中的必备内容：背景介绍、设计方案、实现方法、网络拓扑、优点说明、验证实验设计。文档中的可选内容：实验结果或仿真结果、理论分析、实验数据、其他补充材料。

PS：在准备第二届sdn大赛中