Create a generator type

Author: jwilder

GLOCKFILE

@@ -1,4 +1,2 @@
-github.com/BurntSushi/toml f87ce853111478914f0bcffa34d43a93643e6eda
-github.com/Sirupsen/logrus 6ebb4e7b3c24b9fef150d7693e728cb1ebadf1f5
-github.com/docker/docker 2606a2e4d3bf810ec82e373a6cd334e22e504e83
-github.com/fsouza/go-dockerclient 54afc1babbc57f075f958f84904251332bd8fd73
+github.com/BurntSushi/toml 056c9bc7be7190eaa7715723883caffa5f8fa3e4
+github.com/fsouza/go-dockerclient e0d22d30691bcc996eca51f729a4777b8c7dc2a8

cmd/docker-gen/main.go

@@ -1,16 +1,12 @@
 package main
 
 import (
-	"errors"
 	"flag"
 	"fmt"
 	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
-	"strings"
 	"sync"
-	"time"
 
 	"github.com/BurntSushi/toml"
 	docker "github.com/fsouza/go-dockerclient"
@@ -41,12 +37,6 @@ var (
 	wg                      sync.WaitGroup
 )
 
-type Event struct {
-	ContainerID string `json:"id"`
-	Status      string `json:"status"`
-	Image       string `json:"from"`
-}
-
 func (strings *stringslice) String() string {
 	return "[]"
 }
@@ -73,90 +63,12 @@ Arguments:
 	println(`
 Environment Variables:
   DOCKER_HOST - default value for -endpoint
-  DOCKER_CERT_PATH - directory path containing key.pem, cert.pm and ca.pem
+  DOCKER_CERT_PATH - directory path containing key.pem, cert.pem and ca.pem
   DOCKER_TLS_VERIFY - enable client TLS verification
 `)
 	println(`For more information, see https://github.com/jwilder/docker-gen`)
 }
 
