| commit | a3d1090acbd08c93e5ca85385131d04b08848bf0 | [log] [tgz] |
|---|---|---|
| author | Skalle <skalle.karlsson@gmail.com> | Fri Sep 22 07:23:26 2017 |
| committer | Skalle <skalle.karlsson@gmail.com> | Fri Sep 22 07:23:26 2017 |
| tree | bd26d244a1d5b3fc722b023d9f29f1903a8af27c | |
| parent | efc1f165245abe997a47a8af2d3c115db2e7a8b3 [diff] |
In progress.
This package is an implementation of Expect in Go.
All Spawn functions accept a variadic of type expect.Option , these are used for changing options of the Expecter.
The Go Expecter checks for new data every two seconds as default. This can be changed by using the CheckDuration func CheckDuration(d time.Duration) Option.
The Verbose option is used to turn on/off verbose logging for Expect/Send statements. This option can be very usefull when troubleshooting workflows since it will og every interaction with the device.
The Go Expecter periodically checks that the spawned process/ssh/session/telnet etc. session is alive. This option turns that check off.
The DebugCheck option adds debugging to the alive Check done by the Expecter, this will start logging information everytime the check is run. Can be used for troubleshooting and debugging of Spawners.
The ChangeCheck option makes it possible to replace the Spawner Check function with a brand new one.
First we try to replicate the Telnet example from wikipedia as close as possible.
Interaction:
+ username: - user\n + password: - pass\n + % - cmd\n + % - exit\n
Error checking was omitted to keep the example short
package main
import (
"flag"
"fmt"
"regexp"
"time"
"github.com/golang/glog"
"github.com/google/goexpect"
"github.com/google/goterm/term"
)
const (
timeout = 10 * time.Minute
)
var (
addr = flag.String("address", "", "address of telnet server")
user = flag.String("user", "", "username to use")
pass = flag.String("pass", "", "password to use")
cmd = flag.String("cmd", "", "command to run")
userRE = regexp.MustCompile("username:")
passRE = regexp.MustCompile("password:")
promptRE = regexp.MustCompile("%")
)
func main() {
flag.Parse()
fmt.Println(term.Bluef("Telnet 1 example"))
e, _, err := expect.Spawn(fmt.Sprintf("telnet %s", *addr), -1)
if err != nil {
glog.Exit(err)
}
defer e.Close()
e.Expect(userRE, timeout)
e.Send(*user + "\n")
e.Expect(passRE, timeout)
e.Send(*pass + "\n")
e.Expect(promptRE, timeout)
e.Send(*cmd + "\n")
result, _, _ := e.Expect(promptRE, timeout)
e.Send("exit\n")
fmt.Println(term.Greenf("%s: result: %s\n", *cmd, result))
}
In essence to run and attach to a process the expect.Spawn(<cmd>,<timeout>) is used. The spawn returns and Expecter that can rund e.Expect and e.Send commands to match information in the output and Send information in.
See the https://github.com/google/goexpect/blob/master/examples/newspawner/telnet.go example for a slightly more fleshed out version
For the FTP example we use the expect.Batch for the following interaction.
+ username: - user\n + password: - pass\n + ftp> - prompt\n + ftp> - mget *\n + ftp>' - bye\n
ftp_example.go
package main
import (
"flag"
"fmt"
"time"
"github.com/golang/glog"
"github.com/google/goexpect"
"github.com/google/goterm/term"
)
const (
timeout = 10 * time.Minute
)
var (
addr = flag.String("address", "", "address of telnet server")
user = flag.String("user", "", "username to use")
pass = flag.String("pass", "", "password to use")
)
func main() {
flag.Parse()
fmt.Println(term.Bluef("Ftp 1 example"))
e, _, err := expect.Spawn(fmt.Sprintf("ftp %s", *addr), -1)
if err != nil {
glog.Exit(err)
}
defer e.Close()
e.ExpectBatch([]expect.Batcher{
&expect.BExp{R: "username:"},
&expect.BSnd{S: *user + "\n"},
&expect.BExp{R: "password:"},
&expect.BSnd{S: *pass + "\n"},
&expect.BExp{R: "ftp>"},
&expect.BSnd{S: "bin\n"},
&expect.BExp{R: "ftp>"},
&expect.BSnd{S: "prompt\n"},
&expect.BExp{R: "ftp>"},
&expect.BSnd{S: "mget *\n"},
&expect.BExp{R: "ftp>"},
&expect.BSnd{S: "bye\n"},
}, timeout)
fmt.Println(term.Greenf("All done"))
}
Using the expect.Batcher makes the standard Send/Expect interactions more compact and simpler to write.
With the SSH login example we test out the expect.Caser and the Case Tags.
Also for this we'll use the Go Expect native SSH Spawner instead of spawning a process.
Interaction:
+ "Login: " - user + "Password: " - pass1 + "Wrong password" + "Login" - user + "Password: " - pass2 + router#
ssh_example.to
package main
import (
"flag"
"fmt"
"regexp"
"time"
"golang.org/x/crypto/ssh"
"google.golang.org/grpc/codes"
"github.com/golang/glog"
"github.com/google/goexpect"
"github.com/google/goterm/term"
)
const (
timeout = 10 * time.Minute
)
var (
addr = flag.String("address", "", "address of telnet server")
user = flag.String("user", "user", "username to use")
pass1 = flag.String("pass1", "pass1", "password to use")
pass2 = flag.String("pass2", "pass2", "alternate password to use")
)
func main() {
flag.Parse()
fmt.Println(term.Bluef("SSH Example"))
sshClt, err := ssh.Dial("tcp", *addr, &ssh.ClientConfig{
User: *user,
Auth: []ssh.AuthMethod{ssh.Password(*pass1)},
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
})
if err != nil {
glog.Exitf("ssh.Dial(%q) failed: %v", *addr, err)
}
defer sshClt.Close()
e, _, err := expect.SpawnSSH(sshClt, timeout)
if err != nil {
glog.Exit(err)
}
defer e.Close()
e.ExpectBatch([]expect.Batcher{
&expect.BCas{[]expect.Caser{
&expect.Case{R: regexp.MustCompile(`router#`), T: expect.OK()},
&expect.Case{R: regexp.MustCompile(`Login: `), S: *user,
T: expect.Continue(expect.NewStatus(codes.PermissionDenied, "wrong username")), Rt: 3},
&expect.Case{R: regexp.MustCompile(`Password: `), S: *pass1, T: expect.Next(), Rt: 1},
&expect.Case{R: regexp.MustCompile(`Password: `), S: *pass1,
T: expect.Continue(expect.NewStatus(codes.PermissionDenied, "wrong password")), Rt: 1},
}},
}, timeout)
fmt.Println(term.Greenf("All done"))
}
The Go Expect package supports adding new Spawners with the func SpawnGeneric(opt *GenOptions, timeout time.Duration, opts ...Option) (*GExpect, <-chan error, error) function.
telnet spawner
From the newspawner example.
func telnetSpawn(addr string, timeout time.Duration, opts ...expect.Option) (expect.Expecter, <-chan error, error) {
conn, err := telnet.Dial(network, addr)
if err != nil {
return nil, nil, err
}
resCh := make(chan error)
return expect.SpawnGeneric(&expect.GenOptions{
In: conn,
Out: conn,
Wait: func() error {
return <-resCh
},
Close: func() error {
close(resCh)
return conn.Close()
},
Check: func() bool { return true },
}, timeout, opts...)
}
The Go Expect package includes a Fake Spawner func SpawnFake(b []Batcher, timeout time.Duration, opt ...Option) (*GExpect, <-chan error, error). This is expected to be used to simplify testing and faking of interactive workflows.
Fake Spawner
// TestExpect tests the Expect function.
func TestExpect(t *testing.T) {
tests := []struct {
name string
fail bool
srv []Batcher
timeout time.Duration
re *regexp.Regexp
}{{
name: "Match prompt",
srv: []Batcher{
&BSnd{`
Pretty please don't hack my chassis
router1> `},
},
re: regexp.MustCompile("router1>"),
timeout: 2 * time.Second,
}, {
name: "Match fail",
fail: true,
re: regexp.MustCompile("router1>"),
srv: []Batcher{
&BSnd{`
Welcome
Router42>`},
},
timeout: 1 * time.Second,
}}
for _, tst := range tests {
exp, _, err := SpawnFake(tst.srv, tst.timeout)
if err != nil {
if !tst.fail {
t.Errorf("%s: SpawnFake failed: %v", tst.name, err)
}
continue
}
out, _, err := exp.Expect(tst.re, tst.timeout)
if got, want := err != nil, tst.fail; got != want {
t.Errorf("%s: Expect(%q,%v) = %t want: %t , err: %v, out: %q", tst.name, tst.re.String(), tst.timeout, got, want, err, out)
continue
}
}
}
Disclaimer: This is not an official Google product.