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)