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

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