server now opens a web server on the specified addr/port

main.go

@@ -111,14 +111,24 @@ func main() {
 		fmt.Printf("check successful\n")
 
 	case "server":
-		cfg, err := config.ReadConfig(*cfgpath, *debuglvl)
+		for {
-		if err != nil {
+			cfg, err := config.ReadConfig(*cfgpath, *debuglvl)
-			fmt.Fprintf(os.Stderr, "%s\n", err.Error())
+			if err != nil {
-			os.Exit(1)
+				fmt.Fprintf(os.Stderr, "%s\n", err.Error())
-		}
+				os.Exit(1)
+			}
 
-		srv := server.NewServer(cfg, *debuglvl)
+			srv := server.NewServer(cfg, *debuglvl)
-		srv.Start()
+
+			r, err := srv.Start()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "%s\n", err.Error())
+				os.Exit(1)
+			}
+			if !r {
+				return
+			}
+		}
 
 	case "help", "":
 		printUsage()

server/http.go

@@ -0,0 +1,19 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	switch r.URL.Path {
+	case "/shutdown":
+		fmt.Fprintf(w, "shutting down .. ")
+		s.shutdownc <- false
+	case "/restart":
+		fmt.Fprintf(w, "restarting .. ")
+		s.shutdownc <- true
+	default:
+		fmt.Fprintf(w, "Hello, world!")
+	}
+}

server/server.go

@@ -1,22 +1,35 @@
 package server
 
 import (
+	"context"
 	"fmt"
 	"git.binarythought.com/cdramey/alrm/config"
+	"net"
+	"net/http"
 	"time"
 )
 
 type Server struct {
-	workers  []*worker
+	workers   []*worker
-	cfg      *config.Config
+	cfg       *config.Config
-	debuglvl int
+	shutdownc chan bool
+	debuglvl  int
+	http      http.Server
 }
 
-func (srv *Server) Start() {
+func (srv *Server) Start() (bool, error) {
+	listen, err := net.Listen("tcp", srv.cfg.Listen)
+	if err != nil {
+		return false, err
+	}
+
 	for _, w := range srv.workers {
 		go w.start()
 	}
 
+	srv.http = http.Server{Handler: srv}
+	go srv.http.Serve(listen)
+
 	t := time.NewTicker(srv.cfg.Interval)
 	defer t.Stop()
 	for {
@@ -28,14 +41,26 @@ func (srv *Server) Start() {
 			for _, w := range srv.workers {
 				w.wake()
 			}
+		case b := <-srv.shutdownc:
+			srv.http.Shutdown(context.Background())
+			for _, w := range srv.workers {
+				w.shutdown()
+			}
+			return b, nil
 		}
 	}
 }
 
 func NewServer(cfg *config.Config, debuglvl int) *Server {
-	srv := &Server{cfg: cfg, debuglvl: debuglvl}
+	srv := &Server{
+		cfg:       cfg,
+		debuglvl:  debuglvl,
+		shutdownc: make(chan bool, 1),
+	}
 	for _, g := range cfg.Groups {
-		srv.workers = append(srv.workers, makeworker(g, debuglvl))
+		srv.workers = append(
+			srv.workers, makeworker(g, debuglvl),
+		)
 	}
 	return srv
 }

server/worker.go

@@ -53,11 +53,11 @@ func (w *worker) shutdown() {
 
 func makeworker(g *config.Group, d int) *worker {
 	return &worker{
-		group:     g,
+		group:    g,
-		debuglvl:  d,
+		debuglvl: d,
 		// This channel is unbuffered so that checks that take
 		// over the set interval don't backlog
-		wakec:     make(chan bool),
+		wakec: make(chan bool),
 		// This channel is buffered because we want it to remember
 		// an order to shutdown
 		shutdownc: make(chan bool, 1),