init

cmd/ws/event_handler.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"context"
+	"log"
+
+	"github.com/genudine/saerro-go/types"
+)
+
+type EventHandler struct {
+	Ingest *Ingest
+}
+
+func (eh *EventHandler) HandleEvent(ctx context.Context, event types.ESSEvent) {
+	if event.EventName == "" {
+		log.Println("invalid event; dropping")
+	}
+
+	if event.EventName == "Death" || event.EventName == "VehicleDestroy" {
+		go eh.HandleDeath(ctx, event)
+	} else if event.EventName == "GainExperience" {
+		go eh.HandleExperience(ctx, event)
+	}
+
+	go eh.HandleAnalytics(ctx, event)
+}
+
+func (eh *EventHandler) HandleDeath(ctx context.Context, event types.ESSEvent) {
+	if event.CharacterID != "" && event.CharacterID != "0" {
+		log.Println("got pop event")
+		pe := PopEventFromESSEvent(event, false)
+		eh.Ingest.TrackPop(ctx, pe)
+	}
+
+	if event.AttackerCharacterID != "" && event.AttackerCharacterID != "0" && event.AttackerTeamID != 0 {
+		log.Println("got attacker pop event")
+		pe := PopEventFromESSEvent(event, true)
+		eh.Ingest.TrackPop(ctx, pe)
+	}
+}
+
+func (eh *EventHandler) HandleExperience(ctx context.Context, event types.ESSEvent) {
+	// Detect specific vehicles via related experience IDs
+	vehicleID := ""
+	switch event.ExperienceID {
+	case 201: // Galaxy Spawn Bonus
+		vehicleID = "11"
+		break
+	case 233: // Sunderer Spawn Bonus
+		vehicleID = "2"
+		break
+	case 674: // ANT stuff
+	case 675:
+		vehicleID = "160"
+		break
+	}
+
+	event.VehicleID = vehicleID
+	pe := PopEventFromESSEvent(event, false)
+	eh.Ingest.TrackPop(ctx, pe)
+}
+
+func (eh *EventHandler) HandleAnalytics(ctx context.Context, event types.ESSEvent) {
+
+}

cmd/ws/event_handler_test.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	"github.com/genudine/saerro-go/translators"
+	"github.com/genudine/saerro-go/types"
+	"github.com/stretchr/testify/assert"
+
+	_ "modernc.org/sqlite"
+)
+
+func getEventHandlerTestShim(t *testing.T) (EventHandler, *sql.DB) {
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		t.Fatalf("test shim: sqlite open failed, %v", err)
+	}
+
+	return EventHandler{
+		Ingest: &Ingest{
+			DB: db,
+		},
+	}, db
+}
+
+func TestHandleDeath(t *testing.T) {
+	eh, db := getEventHandlerTestShim(t)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	event := types.ESSEvent{
+		EventName: "Death",
+		WorldID:   17,
+		ZoneID:    2,
+
+		CharacterID: "DollNC",
+		LoadoutID:   "3",
+		TeamID:      types.NC,
+
+		AttackerCharacterID: "Lyyti",
+		AttackerLoadoutID:   "3",
+		AttackerTeamID:      types.TR,
+	}
+
+	eh.HandleDeath(ctx, event)
+
+	type player struct {
+		CharacterID string `json:"character_id"`
+		ClassName   string `json:"class_name"`
+	}
+
+	var player1 player
+	err := db.QueryRowContext(ctx, "SELECT * FROM players WHERE character_id = ?", event.CharacterID).Scan(&player1)
+	if err != nil {
+		t.Error(err)
+	}
+
+	assert.Equal(t, event.CharacterID, player1.CharacterID)
+	assert.Equal(t, translators.ClassFromLoadout(event.LoadoutID), player1.ClassName)
+
+	var player2 player
+	err = db.QueryRowContext(ctx, "SELECT * FROM players WHERE character_id = ?", event.AttackerCharacterID).Scan(&player2)
+	if err != nil {
+		t.Error(err)
+	}
+
+	assert.Equal(t, event.AttackerCharacterID, player2.CharacterID)
+	assert.Equal(t, translators.ClassFromLoadout(event.AttackerLoadoutID), player2.ClassName)
+}

