all done

Author: AhmedAbdelRaheem1

fallback/etc/fallback.urm.png

@@ -1,112 +1,173 @@
 @startuml
-package com.iluwatar {
+package fallback {
   class App {
     - TIMEOUT : int {static}
+    - MAX_ATTEMPTS : int {static}
+    - RETRY_DELAY : int {static}
+    - DEFAULT_API_URL : String {static}
     - circuitBreaker : CircuitBreaker
     - executor : ExecutorService
     - fallbackService : Service
     - primaryService : Service
+    - state : ExecutionState
     - LOGGER : Logger {static}
     + App()
-    + App(primaryService : Service, fallbackService : Service)
+    + App(primaryService : Service, fallbackService : Service, circuitBreaker : CircuitBreaker)
     + executeWithFallback() : String
     - getFallbackData() : String
-    + main(args : String[]) {static}
+    - updateFallbackCache(result : String)
     + shutdown()
+    + main(args : String[]) {static}
   }
 
   interface Service {
-    + getData() : String {abstract}
+    + getData() : String
   }
 
   interface CircuitBreaker {
-    + isOpen() : boolean {abstract}
-    + recordFailure() {abstract}
-    + recordSuccess() {abstract}
-    + reset() {abstract}
+    + isOpen() : boolean
+    + allowRequest() : boolean
+    + recordFailure()
+    + recordSuccess()
+    + reset()
+    + getState() : CircuitState
   }
 
   class DefaultCircuitBreaker {
     - RESET_TIMEOUT : long {static}
-    - failureCount : int
+    - MIN_HALF_OPEN_DURATION : Duration {static}
+    - state : State
     - failureThreshold : int
     - lastFailureTime : long
-    - state : State
+    - failureTimestamps : Queue<Long>
+    - windowSize : Duration
+    - halfOpenStartTime : Instant
     + DefaultCircuitBreaker(failureThreshold : int)
     + isOpen() : boolean
+    + allowRequest() : boolean
     + recordFailure()
     + recordSuccess()
     + reset()
-    - enum State
+    + getState() : CircuitState
+    - transitionToHalfOpen()
+    - enum State { CLOSED, OPEN, HALF_OPEN }
   }
 
   class FallbackService {
-    - MAX_RETRIES : int {static}
-    - RETRY_DELAY_MS : int {static}
-    - TIMEOUT_MS : int {static}
-    - MAX_REQUESTS_PER_MINUTE : int {static}
-    - LOGGER : Logger {static}
+    - {static} MAX_RETRIES : int = 3
+    - {static} RETRY_DELAY_MS : long = 1000
+    - {static} TIMEOUT : int = 2
+    - {static} MIN_SUCCESS_RATE : double = 0.6
+    - {static} MAX_REQUESTS_PER_MINUTE : int = 60
+    - {static} LOGGER : Logger
     - primaryService : Service
     - fallbackService : Service
     - circuitBreaker : CircuitBreaker
     - executor : ExecutorService
     - healthChecker : ScheduledExecutorService
     - monitor : ServiceMonitor
     - rateLimiter : RateLimiter
-    - closed : boolean
+    - state : ServiceState
     + FallbackService(primaryService : Service, fallbackService : Service, circuitBreaker : CircuitBreaker)
     + getData() : String
     - executeWithTimeout(task : Callable<String>) : String
     - executeFallback() : String
     - updateFallbackCache(result : String)
     - startHealthChecker()
     + close()
+    + getMonitor() : ServiceMonitor
+    + getState() : ServiceState
+    - enum ServiceState { STARTING, RUNNING, DEGRADED, CLOSED }
   }
 
   class LocalCacheService {
-    - cache : Cache
+    - cache : Cache<String, String>
+    - refreshExecutor : ScheduledExecutorService
+    - {static} CACHE_EXPIRY_MS : long = 300000
+    - {static} CACHE_REFRESH_INTERVAL : Duration = Duration.ofMinutes(5)
+    - {static} LOGGER : Logger
     + LocalCacheService()
     + getData() : String
     + updateCache(key : String, value : String)
-    - class Cache
-    - class CacheEntry
-  }
+    + close() : void
+    - initializeDefaultCache()
+    - scheduleMaintenanceTasks()
+    - cleanupExpiredEntries()
+    - enum FallbackLevel { PRIMARY, SECONDARY, TERTIARY }
+    - class Cache<K, V> {
+      - map : ConcurrentHashMap<K, CacheEntry<V>>
+      - expiryMs : long
+      + Cache(expiryMs : long)
+      + get(key : K) : V
+      + put(key : K, value : V)
+      + cleanup()
+      - record CacheEntry<V>(value : V, expiryTime : long) { + isExpired() : boolean }
+    }
+
 
   class RemoteService {
-    - HTTP_OK : int {static}
-    - client : HttpClient
-    - serviceUrl : String
-    + RemoteService(serviceUrl : String)
+    - apiUrl : String
+    - httpClient : HttpClient
+    - {static} TIMEOUT_SECONDS : int = 2
+    + RemoteService(apiUrl : String, httpClient : HttpClient)
     + getData() : String
   }
 
   class ServiceMonitor {
+    - successCount : AtomicInteger
+    - fallbackCount : AtomicInteger
+    - errorCount : AtomicInteger
+    - lastSuccessTime : AtomicReference<Instant>
+    - lastFailureTime : AtomicReference<Instant>
+    - lastResponseTime : AtomicReference<Duration>
     - metrics : Queue<ServiceMetric>
+    - fallbackWeight : double
+    - metricWindow : Duration
+    + ServiceMonitor()
+    + ServiceMonitor(fallbackWeight : double, metricWindow : Duration)
     + recordSuccess(responseTime : Duration)
-    + recordError()
     + recordFallback()
-    + getMetrics() : List<ServiceMetric>
-    - class ServiceMetric
-    - enum MetricType
+    + recordError()
+    + getSuccessCount() : int
+    + getFallbackCount() : int
+    + getErrorCount() : int
+    + getLastSuccessTime() : Instant
+    + getLastFailureTime() : Instant
+    + getLastResponseTime() : Duration
+    + getSuccessRate() : double
+    + reset()
+    - pruneOldMetrics()
+    - record ServiceMetric(timestamp : Instant, type : MetricType, responseTime : Duration)
+    - enum MetricType { SUCCESS, FALLBACK, ERROR }
+  }
+
+  class RateLimiter {
+    - maxRequests : int
+    - window : Duration
+    - requestTimestamps : Queue<Long>
+    + RateLimiter(maxRequests : int, window : Duration)
+    + tryAcquire() : boolean
   }
 
   class ServiceException {
     + ServiceException(message : String)
+    + ServiceException(message : String, cause : Throwable)
   }
-
+}
   ' Relationships
-  App -->  "-circuitBreaker" CircuitBreaker
-  App -->  "-primaryService" Service
-  App -->  "-fallbackService" Service
+  App --> CircuitBreaker
+  App --> Service : primaryService
+  App --> Service : fallbackService
   DefaultCircuitBreaker ..|> CircuitBreaker 
   LocalCacheService ..|> Service 
   RemoteService ..|> Service 
   FallbackService ..|> Service
   FallbackService ..|> AutoCloseable
-  FallbackService --> "-primaryService" Service
-  FallbackService --> "-fallbackService" Service
-  FallbackService --> "-circuitBreaker" CircuitBreaker
-  FallbackService --> "-monitor" ServiceMonitor
+  FallbackService --> Service : primaryService
+  FallbackService --> Service : fallbackService
+  FallbackService --> CircuitBreaker
+  FallbackService --> ServiceMonitor
+  FallbackService --> RateLimiter
   ServiceException --|> Exception
 }
 @enduml

