def OF_packet_in_handler(self, event):
msg = event.msg
table_id = msg.table_id
if table_id in self.table_handlers:
handler = self.table_handlers[table_id]
handler(event)
else:
LOG.info(_LI("No handler for table id %s"), format(table_id))
def OF_packet_in_handler(self, event):
msg = event.msg
table_id = msg.table_id
if table_id in self.table_handlers:
handler = self.table_handlers[table_id]
handler(event)
else:
LOG.info("No handler for table id %(table)s with message "
"%(msg)", {'table': table_id, 'msg': msg})
def OF_packet_in_handler(self, event):
msg = event.msg
table_id = msg.table_id
if table_id in self.table_handlers:
handler = self.table_handlers[table_id]
with df_profiler.profiler_context('packet_in',
info={"func": handler.__name__}):
handler(event)
else:
LOG.info("No handler for table id %(table)s with message "
"%(msg)", {'table': table_id, 'msg': msg})
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while True:
ret = ""
try:
ret = self.socket.recv(required_len)
except:
# Hit socket timeout; decide what to do.
if self.close_requested:
pass
else:
continue
if (len(ret) == 0) or (self.close_requested):
self.socket.close()
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid,
buf[:msg_len])
# LOG.debug('queue msg %s cls %s', msg, msg.__class__)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [
handler for handler in self.ofp_brick.get_handlers(ev)
if self.state in dispatchers(handler)
]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while True:
ret = ""
try:
ret = self.socket.recv(required_len)
except:
# Hit socket timeout; decide what to do.
if self.close_requested:
pass
else:
continue
if (len(ret) == 0) or (self.close_requested):
self.socket.close()
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(
self, version, msg_type, msg_len, xid, buf[:msg_len])
# LOG.debug('queue msg %s cls %s', msg, msg.__class__)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [handler for handler in
self.ofp_brick.get_handlers(ev) if
self.state in dispatchers(handler)]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)
def register_event(self,msg):
if msg:
print "Datapath ", self.id, " current state 1: ", self.state, " message type: ", msg.msg_type
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [handler for handler in
self.ofp_brick.get_handlers(ev) if
self.state in dispatchers(handler)]
print "handlers: ", self.ofp_brick.get_handlers(ev)
for handler in handlers:
handler(ev)
print "Datapath ", self.id, " current state 2: ", self.state, " message type: ", msg.msg_type
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while self.is_active:
ret = self.socket.recv(required_len)
if len(ret) == 0:
self.is_active = False
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid,
buf)
#LOG.debug('queue msg %s cls %s', msg, msg.__class__)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
handlers = [
handler for handler in self.ofp_brick.get_handlers(ev)
if self.state in handler.dispatchers
]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)
def _recv_loop(self):
buf = bytearray()
required_len = oxproto_common.OXP_HEADER_SIZE
count = 0
while self.is_active:
ret = self.socket.recv(required_len)
if len(ret) == 0:
self.is_active = False
break
buf += ret
while len(buf) >= required_len:
# Parser.
(version, msg_type, msg_len, xid) = oxproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
# Wait for parsing
msg = oxproto_parser.msg(self, version, msg_type, msg_len, xid, buf)
if msg:
# LOG.info('queue msg %s cls %s', msg, msg.__class__)
ev = oxp_event.oxp_msg_to_ev(msg)
self.oxp_brick.send_event_to_observers(ev, self.state)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [
handler for handler in self.oxp_brick.get_handlers(ev) if self.state in dispatchers(handler)
]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = oxproto_common.OXP_HEADER_SIZE
count += 1
if count > 2048:
count = 0
hub.sleep(0)
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while self.is_active:
ret = self.socket.recv(required_len)
if len(ret) == 0:
self.is_active = False
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(self,
version, msg_type, msg_len, xid, buf)
#LOG.debug('queue msg %s cls %s', msg, msg.__class__)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
handlers = [handler for handler in
self.ofp_brick.get_handlers(ev) if
self.state in handler.dispatchers]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while self.is_active:
ret = self.socket.recv(required_len)
if len(ret) == 0:
self.is_active = False
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(self,
version, msg_type, msg_len, xid, buf)
# LOG.debug('queue msg %s cls %s', msg, msg.__class__)
# -------------------------- Fujitsu code start -----------------------------
# For optical enhancing
LOG.debug('receive data (dpid=%s) <%s> [%s]', str(self.id),
self.msgtype_dict.setdefault(msg_type, 'unknown(%d)' % msg_type),
binascii.hexlify(buf))
# debug mode (replace to flow_stats_reply message for debug)
if CONF.dbg_flow_stats_reply_path is not None and isinstance(msg, self.ofproto_parser.OFPFlowStatsReply):
buf_tmp = ''
bin_len = 0
try:
fl = open(CONF.dbg_flow_stats_reply_path)
bin_data = ''
for line in fl:
bin_data += line
bin_len = len(bin_data) // 2
buf_tmp = bytearray()
for i in range(0,bin_len):
buf_tmp.append(struct.pack("B", int(bin_data[i*2:i*2+2],16)))
except:
# not found data file. (default sequence)
LOG.debug("_recv_loop : flow-stats-reply-file(%s) open error.", CONF.dbg_flow_stats_reply_path)
if buf_tmp != '' :
msg = ofproto_parser.msg(self,
version, msg_type, bin_len, xid, buf_tmp)
LOG.debug('replace receive data(TEST DATA:%s) (dpid=%s) <OFPT_MULTIPART_REPLY> [%s]',
CONF.dbg_flow_stats_reply_path, str(self.id),
binascii.hexlify(buf_tmp))
# -------------------------- Fujitsu code end -------------------------------
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [handler for handler in
self.ofp_brick.get_handlers(ev) if
self.state in dispatchers(handler)]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)
