git.r.bdr.sh - rbdr/mobius/blob - cmd/mobius-hotline-server/main.go

   1 package main
   2
   3 import (
   4         "context"
   5         "embed"
   6         "encoding/json"
   7         "flag"
   8         "fmt"
   9         "github.com/jhalter/mobius/hotline"
  10         "github.com/jhalter/mobius/internal/mobius"
  11         "gopkg.in/natefinch/lumberjack.v2"
  12         "io"
  13         "log"
  14         "log/slog"
  15         "net/http"
  16         "os"
  17         "os/signal"
  18         "path"
  19         "runtime"
  20         "syscall"
  21 )
  22
  23 //go:embed mobius/config
  24 var cfgTemplate embed.FS
  25
  26 const defaultPort = 5500
  27
  28 var logLevels = map[string]slog.Level{
  29         "debug": slog.LevelDebug,
  30         "info":  slog.LevelInfo,
  31         "error": slog.LevelError,
  32 }
  33
  34 // Values swapped in by go-releaser at build time
  35 var (
  36         version = "dev"
  37         commit  = "none"
  38         date    = "unknown"
  39 )
  40
  41 func main() {
  42         ctx, cancel := context.WithCancel(context.Background())
  43
  44         sigChan := make(chan os.Signal, 1)
  45         signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGINT, os.Interrupt)
  46
  47         netInterface := flag.String("interface", "", "IP addr of interface to listen on.  Defaults to all interfaces.")
  48         basePort := flag.Int("bind", defaultPort, "Base Hotline server port.  File transfer port is base port + 1.")
  49         statsPort := flag.String("stats-port", "", "Enable stats HTTP endpoint on address and port")
  50         configDir := flag.String("config", defaultConfigPath(), "Path to config root")
  51         printVersion := flag.Bool("version", false, "Print version and exit")
  52         logLevel := flag.String("log-level", "info", "Log level")
  53         logFile := flag.String("log-file", "", "Path to log file")
  54
  55         init := flag.Bool("init", false, "Populate the config dir with default configuration")
  56
  57         flag.Parse()
  58
  59         if *printVersion {
  60                 fmt.Printf("mobius-hotline-server %s, commit %s, built at %s", version, commit, date)
  61                 os.Exit(0)
  62         }
  63
  64         slogger := slog.New(
  65                 slog.NewTextHandler(
  66                         io.MultiWriter(os.Stdout, &lumberjack.Logger{
  67                                 Filename:   *logFile,
  68                                 MaxSize:    100, // MB
  69                                 MaxBackups: 3,
  70                                 MaxAge:     365, // days
  71                         }),
  72                         &slog.HandlerOptions{Level: logLevels[*logLevel]},
  73                 ),
  74         )
  75
  76         // It's important for Windows compatibility to use path.Join and not filepath.Join for the config dir initialization.
  77         // https://github.com/golang/go/issues/44305
  78         if *init {
  79                 if _, err := os.Stat(path.Join(*configDir, "/config.yaml")); os.IsNotExist(err) {
  80                         if err := os.MkdirAll(*configDir, 0750); err != nil {
  81                                 slogger.Error(fmt.Sprintf("error creating config dir: %s", err))
  82                                 os.Exit(1)
  83                         }
  84                         if err := copyDir(path.Join("mobius", "config"), *configDir); err != nil {
  85                                 slogger.Error(fmt.Sprintf("error copying config dir: %s", err))
  86                                 os.Exit(1)
  87                         }
  88                         slogger.Info("Config dir initialized at " + *configDir)
  89                 } else {
  90                         slogger.Info("Existing config dir found.  Skipping initialization.")
  91                 }
  92         }
  93
  94         if _, err := os.Stat(*configDir); os.IsNotExist(err) {
  95                 slogger.Error("Configuration directory not found.  Correct the path or re-run with -init to generate initial config.")
  96                 os.Exit(1)
  97         }
  98
  99         config, err := mobius.LoadConfig(path.Join(*configDir, "config.yaml"))
 100         if err != nil {
 101                 slogger.Error(fmt.Sprintf("Error loading config: %v", err))
 102                 os.Exit(1)
 103         }
 104
 105         srv, err := hotline.NewServer(*config, *configDir, *netInterface, *basePort, slogger, &hotline.OSFileStore{})
 106         if err != nil {
 107                 slogger.Error(fmt.Sprintf("Error starting server: %s", err))
 108                 os.Exit(1)
 109         }
 110
 111         srv.MessageBoard, err = mobius.NewFlatNews(path.Join(*configDir, "MessageBoard.txt"))
 112         if err != nil {
 113                 slogger.Error(fmt.Sprintf("Error loading message board: %v", err))
 114                 os.Exit(1)
 115         }
 116
 117         srv.BanList, err = mobius.NewBanFile(path.Join(*configDir, "Banlist.yaml"))
 118         if err != nil {
 119                 slogger.Error(fmt.Sprintf("Error loading ban list: %v", err))
 120                 os.Exit(1)
 121         }
 122
 123         srv.ThreadedNewsMgr, err = mobius.NewThreadedNewsYAML(path.Join(*configDir, "ThreadedNews.yaml"))
 124         if err != nil {
 125                 slogger.Error(fmt.Sprintf("Error loading news: %v", err))
 126                 os.Exit(1)
 127         }
 128
 129         sh := statHandler{hlServer: srv}
 130         if *statsPort != "" {
 131                 http.HandleFunc("/", sh.RenderStats)
 132
 133                 go func(srv *hotline.Server) {
 134                         // Use the default DefaultServeMux.
 135                         err = http.ListenAndServe(":"+*statsPort, nil)
 136                         if err != nil {
 137                                 log.Fatal(err)
 138                         }
 139                 }(srv)
 140         }
 141
 142         go func() {
 143                 for {
 144                         sig := <-sigChan
 145                         switch sig {
 146                         case syscall.SIGHUP:
 147                                 slogger.Info("SIGHUP received.  Reloading configuration.")
 148
 149                                 if err := srv.MessageBoard.(*mobius.FlatNews).Reload(); err != nil {
 150                                         slogger.Error("Error reloading news", "err", err)
 151                                 }
 152
 153                                 if err := srv.BanList.(*mobius.BanFile).Load(); err != nil {
 154                                         slogger.Error("Error reloading ban list", "err", err)
 155                                 }
 156
 157                                 if err := srv.ThreadedNewsMgr.(*mobius.ThreadedNewsYAML).Load(); err != nil {
 158                                         slogger.Error("Error reloading threaded news list", "err", err)
 159                                 }
 160                         default:
 161                                 signal.Stop(sigChan)
 162                                 cancel()
 163                                 os.Exit(0)
 164                         }
 165
 166                 }
 167         }()
 168
 169         slogger.Info("Hotline server started",
 170                 "version", version,
 171                 "API port", fmt.Sprintf("%s:%v", *netInterface, *basePort),
 172                 "Transfer port", fmt.Sprintf("%s:%v", *netInterface, *basePort+1),
 173         )
 174
 175         // Serve Hotline requests until program exit
 176         log.Fatal(srv.ListenAndServe(ctx))
 177 }
 178
 179 type statHandler struct {
 180         hlServer *hotline.Server
 181 }
 182
 183 func (sh *statHandler) RenderStats(w http.ResponseWriter, _ *http.Request) {
 184         u, err := json.Marshal(sh.hlServer.CurrentStats())
 185         if err != nil {
 186                 panic(err)
 187         }
 188
 189         _, _ = io.WriteString(w, string(u))
 190 }
 191
 192 func defaultConfigPath() string {
 193         var cfgPath string
 194
 195         switch runtime.GOOS {
 196         case "windows":
 197                 cfgPath = "config/"
 198         case "darwin":
 199                 if _, err := os.Stat("/usr/local/var/mobius/config/"); err == nil {
 200                         cfgPath = "/usr/local/var/mobius/config/"
 201                 } else if _, err := os.Stat("/opt/homebrew/var/mobius/config"); err == nil {
 202                         cfgPath = "/opt/homebrew/var/mobius/config/"
 203                 }
 204         case "linux":
 205                 cfgPath = "/usr/local/var/mobius/config/"
 206         default:
 207                 cfgPath = "./config/"
 208         }
 209
 210         return cfgPath
 211 }
 212
 213 // copyDir recursively copies a directory tree, attempting to preserve permissions.
 214 func copyDir(src, dst string) error {
 215         entries, err := cfgTemplate.ReadDir(src)
 216         if err != nil {
 217                 return err
 218         }
 219         for _, dirEntry := range entries {
 220                 if dirEntry.IsDir() {
 221                         if err := os.MkdirAll(path.Join(dst, dirEntry.Name()), 0777); err != nil {
 222                                 panic(err)
 223                         }
 224                         subdirEntries, _ := cfgTemplate.ReadDir(path.Join(src, dirEntry.Name()))
 225                         for _, subDirEntry := range subdirEntries {
 226                                 f, err := os.Create(path.Join(dst, dirEntry.Name(), subDirEntry.Name()))
 227                                 if err != nil {
 228                                         return err
 229                                 }
 230
 231                                 srcFile, err := cfgTemplate.Open(path.Join(src, dirEntry.Name(), subDirEntry.Name()))
 232                                 if err != nil {
 233                                         return fmt.Errorf("error copying srcFile: %w", err)
 234                                 }
 235                                 _, err = io.Copy(f, srcFile)
 236                                 if err != nil {
 237                                         return err
 238                                 }
 239                                 f.Close()
 240                         }
 241                 } else {
 242                         f, err := os.Create(path.Join(dst, dirEntry.Name()))
 243                         if err != nil {
 244                                 return err
 245                         }
 246
 247                         srcFile, err := cfgTemplate.Open(path.Join(src, dirEntry.Name()))
 248                         if err != nil {
 249                                 return err
 250                         }
 251                         _, err = io.Copy(f, srcFile)
 252                         if err != nil {
 253                                 return err
 254                         }
 255                         f.Close()
 256                 }
 257         }
 258
 259         return nil
 260 }