func (cli *CLI) setup(config *Config) (*Config, error) { if config.Path != "" { newConfig, err := ConfigFromPath(config.Path) if err != nil { return nil, err } // Merge ensuring that the CLI options still take precedence newConfig.Merge(config) config = newConfig } // Setup the logging if err := logging.Setup(&logging.Config{ Name: Name, Level: config.LogLevel, Syslog: config.Syslog.Enabled, SyslogFacility: config.Syslog.Facility, Writer: cli.errStream, }); err != nil { return nil, err } return config, nil }
func (cli *CLI) setup(conf *config.Config) (*config.Config, error) { if err := logging.Setup(&logging.Config{ Name: Name, Level: config.StringVal(conf.LogLevel), Syslog: config.BoolVal(conf.Syslog.Enabled), SyslogFacility: config.StringVal(conf.Syslog.Facility), Writer: cli.errStream, }); err != nil { return nil, err } return conf, nil }
func parseFlags(args []string) (*config.Config, error) { var doHelp bool var c = config.DefaultConfig() flags := flag.NewFlagSet("mesos-consul", flag.ContinueOnError) flags.Usage = func() { fmt.Print(usage) } flags.BoolVar(&doHelp, "help", false, "") flags.StringVar(&c.LogLevel, "log-level", "WARN", "") flags.DurationVar(&c.Refresh, "refresh", time.Minute, "") flags.StringVar(&c.RegistryPort, "registry-port", "8500", "") flags.Var((*config.AuthVar)(c.RegistryAuth), "registry-auth", "") flags.BoolVar(&c.RegistrySSL.Enabled, "registry-ssl", c.RegistrySSL.Enabled, "") flags.BoolVar(&c.RegistrySSL.Verify, "registry-ssl-verify", c.RegistrySSL.Verify, "") flags.StringVar(&c.RegistrySSL.Cert, "registry-ssl-cert", c.RegistrySSL.Cert, "") flags.StringVar(&c.RegistrySSL.CaCert, "registry-ssl-cacert", c.RegistrySSL.CaCert, "") flags.StringVar(&c.RegistryToken, "registry-token", c.RegistryToken, "") flags.StringVar(&c.Zk, "zk", "zk://127.0.0.1:2181/mesos", "") if err := flags.Parse(args); err != nil { return nil, err } args = flags.Args() if len(args) > 0 { return nil, fmt.Errorf("extra argument(s): %q", args) } if doHelp { flags.Usage() os.Exit(0) } logging.Setup(&logging.Config{ Name: "mesos-consul", Level: c.LogLevel, Writer: os.Stderr, }) return c, nil }
// Run accepts a slice of arguments and returns an int representing the exit // status from the command. func (cli *CLI) Run(args []string) int { // Parse the flags and args config, command, once, version, err := cli.parseFlags(args[1:]) if err != nil { return cli.handleError(err, ExitCodeParseFlagsError) } // If a path was given, load the config from file if config.Path != "" { newConfig, err := ConfigFromPath(config.Path) if err != nil { return cli.handleError(err, ExitCodeConfigError) } // Merge ensuring that the CLI options still take precedence newConfig.Merge(config) config = newConfig } // Setup the logging if err := logging.Setup(&logging.Config{ Name: Name, Level: config.LogLevel, Syslog: config.Syslog.Enabled, SyslogFacility: config.Syslog.Facility, Writer: cli.errStream, }); err != nil { return cli.handleError(err, ExitCodeLoggingError) } // Return an error if no command was given if len(command) == 0 && !version { return cli.handleError(ErrMissingCommand, ExitCodeUsageError) } // Print version information for debugging log.Printf("[INFO] envconsul v%s", Version) // If the version was requested, return an "error" containing the version // information. This might sound weird, but most *nix applications actually // print their version on stderr anyway. if version { log.Printf("[DEBUG] (cli) version flag was given, exiting now") fmt.Fprintf(cli.errStream, "%s v%s\n", Name, Version) return ExitCodeOK } // Initial runner runner, err := NewRunner(config, command, once) if err != nil { return cli.handleError(err, ExitCodeRunnerError) } go runner.Start() // Listen for signals signalCh := make(chan os.Signal, 1) signal.Notify(signalCh, Signals...) for { select { case err := <-runner.ErrCh: return cli.handleError(err, ExitCodeRunnerError) case <-runner.DoneCh: return ExitCodeOK case code := <-runner.ExitCh: log.Printf("[INFO] (cli) subprocess exited") runner.Stop() if code == ExitCodeOK { return ExitCodeOK } else { err := fmt.Errorf("unexpected exit from subprocess (%d)", code) return cli.handleError(err, code) } case s := <-signalCh: // Propogate the signal to the child process runner.Signal(s) switch s { case syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT: fmt.Fprintf(cli.errStream, "Received interrupt, cleaning up...\n") runner.Stop() return ExitCodeInterrupt } case <-cli.stopCh: return ExitCodeOK } } }
// Run accepts a slice of arguments and returns an int representing the exit // status from the command. func (cli *CLI) Run(args []string) int { // Parse the flags config, once, dry, version, err := cli.parseFlags(args[1:]) if err != nil { return cli.handleError(err, ExitCodeParseFlagsError) } // If a path was given, load the config from file if config.Path != "" { newConfig, err := ConfigFromPath(config.Path) if err != nil { return cli.handleError(err, ExitCodeConfigError) } // Merge ensuring that the CLI options still take precedence newConfig.Merge(config) config = newConfig } // Setup the logging if err := logging.Setup(&logging.Config{ Name: Name, Level: config.LogLevel, Syslog: config.Syslog.Enabled, SyslogFacility: config.Syslog.Facility, Writer: cli.errStream, }); err != nil { return cli.handleError(err, ExitCodeLoggingError) } // Print version information for debugging log.Printf("[INFO] Consul Template v%s", Version) // If the version was requested, return an "error" containing the version // information. This might sound weird, but most *nix applications actually // print their version on stderr anyway. if version { log.Printf("[DEBUG] (cli) version flag was given, exiting now") fmt.Fprintf(cli.errStream, "%s v%s\n", Name, Version) return ExitCodeOK } // Initial runner runner, err := NewRunner(config, dry, once) if err != nil { return cli.handleError(err, ExitCodeRunnerError) } go runner.Start() // Listen for signals signalCh := make(chan os.Signal, 1) signal.Notify(signalCh, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT, ) for { select { case err := <-runner.ErrCh: return cli.handleError(err, ExitCodeRunnerError) case <-runner.DoneCh: return ExitCodeOK case s := <-signalCh: switch s { case syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT: fmt.Fprintf(cli.errStream, "Received interrupt, cleaning up...\n") runner.Stop() return ExitCodeInterrupt case syscall.SIGHUP: fmt.Fprintf(cli.errStream, "Received HUP, reloading configuration...\n") runner.Stop() runner, err = NewRunner(config, dry, once) if err != nil { return cli.handleError(err, ExitCodeRunnerError) } go runner.Start() } case <-cli.stopCh: return ExitCodeOK } } }