rapid development

client/modules/login.go

@@ -29,7 +29,7 @@ type LoginClient struct {
 	GivenAccount *v1_21_8.LoginToClientPacketSuccess
 }
 
-func (s *LoginClient) Default(event event.Default) (err error) {
+func (s *LoginClient) Default(event event.Unhandled) (err error) {
 	err = fmt.Errorf("unexpected event: %#v", event)
 	return
 }

event/event_bus.go

@@ -1,3 +1,4 @@
+// Package event is the event handler
 package event
 
 import (
@@ -7,17 +8,32 @@ import (
 	"strings"
 )
 
-type Default struct {
+type Loop struct {
+	HandlerFunctions map[reflect.Type][]reflect.Value
+	Handlers         []any
+}
+
+type Unhandled struct {
 	Val any
 }
 
-type OnStart struct{}
+type Anything struct {
-type OnLoopCycle struct{}
+	Val any
+}
 
-var HandlerDone = errors.New("handler done")
+type (
+	OnStart     struct{}
+	OnLoopCycle struct{}
+)
 
-func FindHandlers(insts []any) (handlers map[reflect.Type][]reflect.Value) {
+// ErrHandlerDone will stop the event loop.
-	handlers = make(map[reflect.Type][]reflect.Value)
+var ErrHandlerDone = errors.New("handler done")
+
+// ErrDontForward will stop the event from being forwarded to other handlers, including anything handlers.
+var ErrDontForward = errors.New("dont forward")
+
+func (l *Loop) FindHandlers(insts []any) {
+	l.HandlerFunctions = make(map[reflect.Type][]reflect.Value)
 	for _, inst := range insts {
 		t := reflect.TypeOf(inst)
 		v := reflect.ValueOf(inst)
@@ -32,15 +48,14 @@ func FindHandlers(insts []any) (handlers map[reflect.Type][]reflect.Value) {
 				continue
 			}
 			eventType := method.Type.In(1)
-			handlers[eventType] = append(handlers[eventType], v.Method(i))
+			l.HandlerFunctions[eventType] = append(l.HandlerFunctions[eventType], v.Method(i))
 		}
 	}
-	return
 }
 
-func FireFound(event any, handlersMap map[reflect.Type][]reflect.Value) (found bool, err error) {
+func (l *Loop) FireFound(event any) (found bool, err error) {
 	var handlers []reflect.Value
-	if handlers, found = handlersMap[reflect.TypeOf(event)]; found {
+	if handlers, found = l.HandlerFunctions[reflect.TypeOf(event)]; found {
 		for _, handler := range handlers {
 			errV := handler.Call([]reflect.Value{reflect.ValueOf(event)})[0]
 			if !errV.IsNil() {
@@ -53,13 +68,20 @@ func FireFound(event any, handlersMap map[reflect.Type][]reflect.Value) (found b
 	return
 }
 
-func Fire(event any, handlersMap map[reflect.Type][]reflect.Value) (err error) {
+func (l *Loop) Fire(event any) (err error) {
-	found, err := FireFound(event, handlersMap)
+	found, err := l.FireFound(event)
 	if err != nil {
+		if errors.Is(err, ErrDontForward) {
+			err = nil
+		}
 		return
 	}
 	if !found {
-		_, err = FireFound(Default{event}, handlersMap)
+		_, err = l.FireFound(Unhandled{event})
+		if err != nil {
+			return
 		}
+	}
+	_, err = l.FireFound(Anything{event})
 	return
 }

go.mod

@@ -2,9 +2,8 @@ module github.com/admin-else/strom
 
 go 1.24
 
-require github.com/google/uuid v1.6.0
-
 require (
-	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+	github.com/go-viper/mapstructure/v2 v2.4.0
-	github.com/google/go-cmp v0.7.0 // indirect
+	github.com/google/go-cmp v0.7.0
+	github.com/google/uuid v1.6.0
 )

go.sum

@@ -1,5 +1,3 @@
-github.com/admin-else/queser v0.0.0-20251204142744-84a884c09415 h1:79NZpiedySnmgHDh/SebJ6qIenijozOOmiVys8P1y9Q=
-github.com/admin-else/queser v0.0.0-20251204142744-84a884c09415/go.mod h1:yDPy6zf+PgSaggT3ongNpb6JSgNFt6Z8ryomGEbLNmE=
 github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
 github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=

proto/connection.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"io"
 	"net"
+	"reflect"
 
 	"github.com/admin-else/strom/data"
 	"github.com/admin-else/strom/event"
@@ -42,6 +43,8 @@ type Conn struct {
 	Actor                proto_base.Actor
 	Version              string
 	ProtocolVersion      int32
+
+	Handlers map[reflect.Type][]reflect.Value
 }
 
 func (c *Conn) SetVersion(version string) (err error) {
@@ -188,19 +191,19 @@ func (c *Conn) StartOne(inst any) (err error) {
 
 func (c *Conn) Start(insts []any) (err error) {
 	_ = *c // exit early on nil connection
-	handlers := event.FindHandlers(insts)
+	c.Handlers = event.FindHandlers(insts)
-	err = event.Fire(event.OnStart{}, handlers)
+	err = event.Fire(event.OnStart{}, c.Handlers)
 	for err == nil {
 		var packet any
 		packet, err = c.Receive()
 		if err != nil {
 			break
 		}
-		err = event.Fire(packet, handlers)
+		err = event.Fire(packet, c.Handlers)
 		if err != nil {
 			break
 		}
-		err = event.Fire(event.OnLoopCycle{}, handlers)
+		err = event.Fire(event.OnLoopCycle{}, c.Handlers)
 	}
 	if errors.Is(err, event.HandlerDone) {
 		err = nil

server/server_modules/login_server.go

@@ -75,7 +75,7 @@ func (l *LoginServer) OnLoginAcknowledged(_ *v1_21_8.LoginToServerPacketLoginAck
 	return
 }
 
-func (l *LoginServer) OnDefault(event event.Default) (err error) {
+func (l *LoginServer) OnDefault(event event.Unhandled) (err error) {
 	err = fmt.Errorf("unexpected event during login: %#v", event)
 	fmt.Println(err)
 	return

tools/uncodeable_packet_hunter_proxy/main.go

@@ -21,7 +21,7 @@ type ProxyClient struct {
 	Server *Proxy
 }
 
-func (p *ProxyClient) OnDefault(event event.Default) (err error) {
+func (p *ProxyClient) OnDefault(event event.Unhandled) (err error) {
 	packet, isPacket := event.Val.(proto_base.EncodeDecodeAble)
 	if !isPacket {
 		return
@@ -39,7 +39,7 @@ func (p *ProxyClient) OnStart(_ event.OnStart) (err error) {
 }
 
 func (p *ProxyClient) OnUnCodeAble(packet proto.UnCodablePacket) (err error) {
-	err = p.OnDefault(event.Default{Val: packet})
+	err = p.OnDefault(event.Unhandled{Val: packet})
 	if err != nil {
 		return
 	}
@@ -52,7 +52,7 @@ type Proxy struct {
 	Client *ProxyClient
 }
 
-func (p *Proxy) OnDefault(event event.Default) (err error) {
+func (p *Proxy) OnDefault(event event.Unhandled) (err error) {
 	packet, isPacket := event.Val.(proto_base.EncodeDecodeAble)
 	if !isPacket {
 		return
@@ -70,7 +70,7 @@ func (p *Proxy) OnStart(_ event.OnStart) (err error) {
 }
 
 func (p *Proxy) OnFinishConfiguration(packet *v1_21_8.ConfigurationToServerPacketFinishConfiguration) (err error) {
-	err = p.OnDefault(event.Default{Val: packet})
+	err = p.OnDefault(event.Unhandled{Val: packet})
 	if err != nil {
 		return
 	}
@@ -80,7 +80,7 @@ func (p *Proxy) OnFinishConfiguration(packet *v1_21_8.ConfigurationToServerPacke
 }
 
 func (p *Proxy) OnUnCodeAble(packet proto.UnCodablePacket) (err error) {
-	err = p.OnDefault(event.Default{Val: packet})
+	err = p.OnDefault(event.Unhandled{Val: packet})
 	if err != nil {
 		return
 	}