Refactor into separate types

container_monitor.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/client"
+	"time"
+)
+
+type ContainerMonitor struct {
+	newContainers      chan<- Container
+	goneContainerNames chan<- string
+	client             *client.Client
+	expiryTimes        map[string]time.Time
+	deletionTime       time.Duration
+	nextExpiry         time.Time
+	expiryTimer        *time.Timer
+}
+
+func NewContainerMonitor(client *client.Client, newContainerChannel chan<- Container, goneContainerChannel chan<- string) *ContainerMonitor {
+	timer := time.NewTimer(time.Hour)
+	timer.Stop()
+
+	return &ContainerMonitor{
+		newContainers:      newContainerChannel,
+		goneContainerNames: goneContainerChannel,
+		client:             client,
+		expiryTimes:        make(map[string]time.Time),
+		deletionTime:       10 * time.Second,
+		expiryTimer:        timer,
+		nextExpiry:         time.Now(),
+	}
+}
+
+func (c *ContainerMonitor) Monitor() {
+	args := filters.NewArgs()
+	args.Add("type", "container")
+	args.Add("event", "create")
+	args.Add("event", "destroy")
+	eventsChan, errChan := c.client.Events(context.Background(), types.EventsOptions{Filters: args})
+
+	c.publishExistingContainers()
+
+	for {
+		select {
+		case event := <-eventsChan:
+			if event.Action == "create" {
+				c.publishNewContainer(event.Actor.ID)
+			} else {
+				c.scheduleExpiry(event.Actor.Attributes["name"])
+			}
+
+		case <-c.expiryTimer.C:
+			c.publishExpiredContainers()
+
+		case err := <-errChan:
+			panic(err)
+		}
+	}
+}
+
+func (c *ContainerMonitor) publishExistingContainers() {
+	containers, err := c.client.ContainerList(context.Background(), types.ContainerListOptions{})
+	if err != nil {
+		panic(err)
+	}
+
+	for _, container := range containers {
+		c.newContainers <- Container{
+			Id:     container.ID,
+			Name:   container.Names[0][1:],
+			Labels: container.Labels,
+		}
+	}
+}
+
+func (c *ContainerMonitor) publishNewContainer(id string) {
+	container, err := c.client.ContainerInspect(context.Background(), id)
+	if err != nil {
+		panic(err)
+	}
+	c.newContainers <- Container{
+		Id:     container.ID,
+		Name:   container.Name[1:],
+		Labels: container.Config.Labels,
+	}
+	delete(c.expiryTimes, container.Name[1:])
+}
+
+func (c *ContainerMonitor) scheduleExpiry(name string) {
+	now := time.Now()
+	expiryTime := now.Add(c.deletionTime)
+	c.expiryTimes[name] = expiryTime
+	fmt.Printf("Scheduling expiry timer for %s\n", name)
+	if c.nextExpiry.Before(now) || c.nextExpiry.After(expiryTime) {
+		fmt.Printf("Starting expiry timer with default duration\n")
+		c.expiryTimer.Reset(c.deletionTime + 1*time.Second)
+		c.nextExpiry = expiryTime
+	}
+}
+
+func (c *ContainerMonitor) publishExpiredContainers() {
+	now := time.Now()
+	next := 0 * time.Second
+
+	for name, expiryTime := range c.expiryTimes {
+		if expiryTime.Before(now) {
+			fmt.Printf("Expiring %s\n", name)
+			delete(c.expiryTimes, name)
+			c.goneContainerNames <- name
+		} else if next == 0 || expiryTime.Sub(now) < next {
+			next = expiryTime.Sub(now)
+		}
+	}
+
+	if next > 0 {
+		fmt.Printf("Starting expiry timer with duration %s\n", next)
+		c.expiryTimer.Reset(next + 1*time.Second)
+		c.nextExpiry = now.Add(next)
+	}
+}

dotege.go

