Implementation Strategies

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "sync"
    "time"
)

// ServiceRegistry from previous example...

// DiscoveryRouter routes requests to services using service discovery
type DiscoveryRouter struct {
    registry *ServiceRegistry
    proxies  map[string][]*httputil.ReverseProxy
    mutex    sync.RWMutex
}

// NewDiscoveryRouter creates a new discovery router
func NewDiscoveryRouter(registry *ServiceRegistry) *DiscoveryRouter {
    return &DiscoveryRouter{
        registry: registry,
        proxies:  make(map[string][]*httputil.ReverseProxy),
    }
}

// updateProxies updates the reverse proxies for a service
func (dr *DiscoveryRouter) updateProxies(serviceName string) error {
    instances, exists := dr.registry.GetService(serviceName)
    if !exists || len(instances) == 0 {
        return fmt.Errorf("no instances available for service: %s", serviceName)
    }
    
    var proxies []*httputil.ReverseProxy
    
    for _, instance := range instances {
        if instance.Status != "UP" {
            continue
        }
        
        target, err := url.Parse(fmt.Sprintf("http://%s:%d", instance.Address, instance.Port))
        if err != nil {
            log.Printf("Error parsing URL for instance %s: %v", instance.ID, err)
            continue
        }
        
        proxy := httputil.NewSingleHostReverseProxy(target)
        
        // Add custom error handler
        proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
            log.Printf("Proxy error: %v", err)
            w.WriteHeader(http.StatusBadGateway)
            w.Write([]byte("Service unavailable"))
        }
        
        proxies = append(proxies, proxy)
    }
    
    if len(proxies) == 0 {
        return fmt.Errorf("no healthy instances available for service: %s", serviceName)
    }
    
    dr.mutex.Lock()
    dr.proxies[serviceName] = proxies
    dr.mutex.Unlock()
    
    return nil
}

// ServeHTTP implements the http.Handler interface
func (dr *DiscoveryRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // Extract service name from the request path
    // In a real implementation, you'd use a more sophisticated routing mechanism
    serviceName := extractServiceName(r.URL.Path)
    
    dr.mutex.RLock()
    proxies, exists := dr.proxies[serviceName]
    dr.mutex.RUnlock()
    
    // If no proxies exist or they need to be refreshed
    if !exists || len(proxies) == 0 {
        err := dr.updateProxies(serviceName)
        if err != nil {
            log.Printf("Error updating proxies: %v", err)
            w.WriteHeader(http.StatusServiceUnavailable)
            w.Write([]byte("Service unavailable"))
            return
        }
        
        dr.mutex.RLock()
        proxies = dr.proxies[serviceName]
        dr.mutex.RUnlock()
    }
    
    // Simple round-robin selection
    proxy := proxies[time.Now().UnixNano()%int64(len(proxies))]
    
    // Forward the request
    proxy.ServeHTTP(w, r)
}

// extractServiceName extracts the service name from the request path
// In a real implementation, you'd use a more sophisticated routing mechanism
func extractServiceName(path string) string {
    // This is a simplified example
    // In practice, you might use a routing table or path-based convention
    if len(path) > 1 && path[0] == '/' {
        parts := strings.Split(path[1:], "/")
        if len(parts) > 0 {
            return parts[0]
        }
    }
    return "default"
}

func main() {
    // Create a service registry
    registry := NewServiceRegistry()
    
    // Register some service instances
    registry.Register(ServiceInstance{
        ID:      "payment-service-1",
        Name:    "payment",
        Address: "10.0.0.1",
        Port:    8080,
        Status:  "UP",
    })
    
    registry.Register(ServiceInstance{
        ID:      "payment-service-2",
        Name:    "payment",
        Address: "10.0.0.2",
        Port:    8080,
        Status:  "UP",
    })
    
    registry.Register(ServiceInstance{
        ID:      "order-service-1",
        Name:    "order",
        Address: "10.0.0.3",
        Port:    8080,
        Status:  "UP",
    })
    
    // Create a discovery router
    router := NewDiscoveryRouter(registry)
    
    // Start the router
    log.Println("Starting discovery router on :8000")
    log.Fatal(http.ListenAndServe(":8000", router))
}