コード例 #1
0
def send_stats_request_handler(Type, flow_1, port=None):
    flow = str(flow_1)
    ofp_flow_wildcards = of.ofp_flow_wildcards(flow[8:12])
    ofp_match = of.ofp_match(flow[12:48])
    ofp_flow_mod = of.ofp_flow_mod(flow[48:72])
    if len(flow) >= 88:
        action_header = of.ofp_action_header(flow[72:80])
        action_output = of.ofp_action_output(flow[80:88])
    #we need to send the stats request packets periodically
    msg = {
        0:
        of.ofp_header(type=16, length=12) /
        of.ofp_stats_request(type=0),  #Type of  OFPST_DESC (0) 
        1:
        of.ofp_header(type=16, length=56) / of.ofp_stats_request(type=1) /
        ofp_flow_wildcards / ofp_match /
        of.ofp_flow_stats_request(out_port=ofp_flow_mod.out_port),  #flow stats
        2:
        of.ofp_header(type=16, length=56) / of.ofp_stats_request(type=2) /
        ofp_flow_wildcards / ofp_match /
        of.ofp_aggregate_stats_request(),  # aggregate stats request
        3:
        of.ofp_header(type=16, length=12) /
        of.ofp_stats_request(type=3),  #Type of  OFPST_TABLE (0) 
        4:
        of.ofp_header(type=16, length=20) / of.ofp_stats_request(type=4) /
        of.ofp_port_stats_request(port_no=port),  # port stats request    
        5:
        of.ofp_header(type=16, length=20) / of.ofp_stats_request(type=5) /
        of.ofp_queue_stats_request(),  #queue request
        6:
        of.ofp_header(type=16, length=12) /
        of.ofp_stats_request(type=0xffff)  #vendor request
    }
    return msg[Type]
コード例 #2
0
ファイル: ofp_handler.py プロジェクト: muzixing/Ccontroller
def send_stats_request_handler(Type, flow_1, port =None):
    flow =str(flow_1)
    ofp_flow_wildcards=of.ofp_flow_wildcards(flow[8:12])
    ofp_match =of.ofp_match(flow[12:48])
    ofp_flow_mod =of.ofp_flow_mod(flow[48:72])
    if len(flow)>=88:
        action_header = of.ofp_action_header(flow[72:80])
        action_output = of.ofp_action_output(flow[80:88])
    #we need to send the stats request packets periodically
    msg = { 0: of.ofp_header(type = 16, length = 12)/of.ofp_stats_request(type = 0),                            #Type of  OFPST_DESC (0) 
            1: of.ofp_header(type = 16, length = 56)/of.ofp_stats_request(type =1)/ofp_flow_wildcards/ofp_match/of.ofp_flow_stats_request(out_port = ofp_flow_mod.out_port),                  #flow stats
            2: of.ofp_header(type = 16, length =56)/of.ofp_stats_request(type = 2)/ofp_flow_wildcards/ofp_match/of.ofp_aggregate_stats_request(),                                  # aggregate stats request
            3: of.ofp_header(type = 16, length = 12)/of.ofp_stats_request(type = 3),                            #Type of  OFPST_TABLE (0) 
            4: of.ofp_header(type = 16, length =20)/of.ofp_stats_request(type = 4)/of.ofp_port_stats_request(port_no = port),   # port stats request    
            5: of.ofp_header(type = 16, length =20)/of.ofp_stats_request(type =5)/of.ofp_queue_stats_request(), #queue request
            6: of.ofp_header(type = 16, length = 12)/of.ofp_stats_request(type = 0xffff)                        #vendor request
        }
    return msg[Type]
