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
  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, *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
 238         return nil
 239 }