def handle_event(self, header, msg):
#required_len = self.ofp.OFP_HEADER_SIZE
ret = bytearray(msg)
(version, msg_type, msg_len, xid) = ofproto_parser.header(ret)
self.netide_xid = header[NetIDEOps.NetIDE_header['XID']]
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid, ret)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
event_observers = self.ofp_brick.get_observers(ev,self.state)
module_id = header[NetIDEOps.NetIDE_header['MOD_ID']]
for key, value in self.channel.running_modules.iteritems():
if value == module_id and key in event_observers:
module_brick = ryu.base.app_manager.lookup_service_brick(key)
module_brick_handlers = module_brick.get_handlers(ev)
for handler in module_brick_handlers:
handler(ev)
break
# Sending the FENCE message to the Core only if self.netide_xid is not 0
if self.netide_xid is not 0:
msg_to_send = NetIDEOps.netIDE_encode('NETIDE_FENCE', self.netide_xid, module_id, 0, "")
self.channel.socket.send(msg_to_send)
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)
# Resetting netide_xid to zero
self.netide_xid = 0
def _recv_loop(self):
buf = bytearray()
required_len = ofproto.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__)
self.ev_q.queue(ofp_event.ofp_msg_to_ev(msg))
buf = buf[required_len:]
required_len = ofproto.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
gevent.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__)
self.ev_q.queue(ofp_event.ofp_msg_to_ev(msg))
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
gevent.sleep(0)
def handle_event(self, header, msg):
#required_len = self.ofp.OFP_HEADER_SIZE
ret = bytearray(msg)
(version, msg_type, msg_len, xid) = ofproto_parser.header(ret)
self.netide_xid = header[NetIDEOps.NetIDE_header['XID']]
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid, ret)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
event_observers = self.ofp_brick.get_observers(ev,self.state)
module_id = header[NetIDEOps.NetIDE_header['MOD_ID']]
for key, value in self.channel.running_modules.iteritems():
if value == module_id and key in event_observers:
module_brick = ryu.base.app_manager.lookup_service_brick(key)
module_brick_handlers = module_brick.get_handlers(ev)
for handler in module_brick_handlers:
handler(ev)
break
# Sending the FENCE message to the Core only if self.netide_xid is not 0
if self.netide_xid is not 0:
msg_to_send = NetIDEOps.netIDE_encode('NETIDE_FENCE', self.netide_xid, module_id, 0, "")
self.channel.socket.send(msg_to_send)
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)
# Resetting netide_xid to zero
self.netide_xid = 0
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while self.state != DEAD_DISPATCHER:
ret = ""
try:
ret = self.socket.recv(required_len)
except SocketTimeout:
continue
except ssl.SSLError:
# eventlet throws SSLError (which is a subclass of IOError)
# on SSL socket read timeout; re-try the loop in this case.
continue
except (EOFError, IOError):
break
if len(ret) == 0:
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 _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while self.state != DEAD_DISPATCHER:
ret = ""
try:
ret = self.socket.recv(required_len)
except SocketTimeout:
continue
except ssl.SSLError:
# eventlet throws SSLError (which is a subclass of IOError)
# on SSL socket read timeout; re-try the loop in this case.
continue
except (EOFError, IOError):
break
if len(ret) == 0:
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 handle_event(self, header, msg, of_proto):
#required_len = self.ofp.OFP_HEADER_SIZE
ret = bytearray(msg)
(version, msg_type, msg_len, xid) = ofproto_parser.header(ret)
self.netide_xid = header[NetIDEOps.NetIDE_header['XID']]
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid, ret)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
event_observers = self.ofp_brick.get_observers(ev, self.state)
module_id = header[NetIDEOps.NetIDE_header['MOD_ID']]
for key, value in self.channel.running_modules.iteritems():
if value == module_id and key in event_observers:
module_brick = ryu.base.app_manager.lookup_service_brick(
key)
module_brick_handlers = module_brick.get_handlers(ev)
for handler in module_brick_handlers:
handler(ev)
break
# Sending the FENCE message to the Core only if self.netide_xid is not 0
if self.netide_xid is not 0:
msg_to_send = NetIDEOps.netIDE_encode('NETIDE_FENCE',
self.netide_xid,
module_id, 0, "")
self.channel.socket.send(msg_to_send)
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:
# we record that we received a feature reply from that specific device
if msg_type == of_proto.OFPT_FEATURES_REPLY:
self.datapath_init[msg.datapath.id] = True
# we do not allow multipart messages until the feature_reply has been received (needed for OF1.3 or higher)
if of_proto.OFP_VERSION >= 0x04:
if msg_type == of_proto.OFPT_MULTIPART_REPLY and msg.datapath.id not in self.datapath_init:
break
handler(ev)
# Resetting netide_xid to zero
self.netide_xid = 0
def handle_event(self, header, msg, of_proto):
#required_len = self.ofp.OFP_HEADER_SIZE
ret = bytearray(msg)
(version, msg_type, msg_len, xid) = ofproto_parser.header(ret)
self.netide_xid = header[NetIDEOps.NetIDE_header['XID']]
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid, ret)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
event_observers = self.ofp_brick.get_observers(ev,self.state)
module_id = header[NetIDEOps.NetIDE_header['MOD_ID']]
for key, value in self.channel.running_modules.iteritems():
if value == module_id and key in event_observers:
module_brick = ryu.base.app_manager.lookup_service_brick(key)
module_brick_handlers = module_brick.get_handlers(ev)
for handler in module_brick_handlers:
handler(ev)
break
# Sending the FENCE message to the Core only if self.netide_xid is not 0
if self.netide_xid is not 0:
msg_to_send = NetIDEOps.netIDE_encode('NETIDE_FENCE', self.netide_xid, module_id, 0, "")
self.channel.socket.send(msg_to_send)
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:
# we record that we received a feature reply from that specific device
if msg_type == of_proto.OFPT_FEATURES_REPLY:
self.datapath_init[msg.datapath.id] = True
# we do not allow multipart messages until the feature_reply has been received (needed for OF1.3 or higher)
if of_proto.OFP_VERSION >= 0x04:
if msg_type == of_proto.OFPT_MULTIPART_REPLY and msg.datapath.id not in self.datapath_init:
break
handler(ev)
# Resetting netide_xid to zero
self.netide_xid = 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()
count = 0
min_read_len = remaining_read_len = ofproto_common.OFP_HEADER_SIZE
while self.state != DEAD_DISPATCHER:
try:
read_len = min_read_len
if remaining_read_len > min_read_len:
read_len = remaining_read_len
ret = self.socket.recv(read_len)
except SocketTimeout:
continue
except ssl.SSLError:
# eventlet throws SSLError (which is a subclass of IOError)
# on SSL socket read timeout; re-try the loop in this case.
continue
except (EOFError, IOError):
break
if not ret:
break
buf += ret
buf_len = len(buf)
while buf_len >= min_read_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
if msg_len < min_read_len:
# Someone isn't playing nicely; log it, and try something sane.
LOG.debug(
"Message with invalid length %s received from switch at address %s",
msg_len, self.address)
msg_len = min_read_len
if buf_len < msg_len:
remaining_read_len = (msg_len - buf_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)
def dispatchers(x):
return 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[msg_len:]
buf_len = len(buf)
remaining_read_len = min_read_len
# 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 dispatch(self, msg):
self.ev_q.queue(ofp_event.ofp_msg_to_ev(msg))
def _recv_loop(self):
buf = bytearray()
count = 0
min_read_len = remaining_read_len = ofproto_common.OFP_HEADER_SIZE
while self.state != DEAD_DISPATCHER:
try:
read_len = min_read_len
if (remaining_read_len > min_read_len):
read_len = remaining_read_len
ret = self.socket.recv(read_len)
except SocketTimeout:
continue
except ssl.SSLError:
# eventlet throws SSLError (which is a subclass of IOError)
# on SSL socket read timeout; re-try the loop in this case.
continue
except (EOFError, IOError):
break
if len(ret) == 0:
break
buf += ret
buf_len = len(buf)
while buf_len >= min_read_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
if (msg_len < min_read_len):
# Someone isn't playing nicely; log it, and try something sane.
LOG.debug("Message with invalid length %s received from switch at address %s",
msg_len, self.address)
msg_len = min_read_len
if buf_len < msg_len:
remaining_read_len = (msg_len - buf_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[msg_len:]
buf_len = len(buf)
remaining_read_len = min_read_len
# 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)