コード例 #3
0
def client_handler(address, fd, events):
    sock = fd_map[fd]
    if events & io_loop.READ:
        data = sock.recv(1024)
        if data == '':
            print "connection dropped"
            io_loop.remove_handler(fd)
        if len(data) < 8:
            print "not a openflow message"
        else:
            if len(data) > 8:
                rmsg = of.ofp_header(data[0:8])
                body = data[8:]
            else:
                rmsg = of.ofp_header(data)

            handler = {
                0: ofp_handler.hello_handler(body),
                1: ofp_handler.error_handler(body),
                2: ofp_handler.echo_request_handler(rmsg),
                3: ofp_handler.echo_reply_handler(body),
                4: ofp_handler.echo_reply_handler(body),
                5: ofp_handler.features_request_handler(body),
                6: ofp_handler.features_request_handler(body),
                7: ofp_handler.features_reply_handler(body, fd),
                8: None,
                9: None,
                10: ofp_handler.packet_in_handler(body, fd),
                11: ofp_handler.flow_removed_handler(body),
                12: ofp_handler.port_status_handler(body),
                13: ofp_handler.packet_out_handler(body),
                14: ofp_handler.flow_mod_handler(body),
                15: ofp_handler.port_mod_handler(body),
                16: ofp_handler.status_request_handler(body),
                17: ofp_handler.status_reply(body),  #body
                18: ofp_handler.barrier_request_handler(body),
                19: ofp_handler.barrier_reply_handler(body),
                20: ofp_handler.get_config_request_handler(body),
                21: ofp_handler.get_config_reply_handler(body),
                24: ofp_handler.cfeatrues_reply_handler(body)  #body
            }
            if rmsg.type == 6:
                (msg, port_info) = handler[6]
                global ready
                ready = 1
            elif rmsg.type == 24:
                (msg, port_info) = handler[24]
                ready = 1
            else:
                msg = handler[rmsg.type]

            message_queue_map[sock].put(str(msg))
            io_loop.update_handler(fd, io_loop.WRITE)
    global count
    if ready and count % period == 0:
        #print "send stats_requests"
        flow = of.ofp_header() / of.ofp_flow_wildcards() / of.ofp_match(
        ) / of.ofp_flow_mod()
        message_queue_map[sock].put(
            str(ofp_handler.send_stats_request_handler(
                1, flow)))  #the parameter is the type of stats request
        io_loop.update_handler(fd, io_loop.WRITE)
        count = 1
    count += 1

    #################################   We finish the actions of manipulateing  ################################

    if events & io_loop.WRITE:
        try:
            next_msg = message_queue_map[sock].get_nowait()
        except Queue.Empty:
            #print "%s queue empty" % str(address)
            io_loop.update_handler(fd, io_loop.READ)
        else:
            #print 'sending "%s" to %s' % (of.ofp_header(next_msg).type, address)
            sock.send(next_msg)
