feat: added healthchecking service daemon process and added additional tests.

Author: syntaxsdev

.vscode/launch.json

@@ -0,0 +1,26 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch test function",
+            "type": "go",
+            "request": "launch",
+            "mode": "test",
+            "program": "${workspaceFolder}",
+            "args": [
+                "-test.run",
+                "MyTestFunction"
+            ]
+        },
+        {
+            "name": "Launch Package",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": "${fileDirname}"
+        }
+    ]
+}

bin/air

@@ -0,0 +1,37 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/syntaxsdev/mercury/models"
+)
+
+func TestWriteHttp(t *testing.T) {
+	recorder := httptest.NewRecorder()
+	data := map[string]interface{}{"data": map[string]string{"name": "testing"}}
+
+	err := WriteHttp(recorder, http.StatusOK, "success", data)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	// Check status code
+	if recorder.Code != http.StatusOK {
+		t.Errorf("Expected status code %d, got %d", http.StatusOK, recorder.Code)
+	}
+
+	// Check response body
+	var response models.Response
+
+	if err = json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
+		t.Error("Could not convert to Response type")
+	}
+	if dataMap, ok := response.Data.(map[string]interface{}); ok {
+		if name, exists := dataMap["name"]; exists && name != "testing" {
+			t.Errorf("Expected %v, got %v", response.Data, data)
+		}
+	}
+}

internal/handlers/helpers_test.go

@@ -2,7 +2,6 @@ package handlers
 
 import (
 	"encoding/json"
-	"log"
 	"net/http"
 
 	"github.com/syntaxsdev/mercury/internal/services"
@@ -19,50 +18,26 @@ func GetAllStrategies(w http.ResponseWriter, r *http.Request, f *services.Factor
 	}
 
 	if payload != nil {
+		var results map[string]interface{}
+
 		err := f.MongoService.First("strategies", bson.M(payload), &results)
 		if err == nil && results == nil {
-			WriteHttp(w, http.StatusNotFound, "Nothing was found with the supplied filter", nil)
+			WriteHttp(w, http.StatusNotFound, "No results were returned with the supplied filter", nil)
 			return
 		} else if err == nil {
-			log.Println("Here")
 			WriteHttp(w, http.StatusOK, "Successfully fetched all strategies by filter", results)
+			return
 		}
-		log.Println("Here", err)
 	}
 	err := f.MongoService.All("strategies", bson.M{}, &results)
 	if err != nil {
 		http.Error(w, "Could not retrieve strategies.", http.StatusInternalServerError)
 		return
 	}
-	code := http.StatusOK
-	WriteHttp(w, code, "Successfully fetched all strategies", results)
+	WriteHttp(w, http.StatusOK, "Successfully fetched all strategies", results)
 
 }
 
-// // Get Strategy By ID
-// func GetStrategyByID(w http.ResponseWriter, r *http.Request, f *services.Factory) {
-// 	var result interface{}
-// 	id := chi.URLParam(r, "id")
-// 	port, err := strconv.Atoi(id)
-// 	if err != nil {
-// 		WriteHttp(w, http.StatusBadRequest, "Invalid", err)
-// 	}
-// 	// objectID, err := primitive.ObjectIDFromHex(id)
-// 	// if err != nil {
-// 	// 	WriteHttp(w, http.StatusBadRequest, "Invalid ID", err)
-// 	// 	return
-// 	// }
-
-// 	err = f.MongoService.First("strategies", bson.M{"port": port}, &result)
-// 	if err != nil {
-// 		WriteHttp(w, http.StatusBadRequest, "Could not retrieve strategy by ID.", nil)
-// 		log.Println(err)
-// 		return
-// 	}
-// 	WriteHttp(w, http.StatusOK, "Successfully fetched strategy", result)
-
-// }
-
 // Create A Strategy
 func CreateStrategy(w http.ResponseWriter, r *http.Request, f *services.Factory) {
 	var newStrategy models.Strategy
@@ -73,11 +48,8 @@ func CreateStrategy(w http.ResponseWriter, r *http.Request, f *services.Factory)
 	res, err := f.MongoService.Insert("strategies", newStrategy)
 	if err != nil {
 		http.Error(w, "Could not insert strategy", http.StatusInternalServerError)
+		return
 	}
 
 	WriteHttp(w, http.StatusCreated, "Strategy successfully created", res)
-	// code := http.StatusCreated
-	// w.Header().Set("Content-Type", "application/json")
-	// w.WriteHeader(http.StatusCreated)
-	// json.NewEncoder(w).Encode(models.Response{Message: "Strategy successfully created", Code: code, Data: res})
 }

internal/handlers/strategy.go

