Skeleton certificate scanning

Fix bug in hostname generation not adding additional containers

certificate_manager.go

-package main

certs/certificate_manager.go

+package certs
+
+import (
+	"go.uber.org/zap"
+	"io/ioutil"
+	"path"
+	"strings"
+	"time"
+)
+
+// CertificateManager handles scanning for new/updated certificates and deploying them to a destination.
+type CertificateManager struct {
+	logger      *zap.SugaredLogger
+	directories []string
+}
+
+type foundCertificate struct {
+	cert       string
+	chain      string
+	fullChain  string
+	privateKey string
+	modTime    time.Time
+}
+
+// NewCertificateManager creates a new CertificateManager.
+func NewCertificateManager(logger *zap.SugaredLogger) *CertificateManager {
+	return &CertificateManager{
+		logger: logger,
+	}
+}
+
+func (c *CertificateManager) AddDirectory(directory string) {
+	c.directories = append(c.directories, directory)
+	go c.scanForFolders(directory)
+}
+
+func (c *CertificateManager) scanForFolders(dir string) {
+	dirs, err := ioutil.ReadDir(dir)
+	if err != nil {
+		c.logger.Errorf("Unable to read directory %s - %s", dir, err.Error())
+		return
+	}
+
+	for _, d := range dirs {
+		if d.IsDir() {
+			c.scanForCerts(d.Name(), path.Join(dir, d.Name()))
+		}
+	}
+}
+
+func (c *CertificateManager) scanForCerts(vhost string, dir string) {
+	files, err := ioutil.ReadDir(dir)
+	if err != nil {
+		c.logger.Errorf("Unable to read directory %s - %s", dir, err.Error())
+		return
+	}
+
+	cert := foundCertificate{}
+	for _, f := range files {
+		ext := path.Ext(f.Name())
+		base := path.Base(f.Name())
+		if ext == "" && strings.Contains(base, "-") {
+			switch parts := strings.Split(base, "-"); parts[0] {
+			case "cert":
+				cert.cert = path.Join(dir, f.Name())
+				if f.ModTime().After(cert.modTime) {
+					cert.modTime = f.ModTime()
+				}
+			case "chain":
+				cert.chain = path.Join(dir, f.Name())
+				if f.ModTime().After(cert.modTime) {
+					cert.modTime = f.ModTime()
+				}
+			case "fullchain":
+				cert.fullChain = path.Join(dir, f.Name())
+				if f.ModTime().After(cert.modTime) {
+					cert.modTime = f.ModTime()
+				}
+			case "privkey":
+				cert.privateKey = path.Join(dir, f.Name())
+				if f.ModTime().After(cert.modTime) {
+					cert.modTime = f.ModTime()
+				}
+			}
+		}
+	}
+
+	if len(cert.cert) > 0 && len(cert.chain) > 0 && len(cert.fullChain) > 0 && len(cert.privateKey) > 0 {
+		c.logger.Debugf("Found certificate files for %s in %s", vhost, dir)
+	}
+}

dotege.go

 
 import (
 	"fmt"
+	"github.com/csmith/dotege/certs"
 	"github.com/csmith/dotege/docker"
 	"github.com/csmith/dotege/model"
 	"github.com/docker/docker/client"
 func main() {
 	config := zap.NewDevelopmentConfig()
 	config.DisableCaller = true
+	config.DisableStacktrace = true
 	config.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder
 	config.OutputPaths = []string{"stdout"}
 	config.ErrorOutputPaths = []string{"stdout"}
 		panic(err)
 	}
 
+	certMonitor := certs.NewCertificateManager(sugar)
+	certMonitor.AddDirectory("/certs/certs")
+
 	templateGenerator := NewTemplateGenerator(sugar)
 	templateGenerator.AddTemplate(model.TemplateConfig{
 		Source:      "./templates/domains.txt.tpl",
 	}
 }
 
-func getHostnames(containers map[string]model.Container, config model.LabelConfig) (hostnames map[string]model.Hostname) {
-	hostnames = make(map[string]model.Hostname)
+func getHostnames(containers map[string]model.Container, config model.LabelConfig) (hostnames map[string]*model.Hostname) {
+	hostnames = make(map[string]*model.Hostname)
 	for _, container := range containers {
 		if label, ok := container.Labels[config.Hostnames]; ok {
 			names := strings.Split(strings.Replace(label, ",", " ", -1), " ")
 			if hostname, ok := hostnames[names[0]]; ok {
 				hostname.Containers = append(hostname.Containers, container)
 			} else {
-				hostnames[names[0]] = model.Hostname{
+				hostnames[names[0]] = &model.Hostname{
 					Name:         names[0],
 					Alternatives: make(map[string]bool),
 					Containers:   []model.Container{container},
 	return
 }
 
-func addAlternatives(hostname model.Hostname, alternatives []string) {
+func addAlternatives(hostname *model.Hostname, alternatives []string) {
 	for _, alternative := range alternatives {
 		hostname.Alternatives[alternative] = true
 	}

template_generator.go

 
 type Context struct {
 	Containers map[string]model.Container
-	Hostnames  map[string]model.Hostname
+	Hostnames  map[string]*model.Hostname
 }
 
 type Template struct {
 			panic(err)
 		}
 		if tmpl.content != builder.String() {
-			t.logger.Debugf("%s has been updated, writing to %s", tmpl.config.Source, tmpl.config.Destination)
-			t.logger.Debug(builder.String())
+			t.logger.Infof("Writing updated template to %s", tmpl.config.Destination)
 			tmpl.content = builder.String()
 			err = ioutil.WriteFile(tmpl.config.Destination, []byte(builder.String()), 0666)
 			if err != nil {