def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
self.con = event.connection
self.mac = self.con.eth_addr
log.info("Saw switch come up: %s", sw_str)
name_str = self.t.id_gen(dpid=event.dpid).name_str()
if name_str not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added fresh switch %s" % sw_str)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.info("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("Woo! All switches up")
self.all_switches_up = True
self._get_all_paths()
if self.all_switches_up == True:
self._do_probe()
def _handle_ConnectionUp (self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
log.info("Saw switch come up: %s", sw_str)
name_str = self.t.id_gen(dpid = event.dpid).name_str()
if name_str not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added fresh switch %s" % sw_str)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.info("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("Woo! All switches up")
self.all_switches_up = True
if self.mode == 'proactive':
self._install_proactive_flows()
if self.mode == 'hybrid':
self._install_hybrid_static_flows()
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
log.info("Saw switch com up: %s", sw_str)
name_str = self.t.id_gen(dpid=event.dpid).name_str()
if name_str not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added fresh switch %s" % sw_str)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.info("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("Woo! All switches up")
self.all_switches_up = True
self._save_paths()
# log.info("self.routeTable : %s" % self.routeTable)
start = time()
self._install_paths()
log.info("use %s seconds to install paths" % (time() - start))
# the pre_install_paths should have been installed
log.info("Woo! All paths ok")
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
sw_name = self.t.id_gen(dpid=event.dpid).name_str()
self.macTable.clear() #clear macTable when there is a new conection
if sw_name not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added a new switch %s" % sw_name)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.debug("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("All of the switches are up")
if self.mode == 'proactive':
self._install_proactive_flows()
log.info("Routing is complete")
self.all_switches_up = True
def handle_FEATURES_REPLY (self, con, msg):
connecting = con.connect_time == None
con.features = msg
con.original_ports._ports = set(msg.ports)
con.ports._reset()
con.dpid = msg.datapath_id
nexus = core.OpenFlowConnectionArbiter.getNexus(con)
if nexus is None:
# Cancel connection
con.info("No OpenFlow nexus for " +
pox.lib.util.dpidToStr(msg.datapath_id))
con.disconnect()
return
con.ofnexus = nexus
con.ofnexus._connect(con)
#TODO: Add a timeout for finish_connecting
if con.ofnexus.miss_send_len is not None:
con.send(of.ofp_set_config(miss_send_len =
con.ofnexus.miss_send_len))
if con.ofnexus.clear_flows_on_connect:
con.send(of.ofp_flow_mod(match=of.ofp_match(),command=of.OFPFC_DELETE))
self._barrier = of.ofp_barrier_request()
con.send(self._barrier)
def __init__(self, connection, transparent):
self.connection = connection
self.transparent = transparent
self.sw_info = {}
self.connection.send(of.ofp_set_config(miss_send_len=65535))
# Vhost Demuxer
self.vhost_id = ''
for port in connection.features.ports:
intf_name = port.name.split('-')
if (len(intf_name) < 2):
continue
else:
self.vhost_id = intf_name[
0] #get the first part of vhost1-eth0
intf_name = intf_name[1]
if self.vhost_id not in self.sw_info.keys():
self.sw_info[self.vhost_id] = {}
#if intf_name in VHOST_HW[self.vhost_id].keys():
self.sw_info[self.vhost_id][intf_name] = (
ROUTER_IP_DICT[self.vhost_id][intf_name], port.hw_addr.toStr(),
'10Gbps', port.port_no)
print self.sw_info
self.rtable = RTABLE
# We want to hear Openflow PacketIn messages, so we listen
self.listenTo(connection)
self.listenTo(core.cs123_srhandler)
core.cs123_ofhandler.raiseEvent(
RouterInfo(self.sw_info[self.vhost_id], self.rtable[self.vhost_id],
self.vhost_id))
def _handle_ConnectionUp (self, event):
print "*****************ConnectionUp"
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
log.info("Saw switch come up: %s", sw_str)
found = False
for i in range(1,6):
if event.dpid == i:
found = True
for j in range(1,5):
if event.dpid == (10 * i + j):
found = True
if not found :
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added fresh switch %s" % sw_str)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.info("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == 25:
log.info("Woo! All switches up")
self.all_switches_up = True
def __init__(self, connection):
self.connection = connection
self.dpid = connection.dpid % 1000
log.debug("dpid=%s", self.dpid)
swifaces = {}
self.connection.send(of.ofp_set_config(miss_send_len=65535))
for port in connection.features.ports:
intf_name = port.name.split('-')
if (len(intf_name) < 2):
continue
else:
self.swid = intf_name[0]
intf_name = intf_name[1]
if port.name in IP_SETTING.keys():
swifaces[intf_name] = (IP_SETTING[port.name][0],
IP_SETTING[port.name][1],
port.hw_addr.toStr(), port.port_no)
else:
swifaces[intf_name] = (None, None, None, port.port_no)
# We want to hear OF PacketIn messages, so we listen
self.listenTo(connection)
self.listenTo(core.VNetHandler)
core.VNetOFNetHandler.raiseEvent(
VNetDevInfo(swifaces, self.swid, self.dpid))
def handle_FEATURES_REPLY (self, con, msg):
connecting = con.connect_time == None
con.features = msg
con.original_ports._ports = set(msg.ports)
con.ports._reset()
con.dpid = msg.datapath_id
# If any port status messages come between now and when the connection is
# actually up, buffer them to raise later.
con._deferred_port_status = []
nexus = core.OpenFlowConnectionArbiter.getNexus(con)
if nexus is None:
# Cancel connection
con.info("No OpenFlow nexus for " +
pox.lib.util.dpidToStr(msg.datapath_id))
con.disconnect()
return
con.ofnexus = nexus
#TODO: Add a timeout for finish_connecting
if con.ofnexus.miss_send_len is not None:
con.send(of.ofp_set_config(miss_send_len =
con.ofnexus.miss_send_len))
if con.ofnexus.clear_flows_on_connect:
con.send(of.ofp_flow_mod(match=of.ofp_match(),command=of.OFPFC_DELETE))
self._barrier = of.ofp_barrier_request()
con.send(self._barrier)
def handle_FEATURES_REPLY(self, con, msg):
connecting = con.connect_time == None
con.features = msg
con.original_ports._ports = set(msg.ports)
con.ports._reset()
con.dpid = msg.datapath_id
nexus = core.OpenFlowConnectionArbiter.getNexus(con)
if nexus is None:
# Cancel connection
con.info("No OpenFlow nexus for " +
pox.lib.util.dpidToStr(msg.datapath_id))
con.disconnect()
return
con.ofnexus = nexus
con.ofnexus._connect(con)
#TODO: Add a timeout for finish_connecting
if con.ofnexus.miss_send_len is not None:
con.send(
of.ofp_set_config(miss_send_len=con.ofnexus.miss_send_len))
if con.ofnexus.clear_flows_on_connect:
con.send(
of.ofp_flow_mod(match=of.ofp_match(), command=of.OFPFC_DELETE))
self._barrier = of.ofp_barrier_request()
con.send(self._barrier)
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
log.info("Saw switch come up: %s", sw_str)
name_str = self.t.id_gen(dpid=event.dpid).name_str()
if name_str not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added fresh switch %s" % sw_str)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.info("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("Woo! All switches up")
self.all_switches_up = True
if self.mode == 'proactive':
self._install_proactive_flows()
if self.mode == 'hybrid':
self._install_hybrid_static_flows()
def check_socket(self):
pkt_count = 0
while True:
pkt_count += 1
buff = self.s.recv(100)
pkt = of.ofp_header()
pkt.unpack(buff)
#print('[{}][check_socket]recved: ', len(buff))
print('\n[{0}] received [{1}]byte data.'.format(pkt_count, len(buff)))
print(pkt.show())
if pkt.header_type == gini_of.OFPT_HELLO: # OFPT_HELLO
print("OFPT_HELLO msg: ")
pkt = of.ofp_hello()
pkt.unpack(buff)
self.process_hello(pkt)
elif pkt.header_type == gini_of.OFPT_ECHO_REQUEST:
print("OFPT_ECHO_REPLY msg: ")
pkt = of.ofp_echo_request()
pkt.unpack(buff)
self.process_echo_request(pkt)
elif pkt.header_type == gini_of.OFPT_FEATURES_REQUEST:
print("OFPT_FEATURES_REQUEST msg: ")
pkt = of.ofp_features_request()
pkt.unpack(buff)
self.process_features_request(pkt)
elif pkt.header_type == gini_of.OFPT_SET_CONFIG:
print("OFPT_SET_CONFIG msg: ")
pkt = of.ofp_set_config()
pkt.unpack(buff)
self.process_set_config(pkt)
elif pkt.header_type == gini_of.OFPT_FLOW_MOD:
print("OFPT_FLOW_MOD msg: ")
pkt = giniclass_flow_mod()
pkt.unpack(buff)
self.process_flow_mod(pkt)
elif pkt.header_type == gini_of.OFPT_BARRIER_REQUEST:
print("OFPT_BARRIER_REQUEST msg: ")
pkt = of.ofp_barrier_request()
pkt.unpack(buff)
self.process_barrier_request(pkt)
else:
print("Unknown type!: ", pkt.header_type, "details: ")
print(pkt.show())
def __init__ (self, connection, transparent):
# Switch we'll be adding L2 learning switch capabilities to
self.connection = connection
self.transparent = transparent
self.sw_info = {}
self.connection.send(of.ofp_set_config(miss_send_len = 65535))
for port in connection.features.ports:
intf_name = port.name.split('-')
if(len(intf_name) < 2):
continue
else:
intf_name = intf_name[1]
if intf_name in ROUTER_IP.keys():
self.sw_info[intf_name] = (ROUTER_IP[intf_name], port.hw_addr.toStr(), '10Gbps', port.port_no)
self.rtable = RTABLE
# We want to hear Openflow PacketIn messages, so we listen
self.listenTo(connection)
self.listenTo(core.cs144_srhandler)
core.cs144_ofhandler.raiseEvent(RouterInfo(self.sw_info, self.rtable))
def _handle_ConnectionUp (self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
log.info("Saw switch com up: %s", sw_str)
name_str = self.t.id_gen(dpid = event.dpid).name_str()
if name_str not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added fresh switch %s" % sw_str)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.info("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len = MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("Woo! All switches up")
self.all_switches_up = True
self._save_paths()
# log.info("self.routeTable : %s" % self.routeTable)
# self._install_paths()
log.info("Woo! All paths ok")
# suppose here we have a traffic matrix
# find the routing policies for this traffic matrix
#for i in range(10):
# num_matrix = i
# self.test(num_matrix)
self.input_traffic()
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
log.info("Saw switch com up: %s", sw_str)
name_str = self.t.id_gen(dpid=event.dpid).name_str()
if name_str not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added fresh switch %s" % sw_str)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.info("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("Woo! All switches up")
self.all_switches_up = True
self._save_paths()
# log.info("self.routeTable : %s" % self.routeTable)
# self._install_paths()
log.info("Woo! All paths ok")
# suppose here we have a traffic matrix
# find the routing policies for this traffic matrix
#for i in range(10):
# num_matrix = i
# self.test(num_matrix)
self.input_traffic()
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
sw_name = self.t.node_gen(dpid = event.dpid).name_str()
if sw_name not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added a new switch %s" % sw_name)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.debug("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches)==len(self.t.switches()):
log.info("All of the switches are up")
self.all_switches_up = True
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
sw_name = self.t.node_gen(dpid=event.dpid).name_str()
if sw_name not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
if sw is None:
log.info("Added a new switch %s" % sw_name)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
else:
log.debug("Odd - already saw switch %s come up" % sw_str)
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("All of the switches are up")
self.all_switches_up = True
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
sw_name = self.t.node_gen(dpid = event.dpid).name_str()
if sw_name not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
#log.info("A new switch came up: %s", sw_str)
if sw is None:
log.info("Added a new switch %s" % sw_name)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches)==len(self.t.switches()):
log.info("All of the switches are up")
self.all_switches_up = True
if self.statMonitorLock.locked():
self.statMonitorLock.release()
def _handle_ConnectionUp(self, event):
sw = self.switches.get(event.dpid)
sw_str = dpidToStr(event.dpid)
sw_name = self.t.node_gen(dpid=event.dpid).name_str()
if sw_name not in self.t.switches():
log.warn("Ignoring unknown switch %s" % sw_str)
return
#log.info("A new switch came up: %s", sw_str)
if sw is None:
log.info("Added a new switch %s" % sw_name)
sw = Switch()
self.switches[event.dpid] = sw
sw.connect(event.connection)
sw.connection.send(of.ofp_set_config(miss_send_len=MISS_SEND_LEN))
if len(self.switches) == len(self.t.switches()):
log.info("All of the switches are up")
self.all_switches_up = True
if self.statMonitorLock.locked():
self.statMonitorLock.release()
def handle_FEATURES_REPLY(self, con, msg):
if msg.version not in self.allowed_versions:
# It's likely you won't see this message because the other side will
# not have sent a features reply if it doesn't support OF 1.0.
con.err("OpenFlow version 0x%02x not supported" % (msg.version, ))
con.disconnect()
return
connecting = con.connect_time == None
con.features = msg
con.original_ports._ports = set(msg.ports)
con.ports._reset()
con.dpid = msg.datapath_id
# If any port status messages come between now and when the connection is
# actually up, buffer them to raise later.
con._deferred_port_status = []
nexus = core.OpenFlowConnectionArbiter.getNexus(con)
if nexus is None:
# Cancel connection
con.info("No OpenFlow nexus for " +
pox.lib.util.dpidToStr(msg.datapath_id))
con.disconnect()
return
con.ofnexus = nexus
#TODO: Add a timeout for finish_connecting
if con.ofnexus.miss_send_len is not None:
con.send(
of.ofp_set_config(miss_send_len=con.ofnexus.miss_send_len))
if con.ofnexus.clear_flows_on_connect:
con.send(
of.ofp_flow_mod(match=of.ofp_match(), command=of.OFPFC_DELETE))
self._barrier = of.ofp_barrier_request()
con.send(self._barrier)
def handle_Conn_Up(self, event):
event.connection.send(of.ofp_set_config(miss_send_len=self.packetSize))
def handle_FEATURES_REPLY (con, msg):
connecting = con.connect_time == None
con.features = msg
con.original_ports._ports = set(msg.ports)
con.ports._reset()
con.dpid = msg.datapath_id
if not connecting:
con.ofnexus._connect(con)
e = con.ofnexus.raiseEventNoErrors(FeaturesReceived, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(FeaturesReceived, con, msg)
return
nexus = core.OpenFlowConnectionArbiter.getNexus(con)
if nexus is None:
# Cancel connection
con.info("No OpenFlow nexus for " +
pox.lib.util.dpidToStr(msg.datapath_id))
con.disconnect()
return
con.ofnexus = nexus
con.ofnexus._connect(con)
#connections[con.dpid] = con
barrier = of.ofp_barrier_request()
listeners = []
def finish_connecting (event):
if event.xid != barrier.xid:
con.dpid = None
con.err("failed connect")
con.disconnect()
else:
con.info("connected")
con.connect_time = time.time()
e = con.ofnexus.raiseEventNoErrors(ConnectionUp, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(ConnectionUp, con, msg)
e = con.ofnexus.raiseEventNoErrors(FeaturesReceived, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(FeaturesReceived, con, msg)
con.removeListeners(listeners)
listeners.append(con.addListener(BarrierIn, finish_connecting))
def also_finish_connecting (event):
if event.xid != barrier.xid: return
if event.ofp.type != of.OFPET_BAD_REQUEST: return
if event.ofp.code != of.OFPBRC_BAD_TYPE: return
# Okay, so this is probably an HP switch that doesn't support barriers
# (ugh). We'll just assume that things are okay.
finish_connecting(event)
listeners.append(con.addListener(ErrorIn, also_finish_connecting))
#TODO: Add a timeout for finish_connecting
if con.ofnexus.miss_send_len is not None:
con.send(of.ofp_set_config(miss_send_len =
con.ofnexus.miss_send_len))
if con.ofnexus.clear_flows_on_connect:
con.send(of.ofp_flow_mod(match=of.ofp_match(),command=of.OFPFC_DELETE))
con.send(barrier)
"""
def handle_FEATURES_REPLY(con, msg):
connecting = con.connect_time == None
con.features = msg
con.original_ports._ports = set(msg.ports)
con.ports._reset()
con.dpid = msg.datapath_id
if not connecting:
con.ofnexus._connect(con)
e = con.ofnexus.raiseEventNoErrors(FeaturesReceived, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(FeaturesReceived, con, msg)
return
nexus = core.OpenFlowConnectionArbiter.getNexus(con)
if nexus is None:
# Cancel connection
con.info("No OpenFlow nexus for " +
pox.lib.util.dpidToStr(msg.datapath_id))
con.disconnect()
return
con.ofnexus = nexus
con.ofnexus._connect(con)
#connections[con.dpid] = con
barrier = of.ofp_barrier_request()
listeners = []
def finish_connecting(event):
if event.xid != barrier.xid:
con.dpid = None
con.err("failed connect")
con.disconnect()
else:
con.info("connected")
con.connect_time = time.time()
e = con.ofnexus.raiseEventNoErrors(ConnectionUp, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(ConnectionUp, con, msg)
e = con.ofnexus.raiseEventNoErrors(FeaturesReceived, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(FeaturesReceived, con, msg)
con.removeListeners(listeners)
listeners.append(con.addListener(BarrierIn, finish_connecting))
def also_finish_connecting(event):
if event.xid != barrier.xid: return
if event.ofp.type != of.OFPET_BAD_REQUEST: return
if event.ofp.code != of.OFPBRC_BAD_TYPE: return
# Okay, so this is probably an HP switch that doesn't support barriers
# (ugh). We'll just assume that things are okay.
finish_connecting(event)
listeners.append(con.addListener(ErrorIn, also_finish_connecting))
#TODO: Add a timeout for finish_connecting
if con.ofnexus.miss_send_len is not None:
con.send(of.ofp_set_config(miss_send_len=con.ofnexus.miss_send_len))
if con.ofnexus.clear_flows_on_connect:
con.send(of.ofp_flow_mod(match=of.ofp_match(),
command=of.OFPFC_DELETE))
con.send(barrier)
"""
def handle_FEATURES_REPLY(con, msg): #type:6
print "jiazy: receive Features_Reply message\n"
connecting = con.connect_time == None #connect_time = None as default, so connecting = ture
#print ("con.connect_time:",con.connect_time)
con.features = msg
#con.dpid = msg.dev_id
con.dpid = msg.deviceId #according to tianye
con.port_num_received = 0
if not connecting:
con.ofnexus._connect(con)
e = con.ofnexus.raiseEventNoErrors(FeaturesReceived, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(FeaturesReceived, con, msg)
return
#OpenFlowConnectionArbiter is defined and registered in openflow.__init__.py
nexus = core.OpenFlowConnectionArbiter.getNexus(
con) # nexus = core.openflow (class OpenFlowNexus)
#print ('fun handle_FEATURES_REPLY --> nexus', nexus) # cc
if nexus is None:
# Cancel connection
con.info("No OpenFlow nexus for " + pox.lib.util.dpidToStr(msg.dev_id))
con.disconnect()
return
con.ofnexus = nexus
con.ofnexus._connect(
con) # self._connections[con.dpid] = con (in class OpenFlowNexus)
#connections[con.dpid] = con
#barrier = of.ofp_barrier_request()
#con.send(barrier)
getGonfigReq = of.ofp_get_config_request()
listeners = []
def finish_connecting(event):
if event.xid != getGonfigReq.xid:
con.dpid = None
con.err("failed connect")
con.disconnect()
else:
"""
con.info("connected")
con.connect_time = time.time()
e = con.ofnexus.raiseEventNoErrors(ConnectionUp, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(ConnectionUp, con, msg)
"""
e = con.ofnexus.raiseEventNoErrors(FeaturesReceived, con, msg)
if e is None or e.halt != True:
con.raiseEventNoErrors(FeaturesReceived, con, msg)
con.removeListeners(listeners)
listeners.append(con.addListener(GetConfigReply, finish_connecting))
def also_finish_connecting(event):
if event.xid != getGonfigReq.xid: return
if event.ofp.type != of.OFPET_BAD_REQUEST: return
if event.ofp.code != of.OFPBRC_BAD_TYPE: return
# Okay, so this is probably an HP switch that doesn't support barriers
# (ugh). We'll just assume that things are okay.
finish_connecting(event)
listeners.append(con.addListener(ErrorIn, also_finish_connecting))
#TODO: Add a timeout for finish_connecting
#print ('con.ofnexus.miss_send_len',con.ofnexus.miss_send_len) #cc
if con.ofnexus.miss_send_len is not None:
#con.send(of.ofp_set_config(miss_send_len = con.ofnexus.miss_send_len))
con.send(of.ofp_set_config(miss_send_len=0xffff))
con.send(getGonfigReq)
