Question

我正在关注本教程：

https://github.com/libp2p/go-libp2p-examples/tree/master/chat-with-mdns

简而言之：

配置p2p主机
设置传入连接的默认处理函数（3.不必要）
并向连接的对等方打开流：

stream, err := host.NewStream(ctx, peer.ID, protocol.ID(cfg.ProtocolID))

随后，将创建一个缓冲流/读写变量：

rw := bufio.NewReadWriter(bufio.NewReader(stream), bufio.NewWriter(stream))

现在，此流用于在同级之间发送和接收数据。这可以通过使用两个具有rw作为输入的goroutine函数来完成：

go writeData(rw) go readData(rw)

我的问题是：

我想向同伴发送数据并需要他们的反馈：例如在rw中，有一个问题，他们需要回答是/否。我如何才能转回该答案并进行处理（启用一些交互功能）？
我要在rw中发送的数据并不总是相同的。有时是仅包含名称的字符串，有时是包含整个块的字符串等。如何区分？

我想到了那些解决方案。但是我是golang的新手，所以也许您有一个更好的选择：

是否需要为每个不同的内容提供新的流： stream, err := host.NewStream(ctx, peer.ID, protocol.ID(cfg.ProtocolID))
是否需要为每个不同的内容打开更多的缓冲rw自变量： rw := bufio.NewReadWriter(bufio.NewReader(stream), bufio.NewWriter(stream))
还有其他解决方案吗？

谢谢您为解决此问题提供的帮助！

Answer 1

这是readData在您的tuto中所做的：

func readData(rw *bufio.ReadWriter) {
    for {
        str, err := rw.ReadString('\n')
        if err != nil {
            fmt.Println("Error reading from buffer")
            panic(err)
        }

        if str == "" {
            return
        }
        if str != "\n" {
            // Green console colour:    \x1b[32m
            // Reset console colour:    \x1b[0m
            fmt.Printf("\x1b[32m%s\x1b[0m> ", str)
        }

    }
}

它基本上会读取流，直到找到\n（这是换行符）并将其打印到stdout。

writeData：

func writeData(rw *bufio.ReadWriter) {
    stdReader := bufio.NewReader(os.Stdin)

    for {
        fmt.Print("> ")
        sendData, err := stdReader.ReadString('\n')
        if err != nil {
            fmt.Println("Error reading from stdin")
            panic(err)
        }

        _, err = rw.WriteString(fmt.Sprintf("%s\n", sendData))
        if err != nil {
            fmt.Println("Error writing to buffer")
            panic(err)
        }
        err = rw.Flush()
        if err != nil {
            fmt.Println("Error flushing buffer")
            panic(err)
        }
    }
}

它从stdin读取数据，因此您可以键入消息，并将其写入rw并刷新。这种启用某种tty聊天。如果它正常工作，则您应该至少可以启动两个同级并通过stdin进行通信。

您不应为新内容重新创建新的rw。您可以重用现有的，直到关闭它。根据Tuto的代码，为每个新对等方创建一个新的rw。

现在，tcp流不能用作带有请求和与该请求相对应的响应的http请求。因此，如果您要发送邮件并获得对特定问题的答复，则可以发送以下格式的消息：

[8 bytes unique ID][content of the message]\n

接收到该消息后，您将对其进行解析，准备响应并以相同的格式发送它，以便您可以匹配消息，从而创建一种请求/响应通信。

您可以执行以下操作：

func sendMsg(rw *bufio.ReadWriter, id int64, content []byte) error {
        // allocate our slice of bytes with the correct size 4 + size of the message + 1
        msg := make([]byte, 4 + len(content) + 1)

        // write id 
        binary.LittleEndian.PutUint64(msg, uint64(id))

        // add content to msg
        copy(msg[13:], content)

        // add new line at the end
        msg[len(msg)-1] = '\n'

        // write msg to stream
        _, err = rw.Write(msg)
        if err != nil {
            fmt.Println("Error writing to buffer")
            return err
        }
        err = rw.Flush()
        if err != nil {
            fmt.Println("Error flushing buffer")
            return err
        }
        return nil
}

func readMsg(rw *bufio.ReadWriter) {
    for {
        // read bytes until new line
        msg, err := rw.ReadBytes('\n')
        if err != nil {
            fmt.Println("Error reading from buffer")
            continue
        }

        // get the id
        id := int64(binary.LittleEndian.Uint64(msg[0:8]))

        // get the content, last index is len(msg)-1 to remove the new line char
        content := string(msg[8:len(msg)-1])

        if content != "" {
            // we print [message ID] content
            fmt.Printf("[%d] %s", id, content)
        }

        // here you could parse your message
        // and prepare a response
        response, err := prepareResponse(content)
        if err != nil {
            fmt.Println("Err while preparing response: ", err)
            continue
        }

        if err := s.sendMsg(rw, id, response); err != nil {
            fmt.Println("Err while sending response: ", err)
            continue
        }
    }
}

希望这会有所帮助。

如何使用libp2p处理与golang中的对等对象有关的缓冲读写流？

1 个答案: