sshclient

package
v1.3.8 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 17, 2022 License: MIT, MIT Imports: 15 Imported by: 0

README

simple sshclient with golang

GoDoc

This package implemented a ssh client. It can run remote command, execute remote script, request terminal and request non-interactive shell simply.

install package

# The -u flag instructs get to update modules providing dependencies
# of packages named on the command line to use newer minor or patch
# releases when available.
go get -u github.com/helloyi/go-sshclient

create a ssh client

  • Dial with passwd
client, err := DialWithPasswd("host:port", "username", "passwd")
if err != nil {
  handleErr(err)
}
defer client.Close()
  • Dial with private key
client, err := DialWithKey("host:port", "username", "prikeyFile")
if err != nil {
  handleErr(err)
}
defer client.Close()
  • Dial with private key and a passphrase to decrypt the key
client, err := DialWithKeyWithPassphrase("host:port", "username", "prikeyFile", "my-passphrase"))
if err != nil {
  handleErr(err)
}
defer client.Close()
  • Dia
config := &ssh.ClientConfig{
	User: user,
	Auth: []ssh.AuthMethod{
		ssh.Password("yourpasswd"),
	},
}
client, err := Dial("network", "host:port", config)
if err != nil {
  handleErr(err)
}
defer client.Close()

execute commmand

  • Don't care about output, calling Run
// run one command
if err := client.Cmd("cmd").Run(); err {
  handleErr(err)
}

// run muti command one time
// if there is a command run err, and the next commands will not run
if err := client.Cmd("cmd1").Cmd("cmd2").Cmd("cmd3").Run(); err != nil {
  handleErr(err)
}
  • Get output, calling Output
out, err := client.Cmd("cmd").Output()
if err != nil {
  handleErr(err)
}
fmt.Println(string(out))
  • Return stderr message, when execution error, calling SmartOutput
out, err := client.Cmd("cmd").SmartOutput()
if err != nil {
  // the 'out' is stderr output
  handleErr(err, out)
}
// the 'out' is stdout output
fmt.Println(string(out))
  • Write stdout and stderr to your buffer, calling SetStdio
var (
  stdout bytes.Buffer
  stderr bytes.Buffer
)

if err := client.Cmd("cmd").SetStdio(&stdout, &stderr).Run(); err {
  handleErr(err)
}

// get it
fmt.Println(string(stdout))
fmt.Println(string(stderr))

execute script

  • Run script
script = `
  statment1
  statment2
`

// It's as same as Cmd
client.Script(script).Run()
client.Script(script).Output()
client.Script(script).SmartOutput()
  • Run a shell script file
client.ScriptFile("/path/to/the/script").Run()
client.ScriptFile("/path/to/the/script").Output()
client.ScriptFile("/path/to/the/script").SmartOutput()

get shell

  • Get a non-interactive shell
if err := client.Shell().Start(); err != nil {
  handleErr(err)
}
  • Get a interactive shell
// default terminal
if err := client.Terminal(nil).Start(); err != nil {
  handleErr(err)
}

// with a terminal config
config := &sshclient.TerminalConfig {
  Term: "xterm",
  Height: 40,
  Weight: 80,
  Modes: ssh.TerminalModes {
	  ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
	  ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
  }
}
if err := client.Terminal(config).Start(); err != nil {
  handleErr(err)
}
  • And sometimes, you could set your stdio buffer
var (
  stdin  bytes.Buffer
  stdout bytes.Buffer
  stderr bytes.Buffer
)

// Now, it's like client.Script("script").Run()
stdin.NewBufferString("script")
if err := client.Shell().SetStdio(&stdin, &stdout, &stderr).Start(); err != nil {
  handleErr(err)
}

fmt.Println(stdout.String())
fmt.Println(stderr.String())

Documentation

Overview

Package sshclient implements an SSH client.

Index

Constants

View Source
const (
	SCP_PUSH_BEGIN_FILE       = "C"
	SCP_PUSH_BEGIN_FOLDER     = "D"
	SCP_PUSH_BEGIN_END_FOLDER = "0"
	SCP_PUSH_END_FOLDER       = "E"
	SCP_PUSH_END              = "\x00"
)

Variables

This section is empty.

Functions

func GetPerm

func GetPerm(f *os.File) (perm string)

Types

type Client

type Client struct {
	// contains filtered or unexported fields
}

A Client implements an SSH client that supports running commands and scripts remotely.

