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
}
}
}