Init

lib/pubsub/adapters/localpubsub.go

@@ -0,0 +1,90 @@
+package adapters
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"atri.dad/lib"
+	"atri.dad/lib/pubsub"
+)
+
+type LocalPubSub struct {
+	subscribers map[string][]chan pubsub.Message
+	lock        sync.RWMutex
+}
+
+type LocalPubSubMessage struct {
+	messages <-chan pubsub.Message
+}
+
+func (ps *LocalPubSub) SubscribeToChannel(channel string) (pubsub.PubSubMessage, error) {
+	ps.lock.Lock()
+	defer ps.lock.Unlock()
+
+	if ps.subscribers == nil {
+		ps.subscribers = make(map[string][]chan pubsub.Message)
+	}
+
+	ch := make(chan pubsub.Message, 100)
+	ps.subscribers[channel] = append(ps.subscribers[channel], ch)
+
+	lib.LogInfo.Printf("[PUBSUB/LOCAL] Subscribed to channel %s\n", channel)
+
+	return &LocalPubSubMessage{messages: ch}, nil
+}
+
+func (ps *LocalPubSub) PublishToChannel(channel string, message string) error {
+	subscribers, ok := ps.subscribers[channel]
+	if !ok {
+		lib.LogWarning.Printf("\n[PUBSUB/LOCAL] No subscribers for channel %s\n", channel)
+		return nil
+	}
+
+	ps.lock.Lock()
+	defer ps.lock.Unlock()
+
+	lib.LogInfo.Printf("\n[PUBSUB/LOCAL] Publishing message to channel %s: %s\n", channel, message)
+	for _, ch := range subscribers {
+		ch <- pubsub.Message{Payload: message}
+	}
+
+	return nil
+}
+
+func (ps *LocalPubSub) UnsubscribeFromChannel(channel string, ch <-chan pubsub.Message) {
+	ps.lock.Lock()
+	defer ps.lock.Unlock()
+
+	subscribers := ps.subscribers[channel]
+	for i, subscriber := range subscribers {
+		if subscriber == ch {
+			// Remove the subscriber from the slice
+			subscribers = append(subscribers[:i], subscribers[i+1:]...)
+			break
+		}
+	}
+
+	if len(subscribers) == 0 {
+		delete(ps.subscribers, channel)
+	} else {
+		ps.subscribers[channel] = subscribers
+	}
+}
+
+func (m *LocalPubSubMessage) ReceiveMessage(ctx context.Context) (*pubsub.Message, error) {
+	for {
+		select {
+		case <-ctx.Done():
+			// The client has disconnected. Stop trying to send messages.
+			return nil, ctx.Err()
+		case msg := <-m.messages:
+			// A message has been received. Send it to the client.
+			lib.LogInfo.Printf("\n[PUBSUB/LOCAL] Received message: %s\n", msg.Payload)
+			return &msg, nil
+		case <-time.After(30 * time.Second):
+			// No message has been received for 30 seconds. Send a keep-alive message.
+			return &pubsub.Message{Payload: "keep-alive"}, nil
+		}
+	}
+}

lib/pubsub/adapters/redispubsub.go

@@ -0,0 +1,70 @@
+package adapters
+
+import (
+	"context"
+	"os"
+
+	"atri.dad/lib"
+	"atri.dad/lib/pubsub"
+	"github.com/joho/godotenv"
+	"github.com/redis/go-redis/v9"
+)
+
+var RedisClient *redis.Client
+
+type RedisPubSubMessage struct {
+	pubsub *redis.PubSub
+}
+
+// RedisPubSub is a Redis implementation of the PubSub interface.
+type RedisPubSub struct {
+	Client *redis.Client
+}
+
+func NewRedisClient() *redis.Client {
+	if RedisClient != nil {
+		return RedisClient
+	}
+
+	godotenv.Load(".env")
+	redis_host := os.Getenv("REDIS_HOST")
+	redis_password := os.Getenv("REDIS_PASSWORD")
+
+	lib.LogInfo.Printf("\n[PUBSUB/REDIS]Connecting to Redis at %s\n", redis_host)
+	RedisClient = redis.NewClient(&redis.Options{
+		Addr:     redis_host,
+		Password: redis_password,
+		DB:       0,
+	})
+
+	return RedisClient
+}
+
+func (m *RedisPubSubMessage) ReceiveMessage(ctx context.Context) (*pubsub.Message, error) {
+	msg, err := m.pubsub.ReceiveMessage(ctx)
+	if err != nil {
+		return nil, err
+	}
+	lib.LogInfo.Printf("\n[PUBSUB/REDIS] Received message: %s\n", msg.Payload)
+	return &pubsub.Message{Payload: msg.Payload}, nil
+}
+
+func (ps *RedisPubSub) SubscribeToChannel(channel string) (pubsub.PubSubMessage, error) {
+	pubsub := ps.Client.Subscribe(context.Background(), channel)
+	_, err := pubsub.Receive(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	lib.LogInfo.Printf("\n[PUBSUB/REDIS] Subscribed to channel %s\n", channel)
+
+	return &RedisPubSubMessage{pubsub: pubsub}, nil
+}
+
+func (r *RedisPubSub) PublishToChannel(channel string, message string) error {
+	err := r.Client.Publish(context.Background(), channel, message).Err()
+	if err != nil {
+		return err
+	}
+	lib.LogInfo.Printf("\n[PUBSUB/REDIS] Publishing message to channel %s: %s\n", channel, message)
+	return nil
+}