func NewTunnelledSSHClient(user, tunaddr, tgtaddr string) (*gossh.ClientConn, error) {
clientConfig, err := sshClientConfig(user)
if err != nil {
return nil, err
}
var tunnelClient *gossh.ClientConn
dialFunc := func(echan chan error) {
var err error
tunnelClient, err = gossh.Dial("tcp", tunaddr, clientConfig)
echan <- err
}
err = timeoutSSHDial(dialFunc)
if err != nil {
return nil, err
}
var targetConn net.Conn
dialFunc = func(echan chan error) {
var err error
targetConn, err = tunnelClient.Dial("tcp", tgtaddr)
echan <- err
}
err = timeoutSSHDial(dialFunc)
if err != nil {
return nil, err
}
targetClient, err := gossh.Client(targetConn, clientConfig)
if err != nil {
return nil, err
}
return targetClient, nil
}
func Execute(client *gossh.ClientConn, cmd string) (*bufio.Reader, error) {
session, err := client.NewSession()
if err != nil {
return nil, err
}
stdout, _ := session.StdoutPipe()
bstdout := bufio.NewReader(stdout)
session.Start(cmd)
go session.Wait()
return bstdout, nil
}
func journalAction(c *cli.Context) {
if len(c.Args()) != 1 {
fmt.Println("One unit file must be provided.")
syscall.Exit(1)
}
jobName := c.Args()[0]
js := registryCtl.GetJobState(jobName)
if js == nil {
fmt.Printf("%s does not appear to be running\n", jobName)
syscall.Exit(1)
}
addr := fmt.Sprintf("%s:22", js.MachineState.PublicIP)
var err error
var sshClient *gossh.ClientConn
if tun := getTunnelFlag(); tun != "" {
sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr)
} else {
sshClient, err = ssh.NewSSHClient("core", addr)
}
if err != nil {
log.Fatal(err.Error())
}
defer sshClient.Close()
cmd := fmt.Sprintf("journalctl -u %s --no-pager -l -n %d", jobName, c.Int("lines"))
if c.Bool("follow") {
cmd += " -f"
}
stdout, err := ssh.Execute(sshClient, cmd)
if err != nil {
log.Fatalf("Unable to run command over SSH: %s", err.Error())
}
for true {
bytes, prefix, err := stdout.ReadLine()
if err != nil {
break
}
fmt.Print(string(bytes))
if !prefix {
fmt.Print("\n")
}
}
}
func printUnitStatus(c *cli.Context, r *registry.Registry, jobName string) {
js := r.GetJobState(jobName)
if js == nil {
fmt.Printf("%s does not appear to be running\n", jobName)
syscall.Exit(1)
}
addr := fmt.Sprintf("%s:22", js.MachineState.PublicIP)
var err error
var sshClient *gossh.ClientConn
if tun := getTunnelFlag(c); tun != "" {
sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr)
} else {
sshClient, err = ssh.NewSSHClient("core", addr)
}
if err != nil {
log.Fatalf("Unable to establish SSH connection: %v", err)
}
defer sshClient.Close()
cmd := fmt.Sprintf("systemctl status -l %s", jobName)
stdout, err := ssh.Execute(sshClient, cmd)
if err != nil {
log.Fatalf("Unable to execute command over SSH: %s", err.Error())
}
for true {
bytes, prefix, err := stdout.ReadLine()
if err != nil {
break
}
print(string(bytes))
if !prefix {
print("\n")
}
}
}
func Shell(client *gossh.ClientConn) error {
session, err := client.NewSession()
if err != nil {
return err
}
defer session.Close()
modes := gossh.TerminalModes{
gossh.ECHO: 1, // enable echoing
gossh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
gossh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
}
fd := int(os.Stdin.Fd())
oldState, err := terminal.MakeRaw(fd)
defer terminal.Restore(fd, oldState)
termWidth, termHeight, err := terminal.GetSize(fd)
if err != nil {
return err
}
session.Stdout = os.Stdout
session.Stderr = os.Stderr
session.Stdin = os.Stdin
if err := session.RequestPty("xterm-256color", termHeight, termWidth, modes); err != nil {
return err
}
if err = session.Shell(); err != nil {
return err
}
session.Wait()
return nil
}
func sshAction(c *cli.Context) {
unit := c.String("unit")
machine := c.String("machine")
if unit != "" && machine != "" {
log.Fatal("Both flags, machine and unit provided, please specify only one")
}
args := c.Args()
var err error
var addr string
switch {
case machine != "":
addr, _ = findAddressInMachineList(machine)
case unit != "":
addr, _ = findAddressInRunningUnits(unit)
default:
addr, err = globalMachineLookup(args)
args = args[1:]
}
if err != nil {
log.Fatal(err)
}
if addr == "" {
log.Fatalf("Requested machine could not be found")
}
var sshClient *gossh.ClientConn
if tun := getTunnelFlag(); tun != "" {
sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr)
} else {
sshClient, err = ssh.NewSSHClient("core", addr)
}
if err != nil {
log.Fatal(err.Error())
return
}
defer sshClient.Close()
if len(args) > 0 {
cmd := strings.Join(args, " ")
stdout, err := ssh.Execute(sshClient, cmd)
if err != nil {
log.Fatalf("Unable to run command over SSH: %s", err.Error())
}
for {
bytes, prefix, err := stdout.ReadLine()
if err != nil {
break
}
fmt.Print(string(bytes))
if !prefix {
fmt.Print("\n")
}
}
} else {
if err := ssh.Shell(sshClient); err != nil {
log.Fatalf(err.Error())
}
}
}
func sshAction(c *cli.Context) {
r := getRegistry(c)
args := c.Args()
unit := c.String("unit")
if len(args) == 0 && unit == "" {
log.Fatalf("Provide one machine or unit")
}
var addr string
if unit == "" {
lookup := args[0]
args = args[1:]
states := r.GetActiveMachines()
var match *machine.MachineState
for i, _ := range states {
machState := states[i]
if !strings.HasPrefix(machState.BootId, lookup) {
continue
} else if match != nil {
log.Fatalf("Found more than one Machine, be more specfic")
}
match = &machState
}
if match == nil {
log.Fatalf("Could not find provided Machine")
}
addr = fmt.Sprintf("%s:22", match.PublicIP)
} else {
js := r.GetJobState(unit)
if js == nil {
log.Fatalf("Requested unit %s does not appear to be running", unit)
}
addr = fmt.Sprintf("%s:22", js.MachineState.PublicIP)
}
var err error
var sshClient *gossh.ClientConn
if tun := getTunnelFlag(c); tun != "" {
sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr)
} else {
sshClient, err = ssh.NewSSHClient("core", addr)
}
if err != nil {
log.Fatalf("Unable to establish SSH connection: %v", err)
return
}
defer sshClient.Close()
if len(args) > 0 {
cmd := strings.Join(args, " ")
stdout, err := ssh.Execute(sshClient, cmd)
if err != nil {
log.Fatalf("Unable to run command over SSH: %s", err.Error())
}
for {
bytes, prefix, err := stdout.ReadLine()
if err != nil {
break
}
print(string(bytes))
if !prefix {
print("\n")
}
}
} else {
if err := ssh.Shell(sshClient); err != nil {
log.Fatalf(err.Error())
}
}
}
