def processevent(self, event):
"""Event handler
@param event event to handle
@return false if processed else true
"""
if isinstance(event, ofevents.pktin):
iport = mc.get(bridge.SW_INNER_PORT)
intfs = self.get_ext_intf()
if iport == None:
output.err("No inner port recorded! Are we connected?", self.__class__.__name__)
return True
flow = flows.exact_entry(event.match)
if event.match.in_port == iport:
flow.add_output(self.get_out_port(intfs))
else:
flow.add_output(iport)
if flow.buffer_id != event.pktin.buffer_id:
flow.set_buffer(event.pktin.buffer_id)
self.get_conn().send(flow.get_flow_mod(pyof.OFPFC_ADD).pack())
else:
self.get_conn().send(flow.get_flow_mod(pyof.OFPFC_ADD).pack())
self.get_conn().send(flow.get_packet_out(pyof.OFPFC_ADD).pack() + event.dpkt.pack())
return False
return True
def del_dp(self, name):
"""Delete datapath with name
@param name name of datapath
"""
if (name in self.datapaths):
output.dbg("Delete datapath "+name,
self.__class__.__name__)
self.datapaths.pop(name)
else:
output.err("No datapath of name "+name)
def __init__(self, db, name):
"""Initialize
"""
self.name = name
self.table = None
if (db.started):
output.err("Database "+str(db)+" is already started."+\
" Logger cannot be initialized!",
self.__class__.__name__)
else:
db.add_table(Table(name, self.get_col_names()))
self.table = db.tables[name]
def processevent(self, event):
"""Event handler
@param event event to handle
@return True
"""
if isinstance(event, ofevents.pktin):
self.check_timeout()
iport = mc.get(bridge.SW_INNER_PORT)
intfs = self.get_ext_intf()
if iport == None:
output.err("No inner port recorded! Are we connected?", self.__class__.__name__)
return True
flow = flows.exact_entry(event.match)
# Change IP?
if flow.match.nw_src in self.ip_change:
new_ip = flow.match.nw_src
old_ip = self.ip_change[new_ip][0]
flow.add_nw_rewrite(True, old_ip)
ofpkt.nw_rewrite(event.dpkt, True, old_ip)
output.dbg("Adding rewrite for changing flow", self.__class__.__name__)
ipflow = flows.ethertype_entry(dpkt.ethernet.ETH_TYPE_IP)
ipflow.set_nw_dst(old_ip)
(sr, fsr) = ipflow.get_flow_stats_request()
self.get_conn().send(sr.pack() + fsr.pack())
# Decide output port
if event.match.in_port == iport:
flow.add_output(self.get_out_port(intfs))
else:
flow.add_output(iport)
# Send appropriately
if flow.buffer_id != event.pktin.buffer_id:
flow.set_buffer(event.pktin.buffer_id)
self.get_conn().send(flow.get_flow_mod(pyof.OFPFC_ADD).pack())
else:
self.get_conn().send(flow.get_flow_mod(pyof.OFPFC_ADD).pack())
self.get_conn().send(flow.get_packet_out(pyof.OFPFC_ADD).pack() + event.dpkt.pack())
return False
elif isinstance(event, udpjson.message):
self._handle_json(event)
elif isinstance(event, ofevents.flow_stats):
self._handle_change(event)
return True
def processevent(self, event):
"""Event handler
@param event event to handle
@return True
"""
if isinstance(event, ofevents.pktin):
self.check_timeout()
iport = mc.get(bridge.SW_INNER_PORT)
intfs = self.get_ext_intf()
if iport == None:
output.err("No inner port recorded! Are we connected?", self.__class__.__name__)
return True
flow = flows.exact_entry(event.match)
# Indirection given?
if flow.match.nw_src in self.m2m:
from_ip = flow.match.nw_dst
from_eth = flow.match.dl_dst[:]
to_eth = flow.match.dl_src[:]
to_ip = self.m2m[from_ip][0]
flow.add_nw_rewrite(True, from_ip)
flow.add_dl_rewrite(True, from_eth)
flow.add_nw_rewrite(False, to_ip)
flow.add_dl_rewrite(False, to_eth)
ofpkt.nw_rewrite(event.dpkt, True, from_ip)
ofpkt.dl_rewrite(event.dpkt, True, from_eth)
ofpkt.nw_rewrite(event.dpkt, False, to_ip)
ofpkt.dl_rewrite(event.dpkt, False, to_eth)
flow.add_output(py.OFPP_IN_PORT)
if flow.buffer_id != event.pktin.buffer_id:
flow.set_buffer(event.pktin.buffer_id)
self.get_conn().send(flow.get_flow_mod(pyof.OFPFC_ADD).pack())
else:
self.get_conn().send(flow.get_flow_mod(pyof.OFPFC_ADD).pack())
self.get_conn().send(flow.get_packet_out(pyof.OFPFC_ADD).pack() + event.dpkt.pack())
output.dbg("Indirecting flow...", self.__class__.__name__)
return False
elif isinstance(event, udpjson.message):
self._handle_json(event)
return True
def processevent(self, event):
"""Event handler
@param event event to handle
@return false if processed else true
"""
if isinstance(event, yapc.priv_callback):
self.__sf = mc.get(nat.SW_FEATURE)
if self.__sf != None:
bwquery = ns.bandwidth_query(ns.bandwidth_query.MODE_TOTAL_MAX)
for p in self.__sf.ports:
if mc.get(nat.get_ip_range_key(p.port_no)) != None:
# Port exist
bwquery.interfaces.append(p.name)
if len(bwquery.interfaces) != 0:
self.server.post_event(bwquery)
# Query for bandwidth of intervals
if self.bwinterval != 0:
self.server.post_event(yapc.priv_callback(self), self.bwinterval)
elif isinstance(event, coini.queryresponse) and isinstance(event.query, ns.bandwidth_query):
for p in self.__sf.ports:
if event.response[0]["interface"] == p.name:
self.max_bw_port = p.port_no
output.vdbg(
"Port " + str(p.port_no) + "(" + str(p.name) + ") has most bandwidth", self.__class__.__name__
)
elif (
isinstance(event, ofevents.pktin)
and
# Handle packet in
event.match.dl_type == dpkt.ethernet.ETH_TYPE_IP
):
iport = mc.get(nat.SW_INNER_PORT)
intfs = self.get_intf_n_range()
lointf = mc.get(nat.SW_INNER_PORT_ADDR)
if iport == None:
output.err("No inner port recorded! Are we connected?", self.__class__.__name__)
return True
if event.match.in_port == iport:
return self._process_outbound(event, intfs, iport, lointf)
else:
return self._process_inbound(event, intfs, iport, lointf)
return True
def processevent(self, event):
"""Event handler (for ARP only)
@param event event to handle
@return false if processed else true
"""
if isinstance(event, ofevents.pktin) and event.match.dl_type == dpkt.ethernet.ETH_TYPE_ARP:
iport = mc.get(nat.SW_INNER_PORT)
intfs = self.get_intf_n_range()
lointf = mc.get(nat.SW_INNER_PORT_ADDR)
if iport == None:
output.err("No inner port recorded! Are we connected?", self.__class__.__name__)
return True
if event.match.in_port == iport:
return self._process_outbound(event, intfs, iport, lointf)
else:
return self._process_inbound(event, intfs, iport, lointf)
return True
