Golang Session.Start方法代码示例

func (cmd *command) StartCommand() (error, *ssh.Session) {
	var (
		session *ssh.Session
		err     error
	)

	z := cmd.zh

	// open ssh link
	if z.client == nil {
		if err = z.dialSSH(); err != nil {
			return err, nil
		}
	}

	// establish ssh session
	if session, err = z.client.NewSession(); err != nil {
		return err, nil
	}

	// setup env, stdin, stdout, stderr
	if err = prepareCommand(session, cmd); err != nil {
		return err, nil
	}

	// start remote command
	err = session.Start(cmd.Path)
	if err == nil {
		return err, session
	}
	return err, nil
}

func pipe(ch ssh.Channel, client *ssh.Client, session *ssh.Session, command string) (int, error) {
	targetStderr, err := session.StderrPipe()
	if err != nil {
		return -1, errors.New("fail to pipe stderr: " + err.Error())
	}
	targetStdout, err := session.StdoutPipe()
	if err != nil {
		return -1, errors.New("fail to pipe stdout: " + err.Error())
	}
	targetStdin, err := session.StdinPipe()
	if err != nil {
		return -1, errors.New("fail to pipe stdin: " + err.Error())
	}

	go io.Copy(targetStdin, ch)
	go io.Copy(ch.Stderr(), targetStderr)
	go io.Copy(ch, targetStdout)

	err = session.Start(command)
	if err != nil {
		ch.Write([]byte("Error when starting '" + command + "': " + err.Error()))
		ch.Close()
	}

	err = session.Wait()
	if err != nil {
		if err, ok := err.(*ssh.ExitError); ok {
			return err.ExitStatus(), nil
		} else {
			return -1, errors.New("failed to wait ssh command: " + err.Error())
		}
	}

	return 0, nil
}

func (ssc *SSHConfig) Exec(cmd string, stdout, stderr io.Writer, input chan string) (err tree_lib.TreeError) {
	var (
		session       *ssh.Session
		stdin         io.WriteCloser
		command_ended bool
	)
	err.From = tree_lib.FROM_SSH_EXEC
	session, err.Err = ssc.conn.NewSession()
	if !err.IsNull() {
		return
	}
	defer session.Close()

	session.Stdout = stdout
	session.Stderr = stderr

	stdin, err.Err = session.StdinPipe()
	if !err.IsNull() {
		return
	}

	err.Err = session.Start(cmd)
	if !err.IsNull() {
		return
	}
	command_ended = false
	go func() {
		for !command_ended {
			io.Copy(stdin, bytes.NewBufferString(<-input))
		}
	}()
	err.Err = session.Wait()
	command_ended = true
	return
}

func tailFile(session *ssh.Session, file string, sudo bool, linec chan<- string) error {

	var command string
	if sudo {
		command = fmt.Sprintf("sudo /usr/bin/env tail -F %s", file)
	} else {
		command = fmt.Sprintf("/usr/bin/env tail -F %s", file)
	}

	var wg sync.WaitGroup
	errc := make(chan error, 3)
	consumeStream := func(r io.Reader) {
		defer wg.Done()
		scan := bufio.NewScanner(r)
		scan.Split(bufio.ScanLines)
		for scan.Scan() {
			linec <- scan.Text()
		}
		if err := scan.Err(); err != nil {
			errc <- err
		}
	}

	stderr, err := session.StderrPipe()
	if err != nil {
		return fmt.Errorf("opening stderr: %v", err)
	}
	stdout, err := session.StdoutPipe()
	if err != nil {
		return fmt.Errorf("opening stdout: %v", err)
	}

	wg.Add(1)
	go consumeStream(stderr)
	go consumeStream(stdout)

	if err := session.Start(command); err != nil {
		return err
	}
	wg.Add(1)
	go func() {
		if err := session.Wait(); err != nil {
			errc <- err
		}
	}()

	go func() {
		wg.Wait()
		close(errc)
	}()

	return <-errc
}

// RunCommandBackground runs a background command in a vagrant node
func (n *VagrantNode) RunCommandBackground(cmd string) (string, error) {
	var (
		s   *ssh.Session
		err error
	)

	if s, err = n.client.NewSession(); err != nil {
		return "", err
	}
	defer s.Close()

	// start and forget about the command as user asked to run in background.
	// The limitation is we/ won't know if it fails though. Not a worry right
	// now as the test will fail anyways, but might be good to find a better way.
	return "", s.Start(newCmdStrWithSource(cmd))
}

