Part 1: Controller Hub and Learning Switch You will compare the performance of a Hub…
- User
Part 1: Controller Hub and Learning Switch You will compare the performance of a Hub Controller and a Learning Switch. A Hub Controller redirects all the traffic on a switch to itself and then forwards it to all switch ports except the incoming port. A Learning Switch installs flow rules on the switches based on the MAC to Port mappings it learns from incoming traffic. Begin by implementing a Controller Hub on both switches, S1 and S2. Following that, implement a Learning Switch. Answer the following questions: in both scenarios, conducting 3 pings for each case. Report the latency values. Explain the observed latency differences between the Hub Controller and Learning Switch. Also, explain differences (if any) observed between h2 and h5 for both controller types. • Run a throughput test between h1 and h5. Report the observed values. Explain the differences between the Hub Controller and Learning Switch. • Run pingall in both cases and report the installed rules on switches. Hint: You can use the example code in the Ryu codebase. Code Submission: You should submit two files, learning switch.py and controller hub.py. Each file should be a standalone Ryu app and should be able to run using the following command: ryu-manager file name.py. The same goes for the next two parts.write code. controller_hub.py): 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
class ControllerHub(app_manager.RyuApp): OFP_VERSION = ofproto_v1_3.OFP_VERSION
def __init__(self, *args, **kwargs): super(ControllerHub, self).__init__(*args, **kwargs) @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER) def switch_features_handler(self, ev): datapath = ev.msg.datapath ofproto = datapath.ofproto parser = datapath.ofproto_parser # Install a default flow to flood traffic match = parser.OFPMatch() actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)] self.add_flow(datapath, 0, match, actions) def add_flow(self, datapath, priority, match, actions): ofproto = datapath.ofproto parser = datapath.ofproto_parser inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)] mod = parser.OFPFlowMod(datapath=datapath, priority=priority, match=match, instructions=inst) datapath.send_msg(mod) . learning_switch.py from ryu.base import app_managerfrom 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
class LearningSwitch(app_manager.RyuApp): OFP_VERSION = ofproto_v1_3.OFP_VERSION
def __init__(self, *args, **kwargs): super(LearningSwitch, 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 ofproto = datapath.ofproto parser = datapath.ofproto_parser # Install a default flow to flood unknown traffic match = parser.OFPMatch() actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)] self.add_flow(datapath, 0, match, actions) @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER) def packet_in_handler(self, ev): 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 packets return dst = eth.dst src = eth.src dpid = datapath.id self.mac_to_port.setdefault(dpid, {}) # Learn the MAC address to avoid flooding next time self.mac_to_port[dpid][src] = in_port if dst in self.mac_to_port[dpid]: out_port = self.mac_to_port[dpid][dst] 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) 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) def add_flow(self, datapath, priority, match, actions): ofproto = datapath.ofproto parser = datapath.ofproto_parser inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)] mod = parser.OFPFlowMod(datapath=datapath, priority=priority, match=match, instructions=inst) datapath.send_msg(mod) .is this correct code. - Assistant
The code you provided is correct and can be used to implement a Controller Hub and a Learning Switch using Ryu. However, the code is missing some imports that are necessary for it to work properly.
Please ensure that you have imported the following modules at the beginning of each file:
For controller_hub.py:
from ryu.controller import dpset from ryu.lib import hub from ryu.lib.packet import packet, ethernet, ether_typesFor learning_switch.py:
from ryu.lib.packet import packet, ethernet, ether_typesMake sure to include these imports and try running the code again.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.