Deploy certs

docker.go

 	ContainerInspect(ctx context.Context, containerID string) (types.ContainerJSON, error)
 }
 
-func monitorContainers(client DockerClient, stop <-chan struct{}, addedFn func(model.Container), removedFn func(string)) error {
+func monitorContainers(client DockerClient, stop <-chan struct{}, addedFn func(*model.Container), removedFn func(string)) error {
 	ctx, cancel := context.WithCancel(context.Background())
 	stream, errors := startEventStream(client, ctx)
 
 					cancel()
 					return err
 				}
-				addedFn(container)
+				addedFn(&container)
 			} else {
 				removedFn(event.Actor.Attributes["name"])
 			}
 	return client.Events(ctx, types.EventsOptions{Filters: args})
 }
 
-func publishExistingContainers(client DockerClient, ctx context.Context, addedFn func(model.Container)) error {
+func publishExistingContainers(client DockerClient, ctx context.Context, addedFn func(*model.Container)) error {
 	containers, err := client.ContainerList(ctx, types.ContainerListOptions{})
 	if err != nil {
 		return fmt.Errorf("unable to list containers: %s", err.Error())
 	}
 
 	for _, container := range containers {
-		addedFn(model.Container{
+		addedFn(&model.Container{
 			Id:     container.ID,
 			Name:   container.Names[0][1:],
 			Labels: container.Labels,

dotege.go

 	"github.com/xenolf/lego/lego"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
+	"io/ioutil"
 	"os"
 	"os/signal"
+	"path"
 	"strings"
 	"syscall"
 	"time"
 	envTemplateSourceDefault      = "./templates/haproxy.cfg.tpl"
 )
 
+var (
+	logger             *zap.SugaredLogger
+	certificateManager *CertificateManager
+	config             *model.Config
+)
+
 func requiredVar(key string) (value string) {
 	value, ok := os.LookupEnv(key)
 	if !ok {
 	return logger.Sugar()
 }
 
-func createConfig() *model.Config {
-	return &model.Config{
+func createConfig() {
+	config = &model.Config{
 		Templates: []model.TemplateConfig{
 			{
 				Source:      optionalVar(envTemplateSourceKey, envTemplateSourceDefault),
 	}
 }
 
-func createTemplateGenerator(logger *zap.SugaredLogger, templates []model.TemplateConfig) *TemplateGenerator {
+func createTemplateGenerator(templates []model.TemplateConfig) *TemplateGenerator {
 	templateGenerator := NewTemplateGenerator(logger)
 	for _, template := range templates {
 		templateGenerator.AddTemplate(template)
 	return templateGenerator
 }
 
-func createCertificateManager(logger *zap.SugaredLogger, config model.AcmeConfig) *CertificateManager {
-	certificateManager := NewCertificateManager(logger, config.Endpoint, config.KeyType, config.DnsProvider, config.CacheLocation)
+func createCertificateManager(config model.AcmeConfig) {
+	certificateManager = NewCertificateManager(logger, config.Endpoint, config.KeyType, config.DnsProvider, config.CacheLocation)
 	err := certificateManager.Init(config.Email)
 	if err != nil {
 		panic(err)
 	}
-	return certificateManager
 }
 
 func main() {
-	logger := createLogger()
+	logger = createLogger()
 	logger.Info("Dotege is starting")
 
 	doneChan := monitorSignals()
-	config := createConfig()
+	createConfig()
 
 	dockerStopChan := make(chan struct{})
 	dockerClient, err := client.NewEnvClient()
 		panic(err)
 	}
 
-	templateGenerator := createTemplateGenerator(logger, config.Templates)
-	certificateManager := createCertificateManager(logger, config.Acme)
+	templateGenerator := createTemplateGenerator(config.Templates)
+	createCertificateManager(config.Acme)
 
 	jitterTimer := time.NewTimer(time.Minute)
 	redeployTimer := time.NewTicker(time.Hour * 24)
-	containers := make(map[string]model.Container)
+	containers := make(map[string]*model.Container)
 
 	go func() {
-		err := monitorContainers(dockerClient, dockerStopChan, func(container model.Container) {
+		err := monitorContainers(dockerClient, dockerStopChan, func(container *model.Container) {
 			containers[container.Name] = container
 			jitterTimer.Reset(100 * time.Millisecond)
-			err, _ = certificateManager.GetCertificate(getHostnamesForContainer(container, *config))
+			deployCertForContainer(container)
 		}, func(name string) {
 			delete(containers, name)
 			jitterTimer.Reset(100 * time.Millisecond)
 			case <-redeployTimer.C:
 				logger.Info("Performing periodic certificate refresh")
 				for _, container := range containers {
-					err, _ = certificateManager.GetCertificate(getHostnamesForContainer(container, *config))
+					deployCertForContainer(container)
 				}
 			}
 		}
 	}
 }
 
-func getHostnamesForContainer(container model.Container, config model.Config) []string {
+func getHostnamesForContainer(container *model.Container) []string {
 	if label, ok := container.Labels[config.Labels.Hostnames]; ok {
 		return strings.Split(strings.Replace(label, ",", " ", -1), " ")
 	} else {
 	}
 }
 
-func getHostnames(containers map[string]model.Container, config model.Config) (hostnames map[string]*model.Hostname) {
+func getHostnames(containers map[string]*model.Container, config model.Config) (hostnames map[string]*model.Hostname) {
 	hostnames = make(map[string]*model.Hostname)
 	for _, container := range containers {
 		if label, ok := container.Labels[config.Labels.Hostnames]; ok {
 				hostnames[names[0]] = &model.Hostname{
 					Name:            names[0],
 					Alternatives:    make(map[string]bool),
-					Containers:      []model.Container{container},
+					Containers:      []*model.Container{container},
 					CertActions:     config.DefaultCertActions,
 					CertDestination: config.DefaultCertDestination,
 				}
 		hostname.Alternatives[alternative] = true
 	}
 }
+
+func deployCertForContainer(container *model.Container) {
+	err, cert := certificateManager.GetCertificate(getHostnamesForContainer(container))
+	if err != nil {
+		logger.Warnf("Unable to generate certificate for %s: %s", container.Name, err.Error())
+	} else {
+		deployCert(cert)
+	}
+}
+
+func deployCert(certificate *SavedCertificate) {
+	target := path.Join(config.DefaultCertDestination, fmt.Sprintf("%s.pem", certificate.Domains[0]))
+
+	err := ioutil.WriteFile(target, append(certificate.Certificate, certificate.PrivateKey...), 0700)
+	if err != nil {
+		logger.Warnf("Unable to write certificate %s - %s", target, err.Error())
+	} else {
+		logger.Infof("Updated certificate file %s", target)
+	}
+}

model/model.go

 type Hostname struct {
 	Name            string
 	Alternatives    map[string]bool
-	Containers      []Container
+	Containers      []*Container
 	CertActions     CertActions
 	CertDestination string
 	RequiresAuth    bool

template_generator.go

 )
 
 type Context struct {
-	Containers map[string]model.Container
+	Containers map[string]*model.Container
 	Hostnames  map[string]*model.Hostname
 }