Golang通过SSH执行交换机操作实现

package main

import (
  "bufio"
  "fmt"
  "golang.org/x/crypto/ssh"
  "log"
  "os"
  "strings"
  "sync"
)

//获取账号和密码的对应关系
type hostpassword struct {
  host string
  username string
  password string
}
var (
  a,b string //临时存储变量
  commands = []string{} //执行命令组
  hp []hostpassword //保存账号和密码
  wg sync.waitgroup  //执行goroutine

)
func main() {
  //1. 选择交换机
  //2. 输入要执行命令
  //3. 建立会话连接
  //4. 新建session，并执行命令

  //1. 选择操作交换机
  // 1.1 输入要执行交换机
  fmt.println("请输入计划执行命令的交换机账号和密码,账号密码直接使用|分割，多个账号密码之间使用;分割,例如admin;192.168.56.10;h3csw1|admin;192.168.56.11;h3csw2")
  _, err := fmt.scanln(&a)
  if err != nil {
    log.fatal("输入错误:",err)
  }
  fmt.println("请输入要执行的命令行，以；号间隔")
  //1.1.1切割交换机命令
  switchgroups := strings.split(a, "|")
  length := len(switchgroups)
  hp = make([]hostpassword,length)
  for i,singleswitch := range switchgroups{
    hp[i]=hostpassword{}
    switchsplit := strings.split(singleswitch, ";")
    hp[i].username=switchsplit[0]
    hp[i].host=switchsplit[1]
    hp[i].password=switchsplit[2]
  }

  // 1.2 输入要执行命令
  input := bufio.newreader(os.stdin)
  b, err := input.readstring('\n')
  if err != nil {
    log.fatal("输入错误",err)
  }
  commands = strings.split(b, ";")

  //2. 执行交换机操作
  err = sshswitch(hp)
  if err != nil {
    log.fatalln(err)
  }

  // 同步等待
  wg.wait()
}

//建立ssh连接
func sshswitch(hostpasswords []hostpassword) (error){
  //循环获取hostpasswords的账号和密码
  for i,_ := range hp{
    //添加同步组，下面会执行goroutin
    wg.add(1)
    config := &ssh.clientconfig{
      config:      ssh.config{
        ciphers:    []string{"aes128-ctr", "aes192-ctr", "aes256-ctr", "aes128-gcm@openssh.com", "arcfour256", "arcfour128", "aes128-cbc", "3des-cbc", "aes192-cbc", "aes256-cbc"},
      }, //添加了很多加密方式，为了应对不同的密码规则
      user:       hp[i].username,
      auth:       []ssh.authmethod{
        ssh.password(hp[i].password),
      },
      hostkeycallback:  ssh.insecureignorehostkey(), //此处相当于执行nil，但是并不安全
    }
    client, err := ssh.dial("tcp",hp[i].host+":22", config)
    if err != nil {
      log.fatalln("建立ssh连接错误:",err)
      return err
    }
    //执行goroutine，但是没有返回错误。
    go handlesession(client, commands,&wg)

  }
  return nil
}

//建立session，执行命令。
func handlesession(client *ssh.client,commands []string,wg *sync.waitgroup) error {
  //建立session
  session, err := client.newsession()
  if err != nil {
    log.fatalln("创建session出错",err)
    return err
  }
  //延迟关闭session
  defer session.close()

  //设置terminalmodes的方式
  modes := ssh.terminalmodes{
    ssh.echo:     0,   // disable echoing
    ssh.tty_op_ispeed: 14400, // input speed = 14.4kbaud
    ssh.tty_op_ospeed: 14400, // output speed = 14.4kbaud
  }
  //建立伪终端
  err = session.requestpty("xterm",80,40,modes)
  if err != nil {
    log.fatal("创建requestpty出错",err)
    return err
  }
  //设置session的标准输入是stdin
  stdin, err := session.stdinpipe()
  if err != nil {
    log.fatal("输入错误",err)
    return err
  }
  //设置session的标准输出和错误输出分别是os.stdout,os,stderr.就是输出到后台
  session.stdout = os.stdout
  session.stderr = os.stderr
  err = session.shell()
  if err != nil {
    log.fatal("创建shell出错",err)
    return err
  }
  //将命令依次执行
  for _, cmd := range commands {
    fmt.println(cmd)
    _, err = fmt.fprintf(stdin, "%s\n", cmd)
    if err != nil {
      log.fatal("写入stdin出错",err)
      return err
    }
  }

  //执行等待
  err = session.wait()
  if err != nil {
    log.fatal("等待session出错",err)
    return err
  }
  //减少同步组的次数
  wg.done()
  return nil
}