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