update... work pending

cmd/gobroke/args.go

@@ -0,0 +1,10 @@
+package main
+
+type Args struct {
+	Version       bool   `short:"v" long:"version" description:"Print the version and exit."`
+	DetailVersion bool   `short:"V" long:"detail" description:"Print detailed version info and exit."`
+	DoDebug       bool   `env:"GOBROKE_DEBUG" short:"d" long:"debug" description:"If specified, enable debug logging. This may log potentially sensitive information, so be careful."`
+	DryRun        bool   `env:"GOBROKE_RO" short:"n" long:"dry-run" description:"If specified, only perfrom dry-run operations (read-only). Changes that would be made are logged but are not actually performed."`
+	ConfigPath    string `env:"GOBROKE_CFG" required:"true" short:"c" long:"config" default:"/etc/gobroke/gobroke.conf" description:"The path to the configuration file." validate:"required,file"`
+	Daemon        bool   `env:"GOBROKE_DAEMON" short:"D" long:"daemon" description:"Run as a daemon. If not specified, GoBroke will run once, updating the tunnel configuration if necessary, and then quit."`
+}

cmd/gobroke/consts.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	`log`
+)
+
+const (
+	logFlags      int = log.LstdFlags | log.Lmsgprefix
+	logFlagsDebug int = logFlags | log.Llongfile
+)

cmd/gobroke/funcs_linux.go

@@ -0,0 +1,21 @@
+//go:build !windows
+
+package main
+
+import (
+	`r00t2.io/goutils/logging`
+)
+
+// getOsLogger adds the default logger per OS.
+func getOsLogger(logger *logging.MultiLogger, logFlagsRuntime int) (err error) {
+
+	if err = logger.AddDefaultLogger(
+		"default",
+		logFlagsRuntime,
+		"/var/log/gobroke/gobroke.log", "~/logs/gobroke.log",
+	); err != nil {
+		return
+	}
+
+	return
+}

cmd/gobroke/funcs_windows.go

@@ -0,0 +1,17 @@
+//go:build windows
+
+package main
+
+import (
+	`r00t2.io/goutils/logging`
+)
+
+// getOsLogger adds the default logger per OS.
+func getOsLogger(logger *logging.MultiLogger, logFlagsRuntime int) (err error) {
+
+	if err = logger.AddDefaultLogger("default", logging.DefaultEventID, logFlagsRuntime, `C:\GoBroke\GoBroke.log`, `~\GoBroke\GoBroke.log`); err != nil {
+		return
+	}
+
+	return
+}

cmd/gobroke/main.go

@@ -1 +1,106 @@
-package gobroke
+package main
+
+import (
+	`errors`
+	`fmt`
+	`log`
+	`os`
+
+	`github.com/davecgh/go-spew/spew`
+	`github.com/jessevdk/go-flags`
+	`r00t2.io/gobroke/conf`
+	`r00t2.io/gobroke/daemon`
+	`r00t2.io/gobroke/runner`
+	`r00t2.io/gobroke/version`
+	`r00t2.io/goutils/logging`
+)
+
+func main() {
+
+	var err error
+	var args *Args = new(Args)
+	var logger *logging.MultiLogger
+	var cfg *conf.Config
+	var logFlagsRuntime int = logFlags
+	var singleResults []*runner.TunnelResult
+	var tunsChanged bool
+	var tunsUpdated bool
+	var updater *daemon.Updater
+	var flagsErr *flags.Error = new(flags.Error)
+	var parser *flags.Parser = flags.NewParser(args, flags.Default)
+
+	if _, err = parser.Parse(); err != nil {
+		switch {
+		case errors.As(err, &flagsErr):
+			switch {
+			case errors.Is(flagsErr.Type, flags.ErrHelp), errors.Is(flagsErr.Type, flags.ErrCommandRequired), errors.Is(flagsErr.Type, flags.ErrRequired): // These print their relevant messages by themselves.
+				return
+			default:
+				log.Panicln(err)
+			}
+		default:
+			log.Panicln(err)
+		}
+	}
+
+	if version.Ver, err = version.Version(); err != nil {
+		log.Panicln(err)
+	}
+
+	// If args.Version or args.DetailVersion are true, just print them and exit.
+	if args.DetailVersion || args.Version {
+		if args.Version {
+			fmt.Println(version.Ver.Short())
+			return
+		} else if args.DetailVersion {
+			fmt.Println(version.Ver.Detail())
+			return
+		}
+	}
+
+	// We want to set up logging before anything else.
+	if args.DoDebug {
+		logFlagsRuntime = logFlagsDebug
+	}
+	logger = logging.GetMultiLogger(args.DoDebug, "GoBroke")
+	if err = getOsLogger(logger, logFlagsRuntime); err != nil {
+		log.Panicln(err)
+	}
+	if err = logger.Setup(); err != nil {
+		log.Panicln(err)
+	}
+	logger.Info("main: GoBroke version %v", version.Ver.Short())
+	logger.Debug("main: GoBroke version (extended):\n%v", version.Ver.Detail())
+	defer logger.Shutdown()
+
+	logger.Debug("Initialized with args:\n%v", spew.Sdump(args))
+
+	if cfg, err = conf.NewConfig(args.ConfigPath, args.DoDebug, logger); err != nil {
+		logger.Err("main: Received error while initializing config: %v", err)
+		log.Panicln(err)
+	}
+
+	if singleResults, tunsChanged, tunsUpdated, err = runner.Run(cfg, logger); err != nil {
+		logger.Err("main: Received error while running startup checks/updates: %v", err)
+		log.Panicln(err)
+	}
+	logger.Info("main: Startup check: Changed: %v, Updated: %v", tunsChanged, tunsUpdated)
+	logger.Debug("main: Startup check: Tunnel results:\n%s", spew.Sdump(singleResults))
+
+	if !args.Daemon {
+		// Single run.
+		logger.Debug("main: Done.")
+		os.Exit(0)
+	}
+
+	if updater, err = daemon.NewUpdater(cfg, logger); err != nil {
+		logger.Err("main: Received error while initializing persistent updater: %v", err)
+		log.Panicln(err)
+	}
+	if err = updater.Start(); err != nil {
+		logger.Err("main: Received error while starting/running persistent updater: %v", err)
+		log.Panicln(err)
+	}
+
+	logger.Debug("main: Done.")
+}