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