fixup! Simplify all the things.

metadata_cache.go

@@ -1,6 +1,7 @@
 package traefikoidc
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 	"sync"
@@ -55,6 +56,90 @@ func (c *MetadataCache) isCacheValid() bool {
 	return c.metadata != nil && time.Now().Before(c.expiresAt)
 }
 
+// GetMetadataWithRecovery retrieves the OIDC provider metadata with comprehensive error recovery.
+// It uses circuit breaker protection and graceful degradation patterns.
+// Similar to GetMetadata but with enhanced error handling capabilities.
+//
+// Parameters:
+//   - providerURL: The base URL of the OIDC provider.
+//   - httpClient: The HTTP client to use for fetching metadata.
+//   - logger: The logger instance for recording errors or warnings.
+//   - errorRecoveryManager: The error recovery manager for circuit breaker and retry handling.
+//
+// Returns:
+//   - A pointer to the ProviderMetadata struct.
+//   - An error if metadata cannot be retrieved from cache or fetched from the provider.
+func (c *MetadataCache) GetMetadataWithRecovery(providerURL string, httpClient *http.Client, logger *Logger, errorRecoveryManager *ErrorRecoveryManager) (*ProviderMetadata, error) {
+	c.mutex.RLock()
+	if c.isCacheValid() {
+		defer c.mutex.RUnlock()
+		return c.metadata, nil
+	}
+	c.mutex.RUnlock()
+
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	// Double-check after acquiring write lock
+	if c.isCacheValid() {
+		return c.metadata, nil
+	}
+
+	// Use error recovery manager for fetching metadata with circuit breaker protection
+	serviceName := fmt.Sprintf("metadata-provider-%s", providerURL)
+
+	// Register fallback function for graceful degradation
+	errorRecoveryManager.gracefulDegradation.RegisterFallback(serviceName, func() (interface{}, error) {
+		if c.metadata != nil {
+			logger.Infof("Using cached metadata as fallback for service %s", serviceName)
+			// Extend cache by 10 minutes when using fallback
+			c.expiresAt = time.Now().Add(10 * time.Minute)
+			return c.metadata, nil
+		}
+		return nil, fmt.Errorf("no cached metadata available for fallback")
+	})
+
+	// Register health check function
+	errorRecoveryManager.gracefulDegradation.RegisterHealthCheck(serviceName, func() bool {
+		// Simple health check by attempting a quick metadata fetch
+		_, err := discoverProviderMetadata(providerURL, httpClient, logger)
+		return err == nil
+	})
+
+	// Execute metadata discovery with circuit breaker and retry protection
+	ctx := context.Background()
+	var metadata *ProviderMetadata
+	err := errorRecoveryManager.ExecuteWithRecovery(ctx, serviceName, func() error {
+		var fetchErr error
+		metadata, fetchErr = discoverProviderMetadata(providerURL, httpClient, logger)
+		return fetchErr
+	})
+
+	if err != nil {
+		// Try graceful degradation fallback
+		fallbackResult, fallbackErr := errorRecoveryManager.gracefulDegradation.ExecuteWithFallback(serviceName, func() (interface{}, error) {
+			return discoverProviderMetadata(providerURL, httpClient, logger)
+		})
+
+		if fallbackErr == nil {
+			if fallbackMetadata, ok := fallbackResult.(*ProviderMetadata); ok {
+				logger.Infof("Successfully used fallback metadata for service %s", serviceName)
+				c.metadata = fallbackMetadata
+				// Cache fallback result for 10 minutes
+				c.expiresAt = time.Now().Add(10 * time.Minute)
+				return fallbackMetadata, nil
+			}
+		}
+
+		return nil, fmt.Errorf("failed to fetch provider metadata with error recovery and fallback: %w", err)
+	}
+
+	c.metadata = metadata
+	c.expiresAt = time.Now().Add(1 * time.Hour)
+
+	return metadata, nil
+}
+
 // GetMetadata retrieves the OIDC provider metadata.
 // It first checks the cache for valid, non-expired metadata. If found, it's returned immediately.
 // If the cache is empty or expired, it attempts to fetch the metadata from the provider's