コード例 #4
0
   def run(self):
     while core.running:
       """
       This looks almost exactly like python's select.select, except that it's
       it's handled cooperatively by recoco.

       In this field, you could design your own CLI.
       """
       
       string = raw_input("\n------------------------------\n1.info(ports)\n2.switch\n3.topo\n4.flow(flow type,dpid, type=0 flow, type=1 cflow)\n5.add link-type(add ip1,ip2,type(IP=1, OTN=2))\n6.stype(BOTH=0, IP=1, OTN=2, for all)\n7.create link(create ip1,ip2)\n8.delete(del ip1,ip2)\n?")
       string = string.split(' ')
       if string[0] == 'info':
         action = 1
         print tables.info_map
         print "\n\n\n"
       elif string[0] == 'switch':
         action = 2
         print tables.switch_map
         print "\n\n\n"
       elif string[0] == 'topo':
         action = 3
         print tables.topo_map
         print "\n\n\n"
       elif string[0] == 'flow':
         action = 4
         string = string[1].split(',')
         flow_type = string[0]
         dpid = int(string[1])
         if flow_type == '0':
           print "flows in dpid:", dpid, "\n"
           if dpid in tables.flow_map.iterkeys():
             for flow in tables.flow_map[dpid]:
               flow.show()
         elif flow_type == '1':
           print "cflows in dpid:", dpid, "\n"
           if dpid in tables.cflow_map.iterkeys():
             for link, cflow in tables.cflow_map[dpid]:
               cflow.show()
         else:
           print "wrong type!\n"
         print "\n\n\n"
       elif string[0] == 'add':
         action = 5
         global ip_type
         string = string[1].split(',')
         ip1 = string[0]
         ip2 = string[1]
         ip_type[(ip1,ip2)] = string[2]
         ip_type[(ip2,ip1)] = string[2]
       elif string[0] == 'stype':
         action = 6
         global stype
         stype = string[1]
       
       elif string[0] == 'create':#could not be completed with buffer_id
         action = 7
         string = string[1].split(',')
         src = string[0]
         dst = string[1]
         
         road, link, route_type = route.add_link(src,dst,'1')
         for dpid in road:
           if dpid in link.iterkeys():
             src_port, dst_port = link[dpid][0], link[dpid][1]
             header = of.ofp_header(type = 14, length = 88, xid = dpid)
             wildcards = of.ofp_flow_wildcards(OFPFW_NW_TOS = 1, OFPFW_DL_VLAN_PCP = 1,
                         OFPFW_NW_DST_MASK = 0, OFPFW_NW_SRC_MASK = 0,
                         OFPFW_TP_DST = 1,      OFPFW_TP_SRC = 1,
                         OFPFW_NW_PROTO = 1,    OFPFW_DL_TYPE = 1,
                         OFPFW_DL_DST = 1,      OFPFW_DL_SRC = 1,
                         OFPFW_DL_VLAN = 1,     OFPFW_IN_PORT = 0)
             match = of.ofp_match(in_port = src_port,
                         nw_src = src, nw_dst =dst)
             flow_mod = of.ofp_flow_mod(buffer_id = -1, idle_timeout = 0, hard_timeout = 0, flags = 1, out_port = dst_port)
             action_header = oof.ofp_action_header(type = 0)
             action_output = of.ofp_action_output(type = 0, port = dst_port, len = 8)
             msg = header/wildcards/match/flow_mod/action_header/action_output
             for fd,dp in tables.sock_dpid.items():
               if dpid == dp[1]:
                 sock = tables.fd_map[fd]
                 break
             sock.send(str(msg))
       elif string[0]  == 'del':
         action = 8
         #todo: delete the flows in swithes whenever you want
         string = string[1].split(',')
         src = string[0]
         dst = string[1]
         if (src,dst) not in ip_type.iterkeys():
           print "there is no flow for ", src, " and ", dst, "\n"
         else:
           remove_type = ip_type[src,dst]
	   if remove_type == '1':#for ip, flow in tables.flow_map
             for link, road in tables.road_map.items():
               if link == (src,dst):#find the link, from src to dst
                 for dpid in road:#delete the related flow in every switches
                   for fd,dp in tables.sock_dpid.items():
                     if dpid == dp[1]:#find dpid-sock
                       sock = tables.fd_map[fd]
                       break
                   if dpid in tables.flow_map.iterkeys():
                     for item in tables.flow_map[dpid]:
                       if item.payload.payload.nw_src == src and item.payload.payload.nw_dst == dst:
                         data = str(item)
                         header = of.ofp_header(data[0:8])
                         header.length = 72
                         wildcards = of.ofp_flow_wildcards(data[8:12])
                         match = of.ofp_match(data[12:48])
                         flow_mod = of.ofp_flow_mod(data[48:72])
                         flow_mod.command = 4
                         msg = header/wildcards/match/flow_mod
                         sock.send(str(msg))
                         break
                 break
                                  
           elif remove_type == '2':#for otn, cflow in tables.cflow_map
             pass
   
       elif string[0] == '0':
         print "stop input function...\n"
         return
       else:
         log.warning("Character string cannot be identified!")
         continue
       print action