@@ -2,7 +2,6 @@ package services
 
 import (
 	"context"
-	"log"
 	"time"
 
 	"go.mongodb.org/mongo-driver/v2/mongo"
@@ -30,10 +29,8 @@ func (s *MongoService) First(collection string, filter interface{}, result inter
 	coll := s.Client.Database(s.DatabaseName).Collection(collection)
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
-	log.Println(filter)
-	log.Println(collection)
+
 	err := coll.FindOne(ctx, filter).Decode(result)
-	log.Println(result)
 	if err == mongo.ErrNoDocuments {
 		if resultPtr, ok := result.(*interface{}); ok {
 			*resultPtr = nil
@@ -44,7 +41,7 @@ func (s *MongoService) First(collection string, filter interface{}, result inter
 
 }
 
-func (s *MongoService) All(collection string, filter interface{}, result *[]interface{}) error {
+func (s *MongoService) All(collection string, filter interface{}, result interface{}) error {
 	coll := s.Client.Database(s.DatabaseName).Collection(collection)
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
@@ -55,18 +52,10 @@ func (s *MongoService) All(collection string, filter interface{}, result *[]inte
 	}
 	defer cursor.Close(ctx)
 
-	for cursor.Next(ctx) {
-		var doc interface{}
-		if err := cursor.Decode(&doc); err != nil {
-			return err
-		}
-		*result = append(*result, doc)
-	}
-
-	if err := cursor.Err(); err != nil {
+	// Use the cursor to decode directly into the provided result slice
+	if err := cursor.All(ctx, result); err != nil {
 		return err
-
 	}
-	return nil
 
+	return nil
 }

internal/services/mongo.go

@@ -0,0 +1,95 @@
+package monitoring
+
+import (
+	"log"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/syntaxsdev/mercury/internal/services"
+	"github.com/syntaxsdev/mercury/models"
+)
+
+// HealthData tracks data of each Strategies health
+type HealthData struct {
+	mu           sync.Mutex
+	Healthy      bool
+	LastCheck    time.Time
+	FailureCount int
+}
+
+// Update updates the health check result
+func (h *HealthData) Update(isHealthy bool) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.Healthy = isHealthy
+	h.LastCheck = time.Now()
+	if !isHealthy {
+		h.FailureCount++
+		return
+	}
+	h.FailureCount = 0
+}
+
+// HealthChecker
+type HealthChecker struct {
+	client     *http.Client
+	mu         sync.Mutex
+	healthData map[string]*HealthData
+}
+
+// Initialize a HealthChecker Manager
+func NewHealthChecker(client *http.Client) *HealthChecker {
+	if client == nil {
+		client = &http.Client{}
+	}
+	return &HealthChecker{
+		healthData: make(map[string]*HealthData),
+		client:     client,
+	}
+}
+
+func (h *HealthChecker) Check(data *HealthData, s *models.Strategy) {
+	if s.Options.Active && s.HasHealthCheck() {
+		url, _ := s.HealthCheckUrl()
+		resp, err := h.client.Get(url)
+		if err != nil || (resp.StatusCode < 200 || resp.StatusCode > 203) {
+			data.Update(false)
+		} else {
+			data.Update(true)
+		}
+	}
+	// Max 5 unhealthy checks
+	if data.FailureCount == 5 {
+		s.Options.Active = false
+	}
+}
+
+func (h *HealthChecker) BackgroundProcess(s *services.StrategyService) {
+	defaultWait := 10
+	for {
+		strats, err := s.GetAllStrategies()
+		if err != nil {
+			log.Println("ERROR: Cannot get strategies")
+			continue
+		}
+
+		// Delay the wait if there is no strategies at the moment
+		if len(strats) == 0 {
+			defaultWait = 20
+			continue
+		}
+		defaultWait = 10
+
+		for _, strat := range strats {
+			h.mu.Lock()
+			if _, exists := h.healthData[strat.Name]; !exists {
+				h.healthData[strat.Name] = &HealthData{}
+			}
+			h.mu.Unlock()
+			val := h.healthData[strat.Name]
+			go h.Check(val, &strat)
+		}
+		time.Sleep(time.Duration(defaultWait) * time.Second)
+	}
+}

internal/services/monitoring/health_check.go

@@ -0,0 +1,83 @@
+package monitoring
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/syntaxsdev/mercury/models"
+)
+
+func TestHealthCheck(t *testing.T) {
+	// Mock HTTP Server
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Simulate healthy check
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	// Mock Client
+	mockClient := &http.Client{
+		Transport: &http.Transport{
+			Proxy: func(req *http.Request) (*url.URL, error) {
+				return url.Parse(server.URL)
+			},
+		},
+	}
+	healthChecker := NewHealthChecker(mockClient)
+
+	s := models.Strategy{
+		Name:        "Test",
+		Host:        "http://localhost",
+		Port:        8445,
+		Options:     models.StrategyOptions{Active: true},
+		HealthCheck: models.HealthCheckOptions{},
+	}
+	s.SetDefaults()
+
+	t.Run("CheckStrategyHealth", func(t *testing.T) {
+		data := HealthData{}
+		healthChecker.Check(&data, &s)
+
+		// Asserts
+		if data.FailureCount != 0 {
+			t.Errorf("Expected 0, got %v", data.FailureCount)
+		}
+		if !data.Healthy {
+			t.Errorf("Expected true got %v", data.Healthy)
+		}
+	})
+
+	t.Run("CheckUnhealthyStrategy", func(t *testing.T) {
+		server.Config.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusInternalServerError)
+		})
+		data := HealthData{}
+		healthChecker.Check(&data, &s)
+
+		// Asserts
+		if data.FailureCount != 1 {
+			t.Errorf("Expected 1, got %v", data.FailureCount)
+		}
+		if data.Healthy {
+			t.Errorf("Expected false got %v", data.Healthy)
+		}
+	})
+
+	t.Run("CheckClosedServer", func(t *testing.T) {
+		// Close the server to simulate unavailable resource
+		server.Close()
+
+		data := HealthData{}
+		healthChecker.Check(&data, &s)
+
+		// Asserts
+		if data.FailureCount != 1 {
+			t.Errorf("Expected FailureCount 1, got %v", data.FailureCount)
+		}
+		if data.Healthy {
+			t.Errorf("Expected Healthy false got %v", data.Healthy)
+		}
+	})
+}