异常高的TCP连接超时错误量

Question

我正在使用Go TCP Client连接到我们的Go TCP服务器。

我能够连接到服务器并正确运行命令，但在尝试连接到我们的TCP服务器或连接后发送消息时，我的TCP客户端经常会报告异常大量的连续TCP连接错误：

dial tcp kubernetes_node_ip:exposed_kubernetes_port:
connectex: A connection attempt failed because the connected party did not properly
respond after a period of time, or established connection failed because connected
host has failed to respond.

read tcp unfamiliar_ip:unfamiliar_port->kubernetes_node_ip:exposed_kubernetes_port
wsarecv: A connection attempt failed because the connected party did not properly
respond after a period of time, or established connection failed because connected
host has failed to respond.

我说“异常高”，因为我认为这些错误发生的次数应该非常小（一小时内约为5或更少）。请注意，我并不认为这可能是由连接不稳定引起的，因为我也注意到可以快速连续运行几个命令而没有任何错误。

但是，我仍然会发布我的代码以防我做错了。

以下是我的TCP客户端用于连接到我们服务器的代码：

serverAddress, err := net.ResolveTCPAddr("tcp", kubernetes_ip+":"+kubernetes_port)
if err != nil {     
    fmt.Println(err)
    return
}

// Never stop asking for commands from the user.
for {
    // Connect to the server.
    serverConnection, err := net.DialTCP("tcp", nil, serverAddress)
    if err != nil {         
        fmt.Println(err)
        continue
    }

    defer serverConnection.Close()

    // Added to prevent connection timeout errors, but doesn't seem to be helping
    // because said errors happen within just 1 or 2 minutes.
    err = serverConnection.SetDeadline(time.Now().Add(10 * time.Minute))
    if err != nil {         
        fmt.Println(err)
        continue
    }

    // Ask for a command from the user and convert to JSON bytes...

    // Send message to server.
    _, err = serverConnection.Write(clientMsgBytes)
    if err != nil {
        err = merry.Wrap(err)
        fmt.Println(merry.Details(err))
        continue
    }

    err = serverConnection.CloseWrite()
    if err != nil {
        err = merry.Wrap(err)
        fmt.Println(merry.Details(err))
        continue
    }

    // Wait for a response from the server and print...
}

下面是我们的TCP服务器用于接受客户端请求的代码：

// We only supply the port so the IP can be dynamically assigned:
serverAddress, err := net.ResolveTCPAddr("tcp", ":"+server_port)
if err != nil {     
    return err
}

tcpListener, err := net.ListenTCP("tcp", serverAddress)
if err != nil {     
    return err
}

defer tcpListener.Close()

// Never stop listening for client requests.
for {
    clientConnection, err := tcpListener.AcceptTCP()
    if err != nil {         
        fmt.Println(err)
        continue
    }

    go func() {
        // Add client connection to Job Queue.
        // Note that `clientConnections` is a buffered channel with a size of 1500.
        // Since I am the only user connecting to our server right now, I do not think
        // this is a channel blocking issue.
        clientConnections <- clientConnection
    }()
}

以下是我们的TCP服务器用于处理客户端请求的代码：

defer clientConnection.Close()

// Added to prevent connection timeout errors, but doesn't seem to be helping
// because said errors happen within just 1 or 2 minutes.
err := clientConnection.SetDeadline(time.Now().Add(10 * time.Minute))
if err != nil {     
    return err
}

// Read full TCP message.
// Does not stop until an EOF is reported by `CloseWrite()`
clientMsgBytes, err := ioutil.ReadAll(clientConnection)
if err != nil {
    err = merry.Wrap(err)
    return nil, err
}

// Process the message bytes...

我的问题是：

1. 我在上面的代码中做错了什么，或者对于基本的TCP客户端 - 服务器操作是否足够好？
2. TCP客户端和TCP服务器的代码是否可以延迟关闭一个连接？
3. 我似乎记得在循环中调用defer什么都不做。如何在启动新连接之前正确关闭客户端连接？

一些额外的信息：

• TCP服务器不会记录所述错误，因此除了连接不稳定性之外，这也可能是与Kubernetes / Docker相关的问题。

Answer 1

看起来这段代码并没有像你想象的那样发挥作用。连接关闭的延迟语句只会在函数返回时发生，而不是在迭代结束时发生。所以，就我在这里看到的，你在客户端创建了很多连接，这可能是问题所在。

serverAddress, err := net.ResolveTCPAddr("tcp", kubernetes_ip+":"+kubernetes_port)
if err != nil {     
    fmt.Println(err)
    return
}

// Never stop asking for commands from the user.
for {
    // Connect to the server.
    serverConnection, err := net.DialTCP("tcp", nil, serverAddress)
    if err != nil {         
        fmt.Println(err)
        continue
    }

    defer serverConnection.Close()

    // Added to prevent connection timeout errors, but doesn't seem to be helping
    // because said errors happen within just 1 or 2 minutes.
    err = serverConnection.SetDeadline(time.Now().Add(10 * time.Minute))
    if err != nil {         
        fmt.Println(err)
        continue
    }

    // Ask for a command from the user and send to the server...

    // Wait for a response from the server and print...
}

我建议这样写：

func start() {
    serverAddress, err := net.ResolveTCPAddr("tcp", kubernetes_ip+":"+kubernetes_port)
    if err != nil {     
        fmt.Println(err)
        return
    }
    for {
        if err := listen(serverAddress); err != nil {
            fmt.Println(err)
        }
    }
}

func listen(serverAddress string) error {
     // Connect to the server.
     serverConnection, err := net.DialTCP("tcp", nil, serverAddress)
     if err != nil {         
         fmt.Println(err)
         continue
     }

    defer serverConnection.Close()

    // Never stop asking for commands from the user.
    for {
        // Added to prevent connection timeout errors, but doesn't seem to be helping
        // because said errors happen within just 1 or 2 minutes.
        err = serverConnection.SetDeadline(time.Now().Add(10 * time.Minute))
        if err != nil {         
           fmt.Println(err)
           return err
        }

        // Ask for a command from the user and send to the server...

        // Wait for a response from the server and print...
    }
}

此外，您应该保持单个连接打开或连接池，而不是立即打开和关闭连接。然后，当您发送消息时，您将从池（或单个连接）获得连接，并编写消息并等待响应，然后释放与池的连接。

像这样的东西：

res, err := c.Send([]byte(`my message`))
if err != nil {
    // handle err
}

// the implementation of send
func (c *Client) Send(msg []byte) ([]byte, error) {
    conn, err := c.pool.Get() // returns a connection from the pool or starts a new one
    if err != nil {
        return nil, err
    }
    // send your message and wait for response
    // ...
    return response, nil
}