Merge pull request #3641 from eMxyzptlk/issue_3552_v2

feat(publisher): expose config as flags

Author: mboersma

deisctl/units/deis-publisher.service

@@ -8,7 +8,7 @@ EnvironmentFile=/etc/environment
 TimeoutStartSec=20m
 ExecStartPre=/bin/sh -c "IMAGE=`/run/deis/bin/get_image /deis/publisher` && docker history $IMAGE >/dev/null 2>&1 || docker pull $IMAGE"
 ExecStartPre=/bin/sh -c "docker inspect deis-publisher >/dev/null 2>&1 && docker rm -f deis-publisher || true"
-ExecStart=/bin/sh -c "IMAGE=`/run/deis/bin/get_image /deis/publisher` && docker run --name deis-publisher --rm -e HOST=$COREOS_PRIVATE_IPV4 -e ETCD_HOST=$COREOS_PRIVATE_IPV4 -v /var/run/docker.sock:/var/run/docker.sock $IMAGE"
+ExecStart=/bin/sh -c "IMAGE=`/run/deis/bin/get_image /deis/publisher` && docker run --name deis-publisher --rm -v /var/run/docker.sock:/var/run/docker.sock $IMAGE --host=$COREOS_PRIVATE_IPV4 --etcd-host=$COREOS_PRIVATE_IPV4"
 ExecStopPost=-/usr/bin/docker rm -f deis-publisher
 Restart=on-failure
 RestartSec=5

publisher/README.md

@@ -7,10 +7,10 @@ service discovery.
 
 ## Running this Container
 
-Set $ETCD_HOST to be the IP address/hostname of the etcd endpoint you wish to target, and
-$HOST to be the IP address of the host running this container:
+Run the publisher with the --etcd-host set to be the IP address/hostname of the etcd endpint you wish to target, and --host to be the IP address of the host running this container:
 
-    $ docker run -d -v /var/run/docker.sock:/tmp/docker.sock -e ETCD_HOST=192.168.0.1 -e HOST=192.168.0.1 deis/publisher
+
+    $ docker run -d -v /var/run/docker.sock:/tmp/docker.sock deis/publisher --etcd-host=192.168.0.1 --host=192.168.0.1
 
 ## Building from Source
 

publisher/main.go

