Convert monitor to http server

monitor/monitor.go

@@ -1,7 +1,13 @@
 package monitor
 
 import (
+	"context"
+	"encoding/json"
 	"errors"
+	"fmt"
+	"io/ioutil"
+	"local1/logger"
+	"net/http"
 	"time"
 
 	"github.com/golang-collections/go-datastructures/queue"
@@ -10,16 +16,90 @@ import (
 type Monitor struct {
 	newItems       chan Item
 	triggeredItems chan Item
+	port           string
+	server         *http.Server
 }
 
-func New(newItems, triggeredItems chan Item) (*Monitor, error) {
+func New(port string) (*Monitor, error) {
+	newItems := make(chan Item)
+	triggeredItems := make(chan Item)
 	return &Monitor{
 		newItems:       newItems,
 		triggeredItems: triggeredItems,
+		port:           port,
 	}, nil
 }
 
+func (monitor *Monitor) listen() error {
+	monitor.server = &http.Server{
+		Addr: monitor.port,
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path != "/newfeed" {
+				http.NotFound(w, r)
+				logger.Logf("bad path: %q", r.URL.Path)
+				return
+			}
+			if r.Method != "PUT" && r.Method != "POST" {
+				http.NotFound(w, r)
+				logger.Logf("bad method: %q", r.Method)
+				return
+			}
+			b, err := ioutil.ReadAll(r.Body)
+			defer r.Body.Close()
+			if err != nil || len(b) == 0 {
+				logger.Log(len(b), err)
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			var item Item
+			if err := json.Unmarshal(b, &item); err != nil {
+				logger.Log(err)
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+			select {
+			case monitor.newItems <- item:
+				w.WriteHeader(http.StatusOK)
+			case <-time.After(time.Second * 10):
+				w.WriteHeader(http.StatusInternalServerError)
+			}
+		}),
+	}
+	if err := monitor.server.ListenAndServe(); err != http.ErrServerClosed && err != nil {
+		return err
+	}
+	return nil
+}
+
 func (monitor *Monitor) Start() error {
+	errs := make(chan error)
+	go func() {
+		if err := monitor.listen(); err != nil {
+			select {
+			case errs <- err:
+			case <-time.After(time.Second * 10):
+				panic(err)
+			}
+		}
+	}()
+	go func() {
+		if err := monitor.loop(); err != nil {
+			select {
+			case errs <- err:
+			case <-time.After(time.Second * 10):
+				panic(err)
+			}
+		}
+	}()
+	select {
+	case err := <-errs:
+		return fmt.Errorf("%s: %v", "monitor server quit early", err)
+	case <-time.After(time.Second * 5):
+	}
+	return nil
+}
+
+func (monitor *Monitor) loop() error {
 	queue := queue.NewPriorityQueue(1)
 	active := make(map[string]*Item)
 	nextEvent := time.Date(2099, time.January, 1, 1, 1, 1, 1, time.UTC)
@@ -29,7 +109,7 @@ func (monitor *Monitor) Start() error {
 			if newItem == (Item{}) {
 				return nil
 			}
-			if oldItem, ok := active[newItem.url]; ok {
+			if oldItem, ok := active[newItem.URL]; ok {
 				*oldItem = newItem
 			} else {
 				queue.Put(&newItem)
@@ -73,11 +153,17 @@ func nextEventTime(q *queue.PriorityQueue) (time.Time, error) {
 	return item.next, nil
 }
 
+func (monitor *Monitor) Close() error {
+	return monitor.Stop()
+}
+
 func (monitor *Monitor) Stop() error {
 	select {
 	case monitor.newItems <- Item{}:
-		return nil
 	case <-time.After(time.Second * 10):
+		return errors.New("could not stop monitor")
 	}
-	return errors.New("could not stop monitor")
+	ctx, can := context.WithTimeout(context.Background(), time.Second*10)
+	defer can()
+	return monitor.server.Shutdown(ctx)
 }