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 )
  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 version %s, commit %s\n", version, commit)
  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         if srv.Config.EnableBonjour {
 172                 s, err := bonjour.Register(srv.Config.Name, "_hotline._tcp", "", *basePort, []string{"txtv=1", "app=hotline"}, nil)
 173                 if err != nil {
 174                         slogger.Error("Error registering Hotline server with Bonjour", "err", err)
 175                 }
 176                 defer s.Shutdown()
 177         }
 178
 179         // Serve Hotline requests until program exit
 180         log.Fatal(srv.ListenAndServe(ctx))
 181 }
 182
 183 func configSearchPaths() string {
 184         for _, cfgPath := range mobius.ConfigSearchOrder {
 185                 if _, err := os.Stat(cfgPath); err == nil {
 186                         return cfgPath
 187                 }
 188         }
 189
 190         return "config"
 191 }
 192
 193 // copyDir recursively copies a directory tree, attempting to preserve permissions.
 194 func copyDir(src, dst string) error {
 195         entries, err := cfgTemplate.ReadDir(src)
 196         if err != nil {
 197                 return err
 198         }
 199         for _, dirEntry := range entries {
 200                 if dirEntry.IsDir() {
 201                         if err := os.MkdirAll(path.Join(dst, dirEntry.Name()), 0777); err != nil {
 202                                 panic(err)
 203                         }
 204                         subdirEntries, _ := cfgTemplate.ReadDir(path.Join(src, dirEntry.Name()))
 205                         for _, subDirEntry := range subdirEntries {
 206                                 f, err := os.Create(path.Join(dst, dirEntry.Name(), subDirEntry.Name()))
 207                                 if err != nil {
 208                                         return err
 209                                 }
 210
 211                                 srcFile, err := cfgTemplate.Open(path.Join(src, dirEntry.Name(), subDirEntry.Name()))
 212                                 if err != nil {
 213                                         return fmt.Errorf("error copying srcFile: %w", err)
 214                                 }
 215                                 _, err = io.Copy(f, srcFile)
 216                                 if err != nil {
 217                                         return err
 218                                 }
 219                                 _ = f.Close()
 220                         }
 221                 } else {
 222                         f, err := os.Create(path.Join(dst, dirEntry.Name()))
 223                         if err != nil {
 224                                 return err
 225                         }
 226
 227                         srcFile, err := cfgTemplate.Open(path.Join(src, dirEntry.Name()))
 228                         if err != nil {
 229                                 return err
 230                         }
 231                         _, err = io.Copy(f, srcFile)
 232                         if err != nil {
 233                                 return err
 234                         }
 235                         _ = f.Close()
 236                 }
 237         }
 238
 239         return nil
 240 }