Ilia Denisov
312 lines
11 KiB
Go
312 lines
11 KiB
Go
// Package domainevents implements Redis Stream-backed auxiliary user-domain
|
|
// event publishers.
|
|
package domainevents
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"errors"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"galaxy/user/internal/ports"
|
|
|
|
"github.com/redis/go-redis/v9"
|
|
"go.opentelemetry.io/otel/trace"
|
|
)
|
|
|
|
// Config configures one Redis-backed user domain-event publisher.
|
|
type Config struct {
|
|
// Addr is the Redis network address in host:port form.
|
|
Addr string
|
|
|
|
// Username is the optional Redis ACL username.
|
|
Username string
|
|
|
|
// Password is the optional Redis ACL password.
|
|
Password string
|
|
|
|
// DB is the Redis logical database index.
|
|
DB int
|
|
|
|
// TLSEnabled enables TLS with a conservative minimum protocol version.
|
|
TLSEnabled bool
|
|
|
|
// Stream identifies the Redis Stream key used for domain events.
|
|
Stream string
|
|
|
|
// StreamMaxLen bounds the stream with approximate trimming via
|
|
// `XADD MAXLEN ~`.
|
|
StreamMaxLen int64
|
|
|
|
// OperationTimeout bounds each Redis round trip performed by the adapter.
|
|
OperationTimeout time.Duration
|
|
}
|
|
|
|
// Publisher publishes auxiliary user-domain events into one Redis Stream.
|
|
type Publisher struct {
|
|
client *redis.Client
|
|
stream string
|
|
streamMaxLen int64
|
|
operationTimeout time.Duration
|
|
}
|
|
|
|
// New constructs a Redis-backed domain-event publisher from cfg.
|
|
func New(cfg Config) (*Publisher, error) {
|
|
switch {
|
|
case strings.TrimSpace(cfg.Addr) == "":
|
|
return nil, errors.New("new redis domain-event publisher: redis addr must not be empty")
|
|
case cfg.DB < 0:
|
|
return nil, errors.New("new redis domain-event publisher: redis db must not be negative")
|
|
case strings.TrimSpace(cfg.Stream) == "":
|
|
return nil, errors.New("new redis domain-event publisher: stream must not be empty")
|
|
case cfg.StreamMaxLen <= 0:
|
|
return nil, errors.New("new redis domain-event publisher: stream max len must be positive")
|
|
case cfg.OperationTimeout <= 0:
|
|
return nil, errors.New("new redis domain-event publisher: operation timeout must be positive")
|
|
}
|
|
|
|
options := &redis.Options{
|
|
Addr: cfg.Addr,
|
|
Username: cfg.Username,
|
|
Password: cfg.Password,
|
|
DB: cfg.DB,
|
|
Protocol: 2,
|
|
DisableIdentity: true,
|
|
}
|
|
if cfg.TLSEnabled {
|
|
options.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
|
|
}
|
|
|
|
return &Publisher{
|
|
client: redis.NewClient(options),
|
|
stream: cfg.Stream,
|
|
streamMaxLen: cfg.StreamMaxLen,
|
|
operationTimeout: cfg.OperationTimeout,
|
|
}, nil
|
|
}
|
|
|
|
// Close releases the underlying Redis client resources.
|
|
func (publisher *Publisher) Close() error {
|
|
if publisher == nil || publisher.client == nil {
|
|
return nil
|
|
}
|
|
|
|
return publisher.client.Close()
|
|
}
|
|
|
|
// Ping verifies that the configured Redis backend is reachable within the
|
|
// adapter operation timeout budget.
|
|
func (publisher *Publisher) Ping(ctx context.Context) error {
|
|
operationCtx, cancel, err := publisher.operationContext(ctx, "ping redis domain-event publisher")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer cancel()
|
|
|
|
if err := publisher.client.Ping(operationCtx).Err(); err != nil {
|
|
return fmt.Errorf("ping redis domain-event publisher: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// PublishProfileChanged publishes one committed profile-change event.
|
|
func (publisher *Publisher) PublishProfileChanged(ctx context.Context, event ports.ProfileChangedEvent) error {
|
|
if err := event.Validate(); err != nil {
|
|
return fmt.Errorf("publish profile changed event: %w", err)
|
|
}
|
|
|
|
values := buildEnvelope(ports.ProfileChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
|
|
values["operation"] = string(event.Operation)
|
|
values["race_name"] = event.RaceName.String()
|
|
|
|
return publisher.publish(ctx, "publish profile changed event", values)
|
|
}
|
|
|
|
// PublishSettingsChanged publishes one committed settings-change event.
|
|
func (publisher *Publisher) PublishSettingsChanged(ctx context.Context, event ports.SettingsChangedEvent) error {
|
|
if err := event.Validate(); err != nil {
|
|
return fmt.Errorf("publish settings changed event: %w", err)
|
|
}
|
|
|
|
values := buildEnvelope(ports.SettingsChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
|
|
values["operation"] = string(event.Operation)
|
|
values["preferred_language"] = event.PreferredLanguage.String()
|
|
values["time_zone"] = event.TimeZone.String()
|
|
|
|
return publisher.publish(ctx, "publish settings changed event", values)
|
|
}
|
|
|
|
// PublishEntitlementChanged publishes one committed entitlement-change event.
|
|
func (publisher *Publisher) PublishEntitlementChanged(ctx context.Context, event ports.EntitlementChangedEvent) error {
|
|
if err := event.Validate(); err != nil {
|
|
return fmt.Errorf("publish entitlement changed event: %w", err)
|
|
}
|
|
|
|
values := buildEnvelope(ports.EntitlementChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
|
|
values["operation"] = string(event.Operation)
|
|
values["plan_code"] = string(event.PlanCode)
|
|
values["is_paid"] = strconv.FormatBool(event.IsPaid)
|
|
values["starts_at_ms"] = strconv.FormatInt(event.StartsAt.UTC().UnixMilli(), 10)
|
|
values["reason_code"] = event.ReasonCode.String()
|
|
values["actor_type"] = event.Actor.Type.String()
|
|
values["updated_at_ms"] = strconv.FormatInt(event.UpdatedAt.UTC().UnixMilli(), 10)
|
|
if !event.Actor.ID.IsZero() {
|
|
values["actor_id"] = event.Actor.ID.String()
|
|
}
|
|
if event.EndsAt != nil {
|
|
values["ends_at_ms"] = strconv.FormatInt(event.EndsAt.UTC().UnixMilli(), 10)
|
|
}
|
|
|
|
return publisher.publish(ctx, "publish entitlement changed event", values)
|
|
}
|
|
|
|
// PublishSanctionChanged publishes one committed sanction-change event.
|
|
func (publisher *Publisher) PublishSanctionChanged(ctx context.Context, event ports.SanctionChangedEvent) error {
|
|
if err := event.Validate(); err != nil {
|
|
return fmt.Errorf("publish sanction changed event: %w", err)
|
|
}
|
|
|
|
values := buildEnvelope(ports.SanctionChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
|
|
values["operation"] = string(event.Operation)
|
|
values["sanction_code"] = string(event.SanctionCode)
|
|
values["scope"] = event.Scope.String()
|
|
values["reason_code"] = event.ReasonCode.String()
|
|
values["actor_type"] = event.Actor.Type.String()
|
|
values["applied_at_ms"] = strconv.FormatInt(event.AppliedAt.UTC().UnixMilli(), 10)
|
|
if !event.Actor.ID.IsZero() {
|
|
values["actor_id"] = event.Actor.ID.String()
|
|
}
|
|
if event.ExpiresAt != nil {
|
|
values["expires_at_ms"] = strconv.FormatInt(event.ExpiresAt.UTC().UnixMilli(), 10)
|
|
}
|
|
if event.RemovedAt != nil {
|
|
values["removed_at_ms"] = strconv.FormatInt(event.RemovedAt.UTC().UnixMilli(), 10)
|
|
}
|
|
|
|
return publisher.publish(ctx, "publish sanction changed event", values)
|
|
}
|
|
|
|
// PublishLimitChanged publishes one committed limit-change event.
|
|
func (publisher *Publisher) PublishLimitChanged(ctx context.Context, event ports.LimitChangedEvent) error {
|
|
if err := event.Validate(); err != nil {
|
|
return fmt.Errorf("publish limit changed event: %w", err)
|
|
}
|
|
|
|
values := buildEnvelope(ports.LimitChangedEventType, event.UserID.String(), event.OccurredAt, event.Source.String(), traceIDFromContext(ctx, event.TraceID))
|
|
values["operation"] = string(event.Operation)
|
|
values["limit_code"] = string(event.LimitCode)
|
|
values["reason_code"] = event.ReasonCode.String()
|
|
values["actor_type"] = event.Actor.Type.String()
|
|
values["applied_at_ms"] = strconv.FormatInt(event.AppliedAt.UTC().UnixMilli(), 10)
|
|
if event.Value != nil {
|
|
values["value"] = strconv.Itoa(*event.Value)
|
|
}
|
|
if !event.Actor.ID.IsZero() {
|
|
values["actor_id"] = event.Actor.ID.String()
|
|
}
|
|
if event.ExpiresAt != nil {
|
|
values["expires_at_ms"] = strconv.FormatInt(event.ExpiresAt.UTC().UnixMilli(), 10)
|
|
}
|
|
if event.RemovedAt != nil {
|
|
values["removed_at_ms"] = strconv.FormatInt(event.RemovedAt.UTC().UnixMilli(), 10)
|
|
}
|
|
|
|
return publisher.publish(ctx, "publish limit changed event", values)
|
|
}
|
|
|
|
// PublishDeclaredCountryChanged publishes one committed declared-country change
|
|
// event.
|
|
func (publisher *Publisher) PublishDeclaredCountryChanged(ctx context.Context, event ports.DeclaredCountryChangedEvent) error {
|
|
if err := event.Validate(); err != nil {
|
|
return fmt.Errorf("publish declared-country changed event: %w", err)
|
|
}
|
|
|
|
values := buildEnvelope(
|
|
ports.DeclaredCountryChangedEventType,
|
|
event.UserID.String(),
|
|
event.UpdatedAt,
|
|
event.Source.String(),
|
|
traceIDFromContext(ctx, event.TraceID),
|
|
)
|
|
values["declared_country"] = event.DeclaredCountry.String()
|
|
values["updated_at_ms"] = strconv.FormatInt(event.UpdatedAt.UTC().UnixMilli(), 10)
|
|
|
|
return publisher.publish(ctx, "publish declared-country changed event", values)
|
|
}
|
|
|
|
func (publisher *Publisher) publish(ctx context.Context, operation string, values map[string]any) error {
|
|
operationCtx, cancel, err := publisher.operationContext(ctx, operation)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer cancel()
|
|
|
|
if err := publisher.client.XAdd(operationCtx, &redis.XAddArgs{
|
|
Stream: publisher.stream,
|
|
MaxLen: publisher.streamMaxLen,
|
|
Approx: true,
|
|
Values: values,
|
|
}).Err(); err != nil {
|
|
return fmt.Errorf("%s: %w", operation, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (publisher *Publisher) operationContext(ctx context.Context, operation string) (context.Context, context.CancelFunc, error) {
|
|
if publisher == nil || publisher.client == nil {
|
|
return nil, nil, fmt.Errorf("%s: nil publisher", operation)
|
|
}
|
|
if ctx == nil {
|
|
return nil, nil, fmt.Errorf("%s: nil context", operation)
|
|
}
|
|
|
|
operationCtx, cancel := context.WithTimeout(ctx, publisher.operationTimeout)
|
|
return operationCtx, cancel, nil
|
|
}
|
|
|
|
func buildEnvelope(eventType string, userID string, occurredAt time.Time, source string, traceID string) map[string]any {
|
|
values := map[string]any{
|
|
"event_type": eventType,
|
|
"user_id": userID,
|
|
"occurred_at_ms": strconv.FormatInt(occurredAt.UTC().UnixMilli(), 10),
|
|
"source": source,
|
|
}
|
|
if traceID != "" {
|
|
values["trace_id"] = traceID
|
|
}
|
|
|
|
return values
|
|
}
|
|
|
|
func traceIDFromContext(ctx context.Context, fallback string) string {
|
|
if strings.TrimSpace(fallback) != "" {
|
|
return fallback
|
|
}
|
|
if ctx == nil {
|
|
return ""
|
|
}
|
|
|
|
spanContext := trace.SpanContextFromContext(ctx)
|
|
if !spanContext.IsValid() {
|
|
return ""
|
|
}
|
|
|
|
return spanContext.TraceID().String()
|
|
}
|
|
|
|
var (
|
|
_ interface{ Close() error } = (*Publisher)(nil)
|
|
_ interface{ Ping(context.Context) error } = (*Publisher)(nil)
|
|
_ ports.ProfileChangedPublisher = (*Publisher)(nil)
|
|
_ ports.SettingsChangedPublisher = (*Publisher)(nil)
|
|
_ ports.EntitlementChangedPublisher = (*Publisher)(nil)
|
|
_ ports.SanctionChangedPublisher = (*Publisher)(nil)
|
|
_ ports.LimitChangedPublisher = (*Publisher)(nil)
|
|
_ ports.DeclaredCountryChangedPublisher = (*Publisher)(nil)
|
|
)
|