From 35e09994b545429a569f138a5dc6f160250ee456 Mon Sep 17 00:00:00 2001
From: koladev <onaelmangabo@gmail.com>
Date: Sat, 6 Jul 2024 10:32:56 +0100
Subject: [PATCH] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20refactoring=20for=20adapte?=
 =?UTF-8?q?r?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .DS_Store                                     | Bin 0 -> 10244 bytes
 sendhooks/adapter/adapter.go                  |  41 ++++++
 .../adapter_manager/adapter_manager.go        |  65 ++++++++++
 .../adapter/redis_adapter/redis_adapter.go    | 105 +++++++++++++++
 sendhooks/main.go                             | 120 +++---------------
 sendhooks/queue/worker.go                     |  35 +++--
 sendhooks/sender/utils.go                     |   4 +-
 sendhooks/sender/webhook.go                   |   4 +-
 sendhooks/sender/webhook_test.go              |  14 +-
 9 files changed, 267 insertions(+), 121 deletions(-)
 create mode 100644 .DS_Store
 create mode 100644 sendhooks/adapter/adapter.go
 create mode 100644 sendhooks/adapter/adapter_manager/adapter_manager.go
 create mode 100644 sendhooks/adapter/redis_adapter/redis_adapter.go

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..ab5ceffd90de20a4aad060dcb2704eaf362924b6
GIT binary patch
literal 10244
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
Sxch&1|9^*$)&4L0|9=5|%x}s7

literal 0
HcmV?d00001

