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