Refactored main function

Author: qdm12

cmd/updater/main.go

@@ -3,6 +3,8 @@ package main
 import (
 	"context"
 	"net"
+	"os/signal"
+	"syscall"
 
 	"fmt"
 	"net/http"
@@ -16,10 +18,8 @@ import (
 	"github.com/qdm12/golibs/network/connectivity"
 	libparams "github.com/qdm12/golibs/params"
 	"github.com/qdm12/golibs/server"
-	"github.com/qdm12/golibs/signals"
 
 	"github.com/qdm12/ddns-updater/internal/data"
-	"github.com/qdm12/ddns-updater/internal/env"
 	"github.com/qdm12/ddns-updater/internal/handlers"
 	"github.com/qdm12/ddns-updater/internal/healthcheck"
 	"github.com/qdm12/ddns-updater/internal/models"
@@ -31,70 +31,97 @@ import (
 )
 
 func main() {
-	logger, err := logging.NewLogger(logging.ConsoleEncoding, logging.InfoLevel, -1)
-	if err != nil {
-		panic(err)
-	}
-	paramsReader := params.NewReader(logger)
-	encoding, level, nodeID, err := paramsReader.GetLoggerConfig()
-	if err != nil {
-		logger.Error(err)
-	} else {
-		logger, err = logging.NewLogger(encoding, level, nodeID)
-		if err != nil {
-			panic(err)
-		}
-	}
+	os.Exit(_main(context.Background()))
+	// returns 1 on error
+	// returns 2 on os signal
+}
+
+func _main(ctx context.Context) int {
 	if libhealthcheck.Mode(os.Args) {
 		// Running the program in a separate instance through the Docker
 		// built-in healthcheck, in an ephemeral fashion to query the
 		// long running instance of the program about its status
 		if err := libhealthcheck.Query(); err != nil {
-			logger.Error(err)
-			os.Exit(1)
+			fmt.Println(err)
+			return 1
 		}
-		os.Exit(0)
+		return 0
 	}
-	fmt.Println(splash.Splash(paramsReader))
-	e := env.NewEnv(logger)
-	gotifyURL, err := paramsReader.GetGotifyURL()
-	e.FatalOnError(err)
-	if gotifyURL != nil {
-		gotifyToken, err := paramsReader.GetGotifyToken()
-		e.FatalOnError(err)
-		e.SetGotify(admin.NewGotify(*gotifyURL, gotifyToken, &http.Client{Timeout: time.Second}))
+	logger, err := setupLogger()
+	if err != nil {
+		fmt.Println(err)
+		return 1
+	}
+	paramsReader := params.NewReader(logger)
+
+	fmt.Println(splash.Splash(
+		paramsReader.GetVersion(),
+		paramsReader.GetVcsRef(),
+		paramsReader.GetBuildDate()))
+
+	notify, err := setupGotify(paramsReader, logger)
+	if err != nil {
+		logger.Error(err)
+		return 1
 	}
+
 	listeningPort, warning, err := paramsReader.GetListeningPort()
-	e.FatalOnError(err)
 	if len(warning) > 0 {
 		logger.Warn(warning)
 	}
+	if err != nil {
+		logger.Error(err)
+		notify(4, err)
+		return 1
+	}
 	rootURL, err := paramsReader.GetRootURL()
-	e.FatalOnError(err)
+	if err != nil {
+		logger.Error(err)
+		notify(4, err)
+		return 1
+	}
 	defaultPeriod, err := paramsReader.GetDelay(libparams.Default("10m"))
-	e.FatalOnError(err)
+	if err != nil {
+		logger.Error(err)
+		notify(4, err)
+		return 1
+	}
 	dir, err := paramsReader.GetExeDir()
-	e.FatalOnError(err)
+	if err != nil {
+		logger.Error(err)
+		notify(4, err)
+		return 1
+	}
 	dataDir, err := paramsReader.GetDataDir(dir)
-	e.FatalOnError(err)
-	var persistentDB persistence.Database
-	persistentDB, err = persistence.NewJSON(dataDir)
-	e.FatalOnError(err)
-	go signals.WaitForExit(e.ShutdownFromSignal)
+	if err != nil {
+		logger.Error(err)
+		notify(4, err)
+		return 1
+	}
+
+	persistentDB, err := persistence.NewJSON(dataDir)
+	if err != nil {
+		logger.Error(err)
+		notify(4, err)
+		return 1
+	}
 	settings, warnings, err := paramsReader.GetSettings(dataDir + "/config.json")
 	for _, w := range warnings {
-		e.Warn(w)
+		logger.Warn(w)
+		notify(2, w)
 	}
 	if err != nil {
-		e.Fatal(err)
+		logger.Error(err)
+		notify(4, err)
+		return 1
 	}
 	if len(settings) > 1 {
 		logger.Info("Found %d settings to update records", len(settings))
 	} else if len(settings) == 1 {
 		logger.Info("Found single setting to update records")
 	}
 	for _, err := range connectivity.NewConnectivity(5 * time.Second).Checks("google.com") {
-		e.Warn(err)
+		logger.Warn(err)
 	}
 	records := make([]models.Record, len(settings))
 	idToPeriod := make(map[int]time.Duration)
@@ -103,7 +130,9 @@ func main() {
 		logger.Info("Reading history from database: domain %s host %s", setting.Domain, setting.Host)
 		events, err := persistentDB.GetEvents(setting.Domain, setting.Host)
 		if err != nil {
-			e.FatalOnError(err)
+			logger.Error(err)
+			notify(4, err)
+			return 1
 		}
 		records[i] = models.NewRecord(setting, events)
 		idToPeriod[id] = defaultPeriod
@@ -113,27 +142,91 @@ func main() {
 		i++
 	}
 	HTTPTimeout, err := paramsReader.GetHTTPTimeout()
-	e.FatalOnError(err)
+	if err != nil {
+		logger.Error(err)
+		notify(4, err)
+		return 1
+	}
 	client := network.NewClient(HTTPTimeout)
+	defer client.Close()
 	db := data.NewDatabase(records, persistentDB)
-	e.SetDB(db)
-	updater := update.NewUpdater(db, logger, client, e.Notify)
-	ctx, cancel := context.WithCancel(context.Background())
+	defer func() {
+		if err := db.Close(); err != nil {
+			logger.Error(err)
+		}
+	}()
+	updater := update.NewUpdater(db, logger, client, notify)
+	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
-	forceUpdate := trigger.StartUpdates(ctx, updater, idToPeriod, e.CheckError)
+	checkError := func(err error) {
+		if err != nil {
+			logger.Error(err)
+		}
+	}
+	forceUpdate := trigger.StartUpdates(ctx, updater, idToPeriod, checkError)
 	forceUpdate()
-	productionHandlerFunc := handlers.NewHandler(rootURL, dir, db, logger, forceUpdate, e.CheckError).GetHandlerFunc()
+	productionHandlerFunc := handlers.NewHandler(rootURL, dir, db, logger, forceUpdate, checkError).GetHandlerFunc()
 	healthcheckHandlerFunc := libhealthcheck.GetHandler(func() error {
 		return healthcheck.IsHealthy(db, net.LookupIP, logger)
 	})
 	logger.Info("Web UI listening at address 0.0.0.0:%s with root URL %s", listeningPort, rootURL)
-	e.Notify(1, fmt.Sprintf("Just launched\nIt has %d records to watch", len(records)))
-	serverErrs := server.RunServers(
-		ctx,
-		server.Settings{Name: "production", Addr: "0.0.0.0:" + listeningPort, Handler: productionHandlerFunc},
-		server.Settings{Name: "healthcheck", Addr: "127.0.0.1:9999", Handler: healthcheckHandlerFunc},
+	notify(1, fmt.Sprintf("Launched with %d records to watch", len(records)))
+	serverErrors := make(chan []error)
+	go func() {
+		serverErrors <- server.RunServers(ctx,
+			server.Settings{Name: "production", Addr: "0.0.0.0:" + listeningPort, Handler: productionHandlerFunc},
+			server.Settings{Name: "healthcheck", Addr: "127.0.0.1:9999", Handler: healthcheckHandlerFunc},
+		)
+	}()
+
+	osSignals := make(chan os.Signal, 1)
+	signal.Notify(osSignals,
+		syscall.SIGINT,
+		syscall.SIGTERM,
+		os.Interrupt,
 	)
-	if len(serverErrs) > 0 {
-		e.Fatal(serverErrs)
+	select {
+	case errors := <-serverErrors:
+		for _, err := range errors {
+			logger.Error(err)
+		}
+		return 1
+	case signal := <-osSignals:
+		message := fmt.Sprintf("Stopping program: caught OS signal %q", signal)
+		logger.Warn(message)
+		notify(2, message)
+		return 2
+	case <-ctx.Done():
+		message := fmt.Sprintf("Stopping program: %s", ctx.Err())
+		logger.Warn(message)
+		return 1
 	}
 }
+
+func setupLogger() (logging.Logger, error) {
+	paramsReader := params.NewReader(nil)
+	encoding, level, nodeID, err := paramsReader.GetLoggerConfig()
+	if err != nil {
+		return nil, err
+	}
+	return logging.NewLogger(encoding, level, nodeID)
+}
+
+func setupGotify(paramsReader params.Reader, logger logging.Logger) (notify func(priority int, messageArgs ...interface{}), err error) {
+	gotifyURL, err := paramsReader.GetGotifyURL()
+	if err != nil {
+		return nil, err
+	} else if gotifyURL == nil {
+		return func(priority int, messageArgs ...interface{}) {}, nil
+	}
+	gotifyToken, err := paramsReader.GetGotifyToken()
+	if err != nil {
+		return nil, err
+	}
+	gotify := admin.NewGotify(*gotifyURL, gotifyToken, &http.Client{Timeout: time.Second})
+	return func(priority int, messageArgs ...interface{}) {
+		if err := gotify.Notify("DDNS Updater", priority, messageArgs...); err != nil {
+			logger.Error(err)
+		}
+	}, nil
+}