func stream(command string, session *ssh.Session) (output chan string, done chan bool, err error) {
	outReader, err := session.StdoutPipe()
	Ω(err).ShouldNot(HaveOccurred())
	errReader, err := session.StderrPipe()
	Ω(err).ShouldNot(HaveOccurred())
	outputReader := io.MultiReader(outReader, errReader)
	err = session.Start(command)
	Ω(err).ShouldNot(HaveOccurred())
	scanner := bufio.NewScanner(outputReader)
	outputChan := make(chan string)
	done = make(chan bool)
	go func(scanner *bufio.Scanner, out chan string, done chan bool) {
		defer close(outputChan)
		defer close(done)
		for scanner.Scan() {
			outputChan <- scanner.Text()
		}
		done <- true
		session.Close()
	}(scanner, outputChan, done)
	return outputChan, done, err
}

				})
			})

			Context("while a command is running", func() {
				var stdin io.WriteCloser
				var stdout io.Reader

				BeforeEach(func() {
					var err error
					stdin, err = session.StdinPipe()
					Expect(err).NotTo(HaveOccurred())

					stdout, err = session.StdoutPipe()
					Expect(err).NotTo(HaveOccurred())

					err = session.Start("trap 'echo Caught SIGUSR1' USR1; echo trapped; cat")
					Expect(err).NotTo(HaveOccurred())

					reader := bufio.NewReader(stdout)
					Eventually(reader.ReadLine).Should(ContainSubstring("trapped"))
				})

				It("delivers the signal to the process", func() {
					err := session.Signal(ssh.SIGUSR1)
					Expect(err).NotTo(HaveOccurred())

					Eventually(runner.SignalCallCount).Should(Equal(1))

					err = stdin.Close()
					Expect(err).NotTo(HaveOccurred())

func (s *BotClientT) Start(botId string, botInstance int, cmdline string, cfg *ConfigT, debugLevel int) error {
	var err error
	var sshclient *ssh.Client
	var session *ssh.Session
	//   var wg         sync.WaitGroup
	var cmd string

	if s.Host[botInstance].Status == BotStatPaused {
		return nil
	}

	if s.Host[botInstance].Status == BotStatRunning {
		err = s.PingAt(botId, botInstance, cfg)
		if err == nil {
			Goose.Ping.Logf(2, "bot %[email protected]%s is alive", botId, s.Host[botInstance].Name)
			return nil
		}
	}

	Goose.StartStop.Logf(2, "Starting bot %[email protected]%s", botId, s.Host[botInstance].Name)

	s.Host[botInstance].Status = BotStatUnreachable
	if s.Host[botInstance].OnStatUpdate != nil {
		s.Host[botInstance].OnStatUpdate(BotStatUnreachable)
	}

	cfg.SshClientConfig.User = s.SysUser

	sshclient, err = ssh.Dial("tcp", s.Host[botInstance].Name+":22", cfg.SshClientConfig)
	if err != nil {
		Goose.StartStop.Logf(1, "%s (%s)", ErrDialingToBot, err)
		return ErrDialingToBot
	}
	defer sshclient.Close()

	Goose.StartStop.Logf(3, "Dialed to bot %[email protected]%s", botId, s.Host[botInstance].Name)

	session, err = sshclient.NewSession()
	if err != nil {
		Goose.StartStop.Logf(1, "%s (%s)", ErrCreatingSession, err)
		return ErrCreatingSession
	}
	defer session.Close()

	Goose.StartStop.Logf(3, "Session started at bot %[email protected]%s", botId, s.Host[botInstance].Name)

	/*
	   wg.Add(1)

	   go func() {
	      defer wg.Done()
	      w, _ := session.StdinPipe()
	      defer w.Close()
	      Goose.StartStop.Logf(2,"Closing stdin for bot %s",botId)
	      //fmt.Fprintf(w, "%s\n", config)
	   }()
	*/

	/*
	   // Set up terminal modes
	   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
	   }
	   // Request pseudo terminal
	   if err := session.RequestPty("xterm", 80, 40, modes); err != nil {
	      Goose.StartStop.Fatalf(1,"request for pseudo terminal failed: %s", err)
	   }


	   session.Stdout = &bytes.Buffer{}
	   session.Stderr = &bytes.Buffer{}
	*/

	cmd = fmt.Sprintf("%s%c%s -v %d %s", s.BinDir, os.PathSeparator, s.BinName, debugLevel, cmdline)
	Goose.StartStop.Logf(3, "Will run %[email protected]%s using %s", botId, s.Host[botInstance].Name, cmd)

	err = session.Start(cmd)
	//   err = session.Run(cmd)
	Goose.StartStop.Logf(2, "Running bot %s", botId)
	//   wg.Wait()

	if err != nil {
		session.Signal(ssh.SIGKILL)
		Goose.StartStop.Logf(1, "%s (%s)", ErrFailedStartingBot, err)
		return ErrFailedStartingBot
	}

	Goose.StartStop.Logf(2, "Started bot %s with cmd:[%s]", botId, cmd)

	s.Host[botInstance].Status = BotStatRunning
	if s.Host[botInstance].OnStatUpdate != nil {
		s.Host[botInstance].OnStatUpdate(BotStatRunning)
	}

	return nil
}