You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
332 lines
7.7 KiB
332 lines
7.7 KiB
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/codegangsta/cli"
|
|
"io/ioutil"
|
|
"net/url"
|
|
"os"
|
|
"regexp"
|
|
"strings"
|
|
"sync"
|
|
|
|
acm "github.com/tendermint/tendermint/account"
|
|
"github.com/tendermint/tendermint/binary"
|
|
btypes "github.com/tendermint/tendermint/cmd/barak/types"
|
|
. "github.com/tendermint/tendermint/common"
|
|
cfg "github.com/tendermint/tendermint/config"
|
|
)
|
|
|
|
func remoteNick(remote string) string {
|
|
u, err := url.Parse(remote)
|
|
if err != nil {
|
|
return regexp.MustCompile(`[[:^alnum:]]`).ReplaceAllString(remote, "_")
|
|
} else {
|
|
return regexp.MustCompile(`[[:^alnum:]]`).ReplaceAllString(u.Host, "_")
|
|
}
|
|
}
|
|
|
|
var Config = struct {
|
|
Remotes []string
|
|
PrivKey acm.PrivKey
|
|
}{}
|
|
|
|
func main() {
|
|
fmt.Printf("New Debora Process (PID: %d)\n", os.Getpid())
|
|
|
|
// Apply bare tendermint/* configuration.
|
|
cfg.ApplyConfig(cfg.MapConfig(map[string]interface{}{"log_level": "info"}))
|
|
|
|
rootDir := os.Getenv("DEBROOT")
|
|
if rootDir == "" {
|
|
rootDir = os.Getenv("HOME") + "/.debora"
|
|
}
|
|
|
|
var (
|
|
groupFlag = cli.StringFlag{
|
|
Name: "group",
|
|
Value: "default",
|
|
Usage: "uses ~/.debora/<group>.cfg",
|
|
}
|
|
labelFlag = cli.StringFlag{
|
|
Name: "label",
|
|
Value: "_",
|
|
Usage: "label of the process, or _ by default",
|
|
}
|
|
bgFlag = cli.BoolFlag{
|
|
Name: "bg",
|
|
Usage: "if set, runs as a background daemon",
|
|
}
|
|
inputFlag = cli.StringFlag{
|
|
Name: "input",
|
|
Value: "",
|
|
Usage: "input to the program (e.g. stdin)",
|
|
}
|
|
)
|
|
|
|
app := cli.NewApp()
|
|
app.Name = "debora"
|
|
app.Usage = "summons commands to barak"
|
|
app.Version = "0.0.1"
|
|
app.Email = "ethan@erisindustries.com,jae@tendermint.com"
|
|
app.Flags = []cli.Flag{
|
|
groupFlag,
|
|
}
|
|
app.Before = func(c *cli.Context) error {
|
|
configFile := rootDir + "/" + c.String("group") + ".cfg"
|
|
fmt.Printf("Using configuration from %v\n", configFile)
|
|
ReadConfig(configFile)
|
|
return nil
|
|
}
|
|
app.Commands = []cli.Command{
|
|
cli.Command{
|
|
Name: "status",
|
|
Usage: "shows remote status",
|
|
Action: cliGetStatus,
|
|
},
|
|
cli.Command{
|
|
Name: "run",
|
|
Usage: "run process",
|
|
Action: cliStartProcess,
|
|
Flags: []cli.Flag{
|
|
labelFlag,
|
|
bgFlag,
|
|
inputFlag,
|
|
},
|
|
},
|
|
cli.Command{
|
|
Name: "stop",
|
|
Usage: "stop process",
|
|
Action: cliStopProcess,
|
|
},
|
|
cli.Command{
|
|
Name: "list",
|
|
Usage: "list processes",
|
|
Action: cliListProcesses,
|
|
},
|
|
cli.Command{
|
|
Name: "open",
|
|
Usage: "open listener",
|
|
Action: cliOpenListener,
|
|
},
|
|
cli.Command{
|
|
Name: "close",
|
|
Usage: "close listener",
|
|
Action: cliCloseListener,
|
|
},
|
|
cli.Command{
|
|
Name: "download",
|
|
Usage: "download file <remote-path> <local-path-prefix>",
|
|
Action: cliDownloadFile,
|
|
},
|
|
}
|
|
app.Run(os.Args)
|
|
}
|
|
|
|
func ReadConfig(configFilePath string) {
|
|
configJSONBytes, err := ioutil.ReadFile(configFilePath)
|
|
if err != nil {
|
|
Exit(Fmt("Failed to read config file %v. %v\n", configFilePath, err))
|
|
}
|
|
binary.ReadJSON(&Config, configJSONBytes, &err)
|
|
if err != nil {
|
|
Exit(Fmt("Failed to parse config. %v", err))
|
|
}
|
|
}
|
|
|
|
func cliGetStatus(c *cli.Context) {
|
|
args := c.Args()
|
|
if len(args) != 0 {
|
|
fmt.Println("BTW, status takes no arguments.")
|
|
}
|
|
wg := sync.WaitGroup{}
|
|
for _, remote := range Config.Remotes {
|
|
wg.Add(1)
|
|
go func(remote string) {
|
|
defer wg.Done()
|
|
response, err := GetStatus(remote)
|
|
if err != nil {
|
|
fmt.Printf("%v failure. %v\n", remote, err)
|
|
} else {
|
|
fmt.Printf("%v success. %v\n", remote, response)
|
|
}
|
|
}(remote)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func cliStartProcess(c *cli.Context) {
|
|
args := c.Args()
|
|
if len(args) < 1 {
|
|
Exit("Must specify <execPath> <args...>")
|
|
}
|
|
execPath := args[0]
|
|
args = args[1:]
|
|
command := btypes.CommandStartProcess{
|
|
Wait: !c.Bool("bg"),
|
|
Label: c.String("label"),
|
|
ExecPath: execPath,
|
|
Args: args,
|
|
Input: c.String("input"),
|
|
}
|
|
wg := sync.WaitGroup{}
|
|
for _, remote := range Config.Remotes {
|
|
wg.Add(1)
|
|
go func(remote string) {
|
|
defer wg.Done()
|
|
response, err := StartProcess(Config.PrivKey, remote, command)
|
|
if err != nil {
|
|
fmt.Printf("%v failure. %v\n", remote, err)
|
|
} else {
|
|
fmt.Printf("%v success.\n", remote)
|
|
if response.Output != "" {
|
|
fmt.Println("--------------------------------------------------------------------------------")
|
|
fmt.Println(response.Output)
|
|
fmt.Println("--------------------------------------------------------------------------------")
|
|
} else {
|
|
fmt.Println("(no output)")
|
|
}
|
|
}
|
|
}(remote)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func cliStopProcess(c *cli.Context) {
|
|
args := c.Args()
|
|
if len(args) == 0 {
|
|
Exit("Must specify label to stop")
|
|
}
|
|
label := args[0]
|
|
command := btypes.CommandStopProcess{
|
|
Label: label,
|
|
Kill: true,
|
|
}
|
|
wg := sync.WaitGroup{}
|
|
for _, remote := range Config.Remotes {
|
|
wg.Add(1)
|
|
go func(remote string) {
|
|
defer wg.Done()
|
|
response, err := StopProcess(Config.PrivKey, remote, command)
|
|
if err != nil {
|
|
fmt.Printf("%v failure. %v\n", remote, err)
|
|
} else {
|
|
fmt.Printf("%v success. %v\n", remote, response)
|
|
}
|
|
}(remote)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func cliListProcesses(c *cli.Context) {
|
|
/*
|
|
args := c.Args()
|
|
if len(args) == 0 {
|
|
log.Fatal("Must specify application name")
|
|
}
|
|
app := args[0]
|
|
*/
|
|
command := btypes.CommandListProcesses{}
|
|
wg := sync.WaitGroup{}
|
|
for _, remote := range Config.Remotes {
|
|
wg.Add(1)
|
|
go func(remote string) {
|
|
defer wg.Done()
|
|
response, err := ListProcesses(Config.PrivKey, remote, command)
|
|
if err != nil {
|
|
fmt.Printf("%v failure. %v\n", Blue(remote), Red(err))
|
|
} else {
|
|
fmt.Printf("%v processes:\n", Blue(remote))
|
|
for _, proc := range response.Processes {
|
|
fmt.Printf(" \"%v\" => `%v %v` (%v)\n", Yellow(proc.Label), proc.ExecPath, strings.Join(proc.Args, ","), proc.Pid)
|
|
fmt.Printf(" started at %v", proc.StartTime.String())
|
|
if proc.EndTime.IsZero() {
|
|
fmt.Printf(", running still\n")
|
|
} else {
|
|
endTimeStr := proc.EndTime.String()
|
|
fmt.Printf(", stopped at %v\n", Yellow(endTimeStr))
|
|
}
|
|
fmt.Printf(" stdout/stderr goes to %v\n", proc.OutputPath)
|
|
}
|
|
}
|
|
}(remote)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func cliOpenListener(c *cli.Context) {
|
|
args := c.Args()
|
|
if len(args) < 1 {
|
|
Exit("Must specify <listenAddr e.g. [::]:46661>")
|
|
}
|
|
listenAddr := args[0]
|
|
command := btypes.CommandOpenListener{
|
|
Addr: listenAddr,
|
|
}
|
|
wg := sync.WaitGroup{}
|
|
for _, remote := range Config.Remotes {
|
|
wg.Add(1)
|
|
go func(remote string) {
|
|
defer wg.Done()
|
|
response, err := OpenListener(Config.PrivKey, remote, command)
|
|
if err != nil {
|
|
fmt.Printf("%v failure. %v\n", remote, err)
|
|
} else {
|
|
fmt.Printf("%v opened %v.\n", remote, response.Addr)
|
|
}
|
|
}(remote)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func cliCloseListener(c *cli.Context) {
|
|
args := c.Args()
|
|
if len(args) == 0 {
|
|
Exit("Must specify listenAddr to stop")
|
|
}
|
|
listenAddr := args[0]
|
|
command := btypes.CommandCloseListener{
|
|
Addr: listenAddr,
|
|
}
|
|
wg := sync.WaitGroup{}
|
|
for _, remote := range Config.Remotes {
|
|
wg.Add(1)
|
|
go func(remote string) {
|
|
defer wg.Done()
|
|
response, err := CloseListener(Config.PrivKey, remote, command)
|
|
if err != nil {
|
|
fmt.Printf("%v failure. %v\n", remote, err)
|
|
} else {
|
|
fmt.Printf("%v success. %v\n", remote, response)
|
|
}
|
|
}(remote)
|
|
}
|
|
wg.Wait()
|
|
}
|
|
|
|
func cliDownloadFile(c *cli.Context) {
|
|
args := c.Args()
|
|
if len(args) != 2 {
|
|
Exit("Must specify <remote-path> <local-path-prefix>")
|
|
}
|
|
remotePath := args[0]
|
|
localPathPrefix := args[1]
|
|
command := btypes.CommandServeFile{
|
|
Path: remotePath,
|
|
}
|
|
|
|
wg := sync.WaitGroup{}
|
|
for _, remote := range Config.Remotes {
|
|
wg.Add(1)
|
|
go func(remote string, localPath string) {
|
|
defer wg.Done()
|
|
n, err := DownloadFile(Config.PrivKey, remote, command, localPath)
|
|
if err != nil {
|
|
fmt.Printf("%v failure. %v\n", remote, err)
|
|
} else {
|
|
fmt.Printf("%v success. Wrote %v bytes to %v\n", remote, n, localPath)
|
|
}
|
|
}(remote, Fmt("%v_%v", localPathPrefix, remoteNick(remote)))
|
|
}
|
|
wg.Wait()
|
|
}
|