go实现ssh远程机器并传输文件

 项目目录结构：

 sshtool.go：

package ssh_tool

import (
	"flag"
	"fmt"
	"github.com/pkg/sftp"
	"golang.org/x/crypto/ssh"
	"io"
	"log"
	"net"
	"os"
	"path"
	"time"
)

// SshClient ssh客户端对象 /*
type SshClient struct {
	username string
	password string
	host string
	Client * ssh.Client
}

func (sshClient * SshClient) NewSshClient() *ssh.Client{
	flag.StringVar(&sshClient.username,"username","root","通过ssh2登录linux的用户名")
	flag.StringVar(&sshClient.password,"password","root","通过ssh2登录linux的密码")
	flag.StringVar(&sshClient.host,"host","192.168.56.25","通过ssh2登录linux的ip地址")
	flag.Parse()

	log.Println(sshClient.password)

	auth := make([]ssh.AuthMethod, 0)
	auth = append(auth, ssh.Password(sshClient.password))

	clientConfig := &ssh.ClientConfig{
		User:    sshClient.username,
		Auth:    auth,
		Timeout: 30 * time.Second,
		HostKeyCallback: func(hostname string, remote net.Addr, key ssh.PublicKey) error {
			return nil
		},
	}

	addr := sshClient.host + ":22"
	client, err := ssh.Dial("tcp", addr, clientConfig) //连接ssh
	if err != nil {
		log.Fatal("连接ssh失败", err)
	}

	sshClient.Client = client
	return client
}

func (sshClient * SshClient) RunCmd(cmd string) string {
	session, err := sshClient.Client.NewSession()
	if err != nil{
		panic(err)
	}
	defer session.Close()

	runResult,err := session.CombinedOutput(cmd)
	if err != nil{
		panic(err)
	}
	return string(runResult)
}


func (sshClient * SshClient) UploadFile(localPath string, remoteDir string, remoteFileName string){
	ftpClient, err := sftp.NewClient(sshClient.Client)
	if err != nil {
		fmt.Println("创建ftp客户端失败", err)
		panic(err)
	}

	defer ftpClient.Close()

	fmt.Println(localPath, remoteFileName)
	srcFile, err := os.Open(localPath)
	if err != nil {
		fmt.Println("打开文件失败", err)
		panic(err)
	}
	defer srcFile.Close()

	dstFile, e := ftpClient.Create(path.Join(remoteDir, remoteFileName))
	if e != nil {
		fmt.Println("创建文件失败", e)
		panic(e)
	}
	defer dstFile.Close()

	buffer := make([]byte, 1024000)
	for {
		n, err := srcFile.Read(buffer)
		dstFile.Write(buffer[:n])
		//注意，由于文件大小不定，不可直接使用buffer，否则会在文件末尾重复写入，以填充1024的整数倍
		if err != nil {
			if err == io.EOF {
				fmt.Println("已读取到文件末尾")
				break
			} else {
				fmt.Println("读取文件出错", err)
				panic(err)
			}
		}
	}
}

func (sshClient * SshClient) DownloadFile(remotePath string, localDir string , localFilename string)  {
	ftpClient, err := sftp.NewClient(sshClient.Client)
	if err != nil {
		fmt.Println("创建ftp客户端失败", err)
		panic(err)
	}

	defer ftpClient.Close()

	srcFile, err := ftpClient.Open(remotePath)
	if err != nil {
		fmt.Println("文件读取失败", err)
		panic(err)
	}
	defer srcFile.Close()

	dstFile, e := os.Create(path.Join(localDir, localFilename))
	if e != nil {
		fmt.Println("文件创建失败", e)
		panic(e)
	}
	defer dstFile.Close()
	if _, err1 := srcFile.WriteTo(dstFile); err1 != nil {
		fmt.Println("文件写入失败", err1)
		panic(err1)
	}
	fmt.Println("文件下载成功")
}

const_values.go： 

package constkv

const (
	MSG_CODE_KEY = "code"
	MSG_CONTENT_KEY = "msg"
)

SSHRemote.go： 

package main

import (
	"SSH/constkv"
	"SSH/ssh_tool"
	"bufio"
	"encoding/json"
	"io"
	"log"
	"net/http"
)

var (
	sshClient = new(ssh_tool.SshClient)
	buffer = make([]byte,10240)
)

