Agregar archivos faltantes del sistema de cache: CacheHealth, CacheManager, CacheStats, CachedClass, LRUCache

Author: yasmramos

warmup-core/src/main/java/io/warmup/framework/cache/CacheHealth.java

@@ -0,0 +1,46 @@
+package io.warmup.framework.cache;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class CacheHealth {
+
+    public final boolean healthy;
+    public final List<String> warnings;
+    public final List<String> errors;
+    public final Map<String, Object> metrics;
+
+    public CacheHealth(boolean healthy, List<String> warnings, List<String> errors, Map<String, Object> metrics) {
+        this.healthy = healthy;
+        this.warnings = Collections.unmodifiableList(new ArrayList<>(warnings));
+        this.errors = Collections.unmodifiableList(new ArrayList<>(errors));
+        this.metrics = Collections.unmodifiableMap(new HashMap<>(metrics));
+    }
+
+    public boolean isHealthy() {
+        return healthy && errors.isEmpty();
+    }
+
+    public void printReport() {
+        System.out.println("Cache Health Report:");
+        System.out.println("Overall Status: " + (isHealthy() ? "HEALTHY" : "UNHEALTHY"));
+
+        if (!errors.isEmpty()) {
+            System.out.println("\nErrors:");
+            errors.forEach(error -> System.out.println("  " + error));
+        }
+
+        if (!warnings.isEmpty()) {
+            System.out.println("\nWarnings:");
+            warnings.forEach(warning -> System.out.println("  " + warning));
+        }
+
+        if (!metrics.isEmpty()) {
+            System.out.println("\nMetrics:");
+            metrics.forEach((key, value) -> System.out.println("  " + key + ": " + value));
+        }
+    }
+}

warmup-core/src/main/java/io/warmup/framework/cache/CacheManager.java