fallback/etc/fallback.urm.puml

@@ -0,0 +1,34 @@
+# Java Design Patterns - Fallback Pattern
+
+## Overview
+
+This project demonstrates the implementation of the Fallback Pattern with Circuit Breaker in Java. The Fallback Pattern is used to handle failures gracefully by providing alternative solutions when the primary service fails. The Circuit Breaker pattern is integrated to prevent cascading failures and to monitor the health of the primary service.
+
+## Features
+
+- **Primary Service**: The main service that attempts to retrieve data.
+- **Fallback Service**: A backup service that provides data when the primary service fails.
+- **Circuit Breaker**: Monitors the health of the primary service and prevents further calls when the service is deemed unhealthy.
+- **Service Monitor**: Tracks the performance metrics of the services.
+- **Rate Limiter**: Limits the number of requests to prevent overload.
+- **Service Exception**: Custom exceptions to handle service-specific errors.
+
+## Components
+
+- **Service Interface**: Defines the contract for services.
+- **RemoteService**: Implementation of the primary service that makes HTTP calls.
+- **LocalCacheService**: Implementation of the fallback service that provides cached data.
+- **FallbackService**: Manages the primary and fallback services, integrating the circuit breaker and rate limiter.
+- **DefaultCircuitBreaker**: Implementation of the circuit breaker with state transitions and failure tracking.
+- **ServiceMonitor**: Monitors and records the performance metrics of the services.
+- **Service Exception**: Custom exception class to handle errors specific to service operations.
+
+## Usage
+
+To run the application, execute the `App` class. The application will attempt to retrieve data using the primary service and fallback to the cached data if the primary service fails.
+
+## Reflection
+
+This assignment provided a practical application of Object-Oriented Analysis and Design (OOAD) principles. By implementing the Fallback Pattern with Circuit Breaker, I was able to apply concepts such as encapsulation, polymorphism, and separation of concerns. Each component in the system has a clear responsibility, and the use of interfaces allows for flexibility and easy substitution of different implementations.
+
+One of the challenges faced was ensuring thread safety and proper synchronization, especially in the circuit breaker and rate limiter components. To overcome this, I used concurrent data structures and synchronized methods to manage state transitions and request handling. Additionally, integrating the health monitoring and metrics collection required careful consideration of performance and resource management, which was addressed by using scheduled executors and atomic variables.