コード例 #5
0
def client_handler(address, fd, events):
  global ip_type
  sock = tables.fd_map[fd]
  if events & io_loop.READ:
    data = sock.recv(16384)
    if data == '':
      print "connection dropped"
      #when switch is dropped, the outdated information should be deleted
      io_loop.remove_handler(fd)
      if fd in tables.fd_map.iterkeys() and fd in tables.sock_dpid.iterkeys():
        dpid = tables.sock_dpid[fd][1]
        tables.sock_dpid.pop(fd)
        tables.fd_map.pop(fd)
      
        for link in tables.topo_map.iterkeys():
          if tables.topo_map[link]['status'] != -1 and (link[0] == dpid or link[2] == dpid):
            tables.topo_map[link]['status'] = -1#the link will not be re-counted
            dc.topo_flag += 2#when topo_flag>0, controller will stop dealing with packet
        tables.switch_map.pop(dpid)
        if dpid in tables.info_map.iterkeys():
          tables.info_map.pop(dpid)
        if dpid in tables.flow_map.iterkeys():
          tables.flow_map.pop(dpid)
      
        create_topo._connection_down(dpid)#renew the topo in discovery.py
        create_topo._sender._connection_down(dpid)
        
    if len(data)<8:
      print "not a openflow message"
    else:
      if len(data)>8:
        rmsg = of.ofp_header(data[0:8])
        body = data[8:]
      else:
        rmsg = of.ofp_header(data)

      if rmsg.type == 0:
        print "OFPT_HELLO"
        msg = of.ofp_header(type = 5)#we send the features_request here.
        print "OFPT_FEATURES_REQUEST"
        io_loop.update_handler(fd, io_loop.WRITE)
        message_queue_map[sock].put(data)
        message_queue_map[sock].put(str(msg))

      elif rmsg.type == 1:
        print "OFPT_ERROR"
        of.ofp_error_msg(body).show()

      elif rmsg.type == 2:
        #since the ECHO is too frequent, the print is canceled
        #print "OFPT_ECHO_REQUEST"
        msg = of.ofp_header(type=3, xid=rmsg.xid)
        message_queue_map[sock].put(str(msg))
        io_loop.update_handler(fd, io_loop.WRITE)

      elif rmsg.type == 3:
        print "OFPT_ECHO_REPLY"

      elif rmsg.type == 4:
        print "OFPT_VENDOR"

      elif rmsg.type == 5:
        print "OFPT_FEATURES_REQUEST"

      elif rmsg.type == 6:
        print "OFPT_FEATURES_REPLY"
        msg = of.ofp_features_reply(body[0:24])                   #length of reply msg
        tables.sock_dpid[fd]=[0, msg.datapath_id]                             #sock_dpid[fd] comes from here.

        port_info_raw = str(body[24:])                            #we change it into str so we can manipulate it.
        port_info = {}
        print "port number:",len(port_info_raw)/48, "total length:", len(port_info_raw)
        for i in range(len(port_info_raw)/48):
          port_info[i] = of.ofp_phy_port(port_info_raw[0+i*48:48+i*48])
          print port_info[i].port_no     
                
      elif rmsg.type == 10:
        #print "OFPT_PACKET_IN"
        pkt_in_msg = of.ofp_packet_in(body)#buffer_id+in_port
        raw = pkt_in_msg.load
        pkt_ = ethernet(raw)#this method can be located in pox
        pkt_parsed = of.Ether(raw)
        dpid = tables.sock_dpid[fd][1]
        if pkt_.effective_ethertype == 0x88cc:#deal with the LLDP for topo
          create_topo._handle_openflow_PacketIn(pkt_in_msg, pkt_, dpid)
        if dc.topo_flag:#when the topo is not completed, do nothing
          pass
        else:      
          if pkt_.effective_ethertype == 0x0806:
            #the ARP table is maintained for hosts' MAC in tables.py
            print "\n\nARP\n\n"
            request = pkt_parsed.next         
            if request.opcode == arp.REQUEST:
              reply = arp()
              reply.hwtype = request.hwtype
              reply.prototype = request.prototype
              reply.hwlen = request.hwlen
              reply.protolen = request.protolen
              reply.opcode = arp.REPLY
              reply.hwdst = request.hwsrc
              reply.protodst = request.protosrc
              reply.protosrc = request.protodst
              reply.hwsrc = tables.get_mac(request.protodst.toStr())
              #reply.hwsrc = tables.ip_mac[request.protodst]
              e_dpid = tables.sock_dpid[fd][1]
              for p,v in tables.switch_map[e_dpid]['port'].items():
                if v.port_no == pkt_in_msg.in_port:
                  e_src = v.hw_addr
              e = ethernet(type = pkt_parsed.type, src = e_src, dst = pkt_parsed.src)
              e.set_payload(reply)               
              msg = off.ofp_packet_out()
              msg.data = e.pack()
              msg.actions.append(off.ofp_action_output(port = off.OFPP_IN_PORT))#port problem
              msg.in_port = pkt_in_msg.in_port
              msg = msg.pack()

              io_loop.update_handler(fd, io_loop.WRITE)
              message_queue_map[sock].put(str(msg))
          elif pkt_.effective_ethertype == 0x8100:
            #to detect VLAN packets
            print "VLAN:\n"
            packet = pkt_.next
            print packet.__dict__
          elif pkt_.effective_ethertype == 0x0800:
            #print "\n\nIP\n\n"
            #use the packet to produce flow_mod
            packet = pkt_.next
            if isinstance(packet, ipv4):
              src = packet.srcip.toStr()
              dst = packet.dstip.toStr()
              dpid = tables.sock_dpid[fd][1]
              #the routing type of the link(src,dst) is based on s_type
              if (src, dst) in ip_type.iterkeys():
                s_type = ip_type[(src,dst)]
			  elif stype != '0':
                s_type = stype
              else:
                s_type = '0'
              #src_mac = tables.switch_map[dpid]['port'][src_port].hw_addr
              #dst_mac = tables.switch_map[dpid]['port'][dst_port].hw_addr
              road, rlink, route_type = route.add_link(src, dst, s_type)
              #establish info for barrier
              if (src,dst) not in tables.road_map.iterkeys():
                tables.road_map[(src,dst)] = road
              if (src,dst) not in tables.barrier_map.iterkeys():
                tables.barrier_map[(src,dst)] = {}
              if dpid not in tables.barrier_map[(src,dst)].iterkeys():
                tables.barrier_map[(src,dst)][dpid] = rmsg.xid
              if route_type == 0:#ip link, send flow
                ip_type[(src,dst)] = '1'
                if dpid in rlink.iterkeys():
                  src_port, dst_port = rlink[dpid][0], rlink[dpid][1] 
                  print "flow from ", src, " to ", dst, "\n"
                  print "dpid:",dpid," inport:",src_port," outport:",dst_port, "\n"
                  print "-------------------------"
                  header = of.ofp_header(type=14, length = 88, xid=rmsg.xid)
                  wildcards = of.ofp_flow_wildcards(OFPFW_NW_TOS=1,      OFPFW_DL_VLAN_PCP=1,
                                              OFPFW_NW_DST_MASK=63, OFPFW_NW_SRC_MASK=63,
                                              OFPFW_TP_DST=1,      OFPFW_TP_SRC=1,
                                              OFPFW_NW_PROTO=1,    OFPFW_DL_TYPE=1,
                                              OFPFW_DL_DST=0,      OFPFW_DL_SRC=0,
                                              OFPFW_DL_VLAN=1,     OFPFW_IN_PORT=0)
                  match = of.ofp_match(in_port=pkt_in_msg.in_port,
                          dl_src = pkt_parsed.src, dl_dst = pkt_parsed.dst,
                          dl_type = pkt_parsed.type,
                          nw_tos = pkt_parsed.payload.tos, 
                          nw_proto = pkt_parsed.payload.proto,
                          nw_src=src,  nw_dst=dst)
                  flow_mod = of.ofp_flow_mod(buffer_id = pkt_in_msg.buffer_id, idle_timeout = 0, hard_timeout = 30, flags = 1, cookie = rmsg.xid, out_port = dst_port)
                  action_header = oof.ofp_action_header(type = 0)
                  action_output = of.ofp_action_output(type = 0, port = dst_port, len = 8)
                  msg = header/wildcards/match/flow_mod/action_header/action_output
                  #here is to renew the flow_map
                  if dpid not in tables.flow_map.iterkeys():
                    tables.flow_map[dpid] = []
                    tables.flow_map[dpid].append(msg)
                  else:
                    for flow in tables.flow_map[dpid]:
                      flow_match = of.ofp_match((str(flow))[12:48])
                      if match == flow_match:
                        tables.flow_map[dpid].remove(flow)
                        break
                    tables.flow_map[dpid].append(msg)
                message_queue_map[sock].put(str(msg))
                io_loop.update_handler(fd, io_loop.WRITE)

              elif route_type == 1:#otn or wavelenth
                ip_type[(src,dst)] = '2'
                if dpid in rlink.iterkeys():
                  src = packet.srcip.toStr()
                  dst = packet.dstip.toStr()
                  src_port, dst_port = rlink[dpid][0], rlink[dpid][1]
                  if (src,dst) not in tables.source_map.iterkeys():
                    tables.source_map[(src,dst)] = {}
                  if dpid not in tables.source_map[(src,dst)].iterkeys():
                    tables.source_map[(src,dst)][dpid] = {}
                  if src_port not in tables.source_map[(src,dst)][dpid].iterkeys():
                    tables.source_map[(src,dst)][dpid][src_port] = []
                  if dst_port not in tables.source_map[(src,dst)][dpid].iterkeys():
                    tables.source_map[(src,dst)][dpid][dst_port] = []
                  if dpid == road[-1]:#src host port has no slot
                    src_slot = -1
                  else:
                    for i in xrange(0,80):
                      if tables.info_map[dpid][src_port][i]['status'] == 0:
                        tables.info_map[dpid][src_port][i]['status'] = 1
                        src_slot = i
                        tables.source_map[(src,dst)][dpid][src_port].append(i)
                        break
                  if dpid == road[0]:#dst host port has no slot:
                    dst_slot = -1
                  else:
                    for i in xrange(0,80):
                      if tables.info_map[dpid][dst_port][i]['status'] == 0:
                        tables.info_map[dpid][dst_port][i]['status'] = 1
                        dst_slot = i
                        tables.source_map[(src,dst)][dpid][dst_port].append(i)
                        break

                  cflow_mod = of.ofp_header(type=0xff, xid=rmsg.xid)\
                       /of.ofp_cflow_mod(command=0)\
                       /of.ofp_connect_wildcards()\
                       /of.ofp_connect(in_port = pkt_in_msg.in_port)\
                       /of.ofp_action_output(type=0, port=dst_port, len=8)
                  type = switch_info[tables.sock_dpid[fd][0]]

                  if route_type == 1:#for OTN
                    if src_slot == -1:
                      cflow_mod.payload.payload.payload.nport_in = 81
                    else:
                      cflow_mod.payload.payload.payload.nport_in = src_slot
                    if dst_slot == -1:
                      cflow_mod.payload.payload.payload.nport_out = 81
                    else:  
                      cflow_mod.payload.payload.payload.nport_out = dst_slot
                    cflow_mod.payload.payload.payload.supp_sw_otn_gran_out = tables.switch_map[dpid]['port'][dst_port].SUPP_SW_GRAN
                    cflow_mod.payload.payload.payload.sup_otn_port_bandwidth_out = tables.switch_map[dpid]['port'][dst_port].sup_otn_port_bandwidth

                  elif route_type == 2:#for wavelength
                    cflow_mod.payload.payload.payload.wport_in = src_slot
                    cflow_mod.payload.payload.payload.wport_out = dst_slot
                  
                  #this field is used to record cflow, but I have no ideal about how to delete the outdate flow---------------------
                  
                  if dpid not in tables.cflow_map.iterkeys():#cflow_map,12.19 
                    tables.cflow_map[dpid] = {}
                  tables.cflow_map[dpid][(src,dst)] = cflow_mod

                  print "cflow from ", src, " to ", dst, "\n"
                  print "dpid:", dpid, " in_port:", cflow_mod.payload.payload.payload.in_port, " out_port:", cflow_mod.payload.payload.payload.payload.port, "\n"
                  print "------------------------"
                  message_queue_map[sock].put(str(cflow_mod))
                  io_loop.update_handler(fd, io_loop.WRITE)
              

              #send barrier
              msg = of.ofp_header(type = 18,xid = rmsg.xid) 
              message_queue_map[sock].put(str(msg))
              io_loop.update_handler(fd, io_loop.WRITE)

      elif rmsg.type == 11: 
        print "OFPT_FLOW_REMOVED"
      elif rmsg.type == 12:
        print "OFPT_PORT_STATUS"
      elif rmsg.type == 13:
        print "OFPT_PACKET_OUT"
      elif rmsg.type == 14:
        print "OFPT_FLOW_MOD"
      elif rmsg.type == 15:
        print "OFPT_PORT_MOD"
      elif rmsg.type == 16:
        print "OFPT_STATS_REQUEST"
                
      elif rmsg.type == 17 and len(data)> 12:
        print "OFPT_STATS_REPLY"
        # 1. parsing ofp_stats_reply
        reply_header = of.ofp_stats_reply(body[:4])
        # 2.parsing ofp_flow_stats msg
        if reply_header.type == 0:
          reply_desc = of.ofp_desc_stats(body[4:])
          reply.show()
        elif reply_header.type == 1 and len(data)>92:
          #here informatioin is used for flow stats
          reply_body_data1 = of.ofp_flow_stats(body[4:8])
          # match field in ofp_flow_stats
          reply_body_wildcards = of.ofp_flow_wildcards(body[8:12])
          reply_body_match = of.ofp_match(body[12:48])
          # second part in ofp_flow_stats
          reply_body_data2 = of.ofp_flow_stats_data(body[48:92])
          # 3.parsing actions
          reply_body_action = []
          if len(body[92:])>8:                         #it is very important!
            num = len(body[92:])/8
            for x in xrange(num):
              reply_body_action.append(of.ofp_action_output(body[92+x*8:100+x*8]))
                            
          msg = reply_header/reply_body_data1/reply_body_wildcards/reply_body_match/reply_body_data2

          #the followings are about Load Balancing
          if fd in tables.fd_map.iterkeys() and fd in tables.sock_dpid.iterkeys():
            dpid = tables.sock_dpid[fd][1]
          if dpid in tables.flow_map.iterkeys():
            src_mac = reply_body_match.dl_src
            dst_mac = reply_body_match.dl_dst
            for flow in tables.flow_map[dpid]:
              if flow.payload.payload.dl_src == src_mac and flow.payload.payload.dl_dst == dst_mac:
                src_ip = flow.payload.payload.nw_src
                dst_ip = flow.payload.payload.nw_dst
                pair = (src_ip,dst_ip)
                flow_time = float(reply_body_data2.duration_sec) + float(reply_body_data2.duration_nsec/1000000000)
                flow_data = float(reply_body_data2.byte_count)
                if pair not in ip_stats.iterkeys():
                  ip_stats[pair] = {}
                  ip_stats[pair][0] = {}
                  ip_stats[pair][0]['flow_time'] = flow_time
                  ip_stats[pair][0]['flow_data'] = flow_data
                else:
                  if 1 in ip_stats[pair].iterkeys():#have a pair
                    ip_stats[pair][0]['flow_time'] = ip_stats[pair][1]['flow_time']
                    ip_stats[pair][0]['flow_data'] = ip_stats[pair][1]['flow_data']
                  else:
                    ip_stats[pair][1] = {}
                  ip_stats[pair][1]['flow_time'] = flow_time
                  ip_stats[pair][1]['flow_data'] = flow_data
                  if flow_time != ip_stats[pair][0]['flow_time']:
                    load = (flow_data - ip_stats[pair][0]['flow_data']) / (flow_time - ip_stats[pair][0]['flow_time'])
                    print "now the link ", pair, " load is ", load, "(byte/s)\n"
                    global switch_load
                    if load > switch_load:#change to cflow
                      ip_type[pair] = '2'
                      #todo:flow_mod(delete)

        elif reply_header.type == 2:
          reply_aggregate = of.ofp_aggregate_stats_reply(body[4:])
          reply_aggregate.show()

        elif reply_header.type == 3:
          #table_stats
          length = rmsg.length - 12
          num = length/64
          for i in xrange(num):
            table_body = body[4+i*64:i*64+68]
            reply_table_stats = of.ofp_table_stats(table_body[:36])
            table_wildcards = of.ofp_flow_wildcards(table_body[36:40])
            reply_table_stats_data = of.ofp_table_stats_data(table_body[40:64])
            msg_tmp = reply_header/reply_table_stats/table_wildcards/reply_table_stats_data
          msg = rmsg/msg_tmp
          msg.show() 
        elif reply_header.type == 4:
          #port stats reply
          length = rmsg.length - 12
          num = length/104
          for i in xrange(num):
            offset = 4+i*104
            reply_port_stats = of.ofp_port_stats_reply(body[offset:(offset+104)])
            msg_tmp = reply_header/reply_port_stats
          msg = rmsg/msg_tmp
          msg.show()
        elif reply_header.type == 5:
          #queue reply
          length = rmsg.length - 12
          num = length/32
          if num:                     #if the queue is empty ,you need to check it !
            for i in xrange(num):
              offset = 4+i*32
              queue_reply = of.ofp_queue_stats(body[offset:offset+32])
              msg_tmp = reply_header/queue_reply
            msg = rmsg/msg_tmp
            msg.show()
        elif reply_header.type == 0xffff:
          #vendor reply
          msg = rmsg/reply_header/of.ofp_vendor(body[4:])

      elif rmsg.type == 18:
        print "OFPT_BARRIER_REQUEST"
      #no message body, the xid is the previous barrier request xid
      elif rmsg.type == 19:
        barrier = 0
        dpid = tables.sock_dpid[fd][1]
        for a,b in tables.barrier_map.items():
          for k,v in b.items():
            if k == dpid and v == rmsg.xid:
              if dpid == tables.road_map[a][0]:#if the barrier is from the dst switch, then the road is completed   
                barrier = 1
                print "road ", a, " is completed!\n"
                tables.barrier_map.pop(a)
          if barrier:
            break
          
        #print "OFPT_BARRIER_REPLY: ", rmsg.xid, "Successful"
      elif rmsg.type == 20:
        print "OFPT_QUEUE_GET_CONFIG_REQUEST"
      elif rmsg.type == 21:
        print "OFPT_QUEUE_GET_CONFIG_REPLY"
      elif rmsg.type == 24:
        print "OFPT_CFEATURES_REPLY"
        msg = of.ofp_cfeatures_reply(body[0:24])#length of reply msg
        #bind the bpid and type  (type,  dpid)
        #OTN:WAVE:IP  b'000'
        TYPE = msg.OFPC_IP_SWITCH + msg.OFPC_WAVE_SWITCH * 2 + msg.OFPC_OTN_SWITCH * 4
        tables.sock_dpid[fd] = [TYPE, msg.datapath_id]#IP only
        port_info_raw = body[24:]
        port_info = {}
        port_i = {}
        print "port number:",len(port_info_raw)/72, "total length:", len(port_info_raw)
        for i in range(len(port_info_raw)/72):
          port_info[i] = of.ofp_phy_cport(port_info_raw[i*72:72+i*72])
          port_i[port_info[i].port_no] = port_info[i]

        switch_type = tables.sock_dpid[fd][0]#features recorded in switch_map
        tables.switch_map[msg.datapath_id] = {'features':msg, 'type':switch_type, 'port':port_i}
        tables.info_map[msg.datapath_id] = {} 
 
        #start to discovery
        lldp_flow = create_topo._connection_up(msg.datapath_id)
        
        message_queue_map[sock].put(str(lldp_flow))
        io_loop.update_handler(fd, io_loop.WRITE)#discovery-handle
        
        create_topo._sender._connection_up(msg.datapath_id, port_info)
