Question

我有两个服务在单独的Docker容器中运行，它们使用Gorilla Websocket在彼此之间发送消息。我可以一次发送一条消息，但是当我连续两次发送消息时，它们在一次读取过程中就到达了接收器，从而导致我的编组失败。

在发送方，我有一个循环，它发送两条消息：

for _, result := range results {
    greetingMsg := Message{
        TopicIdentifier: *bot.TopicIdentifier,
        UserIdentifier:  botIdentifier,
        Message:         result,
    }

    msgBytes, err := json.Marshal(greetingMsg)
    if err != nil {
        log.Println("Sender failed marshalling greeting message with error " + err.Error())
    }

    log.Printf("Sender writing %d bytes of message\n%s\n", len(msgBytes), string(msgBytes))
    err = conn.WriteMessage(websocket.TextMessage, msgBytes)

    if err != nil {
        log.Printf("Sender failed to send message\n%s\nwith error %s ", string(msgBytes), err.Error())
    }
}

按预期，在conn.WriteMessage（）调用之前，我得到了两个日志：

2019/12/12 06:23:29 agent.go:119: Sender writing 142 bytes of message
{"topicIdentifier":"7f7d12ea-cee8-4f05-943c-2e802638f075","userIdentifier":"753bcb8a-d378-422e-8a09-a2528565125d","message":"I am doing good"}

2019/12/12 06:23:29 agent.go:119: Sender writing 139 bytes of message
{"topicIdentifier":"7f7d12ea-cee8-4f05-943c-2e802638f075","userIdentifier":"753bcb8a-d378-422e-8a09-a2528565125d","message":"How are you?"}

在接收方，我正在听以下内容：

_, msg, err := conn.ReadMessage()
fmt.Printf("Receiver received %d bytes of message %s\n", len(msg), string(msg))

该日志消息产生：

2019/12/12 06:23:29 Receiver received 282 bytes of message  {"topicIdentifier":"83892f58b4b0-4303-8973-4896eed67ce0","userIdentifier":"119ba709-77a3-4b34-92f0-2187ecab7fc5","message":"I am doing good"}
{"topicIdentifier":"83892f58-b4b0-4303-8973-4896eed67ce0","userIdentifier":"119ba709-77a3-4b34-92f0-2187ecab7fc5","message":"How are you?"}

因此，对于发送方的两个conn.WriteMessage（）调用，我在接收方的conn.ReadMessage（）调用中获得一条消息，其中包含所有数据。

我认为这里存在某种竞争状况，因为有时接收者确实会按预期收到两条单独的消息，但这很少见。

这里是否缺少一些基本信息，还是我只需要对发送者/接收者进行一次额外的调用，一次只处理一条消息？

Answer 1

如果消息被缓冲，则一次接收到两个消息是正常的。问题是在接收端假设一次读取返回一条消息。

如您所见，读取可能会返回多个消息。而且，消息可能会拆分为多个读取。后者取决于消息的大小。只有您知道消息是什么以及如何定界。

您必须实现一个返回下一条消息的函数。这是一个建议的实现方式，假设消息读取的状态存储在结构中。

type MessageParser struct {
    buf []byte
    nBytes int
    conn ... 
}

func NewMessageParser(conn ...) *MessageParser {
    return &MessageParser{
        buf: make([]byte, 256) // best gess of longest message size
        conn: conn
    }
}

func (m *MessageParser) NextMessage() (string, error) {
    var nOpenBrakets, pos int
    var inString bool
    for {
        // scan m.buf to locate next message
        for pos < m.nBytes {
            if m.buf[pos] == '{' && !inString {
                nOpenBrakets++
            } else if m.buf[pos] == '}' && !inString {
                nOpenBrakets--
                if nOpenBrakets == 0 {
                    // we found a full message
                    msg := string(m.buf[:pos+1])
                    m.nBytes = copy(buf, buf[pos+1:m.nBytes)
                    return msg, nil
                }
            } else if m.buf[pos] == '"' {
                if !inString {
                    inString = true
                } else if pos > 0 && m.buf[pos-1] != '\\' {
                    inString = false
                }
            }
            pos++
        }
        // if a message is longer than the buffer capacity, grow the buffer
        if m.nBytes == len(m.buf) {
            temp := make([]byte, len(m.buf)*2)
            copy(temp, m.buf)
            m.buf = temp
        }
        // we didn’t find a full message, read more data
        n, err := conn.Read(m.buf[m.nBytes:]
        m.nBytes += n
        if n == 0 && err != nil {
            return "", err
        }
    }
}

Answer 2

如果您查看用于写函数的gorilla WebSockets代码

NextWriter returns a writer for the next message to send. The writer's Close
// method flushes the complete message to the network.

读者也有相同的实现。这似乎是正确的。也许就像@chmike所建议的那样，消息可能已被缓冲。

对于实现，您总是可以在消息末尾添加一个定界符，并在读取解析消息的过程中直到达到该定界符（以防消息溢出）

func writeString(conn *websocket.Conn, data []byte) {
conn.WriteMessage(1, append(data, "\r\n"...))
}

我试图复制相同的内容，但对我来说不起作用。在较低级别上，连接api通常使用c文件进行编译。您可以尝试使用“ -tags netgo”构建应用程序以完全使用go进行构建。

如何快速连续发送两个消息，一次接收全部

2 个答案: