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