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)
}
}
}
// NewAsgClient returns EC2 and ASG clients with a connection to the region
// configured via the AWS SDK configuration
// It returns an error if the connection cannot be made and exits if the
// AutoScalingGroup does not exist.
func NewAsgClient(asg string, region *string) (*Client, error) {
providers := []credentials.Provider{
&credentials.SharedCredentialsProvider{},
&credentials.EnvProvider{},
}
ec2RoleConn, ec2RoleErr := net.DialTimeout("tcp", "169.254.169.254:80", 100*time.Millisecond)
if ec2RoleErr == nil {
ec2RoleConn.Close()
providers = append(providers, &ec2rolecreds.EC2RoleProvider{})
}
creds := credentials.NewChainCredentials(providers)
_, credErr := creds.Get()
if credErr != nil {
log.Fatal("Can't find AWS credentials")
return nil, credErr
}
// Use region if provided, otherwise rely on the AWS_REGION
// environment variable.
var c *aws.Config
if region != nil && *region != "" {
c = &aws.Config{
Region: aws.String(*region),
}
}
a := autoscaling.New(c)
e := ec2.New(c)
describeAsgReq, describeAsgErr := a.DescribeAutoScalingGroups(
&autoscaling.DescribeAutoScalingGroupsInput{
AutoScalingGroupNames: []*string{&asg},
},
)
if describeAsgErr != nil {
return nil, describeAsgErr
}
if len(describeAsgReq.AutoScalingGroups) == 0 {
log.Fatal("Can't find Auto Scaling Group with name '" + asg + "'")
}
return &Client{
a,
e,
asg,
}, nil
}
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 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 etcd client upfront and use it for the life of the process.
// The etcdClient is an http.Client and designed to be reused.
log.Notice("etcd nodes set to " + strings.Join(config.EtcdNodes(), ", "))
etcdClient, err := etcdutil.NewEtcdClient(config.EtcdNodes(), config.ClientCert(), config.ClientKey(), config.ClientCaKeys())
if err != nil {
log.Fatal(err.Error())
}
for {
runErrors := template.ProcessTemplateResources(etcdClient)
// 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)
}
time.Sleep(time.Duration(config.Interval()) * time.Second)
}
}
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 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
store, err := createStoreClient(config.Backend())
if err != nil {
log.Fatal(err.Error())
}
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)
}
time.Sleep(time.Duration(config.Interval()) * time.Second)
}
}
func (p *watchProcessor) Process() {
defer close(p.doneChan)
ts, err := getTemplateResources(p.config)
if err != nil {
log.Fatal(err.Error())
return
}
for _, t := range ts {
t := t
p.wg.Add(1)
go p.monitorPrefix(t)
}
p.wg.Wait()
}
func (p *intervalProcessor) Process() {
defer close(p.doneChan)
ts, err := getTemplateResources(p.config)
if err != nil {
log.Fatal(err.Error())
return
}
for {
process(ts)
select {
case <-p.stopChan:
break
case <-time.After(time.Duration(p.interval) * time.Second):
continue
}
}
}
func main() {
log.Info("Starting confd")
// All flags are defined in the confd/config package which allow us to
// override configuration settings from the cli. Parse the flags now to
// make them active.
flag.Parse()
if err := InitConfig(); err != nil {
log.Fatal(err.Error())
}
for {
if err := ProcessTemplateResources(); err != nil {
log.Error(err.Error())
}
// If the -onetime flag is passed on the command line we immediately exit
// after processing the template config files.
if Onetime() {
break
}
// By default we poll etcd every 30 seconds
time.Sleep(time.Duration(Interval()) * time.Second)
}
}