diff --git a/sendhooks/adapter/adapter.go b/sendhooks/adapter/adapter.go
new file mode 100644
index 0000000..e101c23
--- /dev/null
+++ b/sendhooks/adapter/adapter.go
@@ -0,0 +1,41 @@
+package adapter
+
+import (
+	"context"
+)
+
+// WebhookPayload represents the structure of the data from Redis.
+type WebhookPayload struct {
+	URL        string                 `json:"url"`
+	WebhookID  string                 `json:"webhookId"`
+	MessageID  string                 `json:"messageId"`
+	Data       map[string]interface{} `json:"data"`
+	SecretHash string                 `json:"secretHash"`
+	MetaData   map[string]interface{} `json:"metaData"`
+}
+
+type RedisConfig struct {
+	RedisAddress          string `json:"redisAddress"`
+	RedisPassword         string `json:"redisPassword"`
+	RedisDb               string `json:"redisDb"`
+	RedisSsl              string `json:"redisSsl"`
+	RedisCaCert           string `json:"redisCaCert"`
+	RedisClientCert       string `json:"redisClientCert"`
+	RedisClientKey        string `json:"redisClientKey"`
+	RedisStreamName       string `json:"redisStreamName"`
+	RedisStreamStatusName string `json:"redisStreamStatusName"`
+}
+
+type Configuration struct {
+	Redis                RedisConfig `json:"redis"`
+	SecretHashHeaderName string      `json:"secretHashHeaderName"`
+	Broker               string      `json:"broker"`
+}
+
+// Adapter defines methods for interacting with different queue systems.
+type Adapter interface {
+	Connect() error
+	SubscribeToQueue(ctx context.Context, queue chan<- WebhookPayload) error
+	ProcessWebhooks(ctx context.Context, queue <-chan WebhookPayload) error
+	PublishStatus(ctx context.Context, webhookID, url, created, delivered, status, deliveryError string) error
+}
diff --git a/sendhooks/adapter/adapter_manager/adapter_manager.go b/sendhooks/adapter/adapter_manager/adapter_manager.go
new file mode 100644
index 0000000..481915a
--- /dev/null
+++ b/sendhooks/adapter/adapter_manager/adapter_manager.go
@@ -0,0 +1,65 @@
+package adapter_manager
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+	"sendhooks/adapter"
+	"sync"
+
+	redisadapter "sendhooks/adapter/redis_adapter"
+)
+
+var (
+	instance adapter.Adapter
+	once     sync.Once
+)
+
+var (
+	config adapter.Configuration
+)
+
+// LoadConfiguration loads the configuration from a file
+func LoadConfiguration(filename string) {
+	once.Do(func() {
+		file, err := os.Open(filename)
+		if err != nil {
+			log.Fatalf("Failed to open config file: %v", err)
+		}
+		defer file.Close()
+
+		decoder := json.NewDecoder(file)
+		err = decoder.Decode(&config)
+		if err != nil {
+			log.Fatalf("Failed to decode config file: %v", err)
+		}
+	})
+}
+
+// GetConfig returns the loaded configuration
+func GetConfig() adapter.Configuration {
+	return config
+}
+
+// Initialize initializes the appropriate adapter based on the configuration.
+func Initialize() {
+	once.Do(func() {
+		conf := GetConfig()
+		switch conf.Broker {
+		case "redis":
+			instance = redisadapter.NewRedisAdapter(conf)
+		default:
+			log.Fatalf("Unsupported broker type: %v", conf.Broker)
+		}
+
+		err := instance.Connect()
+		if err != nil {
+			log.Fatalf("Failed to connect to broker: %v", err)
+		}
+	})
+}
+
+// GetAdapter returns the singleton instance of the adapter.
+func GetAdapter() adapter.Adapter {
+	return instance
+}
diff --git a/sendhooks/adapter/redis_adapter/redis_adapter.go b/sendhooks/adapter/redis_adapter/redis_adapter.go
new file mode 100644
index 0000000..da30347
--- /dev/null
+++ b/sendhooks/adapter/redis_adapter/redis_adapter.go
@@ -0,0 +1,105 @@
+package redisadapter
+
+import (
+	"context"
+	"crypto/tls"
+	"strconv"
+	"strings"
+
+	"sendhooks/adapter"
+	"sendhooks/utils"
+
+	"github.com/go-redis/redis/v8"
+)
+
+type RedisAdapter struct {
+	client       *redis.Client
+	config       adapter.Configuration
+	streamName   string
+	statusStream string
+}
+
+// PublishStatus implements adapter.Adapter.
+func (r *RedisAdapter) PublishStatus(ctx context.Context, webhookID string, url string, created string, delivered string, status string, deliveryError string) error {
+	panic("unimplemented")
+}
+
+// SubscribeToQueue implements adapter.Adapter.
+func (r *RedisAdapter) SubscribeToQueue(ctx context.Context, queue chan<- adapter.WebhookPayload) error {
+	panic("unimplemented")
+}
+
+func NewRedisAdapter(config adapter.Configuration) *RedisAdapter {
+	return &RedisAdapter{
+		config:       config,
+		streamName:   config.Redis.RedisStreamName,
+		statusStream: config.Redis.RedisStreamStatusName,
+	}
+}
+
+func (r *RedisAdapter) Connect() error {
+	redisAddress := r.config.Redis.RedisAddress
+	if redisAddress == "" {
+		redisAddress = "localhost:6379" // Default address
+	}
+
+	redisDB := r.config.Redis.RedisDb
+	if redisDB == "" {
+		redisDB = "0" // Default database
+	}
+
+	redisDBInt, _ := strconv.Atoi(redisDB)
+	redisPassword := r.config.Redis.RedisPassword
+
+	useSSL := strings.ToLower(r.config.Redis.RedisSsl) == "true"
+	var tlsConfig *tls.Config
+
+	if useSSL {
+		caCertPath := r.config.Redis.RedisCaCert
+		clientCertPath := r.config.Redis.RedisClientCert
+		clientKeyPath := r.config.Redis.RedisClientKey
+
+		var err error
+		tlsConfig, err = utils.CreateTLSConfig(caCertPath, clientCertPath, clientKeyPath)
+		if err != nil {
+			return err
+		}
+	}
+
+	r.client = redis.NewClient(&redis.Options{
+		Addr:      redisAddress,
+		Password:  redisPassword,
+		DB:        redisDBInt,
+		TLSConfig: tlsConfig,
+	})
+
+	return nil
+}
+
+func (r *RedisAdapter) SubscribeToStream(ctx context.Context, streamName string, queue chan<- adapter.WebhookPayload) error {
+	stream := streamName
+	if stream == "" {
+		stream = r.streamName
+	}
+	// Implement subscription logic here
+	// Example:
+	// for {
+	//     streams, err := r.client.XRead(&redis.XReadArgs{
+	//         Streams: []string{stream, "0"},
+	//         Count:   1,
+	//         Block:   0,
+	//     }).Result()
+	//     if err != nil {
+	//         return err
+	//     }
+	//     for _, message := range streams[0].Messages {
+	//         queue <- adapter.WebhookPayload{ID: message.ID, Payload: message.Values["data"].(string)}
+	//     }
+	// }
+	return nil
+}
+
+func (r *RedisAdapter) ProcessWebhooks(ctx context.Context, queue <-chan adapter.WebhookPayload) error {
+	// Implement webhook processing logic here
+	return nil
+}
diff --git a/sendhooks/main.go b/sendhooks/main.go
index f86f290..0e3511c 100644
--- a/sendhooks/main.go
+++ b/sendhooks/main.go
@@ -1,85 +1,46 @@
+// main.go
 package main
 
 import (
 	"context"
-	"crypto/tls"
-	"encoding/json"
 	"fmt"
 	"log"
-	"os"
-	"strconv"
-	"strings"
 
-	"sendhooks/logging"
-	"sendhooks/queue"
-
-	redisClient "sendhooks/redis"
-	redistlsconfig "sendhooks/utils"
+	"sendhooks/adapter"
+	"sendhooks/adapter/adapter_manager"
 
-	"github.com/go-redis/redis/v8"
+	redisadapter "sendhooks/adapter/redis_adapter"
+	"sendhooks/logging"
 )
 
