README
¶
simple sshclient with golang
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
- func GetPerm(f *os.File) (perm string)
- type Client
- func (c *Client) Close() error
- func (c *Client) Cmd(cmd string) *RemoteScript
- func (c *Client) Download(remotePath string, localPath string) (err error)
- func (c *Client) NewSftp(opts ...sftp.ClientOption) (*sftp.Client, error)
- func (c *Client) Script(script string) *RemoteScript
- func (c *Client) ScriptFile(fname string) *RemoteScript
- func (c *Client) Shell() *RemoteShell
- func (c *Client) Terminal(config *TerminalConfig) *RemoteShell
- func (c *Client) UnderlyingClient() *ssh.Client
- func (c *Client) Upload(localPath string, remotePath string) (err error)
- type RemoteScript
- type RemoteShell
- type Scp
- type TerminalConfig
Constants ¶
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 ¶
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 ¶
DialWithKey starts a client connection to the given SSH server with key authmethod.
func DialWithKeyWithPassphrase ¶
DialWithKeyWithPassphrase same as DialWithKey but with a passphrase to decrypt the private key
func DialWithPasswd ¶
DialWithPasswd starts a client connection to the given SSH server with passwd authmethod.
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) 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 ¶
UnderlyingClient get the underlying client.
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
}
type TerminalConfig ¶
type TerminalConfig struct {
Term string
Height int
Weight int
Modes ssh.TerminalModes
}
A TerminalConfig represents the configuration for an interactive shell session.
Source Files