140 lines
3.1 KiB
Go
140 lines
3.1 KiB
Go
package discovery
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/google/uuid"
|
|
msg "github.com/tech/sendico/pkg/messaging"
|
|
mb "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/merrors"
|
|
"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, msgBroker mb.Broker, producer msg.Producer, sender string) (*Client, error) {
|
|
if msgBroker == nil {
|
|
return nil, merrors.InvalidArgument("discovery client: broker is nil")
|
|
}
|
|
if logger == nil {
|
|
logger = zap.NewNop()
|
|
}
|
|
logger = logger.Named("discovery_client")
|
|
if producer == nil {
|
|
producer = msgproducer.NewProducer(logger, msgBroker)
|
|
}
|
|
sender = strings.TrimSpace(sender)
|
|
if sender == "" {
|
|
sender = "discovery_client"
|
|
}
|
|
|
|
consumer, err := cons.NewConsumer(logger, msgBroker, 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.Warn("Discovery lookup consumer stopped", zap.String("event", LookupResponseEvent().ToString()), 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{}, merrors.Internal("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 {
|
|
fields := append(envelopeFields(env), zap.Int("data_len", len(env.GetData())), zap.Error(err))
|
|
c.logWarn("Failed to decode discovery lookup response", fields...)
|
|
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 {
|
|
return
|
|
}
|
|
c.logger.Warn(message, fields...)
|
|
}
|