cmd/ws/event_names.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/genudine/saerro-go/util"
+)
+
+var experienceIDs = []int{
+	2, 3, 4, 5, 6, 7, 34, 51, 53, 55, 57, 86, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+	100, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 201, 233, 293,
+	294, 302, 303, 353, 354, 355, 438, 439, 503, 505, 579, 581, 584, 653, 656, 674, 675,
+}
+
+func getEventNames() []string {
+	events := util.Map(experienceIDs, func(i int) string {
+		return fmt.Sprintf("GainExperience_experience_id_%d", i)
+	})
+	events = append(events, "Death", "VehicleDestroy")
+
+	return events
+}

cmd/ws/event_names_test.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEventNames(t *testing.T) {
+	result := getEventNames()
+	assert.Contains(t, result, "GainExperience_experience_id_55")
+	assert.Contains(t, result, "Death")
+	assert.Contains(t, result, "VehicleDestroy")
+}

cmd/ws/ingest.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+)
+
+type Ingest struct {
+	DB *sql.DB
+}
+
+func (i *Ingest) TrackPop(ctx context.Context, event PopEvent) {
+
+}

cmd/ws/pop_event.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"github.com/genudine/saerro-go/translators"
+	"github.com/genudine/saerro-go/types"
+)
+
+type PopEvent struct {
+	WorldID     uint16
+	ZoneID      uint32
+	CharacterID string
+	LoadoutID   string
+	TeamID      types.Faction
+	VehicleID   string
+
+	VehicleName translators.Vehicle
+	ClassName   translators.Class
+}
+
+func PopEventFromESSEvent(event types.ESSEvent, attacker bool) PopEvent {
+	pe := PopEvent{
+		WorldID: event.WorldID,
+		ZoneID:  event.ZoneID,
+	}
+
+	if !attacker {
+		pe.CharacterID = event.CharacterID
+		pe.LoadoutID = event.LoadoutID
+		pe.TeamID = event.TeamID
+		pe.VehicleID = event.VehicleID
+	} else {
+		pe.CharacterID = event.AttackerCharacterID
+		pe.LoadoutID = event.AttackerLoadoutID
+		pe.TeamID = event.AttackerTeamID
+		pe.VehicleID = event.AttackerVehicleID
+	}
+
+	pe.ClassName = translators.ClassFromLoadout(pe.LoadoutID)
+	pe.VehicleName = translators.VehicleNameFromID(pe.VehicleID)
+
+	return pe
+}

cmd/ws/ws.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"context"
+	"database/sql"
+	"log"
+	"os"
+	"time"
+
+	"github.com/genudine/saerro-go/types"
+	"nhooyr.io/websocket"
+	"nhooyr.io/websocket/wsjson"
+)
+
+func main() {
+	wsAddr := os.Getenv("WS_ADDR")
+	if wsAddr == "" {
+		log.Fatalln("WS_ADDR is not set.")
+	}
+
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		log.Fatalln("database connection failed", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+
+	wsConn, _, err := websocket.Dial(ctx, wsAddr, nil)
+	if err != nil {
+		log.Fatalln("Connection to ESS failed.", err)
+	}
+	defer wsConn.Close(websocket.StatusInternalError, "internal error. bye")
+
+	err = wsjson.Write(ctx, wsConn, map[string]interface{}{
+		"action":     "subscribe",
+		"worlds":     "all",
+		"eventNames": getEventNames(),
+		"characters": []string{"all"},
+		"service":    "event",
+
+		"logicalAndCharactersWithWorlds": true,
+	})
+	if err != nil {
+		log.Fatalln("subscription write failed", err)
+	}
+
+	log.Println("subscribe done")
+
+	eventHandler := EventHandler{
+		Ingest: &Ingest{
+			DB: db,
+		},
+	}
+
+	for {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+
+		var event types.ESSData
+		err := wsjson.Read(ctx, wsConn, &event)
+		if err != nil {
+			log.Println("wsjson read failed", err)
+			cancel()
+			continue
+		}
+
+		go eventHandler.HandleEvent(ctx, event.Payload)
+	}
+
+	wsConn.Close(websocket.StatusNormalClosure, "")
+}