tech/sendico
2
0
Fork 0
Code Issues 22 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

discovery service

Browse Source
This commit is contained in:
Stephan D
2026-01-02 02:44:01 +01:00
parent 97ba7500dc
commit ea1c69f14a
47 changed files with 2799 additions and 701 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
api/pkg/discovery/service.go
View File

@@ -8,8 +8,9 @@ import (
"sync"
"time"
"github.com/nats-io/nats.go"
msg "github.com/tech/sendico/pkg/messaging"
"github.com/tech/sendico/pkg/messaging/broker"
mb "github.com/tech/sendico/pkg/messaging/broker"
cons "github.com/tech/sendico/pkg/messaging/consumer"
me "github.com/tech/sendico/pkg/messaging/envelope"
"github.com/tech/sendico/pkg/mlogger"
@@ -22,6 +23,8 @@ type RegistryService struct {
producer msg.Producer
sender string
consumers []consumerHandler
kv *KVStore
kvWatcher nats.KeyWatcher
startOnce sync.Once
stopOnce sync.Once
@@ -30,10 +33,11 @@ type RegistryService struct {
type consumerHandler struct {
consumer msg.Consumer
handler msg.MessageHandlerT
event string
}
func NewRegistryService(logger mlogger.Logger, broker broker.Broker, producer msg.Producer, registry *Registry, sender string) (*RegistryService, error) {
if broker == nil {
func NewRegistryService(logger mlogger.Logger, msgBroker mb.Broker, producer msg.Producer, registry *Registry, sender string) (*RegistryService, error) {
if msgBroker == nil {
return nil, errors.New("discovery registry: broker is nil")
}
if registry == nil {
@@ -47,19 +51,19 @@ func NewRegistryService(logger mlogger.Logger, broker broker.Broker, producer ms
sender = "discovery"
}
serviceConsumer, err := cons.NewConsumer(logger, broker, ServiceAnnounceEvent())
serviceConsumer, err := cons.NewConsumer(logger, msgBroker, ServiceAnnounceEvent())
if err != nil {
return nil, err
}
gatewayConsumer, err := cons.NewConsumer(logger, broker, GatewayAnnounceEvent())
gatewayConsumer, err := cons.NewConsumer(logger, msgBroker, GatewayAnnounceEvent())
if err != nil {
return nil, err
}
heartbeatConsumer, err := cons.NewConsumer(logger, broker, HeartbeatEvent())
heartbeatConsumer, err := cons.NewConsumer(logger, msgBroker, HeartbeatEvent())
if err != nil {
return nil, err
}
lookupConsumer, err := cons.NewConsumer(logger, broker, LookupRequestEvent())
lookupConsumer, err := cons.NewConsumer(logger, msgBroker, LookupRequestEvent())
if err != nil {
return nil, err
}
@@ -69,17 +73,18 @@ func NewRegistryService(logger mlogger.Logger, broker broker.Broker, producer ms
registry: registry,
producer: producer,
sender: sender,
consumers: []consumerHandler{
{consumer: serviceConsumer, handler: func(ctx context.Context, env me.Envelope) error {
return svc.handleAnnounce(ctx, env)
}},
{consumer: gatewayConsumer, handler: func(ctx context.Context, env me.Envelope) error {
return svc.handleAnnounce(ctx, env)
}},
{consumer: heartbeatConsumer, handler: svc.handleHeartbeat},
{consumer: lookupConsumer, handler: svc.handleLookup},
},
}
svc.consumers = []consumerHandler{
{consumer: serviceConsumer, event: ServiceAnnounceEvent().ToString(), handler: func(ctx context.Context, env me.Envelope) error {
return svc.handleAnnounce(ctx, env)
}},
{consumer: gatewayConsumer, event: GatewayAnnounceEvent().ToString(), handler: func(ctx context.Context, env me.Envelope) error {
return svc.handleAnnounce(ctx, env)
}},
{consumer: heartbeatConsumer, event: HeartbeatEvent().ToString(), handler: svc.handleHeartbeat},
{consumer: lookupConsumer, event: LookupRequestEvent().ToString(), handler: svc.handleLookup},
}
svc.initKV(msgBroker)
return svc, nil
}
@@ -88,14 +93,16 @@ func (s *RegistryService) Start() {
return
}
s.startOnce.Do(func() {
s.logInfo("Discovery registry service starting", zap.Int("consumers", len(s.consumers)), zap.Bool("kv_enabled", s.kv != nil))
for _, ch := range s.consumers {
ch := ch
go func() {
if err := ch.consumer.ConsumeMessages(ch.handler); err != nil && s.logger != nil {
s.logger.Warn("Discovery consumer stopped with error", zap.Error(err))
s.logger.Warn("Discovery consumer stopped with error", zap.String("event", ch.event), zap.Error(err))
}
}()
}
s.startKVWatch()
})
}
@@ -109,18 +116,29 @@ func (s *RegistryService) Stop() {
ch.consumer.Close()
}
}
if s.kvWatcher != nil {
_ = s.kvWatcher.Stop()
}
s.logInfo("Discovery registry service stopped")
})
}
func (s *RegistryService) handleAnnounce(_ context.Context, env me.Envelope) error {
var payload Announcement
if err := json.Unmarshal(env.GetData(), &payload); err != nil {
s.logWarn("Failed to decode discovery announce payload", zap.Error(err))
fields := append(envelopeFields(env), zap.Int("data_len", len(env.GetData())), zap.Error(err))
s.logWarn("Failed to decode discovery announce payload", fields...)
return err
}
if strings.TrimSpace(payload.InstanceID) == "" {
fields := append(envelopeFields(env), announcementFields(payload)...)
s.logWarn("Discovery announce missing instance id", fields...)
}
now := time.Now()
result := s.registry.UpsertFromAnnouncement(payload, now)
s.persistEntry(result.Entry)
if result.IsNew || result.BecameHealthy {
s.logInfo("Discovery registry entry updated", append(entryFields(result.Entry), zap.Bool("is_new", result.IsNew), zap.Bool("became_healthy", result.BecameHealthy))...)
s.publishRefresh(result.Entry)
}
return nil
@@ -129,37 +147,48 @@ func (s *RegistryService) handleAnnounce(_ context.Context, env me.Envelope) err
func (s *RegistryService) handleHeartbeat(_ context.Context, env me.Envelope) error {
var payload Heartbeat
if err := json.Unmarshal(env.GetData(), &payload); err != nil {
s.logWarn("Failed to decode discovery heartbeat payload", zap.Error(err))
fields := append(envelopeFields(env), zap.Int("data_len", len(env.GetData())), zap.Error(err))
s.logWarn("Failed to decode discovery heartbeat payload", fields...)
return err
}
if payload.ID == "" {
if strings.TrimSpace(payload.InstanceID) == "" && strings.TrimSpace(payload.ID) == "" {
return nil
}
if strings.TrimSpace(payload.InstanceID) == "" {
fields := append(envelopeFields(env), zap.String("id", payload.ID))
s.logWarn("Discovery heartbeat missing instance id", fields...)
}
ts := time.Unix(payload.TS, 0)
if ts.Unix() <= 0 {
ts = time.Now()
}
result, ok := s.registry.UpdateHeartbeat(payload.ID, strings.TrimSpace(payload.Status), ts, time.Now())
if ok && result.BecameHealthy {
s.publishRefresh(result.Entry)
results := s.registry.UpdateHeartbeat(payload.ID, payload.InstanceID, strings.TrimSpace(payload.Status), ts, time.Now())
for _, result := range results {
if result.BecameHealthy {
s.logInfo("Discovery registry entry became healthy", append(entryFields(result.Entry), zap.String("status", result.Entry.Status))...)
s.publishRefresh(result.Entry)
}
s.persistEntry(result.Entry)
}
return nil
}
func (s *RegistryService) handleLookup(_ context.Context, env me.Envelope) error {
if s.producer == nil {
s.logWarn("Discovery lookup request ignored: producer not configured")
s.logWarn("Discovery lookup request ignored: producer not configured", envelopeFields(env)...)
return nil
}
var payload LookupRequest
if err := json.Unmarshal(env.GetData(), &payload); err != nil {
s.logWarn("Failed to decode discovery lookup payload", zap.Error(err))
fields := append(envelopeFields(env), zap.Int("data_len", len(env.GetData())), zap.Error(err))
s.logWarn("Failed to decode discovery lookup payload", fields...)
return err
}
resp := s.registry.Lookup(time.Now())
resp.RequestID = strings.TrimSpace(payload.RequestID)
if err := s.producer.SendMessage(NewLookupResponseEnvelope(s.sender, resp)); err != nil {
s.logWarn("Failed to publish discovery lookup response", zap.Error(err))
fields := []zap.Field{zap.String("request_id", resp.RequestID), zap.Error(err)}
s.logWarn("Failed to publish discovery lookup response", fields...)
return err
}
return nil
@@ -170,13 +199,99 @@ func (s *RegistryService) publishRefresh(entry RegistryEntry) {
return
}
payload := RefreshEvent{
Service: entry.Service,
Rail: entry.Rail,
Network: entry.Network,
Message: "new module available",
InstanceID: entry.InstanceID,
Service: entry.Service,
Rail: entry.Rail,
Network: entry.Network,
Message: "new module available",
}
if err := s.producer.SendMessage(NewRefreshUIEnvelope(s.sender, payload)); err != nil {
s.logWarn("Failed to publish discovery refresh event", zap.Error(err))
fields := append(entryFields(entry), zap.Error(err))
s.logWarn("Failed to publish discovery refresh event", fields...)
}
}
type jetStreamProvider interface {
JetStream() nats.JetStreamContext
}
func (s *RegistryService) initKV(msgBroker mb.Broker) {
if s == nil || msgBroker == nil {
return
}
provider, ok := msgBroker.(jetStreamProvider)
if !ok {
return
}
js := provider.JetStream()
if js == nil {
return
}
store, err := NewKVStore(s.logger, js, "")
if err != nil {
s.logWarn("Failed to initialise discovery KV store", zap.Error(err))
return
}
s.kv = store
}
func (s *RegistryService) startKVWatch() {
if s == nil || s.kv == nil {
return
}
watcher, err := s.kv.WatchAll()
if err != nil {
s.logWarn("Failed to start discovery KV watch", zap.Error(err))
return
}
s.kvWatcher = watcher
if bucket := s.kv.Bucket(); bucket != "" {
s.logInfo("Discovery KV watch started", zap.String("bucket", bucket))
}
go s.consumeKVUpdates(watcher)
}
func (s *RegistryService) consumeKVUpdates(watcher nats.KeyWatcher) {
if s == nil || watcher == nil {
return
}
for entry := range watcher.Updates() {
if entry == nil {
continue
}
switch entry.Operation() {
case nats.KeyValueDelete, nats.KeyValuePurge:
key := registryKeyFromKVKey(entry.Key())
if key != "" {
if s.registry.Delete(key) {
s.logInfo("Discovery registry entry removed", zap.String("key", key))
}
}
continue
case nats.KeyValuePut:
default:
continue
}
var payload RegistryEntry
if err := json.Unmarshal(entry.Value(), &payload); err != nil {
s.logWarn("Failed to decode discovery KV entry", zap.String("key", entry.Key()), zap.Error(err))
continue
}
result := s.registry.UpsertEntry(payload, time.Now())
if result.IsNew || result.BecameHealthy {
s.logInfo("Discovery registry entry updated from KV", append(entryFields(result.Entry), zap.Bool("is_new", result.IsNew), zap.Bool("became_healthy", result.BecameHealthy))...)
s.publishRefresh(result.Entry)
}
}
}
func (s *RegistryService) persistEntry(entry RegistryEntry) {
if s == nil || s.kv == nil {
return
}
if err := s.kv.Put(entry); err != nil {
s.logWarn("Failed to persist discovery entry", append(entryFields(entry), zap.Error(err))...)
}
}
@@ -186,3 +301,10 @@ func (s *RegistryService) logWarn(message string, fields ...zap.Field) {
}
s.logger.Warn(message, fields...)
}
func (s *RegistryService) logInfo(message string, fields ...zap.Field) {
if s.logger == nil {
return
}
s.logger.Info(message, fields...)
}