Files
wow-AchievementSniffer/service/chatsniffer/main.go

189 lines
4.5 KiB
Go

package main
import (
"flag"
"fmt"
"os"
"path/filepath"
"strings"
"sync"
logger "git.site.quack-lab.dev/dave/cylogger"
"github.com/bmatcuk/doublestar/v4"
lua "github.com/yuin/gopher-lua"
)
const meiliEndpoint = "https://meili.site.quack-lab.dev/"
const meiliIndex = "chatlog"
var debug *bool
func main() {
root := flag.String("root", ".", "Root workdir")
debug = flag.Bool("d", false, "Debug")
flag.Parse()
logger.InitFlag()
if *debug {
logger.SetLevel(logger.LevelDebug)
}
err := Init()
if err != nil {
logger.Error("Failed to initialize Meilisearch: %v", err)
return
}
logger.Info("Root: %q", *root)
cleanedRoot := strings.Replace(*root, "~", os.Getenv("HOME"), 1)
cleanedRoot, err = filepath.Abs(cleanedRoot)
if err != nil {
logger.Error("error getting absolute path: %v", err)
return
}
cleanedRoot = filepath.Clean(cleanedRoot)
cleanedRoot = strings.TrimSuffix(cleanedRoot, "/")
logger.Info("Looking for Heimdall.lua in %q", cleanedRoot)
matches, err := doublestar.Glob(os.DirFS(cleanedRoot), "**/Heimdall.lua")
if err != nil {
logger.Error("error matching Heimdall.lua: %v", err)
return
}
logger.Info("Found %d Heimdall.lua files.", len(matches))
if len(matches) == 0 {
logger.Info("No Heimdall.lua files found. Exiting.")
return
}
for i, match := range matches {
matches[i] = filepath.Join(cleanedRoot, match)
}
luaStates := loadLuaStates(matches)
chatMessages := loadChatMessages(luaStates)
// Save messages to Meilisearch
if err := AddMessages(chatMessages); err != nil {
logger.Error("Failed to save messages: %v", err)
return
}
logger.Info("Successfully saved %d messages", len(chatMessages))
}
func loadLuaStates(matches []string) *sync.Map {
wg := sync.WaitGroup{}
fileLuaStates := &sync.Map{}
for _, match := range matches {
wg.Add(1)
go func(path string) {
defer wg.Done()
log := logger.Default.WithPrefix(path)
L := lua.NewState()
filestat, err := os.Stat(path)
if err != nil {
log.Error("error getting file stats: %v", err)
return
}
log.Info("File size: %.2f MB", float64(filestat.Size())/1024/1024)
log.Info("Running Lua file")
if err := L.DoFile(path); err != nil {
log.Error("error executing Lua file %q: %v", path, err)
return
}
log.Info("Lua file loaded")
fileLuaStates.Store(path, L)
}(match)
}
wg.Wait()
return fileLuaStates
}
func loadChatMessages(luaStates *sync.Map) []ChatMessage {
var messages []ChatMessage
wg := sync.WaitGroup{}
messageChan := make(chan []ChatMessage, 100) // Buffer for concurrent processing
luaStates.Range(func(path, state any) bool {
wg.Add(1)
go func(path string, state *lua.LState) {
defer wg.Done()
log := logger.Default.WithPrefix(path)
fileMessages := loadStateChatMessages(state, log)
messageChan <- fileMessages
}(path.(string), state.(*lua.LState))
return true
})
// Close channel when all goroutines are done
go func() {
wg.Wait()
close(messageChan)
}()
// Collect all messages
for fileMessages := range messageChan {
messages = append(messages, fileMessages...)
}
return messages
}
func loadStateChatMessages(L *lua.LState, log *logger.Logger) []ChatMessage {
log.Info("Getting Heimdall_Chat")
heimdallChat := L.GetGlobal("Heimdall_Chat")
if heimdallChat.Type() == lua.LTNil {
log.Warning("Heimdall_Chat not found. Skipping file.")
return nil
}
chatTable, ok := heimdallChat.(*lua.LTable)
if !ok {
log.Warning("Heimdall_Chat is not a table. Skipping file.")
return nil
}
var messages []ChatMessage
chatTable.ForEach(func(_, value lua.LValue) {
chatStr := value.String()
// Remove quotes and trailing comma if present
chatStr = strings.Trim(chatStr, "\", ")
// Parse the chat message
message, err := parseChatMessage(chatStr)
if err != nil {
log.Warning("Invalid chat format: %s", chatStr)
return
}
messages = append(messages, message)
})
log.Info("Loaded %d chat messages", len(messages))
return messages
}
func parseChatMessage(chatStr string) (ChatMessage, error) {
// Split by pipe - we expect 6 parts (5 pipes)
parts := strings.Split(chatStr, "|")
if len(parts) != 6 {
return ChatMessage{}, fmt.Errorf("invalid message format: %s", chatStr)
}
timestamp := parts[0]
event := parts[1]
sender := parts[2]
msg := parts[3]
language := parts[4]
channel := parts[5]
return ChatMessage{
MessageHash: GenerateMessageHash(timestamp, event, sender, msg, language, channel),
Timestamp: timestamp,
Event: event,
Sender: sender,
Msg: msg,
Language: language,
Channel: channel,
}, nil
}