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         "go.uber.org/zap"
  11         "go.uber.org/zap/zapcore"
  12         "gopkg.in/natefinch/lumberjack.v2"
  13         "io"
  14         "log"
  15         "net/http"
  16         "os"
  17         "path/filepath"
  18         "runtime"
  19 )
  20
  21 //go:embed mobius/config
  22 var cfgTemplate embed.FS
  23
  24 const (
  25         defaultPort = 5500
  26 )
  27
  28 func main() {
  29         ctx, cancel := context.WithCancel(context.Background())
  30
  31         // TODO: implement graceful shutdown by closing context
  32         // c := make(chan os.Signal, 1)
  33         // signal.Notify(c, os.Interrupt)
  34         // defer func() {
  35         //      signal.Stop(c)
  36         //      cancel()
  37         // }()
  38         // go func() {
  39         //      select {
  40         //      case <-c:
  41         //              cancel()
  42         //      case <-ctx.Done():
  43         //      }
  44         // }()
  45
  46         netInterface := flag.String("interface", "", "IP addr of interface to listen on.  Defaults to all interfaces.")
  47         basePort := flag.Int("bind", defaultPort, "Base Hotline server port.  File transfer port is base port + 1.")
  48         statsPort := flag.String("stats-port", "", "Enable stats HTTP endpoint on address and port")
  49         configDir := flag.String("config", defaultConfigPath(), "Path to config root")
  50         version := flag.Bool("version", false, "print version and exit")
  51         logLevel := flag.String("log-level", "info", "Log level")
  52         logFile := flag.String("log-file", "", "Path to log file")
  53
  54         init := flag.Bool("init", false, "Populate the config dir with default configuration")
  55
  56         flag.Parse()
  57
  58         if *version {
  59                 fmt.Printf("v%s\n", hotline.VERSION)
  60                 os.Exit(0)
  61         }
  62
  63         zapLvl, ok := zapLogLevel[*logLevel]
  64         if !ok {
  65                 fmt.Printf("Invalid log level %s.  Must be debug, info, warn, or error.\n", *logLevel)
  66                 os.Exit(0)
  67         }
  68
  69         cores := []zapcore.Core{
  70                 newStdoutCore(zapLvl),
  71         }
  72
  73         if *logFile != "" {
  74                 cores = append(cores, newLogFileCore(*logFile, zapLvl))
  75         }
  76
  77         l := zap.New(zapcore.NewTee(cores...))
  78         defer func() { _ = l.Sync() }()
  79         logger := l.Sugar()
  80
  81         if *init {
  82                 if _, err := os.Stat(filepath.Join(*configDir, "/config.yaml")); os.IsNotExist(err) {
  83                         if err := os.MkdirAll(*configDir, 0750); err != nil {
  84                                 logger.Fatal(err)
  85                         }
  86
  87                         if err := copyDir("mobius/config", *configDir); err != nil {
  88                                 logger.Fatal(err)
  89                         }
  90                         logger.Infow("Config dir initialized at " + *configDir)
  91                 } else {
  92                         logger.Infow("Existing config dir found.  Skipping initialization.")
  93                 }
  94         }
  95
  96         if _, err := os.Stat(*configDir); os.IsNotExist(err) {
  97                 logger.Fatalw("Configuration directory not found.  Correct the path or re-run with -init to generate initial config.", "path", configDir)
  98         }
  99
 100         srv, err := hotline.NewServer(*configDir, *netInterface, *basePort, logger, &hotline.OSFileStore{})
 101         if err != nil {
 102                 logger.Fatal(err)
 103         }
 104
 105         sh := statHandler{hlServer: srv}
 106         if *statsPort != "" {
 107                 http.HandleFunc("/", sh.RenderStats)
 108
 109                 go func(srv *hotline.Server) {
 110                         // Use the default DefaultServeMux.
 111                         err = http.ListenAndServe(":"+*statsPort, nil)
 112                         if err != nil {
 113                                 log.Fatal(err)
 114                         }
 115                 }(srv)
 116         }
 117
 118         // Serve Hotline requests until program exit
 119         logger.Fatal(srv.ListenAndServe(ctx, cancel))
 120 }
 121
 122 type statHandler struct {
 123         hlServer *hotline.Server
 124 }
 125
 126 func (sh *statHandler) RenderStats(w http.ResponseWriter, _ *http.Request) {
 127         u, err := json.Marshal(sh.hlServer.CurrentStats())
 128         if err != nil {
 129                 panic(err)
 130         }
 131
 132         _, _ = io.WriteString(w, string(u))
 133 }
 134
 135 func newStdoutCore(level zapcore.Level) zapcore.Core {
 136         encoderCfg := zap.NewProductionEncoderConfig()
 137         encoderCfg.TimeKey = "timestamp"
 138         encoderCfg.EncodeTime = zapcore.ISO8601TimeEncoder
 139
 140         return zapcore.NewCore(
 141                 zapcore.NewConsoleEncoder(encoderCfg),
 142                 zapcore.Lock(os.Stdout),
 143                 level,
 144         )
 145 }
 146
 147 func newLogFileCore(path string, level zapcore.Level) zapcore.Core {
 148         encoderCfg := zap.NewProductionEncoderConfig()
 149         encoderCfg.TimeKey = "timestamp"
 150         encoderCfg.EncodeTime = zapcore.ISO8601TimeEncoder
 151         writer := zapcore.AddSync(&lumberjack.Logger{
 152                 Filename:   path,
 153                 MaxSize:    100, // MB
 154                 MaxBackups: 3,
 155                 MaxAge:     365, // days
 156         })
 157
 158         return zapcore.NewCore(
 159                 zapcore.NewConsoleEncoder(encoderCfg),
 160                 writer,
 161                 level,
 162         )
 163 }
 164
 165 var zapLogLevel = map[string]zapcore.Level{
 166         "debug": zap.DebugLevel,
 167         "info":  zap.InfoLevel,
 168         "warn":  zap.WarnLevel,
 169         "error": zap.ErrorLevel,
 170 }
 171
 172 func defaultConfigPath() (cfgPath string) {
 173         switch runtime.GOOS {
 174         case "windows":
 175                 cfgPath = "config/"
 176         case "darwin":
 177                 if _, err := os.Stat("/usr/local/var/mobius/config/"); err == nil {
 178                         cfgPath = "/usr/local/var/mobius/config/"
 179                 } else if _, err := os.Stat("/opt/homebrew/var/mobius/config"); err == nil {
 180                         cfgPath = "/opt/homebrew/var/mobius/config/"
 181                 }
 182         case "linux":
 183                 cfgPath = "/usr/local/var/mobius/config/"
 184         default:
 185                 fmt.Printf("unsupported OS")
 186         }
 187
 188         return cfgPath
 189 }
 190
 191 // TODO: Simplify this mess.  Why is it so difficult to recursively copy a directory?
 192 func copyDir(src, dst string) error {
 193         entries, err := cfgTemplate.ReadDir(src)
 194         if err != nil {
 195                 return err
 196         }
 197         for _, dirEntry := range entries {
 198                 if dirEntry.IsDir() {
 199                         if err := os.MkdirAll(filepath.Join(dst, dirEntry.Name()), 0777); err != nil {
 200                                 panic(err)
 201                         }
 202                         subdirEntries, _ := cfgTemplate.ReadDir(filepath.Join(src, dirEntry.Name()))
 203                         for _, subDirEntry := range subdirEntries {
 204                                 f, err := os.Create(filepath.Join(dst, dirEntry.Name(), subDirEntry.Name()))
 205                                 if err != nil {
 206                                         return err
 207                                 }
 208
 209                                 srcFile, err := cfgTemplate.Open(filepath.Join(src, dirEntry.Name(), subDirEntry.Name()))
 210                                 if err != nil {
 211                                         return err
 212                                 }
 213                                 _, err = io.Copy(f, srcFile)
 214                                 if err != nil {
 215                                         return err
 216                                 }
 217                                 f.Close()
 218                         }
 219                 } else {
 220                         f, err := os.Create(filepath.Join(dst, dirEntry.Name()))
 221                         if err != nil {
 222                                 return err
 223                         }
 224
 225                         srcFile, err := cfgTemplate.Open(filepath.Join(src, dirEntry.Name()))
 226                         if err != nil {
 227                                 return err
 228                         }
 229                         _, err = io.Copy(f, srcFile)
 230                         if err != nil {
 231                                 return err
 232                         }
 233                         f.Close()
 234                 }
 235         }
 236
 237         return nil
 238 }