Begin refactoring into packages

.pre-commit-config.yaml

     rev: v1.1.6
     hooks:
       - id: remove-crlf
-      - id: forbid-tabs
   - repo: https://github.com/dnephin/pre-commit-golang
     rev: v0.3.2
     hooks:

certificate_manager.go

+package main

container_monitor.go → docker/monitor.go

-package main
+package docker
 
 import (
 	"context"
+	"github.com/csmith/dotege/model"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
 	"time"
 )
 
+// ContainerMonitor watches for newly created and destroyed containers, and emits their information on a channel.
+// Destroyed containers are given a grace period before being announced, to allow for restarts etc to be less
+// disruptive.
 type ContainerMonitor struct {
 	logger             *zap.SugaredLogger
-	newContainers      chan<- Container
+	newContainers      chan<- model.Container
 	goneContainerNames chan<- string
 	client             *client.Client
 	expiryTimes        map[string]time.Time
 	expiryTimer        *time.Timer
 }
 
-func NewContainerMonitor(logger *zap.SugaredLogger, client *client.Client, newContainerChannel chan<- Container, goneContainerChannel chan<- string) *ContainerMonitor {
+// NewContainerMonitor creates a new container monitor
+func NewContainerMonitor(logger *zap.SugaredLogger, client *client.Client, newContainerChannel chan<- model.Container, goneContainerChannel chan<- string) *ContainerMonitor {
 	timer := time.NewTimer(time.Hour)
 	timer.Stop()
 
 	}
 }
 
+// Monitor starts monitoring for changes, and publishes info on any pre-existing containers. It blocks indefinitely,
+// and should be run from a goroutine.
 func (c *ContainerMonitor) Monitor() {
 	args := filters.NewArgs()
 	args.Add("type", "container")
 
 	for _, container := range containers {
 		c.logger.Infof("Found existing container %s", container.Names[0][1:])
-		c.newContainers <- Container{
+		c.newContainers <- model.Container{
 			Id:     container.ID,
 			Name:   container.Names[0][1:],
 			Labels: container.Labels,
 	if err != nil {
 		c.logger.Fatal("Error received trying to inspect container", err)
 	}
-	c.newContainers <- Container{
+	c.newContainers <- model.Container{
 		Id:     container.ID,
 		Name:   container.Name[1:],
 		Labels: container.Config.Labels,

dotege.go

 
 import (
 	"fmt"
+	"github.com/csmith/dotege/docker"
+	"github.com/csmith/dotege/model"
 	"github.com/docker/docker/client"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 	"time"
 )
 
-type Container struct {
-	Id     string
-	Name   string
-	Labels map[string]string
-}
-
-type LabelConfig struct {
-	Hostnames string
-}
-
-type Hostname struct {
-	Name         string
-	Alternatives map[string]bool
-	Containers   []Container
-}
-
-type Config struct {
-	Templates []TemplateConfig
-	Labels    LabelConfig
-}
-
 func monitorSignals() <-chan bool {
 	signals := make(chan os.Signal, 1)
 	done := make(chan bool, 1)
 	sugar.Info("Dotege is starting")
 
 	done := monitorSignals()
-	containerChan := make(chan Container, 1)
+	containerChan := make(chan model.Container, 1)
 	expiryChan := make(chan string, 1)
-	labelConfig := LabelConfig{
+	labelConfig := model.LabelConfig{
 		Hostnames: "com.chameth.vhost",
 	}
 
 	}
 
 	templateGenerator := NewTemplateGenerator(sugar)
-	templateGenerator.AddTemplate(TemplateConfig{
+	templateGenerator.AddTemplate(model.TemplateConfig{
 		Source:      "./templates/domains.txt.tpl",
 		Destination: "domains.txt",
 	})
-	templateGenerator.AddTemplate(TemplateConfig{
+	templateGenerator.AddTemplate(model.TemplateConfig{
 		Source:      "./templates/haproxy.cfg.tpl",
 		Destination: "haproxy.cfg",
 	})
 
-	monitor := NewContainerMonitor(sugar, cli, containerChan, expiryChan)
+	monitor := docker.NewContainerMonitor(sugar, cli, containerChan, expiryChan)
 	go monitor.Monitor()
 
 	go func() {
-		containers := make(map[string]Container)
+		containers := make(map[string]model.Container)
 		timer := time.NewTimer(time.Hour)
 		timer.Stop()
 
 	}
 }
 
-func getHostnames(containers map[string]Container, config LabelConfig) (hostnames map[string]Hostname) {
-	hostnames = make(map[string]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]] = Hostname{
+				hostnames[names[0]] = model.Hostname{
 					Name:         names[0],
 					Alternatives: make(map[string]bool),
-					Containers:   []Container{container},
+					Containers:   []model.Container{container},
 				}
 			}
 			addAlternatives(hostnames[names[0]], names[1:])
 	return
 }
 
-func addAlternatives(hostname Hostname, alternatives []string) {
+func addAlternatives(hostname model.Hostname, alternatives []string) {
 	for _, alternative := range alternatives {
 		hostname.Alternatives[alternative] = true
 	}

model/model.go

+package model
+
+// Container models a docker container that is running on the system.
+type Container struct {
+	Id     string
+	Name   string
+	Labels map[string]string
+}
+
+// LabelConfig describes the labels used for various properties.
+type LabelConfig struct {
+	Hostnames string
+}
+
+// Hostname describes a DNS name used for proxying, retrieving certificates, etc.
+type Hostname struct {
+	Name         string
+	Alternatives map[string]bool
+	Containers   []Container
+}
+
+// Config is the user-definable configuration for Dotege.
+type Config struct {
+	Templates []TemplateConfig
+	Labels    LabelConfig
+}
+
+// TemplateConfig configures a single template for the generator.
+type TemplateConfig struct {
+	Source      string
+	Destination string
+}

template_generator.go

 package main
 
 import (
+	"github.com/csmith/dotege/model"
 	"go.uber.org/zap"
 	"io/ioutil"
 	"path"
 )
 
 type Context struct {
-	Containers map[string]Container
-	Hostnames map[string]Hostname
-}
-
-type TemplateConfig struct {
-	Source      string
-	Destination string
+	Containers map[string]model.Container
+	Hostnames  map[string]model.Hostname
 }
 
 type Template struct {
-	config   TemplateConfig
+	config   model.TemplateConfig
 	content  string
 	template *template.Template
 }
 
 type TemplateGenerator struct {
-	logger *zap.SugaredLogger
+	logger    *zap.SugaredLogger
 	templates []*Template
 }
 
 	}
 }
 
-func (t *TemplateGenerator) AddTemplate(config TemplateConfig) {
+func (t *TemplateGenerator) AddTemplate(config model.TemplateConfig) {
 	t.logger.Infof("Adding template from %s, writing to %s", config.Source, config.Destination)
 	tmpl, err := template.New(path.Base(config.Source)).Funcs(funcMap).ParseFiles(config.Source)
 	if err != nil {