如何使用ryu控制器向所有交换机发送数据包？

Question

我需要测量 Ryu 控制器中的链路延迟。我想通过控制器向所有交换机发送数据包输出消息，并计算发送数据包输出消息和接收数据包输入消息之间的时间。我是 Ryu 的初学者，不知道如何将具有特定 EtherType（例如 0x8fc）的数据包发送到所有交换机。我已经获取了所有交换机的MAC并构建了一个数据包。如何将具有特定 EtherType 的数据包发送到所有交换机？我不知道每个开关的db参数是什么？

    def send_packet(self, dp, port, pkt):
        ofproto = dp.ofproto
        parser = dp.ofproto_parser
        pkt.serialize()
        data = pkt.data
        action = [parser.OFPActionOutput(port=port)]

        out = parser.OFPPacketOut(
            datapath=dp, buffer_id=ofproto.OFP_NO_BUFFER,
            in_port=ofproto.OFPP_CONTROLLER,
            actions=action, data=data)
        dp.send_msg(out)

def create_packet(self):
        i=l=0
        for l in range(1,len(self.adjacency)+1):
            #print("\n")
            for i in self.adjacency[l]:
                ethertype = 0x8fc
                dst = self.macaddr(i)
                src = self.macaddr(l) 
                e = ethernet.ethernet(dst, src, ethertype)                
                p = packet.Packet()
                p.add_protocol(e)
                p.add_protocol(time.time())
                p.serialize()
                port=self.adjacency[l][i]
                send_packet(self, dp **??????** , port, p):

Answer 1

DP 是 DataPathID 的缩写，是网络中 OpenFlow 交换机的唯一 ID。

根据OpenFlow规范：

“datapath_id 字段唯一标识数据路径。下层 48 位用于交换机 MAC 地址，而前 16 位 由实施者决定。前 16 位的使用示例是 用于区分单个虚拟交换机实例的 VLAN ID 物理开关。”

如果您使用 Mininet，并且运行线性拓扑：

mn --controller remote --topo linear,3

您的拓扑将是：

s1 -- s2 -- s3

 |    |      |

h1    h2     h3

DataPathID 将是：

s1：0x0000000000000001

s2：0x0000000000000002

s3：0x0000000000000003

请注意，在其他测试平台中，该数字可能有所不同，但它们始终是 16 位十六进制数字。

Answer 2

我认为

p.add_protocol(time.time())

不会起作用。

创建一个协议类：

from ryu.lib.packet import packet_base, packet_utils


class timep(packet_base.PacketBase):
    _PACK_STR = '!I'
    _PACK_LEN = struct.calcsize(_PACK_STR)
    _MIN_LEN = _PACK_LEN + struct.calcsize(_CHECKSUM_STR)
    _TYPE = {}

    def __init__(self, timestamp, payload_len=0):
        super().__init__()
        self.timestamp = int(timestamp)
        self.payload_len = payload_len

    def __len__(self):
        return timep._PACK_LEN

    @classmethod
    def parser(cls, buf):
        (timestamp, payload_len) = struct.unpack_from(cls._PACK_STR, buf)
        payload = buf[ppdp._MIN_LEN : ppdp._MIN_LEN + payload_len]
        msg = cls(timestamp, payload_len)
        return msg, None, payload

    def serialize(self, payload, prev):
        length = len(self)
        buf = bytearray(length)
        self.payload_len = len(payload)
        
        struct.pack_into(ppdp._PACK_STR, buf, 0,
            self.timestamp,
            self.payload_len
        )
        return buf

不，你可以做

p.add_protocol(timep(time.time()))