Backend Concurrency for Endpoint Details

Author: ben-burwood

internal/api/endpoint.go

@@ -0,0 +1,32 @@
+package api
+
+import (
+	"net/http"
+	"sync"
+
+	"certui/internal/certificate"
+	"certui/internal/domain"
+)
+
+// EndpointDetails contains the certificate, domain, and WHOIS details for an endpoint.
+type EndpointDetails struct {
+	Domain domain.DomainDetails
+	Whois  *domain.WhoisDetails
+	SSL    *certificate.SSLDetails
+}
+
+// fetchEndpointDetails fetches certificate, domain, and WHOIS details concurrently for a single endpoint
+func fetchEndpointDetails(client *http.Client, endpoint domain.Domain) *EndpointDetails {
+	var ssl *certificate.SSLDetails
+	var domainDetails domain.DomainDetails
+	var whoisDetails *domain.WhoisDetails
+	var wg sync.WaitGroup
+
+	wg.Add(3)
+	go func() { defer wg.Done(); ssl, _ = certificate.GetCertificateInfo(client, endpoint) }()
+	go func() { defer wg.Done(); domainDetails = domain.GetDomainDetails(endpoint) }()
+	go func() { defer wg.Done(); whoisDetails, _ = domain.WhoisForDomain(endpoint) }()
+	wg.Wait()
+
+	return &EndpointDetails{Domain: domainDetails, Whois: whoisDetails, SSL: ssl}
+}

internal/api/handlers.go

@@ -4,47 +4,32 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"sync"
 	"time"
 
-	"certui/internal/certificate"
 	"certui/internal/config"
 	"certui/internal/domain"
 )
 
-type EndpointDetails struct {
-	Domain domain.DomainDetails
-	Whois  *domain.WhoisDetails
-	SSL    *certificate.SSLDetails
-}
-
 // AllEndpointsHandler handles requests for all Endpoints Details
 func AllEndpointsHandler(cfg *config.Config) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		results := make(map[domain.Domain]*EndpointDetails)
+		var mu sync.Mutex
+		var wg sync.WaitGroup
+
 		client := &http.Client{}
 		for _, endpoint := range cfg.Endpoints {
-			endpointDomain := domain.Domain(endpoint)
-
-			ssl, err := certificate.GetCertificateInfo(client, endpointDomain)
-			if err != nil {
-				ssl = nil
-			}
-
-			domainDetails := domain.GetDomainDetails(endpointDomain)
-
-			whoisDetails, err := domain.WhoisForDomain(endpointDomain)
-			if err != nil {
-				whoisDetails = nil
-			}
-
-			response := EndpointDetails{
-				Domain: domainDetails,
-				Whois:  whoisDetails,
-				SSL:    ssl,
-			}
-
-			results[endpoint] = &response
+			wg.Add(1)
+			go func(ep domain.Domain) {
+				defer wg.Done()
+				details := fetchEndpointDetails(client, ep)
+				mu.Lock()
+				results[ep] = details
+				mu.Unlock()
+			}(endpoint)
 		}
+		wg.Wait()
 
 		w.Header().Set("Content-Type", "application/json")
 		json.NewEncoder(w).Encode(results)
@@ -58,27 +43,29 @@ func EndpointHandlerSSE(cfg *config.Config) http.HandlerFunc {
 		w.Header().Set("Cache-Control", "no-cache")
 		w.Header().Set("Connection", "keep-alive")
 
+		var mu sync.Mutex
+		var wg sync.WaitGroup
+
 		client := &http.Client{Timeout: 10 * time.Second}
 		for _, endpoint := range cfg.Endpoints {
-			endpointDomain := domain.Domain(endpoint)
-			ssl, _ := certificate.GetCertificateInfo(client, endpointDomain)
-			domainDetails := domain.GetDomainDetails(endpointDomain)
-			whoisDetails, _ := domain.WhoisForDomain(endpointDomain)
+			wg.Add(1)
+			go func(ep domain.Domain) {
+				defer wg.Done()
+				details := fetchEndpointDetails(client, ep)
+				wrapped := struct {
+					Endpoint domain.Domain   `json:"endpoint"`
+					Details  EndpointDetails `json:"details"`
+				}{Endpoint: ep, Details: *details}
 
-			response := EndpointDetails{
-				Domain: domainDetails,
-				Whois:  whoisDetails,
-				SSL:    ssl,
-			}
-			wrapped := struct {
-				Endpoint domain.Domain   `json:"endpoint"`
-				Details  EndpointDetails `json:"details"`
-			}{Endpoint: endpoint, Details: response}
-
-			b, _ := json.Marshal(wrapped)
-			fmt.Fprintf(w, "data: %s\n\n", b) // Send Single Endpoint Data
-			w.(http.Flusher).Flush()
+				b, _ := json.Marshal(wrapped)
+				mu.Lock()
+				fmt.Fprintf(w, "data: %s\n\n", b) // Send Single Endpoint Data
+				w.(http.Flusher).Flush()
+				mu.Unlock()
+			}(endpoint)
 		}
+		wg.Wait()
+
 		fmt.Fprintf(w, "event: done\ndata: {}\n\n") // Send Done Event
 		w.(http.Flusher).Flush()
 	}