Make hupper watch for proxy changes too

Signed-off-by: Dave Tucker <dt@docker.com>

alpine/packages/hupper/etc/init.d/hupper

@@ -13,16 +13,18 @@ start()
 
 	PIDFILE=/run/hupper.pid
 	DOCKERPIDFILE=/run/docker.pid
-	WATCH=$(mobyconfig watch /etc/docker/daemon.json)
+	WATCH_CONFIG=$(mobyconfig watch /etc/docker/daemon.json)
+	WATCH_PROXY=$(mobyconfig watch proxy)
 
-	[ -z "${WATCH}" ] && exit 1
+	[ -z "${WATCH_CONFIG}" ] && exit 1
+	[ -z "${WATCH_PROXY}" ] && exit 1
 
 	start-stop-daemon --start --quiet \
 		--background \
 		--exec /bin/hupper \
 		--make-pidfile --pidfile ${PIDFILE} \
 		-- -pidfile ${PIDFILE} -huppidfile ${DOCKERPIDFILE} \
-		   -path ${WATCH}
+		   -path ${WATCH_CONFIG} -path ${WATCH_PROXY}
 
 	eend $? "Failed to start hupper"
 }

alpine/packages/hupper/main.go

@@ -2,23 +2,36 @@ package main
 
 import (
 	"flag"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
 	"strconv"
+	"sync"
 	"syscall"
 )
 
 var (
-	path       string
+	paths      stringSlice
 	huppidfile string
 	pidfile    string
 )
 
+type stringSlice []string
+
+func (s *stringSlice) String() string {
+	return fmt.Sprintf("%s", *s)
+}
+
+func (s *stringSlice) Set(value string) error {
+	*s = append(*s, value)
+	return nil
+}
+
 func init() {
-	flag.StringVar(&path, "path", "", "path of the file to watch")
+	flag.Var(&paths, "path", "paths of the files to watch")
 	flag.StringVar(&huppidfile, "huppidfile", "", "pidfile for process to signal")
 	flag.StringVar(&pidfile, "pidfile", "", "my pidfile")
 }
@@ -27,7 +40,7 @@ func main() {
 	log.SetFlags(0)
 	flag.Parse()
 
-	if path == "" {
+	if len(paths) < 1 {
 		log.Fatal("watch path not set")
 	}
 
@@ -41,43 +54,53 @@ func main() {
 		_ = ioutil.WriteFile(pidfile, pidbytes, 0644)
 	}
 
-	watch, err := os.Open(path)
+	var wg sync.WaitGroup
-	if err != nil {
+	wg.Add(len(paths))
-		log.Fatalln("Failed to open file", path, err)
+
-	}
+	for _, path := range paths {
-	// 43 bytes is the record size of the watch
+		watch, err := os.Open(path)
-	buf := make([]byte, 43)
+		if err != nil {
-	// initial state
+			log.Fatalln("Failed to open file", path, err)
-	_, err = watch.Read(buf)
+		}
-	if err != nil && err != io.EOF {
+		// 43 bytes is the record size of the watch
-		log.Fatalln("Error reading watch file", err)
+		buf := make([]byte, 43)
-	}
+		// initial state
-	for {
+		_, err = watch.Read(buf)
-		_, err := watch.Read(buf)
 		if err != nil && err != io.EOF {
 			log.Fatalln("Error reading watch file", err)
 		}
-		if err == io.EOF {
+
-			continue
+		go func() {
-		}
+			for {
-		// a few changes eg debug do not require a daemon restart
+				_, err := watch.Read(buf)
-		// however at present we cannot check changes, and most do
+				if err != nil && err != io.EOF {
-		restart := true
+					log.Fatalln("Error reading watch file", err)
-		if restart {
+				}
-			cmd := exec.Command("service", "docker", "restart")
+				if err == io.EOF {
-			// not much we can do if it does not restart
+					continue
-			_ = cmd.Run()
+				}
-		} else {
+				// a few changes eg debug do not require a daemon restart
-			bytes, err := ioutil.ReadFile(huppidfile)
+				// however at present we cannot check changes, and most do
-			if err != nil {
+				restart := true
-				continue
+				if restart {
+					log.Println("Restarting docker")
+					cmd := exec.Command("service", "docker", "restart")
+					// not much we can do if it does not restart
+					_ = cmd.Run()
+				} else {
+					bytes, err := ioutil.ReadFile(huppidfile)
+					if err != nil {
+						continue
+					}
+					pidstring := string(bytes[:])
+					pid, err := strconv.Atoi(pidstring)
+					if err != nil {
+						continue
+					}
+					syscall.Kill(pid, syscall.SIGHUP)
+				}
 			}
-			pidstring := string(bytes[:])
+		}()
-			pid, err := strconv.Atoi(pidstring)
-			if err != nil {
-				continue
-			}
-			syscall.Kill(pid, syscall.SIGHUP)
-		}
 	}
+	wg.Wait()
 }