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 _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)