-// Config Declare a variable 'config' of type 'redisClient.Configuration'.
-var Config redisClient.Configuration
-
-// LoadConfiguration is a function that takes a filename as a string and returns an error.
-// It's used to load and parse a configuration file for the Redis client.
-func LoadConfiguration(filename string) error {
+func main() {
+	adapter_manager.LoadConfiguration("config.json")
 
-	// Open the file specified by 'filename'. If an error occurs (e.g., file not found),
-	file, err := os.Open(filename)
-	if err != nil {
-		return err
-	}
-	// Defer the closing of the file until the end of the function's execution.
-	// This ensures the file is closed once the function finishes, even if an error occurs.
-	defer func(file *os.File) {
-		err := file.Close()
-		if err != nil {
-			// Currently, this error is ignored.
-		}
-	}(file)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
 
-	// Create a JSON decoder that reads from the opened file.
-	decoder := json.NewDecoder(file)
-	// Use the decoder to decode the JSON content into the 'config' variable.
-	// If an error occurs during decoding (e.g., JSON format issue), return the error.
-	err = decoder.Decode(&Config)
+	err := logging.WebhookLogger(logging.EventType, "starting sendhooks engine")
 	if err != nil {
-		return err
+		log.Fatalf("Failed to log sendhooks event: %v", err)
 	}
 
-	// If everything is successful, return nil indicating no error occurred.
-	return nil
-}
+	var queueAdapter adapter.Adapter
+	conf := adapter_manager.GetConfig()
 
-func main() {
-	// Load configuration file
-	err := LoadConfiguration("config.json")
-	if err != nil {
-		log.Printf("%v. anyway, using default configuration to the project\n", err)
-	}
-	// Create a context
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	err = logging.WebhookLogger(logging.EventType, "starting sendhooks engine")
-	if err != nil {
-		log.Fatalf("Failed to log sendhooks event: %v", err)
+	if conf.Broker == "redis" {
+		queueAdapter = redisadapter.NewRedisAdapter(conf)
 	}
 
-	client, err := createRedisClient()
+	err = queueAdapter.Connect()
 	if err != nil {
-		log.Fatalf("Failed to create Redis client: %v", err)
+		log.Fatalf("Failed to connect to Redis: %v", err)
 	}
 
-	// Create a channel to act as the queue
-	webhookQueue := make(chan redisClient.WebhookPayload, 100) // Buffer size 100
+	webhookQueue := make(chan adapter.WebhookPayload, 100)
 
-	go queue.ProcessWebhooks(ctx, webhookQueue, client, Config)
-
-	// Subscribe to the "hooks" Redis stream
-	err = redisClient.SubscribeToStream(ctx, client, webhookQueue, Config)
+	go queueAdapter.ProcessWebhooks(ctx, webhookQueue)
 
+	err = queueAdapter.SubscribeToQueue(ctx, webhookQueue)
 	if err != nil {
 		logging.WebhookLogger(logging.ErrorType, fmt.Errorf("error initializing connection: %s", err))
 		log.Fatalf("error initializing connection: %v", err)
@@ -88,44 +49,3 @@ func main() {
 
 	select {}
 }
-
-func createRedisClient() (*redis.Client, error) {
-	redisAddress := Config.RedisAddress
-	if redisAddress == "" {
-		redisAddress = "localhost:6379" // Default address
-	}
-
-	redisDB := Config.RedisDb
-	if redisDB == "" {
-		redisDB = "0" // Default database
-	}
-
-	redisDBInt, _ := strconv.Atoi(redisDB)
-
-	redisPassword := Config.RedisPassword
-
-	// SSL/TLS configuration
-	useSSL := strings.ToLower(Config.RedisSsl) == "true"
-	var tlsConfig *tls.Config
-
-	if useSSL {
-		caCertPath := Config.RedisCaCert
-		clientCertPath := Config.RedisClientCert
-		clientKeyPath := Config.RedisClientKey
-
-		var err error
-		tlsConfig, err = redistlsconfig.CreateTLSConfig(caCertPath, clientCertPath, clientKeyPath)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	client := redis.NewClient(&redis.Options{
-		Addr:      redisAddress,
-		Password:  redisPassword,
-		DB:        redisDBInt,
-		TLSConfig: tlsConfig,
-	})
-
-	return client, nil
-}
diff --git a/sendhooks/queue/worker.go b/sendhooks/queue/worker.go
index cf54ec4..be841a9 100644
--- a/sendhooks/queue/worker.go
+++ b/sendhooks/queue/worker.go
@@ -8,13 +8,13 @@ we also handle the retries and the exponential backoff logic for sending the hoo
 import (
 	"context"
 	"fmt"
+	"sendhooks/adapter"
+	"sendhooks/adapter/adapter_manager"
 	"sendhooks/logging"
 	"sendhooks/sender"
 	"time"
 
-	"github.com/go-redis/redis/v8"
-
-	redisClient "sendhooks/redis"
+	redisadapter "sendhooks/adapter/redis_adapter"
 )
 
 const (
@@ -26,17 +26,24 @@ const (
 	maxBackoff     time.Duration = time.Hour
 )
 
-func ProcessWebhooks(ctx context.Context, webhookQueue chan redisClient.WebhookPayload, client *redis.Client, configuration redisClient.Configuration) {
+func ProcessWebhooks(ctx context.Context, webhookQueue chan adapter.WebhookPayload, configuration adapter.Configuration) {
 
 	for payload := range webhookQueue {
-		go sendWebhookWithRetries(ctx, payload, client, configuration)
+		go sendWebhookWithRetries(ctx, payload, configuration)
 	}
 }
 
-func sendWebhookWithRetries(ctx context.Context, payload redisClient.WebhookPayload, client *redis.Client, configuration redisClient.Configuration) {
-	if err, created := retryWithExponentialBackoff(ctx, payload, client, configuration); err != nil {
+func sendWebhookWithRetries(ctx context.Context, payload adapter.WebhookPayload, configuration adapter.Configuration) {
+	conf := adapter_manager.GetConfig()
+
+	var queueAdapter adapter.Adapter
+
+	if conf.Broker == "redis" {
+		queueAdapter = redisadapter.NewRedisAdapter(conf)
+	}
+	if err, created := retryWithExponentialBackoff(ctx, payload, configuration); err != nil {
 		logging.WebhookLogger(logging.WarningType, fmt.Errorf("failed to send sendhooks after maximum retries. WebhookID : %s", payload.WebhookID))
-		err := redisClient.PublishStatus(ctx, payload.WebhookID, payload.URL, created, "", "failed", err.Error(), client, configuration)
+		err := queueAdapter.PublishStatus(ctx, payload.WebhookID, payload.URL, created, "", "failed", err.Error())
 		if err != nil {
 			logging.WebhookLogger(logging.WarningType, fmt.Errorf("error publishing status update: WebhookID : %s ", payload.WebhookID))
 		}
@@ -54,7 +61,7 @@ func calculateBackoff(currentBackoff time.Duration) time.Duration {
 	return nextBackoff
 }
 
-func retryWithExponentialBackoff(context context.Context, payload redisClient.WebhookPayload, client *redis.Client, configuration redisClient.Configuration) (error, string) {
+func retryWithExponentialBackoff(context context.Context, payload adapter.WebhookPayload, configuration adapter.Configuration) (error, string) {
 	retries := 0
 	backoffTime := initialBackoff
 	var requestError error
@@ -90,7 +97,15 @@ func retryWithExponentialBackoff(context context.Context, payload redisClient.We
 
 	delivered := time.Now().String()
 
-	err := redisClient.PublishStatus(context, payload.WebhookID, payload.URL, created, delivered, "success", "", client, configuration)
+	conf := adapter_manager.GetConfig()
+
+	var queueAdapter adapter.Adapter
+
+	if conf.Broker == "redis" {
+		queueAdapter = redisadapter.NewRedisAdapter(conf)
+	}
+
+	err := queueAdapter.PublishStatus(context, payload.WebhookID, payload.URL, created, delivered, "success", "")
 	if err != nil {
 		logging.WebhookLogger(logging.WarningType, fmt.Errorf("error publishing status update: WebhookID : %s ", payload.WebhookID))
 	}
diff --git a/sendhooks/sender/utils.go b/sendhooks/sender/utils.go
index 2049da7..b68be5e 100644
--- a/sendhooks/sender/utils.go
+++ b/sendhooks/sender/utils.go
@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"sendhooks/adapter"
 	"sendhooks/logging"
-	redisClient "sendhooks/redis"
 )
 
 type HTTPDoer interface {
@@ -25,7 +25,7 @@ var marshalJSON = func(data interface{}) ([]byte, error) {
 	return jsonBytes, nil
 }
 
-var prepareRequest = func(url string, jsonBytes []byte, secretHash string, configuration redisClient.Configuration) (*http.Request, error) {
+var prepareRequest = func(url string, jsonBytes []byte, secretHash string, configuration adapter.Configuration) (*http.Request, error) {
 	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBytes))
 	if err != nil {
 		logging.WebhookLogger(logging.ErrorType, fmt.Errorf("error during the sendhooks request preparation"))
diff --git a/sendhooks/sender/webhook.go b/sendhooks/sender/webhook.go
index eeef7e0..9985882 100644
--- a/sendhooks/sender/webhook.go
+++ b/sendhooks/sender/webhook.go
@@ -3,12 +3,12 @@ package sender
 import (
 	"errors"
 	"fmt"
+	"sendhooks/adapter"
 	"sendhooks/logging"
-	redisClient "sendhooks/redis"
 )
 
 // SendWebhook sends a JSON POST request to the specified URL
-func SendWebhook(data interface{}, url string, webhookId string, secretHash string, configuration redisClient.Configuration) error {
+func SendWebhook(data interface{}, url string, webhookId string, secretHash string, configuration adapter.Configuration) error {
 	jsonBytes, err := marshalJSON(data)
 	if err != nil {
 		return err
diff --git a/sendhooks/sender/webhook_test.go b/sendhooks/sender/webhook_test.go
index 153a69c..89b9e38 100644
--- a/sendhooks/sender/webhook_test.go
+++ b/sendhooks/sender/webhook_test.go
@@ -3,8 +3,8 @@ package sender
 import (
 	"errors"
 	"net/http"
+	"sendhooks/adapter"
 	"sendhooks/logging"
-	"sendhooks/redis"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -27,7 +27,7 @@ func TestSendWebhook(t *testing.T) {
 	t.Run("Successful sendhooks sending", func(t *testing.T) {
 		resetMocks() // Reset all mocks to original functions
 
-		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", redis.Configuration{})
+		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", adapter.Configuration{})
 
 		assert.NoError(t, err)
 	})
@@ -38,18 +38,18 @@ func TestSendWebhook(t *testing.T) {
 			return nil, errors.New("marshaling error")
 		}
 
-		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", redis.Configuration{})
+		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", adapter.Configuration{})
 
 		assert.EqualError(t, err, "marshaling error")
 	})
 
 	t.Run("Failed sendhooks due to request preparation errors", func(t *testing.T) {
 		resetMocks()
-		prepareRequest = func(url string, jsonBytes []byte, secretHash string, configuration redis.Configuration) (*http.Request, error) {
+		prepareRequest = func(url string, jsonBytes []byte, secretHash string, configuration adapter.Configuration) (*http.Request, error) {
 			return nil, errors.New("request preparation error")
 		}
 
-		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", redis.Configuration{})
+		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", adapter.Configuration{})
 
 		assert.EqualError(t, err, "request preparation error")
 	})
@@ -60,7 +60,7 @@ func TestSendWebhook(t *testing.T) {
 			return "failed", nil, 0, errors.New("response processing error")
 		}
 
-		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", redis.Configuration{})
+		err := SendWebhook(nil, "http://dummy.com", "webhookId", "secretHash", adapter.Configuration{})
 
 		assert.EqualError(t, err, "response processing error")
 	})
@@ -71,7 +71,7 @@ func TestSendWebhook(t *testing.T) {
 			return "failed", []byte("error body"), 0, nil
 		}
 
-		SendWebhook(nil, "http://dummy\t\tassert.EqualError(t, err, \"failed\")\n.com", "webhookId", "secretHash", redis.Configuration{})
+		SendWebhook(nil, "http://dummy\t\tassert.EqualError(t, err, \"failed\")\n.com", "webhookId", "secretHash", adapter.Configuration{})
 		if !webhookLoggerInvoked {
 			assert.Fail(t, "Expected WebhookLogger to be invoked")
 		}