def installTestStarFlowEntries(self): """ Code written for specific test on start topology. (Measure duplication and tagging time). :return: """ datapath1 = self.id_to_datapath[1] datapath2 = self.id_to_datapath[2] # Install the flow entries on the MP. Match = ofproto_v1_3_parser.OFPMatch( in_port=1, eth_type=ExtraLayers.typeForTestingTaggingAndDuplicationTime) Actions = [ ofproto_v1_3_parser.OFPActionOutput(0xfffffffd), ofproto_v1_3_parser.OFPActionOutput(0xfffffffd), ofproto_v1_3_parser.OFPActionPopVlan(), ofproto_v1_3_parser.OFPActionSetField( eth_type=ExtraLayers.dirBackwardsThreeFlowEntries), ofproto_v1_3_parser.OFPActionPushVlan( ethertype=ExtraLayers.VLAN_ID_ETHERTYPE_QINQ), ofproto_v1_3_parser.OFPActionSetField(vlan_vid=1), ofproto_v1_3_parser.OFPActionOutput(0xfffffffd) ] Inst = [ ofproto_v1_3_parser.OFPInstructionActions( datapath1.ofproto.OFPIT_APPLY_ACTIONS, Actions) ] mod = ofproto_v1_3_parser.OFPFlowMod( datapath=datapath1, priority=NORMAL_SWITCH_FORWARDING_PRIO, match=Match, instructions=Inst) datapath1.send_msg(mod)
def add_lb_flow(self, datapath, mac): global inc match = datapath.ofproto_parser.OFPMatch(in_port=4, eth_type=0x800, ip_proto=6, ipv4_dst='10.0.0.1', eth_dst='00:00:00:00:00:01') ip = "10.0.0." + str(self.mac_port[mac]) eth = "00:00:00:00:00:0" + str(self.mac_port[mac]) actions = [ ofparser.OFPActionSetField(ipv4_dst=ip), ofparser.OFPActionSetField(eth_dst=eth), ofparser.OFPActionSetField(tcp_dst=80), ofparser.OFPActionOutput(port=self.mac_port[mac]) ] print "redirected to port ", self.mac_port[mac] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=100, match=match, instructions=inst, hard_timeout=2) datapath.send_msg(mod)
def getReturnAndTagActions(self, switchID): ''' Get the return and tag actions :param switchID: ID of current switch :return: return and tag flow entries to be installed ''' actions = [] #In 4 flow entries, the packet contains only tagging on last switch ID (inner tagging) need to add #the first switch ID (outer tagging) and change the ethertype to be dirReturnNoTag. # Set type of packet actions.append( ofproto_v1_3_parser.OFPActionSetField( eth_src=ExtraLayers.ReturnNoTagMAC)) #push VLAN header actions.append(ofproto_v1_3_parser.OFPActionPushVlan()) #set the DirectionReturn field to be dirReturnNoTag #tag cuurent switch ID actions.append( ofproto_v1_3_parser.OFPActionSetField( vlan_vid=retMaskedVlanID(switchID))) # Send to ingress port. actions.append( ofproto_v1_3_parser.OFPActionOutput( (self.switch_to_parent_port[switchID]))) #return the actions list return actions
def getDoNotDistributeActions(self, switchID): ''' Get the do not distribute actions to the given switch and current number of flow entries. :param switchID: ID of current switch. :return: Do not distribute flow entries to be installed. ''' #initialize the actions set to be empty. actions = [] # Create the return packet - Set return And tag direaction and set the current switch ID with solid flag FALSE. # set vlan ID to be current switch(No solid flag). actions.append( ofproto_v1_3_parser.OFPActionSetField( eth_src=ExtraLayers.ReturnAndTagMAC)) # set vlan ID to be current switch with solid flag. actions.append( ofproto_v1_3_parser.OFPActionSetField( vlan_vid=retMaskedVlanID(switchID))) # Send to ingress port. actions.append(ofproto_v1_3_parser.OFPActionOutput(OF_IN_PORT)) #return the actions list return actions
def getDistributionActions(self, switchID): ''' Get the distribution actions to the given switch and current number of flow entries. :param switchID: ID of current switch. :return: distribution flow entries to be installed ''' #initialize the actions set to be empty actions = [] #Distribution in 4 flow entries - because returning the packet required extra processing and distribution requires none, first distribute the original packet and then return #First- send the original packet to all the distribution switches #Then - add info about the current switch ID (inner tag) and change the direction to be return and tag direction #packet arrive with inner vlan id of prev switch and dummy switch- change return direction ,set #the outer vlan to be curr switch and return via same port #if there are port to distribute to, should add the distribution actions (send the packet to distribution as is) if (0 != len(self.switch_to_distribution_port[switchID])): #send to every switch in distribution port all the distribution ports for dist_port in self.switch_to_distribution_port[switchID]: actions.append(ofproto_v1_3_parser.OFPActionOutput(dist_port)) #Now add the info about the current switch by popping both vlan and adding current switch tag. actions.append( ofproto_v1_3_parser.OFPActionSetField( eth_src=ExtraLayers.ReturnAndTagMAC)) # set vlan ID to be current switch with solid flag. actions.append( ofproto_v1_3_parser.OFPActionSetField( vlan_vid=(retMaskedVlanID(switchID) | ExtraLayers.solidFlag))) # Send to ingress port. actions.append(ofproto_v1_3_parser.OFPActionOutput(OF_IN_PORT)) # if the there is no any RTP start in the current switch, exit if switchID not in self.rtp_switch_to_start_points: return actions # add the RTP for each RTP ID actions.append( ofproto_v1_3_parser.OFPActionSetField( vlan_vid=retMaskedVlanID(ExtraLayers.NULL_ID))) entryNum = 0 for entry in self.rtp_switch_to_start_points[switchID]: actions.append(ofproto_v1_3_parser.OFPActionPushVlan()) actions.append( ofproto_v1_3_parser.OFPActionSetField( eth_src=ExtraLayers.RTPMAC)) actions.append( ofproto_v1_3_parser.OFPActionSetField( vlan_vid=retMaskedVlanID(entry['id']))) actions.append( ofproto_v1_3_parser.OFPActionOutput(entry['outPort'])) #Do no pop the vlan header from the last packet send entryNum = entryNum + 1 if entryNum < len(self.rtp_switch_to_start_points[switchID]): actions.append(ofproto_v1_3_parser.OFPActionPopVlan()) #return the actions list return actions
def switch_features_handler(self, ev): msg = ev.msg datapath = msg.datapath print "thread start" z = Thread(target=self.ctr_check, args=(datapath, )) z.start() #print "thread block passed" #ARP packets flooding match = ofparser.OFPMatch(eth_type=0x0806) actions = [ofparser.OFPActionOutput(port=ofproto.OFPP_FLOOD)] self.add_flow1(datapath=datapath, table_id=0, priority=100, match=match, actions=actions) # reverse path flow for i in range(1, 4): ip = "10.0.0." + str(i) eth = "00:00:00:00:00:0" + str(i) match = ofparser.OFPMatch(in_port=i, eth_type=0x800, ip_proto=6, tcp_src=80, ipv4_src=ip, eth_src=eth, ipv4_dst='10.0.0.4') actions = [ ofparser.OFPActionSetField(ipv4_src="10.0.0.1"), ofparser.OFPActionSetField(eth_src="00:00:00:00:00:01"), ofparser.OFPActionSetField(tcp_src=80), ofparser.OFPActionOutput(port=4, max_len=0) ] self.add_flow1(datapath=datapath, table_id=0, priority=100, match=match, actions=actions) # reverse ARP path flow match_ = ofparser.OFPMatch(in_port=i, eth_type=ether_types.ETH_TYPE_ARP, ipv4_src=ip, eth_src=eth, eth_dst="00:00:00:00:00:04") actions_ = [ ofparser.OFPActionSetField(ipv4_src="10.0.0.1"), ofparser.OFPActionSetField(eth_src="00:00:00:00:00:01"), ofparser.OFPActionOutput(port=4, max_len=0) ] self.add_flow1(datapath=datapath, table_id=0, priority=100, match=match_, actions=actions_)
def switch_features_handler(self, ev): msg = ev.msg datapath = msg.datapath #ARP packets flooding match = ofparser.OFPMatch(eth_type=0x0806) actions = [ofparser.OFPActionOutput(port=ofproto.OFPP_FLOOD)] self.add_flow1(datapath=datapath, table_id=0, priority=100, match=match, actions=actions) # reverse path flow for i in range(1, 4): ip = "10.0.0." + str(i) eth = "00:00:00:00:00:0" + str(i) match = ofparser.OFPMatch(in_port=i, eth_type=0x800, ip_proto=6, ipv4_src=ip, eth_src=eth) actions = [ ofparser.OFPActionSetField(ipv4_src="10.0.0.1"), ofparser.OFPActionSetField(eth_src="00:00:00:00:00:01"), ofparser.OFPActionSetField(tcp_src=80), ofparser.OFPActionOutput(port=4, max_len=0) ] self.add_flow1(datapath=datapath, table_id=0, priority=100, match=match, actions=actions) # reverse ARP path flow for i in range(1, 4): ip = "10.0.0." + str(i) eth = "00:00:00:00:00:0" + str(i) match = ofparser.OFPMatch(in_port=i, eth_type=ether_types.ETH_TYPE_ARP, ipv4_src=ip, eth_src=eth) actions = [ ofparser.OFPActionSetField(ipv4_src="10.0.0.1"), ofparser.OFPActionSetField(eth_src="00:00:00:00:00:01"), ofparser.OFPActionOutput(port=4, max_len=0) ] self.add_flow1(datapath=datapath, table_id=0, priority=100, match=match, actions=actions)
def nat_actions(self, eth_type, nfvip, nat_offset): ip_ver = nfvip.ip.version ip_src_nxm = 'ipv%u_src_nxm' % ip_ver ip_dst_nxm = 'ipv%u_dst_nxm' % ip_ver ipbits = nfvip.ip.max_prefixlen # pylint: disable=no-member return [ parser.NXActionRegMove(src_field='ipv%u_src' % ip_ver, dst_field=self.AREG, n_bits=nat_offset, src_ofs=0, dst_ofs=nat_offset), parser.NXActionRegMove(src_field='ipv%u_dst' % ip_ver, dst_field=self.AREG, n_bits=nat_offset, src_ofs=0, dst_ofs=0), # we have to load output port numbers into reg1 and reg2 because NXFlowSpecOutput() won't take a literal. parser.NXActionRegLoad(value=self.FAKEPORT, dst=self.FAKEPORTREG, ofs_nbits=nicira_ext.ofs_nbits(0, 15)), parser.NXActionRegLoad(value=self.COPROPORT, dst=self.COPROPORTREG, ofs_nbits=nicira_ext.ofs_nbits(0, 15)), # now program an inbound flow to perform NAT. parser.NXActionLearn( table_id=self.FROM_COPRO_TABLE, priority=2, hard_timeout=self.IDLE, specs=[ parser.NXFlowSpecMatch(src=eth_type, dst=('eth_type_nxm', 0), n_bits=16), parser.NXFlowSpecMatch(src=(ip_src_nxm, 0), dst=(ip_src_nxm, 0), n_bits=ipbits), parser.NXFlowSpecMatch(src=(ip_dst_nxm, 0), dst=(ip_dst_nxm, 0), n_bits=ipbits), parser.NXFlowSpecLoad(src=int(self.FAKECLIENTMAC), dst=('eth_src_nxm', 0), n_bits=48), parser.NXFlowSpecLoad(src=int(self.FAKESERVERMAC), dst=('eth_dst_nxm', 0), n_bits=48), ] + self.reg_copy(self.AREG, ip_src_nxm, ipbits) + [ parser.NXFlowSpecLoad(src=int(nfvip.ip), dst=(ip_dst_nxm, 0), n_bits=ipbits), parser.NXFlowSpecOutput(src=(self.FAKEPORTREG, 0), dst='', n_bits=16), ]), # now program outbound an outbound flow. parser.NXActionLearn( table_id=self.TO_COPRO_TABLE, priority=2, idle_timeout=self.IDLE, specs=[ parser.NXFlowSpecMatch(src=eth_type, dst=('eth_type_nxm', 0), n_bits=16), parser.NXFlowSpecMatch(src=int(nfvip.ip), dst=(ip_src_nxm, 0), n_bits=ipbits), ] + self.reg_copy(self.AREG, ip_dst_nxm, ipbits) + [ parser.NXFlowSpecLoad(src=('eth_dst_nxm', 0), dst=('eth_src_nxm', 0), n_bits=48), parser.NXFlowSpecLoad(src=('eth_src_nxm', 0), dst=('eth_dst_nxm', 0), n_bits=48), parser.NXFlowSpecLoad(src=(ip_dst_nxm, 0), dst=(ip_src_nxm, 0), n_bits=ipbits), parser.NXFlowSpecLoad(src=(ip_src_nxm, 0), dst=(ip_dst_nxm, 0), n_bits=ipbits), parser.NXFlowSpecOutput(src=(self.COPROPORTREG, 0), dst='', n_bits=16), ]), # now that future flows are programmed, handle the packet we have. parser.OFPActionSetField(eth_src=self.FAKECLIENTMAC), parser.OFPActionSetField(eth_dst=self.FAKESERVERMAC), parser.NXActionRegMove(src_field=self.AREG, dst_field=('ipv%u_src' % ip_ver), n_bits=ipbits, src_ofs=0, dst_ofs=0), parser.OFPActionSetField(**{'ipv%u_dst' % ip_ver: str(nfvip.ip)}), parser.OFPActionOutput(self.FAKEPORT) ]
def packet_in_handler(self, ev): global inc msg = ev.msg datapath = msg.datapath ofproto = datapath.ofproto pkt = packet.Packet(msg.data) eth = pkt.get_protocol(ethernet.ethernet) _ipv4 = pkt.get_protocol(ipv4.ipv4) _icmp = pkt.get_protocol(icmp.icmp) if _icmp: self.logger.info("%r", _icmp) if _ipv4: self.logger.info("%r", _ipv4) if eth: self.logger.info("%r", eth) dpid = msg.match['in_port'] #self.mac_to_port.setdefault(dpid,{}) #self.logger.info(pkt) if dpid == 4: match = datapath.ofproto_parser.OFPMatch( in_port=dpid, eth_type=0x800, ip_proto=6, tcp_dst=80, ipv4_dst='10.0.0.1', eth_dst='00:00:00:00:00:01') inc = self.inc ip = "10.0.0." + str(inc) eth = "00:00:00:00:00:0" + str(inc) actions = [ ofparser.OFPActionSetField(ipv4_dst=ip), ofparser.OFPActionSetField(eth_dst=eth), ofparser.OFPActionSetField(tcp_dst=80), ofparser.OFPActionOutput(port=inc) ] self.add_flow(datapath=datapath, table_id=0, priority=100, match=match, actions=actions) print "redirected to port ", inc self.inc = (inc % 3) + 1
def common_reply_actions(self): # pylint: disable=no-member return [ parser.NXActionRegMove(src_field='eth_src', dst_field='eth_dst', n_bits=48, src_ofs=0, dst_ofs=0), parser.OFPActionSetField(eth_src=self.FAKECLIENTMAC), parser.OFPActionOutput(ofp.OFPP_IN_PORT) ]
def arp_reply_actions(self): # pylint: disable=no-member common_reply = self.common_reply_actions() return self.apply_actions([ parser.NXActionRegLoad(value=arp.ARP_REPLY, dst='arp_op', ofs_nbits=nicira_ext.ofs_nbits(0, 2)), parser.NXActionRegMove(src_field='arp_sha', dst_field='arp_tha', n_bits=48, src_ofs=0, dst_ofs=0), parser.NXActionRegMove(src_field='arp_tpa', dst_field=self.AREG, n_bits=32, src_ofs=0, dst_ofs=0), parser.NXActionRegMove(src_field='arp_spa', dst_field='arp_tpa', n_bits=32, src_ofs=0, dst_ofs=0), parser.NXActionRegMove(src_field=self.AREG, dst_field='arp_spa', n_bits=32, src_ofs=0, dst_ofs=0), parser.OFPActionSetField(arp_sha=FAKECLIENTMAC), ] + common_reply)
def _get_ue_ul_of_rule(self, ue, path, anchor): """ Write the OpenFlow rules along the computed routing path """ ofrs = {} try: # Forwarding based on destination MAC unicast addr in_port = [ self.switches[path[0].link.src.dpid].ap_conf.port.port_no ] for p in path: for inp in in_port: out_port = p.link.src.port_no if inp == out_port: out_port = ofproto.OFPP_IN_PORT match = ofp_parser.OFPMatch( in_port=inp, eth_type=ether.ETH_TYPE_IPV6, ipv6_src=(':'.join(anchor.nw_prefix), ipv6_utils.ipv6_mask_from_cidr( anchor.nw_prefix_len))) actions = [ ofp_parser.OFPActionSetField( eth_src=self.switches[p.link.src.dpid].hw_addr), ofp_parser.OFPActionSetField( eth_dst=self.switches[p.link.dst.dpid].hw_addr), ofp_parser.OFPActionOutput(out_port) ] instructions = [ ofp_parser.OFPInstructionActions( ofproto.OFPIT_APPLY_ACTIONS, actions) ] ofr = OFRule(self.switches[p.link.src.dpid], match, actions, instructions, table_id=OF_TABLE_UES) ofrs[ofr.key] = ofr in_port = [p.link.dst.port_no] except IndexError: self.logger.debug("Index error in _get_ue_ul_of_rule") return ofrs
def _get_neigh_of_rule(self, node): """ Write the OpenFlow rule for forwarding the packet to the node (ipv6, hw_addr) lookup and eth_dst address translation """ ofrs = {} match = ofp_parser.OFPMatch(eth_type = ether.ETH_TYPE_IPV6, ipv6_dst = node.ipv6_addr) actions = [ofp_parser.OFPActionSetField(eth_src = node.attachment.switch.hw_addr), ofp_parser.OFPActionSetField(eth_dst = node.hw_addr), ofp_parser.OFPActionOutput(node.attachment.port.port_no)] instructions = [ofp_parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)] ofr = OFRule(node.attachment.switch, match, actions, instructions, table_id = OF_TABLE_NEIGH) ofrs[ofr.key] = ofr return ofrs
def set_vlan_vid(vlan_vid): """Set VLAN VID with VID_PRESENT flag set. Args: vid (int): VLAN VID Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionSetField: set VID with VID_PRESENT. """ return parser.OFPActionSetField(vlan_vid=vid_present(vlan_vid))
def set_eth_src(eth_src): """Return action to set source Ethernet MAC address. Args: eth_src (str): source Ethernet MAC address. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionSetField: set field action. """ return parser.OFPActionSetField(eth_src=eth_src)
def set_eth_dst(eth_dst): """Return action to set destination Ethernet MAC address. Args: eth_src (str): destination Ethernet MAC address. Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionSetField: set field action. """ return parser.OFPActionSetField(eth_dst=eth_dst)
def set_field(**kwds): """Return action to set any field. Args: kwds (dict): exactly one field to set Returns: ryu.ofproto.ofproto_v1_3_parser.OFPActionSetField: set field action. """ return parser.OFPActionSetField(**kwds)
def actions_to_ryu(actions, rule): """ Converts a list of actions to a list of ryu actions This returns both a instruction list and any extra messages that are required to install the instructions such as group mod messages. Currently this is not smart about reusing groups. actions: A iterable list actions such as ActionSet, ActionList, or Bucket. rule: The rule being converted return: A tuple ([actions], [extra messages]) """ ret = [] extra_messages = [] for action in actions: if action[0] == 'OUTPUT': ret.append(parser.OFPActionOutput(action[1])) elif action[0] == 'COPY_TTL_OUT': ret.append(parser.OFPActionCopyTtlOut()) elif action[0] == 'COPY_TTL_IN': ret.append(parser.OFPActionCopyTtlIn()) elif action[0] == 'SET_MPLS_TTL': ret.append(parser.OFPActionSetMplsTtl(action[1])) elif action[0] == 'DEC_MPLS_TTL': ret.append(parser.OFPActionDecMplsTtl()) elif action[0] == 'PUSH_VLAN': ret.append(parser.OFPActionPushVlan(action[1])) elif action[0] == 'POP_VLAN': ret.append(parser.OFPActionPopVlan()) elif action[0] == 'PUSH_MPLS': ret.append(parser.OFPActionPushMpls(action[1])) elif action[0] == 'POP_MPLS': ret.append(parser.OFPActionPopMpls(action[1])) elif action[0] == 'SET_QUEUE': ret.append(parser.OFPActionSetQueue(action[1])) elif action[0] == 'GROUP': if isinstance(action[1], Group): group_id, extra = group_to_ryu(action[1], rule) ret.append(parser.OFPActionGroup(group_id)) extra_messages += extra else: ret.append(parser.OFPActionGroup(action[1])) elif action[0] == 'SET_NW_TTL': ret.append(parser.OFPActionSetNwTtl(action[1])) elif action[0] == 'DEC_NW_TTL': ret.append(parser.OFPActionDecNwTtl()) elif action[0] == 'SET_FIELD': set_field = {action[1][0].lower(): action[1][1]} ret.append(parser.OFPActionSetField(**set_field)) elif action[0] == 'PUSH_PBB': ret.append(parser.OFPActionPushPbb(action[1])) elif action[0] == 'POP_PBB': ret.append(parser.OFPActionPopPbb()) else: assert not "GGRR" return (ret, extra_messages)
def getReturnAndTagActions(self, switchID, numberOfFlowEntries): ''' Get the return and tag actions (only return actions in 3 flow entries case or the first return action for 4 flow entries case) :param switchID: ID of current switch :param numberOfFlowEntries: 3 or 4 flow entries mode :return: return and tag flow entries to be installed ''' #initialize the actions set to be empty actions = [] #3 flow entries case if (3 == numberOfFlowEntries): #transfer to "parent" port as is (the packet already contains the switch ID's tagging) actions.append( ofproto_v1_3_parser.OFPActionOutput( (self.switch_to_parent_port[switchID]))) #4 flow entries case else: #In 4 flow entries, the packet contains only tagging on last switch ID (inner tagging) need to add #the first switch ID (outer tagging) and change the ethertype to be dirReturnNoTag. # Pop vlan actions.append(ofproto_v1_3_parser.OFPActionPopVlan()) #set the DirectionReturn field to be dirReturnNoTag actions.append( ofproto_v1_3_parser.OFPActionSetField( eth_type=ExtraLayers.dirReturnNoTag)) # push a new VLAN with ethertype of vlan actions.append( ofproto_v1_3_parser.OFPActionPushVlan( ethertype=ExtraLayers.VLAN_ID_ETHERTYPE_QINQ)) # set vlan ID to be current switch (last switch field) actions.append( ofproto_v1_3_parser.OFPActionSetField( vlan_vid=retMaskedVlanID(switchID))) #transfer to "parent" port actions.append( ofproto_v1_3_parser.OFPActionOutput( (self.switch_to_parent_port[switchID]))) #return the actions list return actions
def push_vlan_act(vlan_vid): """Return OpenFlow action list to push Ethernet 802.1Q header with VLAN VID. Args: vid (int): VLAN VID Returns: list: actions to push 802.1Q header with VLAN VID set. """ return [ parser.OFPActionPushVlan(ether.ETH_TYPE_8021Q), parser.OFPActionSetField(vlan_vid=vid_present(vlan_vid)) ]
def port_add_vlan_untagged(self, port, vlan, forwarding_table, mirror_act): ofmsgs = [] ofmsgs.extend(self.add_controller_ips(vlan.controller_ips, vlan)) push_vlan_act = mirror_act + [ parser.OFPActionPushVlan(ether.ETH_TYPE_8021Q), parser.OFPActionSetField(vlan_vid=vlan.vid|ofp.OFPVID_PRESENT)] push_vlan_inst = [ self.apply_actions(push_vlan_act), self.goto_table(forwarding_table) ] null_vlan = namedtuple('null_vlan', 'vid') null_vlan.vid = ofp.OFPVID_NONE ofmsgs.append(self.valve_flowmod( self.dp.vlan_table, self.valve_in_match(in_port=port.number, vlan=null_vlan), priority=self.dp.low_priority, inst=push_vlan_inst)) ofmsgs.extend(self.build_flood_rules(vlan)) return ofmsgs
def getRTPReturnActions(self, switchID, inPort): ''' Get the return rtp packet to the given switch. :param switchID: ID of current switch. :param switchID: in port of switch. :return: distribution flow entries to be installed ''' # set as reutrn packet actions = [] actions.append( ofproto_v1_3_parser.OFPActionSetField( eth_src=ExtraLayers.ReturnNoTagMAC)) #return the packet in the in port returnOutPort = self.switch_to_parent_port[switchID] if returnOutPort == inPort: returnOutPort = OF_IN_PORT actions.append(ofproto_v1_3_parser.OFPActionOutput(returnOutPort)) return actions
def install_probing(self, datapath): '''Redirect node rules''' if datapath.id == 2: '''Packet duplication group entry''' buckets = [] actions = [ ofparser.OFPActionSetField(mpls_label=17), ofparser.OFPActionOutput(port=3) ] buckets.append(ofparser.OFPBucket(actions=actions)) actions = [ ofparser.OFPActionSetField(mpls_label=100), ofparser.OFPActionOutput(port=1) ] buckets.append(ofparser.OFPBucket(actions=actions)) req = ofparser.OFPGroupMod(datapath=datapath, type_=ofproto.OFPGT_ALL, group_id=0, buckets=buckets) datapath.send_msg(req) '''Probing rule: packet duplicated in both primary and detour path''' match = ofparser.OFPMatch(in_port=2, state=100, eth_dst="00:00:00:00:00:06", eth_src="00:00:00:00:00:01", eth_type=0x8847) actions = [ osparser.OFPExpActionSetState(state=17, table_id=0, hard_timeout=10, hard_rollback=100), ofparser.OFPActionGroup(0) ] self.add_flow(datapath=datapath, table_id=0, priority=10, match=match, actions=actions) '''Match on probe packet: switch back to the primary path''' match = ofparser.OFPMatch(in_port=1, mpls_label=100, eth_dst="00:00:00:00:00:06", eth_src="00:00:00:00:00:01", eth_type=0x8847) actions = [osparser.OFPExpActionSetState(state=0, table_id=0)] self.add_flow(datapath=datapath, table_id=0, priority=10, match=match, actions=actions) '''Failure: switch on the detour path and set probing timeout''' match = ofparser.OFPMatch(in_port=1, mpls_label=17, eth_dst="00:00:00:00:00:06", eth_src="00:00:00:00:00:01", eth_type=0x8847) actions = [ osparser.OFPExpActionSetState(state=17, table_id=0, hard_timeout=10, hard_rollback=100), ofparser.OFPActionOutput(port=3) ] self.add_flow(datapath=datapath, table_id=0, priority=10, match=match, actions=actions, command=ofproto.OFPFC_MODIFY) '''Detect node rules''' if datapath.id == 3: '''Probe handler group entry''' buckets = [] actions = [ofparser.OFPActionOutput(port=2)] buckets.append(ofparser.OFPBucket(watch_port=2, actions=actions)) actions = [] buckets.append(ofparser.OFPBucket(watch_port=1, actions=actions)) req = ofparser.OFPGroupMod(datapath=datapath, type_=ofproto.OFPGT_FF, group_id=0, buckets=buckets) datapath.send_msg(req) '''Probe handler: if the link is up, the probe packet will be forwarded toward the next node, otherwise drop''' match = ofparser.OFPMatch(in_port=1, state=0, mpls_label=100, eth_dst="00:00:00:00:00:06", eth_src="00:00:00:00:00:01", eth_type=0x8847) actions = [ofparser.OFPActionGroup(group_id=0)] self.add_flow(datapath=datapath, table_id=0, priority=100, match=match, actions=actions) '''It sends back a probe packet coming from the no more "unreachable node"''' match = ofparser.OFPMatch(in_port=2, state=0, mpls_label=100, eth_dst="00:00:00:00:00:06", eth_src="00:00:00:00:00:01", eth_type=0x8847) actions = [ofparser.OFPActionOutput(1)] self.add_flow(datapath=datapath, table_id=0, priority=10, match=match, actions=actions) '''Unreachable node''' if datapath.id == 4: '''probe handler: it sends back a probe message coming from the previous node''' match = ofparser.OFPMatch(in_port=1, state=0, mpls_label=100, eth_dst="00:00:00:00:00:06", eth_src="00:00:00:00:00:01", eth_type=0x8847) actions = [ofparser.OFPActionOutput(ofproto.OFPP_IN_PORT)] self.add_flow(datapath=datapath, table_id=0, priority=100, match=match, actions=actions)
def function_dynamic_nat(self, datapath): """ Set table 1 as stateful """ req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=1, stateful=1) datapath.send_msg(req) """ Set table 2 restore """ req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=2, stateful=1) datapath.send_msg(req) ############################### LOOKUP/UPDATE ################################### """ Tab1 """ """ Set lookup extractor = {OXM_OF_METADATA} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ofproto.OXM_OF_METADATA], table_id=1) datapath.send_msg(req) """ Set update extractor = {OXM_OF_METADATA} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ofproto.OXM_OF_METADATA], table_id=1) datapath.send_msg(req) """ Tab2 """ """ Set lookup extractor = {OXM_OF_IPV4_SRC, OXM_OF_IP_PROTO, OXM_OF_TCP_SRC} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ ofproto.OXM_OF_IPV4_SRC, ofproto.OXM_OF_IP_PROTO, ofproto.OXM_OF_TCP_SRC ], table_id=2) datapath.send_msg(req) """ Set lookup extractor = {OXM_OF_IPV4_DST, OXM_OF_IP_PROTO, OXM_OF_TCP_DST} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ ofproto.OXM_OF_IPV4_DST, ofproto.OXM_OF_IP_PROTO, ofproto.OXM_OF_TCP_DST ], table_id=2) datapath.send_msg(req) """ Tab3 """ ########################### SET STATE TABLE 1 ############################################ for stateVal in range(1, 21): state = bebaparser.OFPExpMsgSetFlowState( datapath=datapath, state=2000 + stateVal, keys=[stateVal, 0, 0, 0, 0, 0, 0, 0], table_id=1) datapath.send_msg(state) ########################### SET HF DATA VARIABLE TAB 1 ############################################ ''' GD[0] = state_label''' req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=1, global_data_variable_id=0, value=0) datapath.send_msg(req) ''' HF[0] = OXM_EXP_STATE [state_label] ''' req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=1, extractor_id=0, field=bebaproto.OXM_EXP_STATE) datapath.send_msg(req) ########################### SET HF DATA VARIABLE TAB 2 ############################################ ''' HF[0] = OXM_OF_IPV4_SRC [id_pkt] ''' req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=2, extractor_id=0, field=ofproto.OXM_OF_IPV4_SRC) datapath.send_msg(req) ''' HF[1] = OXM_OF_TCP_SRC [id_pkt] ''' req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=2, extractor_id=1, field=ofproto.OXM_OF_TCP_SRC) datapath.send_msg(req) ########################### SET HF DATA VARIABLE TAB 3 ############################################ ''' HF[0] = OXM_OF_METADATA [metadata] ''' req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=3, extractor_id=0, field=ofproto.OXM_OF_METADATA) datapath.send_msg(req) ################################# REGOLE ############################################ ''' ####################### TAB 0 ''' match = ofparser.OFPMatch(state=0, in_port=LAN_PORT) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=0), bebaparser.OFPExpActionSetDataVariable(table_id=0, opcode=bebaproto.OPCODE_SUM, output_gd_id=1, operand_1_gd_id=1, operand_2_cost=1), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_GLOBAL_DATA_VAR, src_id=1, dst_field=ofproto.OXM_OF_METADATA) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(1) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=89, match=match, instructions=inst) datapath.send_msg(mod) # Line 12 match = ofparser.OFPMatch(state=1, in_port=LAN_PORT) actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(3) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=88, match=match, instructions=inst) datapath.send_msg(mod) # Line 13 match = ofparser.OFPMatch(state=0, in_port=INTERNET_PORT, eth_type=0x0800, ipv4_dst='1.0.0.1') actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(2) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=87, match=match, instructions=inst) datapath.send_msg(mod) ''' ####################### TAB 1 ''' # Line 0 # HF[0] = state_label # GD[0] = state_label + 0 => GD[0] + HF[0] # state_label -> metadata => GD[0] = HF[0] match = ofparser.OFPMatch(in_port=3) actions = [ bebaparser.OFPExpActionSetDataVariable(table_id=1, opcode=bebaproto.OPCODE_SUM, output_gd_id=0, operand_1_hf_id=0, operand_2_cost=0), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_GLOBAL_DATA_VAR, src_id=0, dst_field=ofproto.OXM_OF_METADATA) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(2) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=1, priority=100, match=match, instructions=inst) datapath.send_msg(mod) ''' ####################### TAB 2 restore''' # Line 0 # ip.src -> R0 => HF[0] -> FD[0] => FD[0] = HF[0] + 0 # tcp.src -> R1 => HF[1] -> FD[1] => FD[1] = HF[1] + 0 match = ofparser.OFPMatch(state=0, in_port=LAN_PORT) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=2), bebaparser.OFPExpActionSetDataVariable(table_id=2, opcode=bebaproto.OPCODE_SUM, output_fd_id=0, operand_1_hf_id=0, operand_2_cost=0), bebaparser.OFPExpActionSetDataVariable(table_id=2, opcode=bebaproto.OPCODE_SUM, output_fd_id=1, operand_1_hf_id=1, operand_2_cost=0) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(3) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=2, priority=100, match=match, instructions=inst) datapath.send_msg(mod) # Line 1 # ip.dst = R0 => IPV4_DST = FD[0] # tcp.dst = R1 => TCP_DST = FD[1] match = ofparser.OFPMatch(state=1, in_port=INTERNET_PORT) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=2), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_FLOW_DATA_VAR, src_id=0, dst_field=ofproto.OXM_OF_IPV4_DST), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_FLOW_DATA_VAR, src_id=1, dst_field=ofproto.OXM_OF_TCP_DST) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=2, priority=99, match=match, instructions=inst) datapath.send_msg(mod) ''' ####################### TAB 3 translate ''' # Line 3 # metadata(b16,b31) -> R1 => metadata(b16,b31) -> FD[1] => FD[1] = HF[0] # ip.src = 10.0.0.1 # tcp.src = R1 => TCP_SRC = FD[1] match = ofparser.OFPMatch(state=0, in_port=LAN_PORT, eth_type=0x0800) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=3), bebaparser.OFPExpActionSetDataVariable(table_id=3, opcode=bebaproto.OPCODE_SUM, output_fd_id=1, operand_1_hf_id=0, operand_2_cost=0), ofparser.OFPActionSetField(ipv4_src="1.0.0.1"), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_FLOW_DATA_VAR, src_id=1, dst_field=ofproto.OXM_OF_TCP_SRC) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=3, priority=97, match=match, instructions=inst) datapath.send_msg(mod) # Line 4 # ip.src = 10.0.0.1 # tcp.src = R1 => TCP_SRC = FD[1] match = ofparser.OFPMatch(state=1, in_port=LAN_PORT, eth_type=0x0800) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=3), ofparser.OFPActionSetField(ipv4_src='1.0.0.1'), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_FLOW_DATA_VAR, src_id=1, dst_field=ofproto.OXM_OF_TCP_SRC) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=3, priority=96, match=match, instructions=inst) datapath.send_msg(mod)
def function_load_balancer(self, datapath): """ Tab0 """ """ Set lookup extractor = {BiFlow} """ # GIA CONFIGURATA """ Set table 3 translate """ req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=3, stateful=1) datapath.send_msg(req) ############################### LOOKUP/UPDATE ################################### """ Tab3 """ """ Set lookup extractor = {OXM_OF_IPV4_SRC, OXM_OF_TCP_SRC} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ofproto.OXM_OF_IPV4_SRC, ofproto.OXM_OF_TCP_SRC], table_id=3) datapath.send_msg(req) """ Set update extractor = {OXM_OF_IPV4_SRC, OXM_OF_TCP_SRC} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ofproto.OXM_OF_IPV4_SRC, ofproto.OXM_OF_TCP_SRC], table_id=3) datapath.send_msg(req) ########################### SET GD E HF DATA VARIABLE TAB 3 ############################################ ''' GD[0] = 0''' req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=3, global_data_variable_id=0, value=0) datapath.send_msg(req) ''' GD[1] = LAN_DUE 10.0.0.2 hexadecimal''' req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=3, global_data_variable_id=1, value=0x0200000a) datapath.send_msg(req) ''' GD[2] = LAN_TRE 10.0.0.3 hexadecimal''' req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=3, global_data_variable_id=2, value=0x0300000a) datapath.send_msg(req) ''' GD[3] = PORT 80 ''' req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=3, global_data_variable_id=3, value=0x5000) datapath.send_msg(req) ################################# RULES ############################################ ''' ####################### TAB 0 ''' # Line 7 match = ofparser.OFPMatch(state=0, in_port=INTERNET_PORT, eth_type=0x0800, ipv4_dst='1.0.0.1', ip_proto=6, tcp_dst=80) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=0), bebaparser.OFPExpActionSetDataVariable(table_id=0, opcode=bebaproto.OPCODE_SUM, output_gd_id=0, operand_1_gd_id=0, operand_2_cost=1), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_GLOBAL_DATA_VAR, src_id=0, dst_field=ofproto.OXM_OF_METADATA) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(3) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=93, match=match, instructions=inst) datapath.send_msg(mod) # Line 8 match = ofparser.OFPMatch(state=1, in_port=INTERNET_PORT, eth_type=0x0800, ipv4_dst='1.0.0.1', ip_proto=6, tcp_dst=80) actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(3) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=92, match=match, instructions=inst) datapath.send_msg(mod) # Line 9 match = ofparser.OFPMatch(state=0, in_port=LAN_PORT, eth_type=0x0800, ipv4_src='10.0.0.2', ip_proto=6, tcp_src=80) actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=91, match=match, instructions=inst) datapath.send_msg(mod) # Line 10 match = ofparser.OFPMatch(state=0, in_port=LAN_PORT, eth_type=0x0800, ipv4_src='10.0.0.3', ip_proto=6, tcp_src=80) actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=90, match=match, instructions=inst) datapath.send_msg(mod) ''' ####################### TAB 3 translate ''' # Line 0 # ip.dst = 10.0.0.2 # tcp.dst = 80 # 10.0.0.2 -> R0 => 10.0.0.2 -> FD[0] => FD[0] = GD[0] + 10.0.0.2 => 0 + 10.0.0.2 # 80 -> R1 => 80 -> FD[1] => GD[0] + 80 => 0 + 80 match = ofparser.OFPMatch(state=0, in_port=INTERNET_PORT, metadata=(0, 0x000000001), eth_type=0x0800, ip_proto=6) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=3), ofparser.OFPActionSetField(ipv4_dst='10.0.0.2'), ofparser.OFPActionSetField(tcp_dst=80), # tolto per test bebaparser.OFPExpActionSetDataVariable(table_id=3, opcode=bebaproto.OPCODE_SUM, output_fd_id=0, operand_1_gd_id=1, operand_2_cost=0), bebaparser.OFPExpActionSetDataVariable(table_id=3, opcode=bebaproto.OPCODE_SUM, output_fd_id=1, operand_1_gd_id=0, operand_2_cost=80) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=3, priority=100, match=match, instructions=inst) datapath.send_msg(mod) # Line 1 # ip.dst = 10.0.0.3 # tcp.dst = 80 # 10.0.0.3 -> R0 => 10.0.0.3 -> FD[0] => FD[0] = GD[0] + 10.0.0.3 => 0 + 10.0.0.3 # 80 -> R1 => 80 -> FD[1] => GD[0] + 80 => 0 + 80 match = ofparser.OFPMatch(state=0, in_port=INTERNET_PORT, metadata=(1, 0x000000001), eth_type=0x0800, ip_proto=6) actions = [ bebaparser.OFPExpActionSetState(state=1, table_id=3), ofparser.OFPActionSetField(ipv4_dst='10.0.0.3'), ofparser.OFPActionSetField(tcp_dst=80), # tolto per test bebaparser.OFPExpActionSetDataVariable(table_id=3, opcode=bebaproto.OPCODE_SUM, output_fd_id=0, operand_1_gd_id=2, operand_2_cost=0), bebaparser.OFPExpActionSetDataVariable(table_id=3, opcode=bebaproto.OPCODE_SUM, output_fd_id=1, operand_1_gd_id=0, operand_2_cost=80) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=3, priority=99, match=match, instructions=inst) datapath.send_msg(mod) # Line 2 # ip.dst = R0 => IPV4_DST = FD[0] # tcp.dst = R1 => TCP_DST = FD[1] match = ofparser.OFPMatch(state=1, in_port=INTERNET_PORT) actions = [ bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_FLOW_DATA_VAR, src_id=0, dst_field=ofproto.OXM_OF_IPV4_DST), bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_FLOW_DATA_VAR, src_id=1, dst_field=ofproto.OXM_OF_TCP_DST) ] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=3, priority=98, match=match, instructions=inst) datapath.send_msg(mod) ''' ####################### TAB 4 forward ''' # Line 4 match = ofparser.OFPMatch(in_port=LAN_PORT, eth_type=0x0800, ipv4_src='10.0.0.2', ip_proto=6, tcp_src=80) actions = [ ofparser.OFPActionSetField(ipv4_src='1.0.0.1'), ofparser.OFPActionSetField(tcp_src=80), ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:01"), ofparser.OFPActionOutput(INTERNET_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=96, match=match, actions=actions) # Line 5 match = ofparser.OFPMatch(in_port=LAN_PORT, eth_type=0x0800, ipv4_src='10.0.0.3', ip_proto=6, tcp_src=80) actions = [ ofparser.OFPActionSetField(ipv4_src='1.0.0.1'), ofparser.OFPActionSetField(tcp_src=80), ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:01"), ofparser.OFPActionOutput(INTERNET_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=95, match=match, actions=actions) # Line 6 match = ofparser.OFPMatch() actions = [ ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:01"), ofparser.OFPActionOutput(INTERNET_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=94, match=match, actions=actions)
def function_lan_dmz_isolation(self, datapath): """ Set table 0 as stateful """ req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=0, stateful=1) datapath.send_msg(req) ############################### LOOKUP/UPDATE ################################### """ Tab0 """ """ Set lookup extractor = {BiFlow} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ ofproto.OXM_OF_IPV4_SRC, ofproto.OXM_OF_IPV4_DST, ofproto.OXM_OF_TCP_SRC, ofproto.OXM_OF_TCP_DST ], table_id=0, biflow=1) datapath.send_msg(req) """ Set lookup extractor = {BiFlow} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ ofproto.OXM_OF_IPV4_SRC, ofproto.OXM_OF_IPV4_DST, ofproto.OXM_OF_TCP_SRC, ofproto.OXM_OF_TCP_DST ], table_id=0, biflow=1) datapath.send_msg(req) """ Tab4 """ """ Stateless """ ########################### SET GD DATA VARIABLE TAB 0 ############################################ ''' GD[0] = 0''' req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=0, global_data_variable_id=0, value=0) datapath.send_msg(req) ''' GD[1] = 0 ''' req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=0, global_data_variable_id=0, value=0) datapath.send_msg(req) ################################# REGOLE ############################################ match = ofparser.OFPMatch(eth_type=0x0806) actions = [ofparser.OFPActionOutput(ofproto.OFPP_FLOOD)] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=100, match=match, instructions=inst) datapath.send_msg(mod) ''' ####################### TAB 0 ''' # Line 0 match = ofparser.OFPMatch(state=0, in_port=DMZ_PORT, eth_type=0x0800, ipv4_dst=('10.0.0.0', '255.255.255.0')) actions = [bebaparser.OFPExpActionSetState(state=11, table_id=0)] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionWriteMetadata(metadata=0, metadata_mask=0xFFFFFFFF), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=100, match=match, instructions=inst) datapath.send_msg(mod) # Line 1 match = ofparser.OFPMatch(state=0, in_port=LAN_PORT, eth_type=0x0800, ipv4_dst=('8.0.0.0', '255.255.255.0')) actions = [bebaparser.OFPExpActionSetState(state=12, table_id=0)] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionWriteMetadata(metadata=0, metadata_mask=0xFFFFFFFF), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=99, match=match, instructions=inst) datapath.send_msg(mod) # Line 2 match = ofparser.OFPMatch(state=11, in_port=DMZ_PORT, eth_type=0x0800, ipv4_dst=('10.0.0.0', '255.255.255.0')) actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionWriteMetadata(metadata=0, metadata_mask=0xFFFFFFFF), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=98, match=match, instructions=inst) datapath.send_msg(mod) # Line 3 match = ofparser.OFPMatch(state=11, in_port=LAN_PORT, eth_type=0x0800, ipv4_dst=('8.0.0.0', '255.255.255.0')) actions = [bebaparser.OFPExpActionSetState(state=2, table_id=0)] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionWriteMetadata(metadata=1, metadata_mask=0xFFFFFFFF), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=97, match=match, instructions=inst) datapath.send_msg(mod) # Line 4 match = ofparser.OFPMatch(state=12, in_port=LAN_PORT, eth_type=0x0800, ipv4_dst=('8.0.0.0', '255.255.255.0')) actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionWriteMetadata(metadata=0, metadata_mask=0xFFFFFFFF), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=96, match=match, instructions=inst) datapath.send_msg(mod) # Line 5 match = ofparser.OFPMatch(state=12, in_port=DMZ_PORT, eth_type=0x0800, ipv4_dst=('10.0.0.0', '255.255.255.0')) actions = [bebaparser.OFPExpActionSetState(state=2, table_id=0)] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionWriteMetadata(metadata=1, metadata_mask=0xFFFFFFFF), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=95, match=match, instructions=inst) datapath.send_msg(mod) # Line 6 match = ofparser.OFPMatch(state=2) actions = [] inst = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), ofparser.OFPInstructionWriteMetadata(metadata=1, metadata_mask=0xFFFFFFFF), ofparser.OFPInstructionGotoTable(4) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=94, match=match, instructions=inst) datapath.send_msg(mod) ''' ####################### TAB 1 ''' # NOT USED IN THIS USE CASE ''' ####################### TAB 2 restore''' # NOT USED IN THIS USE CASE ''' ####################### TAB 3 translate ''' # NOT USED IN THIS USE CASE ''' ####################### TAB 4 forward ''' # Line 0 match = ofparser.OFPMatch(in_port=DMZ_PORT, metadata=(0, 0x00000000F), eth_type=0x0800, ipv4_dst=('10.0.0.0', '255.255.255.0')) actions = [] self.add_flow(datapath=datapath, table_id=4, priority=100, match=match, actions=actions) # Line 1 match = ofparser.OFPMatch(in_port=DMZ_PORT, metadata=(1, 0x00000000F), eth_type=0x0800, ipv4_dst='10.0.0.2') actions = [ ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:03"), ofparser.OFPActionOutput(LAN_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=99, match=match, actions=actions) # Line 1 BIS match = ofparser.OFPMatch(in_port=DMZ_PORT, metadata=(1, 0x00000000F), eth_type=0x0800, ipv4_dst='10.0.0.3') actions = [ ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:04"), ofparser.OFPActionOutput(LAN_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=99, match=match, actions=actions) # Line 2 match = ofparser.OFPMatch(eth_type=0x0800, ipv4_dst='8.0.0.2') actions = [ ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:02"), ofparser.OFPActionOutput(DMZ_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=98, match=match, actions=actions) # Line 3 match = ofparser.OFPMatch(eth_type=0x0800, ipv4_dst='10.0.0.2') actions = [ ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:03"), ofparser.OFPActionOutput(LAN_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=97, match=match, actions=actions) # Line 3 BIS match = ofparser.OFPMatch(eth_type=0x0800, ipv4_dst='10.0.0.3') actions = [ ofparser.OFPActionSetField(eth_dst="00:00:00:00:00:04"), ofparser.OFPActionOutput(LAN_PORT) ] self.add_flow(datapath=datapath, table_id=4, priority=97, match=match, actions=actions)
def set_vlan(self, vlan_id): self.actions_fields.append(ofp.OFPActionPushVlan()) self.actions_fields.append(ofp.OFPActionSetField(vlan_vid=(0x1000 | vlan_id))) return self
def set_mac_rewrite(self, eth_src): self.actions_fields.append(ofp.OFPActionSetField(eth_src=eth_src)) return self
def install_leaves(self, datapath): # Send probe packet to packet generation table req = bebaparser.OFPExpMsgAddPktTmp(datapath=datapath, pkttmp_id=0, pkt_data=pkt_raw) datapath.send_msg(req) ##################################### TABLE 0: DISPATCHING ################################################## ######################### TABLE 0 CONFIG ############### req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=0, stateful=1) datapath.send_msg(req) """ Set lookup extractor = {eth_dst} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ofproto.OXM_OF_IN_PORT], table_id=0) datapath.send_msg(req) """ Set update extractor = {eth_dst} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ofproto.OXM_OF_IN_PORT], table_id=0) datapath.send_msg(req) """ Field extractor for mpls label """ req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=0, extractor_id=0, field=ofproto.OXM_OF_MPLS_LABEL) datapath.send_msg(req) """ Field extractor for timestamp """ req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=0, extractor_id=1, field=bebaproto.OXM_EXP_TIMESTAMP) datapath.send_msg(req) """ Packet counter_max for designing probe frequency """ req = bebaparser.OFPExpMsgsSetGlobalDataVariable( datapath=datapath, table_id=0, global_data_variable_id=0, value=PROBE_FREQ) datapath.send_msg(req) """ Condition C0: if counter reaches counter_max, then trigger probe sending """ req = bebaparser.OFPExpMsgSetCondition( datapath=datapath, table_id=0, condition_id=0, condition=bebaproto.CONDITION_GTE, operand_1_fd_id=0, operand_2_gd_id=0) datapath.send_msg(req) req = bebaparser.OFPExpMsgSetCondition( datapath=datapath, table_id=0, condition_id=3, condition=bebaproto.CONDITION_GTE, operand_1_fd_id=0, operand_2_gd_id=0) datapath.send_msg(req) ##################################### TABLE 0 FLOWS ################################################## """ RECEIVE PROBE ACTION """ """ When a probe is received tab0 sends it to tab3""" """ match: MPLS """ """ no action """ """ instruction: goto tab3""" match = ofparser.OFPMatch(eth_type=0x8847) instructions = [ofparser.OFPInstructionGotoTable(3)] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=200, match=match, instructions=instructions) datapath.send_msg(mod) """ For packets from down ports (attached to hosts): go to ToR Discovery table (1) """ for i in DOWN_PORTS: match = ofparser.OFPMatch(in_port=i) instructions = [ofparser.OFPInstructionGotoTable(1)] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=10, match=match, instructions=instructions) datapath.send_msg(mod) match = ofparser.OFPMatch() instructions = [ofparser.OFPInstructionGotoTable(2)] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=0, priority=0, match=match, instructions=instructions) datapath.send_msg(mod) # using low bitrate flows to refresh the estimates. For testing purposes only for i in [0, 1]: match = ofparser.OFPMatch(in_port=3, eth_type=0x0800, ip_proto=6, tcp_dst=10000 + i) actions = [ofparser.OFPActionOutput(i + 1)] self.add_flow(datapath=datapath, table_id=0, priority=200, match=match, actions=actions) match = ofparser.OFPMatch(in_port=3, eth_type=0x0800, ip_proto=6, tcp_src=10000 + i) actions = [ofparser.OFPActionOutput(i + 1)] self.add_flow(datapath=datapath, table_id=0, priority=200, match=match, actions=actions) ######################## TABLE 1 ToR DISCOVERY ######################################################### # this cycle writes metadata specifying to which leaf belongs the packet for i in LEAVES: if i != datapath.id: match = ofparser.OFPMatch(eth_dst=MAC_ADDRS[i - 1]) instructions = [ ofparser.OFPInstructionWriteMetadata( metadata=i, metadata_mask=0xffffffff), ofparser.OFPInstructionGotoTable(3) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=1, priority=0, match=match, instructions=instructions) datapath.send_msg(mod) ######################### TABLE 2: ACTIVE PROBING ###################################################### ################### TABLE 2 CONFIG ######### req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=2, stateful=1) datapath.send_msg(req) """ Set lookup extractor = {IN_PORT} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ofproto.OXM_OF_IN_PORT], table_id=2) datapath.send_msg(req) """ Set update extractor = {IN_PORT} """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ofproto.OXM_OF_IN_PORT], table_id=2) datapath.send_msg(req) req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=2, extractor_id=1, field=bebaproto.OXM_EXP_TIMESTAMP) datapath.send_msg(req) req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=2, extractor_id=2, field=bebaproto.OXM_EXP_PKT_LEN) datapath.send_msg(req) req = bebaparser.OFPExpMsgSetCondition( datapath=datapath, condition=bebaproto.CONDITION_GTE, condition_id=0, table_id=2, operand_1_hf_id=1, operand_2_fd_id=4) datapath.send_msg(req) ############################### TABLE 2 FLOWS ############################# match = ofparser.OFPMatch(state=0) actions = [ bebaparser.OFPExpActionSetState(table_id=2, state=1, idle_timeout=2), # saves timestamp bebaparser.OFPExpActionSetDataVariable(table_id=2, opcode=bebaproto.OPCODE_SUM, output_fd_id=4, operand_1_hf_id=1, operand_2_cost=PROBE_FREQ), ofparser.OFPActionOutput(3) ] self.add_flow(datapath=datapath, table_id=2, priority=500, match=match, actions=actions) """ For every packet coming from spine ports, calculates ewma """ for i in UPPER_PORTS: # simply ewma measuring match = ofparser.OFPMatch(state=1, in_port=i, condition0=1) actions_ewma_1 = [ # calculates deltaT: FDV[1]=HF[1]-FDV[0]=TS_NOW - TS_LAST bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_SUB, output_fd_id=1, operand_1_hf_id=1, operand_2_fd_id=0), # calculates rate: R = (bytes / deltaT_ms) * 8 [kb/s] bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_MUL, output_fd_id=2, operand_1_fd_id=2, operand_2_cost=8), # stores the result in FDV[3]: THE FLOW ESTIMATED RATE bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_DIV, output_fd_id=2, operand_1_fd_id=2, operand_2_fd_id=1), # calculates ewma bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_EWMA, output_fd_id=3, operand_1_fd_id=3, operand_2_cost=ALPHA, operand_3_fd_id=2), # saves current timestamp bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_SUM, output_fd_id=0, operand_1_hf_id=1, operand_2_cost=0), # saves timestamp + probe freq bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_SUM, output_fd_id=4, operand_1_hf_id=1, operand_2_cost=PROBE_FREQ), # reset byte counter bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_SUB, output_fd_id=2, operand_1_fd_id=2, operand_2_fd_id=2), # saves in GDV[i] the ewma bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_SUM, output_gd_id=i, operand_1_fd_id=3, operand_2_cost=0) ] # actions for the packet actions = actions_ewma_1 + [ofparser.OFPActionOutput(3)] # action group for the probes probe_actions1 = [ ofparser.OFPActionSetField(mpls_tc=datapath.id), # the GDV[i] bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_GLOBAL_DATA_VAR, src_id=i, dst_field=ofproto.OXM_OF_MPLS_LABEL), ofparser.OFPActionOutput(i) ] probe_actions2 = [ ofparser.OFPActionSetField( mpls_tc=datapath.id), # the GDV[other] bebaparser.OFPExpActionWriteContextToField( src_type=bebaproto.SOURCE_TYPE_GLOBAL_DATA_VAR, src_id=(1 if i == 2 else 2), dst_field=ofproto.OXM_OF_MPLS_LABEL), ofparser.OFPActionOutput((1 if i == 2 else 2)) ] # apply packet actions insts = [ ofparser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions), # apply packet generation bebaparser.OFPInstructionInSwitchPktGen( pkttmp_id=0, actions=probe_actions1), bebaparser.OFPInstructionInSwitchPktGen(pkttmp_id=0, actions=probe_actions2) ] mod = ofparser.OFPFlowMod(datapath=datapath, table_id=2, priority=30, match=match, instructions=insts) datapath.send_msg(mod) match = ofparser.OFPMatch(state=1, in_port=i, condition0=0) actions_ewma_2 = [ bebaparser.OFPExpActionSetDataVariable( table_id=2, opcode=bebaproto.OPCODE_SUM, output_fd_id=2, operand_1_fd_id=2, operand_2_hf_id=2) ] self.add_flow(datapath=datapath, table_id=2, priority=30, match=match, actions=actions_ewma_2 + [ofparser.OFPActionOutput(3)]) # using low bitrate flows to refresh the estimates. For testing purposes only for j in [0, 1]: match = ofparser.OFPMatch(in_port=i, eth_type=0x0800, ip_proto=6, tcp_dst=10000 + j, condition0=1) actions = actions_ewma_1 + [ofparser.OFPActionOutput(3)] self.add_flow(datapath=datapath, table_id=2, priority=150, match=match, actions=actions) match = ofparser.OFPMatch(in_port=i, eth_type=0x0800, ip_proto=6, tcp_src=10000 + j, condition0=1) actions = actions_ewma_1 + [ofparser.OFPActionOutput(3)] self.add_flow(datapath=datapath, table_id=2, priority=150, match=match, actions=actions) match = ofparser.OFPMatch(in_port=i, eth_type=0x0800, ip_proto=6, tcp_dst=10000 + j, condition0=0) actions = actions_ewma_2 + [ofparser.OFPActionOutput(3)] self.add_flow(datapath=datapath, table_id=2, priority=150, match=match, actions=actions) match = ofparser.OFPMatch(in_port=i, eth_type=0x0800, ip_proto=6, tcp_src=10000 + j, condition0=0) actions = actions_ewma_2 + [ofparser.OFPActionOutput(3)] self.add_flow(datapath=datapath, table_id=2, priority=150, match=match, actions=actions) ######################## TABLE 3: FORWARDING ############################################################## ######################## TABLE 3 CONFIG ##################################################################### ##### GDV[1] contains path utilization to dest 1 on port 1 ##### GDV[2] contains path utilization to dest 2 on port 1 ##### GDV[3] contains path utilization to dest 1 on port 2 ##### GDV[4] contains path utilization to dest 2 on port 2 req = bebaparser.OFPExpMsgConfigureStatefulTable(datapath=datapath, table_id=3, stateful=1) datapath.send_msg(req) """ Set lookup extractor """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_L_EXTRACTOR, fields=[ ofproto.OXM_OF_IPV4_SRC, ofproto.OXM_OF_IPV4_DST, ofproto.OXM_OF_TCP_SRC, ofproto.OXM_OF_TCP_DST ], table_id=3) datapath.send_msg(req) """ Set update extractor """ req = bebaparser.OFPExpMsgKeyExtract( datapath=datapath, command=bebaproto.OFPSC_EXP_SET_U_EXTRACTOR, fields=[ ofproto.OXM_OF_IPV4_SRC, ofproto.OXM_OF_IPV4_DST, ofproto.OXM_OF_TCP_SRC, ofproto.OXM_OF_TCP_DST ], table_id=3) datapath.send_msg(req) req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=3, extractor_id=0, field=ofproto.OXM_OF_MPLS_LABEL) datapath.send_msg(req) req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=3, extractor_id=1, field=bebaproto.OXM_EXP_TIMESTAMP) datapath.send_msg(req) req = bebaparser.OFPExpMsgHeaderFieldExtract( datapath=datapath, table_id=3, extractor_id=2, field=bebaproto.OXM_EXP_PKT_LEN) datapath.send_msg(req) #################################### TABLE 3 FLOWS ################################### # many conditions as the number of LEAVES-1 # for i in LEAVES except datapath.id: create condition[i] # in case of 2 Spines for destLeaf in [1, 2]: # C[destLeaf]: in which port there is less utilization for that destination? req = bebaparser.OFPExpMsgSetCondition( datapath=datapath, condition=bebaproto.CONDITION_LTE, condition_id=destLeaf, table_id=3, operand_1_gd_id=destLeaf, operand_2_gd_id=destLeaf + 2) datapath.send_msg(req) # leaf number dependent flows if datapath.id == 1: # LEAF 1 new flows: fetch the destination leaf and check the appropriate condition match1true = ofparser.OFPMatch(metadata=2, condition1=1, state=0) # dst=2, port 1 match2true = ofparser.OFPMatch(metadata=3, condition2=1, state=0) # dst=3, port 1 match1false = ofparser.OFPMatch(metadata=2, condition1=0, state=0) # dst=2, port 2 match2false = ofparser.OFPMatch(metadata=3, condition2=0, state=0) # dst=3, port 2 elif datapath.id == 2: # LEAF 2 new flows: fetch the destination leaf and check the appropriate condition match1true = ofparser.OFPMatch(metadata=1, condition1=1, state=0) # dst=1, port 1 match2true = ofparser.OFPMatch(metadata=3, condition2=1, state=0) # dst=3, port 1 match1false = ofparser.OFPMatch(metadata=1, condition1=0, state=0) # dst=1, port 2 match2false = ofparser.OFPMatch(metadata=3, condition2=0, state=0) # dst=3, port 2 elif datapath.id == 3: # LEAF 3 new flows: fetch the destination leaf and check the appropriate condition match1true = ofparser.OFPMatch(metadata=1, condition1=1, state=0) # dst=1, port 1 match2true = ofparser.OFPMatch(metadata=2, condition2=1, state=0) # dst=2, port 1 match1false = ofparser.OFPMatch(metadata=1, condition1=0, state=0) # dst=1, port 2 match2false = ofparser.OFPMatch(metadata=2, condition2=0, state=0) # dst=2, port 2 # if port 1 is better, set_state(1) and output 1 actions_true = [ bebaparser.OFPExpActionSetState(state=1, table_id=3, idle_timeout=RTT), ofparser.OFPActionOutput(1) ] # if port 2 is better, set_state(2) and output 2 actions_false = [ bebaparser.OFPExpActionSetState(state=2, table_id=3, idle_timeout=RTT), ofparser.OFPActionOutput(2) ] self.add_flow(datapath=datapath, table_id=3, priority=20, match=match1true, actions=actions_true) self.add_flow(datapath=datapath, table_id=3, priority=20, match=match2true, actions=actions_true) self.add_flow(datapath=datapath, table_id=3, priority=20, match=match1false, actions=actions_false) self.add_flow(datapath=datapath, table_id=3, priority=20, match=match2false, actions=actions_false) """ extract external probes' data and store in GDVs """ match = ofparser.OFPMatch(eth_type=0x8847, mpls_tc=datapath.id) self.add_flow(datapath=datapath, table_id=3, priority=300, match=match, actions=[]) for i in UPPER_PORTS: for leafNo in LEAVES: if leafNo != datapath.id: match = ofparser.OFPMatch(in_port=i, eth_type=0x8847, mpls_tc=leafNo) """ actions: save in GDVs external probes' data """ if datapath.id == 1: if leafNo == 2: actions = [ bebaparser.OFPExpActionSetDataVariable( table_id=3, opcode=bebaproto.OPCODE_SUM, output_gd_id=(1 if i == 1 else 3), operand_1_hf_id=0, operand_2_cost=0) ] elif leafNo == 3: actions = [ bebaparser.OFPExpActionSetDataVariable( table_id=3, opcode=bebaproto.OPCODE_SUM, output_gd_id=(2 if i == 1 else 4), operand_1_hf_id=0, operand_2_cost=0) ] elif datapath.id == 2: if leafNo == 1: actions = [ bebaparser.OFPExpActionSetDataVariable( table_id=3, opcode=bebaproto.OPCODE_SUM, output_gd_id=(1 if i == 1 else 3), operand_1_hf_id=0, operand_2_cost=0) ] elif leafNo == 3: actions = [ bebaparser.OFPExpActionSetDataVariable( table_id=3, opcode=bebaproto.OPCODE_SUM, output_gd_id=(2 if i == 1 else 4), operand_1_hf_id=0, operand_2_cost=0) ] elif datapath.id == 3: if leafNo == 1: actions = [ bebaparser.OFPExpActionSetDataVariable( table_id=3, opcode=bebaproto.OPCODE_SUM, output_gd_id=(1 if i == 1 else 3), operand_1_hf_id=0, operand_2_cost=0) ] elif leafNo == 2: actions = [ bebaparser.OFPExpActionSetDataVariable( table_id=3, opcode=bebaproto.OPCODE_SUM, output_gd_id=(2 if i == 1 else 4), operand_1_hf_id=0, operand_2_cost=0) ] self.add_flow(datapath=datapath, table_id=3, priority=200, match=match, actions=actions) for s in UPPER_PORTS: for metadata in LEAVES: # normal conditions match = ofparser.OFPMatch(in_port=3, state=s, metadata=metadata) # , condition4=0) actions = [ofparser.OFPActionOutput(s)] self.add_flow(datapath=datapath, table_id=3, priority=30, match=match, actions=actions)
priority=1000, match=parser.OFPMatch(eth_dst=2), instructions=[parser.OFPInstructionGotoTable(2)]), parser.OFPFlowStats(table_id=1, priority=0, match=parser.OFPMatch(), instructions=[parser.OFPInstructionGotoTable(3)]), # Table 2 parser.OFPFlowStats( table_id=2, priority=1008, match=parser.OFPMatch(ipv4_dst=("1.0.0.0", "255.0.0.0")), instructions=[ parser.OFPInstructionActions(ofproto_v1_3.OFPIT_WRITE_ACTIONS, [ parser.OFPActionSetField(eth_src=100), parser.OFPActionSetField(eth_dst=20), parser.OFPActionOutput(20) ]) ]), parser.OFPFlowStats( table_id=2, priority=1008, match=parser.OFPMatch(ipv4_dst=("10.0.0.0", "255.0.0.0")), instructions=[ parser.OFPInstructionActions(ofproto_v1_3.OFPIT_WRITE_ACTIONS, [ parser.OFPActionSetField(eth_src=100), parser.OFPActionSetField(eth_dst=20), parser.OFPActionOutput(20) ]) ]),