250 lines
7.3 KiB
Go
250 lines
7.3 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"log/slog"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/disgoorg/disgo"
|
|
"github.com/disgoorg/disgo/bot"
|
|
"github.com/disgoorg/disgo/discord"
|
|
"github.com/disgoorg/disgo/handler"
|
|
"github.com/disgoorg/disgo/handler/middleware"
|
|
"github.com/disgoorg/disgo/httpserver"
|
|
"github.com/disgoorg/disgo/rest"
|
|
httpmiddle "github.com/go-chi/chi/v5/middleware"
|
|
"zombiezen.com/go/sqlite"
|
|
"zombiezen.com/go/sqlite/sqlitex"
|
|
|
|
"git.sunturtle.xyz/zephyr/horse"
|
|
"git.sunturtle.xyz/zephyr/horse/mdb"
|
|
)
|
|
|
|
func main() {
|
|
var (
|
|
// public site
|
|
addr string
|
|
mdbf string
|
|
public string
|
|
// discord
|
|
tokenFile string
|
|
apiRoute string
|
|
pubkey string
|
|
// logging
|
|
level slog.Level
|
|
textfmt string
|
|
)
|
|
flag.StringVar(&addr, "http", ":80", "`address` to bind HTTP server")
|
|
flag.StringVar(&mdbf, "mdb", "", "`path` to master.mdb")
|
|
flag.StringVar(&public, "public", "", "`dir`ectory containing the website to serve")
|
|
flag.StringVar(&tokenFile, "token", "", "`file` containing the Discord bot token")
|
|
flag.StringVar(&apiRoute, "route", "/interactions/callback", "`path` to serve Discord HTTP API calls")
|
|
flag.StringVar(&pubkey, "key", "", "Discord public key")
|
|
flag.TextVar(&level, "log", slog.LevelInfo, "slog logging `level`")
|
|
flag.StringVar(&textfmt, "log-format", "text", "slog logging `format`, text or json")
|
|
flag.Parse()
|
|
|
|
var lh slog.Handler
|
|
switch textfmt {
|
|
case "text":
|
|
lh = slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: level})
|
|
case "json":
|
|
lh = slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: level})
|
|
default:
|
|
fmt.Fprintf(os.Stderr, "invalid log format %q, must be text or json", textfmt)
|
|
os.Exit(1)
|
|
}
|
|
slog.SetDefault(slog.New(lh))
|
|
|
|
stat, err := os.Stat(public)
|
|
if err != nil {
|
|
slog.Error("public", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
if !stat.IsDir() {
|
|
slog.Error("public", slog.String("err", "not a directory"))
|
|
os.Exit(1)
|
|
}
|
|
|
|
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
|
|
|
|
db, err := sqlitex.NewPool(mdbf, sqlitex.PoolOptions{Flags: sqlite.OpenReadOnly})
|
|
if err != nil {
|
|
slog.Error("mdb", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
|
|
skills, err := mdb.Skills(ctx, db)
|
|
slog.Info("loaded skills", slog.Int("count", len(skills)))
|
|
groups, err2 := mdb.SkillGroups(ctx, db)
|
|
slog.Info("loaded skill groups", slog.Int("count", len(groups)))
|
|
if err = errors.Join(err, err2); err != nil {
|
|
slog.Error("loading data", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
skillSrv := newSkillServer(skills, groups)
|
|
slog.Info("skill server ready")
|
|
|
|
token, err := os.ReadFile(tokenFile)
|
|
if err != nil {
|
|
slog.Error("reading token", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
token = bytes.TrimSuffix(token, []byte{'\n'})
|
|
|
|
r := handler.New()
|
|
r.DefaultContext(func() context.Context { return ctx })
|
|
r.Use(middleware.Go)
|
|
r.Use(logMiddleware)
|
|
r.Route("/skill", func(r handler.Router) {
|
|
r.SlashCommand("/", skillSrv.slash)
|
|
r.Autocomplete("/", skillSrv.autocomplete)
|
|
r.SelectMenuComponent("/swap", skillSrv.menu)
|
|
r.ButtonComponent("/swap/{id}", skillSrv.button)
|
|
})
|
|
slog.Info("connect", slog.String("disgo", disgo.Version))
|
|
client, err := disgo.New(string(token), bot.WithDefaultGateway(), bot.WithEventListeners(r))
|
|
if err != nil {
|
|
slog.Error("building bot", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
|
|
mux := http.NewServeMux()
|
|
mux.Handle("GET /", httpmiddle.Compress(5)(http.FileServerFS(os.DirFS(public))))
|
|
mux.Handle("GET /api/data/affinity", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.AffinitySummary)))
|
|
mux.Handle("GET /api/data/character", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Characters)))
|
|
mux.Handle("GET /api/data/conversation", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Conversations)))
|
|
mux.Handle("GET /api/data/race", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Races)))
|
|
mux.Handle("GET /api/data/saddle", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Saddles)))
|
|
mux.Handle("GET /api/data/scenario", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Scenarios)))
|
|
mux.Handle("GET /api/data/skill", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Skills)))
|
|
mux.Handle("GET /api/data/skill-group", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.SkillGroups)))
|
|
mux.Handle("GET /api/data/spark", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Sparks)))
|
|
mux.Handle("GET /api/data/uma", httpmiddle.Compress(5)(dataroute(ctx, db, mdb.Umas)))
|
|
if pubkey != "" {
|
|
pk, err := hex.DecodeString(pubkey)
|
|
if err != nil {
|
|
slog.Error("pubkey", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
mux.Handle("POST "+apiRoute, httpserver.HandleInteraction(httpserver.DefaultVerifier{}, pk, slog.Default(), client.EventManager.HandleHTTPEvent))
|
|
slog.Info("Discord HTTP API enabled", slog.String("pubkey", pubkey))
|
|
}
|
|
l, err := net.Listen("tcp", addr)
|
|
if err != nil {
|
|
slog.Error("listen", slog.String("addr", addr), slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
srv := http.Server{
|
|
Addr: addr,
|
|
Handler: mux,
|
|
ReadTimeout: 15 * time.Second,
|
|
WriteTimeout: 15 * time.Second,
|
|
BaseContext: func(l net.Listener) context.Context { return ctx },
|
|
}
|
|
go func() {
|
|
slog.Info("HTTP", slog.Any("addr", l.Addr()))
|
|
err := srv.Serve(l)
|
|
if err == http.ErrServerClosed {
|
|
return
|
|
}
|
|
slog.Error("HTTP server closed", slog.Any("err", err))
|
|
}()
|
|
|
|
if err := handler.SyncCommands(client, commands, nil, rest.WithCtx(ctx)); err != nil {
|
|
slog.Error("syncing commands", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
|
|
slog.Info("start gateway")
|
|
if err := client.OpenGateway(ctx); err != nil {
|
|
slog.Error("starting gateway", slog.Any("err", err))
|
|
stop()
|
|
}
|
|
slog.Info("ready")
|
|
<-ctx.Done()
|
|
stop()
|
|
|
|
ctx, stop = context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer stop()
|
|
client.Close(ctx)
|
|
if err := srv.Shutdown(ctx); err != nil {
|
|
slog.Error("HTTP API shutdown", slog.Any("err", err))
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
var commands = []discord.ApplicationCommandCreate{
|
|
discord.SlashCommandCreate{
|
|
Name: "skill",
|
|
Description: "Umamusume skill data",
|
|
Options: []discord.ApplicationCommandOption{
|
|
discord.ApplicationCommandOptionString{
|
|
Name: "query",
|
|
Description: "Skill name or ID",
|
|
Required: true,
|
|
Autocomplete: true,
|
|
},
|
|
discord.ApplicationCommandOptionBool{
|
|
Name: "share",
|
|
Description: "Share the skill info",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
func loadSkills(file string) ([]horse.Skill, error) {
|
|
b, err := os.ReadFile(file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var skills []horse.Skill
|
|
if err := json.Unmarshal(b, &skills); err != nil {
|
|
return nil, err
|
|
}
|
|
return skills, nil
|
|
}
|
|
|
|
func loadSkillGroups(file string) ([]horse.SkillGroup, error) {
|
|
b, err := os.ReadFile(file)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var groups []horse.SkillGroup
|
|
if err := json.Unmarshal(b, &groups); err != nil {
|
|
return nil, err
|
|
}
|
|
return groups, nil
|
|
}
|
|
|
|
func dataroute[T any](ctx context.Context, db *sqlitex.Pool, f func(context.Context, *sqlitex.Pool) ([]T, error)) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
data, err := f(ctx, db)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
b, err := json.Marshal(data)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
|
|
if _, err := w.Write(b); err != nil {
|
|
slog.Error("writing response", slog.Any("err", err))
|
|
return
|
|
}
|
|
}
|
|
}
|