@@ -2,16 +2,10 @@ package main
 
 import (
 	"fmt"
-	"github.com/docker/distribution/context"
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/client"
 	"os"
 	"os/signal"
-	"sort"
-	"strings"
 	"syscall"
-	"text/template"
 	"time"
 )
 
@@ -21,140 +15,44 @@ type Container struct {
 	Labels map[string]string
 }
 
-type Context struct {
-	Containers map[string]Container
-}
+func monitorSignals() <-chan bool {
+	signals := make(chan os.Signal, 1)
+	done := make(chan bool, 1)
+
+	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 
-var funcMap = template.FuncMap{
-	"replace": func(from, to, input string) string { return strings.Replace(input, from, to, -1) },
-	"split":   func(sep, input string) []string { return strings.Split(input, sep) },
-	"join":    func(sep string, input []string) string { return strings.Join(input, sep) },
-	"sortlines": func(input string) string {
-		lines := strings.Split(input, "\n")
-		sort.Strings(lines)
-		return strings.Join(lines, "\n")
-	},
+	go func() {
+		sig := <-signals
+		fmt.Printf("Received %s signal\n", sig)
+		done <- true
+	}()
+
+	return done
 }
 
 func main() {
-	sigs := make(chan os.Signal, 1)
-	done := make(chan bool, 1)
+	done := monitorSignals()
 	containerChan := make(chan Container, 1)
 	expiryChan := make(chan string, 1)
 
-	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
-
 	cli, err := client.NewEnvClient()
 	if err != nil {
 		panic(err)
 	}
 
-	go func() {
-		sig := <-sigs
-		fmt.Printf("Received %s signal\n", sig)
-		err := cli.Close()
-		if err != nil {
-			panic(err)
-		}
-		done <- true
-	}()
-
-	go func() {
-		const deletionTime = 10 * time.Second
-
-		expiryTimes := make(map[string]time.Time)
-		expiryTimer := time.NewTimer(time.Hour)
-		nextExpiry := time.Now()
-		expiryTimer.Stop()
+	templateGenerator := NewTemplateGenerator()
+	templateGenerator.AddTemplate(TemplateConfig{
+		Source: "./templates/domains.txt.tpl",
+	})
 
-		args := filters.NewArgs()
-		args.Add("type", "container")
-		args.Add("event", "create")
-		args.Add("event", "destroy")
-		eventsChan, errChan := cli.Events(context.Background(), types.EventsOptions{Filters: args})
-
-		containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
-		if err != nil {
-			panic(err)
-		}
-
-		for _, container := range containers {
-			containerChan <- Container{
-				Id:     container.ID,
-				Name:   container.Names[0][1:],
-				Labels: container.Labels,
-			}
-		}
-
-		for {
-			select {
-			case event := <-eventsChan:
-				if event.Action == "create" {
-					container, err := cli.ContainerInspect(context.Background(), event.Actor.ID)
-					if err != nil {
-						panic(err)
-					}
-					containerChan <- Container{
-						Id:     container.ID,
-						Name:   container.Name[1:],
-						Labels: container.Config.Labels,
-					}
-				} else {
-					now := time.Now()
-					expiryTime := now.Add(deletionTime)
-					expiryTimes[event.Actor.Attributes["name"]] = expiryTime
-					fmt.Printf("Scheduling expiry timer for %s\n", event.Actor.Attributes["name"])
-					if nextExpiry.Before(now) || nextExpiry.After(expiryTime) {
-						fmt.Printf("Starting expiry timer with default duration\n")
-						expiryTimer.Reset(deletionTime + 1*time.Second)
-						nextExpiry = expiryTime
-					}
-				}
-
-			case <-expiryTimer.C:
-				now := time.Now()
-				next := 0 * time.Second
-
-				for name, expiryTime := range expiryTimes {
-					if expiryTime.Before(now) {
-						fmt.Printf("Expiring %s\n", name)
-						delete(expiryTimes, name)
-						expiryChan <- name
-					} else if next == 0 || expiryTime.Sub(now) < next {
-						next = expiryTime.Sub(now)
-					}
-				}
-
-				if next > 0 {
-					fmt.Printf("Starting expiry timer with duration %s\n", next)
-					expiryTimer.Reset(next + 1*time.Second)
-					nextExpiry = now.Add(next)
-				}
-
-			case err := <-errChan:
-				panic(err)
-			}
-		}
-	}()
+	monitor := NewContainerMonitor(cli, containerChan, expiryChan)
+	go monitor.Monitor()
 
 	go func() {
-		var templates []*template.Template
 		containers := make(map[string]Container)
 		timer := time.NewTimer(time.Hour)
 		timer.Stop()
 
-		tmpl, err := template.New("domains.txt.tpl").Funcs(funcMap).ParseFiles("./templates/domains.txt.tpl")
-		if err != nil {
-			panic(err)
-		}
-		templates = append(templates, tmpl)
-
-		tmpl, err = template.New("haproxy.cfg.tpl").Funcs(funcMap).ParseFiles("./templates/haproxy.cfg.tpl")
-		if err != nil {
-			panic(err)
-		}
-		templates = append(templates, tmpl)
-
 		for {
 			select {
 			case container := <-containerChan:
@@ -164,17 +62,15 @@ func main() {
 				delete(containers, name)
 				timer.Reset(100 * time.Millisecond)
 			case <-timer.C:
-				for _, tmpl := range templates {
-					fmt.Printf("--- Writing %s ---\n", tmpl.Name())
-					err = tmpl.Execute(os.Stdout, Context{Containers: containers})
-					fmt.Printf("--- / writing %s ---\n", tmpl.Name())
-					if err != nil {
-						panic(err)
-					}
-				}
+				templateGenerator.Generate(Context{Containers: containers})
 			}
 		}
 	}()
 
 	<-done
+
+	err = cli.Close()
+	if err != nil {
+		panic(err)
+	}
 }

template_generator.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"sort"
+	"strings"
+	"text/template"
+)
+
+type Context struct {
+	Containers map[string]Container
+}
+
+type TemplateConfig struct {
+	Source      string
+	Destination string
+}
+
+type Template struct {
+	config   TemplateConfig
+	content  string
+	template *template.Template
+}
+
+type TemplateGenerator struct {
+	templates []*Template
+}
+
+var funcMap = template.FuncMap{
+	"replace": func(from, to, input string) string { return strings.Replace(input, from, to, -1) },
+	"split":   func(sep, input string) []string { return strings.Split(input, sep) },
+	"join":    func(sep string, input []string) string { return strings.Join(input, sep) },
+	"sortlines": func(input string) string {
+		lines := strings.Split(input, "\n")
+		sort.Strings(lines)
+		return strings.Join(lines, "\n")
+	},
+}
+
+func NewTemplateGenerator() *TemplateGenerator {
+	return &TemplateGenerator{}
+}
+
+func (t *TemplateGenerator) AddTemplate(config TemplateConfig) {
+	tmpl, err := template.New(path.Base(config.Source)).Funcs(funcMap).ParseFiles(config.Source)
+	if err != nil {
+		panic(err)
+	}
+
+	t.templates = append(t.templates, &Template{
+		config:   config,
+		content:  "", // TODO: Read this in initially
+		template: tmpl,
+	})
+}
+
+func (t *TemplateGenerator) Generate(context Context) {
+	for _, tmpl := range t.templates {
+		// TODO: Actually write to file :)
+		// TODO: Retrieve the output and check if it matches our cache
+		fmt.Printf("--- Writing %s to %s ---\n", tmpl.config.Source, tmpl.config.Destination)
+		err := tmpl.template.Execute(os.Stdout, context)
+		fmt.Printf("--- / writing %s ---\n", tmpl.config.Destination)
+		if err != nil {
+			panic(err)
+		}
+	}
+}