@@ -1,8 +1,8 @@
 package main
 
 import (
+	"flag"
 	"log"
-	"os"
 	"time"
 
 	"github.com/coreos/go-etcd/etcd"
@@ -12,34 +12,40 @@ import (
 )
 
 const (
-	timeout time.Duration = 10 * time.Second
-	etcdTTL time.Duration = timeout * 2
+	defaultRefreshTime time.Duration = 10 * time.Second
+	defaultEtcdTTL     time.Duration = defaultRefreshTime * 2
+	defaultHost                      = "127.0.0.1"
+	defaultDockerHost                = "unix:///var/run/docker.sock"
+	defaultEtcdHost                  = "127.0.0.1"
+	defaultEtcdPort                  = "4001"
+	defaultLogLevel                  = "error"
 )
 
-func getopt(name, dfault string) string {
-	value := os.Getenv(name)
-	if value == "" {
-		value = dfault
-	}
-	return value
-}
+var (
+	refreshDuration = flag.Duration("refresh-duration", defaultRefreshTime, "The time to wait between etcd refreshes.")
+	etcdTTL         = flag.Duration("etcd-ttl", defaultEtcdTTL, "The TTL for all of the keys in etcd.")
+	host            = flag.String("host", defaultHost, "The host where the publisher is running.")
+	dockerHost      = flag.String("docker-host", defaultDockerHost, "The host where to find docker.")
+	etcdHost        = flag.String("etcd-host", defaultEtcdHost, "The etcd host.")
+	etcdPort        = flag.String("etcd-port", defaultEtcdPort, "The etcd port.")
+	logLevel        = flag.String("log-level", defaultLogLevel, "Acceptable values: error, debug")
+)
 
 func main() {
-	endpoint := getopt("DOCKER_HOST", "unix:///var/run/docker.sock")
-	etcdHost := getopt("ETCD_HOST", "127.0.0.1")
+	flag.Parse()
 
-	client, err := docker.NewClient(endpoint)
+	dockerClient, err := docker.NewClient(*dockerHost)
 	if err != nil {
 		log.Fatal(err)
 	}
-	etcdClient := etcd.NewClient([]string{"http://" + etcdHost + ":4001"})
+	etcdClient := etcd.NewClient([]string{"http://" + *etcdHost + ":" + *etcdPort})
 
-	server := &server.Server{DockerClient: client, EtcdClient: etcdClient}
+	server := server.New(dockerClient, etcdClient, *host, *logLevel)
 
-	go server.Listen(etcdTTL)
+	go server.Listen(*etcdTTL)
 
 	for {
-		go server.Poll(etcdTTL)
-		time.Sleep(timeout)
+		go server.Poll(*etcdTTL)
+		time.Sleep(*refreshDuration)
 	}
 }

publisher/server/publisher.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"log"
 	"net"
-	"os"
 	"regexp"
 	"strconv"
 	"sync"
@@ -23,13 +22,26 @@ const (
 type Server struct {
 	DockerClient *docker.Client
 	EtcdClient   *etcd.Client
+
+	host     string
+	logLevel string
 }
 
 var safeMap = struct {
 	sync.RWMutex
 	data map[string]string
 }{data: make(map[string]string)}
 
+// New returns a new instance of Server.
+func New(dockerClient *docker.Client, etcdClient *etcd.Client, host, logLevel string) *Server {
+	return &Server{
+		DockerClient: dockerClient,
+		EtcdClient:   etcdClient,
+		host:         host,
+		logLevel:     logLevel,
+	}
+}
+
 // Listen adds an event listener to the docker client and publishes containers that were started.
 func (s *Server) Listen(ttl time.Duration) {
 	listener := make(chan *docker.APIEvents)
@@ -86,7 +98,6 @@ func (s *Server) getContainer(id string) (*docker.APIContainers, error) {
 // publishContainer publishes the docker container to etcd.
 func (s *Server) publishContainer(container *docker.APIContainers, ttl time.Duration) {
 	r := regexp.MustCompile(appNameRegex)
-	host := os.Getenv("HOST")
 	for _, name := range container.Names {
 		// HACK: remove slash from container name
 		// see https://github.com/docker/docker/issues/7519
@@ -101,7 +112,7 @@ func (s *Server) publishContainer(container *docker.APIContainers, ttl time.Dura
 		dirPath := fmt.Sprintf("/deis/services/%s", appName)
 		for _, p := range container.Ports {
 			port := strconv.Itoa(int(p.PublicPort))
-			hostAndPort := host + ":" + port
+			hostAndPort := s.host + ":" + port
 			if s.IsPublishableApp(containerName) && s.IsPortOpen(hostAndPort) {
 				s.setEtcd(keyPath, hostAndPort, uint64(ttl.Seconds()))
 				s.updateDir(dirPath, uint64(ttl.Seconds()))
@@ -208,15 +219,19 @@ func (s *Server) setEtcd(key, value string, ttl uint64) {
 	if _, err := s.EtcdClient.Set(key, value, ttl); err != nil {
 		log.Println(err)
 	}
-	log.Println("set", key, "->", value)
+	if s.logLevel == "debug" {
+		log.Println("set", key, "->", value)
+	}
 }
 
 // removeEtcd removes the corresponding etcd key
 func (s *Server) removeEtcd(key string, recursive bool) {
 	if _, err := s.EtcdClient.Delete(key, recursive); err != nil {
 		log.Println(err)
 	}
-	log.Println("del", key)
+	if s.logLevel == "debug" {
+		log.Println("del", key)
+	}
 }
 
 // updateDir updates the given directory for a given ttl. It succeeds
@@ -225,5 +240,7 @@ func (s *Server) updateDir(directory string, ttl uint64) {
 	if _, err := s.EtcdClient.UpdateDir(directory, ttl); err != nil {
 		log.Println(err)
 	}
-	log.Println("updateDir", directory)
+	if s.logLevel == "debug" {
+		log.Println("updateDir", directory)
+	}
 }

publisher/server/publisher_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func TestIsPublishableApp(t *testing.T) {
-	s := &Server{nil, nil}
+	s := &Server{}
 	appName := "go_v2.web.1"
 	if !s.IsPublishableApp(appName) {
 		t.Errorf("%s should be publishable", appName)
@@ -37,7 +37,7 @@ func TestIsPortOpen(t *testing.T) {
 	}
 	defer ln.Close()
 
-	s := &Server{nil, nil}
+	s := &Server{}
 	if !s.IsPortOpen(ln.Addr().String()) {
 		t.Errorf("Port should be open")
 	}