func Dial

func Dial(network, addr string, config *ssh.ClientConfig) (*Client, error)

Dial starts a client connection to the given SSH server. This wraps ssh.Dial.

func DialWithKey

func DialWithKey(addr, user, keyfile string) (*Client, error)

DialWithKey starts a client connection to the given SSH server with key authmethod.

func DialWithKeyWithPassphrase

func DialWithKeyWithPassphrase(addr, user, keyfile string, passphrase string) (*Client, error)

DialWithKeyWithPassphrase same as DialWithKey but with a passphrase to decrypt the private key

func DialWithPasswd

func DialWithPasswd(addr, user, passwd string) (*Client, error)

DialWithPasswd starts a client connection to the given SSH server with passwd authmethod.

func (*Client) Close

func (c *Client) Close() error

Close closes the underlying client network connection.

func (*Client) Cmd

func (c *Client) Cmd(cmd string) *RemoteScript

Cmd creates a RemoteScript that can run the command on the client. The cmd string is split on newlines and each line is executed separately.

func (*Client) Download

func (c *Client) Download(remotePath string, localPath string) (err error)

Download file from remote server

func (*Client) NewSftp

func (c *Client) NewSftp(opts ...sftp.ClientOption) (*sftp.Client, error)

func (*Client) Script

func (c *Client) Script(script string) *RemoteScript

Script creates a RemoteScript that can run the script on the client.

func (*Client) ScriptFile

func (c *Client) ScriptFile(fname string) *RemoteScript

ScriptFile creates a RemoteScript that can read a local script file and run it remotely on the client.

func (*Client) Shell

func (c *Client) Shell() *RemoteShell

Shell create a noninteractive shell on client.

func (*Client) Terminal

func (c *Client) Terminal(config *TerminalConfig) *RemoteShell

Terminal create an interactive shell on client.

func (*Client) UnderlyingClient

func (c *Client) UnderlyingClient() *ssh.Client

UnderlyingClient get the underlying client.

func (*Client) Upload

func (c *Client) Upload(localPath string, remotePath string) (err error)

Upload a local file to remote server

type RemoteScript

type RemoteScript struct {
	// contains filtered or unexported fields
}

A RemoteScript represents script that can be run remotely.

func (*RemoteScript) Cmd

func (rs *RemoteScript) Cmd(cmd string) *RemoteScript

Cmd appends a command to the RemoteScript.

func (*RemoteScript) Output

func (rs *RemoteScript) Output() ([]byte, error)

Output runs the script on the client and returns its standard output.

func (*RemoteScript) Run

func (rs *RemoteScript) Run() error

Run runs the script on the client.

The returned error is nil if the command runs, has no problems copying stdin, stdout, and stderr, and exits with a zero exit status.

func (*RemoteScript) SetStdio

func (rs *RemoteScript) SetStdio(stdout, stderr io.Writer) *RemoteScript

SetStdio specifies where its standard output and error data will be written.

func (*RemoteScript) SmartOutput

func (rs *RemoteScript) SmartOutput() ([]byte, error)

SmartOutput runs the script on the client. On success, its standard ouput is returned. On error, its standard error is returned.

type RemoteShell

type RemoteShell struct {
	// contains filtered or unexported fields
}

A RemoteShell represents a login shell on the client.

func (*RemoteShell) SetStdio

func (rs *RemoteShell) SetStdio(stdin io.Reader, stdout, stderr io.Writer) *RemoteShell

SetStdio specifies where the its standard output and error data will be written.

func (*RemoteShell) Start

func (rs *RemoteShell) Start() error

Start starts a remote shell on client.

type Scp

type Scp struct {
	// contains filtered or unexported fields
}

func NewScp

func NewScp(clientConn *ssh.Client) *Scp

Initializer

func (*Scp) PullFile

func (scp *Scp) PullFile(srcpath, targetFile string) error

PullFile Pull file from remote to local targetFile 远端目标文件 srcpath 本地目录

func (*Scp) PushDir

func (scp *Scp) PushDir(src string, dest string) error

PushDir Push directory to server

func (*Scp) PushFile

func (scp *Scp) PushFile(src string, dest string) error

PushFile Push one file to server

type TerminalConfig

type TerminalConfig struct {
	Term   string
	Height int
	Weight int
	Modes  ssh.TerminalModes
}

A TerminalConfig represents the configuration for an interactive shell session.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL