Golang的SSH客户端在检测OpenWrt v15会话终止时遇到问题

Golang的SSH客户端在检测OpenWrt v15会话终止时遇到问题 Go 标准 SSH 客户端库在识别旧版 OpenWrt SSH 会话终止时似乎存在问题，特别是 OpenWrt v15.05.1 Chaos Calmer 版本。当这种情况发生时，在客户端调用 Wait() 会导致 Go 无限期阻塞，或至少整夜阻塞数小时。例如，尝试使用 Go 语言的 packer 工具配合 SSH 配置脚本来设置 OpenWrt v15 虚拟箱时，packer 会在其代码中调用 Go SSH 客户端对象的 Wait() 时永远停滞。

值得一提的是，macOS SSH 客户端确实能识别 OpenWrt SSH 连接的终止，因此我怀疑 Go SSH 客户端的终止识别机制存在缺陷。此外，较新的 OpenWrt 版本 v17 LEDE 似乎能更成功地向 Go SSH 库传达 SSH 会话终止信息。所以我在想，是否 v17 之前的 OpenWrt 版本存在非标准行为，可能使用了 Go 库尚未考虑到的终止信号。

目前，我通过在处理 OpenWrt v15 时避免使用 Go SSH 客户端库来解决这个问题，例如配置 packer 通过 boot_command 发送 shell 脚本配置，而不是通过 SSH 配置。不过如果 Go 库能处理这种情况就更好了。


更多关于Golang的SSH客户端在检测OpenWrt v15会话终止时遇到问题的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于Golang的SSH客户端在检测OpenWrt v15会话终止时遇到问题的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


针对您在Go SSH客户端与OpenWrt v15.05.1交互时遇到的会话终止检测问题，这确实是一个已知的兼容性问题。旧版OpenWrt的SSH实现可能没有正确发送会话终止信号，导致Go的Session.Wait()方法无法检测到连接关闭。

以下是几种可行的解决方案：

方案1：使用带超时的上下文控制

package main

import (
    "context"
    "time"
    "golang.org/x/crypto/ssh"
)

func executeCommandWithTimeout(client *ssh.Client, command string, timeout time.Duration) error {
    session, err := client.NewSession()
    if err != nil {
        return err
    }
    defer session.Close()

    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    done := make(chan error, 1)
    
    go func() {
        done <- session.Run(command)
    }()

    select {
    case <-ctx.Done():
        return ctx.Err()
    case err := <-done:
        return err
    }
}

方案2：实现自定义会话监控

package main

import (
    "io"
    "time"
    "golang.org/x/crypto/ssh"
)

type monitoredSession struct {
    session *ssh.Session
    timeout time.Duration
}

func (ms *monitoredSession) Run(command string) error {
    if err := ms.session.Start(command); err != nil {
        return err
    }

    done := make(chan error, 1)
    go func() {
        done <- ms.session.Wait()
    }()

    timer := time.NewTimer(ms.timeout)
    defer timer.Stop()

    select {
    case err := <-done:
        return err
    case <-timer.C:
        return ms.session.Close()
    }
}

func createMonitoredSession(client *ssh.Client, timeout time.Duration) (*monitoredSession, error) {
    session, err := client.NewSession()
    if err != nil {
        return nil, err
    }
    return &monitoredSession{session: session, timeout: timeout}, nil
}

方案3：使用连接级别的心跳检测

package main

import (
    "net"
    "time"
    "golang.org/x/crypto/ssh"
)

func createSSHClientWithKeepalive(config *ssh.ClientConfig, addr string) (*ssh.Client, error) {
    conn, err := net.DialTimeout("tcp", addr, config.Timeout)
    if err != nil {
        return nil, err
    }

    sshConn, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
    if err != nil {
        return nil, err
    }

    client := ssh.NewClient(sshConn, chans, reqs)
    
    // 启动心跳检测
    go func() {
        ticker := time.NewTicker(30 * time.Second)
        defer ticker.Stop()
        
        for range ticker.C {
            _, _, err := client.SendRequest("keepalive@openssh.com", true, nil)
            if err != nil {
                client.Close()
                return
            }
        }
    }()
    
    return client, nil
}

方案4：组合使用超时和输出监控

package main

import (
    "bytes"
    "io"
    "time"
    "golang.org/x/crypto/ssh"
)

func executeCommandWithOutputMonitoring(client *ssh.Client, command string, timeout time.Duration) (string, error) {
    session, err := client.NewSession()
    if err != nil {
        return "", err
    }
    defer session.Close()

    var output bytes.Buffer
    session.Stdout = &output
    session.Stderr = &output

    if err := session.Start(command); err != nil {
        return "", err
    }

    done := make(chan error, 1)
    go func() {
        done <- session.Wait()
    }()

    select {
    case err := <-done:
        return output.String(), err
    case <-time.After(timeout):
        session.Close()
        return output.String(), &timeoutError{message: "command execution timeout"}
    }
}

type timeoutError struct {
    message string
}

func (e *timeoutError) Error() string {
    return e.message
}

这些方案通过添加超时控制、连接监控和输出检测，可以有效避免Go SSH客户端在OpenWrt v15环境下的无限阻塞问题。建议在实际部署时根据具体需求调整超时时间，通常设置为5-30秒的范围比较合适。

回到顶部