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() } }, } }