func handlerCmd(writer http.ResponseWriter, request *http.Request) {
	var resultMap = make(map[string]interface{})
	//处理错误的panic
	defer func() {
		err := recover()
		if err != nil{
			resultMap[constkv.MSG_CODE_KEY] = http.StatusOK
			resultMap[constkv.MSG_CONTENT_KEY] = err.(error).Error()
			bytes, _ := json.Marshal(&resultMap)
			writer.Write(bytes)
		}
	}()

	var bufferSlice = make([]byte,0)

	reader := request.Body
	bufferReader := bufio.NewReader(reader)

	for {
		length, err := bufferReader.Read(buffer)
		bufferSlice = append(bufferSlice,buffer[:length]...)
		if err == io.EOF{
			break
		}
	}

	log.Println(string(bufferSlice))
	var paramMap = make(map[string]interface{})
	_ = json.Unmarshal(bufferSlice, &paramMap)

	log.Println(paramMap["cmd"])
	cmd := paramMap["cmd"]
	log.Println(cmd.(string) + "--------------------")

	if sshClient.Client != nil{
		runCmd := sshClient.RunCmd(cmd.(string))
		resultMap[constkv.MSG_CODE_KEY] = http.StatusOK
		resultMap[constkv.MSG_CONTENT_KEY] = runCmd
	}

	bytes, _ := json.Marshal(&resultMap)
	_ , _ = writer.Write(bytes)
}

func handleUploadFile(writer http.ResponseWriter, request *http.Request)  {
	var resultMap = make(map[string]interface{})
	//处理错误的panic
	defer func() {
		err := recover()
		if err != nil{
			resultMap[constkv.MSG_CODE_KEY] = http.StatusOK
			resultMap[constkv.MSG_CONTENT_KEY] = err.(error).Error()
			bytes, _ := json.Marshal(&resultMap)
			writer.Write(bytes)
		}

	}()
	var bufferSlice = make([]byte,0)
	reader := request.Body
	bufferReader := bufio.NewReader(reader)

	for {
		length, err := bufferReader.Read(buffer)
		bufferSlice = append(bufferSlice,buffer[:length]...)
		if err == io.EOF{
			break
		}
	}

	log.Println(string(bufferSlice))
	var paramMap = make(map[string]interface{})
	_ = json.Unmarshal(bufferSlice, &paramMap)

	localPath := paramMap["localPath"]
	remoteDir := paramMap["remoteDir"]
	remoteFileName := paramMap["remoteFileName"]

	log.Println(localPath)
	log.Println(remoteDir)

	sshClient.UploadFile(localPath.(string),remoteDir.(string),remoteFileName.(string))
}

func handleDownloadFile(writer http.ResponseWriter, request *http.Request)  {
	var resultMap = make(map[string]interface{})
	//处理错误的panic
	defer func() {
		err := recover()
		if err != nil{
			resultMap[constkv.MSG_CODE_KEY] = http.StatusOK
			resultMap[constkv.MSG_CONTENT_KEY] = err.(error).Error()
			bytes, _ := json.Marshal(&resultMap)
			writer.Write(bytes)
		}

	}()
	var bufferSlice = make([]byte,0)
	reader := request.Body
	bufferReader := bufio.NewReader(reader)

	for {
		length, err := bufferReader.Read(buffer)
		bufferSlice = append(bufferSlice,buffer[:length]...)
		if err == io.EOF{
			break
		}
	}

	log.Println(string(bufferSlice))
	var paramMap = make(map[string]interface{})
	_ = json.Unmarshal(bufferSlice, &paramMap)

	remotePath := paramMap["remotePath"]
	localDir := paramMap["localDir"]
	localFileName := paramMap["localFileName"]

	log.Println(remotePath)
	log.Println(localDir)
	log.Println(localFileName)

	sshClient.DownloadFile(remotePath.(string),localDir.(string),localFileName.(string))
}

func main(){
	//初始化ssh客户端
	sshClient.NewSshClient()
	//1.注册一个给定模式的处理器函数到DefaultServeMux
	http.HandleFunc("/", handlerCmd)
	http.HandleFunc("/uploadFile", handleUploadFile)
	http.HandleFunc("/downloadFile", handleDownloadFile)

	//2.设置监听的TCP地址并启动服务
	//参数1：TCP地址(IP+Port)
	//参数2：当设置为nil时表示使用DefaultServeMux
	err := http.ListenAndServe(":8080", nil)
	log.Fatal(err)
}