func main() { // Most flags are defined in the confd/config package which allows us to // override configuration settings from the command line. Parse the flags now // to make them active. flag.Parse() if printVersion { fmt.Printf("confd %s\n", Version) os.Exit(0) } if configFile == "" { if IsFileExist(defaultConfigFile) { configFile = defaultConfigFile } } // Initialize the global configuration. log.Debug("Loading confd configuration") if err := config.LoadConfig(configFile); err != nil { log.Fatal(err.Error()) } // Configure logging. While you can enable debug and verbose logging, however // if quiet is set to true then debug and verbose messages will not be printed. log.SetQuiet(config.Quiet()) log.SetVerbose(config.Verbose()) log.SetDebug(config.Debug()) log.Notice("Starting confd") // Create the storage client log.Notice("Backend set to " + config.Backend()) store, err := backends.New(config.Backend()) if err != nil { log.Fatal(err.Error()) } signalChan := make(chan os.Signal, 1) signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM) for { runErrors := template.ProcessTemplateResources(store) // If the -onetime flag is passed on the command line we immediately exit // after processing the template config files. if onetime { if len(runErrors) > 0 { os.Exit(1) } os.Exit(0) } select { case c := <-signalChan: log.Info(fmt.Sprintf("captured %v exiting...", c)) os.Exit(0) case <-time.After(time.Duration(config.Interval()) * time.Second): // Continue processing templates. } } }
func main() { flag.Parse() if printVersion { fmt.Printf("confd %s\n", Version) os.Exit(0) } if err := initConfig(); err != nil { log.Fatal(err.Error()) } log.Info("Starting confd") storeClient, err := backends.New(backendsConfig) if err != nil { log.Fatal(err.Error()) } templateConfig.StoreClient = storeClient if onetime { if err := template.Process(templateConfig); err != nil { os.Exit(1) } os.Exit(0) } stopChan := make(chan bool) doneChan := make(chan bool) errChan := make(chan error, 10) var processor template.Processor switch { case config.Watch: processor = template.WatchProcessor(templateConfig, stopChan, doneChan, errChan) default: processor = template.IntervalProcessor(templateConfig, stopChan, doneChan, errChan, config.Interval) } go processor.Process() signalChan := make(chan os.Signal, 1) signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM) for { select { case err := <-errChan: log.Error(err.Error()) case s := <-signalChan: log.Info(fmt.Sprintf("Captured %v. Exiting...", s)) close(doneChan) case <-doneChan: os.Exit(0) } } }
// templateResource creates a templateResource for creating a config file func templateResource() (*TemplateResource, error) { backendConf := backends.Config{ Backend: "env"} client, err := backends.New(backendConf) if err != nil { return nil, err } config := Config{ StoreClient: client, // not used but must be set TemplateDir: "./test/templates", } tr, err := NewTemplateResource(tomlFilePath, config) if err != nil { return nil, err } tr.Dest = "./test/tmp/test.conf" tr.FileMode = 0666 return tr, nil }