124 lines
3.0 KiB
Go
124 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"flag"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"time"
|
|
|
|
"github.com/golang/glog"
|
|
|
|
"golang.org/x/crypto/ssh"
|
|
)
|
|
|
|
var (
|
|
host = flag.String("host", "localhost:22", "host:port to scp from")
|
|
user = flag.String("user", os.Getenv("USER"), "ssh user")
|
|
)
|
|
|
|
// Example: @auto-20171001.1400-2w
|
|
var (
|
|
snapshotPattern = regexp.MustCompile(`^([^@]+)@auto-(\d{8}\.\d{4})-\d+[mwy]$`)
|
|
snapshotFormat = "20060102.1504"
|
|
)
|
|
|
|
func newPublicKey() ([]ssh.AuthMethod, error) {
|
|
var signers []ssh.AuthMethod
|
|
|
|
for _, path := range []string{
|
|
filepath.Join(os.Getenv("HOME"), ".ssh", "id_dsa"),
|
|
filepath.Join(os.Getenv("HOME"), ".ssh", "id_rsa"),
|
|
} {
|
|
|
|
// A public key may be used to authenticate against the remote
|
|
// server by using an unencrypted PEM-encoded private key file.
|
|
//
|
|
// If you have an encrypted private key, the crypto/x509 package
|
|
// can be used to decrypt it.
|
|
key, err := ioutil.ReadFile(path)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
continue
|
|
}
|
|
return nil, fmt.Errorf("unable to read private key %q: %v", path, err)
|
|
}
|
|
|
|
// Create the Signer for this private key.
|
|
signer, err := ssh.ParsePrivateKey(key)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("unable to parse private key %q: %v", path, err)
|
|
}
|
|
signers = append(signers, ssh.PublicKeys(signer))
|
|
}
|
|
if len(signers) == 0 {
|
|
return nil, fmt.Errorf("no public keys configured")
|
|
}
|
|
return signers, nil
|
|
}
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
defer glog.Flush()
|
|
|
|
ams, err := newPublicKey()
|
|
if err != nil {
|
|
glog.Exitf("Error fetching public keys: %v", err)
|
|
}
|
|
|
|
// An SSH client is represented with a ClientConn.
|
|
//
|
|
// To authenticate with the remote server you must pass at least one
|
|
// implementation of ClientAuth via the Auth field in ClientConfig.
|
|
config := &ssh.ClientConfig{
|
|
User: *user,
|
|
Auth: ams,
|
|
// TODO(wathiede); use FixedHostKey?
|
|
HostKeyCallback: ssh.InsecureIgnoreHostKey(),
|
|
}
|
|
client, err := ssh.Dial("tcp", *host, config)
|
|
if err != nil {
|
|
glog.Exitf("Error dialing %q: %v", *host, err)
|
|
}
|
|
|
|
// Each ClientConn can support multiple interactive sessions,
|
|
// represented by a Session.
|
|
s, err := client.NewSession()
|
|
if err != nil {
|
|
glog.Exitf("Error creating new session: %v", err)
|
|
}
|
|
cmd := "/sbin/zfs list -t snapshot -H -o name -s name"
|
|
b, err := s.CombinedOutput(cmd)
|
|
if err != nil {
|
|
glog.Exitf("Error running %q: %v", cmd, err)
|
|
}
|
|
scanner := bufio.NewScanner(bytes.NewReader(b))
|
|
snapshotAges := map[string]time.Time{}
|
|
for scanner.Scan() {
|
|
l := scanner.Text()
|
|
m := snapshotPattern.FindStringSubmatch(l)
|
|
if len(m) == 3 {
|
|
snapshot := m[1]
|
|
t, err := time.Parse(snapshotFormat, m[2])
|
|
if err != nil {
|
|
glog.Errorf("Malformed time in snapshot %q: %v", m[2], err)
|
|
continue
|
|
}
|
|
snapshotTime := snapshotAges[snapshot]
|
|
if snapshotTime.Before(t) {
|
|
snapshotAges[snapshot] = t
|
|
}
|
|
}
|
|
}
|
|
if err := scanner.Err(); err != nil {
|
|
glog.Exitf("Failed to scan response: %v", err)
|
|
}
|
|
for snapshot, snapshotTime := range snapshotAges {
|
|
fmt.Println(snapshot, snapshotTime, time.Since(snapshotTime))
|
|
}
|
|
}
|