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