Comment envoyer plusieurs commandes en une seule session mais enregistrer les sorties séparément

Vérifiez ceci: https://github.com/yahoo/vssh Vous pouvez définir les sessions sur le nombre de commandes à exécuter simultanément, puis envoyer chaque commande à l'hôte distant via la méthode d'exécution et obtenir le résultat individuellement!

Cela fonctionne correctement:

package main

import (
    "bufio"
    "errors"
    "fmt"
    "log"
    "time"

    "golang.org/x/crypto/ssh"
)

func main() {

    // List of the commands should be sent to the devices
    listCMDs := []string{
        "set cli op-command-xml-output on\n",
        "test routing fib-lookup virtual-router default ip 1.1.1.1\n",
        "test routing fib-lookup virtual-router default ip 2.2.2.2\n",
        "show interface ethernet1/1\n",
        "show interface ethernet1/2\n",
        "test security-policy-match protocol 6 source 1.1.1.1 destination 2.2.2.2 destination-port 443 from ZONE1 to ZONE2\n",
        "test security-policy-match protocol 6 source 10.0.0.1 destination 10.0.2.1 destination-port 443 from ZONE1 to ZONE2\n",
        "exit",
    }

    sshconfig := InsecureClientConfig("admin", "Ghazanfar1!")

    s, _ := ExecCommands("192.168.1.249", listCMDs, sshconfig)

    for _, item := range s {
        fmt.Println(item)
        fmt.Println("-------------------------------")
    }
}

// ExecCommands ...
func ExecCommands(ipAddr string, commands []string, sshconfig *ssh.ClientConfig) ([]string, error) {

    // Gets IP, credentials and config/commands, SSH Config (Timeout, Ciphers, ...) and returns
    // output of the device as "string" and an error. If error == nil, means program was able to SSH with no issue

    // Creating outerr as Output Error.
    outerr := errors.New("nil")
    outerr = nil

    // Creating Output as String
    var outputStr []string
    var strTmp string

    // Dial to the remote-host
    client, err := ssh.Dial("tcp", ipAddr+":22", sshconfig)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    // Create sesssion
    session, err := client.NewSession()
    if err != nil {
        log.Fatal(err)
    }
    defer session.Close()

    // StdinPipee() returns a pipe that will be connected to the remote command's standard input when the command starts.
    // StdoutPipe() returns a pipe that will be connected to the remote command's standard output when the command starts.
    stdin, err := session.StdinPipe()
    if err != nil {
        log.Fatal(err)
    }

    stdout, err := session.StdoutPipe()
    if err != nil {
        log.Fatal(err)
    }

    // Start remote shell
    err = session.Shell()
    if err != nil {
        log.Fatal(err)
    }

    stdinLines := make(chan string)
    go func() {
        scanner := bufio.NewScanner(stdout)
        for scanner.Scan() {
            stdinLines <- scanner.Text()
        }
        if err := scanner.Err(); err != nil {
            log.Printf("scanner failed: %v", err)
        }
        close(stdinLines)
    }()

    // Send the commands to the remotehost one by one.
    for i, cmd := range commands {
        _, err := stdin.Write([]byte(cmd + "\n"))
        if err != nil {
            log.Fatal(err)
        }
        if i == len(commands)-1 {
            _ = stdin.Close() // send eof
        }

        // wait for command to complete
        // we'll assume the moment we've gone 1 secs w/o any output that our command is done
        timer := time.NewTimer(0)
    InputLoop:
        for {
            timer.Reset(time.Second)
            select {
            case line, ok := <-stdinLines:
                if !ok {
                    log.Println("Finished processing")
                    break InputLoop
                }
                strTmp += line
                strTmp += "\n"
            case <-timer.C:
                break InputLoop
            }
        }
        outputStr = append(outputStr, strTmp)
        //log.Printf("Finished processing %v\n", cmd)
        strTmp = ""
    }

    // Wait for session to finish
    err = session.Wait()
    if err != nil {
        log.Fatal(err)
    }

    return outputStr, outerr
}

// InsecureClientConfig ...
func InsecureClientConfig(userStr, passStr string) *ssh.ClientConfig {

    SSHconfig := &ssh.ClientConfig{
        User:    userStr,
        Timeout: 5 * time.Second,
        Auth:    []ssh.AuthMethod{ssh.Password(passStr)},

        HostKeyCallback: ssh.InsecureIgnoreHostKey(),
        Config: ssh.Config{
            Ciphers: []string{"aes128-ctr", "aes192-ctr", "aes256-ctr", "aes128-cbc", "aes192-cbc",
                "aes256-cbc", "3des-cbc", "des-cbc"},
            KeyExchanges: []string{"diffie-hellman-group1-sha1",
                "diffie-hellman-group-exchange-sha1",
                "diffie-hellman-group14-sha1"},
        },
    }
    return SSHconfig
}

Puisque vous avez un nombre limité de commandes à exécuter sur des matériels spéciaux et que vous connaissez le modèle de sortie de chaque commande, vous pouvez utiliser des strings.Split ou regexp pour diviser la sortie.
Et si vous n'avez pas de commande echo , mais que vous connaissez une commande avec une réponse rapide avec un modèle de sortie unique, vous pouvez la remplacer par la commande echo dans l'exemple suivant (numéro 2).

Depuis une session accepte un seul appel à Run , Start , Shell , Output ou CombinedOutput , et vous ne voulez pas commencer une nouvelle session par commande:

La clé est d'utiliser un strings.Builder et de le vider en utilisant sb.Reset() avant d'envoyer la commande, et en utilisant io.Copy pour copier simultanément le stdout de la session dans strings.Builder (en supposant que vous n'avez pas besoin de stderr de session):

sb := new(strings.Builder)
go io.Copy(sb, stdout)
commands := []string{"uname -a", "sleep 1", "pwd", "whoami"}
delim := "********--------========12345678"
for _, cmd := range commands {
    _, err = stdin.Write([]byte("echo " + delim + "\n"))
    if err != nil {
        log.Fatal(err)
    }
    _, err := stdin.Write([]byte(cmd + "\n"))
    if err != nil {
        log.Fatal(err)
    }
}
_, err = stdin.Write([]byte("exit\n"))
if err != nil {
    log.Fatal(err)
}
err = session.Wait() // Wait for session to exit
if err != nil {
    log.Fatal(err)
}
ans := strings.Split(sb.String(), delim)
ans = ans[1:] // remove ssh greetings

1. Cela fonctionne si vous savez combien attendre chaque commande (testée):

sb := new(strings.Builder)
go io.Copy(sb, stdout)

commands := []string{"uname -a", "sleep 1", "pwd", "whoami", "exit"}
wait := []time.Duration{10, 1200, 20, 10, 10} // * time.Millisecond
ans := []string{}

time.Sleep(10 * time.Millisecond) // wait for the ssh greetings

// Send the commands to the remotehost one by one.
for i, cmd := range commands {
    sb.Reset()
    fmt.Println("*** command:\t", cmd)
    _, err := stdin.Write([]byte(cmd + "\n"))
    if err != nil {
        log.Fatal(err)
    }
    time.Sleep(wait[i] * time.Millisecond) // wait for the command to finish
    s := sb.String()
    fmt.Println("*** response:\t", s)
    ans = append(ans, s)
}

2. Utilisation du délimiteur de chaîne et des strings.Split (Remarque: vous pouvez remplacer echo par n'importe quelle commande rapide avec un modèle de sortie connu):

sb := new(strings.Builder)
go io.Copy(sb, stdout)