266 lines
7.7 KiB
Go
266 lines
7.7 KiB
Go
package msg
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"gitea.dwysokinski.me/twhelp/core/internal/msg/internal/model"
|
|
"github.com/ThreeDotsLabs/watermill"
|
|
|
|
"gitea.dwysokinski.me/twhelp/core/internal/domain"
|
|
"github.com/ThreeDotsLabs/watermill/message"
|
|
)
|
|
|
|
//counterfeiter:generate -o internal/mock/server_service.gen.go . ServerService
|
|
type ServerService interface {
|
|
Refresh(ctx context.Context, url, versionCode string) ([]domain.Server, error)
|
|
UpdateInfoAndConfig(ctx context.Context, key, url string) error
|
|
UpdateNumPlayers(ctx context.Context, key string, numPlayers int64) error
|
|
UpdateNumTribes(ctx context.Context, key string, numTribes int64) error
|
|
UpdateNumVillages(ctx context.Context, key string, res domain.RefreshVillagesResult) error
|
|
UpdateEnnoblementDataUpdatedAt(ctx context.Context, key string) error
|
|
UpdatePlayerSnapshotsCreatedAt(ctx context.Context, key string) error
|
|
UpdateTribeSnapshotsCreatedAt(ctx context.Context, key string) error
|
|
}
|
|
|
|
type ServerConsumer struct {
|
|
marshaler CommandEventMarshaler
|
|
publisher message.Publisher
|
|
subscriber message.Subscriber
|
|
logger watermill.LoggerAdapter
|
|
svc ServerService
|
|
}
|
|
|
|
func NewServerConsumer(
|
|
marshaler CommandEventMarshaler,
|
|
publisher message.Publisher,
|
|
subscriber message.Subscriber,
|
|
logger watermill.LoggerAdapter,
|
|
svc ServerService,
|
|
) *ServerConsumer {
|
|
return &ServerConsumer{
|
|
marshaler: marshaler,
|
|
publisher: publisher,
|
|
subscriber: subscriber,
|
|
logger: logger,
|
|
svc: svc,
|
|
}
|
|
}
|
|
|
|
func (s *ServerConsumer) Register(router *message.Router) {
|
|
router.AddHandler(
|
|
"ServerConsumer.refresh",
|
|
serversCmdRefresh,
|
|
s.subscriber,
|
|
serversEventRefreshed,
|
|
s.publisher,
|
|
s.refresh,
|
|
)
|
|
|
|
router.AddNoPublisherHandler(
|
|
"ServerConsumer.updateInfoAndConfig",
|
|
serversEventRefreshed,
|
|
s.subscriber,
|
|
s.updateInfoAndConfig,
|
|
)
|
|
|
|
router.AddNoPublisherHandler(
|
|
"ServerConsumer.updateNumTribes",
|
|
tribesEventRefreshed,
|
|
s.subscriber,
|
|
s.updateNumTribes,
|
|
)
|
|
|
|
router.AddNoPublisherHandler(
|
|
"ServerConsumer.updateNumPlayers",
|
|
playersEventRefreshed,
|
|
s.subscriber,
|
|
s.updateNumPlayers,
|
|
)
|
|
|
|
router.AddNoPublisherHandler(
|
|
"ServerConsumer.updateNumVillages",
|
|
villagesEventRefreshed,
|
|
s.subscriber,
|
|
s.updateNumVillages,
|
|
)
|
|
|
|
router.AddNoPublisherHandler(
|
|
"ServerConsumer.updateEnnoblementDataUpdatedAt",
|
|
ennoblementsEventRefreshed,
|
|
s.subscriber,
|
|
s.updateEnnoblementDataUpdatedAt,
|
|
)
|
|
|
|
router.AddNoPublisherHandler(
|
|
"ServerConsumer.updatePlayerSnapshotsCreatedAt",
|
|
playersEventSnapshotsCreated,
|
|
s.subscriber,
|
|
s.updatePlayerSnapshotsCreatedAt,
|
|
)
|
|
|
|
router.AddNoPublisherHandler(
|
|
"ServerConsumer.updateTribeSnapshotsCreatedAt",
|
|
tribesEventSnapshotsCreated,
|
|
s.subscriber,
|
|
s.updateTribeSnapshotsCreatedAt,
|
|
)
|
|
}
|
|
|
|
func (s *ServerConsumer) refresh(msg *message.Message) ([]*message.Message, error) {
|
|
var payload model.RefreshServersCmdPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil, nil
|
|
}
|
|
|
|
servers, err := s.svc.Refresh(msg.Context(), payload.URL, payload.VersionCode)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("ServerService.Refresh: %w", err)
|
|
}
|
|
|
|
events := make([]*message.Message, 0, len(servers))
|
|
for _, srv := range servers {
|
|
ev, err := s.marshaler.Marshal(model.ServerRefreshedEvPayload{
|
|
Key: srv.Key,
|
|
URL: srv.URL,
|
|
Open: srv.Open,
|
|
VersionCode: srv.VersionCode,
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshaler.Marshal: %w", err)
|
|
}
|
|
events = append(events, ev)
|
|
}
|
|
|
|
return events, nil
|
|
}
|
|
|
|
func (s *ServerConsumer) updateInfoAndConfig(msg *message.Message) error {
|
|
var payload model.ServerRefreshedEvPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if !payload.Open {
|
|
s.logger.Debug("server is closed, dropping message", watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
"server_key": payload.Key,
|
|
"version_code": payload.VersionCode,
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if err := s.svc.UpdateInfoAndConfig(msg.Context(), payload.Key, payload.URL); err != nil {
|
|
return fmt.Errorf("ServerService.UpdateInfoAndConfig: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerConsumer) updateNumPlayers(msg *message.Message) error {
|
|
var payload model.PlayersRefreshedEvPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if err := s.svc.UpdateNumPlayers(msg.Context(), payload.Key, payload.NumPlayers); err != nil {
|
|
return fmt.Errorf("ServerService.UpdateNumPlayers: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerConsumer) updateNumTribes(msg *message.Message) error {
|
|
var payload model.TribesRefreshedEvPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if err := s.svc.UpdateNumTribes(msg.Context(), payload.Key, payload.NumTribes); err != nil {
|
|
return fmt.Errorf("ServerService.UpdateNumTribes: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerConsumer) updateNumVillages(msg *message.Message) error {
|
|
var payload model.VillagesRefreshedEvPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if err := s.svc.UpdateNumVillages(msg.Context(), payload.Key, domain.RefreshVillagesResult{
|
|
NumVillages: payload.NumVillages,
|
|
NumPlayerVillages: payload.NumPlayerVillages,
|
|
NumBarbarianVillages: payload.NumBarbarianVillages,
|
|
NumBonusVillages: payload.NumBonusVillages,
|
|
}); err != nil {
|
|
return fmt.Errorf("ServerService.UpdateNumVillages: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerConsumer) updateEnnoblementDataUpdatedAt(msg *message.Message) error {
|
|
var payload model.EnnoblementsRefreshedEvPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if err := s.svc.UpdateEnnoblementDataUpdatedAt(msg.Context(), payload.Key); err != nil {
|
|
return fmt.Errorf("ServerService.UpdateEnnoblementDataUpdatedAt: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerConsumer) updatePlayerSnapshotsCreatedAt(msg *message.Message) error {
|
|
var payload model.SnapshotsCreatedEvPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if err := s.svc.UpdatePlayerSnapshotsCreatedAt(msg.Context(), payload.Key); err != nil {
|
|
return fmt.Errorf("ServerService.UpdatePlayerSnapshotsCreatedAt: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *ServerConsumer) updateTribeSnapshotsCreatedAt(msg *message.Message) error {
|
|
var payload model.SnapshotsCreatedEvPayload
|
|
if err := s.marshaler.Unmarshal(msg, &payload); err != nil {
|
|
s.logger.Error("invalid payload, dropping message", err, watermill.LogFields{
|
|
"handler_name": message.HandlerNameFromCtx(msg.Context()),
|
|
})
|
|
return nil
|
|
}
|
|
|
|
if err := s.svc.UpdateTribeSnapshotsCreatedAt(msg.Context(), payload.Key); err != nil {
|
|
return fmt.Errorf("ServerService.UpdateTribeSnapshotsCreatedAt: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|