func TestRecursiveFindFiles(t *testing.T) {
log.SetLevel("warn")
// Setup temporary directories
rootDir, err := createRecursiveDirs()
if err != nil {
t.Errorf("Failed to create temp dirs: %s", err.Error())
}
defer os.RemoveAll(rootDir)
files, err := recursiveFindFiles(rootDir, "*toml")
if err != nil {
t.Errorf("Failed to run recursiveFindFiles, got error: " + err.Error())
}
sort.Strings(files)
exceptedFiles := []string{
rootDir + "/" + "root.toml",
rootDir + "/subDir1/" + "sub1.toml",
rootDir + "/subDir1/" + "sub12.toml",
rootDir + "/subDir2/" + "sub2.toml",
rootDir + "/subDir2/" + "sub22.toml",
rootDir + "/subDir2/subSubDir/" + "subsub.toml",
rootDir + "/subDir2/subSubDir/" + "subsub2.toml",
}
for i, f := range exceptedFiles {
if f != files[i] {
t.FailNow()
}
}
}
func TestSameConfigFalse(t *testing.T) {
log.SetLevel("warn")
src, err := ioutil.TempFile("", "src")
defer os.Remove(src.Name())
if err != nil {
t.Errorf(err.Error())
}
_, err = src.WriteString("src")
if err != nil {
t.Errorf(err.Error())
}
dest, err := ioutil.TempFile("", "dest")
defer os.Remove(dest.Name())
if err != nil {
t.Errorf(err.Error())
}
_, err = dest.WriteString("dest")
if err != nil {
t.Errorf(err.Error())
}
status, err := sameConfig(src.Name(), dest.Name())
if err != nil {
t.Errorf(err.Error())
}
if status != false {
t.Errorf("Expected sameConfig(src, dest) to be %v, got %v", false, status)
}
}
func TestInitConfigDefaultConfig(t *testing.T) {
log.SetLevel("warn")
want := Config{
Backend: "etcd",
BackendNodes: []string{"http://127.0.0.1:4001"},
ClientCaKeys: "",
ClientCert: "",
ClientKey: "",
ConfDir: "/etc/confd",
Interval: 600,
Noop: false,
Prefix: "/",
SRVDomain: "",
Scheme: "http",
Table: "",
Asg: "",
AWSRegion: "",
}
if err := initConfig(); err != nil {
t.Errorf(err.Error())
}
if !reflect.DeepEqual(want, config) {
t.Errorf("initConfig() = %v, want %v", config, want)
}
}
// initConfig initializes the confd configuration by first setting defaults,
// then overriding settings from the confd config file, then overriding
// settings from environment variables, and finally overriding
// settings from flags set on the command line.
// It returns an error if any.
func initConfig() error {
if configFile == "" {
if _, err := os.Stat(defaultConfigFile); !os.IsNotExist(err) {
configFile = defaultConfigFile
}
}
// Set defaults.
config = Config{
Backend: "etcd",
ConfDir: "/etc/confd",
Interval: 600,
Prefix: "/",
Scheme: "http",
}
// Update config from the TOML configuration file.
if configFile == "" {
log.Debug("Skipping confd config file.")
} else {
log.Debug("Loading " + configFile)
configBytes, err := ioutil.ReadFile(configFile)
if err != nil {
return err
}
_, err = toml.Decode(string(configBytes), &config)
if err != nil {
return err
}
}
// Update config from environment variables.
processEnv()
// Update config from commandline flags.
processFlags()
if config.LogLevel != "" {
log.SetLevel(config.LogLevel)
}
// Update BackendNodes from SRV records.
if config.Backend != "env" && config.SRVDomain != "" {
log.Info("SRV domain set to " + config.SRVDomain)
srvNodes, err := getBackendNodesFromSRV(config.Backend, config.SRVDomain, config.Scheme)
if err != nil {
return errors.New("Cannot get nodes from SRV records " + err.Error())
}
config.BackendNodes = srvNodes
}
if len(config.BackendNodes) == 0 {
switch config.Backend {
case "consul":
config.BackendNodes = []string{"127.0.0.1:8500"}
case "etcd":
peerstr := os.Getenv("ETCDCTL_PEERS")
if len(peerstr) > 0 {
config.BackendNodes = strings.Split(peerstr, ",")
} else {
config.BackendNodes = []string{"http://127.0.0.1:4001"}
}
case "redis":
config.BackendNodes = []string{"127.0.0.1:6379"}
case "zookeeper":
config.BackendNodes = []string{"127.0.0.1:2181"}
}
}
// Initialize the storage client
log.Info("Backend set to " + config.Backend)
if config.Watch {
unsupportedBackends := map[string]bool{
"zookeeper": true,
"redis": true,
"dynamodb": true,
"rancher": true,
}
if unsupportedBackends[config.Backend] {
log.Info(fmt.Sprintf("Watch is not supported for backend %s. Exiting...", config.Backend))
os.Exit(1)
}
}
if config.Backend == "dynamodb" && config.Table == "" {
return errors.New("No DynamoDB table configured")
}
backendsConfig = backends.Config{
AuthToken: config.AuthToken,
Backend: config.Backend,
ClientCaKeys: config.ClientCaKeys,
ClientCert: config.ClientCert,
ClientKey: config.ClientKey,
BackendNodes: config.BackendNodes,
Scheme: config.Scheme,
Table: config.Table,
}
// Template configuration.
templateConfig = template.Config{
ConfDir: config.ConfDir,
ConfigDir: filepath.Join(config.ConfDir, "conf.d"),
KeepStageFile: keepStageFile,
Noop: config.Noop,
Prefix: config.Prefix,
TemplateDir: filepath.Join(config.ConfDir, "templates"),
}
return nil
}
func TestProcessTemplateResources(t *testing.T) {
log.SetLevel("warn")
// Setup temporary conf, config, and template directories.
tempConfDir, err := createTempDirs()
if err != nil {
t.Errorf("Failed to create temp dirs: %s", err.Error())
}
defer os.RemoveAll(tempConfDir)
// Create the src template.
srcTemplateFile := filepath.Join(tempConfDir, "templates", "foo.tmpl")
err = ioutil.WriteFile(srcTemplateFile, []byte(`foo = {{getv "/foo"}}`), 0644)
if err != nil {
t.Error(err.Error())
}
// Create the dest.
destFile, err := ioutil.TempFile("", "")
if err != nil {
t.Errorf("Failed to create destFile: %s", err.Error())
}
defer os.Remove(destFile.Name())
// Create the template resource configuration file.
templateResourcePath := filepath.Join(tempConfDir, "conf.d", "foo.toml")
templateResourceFile, err := os.Create(templateResourcePath)
if err != nil {
t.Errorf(err.Error())
}
tmpl, err := template.New("templateResourceConfig").Parse(templateResourceConfigTmpl)
if err != nil {
t.Errorf("Unable to parse template resource template: %s", err.Error())
}
data := make(map[string]string)
data["src"] = "foo.tmpl"
data["dest"] = destFile.Name()
err = tmpl.Execute(templateResourceFile, data)
if err != nil {
t.Errorf(err.Error())
}
os.Setenv("FOO", "bar")
storeClient, err := env.NewEnvClient()
if err != nil {
t.Errorf(err.Error())
}
c := Config{
ConfDir: tempConfDir,
ConfigDir: filepath.Join(tempConfDir, "conf.d"),
StoreClient: storeClient,
TemplateDir: filepath.Join(tempConfDir, "templates"),
}
// Process the test template resource.
err = Process(c)
if err != nil {
t.Error(err.Error())
}
// Verify the results.
expected := "foo = bar"
results, err := ioutil.ReadFile(destFile.Name())
if err != nil {
t.Error(err.Error())
}
if string(results) != expected {
t.Errorf("Expected contents of dest == '%s', got %s", expected, string(results))
}
}