@@ -0,0 +1,330 @@
+package io.warmup.framework.cache;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * O(1) Optimized Cache Manager with atomic counters, TTL caches, and cache invalidation.
+ * Provides production-ready caching performance with comprehensive statistics.
+ */
+public class CacheManager {
+
+    private static final Logger log = Logger.getLogger(CacheManager.class.getName());
+    
+    // O(1) Atomic Counters for Real-time Statistics
+    private final AtomicInteger cachePuts = new AtomicInteger(0);
+    private final AtomicInteger cacheGets = new AtomicInteger(0);
+    private final AtomicInteger cacheHits = new AtomicInteger(0);
+    private final AtomicInteger cacheMisses = new AtomicInteger(0);
+    private final AtomicInteger cacheRemovals = new AtomicInteger(0);
+    private final AtomicInteger cacheExpirations = new AtomicInteger(0);
+    private final AtomicLong totalCacheOperations = new AtomicLong(0);
+    
+    // O(1) TTL Caches - Cache Data (10s), Cache Stats (30s)
+    private final Map<String, CacheEntry> cacheData = new ConcurrentHashMap<>();
+    private final Map<String, Long> cacheDataExpiry = new ConcurrentHashMap<>();
+    private static final long CACHE_DATA_TTL = TimeUnit.SECONDS.toMillis(10);
+    
+    private final Map<String, Object> cacheStatsCache = new ConcurrentHashMap<>();
+    private final Map<String, Long> cacheStatsExpiry = new ConcurrentHashMap<>();
+    private static final long CACHE_STATS_TTL = TimeUnit.SECONDS.toMillis(30);
+    
+    // O(1) Cache Invalidation Flags
+    private volatile boolean cacheDataDirty = false;
+    private volatile boolean cacheStatsDirty = false;
+    
+    // O(1) Performance Monitoring
+    private final AtomicLong totalCacheOperationTime = new AtomicLong(0);
+    private volatile long startTime = System.currentTimeMillis();
+    
+    // Backend storage for cache data
+    private final Map<String, Object> backendStorage = new ConcurrentHashMap<>();
+    
+    // Configuration
+    private static final int MAX_CACHE_SIZE = 10000; // Maximum cache entries
+    private static final int CLEANUP_THRESHOLD = 1000; // Trigger cleanup when threshold exceeded
+    
+    /**
+     * Default constructor
+     */
+    public CacheManager() {
+        log.info("CacheManager initialized with in-memory backend");
+    }
+
+    // O(1) Optimized put operation with TTL caching
+    public void put(String key, Object value) {
+        long startTime = System.nanoTime();
+        
+        cachePuts.incrementAndGet();
+        totalCacheOperations.incrementAndGet();
+        
+        // Backend storage operation (O(1))
+        backendStorage.put(key, value);
+        
+        // O(1) TTL cache storage
+        cacheData.put(key, new CacheEntry(value, System.currentTimeMillis() + CACHE_DATA_TTL));
+        cacheDataExpiry.put(key, System.currentTimeMillis() + CACHE_DATA_TTL);
+        
+        // O(1) Cache invalidation
+        cacheDataDirty = true;
+        cacheStatsDirty = true;
+        
+        // Trigger cleanup if needed
+        if (cacheData.size() > CLEANUP_THRESHOLD) {
+            cleanupExpiredEntries();
+        }
+        
+        long duration = System.nanoTime() - startTime;
+        totalCacheOperationTime.addAndGet(duration);
+        
+        log.info("Cache PUT: " + key + " = " + value);
+    }
+
+    // O(1) Optimized get operation with TTL caching and hit/miss tracking
+    public Object get(String key) {
+        long startTime = System.nanoTime();
+        
+        cacheGets.incrementAndGet();
+        totalCacheOperations.incrementAndGet();
+        
+        Object result = null;
+        
+        // O(1) TTL cache check first
+        if (isCacheValid(key, cacheData, cacheDataExpiry)) {
+            CacheEntry entry = cacheData.get(key);
+            if (entry != null && entry.value != null) {
+                result = entry.value;
+                cacheHits.incrementAndGet();
+                
+                long duration = System.nanoTime() - startTime;
+                totalCacheOperationTime.addAndGet(duration);
+                
+                return result;
+            }
+        }
+        
+        // Cache miss - try backend storage (O(1))
+        result = backendStorage.get(key);
+        
+        if (result != null) {
+            cacheHits.incrementAndGet();
+            // Refresh TTL cache
+            cacheData.put(key, new CacheEntry(result, System.currentTimeMillis() + CACHE_DATA_TTL));
+            cacheDataExpiry.put(key, System.currentTimeMillis() + CACHE_DATA_TTL);
+        } else {
+            cacheMisses.incrementAndGet();
+        }
+        
+        long duration = System.nanoTime() - startTime;
+        totalCacheOperationTime.addAndGet(duration);
+        
+        log.info("Cache GET: " + key + " = " + result);
+        return result;
+    }
+
+    // O(1) Optimized remove operation with cache invalidation
+    public void remove(String key) {
+        long startTime = System.nanoTime();
+        
+        cacheRemovals.incrementAndGet();
+        totalCacheOperations.incrementAndGet();
+        
+        // Backend storage operation (O(1))
+        backendStorage.remove(key);
+        
+        // O(1) TTL cache removal
+        CacheEntry removed = cacheData.remove(key);
+        cacheDataExpiry.remove(key);
+        
+        if (removed != null) {
+            cacheDataDirty = true;
+            cacheStatsDirty = true;
+        }
+        
+        long duration = System.nanoTime() - startTime;
+        totalCacheOperationTime.addAndGet(duration);
+        
+        log.info("Cache REMOVE: " + key);
+    }
+
+    // O(1) Optimized info method with TTL caching
+    public String getInfo() {
+        String cacheKey = "cacheInfo";
+        
+        // O(1) Cache check
+        if (!cacheStatsDirty && isCacheValid(cacheKey, cacheStatsCache, cacheStatsExpiry)) {
+            String cached = (String) cacheStatsCache.get(cacheKey);
+            if (cached != null) return cached;
+        }
+        
+        StringBuilder info = new StringBuilder();
+        info.append("CacheManager with O(1) Optimizations - ");
+        info.append("Entries: ").append(cacheData.size());
+        info.append(" | Backend: InMemory");
+        info.append(" | Hit Rate: ").append(getHitRate()).append("%");
+        info.append(" | Operations: ").append(totalCacheOperations.get());
+        
+        String result = info.toString();
+        
+        // O(1) Cache storage
+        cacheStatsCache.put(cacheKey, result);
+        cacheStatsExpiry.put(cacheKey, System.currentTimeMillis() + CACHE_STATS_TTL);
+        cacheStatsDirty = false;
+        
+        return result;
+    }
+    
+    // O(1) Helper method for cache validation
+    private boolean isCacheValid(String key, Map<String, ?> cache, Map<String, Long> expiry) {
+        Long expireTime = expiry.get(key);
+        if (expireTime == null || System.currentTimeMillis() >= expireTime) {
+            // Cache expired - count as expiration and clean up
+            if (cache == cacheData) {
+                cacheExpirations.incrementAndGet();
+                cacheData.remove(key);
+                cacheDataExpiry.remove(key);
+            }
+            return false;
+        }
+        return true;
+    }
+    
+    // O(1) Cleanup expired entries
+    private void cleanupExpiredEntries() {
+        long currentTime = System.currentTimeMillis();
+        int expiredCount = 0;
+        
+        Iterator<Map.Entry<String, Long>> iterator = cacheDataExpiry.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<String, Long> entry = iterator.next();
+            if (currentTime >= entry.getValue()) {
+                cacheData.remove(entry.getKey());
+                iterator.remove();
+                expiredCount++;
+            }
+        }
+        
+        if (expiredCount > 0) {
+            cacheExpirations.addAndGet(expiredCount);
+            cacheDataDirty = true;
+            cacheStatsDirty = true;
+            log.info("Cache cleanup: " + expiredCount + " expired entries removed");
+        }
+    }
+    
+    // O(1) Atomic counter getters
+    public int getCachePuts() {
+        return cachePuts.get();
+    }
+    
+    public int getCacheGets() {
+        return cacheGets.get();
+    }
+    
+    public int getCacheHits() {
+        return cacheHits.get();
+    }
+    
+    public int getCacheMisses() {
+        return cacheMisses.get();
+    }
+    
+    public int getCacheRemovals() {
+        return cacheRemovals.get();
+    }
+    
+    public int getCacheExpirations() {
+        return cacheExpirations.get();
+    }
+    
+    public long getTotalCacheOperations() {
+        return totalCacheOperations.get();
+    }
+    
+    // O(1) Performance metrics
+    public double getHitRate() {
+        int total = cacheHits.get() + cacheMisses.get();
+        return total > 0 ? (double) cacheHits.get() / total * 100 : 0.0;
+    }
+    
+    public double getAverageOperationTime() {
+        long total = totalCacheOperations.get();
+        return total > 0 ? (double) totalCacheOperationTime.get() / total / 1_000_000.0 : 0.0; // milliseconds
+    }
+    
+    public long getUptime() {
+        return System.currentTimeMillis() - startTime;
+    }
+    
+    // O(1) Cache statistics
+    public Map<String, Object> getCacheStatistics() {
+        String cacheKey = "cacheStatistics";
+        
+        // O(1) Cache check
+        if (!cacheStatsDirty && isCacheValid(cacheKey, cacheStatsCache, cacheStatsExpiry)) {
+            @SuppressWarnings("unchecked")
+            Map<String, Object> cached = (Map<String, Object>) cacheStatsCache.get(cacheKey);
+            if (cached != null) return cached;
+        }
+        
+        Map<String, Object> stats = new HashMap<>();
+        stats.put("cachePuts", cachePuts.get());
+        stats.put("cacheGets", cacheGets.get());
+        stats.put("cacheHits", cacheHits.get());
+        stats.put("cacheMisses", cacheMisses.get());
+        stats.put("cacheRemovals", cacheRemovals.get());
+        stats.put("cacheExpirations", cacheExpirations.get());
+        stats.put("totalOperations", totalCacheOperations.get());
+        stats.put("hitRate", getHitRate());
+        stats.put("averageOperationTimeMs", getAverageOperationTime());
+        stats.put("uptimeMs", getUptime());
+        stats.put("currentCacheSize", cacheData.size());
+        stats.put("backendCacheType", "InMemory");
+        
+        // O(1) Cache storage
+        cacheStatsCache.put(cacheKey, stats);
+        cacheStatsExpiry.put(cacheKey, System.currentTimeMillis() + CACHE_STATS_TTL);
+        cacheStatsDirty = false;
+        
+        return stats;
+    }
+    
+    // O(1) Force cache invalidation
+    public void clearAllCaches() {
+        cacheData.clear();
+        cacheDataExpiry.clear();
+        cacheStatsCache.clear();
+        cacheStatsExpiry.clear();
+        
+        cacheDataDirty = false;
+        cacheStatsDirty = false;
+        
+        log.info("All caches cleared");
+    }
+    
+    // O(1) Force refresh all cached data
+    public void refreshCache() {
+        clearAllCaches();
+        // Optionally clear backend cache
+        // This would need to be implemented in the backend cache service
+    }
+    
+    // Internal CacheEntry class
+    private static class CacheEntry {
+        final Object value;
+        final long expiryTime;
+        
+        CacheEntry(Object value, long expiryTime) {
+            this.value = value;
+            this.expiryTime = expiryTime;
+        }
+        
+        boolean isExpired() {
+            return System.currentTimeMillis() >= expiryTime;
+        }
+    }
+}