fallback/readme.md

@@ -1,4 +1,4 @@
-package com.iluwatar;
+package com.iluwatar.fallback;
 
 import java.net.http.HttpClient;
 import java.time.Duration;

fallback/src/main/java/com/iluwatar/App.java renamed to fallback/src/main/java/com/iluwatar/fallback/App.java

@@ -22,7 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-package com.iluwatar;
+package com.iluwatar.fallback;
 
 /**
  * Interface defining the contract for a circuit breaker implementation.

fallback/src/main/java/com/iluwatar/CircuitBreaker.java renamed to fallback/src/main/java/com/iluwatar/fallback/CircuitBreaker.java

@@ -22,7 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-package com.iluwatar;
+package com.iluwatar.fallback;
 
 import java.time.Duration;
 import java.time.Instant;
@@ -76,14 +76,30 @@ public DefaultCircuitBreaker(final int failureThreshold) {
    */
   @Override
   public synchronized boolean allowRequest() {
-    checkAndTransitionState();
-    return state != State.OPEN;
+    if (state == State.CLOSED) {
+      return true;
+    }
+    if (state == State.OPEN) {
+      if (System.currentTimeMillis() - lastFailureTime > RESET_TIMEOUT) {
+        transitionToHalfOpen();
+        return true;
+      }
+      return false;
+    }
+    // In HALF_OPEN state, allow limited testing
+    return true;
   }
 
   @Override
   public synchronized boolean isOpen() {
-    checkAndTransitionState();
-    return state == State.OPEN;
+    if (state == State.OPEN) {
+      if (System.currentTimeMillis() - lastFailureTime > RESET_TIMEOUT) {
+        transitionToHalfOpen();
+        return false;
+      }
+      return true;
+    }
+    return false;
   }
 
   /**
@@ -144,23 +160,16 @@ public void reset() {
    */
   @Override
   public synchronized CircuitState getState() {
-    checkAndTransitionState();
+    if (state == State.OPEN && System.currentTimeMillis() - lastFailureTime > RESET_TIMEOUT) {
+      transitionToHalfOpen();
+    }
     return switch (state) {
       case CLOSED -> CircuitState.CLOSED;
       case OPEN -> CircuitState.OPEN;
       case HALF_OPEN -> CircuitState.HALF_OPEN;
     };
   }
 
-  /**
-   * Checks if state transition is needed and performs it if necessary.
-   */
-  private void checkAndTransitionState() {
-    if (state == State.OPEN && System.currentTimeMillis() - lastFailureTime > RESET_TIMEOUT) {
-      transitionToHalfOpen();
-    }
-  }
-
   /**
    * Internal states of the circuit breaker.
    * Maps to the public CircuitState enum for external reporting.

fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java renamed to fallback/src/main/java/com/iluwatar/fallback/DefaultCircuitBreaker.java

@@ -22,7 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-package com.iluwatar;
+package com.iluwatar.fallback;
 
 import java.time.Duration;
 import java.time.Instant;

fallback/src/main/java/com/iluwatar/FallbackService.java renamed to fallback/src/main/java/com/iluwatar/fallback/FallbackService.java

@@ -22,7 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-package com.iluwatar;
+package com.iluwatar.fallback;
 
 import ch.qos.logback.classic.Logger;
 import java.time.Duration;

fallback/src/main/java/com/iluwatar/LocalCacheService.java renamed to fallback/src/main/java/com/iluwatar/fallback/LocalCacheService.java

@@ -22,7 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-package com.iluwatar;
+package com.iluwatar.fallback;
 
 import java.net.URI;
 import java.net.http.HttpClient;

fallback/src/main/java/com/iluwatar/RemoteService.java renamed to fallback/src/main/java/com/iluwatar/fallback/RemoteService.java

@@ -22,7 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-package com.iluwatar;
+package com.iluwatar.fallback;
 
 /**
  * Service interface that defines a method to retrieve data.