コード例 #6
0
ファイル: Ccontroller.py プロジェクト: muzixing/Ccontroller
def client_handler(address, fd, events):
    sock = fd_map[fd]
    if events & io_loop.READ:
        data = sock.recv(1024)
        if data == '':
            print "connection dropped"
            io_loop.remove_handler(fd)
        if len(data)<8:
            print "not a openflow message"
        else:
            if len(data)>8:
                rmsg = of.ofp_header(data[0:8])
                body = data[8:]
            else:
                rmsg = of.ofp_header(data)

            handler = { 0:ofp_handler.hello_handler(body),
                        1:ofp_handler.error_handler(body),
                        2:ofp_handler.echo_request_handler(rmsg),
                        3:ofp_handler.echo_reply_handler(body),
                        4:ofp_handler.echo_reply_handler(body),
                        5:ofp_handler.features_request_handler(body),
                        6:ofp_handler.features_request_handler(body),
                        7:ofp_handler.features_reply_handler(body,fd),
                        8:None,
                        9:None,
                        10:ofp_handler.packet_in_handler(body,fd),
                        11:ofp_handler.flow_removed_handler(body),
                        12:ofp_handler.port_status_handler(body),
                        13:ofp_handler.packet_out_handler(body),
                        14:ofp_handler.flow_mod_handler(body),
                        15:ofp_handler.port_mod_handler(body),
                        16:ofp_handler.status_request_handler(body),
                        17:ofp_handler.status_reply(body),#body
                        18:ofp_handler.barrier_request_handler(body),
                        19:ofp_handler.barrier_reply_handler(body),
                        20:ofp_handler.get_config_request_handler(body),
                        21:ofp_handler.get_config_reply_handler(body),
                        24:ofp_handler.cfeatrues_reply_handler(body) #body
                        }
            if rmsg.type == 6:
                (msg, port_info) = handler[6]
                global ready
                ready = 1
            elif rmsg.type == 24:
                (msg, port_info) = handler[24]
                ready = 1
            else:
                msg = handler[rmsg.type]

            message_queue_map[sock].put(str(msg))
            io_loop.update_handler(fd, io_loop.WRITE)
    global count
    if ready and count % period == 0:
        #print "send stats_requests"
        flow =of.ofp_header()/of.ofp_flow_wildcards()/of.ofp_match()/of.ofp_flow_mod()
        message_queue_map[sock].put(str(ofp_handler.send_stats_request_handler(1,flow)))  #the parameter is the type of stats request
        io_loop.update_handler(fd, io_loop.WRITE)
        count = 1
    count+=1

    #################################   We finish the actions of manipulateing  ################################

    if events & io_loop.WRITE:
        try:
            next_msg = message_queue_map[sock].get_nowait()
        except Queue.Empty:
            #print "%s queue empty" % str(address)
            io_loop.update_handler(fd, io_loop.READ)
        else:
            #print 'sending "%s" to %s' % (of.ofp_header(next_msg).type, address)
            sock.send(next_msg)