func printUnitStatus(c *cli.Context, jobName string) { 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 *ssh.SSHForwardingClient if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), false) } else { sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), false) } if err != nil { log.Fatal(err.Error()) } defer sshClient.Close() cmd := fmt.Sprintf("systemctl status -l %s", jobName) channel, err := ssh.Execute(sshClient, cmd) if err != nil { log.Fatalf("Unable to execute command over SSH: %s", err.Error()) } readSSHChannel(channel) }
func runSSH(args []string) (exit int) { if flagUnit != "" && flagMachine != "" { fmt.Fprintln(os.Stderr, "Both machine and unit flags provided, please specify only one.") return 1 } var err error var addr string switch { case flagMachine != "": addr, _ = findAddressInMachineList(flagMachine) case flagUnit != "": addr, _ = findAddressInRunningUnits(flagUnit) default: addr, err = globalMachineLookup(args) if err != nil { fmt.Fprintln(os.Stderr, err) return 1 } // trim machine/unit name from args if len(args) > 0 { args = args[1:] } } if addr == "" { fmt.Fprintln(os.Stderr, "Requested machine could not be found.") return 1 } args = pkg.TrimToDashes(args) var sshClient *ssh.SSHForwardingClient if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), flagSSHAgentForwarding) } else { sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), flagSSHAgentForwarding) } if err != nil { fmt.Fprintf(os.Stderr, "Failed building SSH client: %v\n", err) return 1 } defer sshClient.Close() if len(args) > 0 { cmd := strings.Join(args, " ") err, exit = ssh.Execute(sshClient, cmd) if err != nil { fmt.Fprintf(os.Stderr, "Failed running command over SSH: %v\n", err) } } else { if err := ssh.Shell(sshClient); err != nil { fmt.Fprintf(os.Stderr, "Failed opening shell over SSH: %v\n", err) exit = 1 } } return }
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") } agentForwarding := c.Bool("agent") var sshClient *ssh.SSHForwardingClient if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), agentForwarding) } else { sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), agentForwarding) } if err != nil { log.Fatal(err.Error()) return } defer sshClient.Close() if len(args) > 0 { cmd := strings.Join(args, " ") channel, err := ssh.Execute(sshClient, cmd) if err != nil { log.Fatalf("Unable to run command over SSH: %s", err.Error()) } readSSHChannel(channel) } else { if err := ssh.Shell(sshClient); err != nil { log.Fatalf(err.Error()) } } }
func (c *FleetClient) SSHExec(name, cmd string) error { fmt.Printf("Executing '%s' on container '%s'\n", cmd, name) conn, err := c.sshConnect(name) if err != nil { return err } err, _ = ssh.Execute(conn, cmd) return err }
func (c *FleetClient) SSHExec(name, cmd string) error { conn, ms, err := c.sshConnect(name) if err != nil { return err } fmt.Printf("Executing '%s' on %s\n", cmd, ms.PublicIP) err, _ = ssh.Execute(conn, cmd) return err }
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") } } }
// runRemoteCommand runs the given command over SSH on the given IP, and returns // any error encountered and the exit status of the command func runRemoteCommand(cmd string, addr string) (err error, exit int) { var sshClient *ssh.SSHForwardingClient if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), false) } else { sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), false) } if err != nil { return err, -1 } defer sshClient.Close() return ssh.Execute(sshClient, cmd) }
// runRemoteCommand runs the given command over SSH on the given IP, and returns // any error encountered and the exit status of the command func runRemoteCommand(cmd string, addr string, timeout time.Duration) (exit int, err error) { var sshClient *ssh.SSHForwardingClient if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), false, timeout) } else { sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), false, timeout) } if err != nil { return -1, err } defer sshClient.Close() err, exit = ssh.Execute(sshClient, cmd) return }
// runRemoteCommand runs the given command over SSH on the given IP, and returns // any error encountered and the exit status of the command func runRemoteCommand(cmd string, addr string) (err error, exit int) { var sshClient *ssh.SSHForwardingClient timeout := getSSHTimeoutFlag() if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient(globalFlags.SSHUserName, tun, addr, getChecker(), false, timeout) } else { sshClient, err = ssh.NewSSHClient(globalFlags.SSHUserName, addr, getChecker(), false, timeout) } if err != nil { return err, -1 } defer sshClient.Close() return ssh.Execute(sshClient, cmd) }
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") } } }
// runRemoteCommand runs the given command over SSH on the given IP, and returns // any error encountered and the exit status of the command func runRemoteCommand(cCmd *cobra.Command, addr string, cmd string, args ...string) (err error, exit int) { var sshClient *ssh.SSHForwardingClient timeout := getSSHTimeoutFlag(cCmd) if tun := getTunnelFlag(cCmd); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient(globalFlags.SSHUserName, tun, addr, getChecker(cCmd), false, timeout) } else { sshClient, err = ssh.NewSSHClient(globalFlags.SSHUserName, addr, getChecker(cCmd), false, timeout) } if err != nil { return err, -1 } cmdargs := cmd for _, arg := range args { cmdargs += fmt.Sprintf(" %q", arg) } defer sshClient.Close() return ssh.Execute(sshClient, cmdargs) }
func runRemoteCommand(cmd string, ip string) (*ssh.Channel, error) { addr := fmt.Sprintf("%s:22", ip) var sshClient *ssh.SSHForwardingClient var err error if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient("core", tun, addr, getChecker(), false) } else { sshClient, err = ssh.NewSSHClient("core", addr, getChecker(), false) } if err != nil { return nil, err } defer sshClient.Close() channel, err := ssh.Execute(sshClient, cmd) if err != nil { return nil, err } return channel, 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 runSSH(args []string) (exit int) { if flagUnit != "" && flagMachine != "" { stderr("Both machine and unit flags provided, please specify only one.") return 1 } var err error var addr string switch { case flagMachine != "": addr, _, err = findAddressInMachineList(flagMachine) case flagUnit != "": addr, _, err = findAddressInRunningUnits(flagUnit) default: addr, err = globalMachineLookup(args) // trim machine/unit name from args if len(args) > 0 { args = args[1:] } } if err != nil { stderr("Unable to proceed: %v", err) return 1 } if addr == "" { stderr("Could not determine address of machine.") return 1 } args = pkg.TrimToDashes(args) var sshClient *ssh.SSHForwardingClient timeout := getSSHTimeoutFlag() if tun := getTunnelFlag(); tun != "" { sshClient, err = ssh.NewTunnelledSSHClient(globalFlags.SSHUserName, tun, addr, getChecker(), flagSSHAgentForwarding, timeout) } else { sshClient, err = ssh.NewSSHClient(globalFlags.SSHUserName, addr, getChecker(), flagSSHAgentForwarding, timeout) } if err != nil { stderr("Failed building SSH client: %v", err) return 1 } defer sshClient.Close() if len(args) > 0 { cmd := strings.Join(args, " ") err, exit = ssh.Execute(sshClient, cmd) if err != nil { stderr("Failed running command over SSH: %v", err) } } else { if err := ssh.Shell(sshClient); err != nil { stderr("Failed opening shell over SSH: %v", err) exit = 1 } } return }
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()) } } }