events: implement package with memory & nats streams (#1942)

2020-08-18 16:19:53 +01:00
parent 19ef225b2f
commit 21cca297c0
10 changed files with 1008 additions and 13 deletions
--- a/events/nats/nats.go
+++ b/events/nats/nats.go
@@ -0,0 +1,154 @@
+package nats
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/google/uuid"
+	stan "github.com/nats-io/stan.go"
+	"github.com/pkg/errors"
+
+	"github.com/micro/go-micro/v3/events"
+	"github.com/micro/go-micro/v3/logger"
+)
+
+const (
+	defaultClusterID = "micro"
+	eventsTopic      = "events"
+)
+
+// NewStream returns an initialized nats stream or an error if the connection to the nats
+// server could not be established
+func NewStream(opts ...Option) (events.Stream, error) {
+	// parse the options
+	options := Options{
+		ClientID:  uuid.New().String(),
+		ClusterID: defaultClusterID,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// pass the address as an option if it was set
+	var cOpts []stan.Option
+	if len(options.Address) > 0 {
+		cOpts = append(cOpts, stan.NatsURL(options.Address))
+	}
+
+	// connect to the cluster
+	conn, err := stan.Connect(options.ClusterID, options.ClientID, cOpts...)
+	if err != nil {
+		return nil, errors.Wrap(err, "Error connecting to nats")
+	}
+
+	return &stream{conn}, nil
+}
+
+type stream struct {
+	conn stan.Conn
+}
+
+// Publish a message to a topic
+func (s *stream) Publish(topic string, opts ...events.PublishOption) error {
+	// validate the topic
+	if len(topic) == 0 {
+		return events.ErrMissingTopic
+	}
+
+	// parse the options
+	options := events.PublishOptions{
+		Timestamp: time.Now(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// encode the message if it's not already encoded
+	var payload []byte
+	if p, ok := options.Payload.([]byte); ok {
+		payload = p
+	} else {
+		p, err := json.Marshal(options.Payload)
+		if err != nil {
+			return events.ErrEncodingMessage
+		}
+		payload = p
+	}
+
+	// construct the event
+	event := &events.Event{
+		ID:        uuid.New().String(),
+		Topic:     topic,
+		Timestamp: options.Timestamp,
+		Metadata:  options.Metadata,
+		Payload:   payload,
+	}
+
+	// serialize the event to bytes
+	bytes, err := json.Marshal(event)
+	if err != nil {
+		return errors.Wrap(err, "Error encoding event")
+	}
+
+	// publish the event to the events channel
+	if _, err := s.conn.PublishAsync(eventsTopic, bytes, nil); err != nil {
+		return errors.Wrap(err, "Error publishing message to events")
+	}
+
+	// publish the event to the topic's channel
+	if _, err := s.conn.PublishAsync(event.Topic, bytes, nil); err != nil {
+		return errors.Wrap(err, "Error publishing message to topic")
+	}
+
+	return nil
+}
+
+// Subscribe to a topic
+func (s *stream) Subscribe(opts ...events.SubscribeOption) (<-chan events.Event, error) {
+	// parse the options
+	options := events.SubscribeOptions{
+		Topic: eventsTopic,
+		Queue: uuid.New().String(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// setup the subscriber
+	c := make(chan events.Event)
+	handleMsg := func(m *stan.Msg) {
+		// decode the message
+		var evt events.Event
+		if err := json.Unmarshal(m.Data, &evt); err != nil {
+			if logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+				logger.Errorf("Error decoding message: %v", err)
+			}
+			// not ackknowledging the message is the way to indicate an error occured
+			return
+		}
+
+		// push onto the channel and wait for the consumer to take the event off before we acknowledge it.
+		c <- evt
+
+		if err := m.Ack(); err != nil && logger.V(logger.ErrorLevel, logger.DefaultLogger) {
+			logger.Errorf("Error acknowledging message: %v", err)
+		}
+	}
+
+	// setup the options
+	subOpts := []stan.SubscriptionOption{
+		stan.DurableName(options.Topic),
+		stan.SetManualAckMode(),
+	}
+	if options.StartAtTime.Unix() > 0 {
+		stan.StartAtTime(options.StartAtTime)
+	}
+
+	// connect the subscriber
+	_, err := s.conn.QueueSubscribe(options.Topic, options.Queue, handleMsg, subOpts...)
+	if err != nil {
+		return nil, errors.Wrap(err, "Error subscribing to topic")
+	}
+
+	return c, nil
+}
--- a/events/nats/nats_test.go
+++ b/events/nats/nats_test.go
@@ -0,0 +1,200 @@
+package nats
+
+import (
+	"net"
+	"os/exec"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/micro/go-micro/v3/events"
+	"github.com/stretchr/testify/assert"
+)
+
+type testPayload struct {
+	Message string
+}
+
+func TestStream(t *testing.T) {
+	_, err := exec.LookPath("nats-streaming-server")
+	if err != nil {
+		t.Skipf("Skipping nats test, nats-streaming-server binary is not detected")
+	}
+
+	conn, err := net.DialTimeout("tcp", ":4222", time.Millisecond*100)
+	if err != nil {
+		t.Skipf("Skipping nats test, could not connect to cluster on port 4222: %v", err)
+	}
+	if err := conn.Close(); err != nil {
+		t.Fatalf("Error closing test tcp connection to nats cluster")
+	}
+
+	stream, err := NewStream(ClusterID("test-cluster"))
+	assert.Nilf(t, err, "NewStream should not return an error")
+	assert.NotNilf(t, stream, "NewStream should return a stream object")
+
+	// TestMissingTopic will test the topic validation on publish
+	t.Run("TestMissingTopic", func(t *testing.T) {
+		err := stream.Publish("")
+		assert.Equalf(t, err, events.ErrMissingTopic, "Publishing to a blank topic should return an error")
+	})
+
+	// TestFirehose will publish a message to the test topic. The subscriber will subscribe to the
+	// firehose topic (indicated by a lack of the topic option).
+	t.Run("TestFirehose", func(t *testing.T) {
+		payload := &testPayload{Message: "HelloWorld"}
+		metadata := map[string]string{"foo": "bar"}
+
+		// create the subscriber
+		evChan, err := stream.Subscribe()
+		assert.Nilf(t, err, "Subscribe should not return an error")
+
+		// setup the subscriber async
+		var wg sync.WaitGroup
+
+		go func() {
+			timeout := time.NewTimer(time.Millisecond * 250)
+
+			select {
+			case event, _ := <-evChan:
+				assert.NotNilf(t, event, "The message was nil")
+				assert.Equal(t, event.Metadata, metadata, "Metadata didn't match")
+
+				var result testPayload
+				err = event.Unmarshal(&result)
+				assert.Nil(t, err, "Error decoding result")
+				assert.Equal(t, result, *payload, "Payload didn't match")
+
+				wg.Done()
+			case <-timeout.C:
+				t.Fatalf("Event was not recieved")
+			}
+		}()
+
+		err = stream.Publish("test",
+			events.WithPayload(payload),
+			events.WithMetadata(metadata),
+		)
+		assert.Nil(t, err, "Publishing a valid message should not return an error")
+		wg.Add(1)
+
+		// wait for the subscriber to recieve the message or timeout
+		wg.Wait()
+	})
+
+	// TestSubscribeTopic will publish a message to the test topic. The subscriber will subscribe to the
+	// same test topic.
+	t.Run("TestSubscribeTopic", func(t *testing.T) {
+		payload := &testPayload{Message: "HelloWorld"}
+		metadata := map[string]string{"foo": "bar"}
+
+		// create the subscriber
+		evChan, err := stream.Subscribe(events.WithTopic("test"))
+		assert.Nilf(t, err, "Subscribe should not return an error")
+
+		// setup the subscriber async
+		var wg sync.WaitGroup
+
+		go func() {
+			timeout := time.NewTimer(time.Millisecond * 250)
+
+			select {
+			case event, _ := <-evChan:
+				assert.NotNilf(t, event, "The message was nil")
+				assert.Equal(t, event.Metadata, metadata, "Metadata didn't match")
+
+				var result testPayload
+				err = event.Unmarshal(&result)
+				assert.Nil(t, err, "Error decoding result")
+				assert.Equal(t, result, *payload, "Payload didn't match")
+
+				wg.Done()
+			case <-timeout.C:
+				t.Fatalf("Event was not recieved")
+			}
+		}()
+
+		err = stream.Publish("test",
+			events.WithPayload(payload),
+			events.WithMetadata(metadata),
+		)
+		assert.Nil(t, err, "Publishing a valid message should not return an error")
+		wg.Add(1)
+
+		// wait for the subscriber to recieve the message or timeout
+		wg.Wait()
+	})
+
+	// TestSubscribeQueue will publish a message to a random topic. Two subscribers will then consume
+	// the message from the firehose topic with different queues. The second subscriber will be registered
+	// after the message is published to test durability.
+	t.Run("TestSubscribeQueue", func(t *testing.T) {
+		topic := uuid.New().String()
+		payload := &testPayload{Message: "HelloWorld"}
+		metadata := map[string]string{"foo": "bar"}
+
+		// create the first subscriber
+		evChan1, err := stream.Subscribe(events.WithTopic(topic))
+		assert.Nilf(t, err, "Subscribe should not return an error")
+
+		// setup the subscriber async
+		var wg sync.WaitGroup
+
+		go func() {
+			timeout := time.NewTimer(time.Millisecond * 250)
+
+			select {
+			case event, _ := <-evChan1:
+				assert.NotNilf(t, event, "The message was nil")
+				assert.Equal(t, event.Metadata, metadata, "Metadata didn't match")
+
+				var result testPayload
+				err = event.Unmarshal(&result)
+				assert.Nil(t, err, "Error decoding result")
+				assert.Equal(t, result, *payload, "Payload didn't match")
+
+				wg.Done()
+			case <-timeout.C:
+				t.Fatalf("Event was not recieved")
+			}
+		}()
+
+		err = stream.Publish(topic,
+			events.WithPayload(payload),
+			events.WithMetadata(metadata),
+		)
+		assert.Nil(t, err, "Publishing a valid message should not return an error")
+		wg.Add(2)
+
+		// create the second subscriber
+		evChan2, err := stream.Subscribe(
+			events.WithTopic(topic),
+			events.WithQueue("second_queue"),
+			events.WithStartAtTime(time.Now().Add(time.Minute*-1)),
+		)
+		assert.Nilf(t, err, "Subscribe should not return an error")
+
+		go func() {
+			timeout := time.NewTimer(time.Millisecond * 250)
+
+			select {
+			case event, _ := <-evChan2:
+				assert.NotNilf(t, event, "The message was nil")
+				assert.Equal(t, event.Metadata, metadata, "Metadata didn't match")
+
+				var result testPayload
+				err = event.Unmarshal(&result)
+				assert.Nil(t, err, "Error decoding result")
+				assert.Equal(t, result, *payload, "Payload didn't match")
+
+				wg.Done()
+			case <-timeout.C:
+				t.Fatalf("Event was not recieved")
+			}
+		}()
+
+		// wait for the subscriber to recieve the message or timeout
+		wg.Wait()
+	})
+}
--- a/events/nats/options.go
+++ b/events/nats/options.go
@@ -0,0 +1,32 @@
+package nats
+
+// Options which are used to configure the nats stream
+type Options struct {
+	ClusterID string
+	ClientID  string
+	Address   string
+}
+
+// Option is a function which configures options
+type Option func(o *Options)
+
+// ClusterID sets the cluster id for the nats connection
+func ClusterID(id string) Option {
+	return func(o *Options) {
+		o.ClusterID = id
+	}
+}
+
+// ClientID sets the client id for the nats connection
+func ClientID(id string) Option {
+	return func(o *Options) {
+		o.ClientID = id
+	}
+}
+
+// Address of the nats cluster
+func Address(addr string) Option {
+	return func(o *Options) {
+		o.Address = addr
+	}
+}