golang scp Datei mit Krypto/ssh

Question

Ich versuche, eine Remote-Datei über ssh Den folgenden Ansatz auf Shell

funktioniert

ssh hostname "tar cz /opt/local/folder" > folder.tar.gz 

jedoch der gleiche Ansatz auf golang zum Download einiger Unterschiede in der Ausgabe Artefakt Größe zu geben. Zum Beispiel die gleichen Ordner mit reiner Shell produzieren Artefakt gz-Datei 179B und das gleiche mit go Skript 178B. Ich nehme an, dass etwas von io.Reader oder Sitzung wurde früher geschlossen wurde geschlossen. Bitte bittet euch, zu helfen.

Hier ist das Beispiel meines Skript:

func executeCmd(cmd, hostname string, config *ssh.ClientConfig, path string) error { 
    conn, _ := ssh.Dial("tcp", hostname+":22", config) 
    session, err := conn.NewSession() 
    if err != nil { 
     panic("Failed to create session: " + err.Error()) 
    } 

    r, _ := session.StdoutPipe() 
    scanner := bufio.NewScanner(r) 

    go func() { 
     defer session.Close() 

     name := fmt.Sprintf("%s/backup_folder_%v.tar.gz", path, time.Now().Unix()) 
     file, err := os.OpenFile(name, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644) 
     if err != nil { 
      panic(err) 
     } 
     defer file.Close() 
     for scanner.Scan() { 
      fmt.Println(scanner.Bytes()) 
      if err := scanner.Err(); err != nil { 
       fmt.Println(err) 
      } 

      if _, err = file.Write(scanner.Bytes()); err != nil { 
       log.Fatal(err) 

      } 
     } 
    }() 

    if err := session.Run(cmd); err != nil { 
     fmt.Println(err.Error()) 
     panic("Failed to run: " + err.Error()) 
    } 

    return nil 
} 

Dank!

Answer 1

bufio.Scanner ist für durch Zeilentrennzeichen getrennter Text. Laut der Dokumentation entfernt der Scanner die Newline-Zeichen und entfernt alle 10 s aus Ihrer Binärdatei.

Sie benötigen keine Goroutine, um die Kopie zu erstellen, da Sie session.Start verwenden können, um den Prozess asynchron zu starten.

Sie müssen wahrscheinlich auch nicht bufio verwenden. Sie sollten io.Copy verwenden, um die Datei zu kopieren, die bereits über einen Puffer verfügt, der bereits im ssh-Client selbst gepuffert wurde. Wenn ein zusätzlicher Puffer für die Leistung benötigt wird, müssen Sie die Session-Ausgabe in eine bufio.Reader

schlüpfen. Schließlich geben Sie einen Fehlerwert zurück, also verwenden Sie ihn lieber als Panik bei normalen Fehlerbedingungen.

conn, err := ssh.Dial("tcp", hostname+":22", config) 
if err != nil { 
    return err 
} 

session, err := conn.NewSession() 
if err != nil { 
    return err 
} 
defer session.Close() 

r, err := session.StdoutPipe() 
if err != nil { 
    return err 
} 

name := fmt.Sprintf("%s/backup_folder_%v.tar.gz", path, time.Now().Unix()) 
file, err := os.OpenFile(name, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644) 
if err != nil { 
    return err 
} 
defer file.Close() 

if err := session.Start(cmd); err != nil { 
    return err 
} 

n, err := io.Copy(file, r) 
if err != nil { 
    return err 
} 

if err := session.Wait(); err != nil { 
    return err 
} 

return nil 

Answer 2

können Sie versuchen, so etwas wie tun:

r, _ := session.StdoutPipe() 
reader := bufio.NewReader(r) 

go func() { 
    defer session.Close() 
    // open file etc 

    // 10 is the number of bytes you'd like to copy in one write operation 
    p := make([]byte, 10) 
    for { 
     n, err := reader.Read(p) 
     if err == io.EOF { 
      break 
     } 
     if err != nil { 
      log.Fatal("err", err) 
     } 

     if _, err = file.Write(p[:n]); err != nil { 
      log.Fatal(err) 
     } 
    } 
}() 

Stellen Sie sicher, dass Ihre goroutines synchronisiert richtig so Ausgabe completeky in die Datei geschrieben wird.