Little bit of refactoring to make code cleaner and silence vet -shadow.

Makefile

@@ -38,7 +38,7 @@ vet:
 	go vet ./...
 
 lint:
-	gometalinter.v2 --disable=vetshadow --vendor ./...
+	gometalinter.v2 --deadline 120s --vendor ./...
 
 clean:
 	rm nanny || true

api/api.go

@@ -9,6 +9,7 @@ import (
 	"strconv"
 	"time"
 
+	"nanny/pkg/closer"
 	"nanny/pkg/nanny"
 	"nanny/pkg/notifier"
 	"nanny/pkg/storage"
@@ -97,6 +98,8 @@ func loadStorage(n *nanny.Nanny, notifiers notifiers, store storage.Storage) {
 		log.Warn(msg)
 		return
 	}
+	// create callback func using our storage.
+	callbackFunc := makeCallbackFunc(store)
 
 	// Create nanny timers from persisted signals.
 	for _, signal := range signals {
@@ -124,12 +127,7 @@ func loadStorage(n *nanny.Nanny, notifiers notifiers, store storage.Storage) {
 			NextSignal: time.Until(signal.NextSignal),
 			Meta:       signal.Meta,
 
-			CallbackFunc: func(s *nanny.Signal) {
-				err := store.Remove(storage.Signal{Name: s.Name})
-				if err != nil {
-					log.Error("Error removing signal from storage.", "err", err, "signal", signal)
-				}
-			},
+			CallbackFunc: callbackFunc,
 		}
 
 		err = n.Handle(s)
@@ -147,6 +145,18 @@ func loadStorage(n *nanny.Nanny, notifiers notifiers, store storage.Storage) {
 	}
 }
 
+// makeCallbackFunc creates new function that can be used as nanny.Signal callback
+// while injecting storage dependency. This is used to remove signal from persistent
+// storage.
+func makeCallbackFunc(store storage.Storage) func(*nanny.Signal) {
+	return func(signal *nanny.Signal) {
+		err := store.Remove(storage.Signal{Name: signal.Name})
+		if err != nil {
+			log.Error("Error removing signal from storage.", "err", err, "signal", signal)
+		}
+	}
+}
+
 func router(nanny *nanny.Nanny, notifiers notifiers, store storage.Storage) *mux.Router {
 	router := mux.NewRouter()
 	// Clarify this is API.
@@ -194,7 +204,7 @@ func signalHandler(n *nanny.Nanny, notifiers notifiers, store storage.Storage, w
 	var signal Signal
 
 	dec := json.NewDecoder(req.Body)
-	defer Close(req.Body)
+	defer closer.Close(req.Body)
 
 	err := dec.Decode(&signal)
 	if err != nil {
@@ -321,11 +331,3 @@ func saveRoutes(route *mux.Route, router *mux.Router, ancestors []*mux.Route) er
 	routes[path] = route.GetName()
 	return nil
 }
-
-// Close closes any io.Closer and checks for error, which will be logged.
-func Close(closer io.Closer) {
-	err := closer.Close()
-	if err != nil {
-		log.Error("Unable to close resource!", "err", err, "type", fmt.Sprintf("%T", closer))
-	}
-}

cmd/root.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"nanny/api"
+	"nanny/pkg/closer"
 	"nanny/pkg/notifier"
 
 	log "github.com/mgutz/logxi"
@@ -139,12 +140,8 @@ func runAPI() {
 	if err != nil {
 		log.Fatal("Unable to create/load sqlite storage", "dsn", config.StorageDSN, "err", err)
 	}
-	defer func() {
-		err := store.Close()
-		if err != nil {
-			log.Fatal("Unable to close sqlite storage.")
-		}
-	}()
+	defer closer.Close(store)
+
 	api := api.Server{
 		Name:      config.Name,
 		Notifiers: notifiers,
@@ -169,19 +166,7 @@ func runAPI() {
 
 	// CTRL+C handling.
 	idleConnsClosed := make(chan struct{})
-	go func() {
-		sigint := make(chan os.Signal, 1)
-		signal.Notify(sigint, os.Interrupt)
-		<-sigint
-		log.Info("Nanny shutting down.")
-
-		// We received an interrupt signal, shut down.
-		if err := server.Shutdown(context.Background()); err != nil {
-			// Error from closing listeners, or context timeout:
-			log.Error("HTTP server Shutdown: %v", err)
-		}
-		close(idleConnsClosed)
-	}()
+	go shutdown(&server, idleConnsClosed)
 
 	log.Info("Nanny listening", "addr", server.Addr)
 	err = server.ListenAndServe()
@@ -236,6 +221,22 @@ func makeNotifiers() (map[string]notifier.Notifier, error) {
 	return notifiers, nil
 }
 
+// shutdown handles interrupt signal and shuts down server cleanly, waiting for
+// all idle connections to be closed.
+func shutdown(server *http.Server, idleConnsClosed chan struct{}) {
+	sigint := make(chan os.Signal, 1)
+	signal.Notify(sigint, os.Interrupt)
+	<-sigint
+	log.Info("Nanny shutting down.")
+
+	// We received an interrupt signal, shut down.
+	if err := server.Shutdown(context.Background()); err != nil {
+		// Error from closing listeners, or context timeout:
+		log.Error("HTTP server Shutdown: %v", err)
+	}
+	close(idleConnsClosed)
+}
+
 // Execute adds all child commands to the root command and sets flags appropriately.
 // This is called by main.main(). It only needs to happen once to the rootCmd.
 func Execute() {

pkg/closer/closer.go

@@ -0,0 +1,16 @@
+package closer
+
+import (
+	"fmt"
+	"io"
+
+	log "github.com/mgutz/logxi"
+)
+
+// Close closes any io.Closer and checks for error, which will be logged.
+func Close(closer io.Closer) {
+	err := closer.Close()
+	if err != nil {
+		log.Error("Unable to close resource!", "err", err, "type", fmt.Sprintf("%T", closer))
+	}
+}