func helpPrinter(w io.Writer, templ string, data interface{}) { cliHelpPrinter(w, templ, data) fmt.Fprintf(w, providerHelpHeader) margin := 4 maxLen := 0 backend.EachBackend(func(b *backend.Backend) { for itemKey := range b.ProviderHelp { if len(itemKey) > maxLen { maxLen = len(itemKey) } } }) itemFmt := fmt.Sprintf("%%%ds - %%s\n", maxLen+margin) backend.EachBackend(func(b *backend.Backend) { fmt.Fprintf(w, "\n%s provider help:\n\n", b.HumanReadableName) sortedKeys := []string{} for key := range b.ProviderHelp { sortedKeys = append(sortedKeys, key) } sort.Strings(sortedKeys) for _, key := range sortedKeys { fmt.Printf(itemFmt, key, b.ProviderHelp[key]) } }) fmt.Println("") }
func workWithBackendProviderCommands(queueType string, flags []cli.Flag) []cli.Command { config.DefaultConfig.QueueType = queueType commands := []cli.Command{} backend.EachBackend(func(b *backend.Backend) { commands = append(commands, cli.Command{ Name: b.Alias, Aliases: []string{string(b.Alias[0])}, Usage: fmt.Sprintf("Work with queue type of %q and backend of %q", queueType, b.Alias), Flags: append(b.Flags, flags...), Action: func(c *cli.Context) { config.DefaultConfig.ProviderName = b.Alias runWorker(c) }, }) }) return commands }
func listBackendProviders(c *cli.Context) { backend.EachBackend(func(b *backend.Backend) { fmt.Println(b.Alias) }) }
// Setup runs one-time preparatory actions and returns a boolean success value // that is used to determine if it is safe to invoke the Run func func (i *CLI) Setup() (bool, error) { if i.c.String("pprof-port") != "" { // Start net/http/pprof server go func() { http.ListenAndServe(fmt.Sprintf("localhost:%s", i.c.String("pprof-port")), nil) }() } if i.c.Bool("debug") { logrus.SetLevel(logrus.DebugLevel) } ctx, cancel := gocontext.WithCancel(gocontext.Background()) logger := context.LoggerFromContext(ctx) i.ctx = ctx i.cancel = cancel i.logger = logger logrus.SetFormatter(&logrus.TextFormatter{DisableColors: true}) cfg := config.FromCLIContext(i.c) i.Config = cfg if i.c.Bool("echo-config") { config.WriteEnvConfig(cfg, os.Stdout) return false, nil } if i.c.Bool("list-backend-providers") { backend.EachBackend(func(b *backend.Backend) { fmt.Println(b.Alias) }) return false, nil } logger.WithFields(logrus.Fields{ "cfg": fmt.Sprintf("%#v", cfg), }).Debug("read config") i.setupSentry() i.setupMetrics() err := i.setupJobQueueAndCanceller() if err != nil { logger.WithField("err", err).Error("couldn't create job queue and canceller") return false, err } generator := NewBuildScriptGenerator(cfg) logger.WithFields(logrus.Fields{ "build_script_generator": fmt.Sprintf("%#v", generator), }).Debug("built") i.BuildScriptGenerator = generator provider, err := backend.NewBackendProvider(cfg.ProviderName, cfg.ProviderConfig) if err != nil { logger.WithField("err", err).Error("couldn't create backend provider") return false, err } err = provider.Setup(ctx) if err != nil { logger.WithField("err", err).Error("couldn't setup backend provider") return false, err } logger.WithFields(logrus.Fields{ "provider": fmt.Sprintf("%#v", provider), }).Debug("built") i.BackendProvider = provider ppc := &ProcessorPoolConfig{ Hostname: cfg.Hostname, Context: ctx, HardTimeout: cfg.HardTimeout, LogTimeout: cfg.LogTimeout, ScriptUploadTimeout: cfg.ScriptUploadTimeout, StartupTimeout: cfg.StartupTimeout, } pool := NewProcessorPool(ppc, i.BackendProvider, i.BuildScriptGenerator, i.Canceller) pool.SkipShutdownOnLogTimeout = cfg.SkipShutdownOnLogTimeout logger.WithFields(logrus.Fields{ "pool": pool, }).Debug("built") i.ProcessorPool = pool return true, nil }