func VitalsCommand() common.Command {
var (
addrs string
)
flagSet := flag.NewFlagSet("vitals", flag.ExitOnError)
flagSet.StringVar(&addrs, "vitalsAddrs", "", "debug addresses: name:addr:port,...")
return common.Command{
Name: "vitals",
Description: "[file] - Fetch vitals for passed in golang processes",
FlagSet: flagSet,
Run: func(args []string) {
vitalsAddrs, err := config_finder.FindVitalsAddrs(addrs)
common.ExitIfError("Could not find vitals addrs", err)
if len(args) == 0 {
err := vitals.Vitals(vitalsAddrs, os.Stdout)
common.ExitIfError("Failed to fetch vitals", err)
} else {
f, err := os.Create(args[0])
common.ExitIfError("Could not create file", err)
err = vitals.Vitals(vitalsAddrs, f)
common.ExitIfError("Failed to fetch vitals", err)
f.Close()
}
},
}
}
func PrintStoreCommand() common.Command {
var (
tasks bool
lrps bool
verbose bool
)
flagSet := flag.NewFlagSet("print-store", flag.ExitOnError)
flagSet.BoolVar(&verbose, "v", false, "be verbose")
flagSet.BoolVar(&tasks, "tasks", true, "print tasks")
flagSet.BoolVar(&lrps, "lrps", true, "print lrps")
return common.Command{
Name: "print-store",
Description: "[file] - Print previously fetched contents of the BBS. If file is blank, reads from stdin.",
FlagSet: flagSet,
Run: func(args []string) {
if len(args) == 0 {
err := print_store.PrintStore(verbose, tasks, lrps, false, os.Stdin)
common.ExitIfError("Failed to print store", err)
} else {
f, err := os.Open(args[0])
common.ExitIfError("Could not open file", err)
err = print_store.PrintStore(verbose, tasks, lrps, false, f)
common.ExitIfError("Failed to print store", err)
}
},
}
}
func GetDesiredLRPCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
)
flagSet := flag.NewFlagSet("get-desired-lrp", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
return common.Command{
Name: "get-desired-lrp",
Description: "<process-guid> - get a DesiredLRP",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
if len(args) == 0 {
say.Fprintln(os.Stderr, 0, say.Red("missing process-guid"))
os.Exit(1)
}
desiredLRP, err := bbsClient.DesiredLRPByProcessGuid(args[0])
common.ExitIfError("Failed to fetch DesiredLRP", err)
preview, _ := json.MarshalIndent(desiredLRP, "", " ")
say.Println(0, string(preview))
},
}
}
func RemoveLRPCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
)
flagSet := flag.NewFlagSet("remove-lrp", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
return common.Command{
Name: "remove-lrp",
Description: "<process-guid> - remove an lrp",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
if len(args) == 0 {
say.Fprintln(os.Stderr, 0, say.Red("You must specify a process-guid"))
os.Exit(1)
} else {
err := bbsClient.RemoveDesiredLRP(args[0])
common.ExitIfError("Failed to remove lrp", err)
}
},
}
}
func FetchStoreCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
)
flagSet := flag.NewFlagSet("fetch-store", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
return common.Command{
Name: "fetch-store",
Description: "[file] - Fetch contents of the BBS",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
if len(args) == 0 {
err := fetch_store.Fetch(bbsClient, os.Stdout)
common.ExitIfError("Failed to fetch store", err)
} else {
f, err := os.Create(args[0])
common.ExitIfError("Could not create file", err)
err = fetch_store.Fetch(bbsClient, f)
common.ExitIfError("Failed to fetch store", err)
f.Close()
}
},
}
}
func SetDomainCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
)
flagSet := flag.NewFlagSet("set-domain", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
return common.Command{
Name: "set-domain",
Description: "domain ttl - updates the domain in the BBS (ttl is a duration)",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
if len(args) != 2 {
say.Fprintln(os.Stderr, 0, say.Red("Expected domain and ttl"))
os.Exit(1)
}
ttl, err := time.ParseDuration(args[1])
common.ExitIfError("Failed to parse TTL", err)
err = set_domain.SetDomain(bbsClient, args[0], ttl)
common.ExitIfError("Failed to submit lrp", err)
},
}
}
func UnifyChugCommand() common.Command {
var (
minTimeFlag string
maxTimeFlag string
matchFlag string
excludeFlag string
)
flagSet := baseFlagSet("chug-unify", &minTimeFlag, &maxTimeFlag, &matchFlag, &excludeFlag)
return common.Command{
Name: "chug-unify",
Description: "file1, file2,... - Combine lager files in temporal order",
FlagSet: flagSet,
Run: func(args []string) {
minTime, maxTime, match, exclude := parseBaseFlags(minTimeFlag, maxTimeFlag, matchFlag, excludeFlag)
if len(args) == 0 {
say.Println(0, say.Red("You must pass chug-unify files to combine"))
os.Exit(1)
} else {
files := []io.Reader{}
for _, arg := range args {
f, err := os.Open(arg)
common.ExitIfError("Could not open file", err)
files = append(files, f)
}
err := Unify(files, os.Stdout, minTime, maxTime, match, exclude)
common.ExitIfError("Failed to chug-unify", err)
}
},
}
}
func GardenContainersCommand() common.Command {
var (
raw bool
gardenAddr string
gardenNetwork string
)
flagSet := flag.NewFlagSet("garden-containers", flag.ExitOnError)
flagSet.BoolVar(&raw, "raw", false, "display raw response")
flagSet.StringVar(&gardenAddr, "gardenAddr", "", "garden API address")
flagSet.StringVar(&gardenNetwork, "gardenNetwork", "", "garden API network (unix/tcp)")
return common.Command{
Name: "garden-containers",
Description: "[file] - Fetch garden containers",
FlagSet: flagSet,
Run: func(args []string) {
gardenAddr, gardenNetwork, err := config_finder.FindGardenAddr(gardenAddr, gardenNetwork)
common.ExitIfError("Could not find garden", err)
if len(args) == 0 {
err := garden.GardenContainers(gardenAddr, gardenNetwork, raw, os.Stdout)
common.ExitIfError("Failed to fetch garden containers", err)
} else {
f, err := os.Create(args[0])
common.ExitIfError("Could not create file", err)
err = garden.GardenContainers(gardenAddr, gardenNetwork, raw, f)
common.ExitIfError("Failed to fetch garden containers", err)
f.Close()
}
},
}
}
func GetActualLRPCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
)
flagSet := flag.NewFlagSet("get-actual-lrp", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
return common.Command{
Name: "get-actual-lrp",
Description: "<process-guid> <optional: index> - get an ActualLRP",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
var index = -1
if len(args) == 0 {
say.Fprintln(os.Stderr, 0, say.Red("missing process-guid"))
os.Exit(1)
}
processGuid := args[0]
if len(args) == 2 {
index, err = strconv.Atoi(args[1])
common.ExitIfError("Could not parse index", err)
}
if index == -1 {
actualLRPGroups, err := bbsClient.ActualLRPGroupsByProcessGuid(processGuid)
common.ExitIfError("Could not fetch ActualLRPs", err)
for _, actualLRPGroup := range actualLRPGroups {
actualLRP, _ := actualLRPGroup.Resolve()
preview, _ := json.MarshalIndent(actualLRP, "", " ")
say.Println(0, string(preview))
}
} else {
actualLRPGroup, err := bbsClient.ActualLRPGroupByProcessGuidAndIndex(processGuid, index)
common.ExitIfError("Could not fetch ActualLRP", err)
actualLRP, _ := actualLRPGroup.Resolve()
preview, _ := json.MarshalIndent(actualLRP, "", " ")
say.Println(0, string(preview))
}
},
}
}
func parseBaseFlags(minTimeFlag, maxTimeFlag, matchFlag, excludeFlag string) (time.Time, time.Time, *regexp.Regexp, *regexp.Regexp) {
minTime, err := ParseTimeFlag(minTimeFlag)
common.ExitIfError("Failed to parse -min", err)
maxTime, err := ParseTimeFlag(maxTimeFlag)
common.ExitIfError("Failed to parse -max", err)
match, err := regexp.Compile(matchFlag)
common.ExitIfError("Failed to parse -match", err)
if matchFlag == "" {
match = nil
}
exclude, err := regexp.Compile(excludeFlag)
common.ExitIfError("Failed to parse -match", err)
if excludeFlag == "" {
exclude = nil
}
return minTime, maxTime, match, exclude
}
func UpdateDesiredLRPCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
)
flagSet := flag.NewFlagSet("update-lrp", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
return common.Command{
Name: "update-lrp",
Description: "<process-guid> <path to json file> - update a DesiredLRP",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
var raw = []byte{}
if len(args) == 0 {
say.Fprintln(os.Stderr, 0, say.Red("missing process-guid"))
os.Exit(1)
} else if len(args) == 1 {
say.Fprintln(os.Stderr, 0, "Reading from stdin...")
raw, err = ioutil.ReadAll(os.Stdin)
common.ExitIfError("Failed to read from stdin", err)
} else {
raw, err = ioutil.ReadFile(args[1])
common.ExitIfError("Failed to read from file", err)
}
desiredLRPUpdate := &models.DesiredLRPUpdate{}
err = json.Unmarshal(raw, desiredLRPUpdate)
common.ExitIfError("Failed to decode DesiredLRPUpdate", err)
say.Println(0, "Updating %s:", args[0])
preview, _ := json.MarshalIndent(desiredLRPUpdate, "", " ")
say.Println(0, string(preview))
err = bbsClient.UpdateDesiredLRP(args[0], desiredLRPUpdate)
common.ExitIfError("Failed to update DesiredLRP", err)
},
}
}
func CreateDesiredLRPCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
)
flagSet := flag.NewFlagSet("desire-lrp", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
return common.Command{
Name: "desire-lrp",
Description: "<path to json file> - create a DesiredLRP",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
var raw = []byte{}
if len(args) == 0 {
say.Fprintln(os.Stderr, 0, "Reading from stdin...")
raw, err = ioutil.ReadAll(os.Stdin)
common.ExitIfError("Failed to read from stdin", err)
} else {
raw, err = ioutil.ReadFile(args[0])
common.ExitIfError("Failed to read from file", err)
}
desiredLRP := &models.DesiredLRP{}
err = json.Unmarshal(raw, desiredLRP)
common.ExitIfError("Failed to decode DesiredLRP", err)
say.Println(0, "Desiring:")
preview, _ := json.MarshalIndent(desiredLRP, "", " ")
say.Println(0, string(preview))
err = bbsClient.DesireLRP(desiredLRP)
common.ExitIfError("Failed to desire DesiredLRP", err)
},
}
}
func DumpStoreCommand() common.Command {
var (
bbsConfig config_finder.BBSConfig
tasks bool
lrps bool
rate time.Duration
verbose bool
)
flagSet := flag.NewFlagSet("dump-store", flag.ExitOnError)
bbsConfig.PopulateFlags(flagSet)
flagSet.BoolVar(&tasks, "tasks", true, "print tasks")
flagSet.BoolVar(&lrps, "lrps", true, "print lrps")
flagSet.BoolVar(&verbose, "v", false, "be verbose")
flagSet.DurationVar(&rate, "rate", time.Duration(0), "rate at which to poll the store")
return common.Command{
Name: "dump-store",
Description: "- Fetch and print contents of the BBS",
FlagSet: flagSet,
Run: func(args []string) {
bbsClient, err := config_finder.NewBBS(bbsConfig)
common.ExitIfError("Could not construct BBS", err)
if rate == 0 {
err = dump(bbsClient, verbose, tasks, lrps, false)
common.ExitIfError("Failed to dump", err)
return
}
ticker := time.NewTicker(rate)
for {
<-ticker.C
err = dump(bbsClient, verbose, tasks, lrps, true)
if err != nil {
say.Println(0, say.Red("Failed to dump: %s", err.Error()))
}
}
},
}
}
func AutodetectCommand() common.Command {
flagSet := flag.NewFlagSet("autodetect", flag.ExitOnError)
return common.Command{
Name: "autodetect",
Description: "- autodetect configuration **must be run on a bosh vm**",
FlagSet: flagSet,
Run: func(args []string) {
err := Autodetect(os.Stdout)
common.ExitIfError("Autodetect failed", err)
},
}
}
func RepStateCommand() common.Command {
flagSet := flag.NewFlagSet("rep-state", flag.ExitOnError)
return common.Command{
Name: "rep-state",
Description: "- Fetch state for rep on localhost",
FlagSet: flagSet,
Run: func(args []string) {
err := rep.RepState(os.Stdout)
common.ExitIfError("Failed to fetch rep state", err)
},
}
}
func ChugCommand() common.Command {
var (
minTimeFlag string
maxTimeFlag string
matchFlag string
excludeFlag string
rel string
data string
hideNonLager bool
)
flagSet := baseFlagSet("chug", &minTimeFlag, &maxTimeFlag, &matchFlag, &excludeFlag)
flagSet.StringVar(&rel, "rel", "", "render timestamps as durations relative to: 'first', 'now', or a number interpreted as a unix timestamp")
flagSet.StringVar(&data, "data", "short", "render data: 'none', 'short', 'long'")
flagSet.BoolVar(&hideNonLager, "hide", false, "hide non-lager logs")
return common.Command{
Name: "chug",
Description: "[file] - Prettify lager logs",
FlagSet: flagSet,
Run: func(args []string) {
minTime, maxTime, match, exclude := parseBaseFlags(minTimeFlag, maxTimeFlag, matchFlag, excludeFlag)
if len(args) == 0 {
err := Prettify(rel, data, hideNonLager, minTime, maxTime, match, exclude, os.Stdin)
common.ExitIfError("Failed to chug", err)
} else {
f, err := os.Open(args[0])
common.ExitIfError("Could not open file", err)
err = Prettify(rel, data, hideNonLager, minTime, maxTime, match, exclude, f)
common.ExitIfError("Failed to chug", err)
f.Close()
}
},
}
}
func ServeChugCommand() common.Command {
var (
minTimeFlag string
maxTimeFlag string
matchFlag string
excludeFlag string
addr string
dev bool
)
flagSet := baseFlagSet("chug-serve", &minTimeFlag, &maxTimeFlag, &matchFlag, &excludeFlag)
flagSet.StringVar(&addr, "addr", "0.0.0.0:0", "address to serve chug")
flagSet.BoolVar(&dev, "dev", false, "dev mode")
return common.Command{
Name: "chug-serve",
Description: "[file] - Serve up pretty lager logs",
FlagSet: flagSet,
Run: func(args []string) {
minTime, maxTime, match, exclude := parseBaseFlags(minTimeFlag, maxTimeFlag, matchFlag, excludeFlag)
if len(args) == 0 {
err := ServeLogs(addr, dev, minTime, maxTime, match, exclude, os.Stdin)
common.ExitIfError("Failed to serve chug", err)
} else {
f, err := os.Open(args[0])
common.ExitIfError("Could not open file", err)
err = ServeLogs(addr, dev, minTime, maxTime, match, exclude, f)
common.ExitIfError("Failed to serve chug", err)
f.Close()
}
},
}
}
