unified gateway interface

api/pkg/discovery/client.go

@@ -0,0 +1,137 @@
+package discovery
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"strings"
+	"sync"
+
+	"github.com/google/uuid"
+	msg "github.com/tech/sendico/pkg/messaging"
+	"github.com/tech/sendico/pkg/messaging/broker"
+	cons "github.com/tech/sendico/pkg/messaging/consumer"
+	me "github.com/tech/sendico/pkg/messaging/envelope"
+	msgproducer "github.com/tech/sendico/pkg/messaging/producer"
+	"github.com/tech/sendico/pkg/mlogger"
+	"go.uber.org/zap"
+)
+
+type Client struct {
+	logger   mlogger.Logger
+	producer msg.Producer
+	consumer msg.Consumer
+	sender   string
+
+	mu      sync.Mutex
+	pending map[string]chan LookupResponse
+}
+
+func NewClient(logger mlogger.Logger, broker broker.Broker, producer msg.Producer, sender string) (*Client, error) {
+	if broker == nil {
+		return nil, errors.New("discovery client: broker is nil")
+	}
+	if logger != nil {
+		logger = logger.Named("discovery_client")
+	}
+	if producer == nil {
+		producer = msgproducer.NewProducer(logger, broker)
+	}
+	sender = strings.TrimSpace(sender)
+	if sender == "" {
+		sender = "discovery_client"
+	}
+
+	consumer, err := cons.NewConsumer(logger, broker, LookupResponseEvent())
+	if err != nil {
+		return nil, err
+	}
+
+	client := &Client{
+		logger:   logger,
+		producer: producer,
+		consumer: consumer,
+		sender:   sender,
+		pending:  map[string]chan LookupResponse{},
+	}
+
+	go func() {
+		if err := consumer.ConsumeMessages(client.handleLookupResponse); err != nil && client.logger != nil {
+			client.logger.Warn("Discovery lookup consumer stopped", zap.Error(err))
+		}
+	}()
+
+	return client, nil
+}
+
+func (c *Client) Close() {
+	if c == nil {
+		return
+	}
+	if c.consumer != nil {
+		c.consumer.Close()
+	}
+	c.mu.Lock()
+	for key, ch := range c.pending {
+		close(ch)
+		delete(c.pending, key)
+	}
+	c.mu.Unlock()
+}
+
+func (c *Client) Lookup(ctx context.Context) (LookupResponse, error) {
+	if c == nil || c.producer == nil {
+		return LookupResponse{}, errors.New("discovery client: producer not configured")
+	}
+	requestID := uuid.NewString()
+	ch := make(chan LookupResponse, 1)
+
+	c.mu.Lock()
+	c.pending[requestID] = ch
+	c.mu.Unlock()
+
+	defer func() {
+		c.mu.Lock()
+		delete(c.pending, requestID)
+		c.mu.Unlock()
+	}()
+
+	req := LookupRequest{RequestID: requestID}
+	if err := c.producer.SendMessage(NewLookupRequestEnvelope(c.sender, req)); err != nil {
+		return LookupResponse{}, err
+	}
+
+	select {
+	case <-ctx.Done():
+		return LookupResponse{}, ctx.Err()
+	case resp := <-ch:
+		return resp, nil
+	}
+}
+
+func (c *Client) handleLookupResponse(_ context.Context, env me.Envelope) error {
+	var payload LookupResponse
+	if err := json.Unmarshal(env.GetData(), &payload); err != nil {
+		c.logWarn("Failed to decode discovery lookup response", zap.Error(err))
+		return err
+	}
+	requestID := strings.TrimSpace(payload.RequestID)
+	if requestID == "" {
+		return nil
+	}
+
+	c.mu.Lock()
+	ch := c.pending[requestID]
+	c.mu.Unlock()
+	if ch != nil {
+		ch <- payload
+	}
+	return nil
+}
+
+func (c *Client) logWarn(message string, fields ...zap.Field) {
+	if c == nil || c.logger == nil {
+		return
+	}
+	c.logger.Warn(message, fields...)
+}