我有一些用于自定义协议(protocol)的 Go 客户端。该协议(protocol)是 lz4 压缩的 JSON-RPC，带有给出压缩 JSON 长度的四字节 header 。

func ReceiveMessage(conn net.Conn) ([]byte, error) {
    start := time.Now()
    bodyLen := 0
    body := make([]byte, 0, 4096)
    buf := make([]byte, 0, 256)

    for bodyLen == 0 || len(body) < bodyLen {
        if len(body) > 4 {
            header := body[:4]
            body = body[:4]
            bodyLen = int(unpack(header))
        }

        n, err := conn.Read(buf[:])
        if err != nil {
            if err != io.EOF {
                return body, err
            }
        }
        body = append(body, buf[0:n]...)

        now := time.Now()
        if now.Sub(start) > time.Duration(readTimeout) * time.Millisecond     {
            return body, fmt.Errorf("Timed-out while reading from socket.")
        }
        time.Sleep(time.Duration(1) * time.Millisecond)
    }

    return lz4.Decode(nil, body)
}

客户端:

func main() {
    address := os.Args[1]
    msg := []byte(os.Args[2])

    fmt.Printf("Sending %s to %s\n", msg, address)

    conn, err := net.Dial(address)
    if err != nil {
        fmt.Printf("%v\n", err)
        return
    }

    // Another library call
    _, err = SendMessage(conn, []byte(msg))
    if err != nil {
        fmt.Printf("%v\n", err)
        return
    }

    response, err := ReceiveMessage(conn)
    conn.Close()

    if err != nil {
        fmt.Printf("%v\n", err)
        return
    }

    fmt.Printf("Response: %s\n", response)
}

当我调用它时，我没有得到任何响应，它只是超时了。 (如果我没有明确忽略 EOF，它会返回 io.EOF 错误。)我有另一个用 Python 编写的库，它也适用于具有相同负载的相同端点。你立即看到什么了吗？

最佳答案

[JimB 抢在我之前给出了答案，但不管怎样，还是来了。]

根本问题是你做了 body = body[:4] 当你想要 body = body[4:] 时。 前者只保留头四个字节 而后者抛 刚刚解码的四个 header 字节。

这是一个带有一些调试日志的自包含版本 这样可行。 它具有我提到的其他一些变化。 (我猜了各种你没有包括的东西，比如使用的 lz4 包，超时，unpack 等等)

package main

import (
        "encoding/binary"
        "errors"
        "fmt"
        "io"
        "log"
        "net"
        "time"

        "github.com/bkaradzic/go-lz4"
)

const readTimeout = 30 * time.Second // XXX guess

func ReceiveMessage(conn net.Conn) ([]byte, error) {
        bodyLen := 0
        body := make([]byte, 0, 4096)
        var buf [256]byte

        conn.SetDeadline(time.Now().Add(readTimeout))
        defer conn.SetDeadline(time.Time{}) // disable deadline
        for bodyLen == 0 || len(body) < bodyLen {
                if bodyLen == 0 && len(body) >= 4 {
                        bodyLen = int(unpack(body[:4]))
                        body = body[4:]
                        if bodyLen <= 0 {
                                return nil, errors.New("invalid body length")
                        }
                        log.Println("read bodyLen:", bodyLen)
                        continue
                }

                n, err := conn.Read(buf[:])
                body = append(body, buf[:n]...)
                log.Printf("appended %d bytes, len(body) now %d", n, len(body))
                // Note, this is checked *after* handing any n bytes.
                // An io.Reader is allowed to return data with an error.
                if err != nil {
                        if err != io.EOF {
                                return nil, err
                        }
                        break
                }
        }
        if len(body) != bodyLen {
                return nil, fmt.Errorf("got %d bytes, expected %d",
                        len(body), bodyLen)
        }

        return lz4.Decode(nil, body)
}

const address = ":5678"

var msg = []byte(`{"foo":"bar"}`)

func main() {
        //address := os.Args[1]
        //msg := []byte(os.Args[2])

        fmt.Printf("Sending %s to %s\n", msg, address)

        conn, err := net.Dial("tcp", address)
        if err != nil {
                fmt.Printf("%v\n", err)
                return
        }

        // Another library call
        _, err = SendMessage(conn, msg)
        if err != nil {
                fmt.Printf("%v\n", err)
                return
        }

        response, err := ReceiveMessage(conn)
        conn.Close()

        if err != nil {
                fmt.Printf("%v\n", err)
                return
        }

        fmt.Printf("Response: %s\n", response)
}

// a guess at what your `unpack` does
func unpack(b []byte) uint32 {
        return binary.LittleEndian.Uint32(b)
}

func SendMessage(net.Conn, []byte) (int, error) {
        // stub
        return 0, nil
}

func init() {
        // start a simple test server in the same process as a go-routine.
        ln, err := net.Listen("tcp", address)
        if err != nil {
                log.Fatal(err)
        }
        go func() {
                defer ln.Close()
                for {
                        conn, err := ln.Accept()
                        if err != nil {
                                log.Fatalln("accept:", err)
                        }
                        go Serve(conn)
                }
        }()
}

func Serve(c net.Conn) {
        defer c.Close()
        // skip readding the initial request/message and just respond
        const response = `{"somefield": "someval"}`
        // normally (de)compression in Go is done streaming via
        // an io.Reader or io.Writer but we need the final length.
        data, err := lz4.Encode(nil, []byte(response))
        if err != nil {
                log.Println("lz4 encode:", err)
                return
        }
        log.Println("sending len:", len(data))
        if err = binary.Write(c, binary.LittleEndian, uint32(len(data))); err != nil {
                log.Println("writing len:", err)
                return
        }
        log.Println("sending data")
        if _, err = c.Write(data); err != nil {
                log.Println("writing compressed response:", err)
                return
        }
        log.Println("Serve done, closing connection")
}

Playground (但不能在那里运行)。

关于go - 在 Go 中作为客户端从服务器获取 EOF，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29928033/