# your code goes here ….# Copyright (C) 2011 Nippon Telegraph and Telephone Corporation. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://w...content-available-to-author-only...e.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or # implied. # See the License for the specific language governing permissions and # limitations under the License. from ryu.base import app_manager from ryu.controller import ofp_event from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER from ryu.controller.handler import set_ev_cls from ryu.ofproto import ofproto_v1_3 from ryu.lib.packet import packet from ryu.lib.packet import ethernet from ryu.lib.packet import ether_types class SimpleSwitch13(app_manager.RyuApp): OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION] def __init__(self, *args, **kwargs): super(SimpleSwitch13, self).__init__(*args, **kwargs) self.mac_to_port = {} @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER) def switch_features_handler(self, ev): datapath = ev.msg.datapath #ev.msg 是用來儲存對應事件的 OpenFlow 訊息類別實體 ofproto = datapath.ofproto parser = datapath.ofproto_parser #print(ofproto) #print(parser) # install table-miss flow entry # # We specify NO BUFFER to max_len of the output action due to # OVS bug. At this moment, if we specify a lesser number, e.g., # 128, OVS will send Packet-In with invalid buffer_id and # truncated packet data. In that case, we cannot output packets # correctly. The bug has been fixed in OVS v2.1.0. match = parser.OFPMatch() #print(match) actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)] #print(actions) self.add_flow(datapath, 0, match, actions) #meter examples #add meters,m_id meter_id,unit of rate:Kbps #self.meter_table ={"00:00:00:00:00:01":1,"00:00:00:00:00:02":1} #for m_id in range(1,2):$ #m_id = 1 #bands = [parser.OFPMeterBandDrop(type_=ofproto.OFPMBT_DROP, len_=0,rate=50, burst_size=10)] #self.add_meter(datapath,bands,m_id) # add rule for metering in s1 if ev.msg.datapath.id == 1: datapath = ev.msg.datapath ofproto = datapath.ofproto parser = datapath.ofproto_parser #seed_file = open("./cntr.txt", "r") #seed_num = seed_file.read() #print("seed num:",seed_num) #seed_num.split() input_file_name = "./input_5_seed1.txt" input_file = open(input_file_name, "r") print("input file: ", input_file_name) content = input_file.readlines() for i in content: line = i.split() flow_id_buf = int(line[0]) flow_rate_buf = (int)(int(line[1]) * 1.1) print('id: ', flow_id_buf, ' d(f): ', flow_rate_buf) bands = [parser.OFPMeterBandDrop(type_ = ofproto.OFPMBT_DROP, len_ = 0,rate= flow_rate_buf, burst_size = 5)] req = parser.OFPMeterMod(datapath = datapath, command = ofproto.OFPMC_ADD, flags = ofproto.OFPMF_KBPS, meter_id = flow_id_buf + 1 , bands = bands) #set up a controller,send for switch request print("meter id :",bands) datapath.send_msg(req) ip_src = "10.0.0." + str((flow_id_buf + 1) % 256) ip_dst = "10.0.0." + str((flow_id_buf + 1 + 5) % 256) #print(ip_dst) match = parser.OFPMatch(in_port = flow_id_buf + 1 , eth_type = 0x0800, ipv4_src = ip_src, ipv4_dst = ip_dst) actions = [parser.OFPActionOutput(121)] inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), parser.OFPInstructionMeter(flow_id_buf + 1, ofproto.OFPIT_METER)] mod = datapath.ofproto_parser.OFPFlowMod( datapath=datapath, match=match, cookie=0, command=ofproto.OFPFC_ADD, idle_timeout=0, hard_timeout=0, priority=3, instructions=inst) #t_start = time.time() datapath.send_msg(mod) #def add_meter(self,datapath,bands,meter_id): #ofproto=datapath.ofproto #parser =datapath.ofproto_parser #print(meter) #req = parser.OFPMeterMod(datapath=datapath,command=ofproto.OFPMC_ADD,flags=ofproto.OFPMF_KBPS,meter_id=meter_id,bands=bands) #datapath.send_msg(req) def add_flow(self, datapath, priority, match, actions, buffer_id=None): ofproto = datapath.ofproto parser = datapath.ofproto_parser inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)] if buffer_id: mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id, priority=priority, match=match, instructions=inst) else: mod = parser.OFPFlowMod(datapath=datapath, priority=priority, match=match, instructions=inst) datapath.send_msg(mod) @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER) def _packet_in_handler(self, ev): # If you hit this you might want to increase # the "miss_send_length" of your switch if ev.msg.msg_len < ev.msg.total_len: self.logger.debug("packet truncated: only %s of %s bytes", ev.msg.msg_len, ev.msg.total_len) msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto parser = datapath.ofproto_parser in_port = msg.match['in_port'] pkt = packet.Packet(msg.data) eth = pkt.get_protocols(ethernet.ethernet)[0] #if eth.ethertype == ether_types.ETH_TYPE_LLDP: # ignore lldp packet # return dst = eth.dst src = eth.src dpid = format(datapath.id, "d").zfill(4) self.mac_to_port.setdefault(dpid, {}) #print("......................................") #print("Add switch",dpid,"to mac_to_port table") #print("......................................") self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port) # learn a mac address to avoid FLOOD next time print(self.mac_to_port[dpid]) self.mac_to_port[dpid][src] = in_port #dpid=switch id,src=host mac if dst in self.mac_to_port[dpid]: out_port = self.mac_to_port[dpid][dst] ##add flow with meter id # when traffic generated frm src x.x.x.x. will be applied to a meter_id #meter_id =self.meter_table[src] else: out_port = ofproto. OFPP_FLOOD actions = [parser.OFPActionOutput(out_port)] # install a flow to avoid packet_in next time if out_port != ofproto.OFPP_FLOOD: match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src) # verify if we have a valid buffer_id, if yes avoid to send both # flow_mod & packet_out if msg.buffer_id != ofproto.OFP_NO_BUFFER: self.add_flow(datapath, 1, match, actions,msg.buffer_id) return else: self.add_flow(datapath, 1, match, actions) data = None if msg.buffer_id == ofproto.OFP_NO_BUFFER: data = msg.data out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port, actions=actions, data=data) datapath.send_msg(out)