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