-func tlsEnabled() bool {
-	for _, v := range []string{tlsCert, tlsCaCert, tlsKey} {
-		if e, err := pathExists(v); e && err == nil {
-			return true
-		}
-	}
-	return false
-}
-
-func NewDockerClient(endpoint string) (*docker.Client, error) {
-	if strings.HasPrefix(endpoint, "unix:") {
-		return docker.NewClient(endpoint)
-	} else if tlsVerify || tlsEnabled() {
-		if tlsVerify {
-			if e, err := pathExists(tlsCaCert); !e || err != nil {
-				return nil, errors.New("TLS verification was requested, but CA cert does not exist")
-			}
-		}
-
-		return docker.NewTLSClient(endpoint, tlsCert, tlsKey, tlsCaCert)
-	}
-	return docker.NewClient(endpoint)
-}
-
-func generateFromContainers(client *docker.Client) {
-	containers, err := dockergen.GetContainers(client)
-	if err != nil {
-		log.Printf("error listing containers: %s\n", err)
-		return
-	}
-	for _, config := range configs.Config {
-		changed := dockergen.GenerateFile(config, containers)
-		if !changed {
-			log.Printf("Contents of %s did not change. Skipping notification '%s'", config.Dest, config.NotifyCmd)
-			continue
-		}
-		runNotifyCmd(config)
-		sendSignalToContainer(client, config)
-	}
-}
-
-func runNotifyCmd(config dockergen.Config) {
-	if config.NotifyCmd == "" {
-		return
-	}
-
-	log.Printf("Running '%s'", config.NotifyCmd)
-	cmd := exec.Command("/bin/sh", "-c", config.NotifyCmd)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		log.Printf("Error running notify command: %s, %s\n", config.NotifyCmd, err)
-	}
-	if config.NotifyOutput {
-		for _, line := range strings.Split(string(out), "\n") {
-			if line != "" {
-				log.Printf("[%s]: %s", config.NotifyCmd, line)
-			}
-		}
-	}
-}
-
-func sendSignalToContainer(client *docker.Client, config dockergen.Config) {
-	if len(config.NotifyContainers) < 1 {
-		return
-	}
-
-	for container, signal := range config.NotifyContainers {
-		log.Printf("Sending container '%s' signal '%v'", container, signal)
-		killOpts := docker.KillContainerOptions{
-			ID:     container,
-			Signal: signal,
-		}
-		if err := client.KillContainer(killOpts); err != nil {
-			log.Printf("Error sending signal to container: %s", err)
-		}
-	}
-}
-
 func loadConfig(file string) error {
 	_, err := toml.DecodeFile(file, &configs)
 	if err != nil {
@@ -165,126 +77,6 @@ func loadConfig(file string) error {
 	return nil
 }
 
-func generateAtInterval(client *docker.Client, configs dockergen.ConfigFile) {
-	for _, config := range configs.Config {
-
-		if config.Interval == 0 {
-			continue
-		}
-
-		log.Printf("Generating every %d seconds", config.Interval)
-		wg.Add(1)
-		ticker := time.NewTicker(time.Duration(config.Interval) * time.Second)
-		quit := make(chan struct{})
-		configCopy := config
-		go func() {
-			defer wg.Done()
-			for {
-				select {
-				case <-ticker.C:
-					containers, err := dockergen.GetContainers(client)
-					if err != nil {
-						log.Printf("Error listing containers: %s\n", err)
-						continue
-					}
-					// ignore changed return value. always run notify command
-					dockergen.GenerateFile(configCopy, containers)
-					runNotifyCmd(configCopy)
-					sendSignalToContainer(client, configCopy)
-				case <-quit:
-					ticker.Stop()
-					return
-				}
-			}
-		}()
-	}
-}
-
-func generateFromEvents(client *docker.Client, configs dockergen.ConfigFile) {
-	configs = configs.FilterWatches()
-	if len(configs.Config) == 0 {
-		return
-	}
-
-	wg.Add(1)
-	defer wg.Done()
-
-	for {
-		if client == nil {
-			var err error
-			endpoint, err := dockergen.GetEndpoint(endpoint)
-			if err != nil {
-				log.Printf("Bad endpoint: %s", err)
-				time.Sleep(10 * time.Second)
-				continue
-			}
-
-			client, err = NewDockerClient(endpoint)
-			if err != nil {
-				log.Printf("Unable to connect to docker daemon: %s", err)
-				time.Sleep(10 * time.Second)
-				continue
-			}
-			generateFromContainers(client)
-		}
-
-		eventChan := make(chan *docker.APIEvents, 100)
-		defer close(eventChan)
-
-		watching := false
-		for {
-
-			if client == nil {
-				break
-			}
-			err := client.Ping()
-			if err != nil {
-				log.Printf("Unable to ping docker daemon: %s", err)
-				if watching {
-					client.RemoveEventListener(eventChan)
-					watching = false
-					client = nil
-				}
-				time.Sleep(10 * time.Second)
-				break
-
-			}
-
-			if !watching {
-				err = client.AddEventListener(eventChan)
-				if err != nil && err != docker.ErrListenerAlreadyExists {
-					log.Printf("Error registering docker event listener: %s", err)
-					time.Sleep(10 * time.Second)
-					continue
-				}
-				watching = true
-				log.Println("Watching docker events")
-			}
-
-			select {
-
-			case event := <-eventChan:
-				if event == nil {
-					if watching {
-						client.RemoveEventListener(eventChan)
-						watching = false
-						client = nil
-					}
-					break
-				}
-
-				if event.Status == "start" || event.Status == "stop" || event.Status == "die" {
-					log.Printf("Received event %s for container %s", event.Status, event.ID[:12])
-					generateFromContainers(client)
-				}
-			case <-time.After(10 * time.Second):
-				// check for docker liveness
-			}
-
-		}
-	}
-}
-
 func initFlags() {
 
 	certPath := filepath.Join(os.Getenv("DOCKER_CERT_PATH"))
@@ -354,30 +146,20 @@ func main() {
 			Config: []dockergen.Config{config}}
 	}
 
-	endpoint, err := dockergen.GetEndpoint(endpoint)
-	if err != nil {
-		log.Fatalf("Bad endpoint: %s", err)
-	}
+	generator, err := dockergen.NewGenerator(dockergen.GeneratorConfig{
+		Endpoint:   endpoint,
+		TLSKey:     tlsKey,
+		TLSCert:    tlsCert,
+		TLSCACert:  tlsCaCert,
+		TLSVerify:  tlsVerify,
+		ConfigFile: configs,
+	})
 
-	client, err := NewDockerClient(endpoint)
 	if err != nil {
-		log.Fatalf("Unable to create docker client: %s", err)
+		log.Fatalf("error creating generator: %v", err)
 	}
 
-	generateFromContainers(client)
-	generateAtInterval(client, configs)
-	generateFromEvents(client, configs)
-	wg.Wait()
-}
-
-// pathExists returns whether the given file or directory exists or not
-func pathExists(path string) (bool, error) {
-	_, err := os.Stat(path)
-	if err == nil {
-		return true, nil
-	}
-	if os.IsNotExist(err) {
-		return false, nil
+	if err := generator.Generate(); err != nil {
+		log.Fatalf("error running generate: %v", err)
 	}
-	return false, err
 }

context.go

@@ -51,6 +51,7 @@ type RuntimeContainer struct {
 	IP           string
 	IP6LinkLocal string
 	IP6Global    string
+	Server       Server
 }
 
 func (r *RuntimeContainer) Equals(o RuntimeContainer) bool {
@@ -89,3 +90,18 @@ type SwarmNode struct {
 	Name    string
 	Address Address
 }
+
+type Server struct {
+	Name          string
+	NumContainers int
+	NumImages     int
+	Docker        Docker
+}
+
+type Docker struct {
+	Version         string
+	ApiVersion      string
+	GoVersion       string
+	OperatingSystem string
+	Architecture    string
+}

docker_client.go

@@ -1,14 +1,40 @@
 package dockergen
 
 import (
+	"errors"
 	"fmt"
 	"log"
+	"os"
 	"strconv"
 	"strings"
 
 	docker "github.com/fsouza/go-dockerclient"
 )
 
+func NewDockerClient(endpoint string, tlsVerify bool, tlsCert, tlsCaCert, tlsKey string) (*docker.Client, error) {
+	if strings.HasPrefix(endpoint, "unix:") {
+		return docker.NewClient(endpoint)
+	} else if tlsVerify || tlsEnabled(tlsCert, tlsCaCert, tlsKey) {
+		if tlsVerify {
+			if e, err := pathExists(tlsCaCert); !e || err != nil {
+				return nil, errors.New("TLS verification was requested, but CA cert does not exist")
+			}
+		}
+
+		return docker.NewTLSClient(endpoint, tlsCert, tlsKey, tlsCaCert)
+	}
+	return docker.NewClient(endpoint)
+}
+
+func tlsEnabled(tlsCert, tlsCaCert, tlsKey string) bool {
+	for _, v := range []string{tlsCert, tlsCaCert, tlsKey} {
+		if e, err := pathExists(v); e && err == nil {
+			return true
+		}
+	}
+	return false
+}
+
 type DockerContainer struct {
 }
 
@@ -95,7 +121,6 @@ func splitDockerImage(img string) (string, string, string) {
 }
 
 func GetContainers(client *docker.Client) ([]*RuntimeContainer, error) {
-
 	apiContainers, err := client.ListContainers(docker.ListContainersOptions{
 		All:  false,
 		Size: false,
@@ -187,3 +212,15 @@ func GetContainers(client *docker.Client) ([]*RuntimeContainer, error) {
 	return containers, nil
 
 }
+
+// pathExists returns whether the given file or directory exists or not
+func pathExists(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return false, err
+}