From 3fba38126ea1bbe7538293e5fbc51551e17f0dc6 Mon Sep 17 00:00:00 2001 From: Ahmed Abdelraheem Date: Sun, 8 Dec 2024 23:57:59 +0200 Subject: [PATCH 1/4] dev is done, tests are not. --- fallback/etc/fallback.urm.puml | 57 ++ fallback/pom.xml | 71 ++ fallback/src/main/java/com/iluwatar/App.java | 154 +++ .../java/com/iluwatar/CircuitBreaker.java | 53 ++ .../com/iluwatar/DefaultCircuitBreaker.java | 101 ++ .../java/com/iluwatar/FallbackService.java | 229 +++++ .../java/com/iluwatar/LocalCacheService.java | 97 ++ .../main/java/com/iluwatar/RemoteService.java | 63 ++ .../src/main/java/com/iluwatar/Service.java | 38 + .../java/com/iluwatar/ServiceException.java | 19 + .../java/com/iluwatar/ServiceMonitor.java | 122 +++ .../iluwatar/DefaultCircuitBreakerTest.java | 74 ++ .../com/iluwatar/FallbackServiceTest.java | 369 ++++++++ .../java/com/iluwatar/IntegrationTest.java | 320 +++++++ .../java/com/iluwatar/ServiceMonitorTest.java | 109 +++ pom.xml | 873 +++++++++--------- 16 files changed, 2313 insertions(+), 436 deletions(-) create mode 100644 fallback/etc/fallback.urm.puml create mode 100644 fallback/pom.xml create mode 100644 fallback/src/main/java/com/iluwatar/App.java create mode 100644 fallback/src/main/java/com/iluwatar/CircuitBreaker.java create mode 100644 fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java create mode 100644 fallback/src/main/java/com/iluwatar/FallbackService.java create mode 100644 fallback/src/main/java/com/iluwatar/LocalCacheService.java create mode 100644 fallback/src/main/java/com/iluwatar/RemoteService.java create mode 100644 fallback/src/main/java/com/iluwatar/Service.java create mode 100644 fallback/src/main/java/com/iluwatar/ServiceException.java create mode 100644 fallback/src/main/java/com/iluwatar/ServiceMonitor.java create mode 100644 fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java create mode 100644 fallback/src/test/java/com/iluwatar/FallbackServiceTest.java create mode 100644 fallback/src/test/java/com/iluwatar/IntegrationTest.java create mode 100644 fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java diff --git a/fallback/etc/fallback.urm.puml b/fallback/etc/fallback.urm.puml new file mode 100644 index 000000000000..28315a58ebe3 --- /dev/null +++ b/fallback/etc/fallback.urm.puml @@ -0,0 +1,57 @@ +@startuml +package com.iluwatar { + class App { + - MAX_ATTEMPTS : int {static} + - RETRY_DELAY : int {static} + - TIMEOUT : int {static} + - circuitBreaker : CircuitBreaker + - executor : ExecutorService + - fallbackService : Service + - primaryService : Service + + App() + + App(primaryService : Service, fallbackService : Service) + + executeWithFallback() : String + - getFallbackData() : String + + main(args : String[]) {static} + + shutdown() + } + interface CircuitBreaker { + + isOpen() : boolean {abstract} + + recordFailure() {abstract} + + recordSuccess() {abstract} + + reset() {abstract} + } + class DefaultCircuitBreaker { + - RESET_TIMEOUT : long {static} + - failureCount : int + - failureThreshold : int + - lastFailureTime : long + + DefaultCircuitBreaker(failureThreshold : int) + + isOpen() : boolean + + recordFailure() + + recordSuccess() + + reset() + } + class LocalCacheService { + - cache : ConcurrentHashMap + + LocalCacheService() + + getData() : String + + updateCache(key : String, value : String) + } + class RemoteService { + - HTTP_OK : int {static} + - client : HttpClient + - serviceUrl : String + + RemoteService(serviceUrl : String) + + getData() : String + } + interface Service { + + getData() : String {abstract} + } +} +App --> "-circuitBreaker" CircuitBreaker +App --> "-primaryService" Service +DefaultCircuitBreaker ..|> CircuitBreaker +LocalCacheService ..|> Service +RemoteService ..|> Service +@enduml \ No newline at end of file diff --git a/fallback/pom.xml b/fallback/pom.xml new file mode 100644 index 000000000000..9d9fdaf5fce3 --- /dev/null +++ b/fallback/pom.xml @@ -0,0 +1,71 @@ + + + + 4.0.0 + + com.iluwatar + java-design-patterns + 1.26.0-SNAPSHOT + + + fallback + + + 17 + 17 + UTF-8 + + + + org.junit.jupiter + junit-jupiter-engine + 5.8.2 + test + + + org.junit.jupiter + junit-jupiter-api + 5.8.2 + test + + + org.junit.jupiter + junit-jupiter + 5.8.2 + test + + + org.mockito + mockito-core + 4.5.1 + test + + + \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/App.java b/fallback/src/main/java/com/iluwatar/App.java new file mode 100644 index 000000000000..36b38efe4fe8 --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/App.java @@ -0,0 +1,154 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import java.net.http.HttpClient; +import java.time.Duration; // Add this import +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.logging.Logger; + +/** + * App class that demonstrates the use of Circuit Breaker pattern with fallback mechanism. + */ +public class App { + private static final Logger LOGGER = Logger.getLogger(App.class.getName()); + private static final int TIMEOUT = 2; + private static final int MAX_ATTEMPTS = 3; + private static final int RETRY_DELAY = 1000; + private static final String DEFAULT_API_URL = "https://jsonplaceholder.typicode.com/todos"; + + private final CircuitBreaker circuitBreaker; + private final ExecutorService executor; + private final Service primaryService; + private final Service fallbackService; + + /** + * Constructs an App with default primary and fallback services. + */ + public App() { + HttpClient httpClient; + try { + httpClient = HttpClient.newBuilder() + .connectTimeout(Duration.ofSeconds(TIMEOUT)) + .build(); + } catch (Exception e) { + LOGGER.severe("Failed to create HTTP client: " + e.getMessage()); + httpClient = HttpClient.newHttpClient(); // Fallback to default client + } + + this.primaryService = new RemoteService(DEFAULT_API_URL, httpClient); + this.fallbackService = new LocalCacheService(); + this.circuitBreaker = new DefaultCircuitBreaker(MAX_ATTEMPTS); + this.executor = Executors.newSingleThreadExecutor(); + } + + /** + * Constructs an App with the specified primary and fallback services and a circuit breaker. + * + * @param primaryService the primary service to use + * @param fallbackService the fallback service to use + * @param circuitBreaker the circuit breaker to use + */ + public App(final Service primaryService, final Service fallbackService, final CircuitBreaker circuitBreaker) { + this.circuitBreaker = circuitBreaker; + this.executor = Executors.newSingleThreadExecutor(); + this.primaryService = primaryService; + this.fallbackService = fallbackService; + } + + /** + * Main method to run the application. + * + * @param args command line arguments + */ + public static void main(final String[] args) { + App app = new App(); + for (int i = 0; i < 5; i++) { + try { + String result = app.executeWithFallback(); + System.out.println("Attempt " + (i + 1) + ": Result = " + result); + } catch (Exception e) { + System.err.println("Attempt " + (i + 1) + " failed: " + e.getMessage()); + } + try { + Thread.sleep(RETRY_DELAY); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + System.err.println("Thread was interrupted: " + e.getMessage()); + } + } + app.shutdown(); + } + + /** + * Executes the primary service with a fallback mechanism. + * + * @return the result from the primary or fallback service + */ + public String executeWithFallback() { + if (circuitBreaker.isOpen()) { + LOGGER.info("Circuit breaker is open, using cached data"); + return getFallbackData(); + } + + try { + Future future = executor.submit(primaryService::getData); + String result = future.get(TIMEOUT, TimeUnit.SECONDS); + circuitBreaker.recordSuccess(); + if (fallbackService instanceof LocalCacheService) { + ((LocalCacheService) fallbackService).updateCache("default", result); + } + return result; + } catch (Exception e) { + LOGGER.warning("Primary service failed, using fallback. Exception: " + e.getMessage()); + circuitBreaker.recordFailure(); + return getFallbackData(); + } + } + + /** + * Retrieves data from the fallback service. + * + * @return the data from the fallback service + */ + private String getFallbackData() { + try { + return fallbackService.getData(); + } catch (Exception e) { + LOGGER.warning("Fallback service failed. Exception: " + e.getMessage()); + return "System is currently unavailable"; + } + } + + /** + * Shuts down the executor service. + */ + public void shutdown() { + executor.shutdown(); + } +} \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/CircuitBreaker.java b/fallback/src/main/java/com/iluwatar/CircuitBreaker.java new file mode 100644 index 000000000000..e75617ed498d --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/CircuitBreaker.java @@ -0,0 +1,53 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +/** + * CircuitBreaker interface that defines methods to manage the state of a circuit breaker. + */ +public interface CircuitBreaker { + + /** + * Checks if the circuit breaker is open. + * + * @return true if the circuit breaker is open, false otherwise + */ + boolean isOpen(); + + /** + * Records a successful operation. + */ + void recordSuccess(); + + /** + * Records a failed operation. + */ + void recordFailure(); + + /** + * Resets the circuit breaker. + */ + void reset(); +} \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java b/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java new file mode 100644 index 000000000000..083f406b95e7 --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java @@ -0,0 +1,101 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import java.time.Duration; +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedQueue; + +/** + * DefaultCircuitBreaker class that implements the CircuitBreaker interface. + * It manages the state of a circuit breaker with a failure threshold and reset timeout. + */ +public final class DefaultCircuitBreaker implements CircuitBreaker { + private final int failureThreshold; + private long lastFailureTime; + private State state; + private static final long RESET_TIMEOUT = 5000; + private final Queue failureTimestamps; + private final Duration windowSize; + + /** + * Constructs a DefaultCircuitBreaker with the given failure threshold. + * + * @param failureThreshold the number of failures to trigger the circuit breaker + */ + public DefaultCircuitBreaker(final int failureThreshold) { + this.failureThreshold = failureThreshold; + this.state = State.CLOSED; + this.failureTimestamps = new ConcurrentLinkedQueue<>(); + this.windowSize = Duration.ofMinutes(1); + } + + @Override + public boolean isOpen() { + if (state == State.OPEN) { + if (System.currentTimeMillis() - lastFailureTime > RESET_TIMEOUT) { + state = State.HALF_OPEN; + return false; + } + return true; + } + return false; + } + + @Override + public void recordSuccess() { + failureTimestamps.clear(); + state = State.CLOSED; + } + + @Override + public void recordFailure() { + long now = System.currentTimeMillis(); + failureTimestamps.offer(now); + + while (!failureTimestamps.isEmpty() + && failureTimestamps.peek() < now - windowSize.toMillis()) { + failureTimestamps.poll(); + } + + if (failureTimestamps.size() >= failureThreshold) { + state = State.OPEN; + lastFailureTime = now; + } + } + + @Override + public void reset() { + failureTimestamps.clear(); + lastFailureTime = 0; + state = State.CLOSED; + } + + private enum State { + CLOSED, + OPEN, + HALF_OPEN + } +} \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/FallbackService.java b/fallback/src/main/java/com/iluwatar/FallbackService.java new file mode 100644 index 000000000000..fe44fbf5b90d --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/FallbackService.java @@ -0,0 +1,229 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import java.time.Duration; +import java.time.Instant; +import java.util.Queue; +import java.util.concurrent.Callable; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.logging.Logger; + +/** + * FallbackService class that implements the fallback pattern. + */ +public class FallbackService implements Service, AutoCloseable { + private static final Logger LOGGER = Logger.getLogger(FallbackService.class.getName()); + private static final int TIMEOUT = 2; + private static final int MAX_RETRIES = 3; + private static final long RETRY_DELAY_MS = 1000; + private static final double MIN_SUCCESS_RATE = 0.6; + private static final int MAX_REQUESTS_PER_MINUTE = 60; + + private final CircuitBreaker circuitBreaker; + private final ExecutorService executor; + private final Service primaryService; + private final Service fallbackService; + private final ServiceMonitor monitor; + private final ScheduledExecutorService healthChecker; + private final RateLimiter rateLimiter; + private volatile boolean closed = false; + + /** + * Constructs a FallbackService with the specified primary and fallback services and a circuit breaker. + * + * @param primaryService the primary service to use + * @param fallbackService the fallback service to use + * @param circuitBreaker the circuit breaker to use + */ + public FallbackService(Service primaryService, Service fallbackService, CircuitBreaker circuitBreaker) { + this.primaryService = primaryService; + this.fallbackService = fallbackService; + this.circuitBreaker = circuitBreaker; + this.executor = Executors.newCachedThreadPool(); + this.monitor = new ServiceMonitor(); + this.healthChecker = Executors.newSingleThreadScheduledExecutor(); + this.rateLimiter = new RateLimiter(MAX_REQUESTS_PER_MINUTE, Duration.ofMinutes(1)); + + startHealthChecker(); + } + + private void startHealthChecker() { + healthChecker.scheduleAtFixedRate(() -> { + try { + if (monitor.getSuccessRate() < MIN_SUCCESS_RATE) { + LOGGER.warning("Success rate below threshold: " + monitor.getSuccessRate()); + } + if (Duration.between(monitor.getLastSuccessTime(), Instant.now()).toMinutes() > 5) { + LOGGER.warning("No successful requests in last 5 minutes"); + } + } catch (Exception e) { + LOGGER.severe("Health check failed: " + e.getMessage()); + } + }, 1, 1, TimeUnit.MINUTES); + } + + /** + * Retrieves data from the primary service with a fallback mechanism. + * + * @return the data from the primary or fallback service + * @throws Exception if an error occurs while retrieving the data + */ + @Override + public String getData() throws Exception { + if (closed) { + throw new ServiceException("Service is closed"); + } + + if (!rateLimiter.tryAcquire()) { + monitor.recordFallback(); + return executeFallback(); + } + + if (circuitBreaker.isOpen()) { + LOGGER.info("Circuit breaker is open, using fallback"); + monitor.recordFallback(); + return executeFallback(); + } + + Instant start = Instant.now(); + Exception lastException = null; + + for (int attempt = 0; attempt < MAX_RETRIES; attempt++) { + try { + String result = executeWithTimeout(primaryService::getData); + Duration responseTime = Duration.between(start, Instant.now()); + + circuitBreaker.recordSuccess(); + monitor.recordSuccess(responseTime); + updateFallbackCache(result); + + return result; + } catch (Exception e) { + lastException = e; + LOGGER.warning("Attempt " + (attempt + 1) + " failed: " + e.getMessage()); + circuitBreaker.recordFailure(); + monitor.recordError(); + + if (attempt < MAX_RETRIES - 1) { + Thread.sleep(RETRY_DELAY_MS * (attempt + 1)); // Exponential backoff + } + } + } + + monitor.recordFallback(); + if (lastException != null) { + LOGGER.severe("All attempts failed. Last error: " + lastException.getMessage()); + } + return executeFallback(); + } + + private String executeWithTimeout(Callable task) throws Exception { + Future future = executor.submit(task); + try { + return future.get(TIMEOUT, TimeUnit.SECONDS); + } catch (TimeoutException e) { + future.cancel(true); + throw new ServiceException("Service timeout after " + TIMEOUT + " seconds", e); + } + } + + private String executeFallback() { + try { + return fallbackService.getData(); + } catch (Exception e) { + LOGGER.severe("Fallback service failed: " + e.getMessage()); + return "Service temporarily unavailable"; + } + } + + private void updateFallbackCache(String result) { + try { + if (fallbackService instanceof LocalCacheService) { + ((LocalCacheService) fallbackService).updateCache("default", result); + } + } catch (Exception e) { + LOGGER.warning("Failed to update fallback cache: " + e.getMessage()); + } + } + + /** + * Shuts down the executor service. + */ + @Override + public void close() { + closed = true; + executor.shutdown(); + healthChecker.shutdown(); + try { + if (!executor.awaitTermination(5, TimeUnit.SECONDS)) { + executor.shutdownNow(); + } + if (!healthChecker.awaitTermination(5, TimeUnit.SECONDS)) { + healthChecker.shutdownNow(); + } + } catch (InterruptedException e) { + executor.shutdownNow(); + healthChecker.shutdownNow(); + Thread.currentThread().interrupt(); + } + } + + public ServiceMonitor getMonitor() { + return monitor; + } + + private static class RateLimiter { + private final int maxRequests; + private final Duration window; + private final Queue requestTimestamps = new ConcurrentLinkedQueue<>(); + + RateLimiter(int maxRequests, Duration window) { + this.maxRequests = maxRequests; + this.window = window; + } + + boolean tryAcquire() { + long now = System.currentTimeMillis(); + long windowStart = now - window.toMillis(); + + // Remove expired timestamps + while (!requestTimestamps.isEmpty() && requestTimestamps.peek() < windowStart) { + requestTimestamps.poll(); + } + + if (requestTimestamps.size() < maxRequests) { + requestTimestamps.offer(now); + return true; + } + return false; + } + } +} \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/LocalCacheService.java b/fallback/src/main/java/com/iluwatar/LocalCacheService.java new file mode 100644 index 000000000000..59cedc70490b --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/LocalCacheService.java @@ -0,0 +1,97 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import java.util.concurrent.ConcurrentHashMap; // Add this import + +/** + * LocalCacheService implementation that provides cached data as a fallback mechanism. + * This service stores and retrieves data from a local cache with expiration support. + */ +public class LocalCacheService implements Service { + private final Cache cache; + private static final long CACHE_EXPIRY_MS = 300000; // 5 minutes + + private static final String[] DEFAULT_KEYS = {"default", "backup1", "backup2"}; + private static final String[] DEFAULT_VALUES = { + "Default fallback response", + "Secondary fallback response", + "Tertiary fallback response" + }; + + public LocalCacheService() { + this.cache = new Cache<>(CACHE_EXPIRY_MS); + initializeDefaultCache(); + } + + private void initializeDefaultCache() { + for (int i = 0; i < DEFAULT_KEYS.length; i++) { + cache.put(DEFAULT_KEYS[i], DEFAULT_VALUES[i]); + } + } + + @Override + public String getData() throws Exception { + // Try all cache entries in order until a valid one is found + for (String key : DEFAULT_KEYS) { + String value = cache.get(key); + if (value != null) { + return value; + } + } + throw new Exception("No valid cache entry found"); + } + + public void updateCache(String key, String value) { + cache.put(key, value); + } + + private static class Cache { + private final ConcurrentHashMap> map = new ConcurrentHashMap<>(); + private final long expiryMs; + + Cache(long expiryMs) { + this.expiryMs = expiryMs; + } + + V get(K key) { + CacheEntry entry = map.get(key); + if (entry != null && !entry.isExpired()) { + return entry.value; + } + return null; + } + + void put(K key, V value) { + map.put(key, new CacheEntry<>(value, System.currentTimeMillis() + expiryMs)); + } + + private record CacheEntry(V value, long expiryTime) { + boolean isExpired() { + return System.currentTimeMillis() > expiryTime; + } + } + } +} \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/RemoteService.java b/fallback/src/main/java/com/iluwatar/RemoteService.java new file mode 100644 index 000000000000..6794bac6d902 --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/RemoteService.java @@ -0,0 +1,63 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.time.Duration; + +/** + * RemoteService implementation that makes HTTP calls to an external API. + * This service acts as the primary service in the fallback pattern. + */ +public class RemoteService implements Service { + private final String apiUrl; + private final HttpClient httpClient; + private static final int TIMEOUT_SECONDS = 2; + + public RemoteService(String apiUrl, HttpClient httpClient) { + this.apiUrl = apiUrl; + this.httpClient = httpClient; + } + + @Override + public String getData() throws Exception { + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create(apiUrl)) + .timeout(Duration.ofSeconds(TIMEOUT_SECONDS)) + .GET() + .build(); + + HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); + + if (response.statusCode() != 200) { + throw new Exception("Remote service failed with status code: " + response.statusCode()); + } + + return response.body(); + } +} diff --git a/fallback/src/main/java/com/iluwatar/Service.java b/fallback/src/main/java/com/iluwatar/Service.java new file mode 100644 index 000000000000..994045fc3480 --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/Service.java @@ -0,0 +1,38 @@ +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +/** + * Service interface that defines a method to retrieve data. + */ +public interface Service { + /** + * Retrieves data. + * + * @return the data + * @throws Exception if an error occurs while retrieving the data + */ + String getData() throws Exception; +} \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/ServiceException.java b/fallback/src/main/java/com/iluwatar/ServiceException.java new file mode 100644 index 000000000000..7001c1b0eb9f --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/ServiceException.java @@ -0,0 +1,19 @@ +package com.iluwatar; + +import java.io.Serial; + +/** + * Custom exception class for service-related errors in the fallback pattern. + */ +public class ServiceException extends Exception { + @Serial + private static final long serialVersionUID = 1L; + + public ServiceException(String message) { + super(message); + } + + public ServiceException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/fallback/src/main/java/com/iluwatar/ServiceMonitor.java b/fallback/src/main/java/com/iluwatar/ServiceMonitor.java new file mode 100644 index 000000000000..bb9827f335a9 --- /dev/null +++ b/fallback/src/main/java/com/iluwatar/ServiceMonitor.java @@ -0,0 +1,122 @@ +package com.iluwatar; + +import java.time.Duration; +import java.time.Instant; +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + +/** + * ServiceMonitor class provides monitoring capabilities for tracking service performance metrics. + * It maintains thread-safe counters for success, fallback, and error rates, as well as timing information. + */ +public class ServiceMonitor { + private final AtomicInteger successCount = new AtomicInteger(0); + private final AtomicInteger fallbackCount = new AtomicInteger(0); + private final AtomicInteger errorCount = new AtomicInteger(0); + private final AtomicReference lastSuccessTime = new AtomicReference<>(Instant.now()); + private final AtomicReference lastFailureTime = new AtomicReference<>(Instant.now()); + private final AtomicReference lastResponseTime = new AtomicReference<>(Duration.ZERO); + + // Add sliding window for metrics + private final Queue metrics = new ConcurrentLinkedQueue<>(); + private final Duration metricWindow = Duration.ofMinutes(5); + + private record ServiceMetric(Instant timestamp, MetricType type, Duration responseTime) {} + private enum MetricType { SUCCESS, FALLBACK, ERROR } + + /** + * Records a successful service operation with its response time. + * + * @param responseTime the duration of the successful operation + */ + public void recordSuccess(Duration responseTime) { + successCount.incrementAndGet(); + lastSuccessTime.set(Instant.now()); + lastResponseTime.set(responseTime); + metrics.offer(new ServiceMetric(Instant.now(), MetricType.SUCCESS, responseTime)); + pruneOldMetrics(); + } + + /** + * Records a fallback operation in the monitoring metrics. + * This method increments the fallback counter and adds a new metric to the sliding window. + */ + public void recordFallback() { + fallbackCount.incrementAndGet(); + lastFailureTime.set(Instant.now()); + metrics.offer(new ServiceMetric(Instant.now(), MetricType.FALLBACK, Duration.ZERO)); + pruneOldMetrics(); + } + + /** + * Records an error operation in the monitoring metrics. + * This method increments the error counter, updates the last failure time, + * and adds a new metric to the sliding window. + */ + public void recordError() { + errorCount.incrementAndGet(); + lastFailureTime.set(Instant.now()); + metrics.offer(new ServiceMetric(Instant.now(), MetricType.ERROR, Duration.ZERO)); + pruneOldMetrics(); + } + + public int getSuccessCount() { + return successCount.get(); + } + + public int getFallbackCount() { + return fallbackCount.get(); + } + + public int getErrorCount() { + return errorCount.get(); + } + + public Instant getLastSuccessTime() { + return lastSuccessTime.get(); + } + + public Instant getLastFailureTime() { + return lastFailureTime.get(); + } + + public Duration getLastResponseTime() { + return lastResponseTime.get(); + } + + /** + * Calculates the success rate of service operations. + * The rate is calculated as the ratio of successful operations to total operations, + * treating fallbacks as partial successes. + * + * @return the success rate as a double between 0.0 and 1.0 + */ + public double getSuccessRate() { + int total = successCount.get() + errorCount.get(); + if (total == 0) { + return 1.0; // Return 1.0 for initial state with no requests + } + return (double) successCount.get() / total; + } + + /** + * Resets all monitoring statistics to their initial values. + * This includes resetting all counters to zero and setting timestamps to current time. + */ + public void reset() { + successCount.set(0); + fallbackCount.set(0); + errorCount.set(0); + lastSuccessTime.set(Instant.now()); + lastFailureTime.set(Instant.now()); + lastResponseTime.set(Duration.ZERO); + metrics.clear(); + } + + private void pruneOldMetrics() { + Instant cutoff = Instant.now().minus(metricWindow); + metrics.removeIf(metric -> metric.timestamp.isBefore(cutoff)); + } +} diff --git a/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java b/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java new file mode 100644 index 000000000000..acaa252bc145 --- /dev/null +++ b/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java @@ -0,0 +1,74 @@ +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class DefaultCircuitBreakerTest { + private DefaultCircuitBreaker circuitBreaker; + private static final int FAILURE_THRESHOLD = 3; + + @BeforeEach + void setUp() { + circuitBreaker = new DefaultCircuitBreaker(FAILURE_THRESHOLD); + } + + @Test + void testInitialState() { + assertFalse(circuitBreaker.isOpen()); + } + + @Test + void testOpenStateAfterFailures() { + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + } + + @Test + void testHalfOpenStateAfterTimeout() throws InterruptedException { + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + + // Wait for reset timeout + Thread.sleep(5100); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + void testSuccessResetsFailureCount() { + circuitBreaker.recordFailure(); + circuitBreaker.recordFailure(); + circuitBreaker.recordSuccess(); + + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + } + + @Test + void testReset() { + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + + circuitBreaker.reset(); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + void testFailureThresholdBoundary() { + for (int i = 0; i < FAILURE_THRESHOLD - 1; i++) { + circuitBreaker.recordFailure(); + assertFalse(circuitBreaker.isOpen()); + } + + circuitBreaker.recordFailure(); + assertTrue(circuitBreaker.isOpen()); + } +} diff --git a/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java b/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java new file mode 100644 index 000000000000..7f54b3481e70 --- /dev/null +++ b/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java @@ -0,0 +1,369 @@ +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicBoolean; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +class FallbackServiceTest { + @Mock private Service primaryService; + @Mock private Service fallbackService; + @Mock private CircuitBreaker circuitBreaker; + private FallbackService fallbackServiceUnderTest; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + fallbackServiceUnderTest = new FallbackService(primaryService, fallbackService, circuitBreaker); + } + + @Test + void testSuccessfulPrimaryService() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenReturn("success"); + + String result = fallbackServiceUnderTest.getData(); + + assertEquals("success", result); + verify(primaryService, times(1)).getData(); + verify(fallbackService, never()).getData(); + verify(circuitBreaker).recordSuccess(); + } + + @Test + void testFallbackWhenPrimaryFails() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenThrow(new TimeoutException()); + when(fallbackService.getData()).thenReturn("fallback"); + + String result = fallbackServiceUnderTest.getData(); + + assertEquals("fallback", result); + verify(primaryService, times(3)).getData(); + verify(fallbackService, times(1)).getData(); + verify(circuitBreaker, times(3)).recordFailure(); + } + + @Test + void testCircuitBreakerOpen() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(true); + when(fallbackService.getData()).thenReturn("fallback"); + + String result = fallbackServiceUnderTest.getData(); + + assertEquals("fallback", result); + verify(primaryService, never()).getData(); + verify(fallbackService, times(1)).getData(); + } + + @Test + void testFallbackServiceFailure() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenThrow(new TimeoutException()); + when(fallbackService.getData()).thenThrow(new Exception("Fallback failed")); + + String result = fallbackServiceUnderTest.getData(); + + assertEquals("Service temporarily unavailable", result); + verify(primaryService, times(3)).getData(); + verify(fallbackService, times(1)).getData(); + } + + @Test + void testServiceClosedState() throws Exception { + fallbackServiceUnderTest.close(); + assertThrows(ServiceException.class, () -> fallbackServiceUnderTest.getData()); + } + + @Test + void testLocalCacheUpdateOnSuccess() throws Exception { + LocalCacheService localCache = new LocalCacheService(); + FallbackService service = new FallbackService(primaryService, localCache, circuitBreaker); + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenReturn("new data"); + + String result = service.getData(); + + assertEquals("new data", result); + assertEquals("new data", localCache.getData()); + } + + @Test + void testMonitoringMetricsAfterMultipleOperations() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()) + .thenReturn("success1") + .thenThrow(new TimeoutException()) + .thenThrow(new TimeoutException()) + .thenThrow(new TimeoutException()) + .thenReturn("success2"); + when(fallbackService.getData()).thenReturn("fallback"); + + // First call - success + String result1 = fallbackServiceUnderTest.getData(); + assertEquals("success1", result1); + + // Second call - fallback after retries + String result2 = fallbackServiceUnderTest.getData(); + assertEquals("fallback", result2); + + // Third call - success + String result3 = fallbackServiceUnderTest.getData(); + assertEquals("success2", result3); + + ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); + assertEquals(2, monitor.getSuccessCount()); + assertEquals(1, monitor.getFallbackCount()); + assertTrue(monitor.getSuccessRate() > 0.6); + } + + @Test + void testHealthCheck() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenThrow(new TimeoutException()); + when(fallbackService.getData()).thenReturn("fallback"); + + // Generate some failing requests + for (int i = 0; i < 10; i++) { + fallbackServiceUnderTest.getData(); + } + + // Wait for health check to run + Thread.sleep(2000); + + ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); + assertTrue(monitor.getSuccessRate() < 0.6); + } + + @Test + void testRetryBehavior() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()) + .thenThrow(new TimeoutException()) + .thenThrow(new TimeoutException()) + .thenReturn("success"); + + String result = fallbackServiceUnderTest.getData(); + + assertEquals("success", result); + verify(primaryService, times(3)).getData(); + verify(fallbackService, never()).getData(); + } + + @Test + void testCircuitBreakerTripping() throws Exception { + when(circuitBreaker.isOpen()) + .thenReturn(false) // First call + .thenReturn(false) // Second call + .thenReturn(true); // Third call + when(primaryService.getData()).thenThrow(new TimeoutException()); + when(fallbackService.getData()).thenReturn("fallback"); + + String result1 = fallbackServiceUnderTest.getData(); + String result2 = fallbackServiceUnderTest.getData(); + String result3 = fallbackServiceUnderTest.getData(); + + assertEquals("fallback", result1); + assertEquals("fallback", result2); + assertEquals("fallback", result3); + + // Verify primary service was called only during first two attempts + verify(primaryService, times(6)).getData(); // 3 retries * 2 attempts + verify(fallbackService, times(3)).getData(); // Called for each attempt + } + + @Test + void testConcurrentRequests() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenReturn("success"); + + // Simulate concurrent requests + Thread[] threads = new Thread[5]; + for (int i = 0; i < 5; i++) { + threads[i] = new Thread(() -> { + try { + fallbackServiceUnderTest.getData(); + } catch (Exception e) { + fail("Concurrent request failed: " + e.getMessage()); + } + }); + threads[i].start(); + } + + // Wait for all threads to complete + for (Thread thread : threads) { + thread.join(); + } + + verify(primaryService, times(5)).getData(); + } + + @Test + void testServiceMetricsAfterMultipleFailures() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenThrow(new TimeoutException()); + when(fallbackService.getData()).thenReturn("fallback"); + + // Generate multiple failures + for (int i = 0; i < 5; i++) { + fallbackServiceUnderTest.getData(); + } + + ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); + assertEquals(0, monitor.getSuccessCount()); + assertEquals(5, monitor.getFallbackCount()); + assertEquals(15, monitor.getErrorCount()); // 3 retries per attempt + } + + @Test + void testGracefulDegradation() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()) + .thenReturn("success") + .thenThrow(new TimeoutException()) + .thenThrow(new RuntimeException()) + .thenThrow(new OutOfMemoryError()); + when(fallbackService.getData()).thenReturn("fallback"); + + // First call succeeds + assertEquals("success", fallbackServiceUnderTest.getData()); + + // Subsequent calls should gracefully degrade to fallback + for (int i = 0; i < 3; i++) { + String result = fallbackServiceUnderTest.getData(); + assertEquals("fallback", result); + } + } + + @Test + void testSystemStability() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenReturn("success"); + when(fallbackService.getData()).thenReturn("fallback"); + + AtomicInteger requestCount = new AtomicInteger(); + AtomicInteger errorCount = new AtomicInteger(); + + long endTime = System.currentTimeMillis() + 5000; // 5 second test + while (System.currentTimeMillis() < endTime) { + try { + fallbackServiceUnderTest.getData(); + requestCount.incrementAndGet(); + } catch (Exception e) { + errorCount.incrementAndGet(); + } + Thread.sleep(50); // Prevent tight loop + } + + assertTrue(requestCount.get() > 0); + assertEquals(0, errorCount.get()); + assertTrue(fallbackServiceUnderTest.getMonitor().getSuccessRate() > 0.95); + } + + @Test + void testResourceExhaustion() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenAnswer(inv -> { + Thread.sleep(100); // Simulate processing time + return "success"; + }); + + // Create many concurrent requests + ExecutorService executor = Executors.newFixedThreadPool(50); + List> futures = new ArrayList<>(); + + for (int i = 0; i < 100; i++) { + futures.add(executor.submit(() -> fallbackServiceUnderTest.getData())); + } + + + + executor.shutdown(); + assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS)); + } + + @Test + void testRecoveryAfterFailure() throws Exception { + // Setup circuit breaker state transitions + when(circuitBreaker.isOpen()) + .thenReturn(false) // Initial attempt + .thenReturn(true) // Circuit open + .thenReturn(false); // Circuit reset + + // Setup primary service behavior + when(primaryService.getData()) + .thenThrow(new TimeoutException()) // Initial failure + .thenThrow(new TimeoutException()) // When circuit opens + .thenThrow(new TimeoutException()) // Third retry + .thenReturn("recovered"); // After reset + + // Setup fallback service behavior + when(fallbackService.getData()) + .thenReturn("fallback") + .thenReturn("fallback") + .thenReturn("fallback"); + + // Initial failure should trigger fallback + String result1 = fallbackServiceUnderTest.getData(); + assertEquals("fallback", result1); + + // Circuit is open, should use fallback without trying primary + String result2 = fallbackServiceUnderTest.getData(); + assertEquals("fallback", result2); + + // Circuit resets, primary service should be tried again + String result3 = fallbackServiceUnderTest.getData(); + assertEquals("recovered", result3); + + // Verify timing of success/failure + ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); + assertTrue(monitor.getLastSuccessTime().isAfter(monitor.getLastFailureTime())); + + // Verify correct number of calls + verify(primaryService, atLeast(3)).getData(); + verify(fallbackService, times(2)).getData(); + } + + @Test + void testReliabilityUnderLoad() throws Exception { + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenReturn("success"); + when(fallbackService.getData()).thenReturn("fallback"); + + int totalRequests = 100; + CountDownLatch latch = new CountDownLatch(totalRequests); + AtomicInteger successCount = new AtomicInteger(); + AtomicInteger failureCount = new AtomicInteger(); + + ExecutorService executor = Executors.newFixedThreadPool(10); + try { + for (int i = 0; i < totalRequests; i++) { + executor.execute(() -> { + try { + fallbackServiceUnderTest.getData(); + successCount.incrementAndGet(); + } catch (Exception e) { + failureCount.incrementAndGet(); + } finally { + latch.countDown(); + } + }); + } + + assertTrue(latch.await(30, TimeUnit.SECONDS)); + assertTrue(successCount.get() >= 85, "Success count should be at least 85%"); + assertTrue(failureCount.get() <= 15, "Failure count should be no more than 15%"); + } finally { + executor.shutdown(); + executor.awaitTermination(5, TimeUnit.SECONDS); + } + } +} diff --git a/fallback/src/test/java/com/iluwatar/IntegrationTest.java b/fallback/src/test/java/com/iluwatar/IntegrationTest.java new file mode 100644 index 000000000000..b3ceb0e25c80 --- /dev/null +++ b/fallback/src/test/java/com/iluwatar/IntegrationTest.java @@ -0,0 +1,320 @@ +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.net.http.HttpClient; +import java.time.Duration; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import static org.junit.jupiter.api.Assertions.*; + +class IntegrationTest { + private FallbackService fallbackService; + private LocalCacheService cacheService; + private CircuitBreaker circuitBreaker; + private static final int CONCURRENT_REQUESTS = 50; + private static final int THREAD_POOL_SIZE = 10; + + @BeforeEach + void setUp() { + Service remoteService = new RemoteService( + "http://localhost:0", // Invalid port to force failure + HttpClient.newHttpClient() + ); + + cacheService = new LocalCacheService(); + circuitBreaker = new DefaultCircuitBreaker(3); + fallbackService = new FallbackService(remoteService, cacheService, circuitBreaker); + } + + @Test + void testCompleteFailoverFlow() throws Exception { + // First call should try remote service, fail, and fall back to cache + String result1 = fallbackService.getData(); + assertNotNull(result1); + assertTrue(result1.contains("fallback")); + + // Update cache with new data + cacheService.updateCache("default", "updated cache data"); + + // Second call should use updated cache data + String result2 = fallbackService.getData(); + assertEquals("updated cache data", result2); + + // Verify metrics + ServiceMonitor monitor = fallbackService.getMonitor(); + assertEquals(0, monitor.getSuccessCount()); + assertTrue(monitor.getFallbackCount() > 0); + assertTrue(monitor.getErrorCount() > 0); + } + + @Test + void testCircuitBreakerIntegration() throws Exception { + // Make multiple calls to trigger circuit breaker + for (int i = 0; i < 5; i++) { + fallbackService.getData(); + } + + // Verify circuit breaker is open + assertTrue(circuitBreaker.isOpen()); + + // Verify all subsequent calls use fallback without trying primary + String result = fallbackService.getData(); + assertNotNull(result); + assertTrue(result.contains("fallback")); + + // Wait for circuit breaker timeout + Thread.sleep(5100); + + // Verify circuit breaker is reset + assertFalse(circuitBreaker.isOpen()); + } + + @Test + void testPerformanceMetrics() throws Exception { + long startTime = System.currentTimeMillis(); + + // Make multiple service calls + for (int i = 0; i < 3; i++) { + fallbackService.getData(); + } + + long endTime = System.currentTimeMillis(); + Duration totalDuration = Duration.ofMillis(endTime - startTime); + + // Verify performance metrics + ServiceMonitor monitor = fallbackService.getMonitor(); + assertTrue(monitor.getLastResponseTime().compareTo(totalDuration) <= 0); + assertTrue(monitor.getLastFailureTime().isAfter(monitor.getLastSuccessTime())); + } + + @Test + void testResourceCleanup() throws Exception { + // Verify service works before closing + String result = fallbackService.getData(); + assertNotNull(result); + + // Close service + fallbackService.close(); + + // Verify service is closed + assertThrows(ServiceException.class, () -> fallbackService.getData()); + } + + @Test + void testSystemReliability() throws Exception { + AtomicInteger successCount = new AtomicInteger(); + AtomicInteger fallbackCount = new AtomicInteger(); + CountDownLatch latch = new CountDownLatch(CONCURRENT_REQUESTS); + + ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE); + try { + for (int i = 0; i < CONCURRENT_REQUESTS; i++) { + executor.execute(() -> { + try { + String result = fallbackService.getData(); + if (result.contains("fallback")) { + fallbackCount.incrementAndGet(); + } else { + successCount.incrementAndGet(); + } + } catch (Exception e) { + fail("Request failed: " + e.getMessage()); + } finally { + latch.countDown(); + } + }); + } + + assertTrue(latch.await(30, TimeUnit.SECONDS), "Timed out waiting for requests"); + + // Verify system reliability + ServiceMonitor monitor = fallbackService.getMonitor(); + double reliabilityRate = (monitor.getSuccessRate() + + (double)fallbackCount.get() / CONCURRENT_REQUESTS); + assertTrue(reliabilityRate > 0.95, + "Reliability rate should be > 95%, actual: " + (reliabilityRate * 100) + "%"); + } finally { + executor.shutdown(); + assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); + } + } + + @Test + void testLongTermStability() throws Exception { + ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); + AtomicBoolean stable = new AtomicBoolean(true); + AtomicInteger requestCount = new AtomicInteger(); + + try { + ScheduledFuture future = scheduler.scheduleAtFixedRate(() -> { + try { + fallbackService.getData(); + requestCount.incrementAndGet(); + } catch (Exception e) { + stable.set(false); + } + }, 0, 100, TimeUnit.MILLISECONDS); + + // Run for 5 seconds instead of 30 for faster tests + Thread.sleep(5_000); + future.cancel(false); + + assertTrue(stable.get(), "System should remain stable"); + assertTrue(requestCount.get() >= 45, + "Should handle at least 45 requests in 5 seconds"); + assertTrue(fallbackService.getMonitor().getSuccessRate() + + fallbackService.getMonitor().getFallbackCount() / + (double)requestCount.get() > 0.9, + "Combined success and fallback rate should be > 90%"); + } finally { + scheduler.shutdown(); + assertTrue(scheduler.awaitTermination(5, TimeUnit.SECONDS)); + } + } + @Test + void testConcurrentRequestsUnderLoad() throws Exception { + int numThreads = 100; + int requestsPerThread = 100; + CountDownLatch startLatch = new CountDownLatch(1); + CountDownLatch completionLatch = new CountDownLatch(numThreads); + AtomicInteger successCount = new AtomicInteger(0); + AtomicInteger failureCount = new AtomicInteger(0); + + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()) + .thenAnswer(inv -> { + Thread.sleep(5); // Simulate processing time + return "success"; + }); + + ExecutorService executor = Executors.newFixedThreadPool(numThreads); + List> futures = new ArrayList<>(); + + try { + // Create worker threads + for (int i = 0; i < numThreads; i++) { + futures.add(executor.submit(() -> { + try { + startLatch.await(); // Wait for all threads to be ready + for (int j = 0; j < requestsPerThread; j++) { + try { + String result = fallbackServiceUnderTest.getData(); + if (result != null && !result.isEmpty()) { + successCount.incrementAndGet(); + } + } catch (Exception e) { + failureCount.incrementAndGet(); + } + } + } finally { + completionLatch.countDown(); + } + })); + } + + // Start all threads simultaneously + startLatch.countDown(); + + // Wait for completion with timeout + assertTrue(completionLatch.await(30, TimeUnit.SECONDS), + "Test timed out waiting for completion"); + + // Verify results + assertTrue(successCount.get() > numThreads * requestsPerThread * 0.95, + "Success rate should be > 95%"); + assertTrue(failureCount.get() < numThreads * requestsPerThread * 0.05, + "Failure rate should be < 5%"); + + // Check service monitor metrics + ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); + assertTrue(monitor.getSuccessRate() > 0.95, + "Service monitor success rate should be > 95%"); + assertTrue(monitor.getLastResponseTime().toMillis() < 1000, + "Response time should be under 1 second"); + + } finally { + executor.shutdown(); + assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); + } + } + + @Test + void testCircuitBreakerBehaviorUnderStress() throws Exception { + AtomicInteger openStateCount = new AtomicInteger(); + AtomicInteger closedStateCount = new AtomicInteger(); + CountDownLatch completionLatch = new CountDownLatch(1); + + when(circuitBreaker.isOpen()).thenAnswer(inv -> { + if (openStateCount.get() > 100) { // Switch to closed after 100 open calls + closedStateCount.incrementAndGet(); + return false; + } + openStateCount.incrementAndGet(); + return true; + }); + + when(primaryService.getData()) + .thenThrow(new TimeoutException()) + .thenThrow(new TimeoutException()) + .thenReturn("recovered"); + when(fallbackService.getData()).thenReturn("fallback"); + + ExecutorService executor = Executors.newFixedThreadPool(10); + try { + // Generate load + for (int i = 0; i < 200; i++) { + executor.submit(() -> { + try { + fallbackServiceUnderTest.getData(); + } catch (Exception ignored) { + } + }); + } + + Thread.sleep(2000); // Allow time for requests to process + + assertTrue(openStateCount.get() >= 100, + "Circuit breaker should have been open at least 100 times"); + assertTrue(closedStateCount.get() > 0, + "Circuit breaker should have transitioned to closed state"); + + verify(fallbackService, atLeast(50)).getData(); + verify(primaryService, atLeast(10)).getData(); + + } finally { + executor.shutdown(); + assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); + } + } + + @Test + void testErrorBoundaries() throws Exception { + // Test with null responses + when(primaryService.getData()).thenReturn(null); + when(fallbackService.getData()).thenReturn(null); + + String result = fallbackServiceUnderTest.getData(); + assertEquals("Service temporarily unavailable", result); + + // Test with empty responses + when(primaryService.getData()).thenReturn(""); + when(fallbackService.getData()).thenReturn(""); + + result = fallbackServiceUnderTest.getData(); + assertNotNull(result); + + // Test with very large responses + StringBuilder largeResponse = new StringBuilder(); + for (int i = 0; i < 1000000; i++) { + largeResponse.append("x"); + } + when(primaryService.getData()).thenReturn(largeResponse.toString()); + + result = fallbackServiceUnderTest.getData(); + assertNotNull(result); + assertTrue(result.length() > 0); + } +} diff --git a/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java b/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java new file mode 100644 index 000000000000..f5e9b281425e --- /dev/null +++ b/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java @@ -0,0 +1,109 @@ +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import java.time.Duration; +import java.time.Instant; +import static org.junit.jupiter.api.Assertions.*; + +class ServiceMonitorTest { + private ServiceMonitor monitor; + + @BeforeEach + void setUp() { + monitor = new ServiceMonitor(); + } + + @Test + void testInitialState() { + assertEquals(0, monitor.getSuccessCount()); + assertEquals(0, monitor.getFallbackCount()); + assertEquals(0, monitor.getErrorCount()); + assertEquals(1.0, monitor.getSuccessRate()); + assertNotNull(monitor.getLastSuccessTime()); + assertNotNull(monitor.getLastFailureTime()); + assertEquals(Duration.ZERO, monitor.getLastResponseTime()); + } + + @Test + void testSuccessRate() { + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordFallback(); + monitor.recordError(); + + assertEquals(2, monitor.getSuccessCount()); + assertEquals(1, monitor.getFallbackCount()); + assertEquals(1, monitor.getErrorCount()); + assertEquals(0.5, monitor.getSuccessRate(), 0.01); + } + + @Test + void testResponseTimeTracking() { + Duration responseTime = Duration.ofMillis(150); + monitor.recordSuccess(responseTime); + assertEquals(responseTime, monitor.getLastResponseTime()); + } + + @Test + void testLastSuccessTime() { + Instant before = Instant.now(); + monitor.recordSuccess(Duration.ofMillis(100)); + Instant after = Instant.now(); + + Instant lastSuccess = monitor.getLastSuccessTime(); + assertTrue(lastSuccess.isAfter(before) || lastSuccess.equals(before)); + assertTrue(lastSuccess.isBefore(after) || lastSuccess.equals(after)); + } + + @Test + void testLastFailureTime() { + Instant before = Instant.now(); + monitor.recordError(); + Instant after = Instant.now(); + + Instant lastFailure = monitor.getLastFailureTime(); + assertTrue(lastFailure.isAfter(before) || lastFailure.equals(before)); + assertTrue(lastFailure.isBefore(after) || lastFailure.equals(after)); + } + + @Test + void testSuccessRateWithOnlyErrors() { + monitor.recordError(); + monitor.recordError(); + monitor.recordError(); + assertEquals(0.0, monitor.getSuccessRate()); + } + + @Test + void testSuccessRateWithOnlyFallbacks() { + monitor.recordFallback(); + monitor.recordFallback(); + monitor.recordFallback(); + assertEquals(0.0, monitor.getSuccessRate()); + } + + @Test + void testSuccessRateWithOnlySuccesses() { + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordSuccess(Duration.ofMillis(100)); + assertEquals(1.0, monitor.getSuccessRate()); + } + + @Test + void testReset() { + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordFallback(); + monitor.recordError(); + monitor.reset(); + + assertEquals(0, monitor.getSuccessCount()); + assertEquals(0, monitor.getFallbackCount()); + assertEquals(0, monitor.getErrorCount()); + assertEquals(1.0, monitor.getSuccessRate()); + assertEquals(Duration.ZERO, monitor.getLastResponseTime()); + assertTrue(monitor.getLastSuccessTime().isAfter(Instant.now().minusSeconds(1))); + assertTrue(monitor.getLastFailureTime().isAfter(Instant.now().minusSeconds(1))); + } +} diff --git a/pom.xml b/pom.xml index 959643f79fcf..57b4f5c6ec05 100644 --- a/pom.xml +++ b/pom.xml @@ -1,436 +1,437 @@ - - - - 4.0.0 - com.iluwatar - java-design-patterns - 1.26.0-SNAPSHOT - pom - 2014-2022 - Java Design Patterns - Java Design Patterns - - UTF-8 - 4.0.0.4121 - 2.7.5 - 0.8.12 - 1.4 - 4.5.0 - 2.11.0 - 6.0.0 - 1.1.0 - 3.5.1 - 3.6.0 - 4.6 - 2.1.1 - 2.0.16 - 1.5.6 - - https://sonarcloud.io - iluwatar - iluwatar_java-design-patterns - ${project.artifactId} - Java Design Patterns - - - abstract-factory - collecting-parameter - monitor - builder - factory-method - prototype - singleton - adapter - bridge - composite - data-access-object - data-mapper - decorator - facade - flyweight - proxy - chain-of-responsibility - command - interpreter - iterator - mediator - memento - model-view-presenter - observer - state - strategy - template-method - version-number - visitor - double-checked-locking - servant - service-locator - null-object - event-aggregator - callback - execute-around - property - intercepting-filter - producer-consumer - pipeline - poison-pill - lazy-loading - service-layer - specification - tolerant-reader - model-view-controller - flux - double-dispatch - multiton - resource-acquisition-is-initialization - twin - private-class-data - object-pool - dependency-injection - front-controller - repository - async-method-invocation - monostate - step-builder - business-delegate - half-sync-half-async - layered-architecture - fluent-interface - reactor - caching - delegation - event-driven-architecture - microservices-api-gateway - factory-kit - feature-toggle - value-object - monad - mute-idiom - hexagonal-architecture - abstract-document - microservices-aggregrator - promise - page-controller - page-object - event-based-asynchronous - event-queue - queue-based-load-leveling - object-mother - data-bus - converter - guarded-suspension - balking - extension-objects - marker-interface - command-query-responsibility-segregation - event-sourcing - data-transfer-object - throttling - unit-of-work - partial-response - retry - dirty-flag - trampoline - ambassador - acyclic-visitor - collection-pipeline - master-worker - spatial-partition - commander - type-object - bytecode - leader-election - data-locality - subclass-sandbox - circuit-breaker - role-object - saga - double-buffer - sharding - game-loop - combinator - update-method - leader-followers - strangler - arrange-act-assert - transaction-script - registry - filterer - factory - separated-interface - special-case - parameter-object - active-object - model-view-viewmodel - composite-entity - table-module - presentation-model - lockable-object - fanout-fanin - domain-model - composite-view - metadata-mapping - service-to-worker - client-session - model-view-intent - currying - serialized-entity - identity-map - component - context-object - optimistic-offline-lock - curiously-recurring-template-pattern - microservices-log-aggregation - anti-corruption-layer - health-check - notification - single-table-inheritance - dynamic-proxy - gateway - serialized-lob - server-session - virtual-proxy - function-composition - microservices-distributed-tracing - microservices-idempotent-consumer - - - - jitpack.io - https://jitpack.io - - - - - - org.springframework.boot - spring-boot-dependencies - ${spring-boot.version} - pom - import - - - commons-dbcp - commons-dbcp - ${commons-dbcp.version} - - - org.htmlunit - htmlunit - ${htmlunit.version} - - - com.google.code.gson - gson - ${gson.version} - - - com.google.inject - guice - ${guice.version} - - - com.github.stefanbirkner - system-lambda - ${system-lambda.version} - test - - - - - - org.slf4j - slf4j-api - ${slf4j.version} - - - ch.qos.logback - logback-classic - ${logback.version} - - - ch.qos.logback - logback-core - ${logback.version} - - - org.projectlombok - lombok - provided - - - - - - - org.apache.maven.plugins - maven-compiler-plugin - - 17 - 17 - - - - org.apache.maven.plugins - maven-surefire-plugin - ${maven-surefire-plugin.version} - - - org.springframework.boot - spring-boot-maven-plugin - - - - org.apache.maven.plugins - maven-assembly-plugin - - - package - - single - - - - jar-with-dependencies - - - ${project.artifactId}-${project.version} - false - - - - - - org.sonarsource.scanner.maven - sonar-maven-plugin - ${sonar-maven-plugin.version} - - - - - - org.apache.maven.plugins - maven-checkstyle-plugin - ${maven-checkstyle-plugin.version} - - - validate - - check - - validate - - google_checks.xml - checkstyle-suppressions.xml - - true - warning - false - - - - - - com.mycila - license-maven-plugin - ${license-maven-plugin.version} - - - - - -
com/mycila/maven/plugin/license/templates/MIT.txt
- - - **/README - src/test/resources/** - src/main/resources/** - checkstyle-suppressions.xml - - - - - Ilkka Seppälä - iluwatar@gmail.com - - - - - install-format - install - - format - - - - - - org.jacoco - jacoco-maven-plugin - ${jacoco.version} - - - prepare-agent - - prepare-agent - - - - report - - report - - - - - - com.iluwatar.urm - urm-maven-plugin - ${urm-maven-plugin.version} - - - ${project.basedir}/etc - - com.iluwatar - - true - false - plantuml - - - - process-classes - - map - - - - - - - + + + + 4.0.0 + com.iluwatar + java-design-patterns + 1.26.0-SNAPSHOT + pom + 2014-2022 + Java Design Patterns + Java Design Patterns + + UTF-8 + 4.0.0.4121 + 2.7.5 + 0.8.12 + 1.4 + 4.5.0 + 2.11.0 + 6.0.0 + 1.1.0 + 3.5.1 + 3.6.0 + 4.6 + 2.1.1 + 2.0.16 + 1.5.6 + + https://sonarcloud.io + iluwatar + iluwatar_java-design-patterns + ${project.artifactId} + Java Design Patterns + + + abstract-factory + collecting-parameter + monitor + builder + factory-method + prototype + singleton + adapter + bridge + composite + data-access-object + data-mapper + decorator + facade + flyweight + proxy + chain-of-responsibility + command + interpreter + iterator + mediator + memento + model-view-presenter + observer + state + strategy + template-method + version-number + visitor + double-checked-locking + servant + service-locator + null-object + event-aggregator + callback + execute-around + property + intercepting-filter + producer-consumer + pipeline + poison-pill + lazy-loading + service-layer + specification + tolerant-reader + model-view-controller + flux + double-dispatch + multiton + resource-acquisition-is-initialization + twin + private-class-data + object-pool + dependency-injection + front-controller + repository + async-method-invocation + monostate + step-builder + business-delegate + half-sync-half-async + layered-architecture + fluent-interface + reactor + caching + delegation + event-driven-architecture + microservices-api-gateway + factory-kit + feature-toggle + value-object + monad + mute-idiom + hexagonal-architecture + abstract-document + microservices-aggregrator + promise + page-controller + page-object + event-based-asynchronous + event-queue + queue-based-load-leveling + object-mother + data-bus + converter + guarded-suspension + balking + extension-objects + marker-interface + command-query-responsibility-segregation + event-sourcing + data-transfer-object + throttling + unit-of-work + partial-response + retry + dirty-flag + trampoline + ambassador + acyclic-visitor + collection-pipeline + master-worker + spatial-partition + commander + type-object + bytecode + leader-election + data-locality + subclass-sandbox + circuit-breaker + role-object + saga + double-buffer + sharding + game-loop + combinator + update-method + leader-followers + strangler + arrange-act-assert + transaction-script + registry + filterer + factory + separated-interface + special-case + parameter-object + active-object + model-view-viewmodel + composite-entity + table-module + presentation-model + lockable-object + fanout-fanin + domain-model + composite-view + metadata-mapping + service-to-worker + client-session + model-view-intent + currying + serialized-entity + identity-map + component + context-object + optimistic-offline-lock + curiously-recurring-template-pattern + microservices-log-aggregation + anti-corruption-layer + health-check + notification + single-table-inheritance + dynamic-proxy + gateway + serialized-lob + server-session + virtual-proxy + function-composition + microservices-distributed-tracing + microservices-idempotent-consumer + fallback + + + + jitpack.io + https://jitpack.io + + + + + + org.springframework.boot + spring-boot-dependencies + ${spring-boot.version} + pom + import + + + commons-dbcp + commons-dbcp + ${commons-dbcp.version} + + + org.htmlunit + htmlunit + ${htmlunit.version} + + + com.google.code.gson + gson + ${gson.version} + + + com.google.inject + guice + ${guice.version} + + + com.github.stefanbirkner + system-lambda + ${system-lambda.version} + test + + + + + + org.slf4j + slf4j-api + ${slf4j.version} + + + ch.qos.logback + logback-classic + ${logback.version} + + + ch.qos.logback + logback-core + ${logback.version} + + + org.projectlombok + lombok + provided + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 17 + 17 + + + + org.apache.maven.plugins + maven-surefire-plugin + ${maven-surefire-plugin.version} + + + org.springframework.boot + spring-boot-maven-plugin + + + + org.apache.maven.plugins + maven-assembly-plugin + + + package + + single + + + + jar-with-dependencies + + + ${project.artifactId}-${project.version} + false + + + + + + org.sonarsource.scanner.maven + sonar-maven-plugin + ${sonar-maven-plugin.version} + + + + + + org.apache.maven.plugins + maven-checkstyle-plugin + ${maven-checkstyle-plugin.version} + + + validate + + check + + validate + + google_checks.xml + checkstyle-suppressions.xml + + true + warning + false + + + + + + com.mycila + license-maven-plugin + ${license-maven-plugin.version} + + + + + +
com/mycila/maven/plugin/license/templates/MIT.txt
+ + + **/README + src/test/resources/** + src/main/resources/** + checkstyle-suppressions.xml + + + + + Ilkka Seppälä + iluwatar@gmail.com + + + + + install-format + install + + format + + + + + + org.jacoco + jacoco-maven-plugin + ${jacoco.version} + + + prepare-agent + + prepare-agent + + + + report + + report + + + + + + com.iluwatar.urm + urm-maven-plugin + ${urm-maven-plugin.version} + + + ${project.basedir}/etc + + com.iluwatar + + true + false + plantuml + + + + process-classes + + map + + + + + + + From 59d65648d1523bd8a782c3006df260a44c8f8118 Mon Sep 17 00:00:00 2001 From: Ahmed Abdelraheem Date: Tue, 10 Dec 2024 15:25:49 +0200 Subject: [PATCH 2/4] all done including tests, just need more tests --- fallback/etc/fallback.urm.puml | 75 ++- fallback/pom.xml | 1 + fallback/src/main/java/com/iluwatar/App.java | 331 +++++----- .../java/com/iluwatar/CircuitBreaker.java | 99 ++- .../com/iluwatar/DefaultCircuitBreaker.java | 272 +++++--- .../java/com/iluwatar/FallbackService.java | 132 +++- .../java/com/iluwatar/LocalCacheService.java | 293 ++++++--- .../main/java/com/iluwatar/RemoteService.java | 126 ++-- .../java/com/iluwatar/ServiceException.java | 52 +- .../java/com/iluwatar/ServiceMonitor.java | 302 +++++---- .../iluwatar/DefaultCircuitBreakerTest.java | 214 ++++--- .../com/iluwatar/FallbackServiceTest.java | 585 +++++++----------- .../java/com/iluwatar/IntegrationTest.java | 492 +++++---------- .../java/com/iluwatar/ServiceMonitorTest.java | 270 ++++---- 14 files changed, 1729 insertions(+), 1515 deletions(-) diff --git a/fallback/etc/fallback.urm.puml b/fallback/etc/fallback.urm.puml index 28315a58ebe3..151db1d973d9 100644 --- a/fallback/etc/fallback.urm.puml +++ b/fallback/etc/fallback.urm.puml @@ -1,13 +1,12 @@ @startuml package com.iluwatar { class App { - - MAX_ATTEMPTS : int {static} - - RETRY_DELAY : int {static} - TIMEOUT : int {static} - circuitBreaker : CircuitBreaker - executor : ExecutorService - fallbackService : Service - primaryService : Service + - LOGGER : Logger {static} + App() + App(primaryService : Service, fallbackService : Service) + executeWithFallback() : String @@ -15,29 +14,64 @@ package com.iluwatar { + main(args : String[]) {static} + shutdown() } + + interface Service { + + getData() : String {abstract} + } + interface CircuitBreaker { + isOpen() : boolean {abstract} + recordFailure() {abstract} + recordSuccess() {abstract} + reset() {abstract} } + class DefaultCircuitBreaker { - RESET_TIMEOUT : long {static} - failureCount : int - failureThreshold : int - lastFailureTime : long + - state : State + DefaultCircuitBreaker(failureThreshold : int) + isOpen() : boolean + recordFailure() + recordSuccess() + reset() + - enum State + } + + class FallbackService { + - MAX_RETRIES : int {static} + - RETRY_DELAY_MS : int {static} + - TIMEOUT_MS : int {static} + - MAX_REQUESTS_PER_MINUTE : int {static} + - LOGGER : Logger {static} + - primaryService : Service + - fallbackService : Service + - circuitBreaker : CircuitBreaker + - executor : ExecutorService + - healthChecker : ScheduledExecutorService + - monitor : ServiceMonitor + - rateLimiter : RateLimiter + - closed : boolean + + FallbackService(primaryService : Service, fallbackService : Service, circuitBreaker : CircuitBreaker) + + getData() : String + - executeWithTimeout(task : Callable) : String + - executeFallback() : String + - updateFallbackCache(result : String) + - startHealthChecker() + + close() } + class LocalCacheService { - - cache : ConcurrentHashMap + - cache : Cache + LocalCacheService() + getData() : String + updateCache(key : String, value : String) + - class Cache + - class CacheEntry } + class RemoteService { - HTTP_OK : int {static} - client : HttpClient @@ -45,13 +79,34 @@ package com.iluwatar { + RemoteService(serviceUrl : String) + getData() : String } - interface Service { - + getData() : String {abstract} + + class ServiceMonitor { + - metrics : Queue + + recordSuccess(responseTime : Duration) + + recordError() + + recordFallback() + + getMetrics() : List + - class ServiceMetric + - enum MetricType + } + + class ServiceException { + + ServiceException(message : String) } + + ' Relationships + App --> "-circuitBreaker" CircuitBreaker + App --> "-primaryService" Service + App --> "-fallbackService" Service + DefaultCircuitBreaker ..|> CircuitBreaker + LocalCacheService ..|> Service + RemoteService ..|> Service + FallbackService ..|> Service + FallbackService ..|> AutoCloseable + FallbackService --> "-primaryService" Service + FallbackService --> "-fallbackService" Service + FallbackService --> "-circuitBreaker" CircuitBreaker + FallbackService --> "-monitor" ServiceMonitor + ServiceException --|> Exception } -App --> "-circuitBreaker" CircuitBreaker -App --> "-primaryService" Service -DefaultCircuitBreaker ..|> CircuitBreaker -LocalCacheService ..|> Service -RemoteService ..|> Service @enduml \ No newline at end of file diff --git a/fallback/pom.xml b/fallback/pom.xml index 9d9fdaf5fce3..23bf3df7e010 100644 --- a/fallback/pom.xml +++ b/fallback/pom.xml @@ -67,5 +67,6 @@ 4.5.1 test + \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/App.java b/fallback/src/main/java/com/iluwatar/App.java index 36b38efe4fe8..de7d2c067996 100644 --- a/fallback/src/main/java/com/iluwatar/App.java +++ b/fallback/src/main/java/com/iluwatar/App.java @@ -1,154 +1,177 @@ -/* - * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). - * - * The MIT License - * Copyright © 2014-2022 Ilkka Seppälä - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ -package com.iluwatar; - -import java.net.http.HttpClient; -import java.time.Duration; // Add this import -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.logging.Logger; - -/** - * App class that demonstrates the use of Circuit Breaker pattern with fallback mechanism. - */ -public class App { - private static final Logger LOGGER = Logger.getLogger(App.class.getName()); - private static final int TIMEOUT = 2; - private static final int MAX_ATTEMPTS = 3; - private static final int RETRY_DELAY = 1000; - private static final String DEFAULT_API_URL = "https://jsonplaceholder.typicode.com/todos"; - - private final CircuitBreaker circuitBreaker; - private final ExecutorService executor; - private final Service primaryService; - private final Service fallbackService; - - /** - * Constructs an App with default primary and fallback services. - */ - public App() { - HttpClient httpClient; - try { - httpClient = HttpClient.newBuilder() - .connectTimeout(Duration.ofSeconds(TIMEOUT)) - .build(); - } catch (Exception e) { - LOGGER.severe("Failed to create HTTP client: " + e.getMessage()); - httpClient = HttpClient.newHttpClient(); // Fallback to default client - } - - this.primaryService = new RemoteService(DEFAULT_API_URL, httpClient); - this.fallbackService = new LocalCacheService(); - this.circuitBreaker = new DefaultCircuitBreaker(MAX_ATTEMPTS); - this.executor = Executors.newSingleThreadExecutor(); - } - - /** - * Constructs an App with the specified primary and fallback services and a circuit breaker. - * - * @param primaryService the primary service to use - * @param fallbackService the fallback service to use - * @param circuitBreaker the circuit breaker to use - */ - public App(final Service primaryService, final Service fallbackService, final CircuitBreaker circuitBreaker) { - this.circuitBreaker = circuitBreaker; - this.executor = Executors.newSingleThreadExecutor(); - this.primaryService = primaryService; - this.fallbackService = fallbackService; - } - - /** - * Main method to run the application. - * - * @param args command line arguments - */ - public static void main(final String[] args) { - App app = new App(); - for (int i = 0; i < 5; i++) { - try { - String result = app.executeWithFallback(); - System.out.println("Attempt " + (i + 1) + ": Result = " + result); - } catch (Exception e) { - System.err.println("Attempt " + (i + 1) + " failed: " + e.getMessage()); - } - try { - Thread.sleep(RETRY_DELAY); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - System.err.println("Thread was interrupted: " + e.getMessage()); - } - } - app.shutdown(); - } - - /** - * Executes the primary service with a fallback mechanism. - * - * @return the result from the primary or fallback service - */ - public String executeWithFallback() { - if (circuitBreaker.isOpen()) { - LOGGER.info("Circuit breaker is open, using cached data"); - return getFallbackData(); - } - - try { - Future future = executor.submit(primaryService::getData); - String result = future.get(TIMEOUT, TimeUnit.SECONDS); - circuitBreaker.recordSuccess(); - if (fallbackService instanceof LocalCacheService) { - ((LocalCacheService) fallbackService).updateCache("default", result); - } - return result; - } catch (Exception e) { - LOGGER.warning("Primary service failed, using fallback. Exception: " + e.getMessage()); - circuitBreaker.recordFailure(); - return getFallbackData(); - } - } - - /** - * Retrieves data from the fallback service. - * - * @return the data from the fallback service - */ - private String getFallbackData() { - try { - return fallbackService.getData(); - } catch (Exception e) { - LOGGER.warning("Fallback service failed. Exception: " + e.getMessage()); - return "System is currently unavailable"; - } - } - - /** - * Shuts down the executor service. - */ - public void shutdown() { - executor.shutdown(); - } -} \ No newline at end of file +package com.iluwatar; + +import java.net.http.HttpClient; +import java.time.Duration; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Demonstrates the Fallback pattern with Circuit Breaker implementation. + * + *

This application shows how to: + * - Handle failures gracefully using fallback mechanisms. + * - Implement circuit breaker pattern to prevent cascade failures. + * - Configure timeouts and retries for resilient service calls. + * - Monitor service health and performance. + * + *

The app uses a primary remote service with a local cache fallback. + */ +public class App { + private static final Logger LOGGER = LoggerFactory.getLogger(App.class); + + /** Service call timeout in seconds. */ + private static final int TIMEOUT = 2; + + /** Maximum number of retry attempts. */ + private static final int MAX_ATTEMPTS = 3; + + /** Delay between retry attempts in milliseconds. */ + private static final int RETRY_DELAY = 1000; + + /** Default API endpoint for remote service. */ + private static final String DEFAULT_API_URL = "https://jsonplaceholder.typicode.com/todos"; + + /** Service execution state tracking. */ + private enum ExecutionState { + READY, RUNNING, FAILED, SHUTDOWN + } + + private final CircuitBreaker circuitBreaker; + private final ExecutorService executor; + private final Service primaryService; + private final Service fallbackService; + private volatile ExecutionState state; + + /** + * Constructs an App with default configuration. + * Creates HTTP client with timeout, remote service, and local cache fallback. + */ + public App() { + HttpClient httpClient = createHttpClient(); + this.primaryService = new RemoteService(DEFAULT_API_URL, httpClient); + this.fallbackService = new LocalCacheService(); + this.circuitBreaker = new DefaultCircuitBreaker(MAX_ATTEMPTS); + this.executor = Executors.newSingleThreadExecutor(); + this.state = ExecutionState.READY; + } + + private HttpClient createHttpClient() { + try { + return HttpClient.newBuilder() + .connectTimeout(Duration.ofSeconds(TIMEOUT)) + .build(); + } catch (Exception e) { + LOGGER.warn("Failed to create custom HTTP client, using default", e); + return HttpClient.newHttpClient(); + } + } + + /** + * Constructs an App with custom services and circuit breaker. + * + * @param primaryService Primary service implementation + * @param fallbackService Fallback service implementation + * @param circuitBreaker Circuit breaker implementation + * @throws IllegalArgumentException if any parameter is null + */ + public App(Service primaryService, Service fallbackService, CircuitBreaker circuitBreaker) { + if (primaryService == null || fallbackService == null || circuitBreaker == null) { + throw new IllegalArgumentException("All services must be non-null"); + } + this.circuitBreaker = circuitBreaker; + this.executor = Executors.newSingleThreadExecutor(); + this.primaryService = primaryService; + this.fallbackService = fallbackService; + this.state = ExecutionState.READY; + } + + /** + * Executes the service with fallback mechanism. + * + * @return Result from primary or fallback service + * @throws IllegalStateException if app is shutdown + */ + public String executeWithFallback() { + if (state == ExecutionState.SHUTDOWN) { + throw new IllegalStateException("Application is shutdown"); + } + + state = ExecutionState.RUNNING; + if (circuitBreaker.isOpen()) { + LOGGER.info("Circuit breaker is open, using cached data"); + return getFallbackData(); + } + + try { + Future future = executor.submit(primaryService::getData); + String result = future.get(TIMEOUT, TimeUnit.SECONDS); + circuitBreaker.recordSuccess(); + updateFallbackCache(result); + return result; + } catch (Exception e) { + LOGGER.warn("Primary service failed: {}", e.getMessage()); + circuitBreaker.recordFailure(); + state = ExecutionState.FAILED; + return getFallbackData(); + } + } + + private String getFallbackData() { + try { + return fallbackService.getData(); + } catch (Exception e) { + LOGGER.error("Fallback service failed: {}", e.getMessage()); + return "System is currently unavailable"; + } + } + + private void updateFallbackCache(String result) { + if (fallbackService instanceof LocalCacheService) { + ((LocalCacheService) fallbackService).updateCache("default", result); + } + } + + /** + * Shuts down the executor service and cleans up resources. + */ + public void shutdown() { + state = ExecutionState.SHUTDOWN; + executor.shutdown(); + try { + if (!executor.awaitTermination(5, TimeUnit.SECONDS)) { + executor.shutdownNow(); + } + } catch (InterruptedException e) { + executor.shutdownNow(); + Thread.currentThread().interrupt(); + LOGGER.error("Shutdown interrupted", e); + } + } + + /** + * Main method demonstrating the fallback pattern. + */ + public static void main(String[] args) { + App app = new App(); + try { + for (int i = 0; i < MAX_ATTEMPTS; i++) { + try { + String result = app.executeWithFallback(); + LOGGER.info("Attempt {}: Result = {}", i + 1, result); + } catch (Exception e) { + LOGGER.error("Attempt {} failed: {}", i + 1, e.getMessage()); + } + Thread.sleep(RETRY_DELAY); + } + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + LOGGER.error("Main thread interrupted", e); + } finally { + app.shutdown(); + } + } +} diff --git a/fallback/src/main/java/com/iluwatar/CircuitBreaker.java b/fallback/src/main/java/com/iluwatar/CircuitBreaker.java index e75617ed498d..a7a00cb8bfeb 100644 --- a/fallback/src/main/java/com/iluwatar/CircuitBreaker.java +++ b/fallback/src/main/java/com/iluwatar/CircuitBreaker.java @@ -1,53 +1,48 @@ -/* - * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). - * - * The MIT License - * Copyright © 2014-2022 Ilkka Seppälä - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ -package com.iluwatar; - -/** - * CircuitBreaker interface that defines methods to manage the state of a circuit breaker. - */ -public interface CircuitBreaker { - - /** - * Checks if the circuit breaker is open. - * - * @return true if the circuit breaker is open, false otherwise - */ - boolean isOpen(); - - /** - * Records a successful operation. - */ - void recordSuccess(); - - /** - * Records a failed operation. - */ - void recordFailure(); - - /** - * Resets the circuit breaker. - */ - void reset(); +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +/** + * Interface defining the contract for a circuit breaker implementation. + * Provides methods to check circuit state and record success/failure events. + */ +public interface CircuitBreaker { + boolean isOpen(); + boolean allowRequest(); + void recordSuccess(); + void recordFailure(); + CircuitState getState(); + void reset(); + + /** + * Represents the possible states of the circuit breaker. + * CLOSED - Circuit is closed and allowing requests + * HALF_OPEN - Circuit is testing if service has recovered + * OPEN - Circuit is open and blocking requests + */ + enum CircuitState { + CLOSED, HALF_OPEN, OPEN + } } \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java b/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java index 083f406b95e7..62d34acf6002 100644 --- a/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java +++ b/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java @@ -1,101 +1,173 @@ -/* - * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). - * - * The MIT License - * Copyright © 2014-2022 Ilkka Seppälä - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ -package com.iluwatar; - -import java.time.Duration; -import java.util.Queue; -import java.util.concurrent.ConcurrentLinkedQueue; - -/** - * DefaultCircuitBreaker class that implements the CircuitBreaker interface. - * It manages the state of a circuit breaker with a failure threshold and reset timeout. - */ -public final class DefaultCircuitBreaker implements CircuitBreaker { - private final int failureThreshold; - private long lastFailureTime; - private State state; - private static final long RESET_TIMEOUT = 5000; - private final Queue failureTimestamps; - private final Duration windowSize; - - /** - * Constructs a DefaultCircuitBreaker with the given failure threshold. - * - * @param failureThreshold the number of failures to trigger the circuit breaker - */ - public DefaultCircuitBreaker(final int failureThreshold) { - this.failureThreshold = failureThreshold; - this.state = State.CLOSED; - this.failureTimestamps = new ConcurrentLinkedQueue<>(); - this.windowSize = Duration.ofMinutes(1); - } - - @Override - public boolean isOpen() { - if (state == State.OPEN) { - if (System.currentTimeMillis() - lastFailureTime > RESET_TIMEOUT) { - state = State.HALF_OPEN; - return false; - } - return true; - } - return false; - } - - @Override - public void recordSuccess() { - failureTimestamps.clear(); - state = State.CLOSED; - } - - @Override - public void recordFailure() { - long now = System.currentTimeMillis(); - failureTimestamps.offer(now); - - while (!failureTimestamps.isEmpty() - && failureTimestamps.peek() < now - windowSize.toMillis()) { - failureTimestamps.poll(); - } - - if (failureTimestamps.size() >= failureThreshold) { - state = State.OPEN; - lastFailureTime = now; - } - } - - @Override - public void reset() { - failureTimestamps.clear(); - lastFailureTime = 0; - state = State.CLOSED; - } - - private enum State { - CLOSED, - OPEN, - HALF_OPEN - } +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import java.time.Duration; +import java.time.Instant; +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedQueue; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Circuit breaker implementation with three states: + * - CLOSED: Normal operation, requests flow through + * - OPEN: Failing fast, no attempts to call primary service + * - HALF_OPEN: Testing if service has recovered. + * + *

Features: + * - Thread-safe operation + * - Sliding window failure counting + * - Automatic state transitions + * - Configurable thresholds and timeouts + * - Recovery validation period + */ +public class DefaultCircuitBreaker implements CircuitBreaker { + private static final Logger LOGGER = LoggerFactory.getLogger(DefaultCircuitBreaker.class); + + // Circuit breaker configuration + private static final long RESET_TIMEOUT = 5000; // 5 seconds + private static final Duration MIN_HALF_OPEN_DURATION = Duration.ofSeconds(30); + + private volatile State state; + private final int failureThreshold; + private volatile long lastFailureTime; + private final Queue failureTimestamps; + private final Duration windowSize; + private volatile Instant halfOpenStartTime; + + /** + * Constructs a DefaultCircuitBreaker with the given failure threshold. + * + * @param failureThreshold the number of failures to trigger the circuit breaker + */ + public DefaultCircuitBreaker(final int failureThreshold) { + this.failureThreshold = failureThreshold; + this.state = State.CLOSED; + this.failureTimestamps = new ConcurrentLinkedQueue<>(); + this.windowSize = Duration.ofMinutes(1); + } + + /** + * Checks if a request should be allowed through the circuit breaker. + * @return true if request should be allowed, false if it should be blocked + */ + @Override + public synchronized boolean allowRequest() { + checkAndTransitionState(); + return state != State.OPEN; + } + + @Override + public synchronized boolean isOpen() { + checkAndTransitionState(); + return state == State.OPEN; + } + + /** + * Transitions circuit breaker to half-open state. + * Clears failure history and starts recovery monitoring. + */ + private synchronized void transitionToHalfOpen() { + state = State.HALF_OPEN; + halfOpenStartTime = Instant.now(); + failureTimestamps.clear(); + LOGGER.info("Circuit breaker transitioning to HALF_OPEN state"); + } + + /** + * Records successful operation. + * In half-open state, requires sustained success before closing circuit. + */ + @Override + public synchronized void recordSuccess() { + if (state == State.HALF_OPEN) { + if (Duration.between(halfOpenStartTime, Instant.now()) + .compareTo(MIN_HALF_OPEN_DURATION) >= 0) { + LOGGER.info("Circuit breaker recovering - transitioning to CLOSED"); + state = State.CLOSED; + } + } + failureTimestamps.clear(); + } + + @Override + public synchronized void recordFailure() { + long now = System.currentTimeMillis(); + failureTimestamps.offer(now); + + // Cleanup old timestamps outside window + while (!failureTimestamps.isEmpty() + && failureTimestamps.peek() < now - windowSize.toMillis()) { + failureTimestamps.poll(); + } + + if (failureTimestamps.size() >= failureThreshold) { + LOGGER.warn("Failure threshold reached - opening circuit breaker"); + state = State.OPEN; + lastFailureTime = now; + } + } + + @Override + public void reset() { + failureTimestamps.clear(); + lastFailureTime = 0; + state = State.CLOSED; + } + + /** + * Returns the current state of the circuit breaker mapped to the public enum. + * @return Current CircuitState value + */ + @Override + public synchronized CircuitState getState() { + checkAndTransitionState(); + 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. + */ + private enum State { + CLOSED, + OPEN, + HALF_OPEN + } } \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/FallbackService.java b/fallback/src/main/java/com/iluwatar/FallbackService.java index fe44fbf5b90d..4b573ffdba0e 100644 --- a/fallback/src/main/java/com/iluwatar/FallbackService.java +++ b/fallback/src/main/java/com/iluwatar/FallbackService.java @@ -6,6 +6,7 @@ * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal + * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is @@ -32,20 +33,51 @@ import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -import java.util.logging.Logger; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** - * FallbackService class that implements the fallback pattern. + * FallbackService implements a resilient service pattern with circuit breaking, + * rate limiting, and fallback capabilities. It manages service degradation gracefully + * by monitoring service health and automatically switching to fallback mechanisms + * when the primary service is unavailable or performing poorly. + * + *

Features: + * - Circuit breaking to prevent cascading failures. + * - Rate limiting to protect from overload. + * - Automatic fallback to backup service. + * - Health monitoring and metrics collection. + * - Retry mechanism with exponential backoff. */ public class FallbackService implements Service, AutoCloseable { - private static final Logger LOGGER = Logger.getLogger(FallbackService.class.getName()); + + /** Logger for this class. */ + private static final Logger LOGGER = LoggerFactory.getLogger(FallbackService.class); + + /** Timeout in seconds for primary service calls. */ private static final int TIMEOUT = 2; + + /** Maximum number of retry attempts for failed requests. */ private static final int MAX_RETRIES = 3; + + /** Base delay between retries in milliseconds. */ private static final long RETRY_DELAY_MS = 1000; + + /** Minimum success rate threshold before triggering warnings. */ private static final double MIN_SUCCESS_RATE = 0.6; + + /** Maximum requests allowed per minute for rate limiting. */ private static final int MAX_REQUESTS_PER_MINUTE = 60; + + /** Service state tracking. */ + private enum ServiceState { + STARTING, RUNNING, DEGRADED, CLOSED + } + + private volatile ServiceState state = ServiceState.STARTING; private final CircuitBreaker circuitBreaker; private final ExecutorService executor; @@ -54,16 +86,22 @@ public class FallbackService implements Service, AutoCloseable { private final ServiceMonitor monitor; private final ScheduledExecutorService healthChecker; private final RateLimiter rateLimiter; - private volatile boolean closed = false; /** - * Constructs a FallbackService with the specified primary and fallback services and a circuit breaker. + * Constructs a new FallbackService with the specified components. * - * @param primaryService the primary service to use - * @param fallbackService the fallback service to use - * @param circuitBreaker the circuit breaker to use + * @param primaryService Main service implementation + * @param fallbackService Backup service for failover + * @param circuitBreaker Circuit breaker for failure detection + * @throws IllegalArgumentException if any parameter is null */ public FallbackService(Service primaryService, Service fallbackService, CircuitBreaker circuitBreaker) { + // Validate parameters + if (primaryService == null || fallbackService == null || circuitBreaker == null) { + throw new IllegalArgumentException("All service components must be non-null"); + } + + // Initialize components this.primaryService = primaryService; this.fallbackService = fallbackService; this.circuitBreaker = circuitBreaker; @@ -73,19 +111,24 @@ public FallbackService(Service primaryService, Service fallbackService, CircuitB this.rateLimiter = new RateLimiter(MAX_REQUESTS_PER_MINUTE, Duration.ofMinutes(1)); startHealthChecker(); + state = ServiceState.RUNNING; } + /** + * Starts the health monitoring schedule. + * Monitors service health metrics and logs warnings when thresholds are exceeded. + */ private void startHealthChecker() { healthChecker.scheduleAtFixedRate(() -> { try { if (monitor.getSuccessRate() < MIN_SUCCESS_RATE) { - LOGGER.warning("Success rate below threshold: " + monitor.getSuccessRate()); + LOGGER.warn("Success rate below threshold: {}", monitor.getSuccessRate()); } if (Duration.between(monitor.getLastSuccessTime(), Instant.now()).toMinutes() > 5) { - LOGGER.warning("No successful requests in last 5 minutes"); + LOGGER.warn("No successful requests in last 5 minutes"); } } catch (Exception e) { - LOGGER.severe("Health check failed: " + e.getMessage()); + LOGGER.error("Health check failed: {}", e.getMessage()); } }, 1, 1, TimeUnit.MINUTES); } @@ -98,17 +141,23 @@ private void startHealthChecker() { */ @Override public String getData() throws Exception { - if (closed) { + // Validate service state + if (state == ServiceState.CLOSED) { throw new ServiceException("Service is closed"); } - + + // Apply rate limiting if (!rateLimiter.tryAcquire()) { + state = ServiceState.DEGRADED; + LOGGER.warn("Rate limit exceeded, switching to fallback"); monitor.recordFallback(); return executeFallback(); } - - if (circuitBreaker.isOpen()) { - LOGGER.info("Circuit breaker is open, using fallback"); + + // Check circuit breaker + if (!circuitBreaker.allowRequest()) { + state = ServiceState.DEGRADED; + LOGGER.warn("Circuit breaker open, switching to fallback"); monitor.recordFallback(); return executeFallback(); } @@ -118,6 +167,13 @@ public String getData() throws Exception { for (int attempt = 0; attempt < MAX_RETRIES; attempt++) { try { + if (attempt > 0) { + // Exponential backoff with jitter + long delay = RETRY_DELAY_MS * (long) Math.pow(2, attempt - 1); + delay += ThreadLocalRandom.current().nextLong(delay / 2); + Thread.sleep(delay); + } + String result = executeWithTimeout(primaryService::getData); Duration responseTime = Duration.between(start, Instant.now()); @@ -128,23 +184,32 @@ public String getData() throws Exception { return result; } catch (Exception e) { lastException = e; - LOGGER.warning("Attempt " + (attempt + 1) + " failed: " + e.getMessage()); - circuitBreaker.recordFailure(); - monitor.recordError(); + LOGGER.warn("Attempt {} failed: {}", attempt + 1, e.getMessage()); - if (attempt < MAX_RETRIES - 1) { - Thread.sleep(RETRY_DELAY_MS * (attempt + 1)); // Exponential backoff + // Don't retry certain exceptions + if (e instanceof ServiceException + || e instanceof IllegalArgumentException) { + break; } + + circuitBreaker.recordFailure(); + monitor.recordError(); } } monitor.recordFallback(); if (lastException != null) { - LOGGER.severe("All attempts failed. Last error: " + lastException.getMessage()); + LOGGER.error("All attempts failed. Last error: {}", lastException.getMessage()); } return executeFallback(); } + /** + * Executes a service call with timeout protection. + * @param task The service call to execute + * @return The service response + * @throws Exception if the call fails or times out + */ private String executeWithTimeout(Callable task) throws Exception { Future future = executor.submit(task); try { @@ -159,7 +224,7 @@ private String executeFallback() { try { return fallbackService.getData(); } catch (Exception e) { - LOGGER.severe("Fallback service failed: " + e.getMessage()); + LOGGER.error("Fallback service failed: {}", e.getMessage()); return "Service temporarily unavailable"; } } @@ -170,7 +235,7 @@ private void updateFallbackCache(String result) { ((LocalCacheService) fallbackService).updateCache("default", result); } } catch (Exception e) { - LOGGER.warning("Failed to update fallback cache: " + e.getMessage()); + LOGGER.warn("Failed to update fallback cache: {}", e.getMessage()); } } @@ -178,8 +243,8 @@ private void updateFallbackCache(String result) { * Shuts down the executor service. */ @Override - public void close() { - closed = true; + public void close() throws Exception { + state = ServiceState.CLOSED; executor.shutdown(); healthChecker.shutdown(); try { @@ -193,6 +258,7 @@ public void close() { executor.shutdownNow(); healthChecker.shutdownNow(); Thread.currentThread().interrupt(); + throw new Exception("Failed to shutdown executors", e); } } @@ -200,6 +266,18 @@ public ServiceMonitor getMonitor() { return monitor; } + /** + * Returns the current service state. + * @return Current ServiceState enum value + */ + public ServiceState getState() { + return state; + } + + /** + * Rate limiter implementation using a sliding window approach. + * Manages request rate by tracking timestamps within a rolling time window. + */ private static class RateLimiter { private final int maxRequests; private final Duration window; @@ -214,7 +292,7 @@ boolean tryAcquire() { long now = System.currentTimeMillis(); long windowStart = now - window.toMillis(); - // Remove expired timestamps + // Removing expired timestamps while (!requestTimestamps.isEmpty() && requestTimestamps.peek() < windowStart) { requestTimestamps.poll(); } diff --git a/fallback/src/main/java/com/iluwatar/LocalCacheService.java b/fallback/src/main/java/com/iluwatar/LocalCacheService.java index 59cedc70490b..9eeb6b7a8c8b 100644 --- a/fallback/src/main/java/com/iluwatar/LocalCacheService.java +++ b/fallback/src/main/java/com/iluwatar/LocalCacheService.java @@ -1,97 +1,198 @@ -/* - * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). - * - * The MIT License - * Copyright © 2014-2022 Ilkka Seppälä - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ -package com.iluwatar; - -import java.util.concurrent.ConcurrentHashMap; // Add this import - -/** - * LocalCacheService implementation that provides cached data as a fallback mechanism. - * This service stores and retrieves data from a local cache with expiration support. - */ -public class LocalCacheService implements Service { - private final Cache cache; - private static final long CACHE_EXPIRY_MS = 300000; // 5 minutes - - private static final String[] DEFAULT_KEYS = {"default", "backup1", "backup2"}; - private static final String[] DEFAULT_VALUES = { - "Default fallback response", - "Secondary fallback response", - "Tertiary fallback response" - }; - - public LocalCacheService() { - this.cache = new Cache<>(CACHE_EXPIRY_MS); - initializeDefaultCache(); - } - - private void initializeDefaultCache() { - for (int i = 0; i < DEFAULT_KEYS.length; i++) { - cache.put(DEFAULT_KEYS[i], DEFAULT_VALUES[i]); - } - } - - @Override - public String getData() throws Exception { - // Try all cache entries in order until a valid one is found - for (String key : DEFAULT_KEYS) { - String value = cache.get(key); - if (value != null) { - return value; - } - } - throw new Exception("No valid cache entry found"); - } - - public void updateCache(String key, String value) { - cache.put(key, value); - } - - private static class Cache { - private final ConcurrentHashMap> map = new ConcurrentHashMap<>(); - private final long expiryMs; - - Cache(long expiryMs) { - this.expiryMs = expiryMs; - } - - V get(K key) { - CacheEntry entry = map.get(key); - if (entry != null && !entry.isExpired()) { - return entry.value; - } - return null; - } - - void put(K key, V value) { - map.put(key, new CacheEntry<>(value, System.currentTimeMillis() + expiryMs)); - } - - private record CacheEntry(V value, long expiryTime) { - boolean isExpired() { - return System.currentTimeMillis() > expiryTime; - } - } - } +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import ch.qos.logback.classic.Logger; +import java.time.Duration; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import org.slf4j.LoggerFactory; + +/** + * LocalCacheService implementation that provides cached data with fallback mechanism. + * This service maintains a local cache with multiple fallback levels and automatic + * expiration of cached entries. If the primary data source fails, the service + * falls back to cached data in order of priority. + */ +public class LocalCacheService implements Service, AutoCloseable { + + /** Cache instance for storing key-value pairs. */ + private final Cache cache; + + /** Default cache entry expiration time in milliseconds. */ + private static final long CACHE_EXPIRY_MS = 300000; + + /** Logger instance for this class. */ + private static final Logger LOGGER = (Logger) LoggerFactory.getLogger(LocalCacheService.class); + + /** Interval for periodic cache refresh operations. */ + private static final Duration CACHE_REFRESH_INTERVAL = Duration.ofMinutes(5); + + /** Executor service for scheduling cache maintenance tasks. */ + private final ScheduledExecutorService refreshExecutor; + + /** + * Defines the fallback chain priority levels. + * Entries are tried in order from PRIMARY to TERTIARY until valid data is found. + */ + private enum FallbackLevel { + PRIMARY("default"), + SECONDARY("backup1"), + TERTIARY("backup2"); + + private final String key; + + FallbackLevel(String key) { + this.key = key; + } + } + + /** + * Constructs a new LocalCacheService with initialized cache and scheduled maintenance. + */ + public LocalCacheService() { + this.cache = new Cache<>(CACHE_EXPIRY_MS); + this.refreshExecutor = Executors.newSingleThreadScheduledExecutor(); + initializeDefaultCache(); + scheduleMaintenanceTasks(); + } + + /** + * Initializes the cache with default fallback values. + */ + private void initializeDefaultCache() { + cache.put(FallbackLevel.PRIMARY.key, "Default fallback response"); + cache.put(FallbackLevel.SECONDARY.key, "Secondary fallback response"); + cache.put(FallbackLevel.TERTIARY.key, "Tertiary fallback response"); + } + + /** + * Schedules periodic cache maintenance tasks. + */ + private void scheduleMaintenanceTasks() { + refreshExecutor.scheduleAtFixedRate( + this::cleanupExpiredEntries, + CACHE_REFRESH_INTERVAL.toMinutes(), + CACHE_REFRESH_INTERVAL.toMinutes(), + TimeUnit.MINUTES + ); + } + + /** + * Removes expired entries from the cache. + */ + private void cleanupExpiredEntries() { + try { + cache.cleanup(); + LOGGER.debug("Completed cache cleanup"); + } catch (Exception e) { + LOGGER.error("Error during cache cleanup", e); + } + } + + @Override + public void close() throws Exception { + if (refreshExecutor != null) { + refreshExecutor.shutdown(); + try { + if (!refreshExecutor.awaitTermination(5, TimeUnit.SECONDS)) { + refreshExecutor.shutdownNow(); + } + } catch (InterruptedException e) { + refreshExecutor.shutdownNow(); + Thread.currentThread().interrupt(); + throw new Exception("Failed to shutdown refresh executor", e); + } + } + } + + /** + * Retrieves data using the fallback chain mechanism. + * @return The cached data from the highest priority available fallback level. + * @throws Exception if no valid data is available at any fallback level. + */ + @Override + public String getData() throws Exception { + // Try each fallback level in order of priority + for (FallbackLevel level : FallbackLevel.values()) { + String value = cache.get(level.key); + if (value != null) { + LOGGER.debug("Retrieved value from {} fallback level", level); + return value; + } + LOGGER.debug("Cache miss at {} fallback level", level); + } + throw new Exception("All fallback levels exhausted"); + } + + /** + * Updates the cached data for a specific key. + * @param key The cache key to update. + * @param value The new value to cache. + */ + public void updateCache(String key, String value) { + cache.put(key, value); + } + + /** + * Thread-safe cache implementation with entry expiration. + */ + private static class Cache { + private final ConcurrentHashMap> map; + private final long expiryMs; + + Cache(long expiryMs) { + this.map = new ConcurrentHashMap<>(); + this.expiryMs = expiryMs; + } + + V get(K key) { + CacheEntry entry = map.get(key); + if (entry != null && !entry.isExpired()) { + return entry.value; + } + return null; + } + + void put(K key, V value) { + map.put(key, new CacheEntry<>(value, System.currentTimeMillis() + expiryMs)); + } + + /** + * Removes all expired entries from the cache. + */ + void cleanup() { + map.entrySet().removeIf(entry -> entry.getValue().isExpired()); + } + + private record CacheEntry(V value, long expiryTime) { + boolean isExpired() { + return System.currentTimeMillis() > expiryTime; + } + } + } } \ No newline at end of file diff --git a/fallback/src/main/java/com/iluwatar/RemoteService.java b/fallback/src/main/java/com/iluwatar/RemoteService.java index 6794bac6d902..43dc6eebe7e8 100644 --- a/fallback/src/main/java/com/iluwatar/RemoteService.java +++ b/fallback/src/main/java/com/iluwatar/RemoteService.java @@ -1,63 +1,63 @@ -/* - * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). - * - * The MIT License - * Copyright © 2014-2022 Ilkka Seppälä - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ -package com.iluwatar; - -import java.net.URI; -import java.net.http.HttpClient; -import java.net.http.HttpRequest; -import java.net.http.HttpResponse; -import java.time.Duration; - -/** - * RemoteService implementation that makes HTTP calls to an external API. - * This service acts as the primary service in the fallback pattern. - */ -public class RemoteService implements Service { - private final String apiUrl; - private final HttpClient httpClient; - private static final int TIMEOUT_SECONDS = 2; - - public RemoteService(String apiUrl, HttpClient httpClient) { - this.apiUrl = apiUrl; - this.httpClient = httpClient; - } - - @Override - public String getData() throws Exception { - HttpRequest request = HttpRequest.newBuilder() - .uri(URI.create(apiUrl)) - .timeout(Duration.ofSeconds(TIMEOUT_SECONDS)) - .GET() - .build(); - - HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); - - if (response.statusCode() != 200) { - throw new Exception("Remote service failed with status code: " + response.statusCode()); - } - - return response.body(); - } -} +/* + * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt). + * + * The MIT License + * Copyright © 2014-2022 Ilkka Seppälä + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ +package com.iluwatar; + +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.time.Duration; + +/** + * RemoteService implementation that makes HTTP calls to an external API. + * This service acts as the primary service in the fallback pattern. + */ +public class RemoteService implements Service { + private final String apiUrl; + private final HttpClient httpClient; + private static final int TIMEOUT_SECONDS = 2; + + public RemoteService(String apiUrl, HttpClient httpClient) { + this.apiUrl = apiUrl; + this.httpClient = httpClient; + } + + @Override + public String getData() throws Exception { + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create(apiUrl)) + .timeout(Duration.ofSeconds(TIMEOUT_SECONDS)) + .GET() + .build(); + + HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); + + if (response.statusCode() != 200) { + throw new Exception("Remote service failed with status code: " + response.statusCode()); + } + + return response.body(); + } +} diff --git a/fallback/src/main/java/com/iluwatar/ServiceException.java b/fallback/src/main/java/com/iluwatar/ServiceException.java index 7001c1b0eb9f..51611f72e9b9 100644 --- a/fallback/src/main/java/com/iluwatar/ServiceException.java +++ b/fallback/src/main/java/com/iluwatar/ServiceException.java @@ -1,19 +1,33 @@ -package com.iluwatar; - -import java.io.Serial; - -/** - * Custom exception class for service-related errors in the fallback pattern. - */ -public class ServiceException extends Exception { - @Serial - private static final long serialVersionUID = 1L; - - public ServiceException(String message) { - super(message); - } - - public ServiceException(String message, Throwable cause) { - super(message, cause); - } -} +package com.iluwatar; + +import java.io.Serial; + +/** + * Custom exception class for service-related errors in the fallback pattern. + * This exception is thrown when a service operation fails and needs to be handled + * by the fallback mechanism. + */ +public class ServiceException extends Exception { + + @Serial + private static final long serialVersionUID = 1L; + + /** + * Constructs a new ServiceException with the specified detail message. + * + * @param message the detail message describing the error + */ + public ServiceException(String message) { + super(message); + } + + /** + * Constructs a new ServiceException with the specified detail message and cause. + * + * @param message the detail message describing the error + * @param cause the cause of the exception + */ + public ServiceException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/fallback/src/main/java/com/iluwatar/ServiceMonitor.java b/fallback/src/main/java/com/iluwatar/ServiceMonitor.java index bb9827f335a9..53e04f7b01af 100644 --- a/fallback/src/main/java/com/iluwatar/ServiceMonitor.java +++ b/fallback/src/main/java/com/iluwatar/ServiceMonitor.java @@ -1,122 +1,180 @@ -package com.iluwatar; - -import java.time.Duration; -import java.time.Instant; -import java.util.Queue; -import java.util.concurrent.ConcurrentLinkedQueue; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicReference; - -/** - * ServiceMonitor class provides monitoring capabilities for tracking service performance metrics. - * It maintains thread-safe counters for success, fallback, and error rates, as well as timing information. - */ -public class ServiceMonitor { - private final AtomicInteger successCount = new AtomicInteger(0); - private final AtomicInteger fallbackCount = new AtomicInteger(0); - private final AtomicInteger errorCount = new AtomicInteger(0); - private final AtomicReference lastSuccessTime = new AtomicReference<>(Instant.now()); - private final AtomicReference lastFailureTime = new AtomicReference<>(Instant.now()); - private final AtomicReference lastResponseTime = new AtomicReference<>(Duration.ZERO); - - // Add sliding window for metrics - private final Queue metrics = new ConcurrentLinkedQueue<>(); - private final Duration metricWindow = Duration.ofMinutes(5); - - private record ServiceMetric(Instant timestamp, MetricType type, Duration responseTime) {} - private enum MetricType { SUCCESS, FALLBACK, ERROR } - - /** - * Records a successful service operation with its response time. - * - * @param responseTime the duration of the successful operation - */ - public void recordSuccess(Duration responseTime) { - successCount.incrementAndGet(); - lastSuccessTime.set(Instant.now()); - lastResponseTime.set(responseTime); - metrics.offer(new ServiceMetric(Instant.now(), MetricType.SUCCESS, responseTime)); - pruneOldMetrics(); - } - - /** - * Records a fallback operation in the monitoring metrics. - * This method increments the fallback counter and adds a new metric to the sliding window. - */ - public void recordFallback() { - fallbackCount.incrementAndGet(); - lastFailureTime.set(Instant.now()); - metrics.offer(new ServiceMetric(Instant.now(), MetricType.FALLBACK, Duration.ZERO)); - pruneOldMetrics(); - } - - /** - * Records an error operation in the monitoring metrics. - * This method increments the error counter, updates the last failure time, - * and adds a new metric to the sliding window. - */ - public void recordError() { - errorCount.incrementAndGet(); - lastFailureTime.set(Instant.now()); - metrics.offer(new ServiceMetric(Instant.now(), MetricType.ERROR, Duration.ZERO)); - pruneOldMetrics(); - } - - public int getSuccessCount() { - return successCount.get(); - } - - public int getFallbackCount() { - return fallbackCount.get(); - } - - public int getErrorCount() { - return errorCount.get(); - } - - public Instant getLastSuccessTime() { - return lastSuccessTime.get(); - } - - public Instant getLastFailureTime() { - return lastFailureTime.get(); - } - - public Duration getLastResponseTime() { - return lastResponseTime.get(); - } - - /** - * Calculates the success rate of service operations. - * The rate is calculated as the ratio of successful operations to total operations, - * treating fallbacks as partial successes. - * - * @return the success rate as a double between 0.0 and 1.0 - */ - public double getSuccessRate() { - int total = successCount.get() + errorCount.get(); - if (total == 0) { - return 1.0; // Return 1.0 for initial state with no requests - } - return (double) successCount.get() / total; - } - - /** - * Resets all monitoring statistics to their initial values. - * This includes resetting all counters to zero and setting timestamps to current time. - */ - public void reset() { - successCount.set(0); - fallbackCount.set(0); - errorCount.set(0); - lastSuccessTime.set(Instant.now()); - lastFailureTime.set(Instant.now()); - lastResponseTime.set(Duration.ZERO); - metrics.clear(); - } - - private void pruneOldMetrics() { - Instant cutoff = Instant.now().minus(metricWindow); - metrics.removeIf(metric -> metric.timestamp.isBefore(cutoff)); - } -} +package com.iluwatar; + +import java.time.Duration; +import java.time.Instant; +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + +/** + * ServiceMonitor class provides monitoring capabilities for tracking service performance metrics. + * It maintains thread-safe counters for success, fallback, and error rates, as well as timing information. + */ +public class ServiceMonitor { + private final AtomicInteger successCount = new AtomicInteger(0); + private final AtomicInteger fallbackCount = new AtomicInteger(0); + private final AtomicInteger errorCount = new AtomicInteger(0); + private final AtomicReference lastSuccessTime = new AtomicReference<>(Instant.now()); + private final AtomicReference lastFailureTime = new AtomicReference<>(Instant.now()); + private final AtomicReference lastResponseTime = new AtomicReference<>(Duration.ZERO); + + // Sliding window for metrics + private final Queue metrics = new ConcurrentLinkedQueue<>(); + + private record ServiceMetric(Instant timestamp, MetricType type, Duration responseTime) {} + private enum MetricType { SUCCESS, FALLBACK, ERROR } + + /** + * Weight applied to fallback operations when calculating success rate. + * Values between 0.0 and 1.0: + * - 1.0 means fallbacks count as full successes + * - 0.0 means fallbacks count as failures + * - Default 0.7 indicates fallbacks are "partial successes" since they provide + * degraded but still functional service to users + */ + private final double fallbackWeight; + + /** + * Duration for which metrics should be retained. + * Metrics older than this window will be removed during pruning. + */ + private final Duration metricWindow; + + /** + * Constructs a ServiceMonitor with default configuration. + * Uses default fallback weight of 0.7 and 5-minute metric window. + */ + public ServiceMonitor() { + this(0.7, Duration.ofMinutes(5)); + } + + /** + * Constructs a ServiceMonitor with the specified fallback weight and metric window. + * + * @param fallbackWeight weight applied to fallback operations (0.0 to 1.0) + * @param metricWindow duration for which metrics should be retained + * @throws IllegalArgumentException if parameters are invalid + */ + public ServiceMonitor(double fallbackWeight, Duration metricWindow) { + if (fallbackWeight < 0.0 || fallbackWeight > 1.0) { + throw new IllegalArgumentException("Fallback weight must be between 0.0 and 1.0"); + } + if (metricWindow.isNegative() || metricWindow.isZero()) { + throw new IllegalArgumentException("Metric window must be positive"); + } + this.fallbackWeight = fallbackWeight; + this.metricWindow = metricWindow; + } + + /** + * Records a successful service operation with its response time. + * + * @param responseTime the duration of the successful operation + */ + public void recordSuccess(Duration responseTime) { + successCount.incrementAndGet(); + lastSuccessTime.set(Instant.now()); + lastResponseTime.set(responseTime); + metrics.offer(new ServiceMetric(Instant.now(), MetricType.SUCCESS, responseTime)); + pruneOldMetrics(); + } + + /** + * Records a fallback operation in the monitoring metrics. + * This method increments the fallback counter and updates metrics. + * Fallbacks are considered as degraded successes. + */ + public void recordFallback() { + fallbackCount.incrementAndGet(); + Instant now = Instant.now(); + Duration responseTime = lastResponseTime.get(); + metrics.offer(new ServiceMetric(now, MetricType.FALLBACK, responseTime)); + pruneOldMetrics(); + } + + /** + * Records an error operation in the monitoring metrics. + * This method increments the error counter, updates the last failure time, + * and adds a new metric to the sliding window. + */ + public void recordError() { + errorCount.incrementAndGet(); + Instant now = Instant.now(); + lastFailureTime.set(now); + Duration responseTime = lastResponseTime.get(); + metrics.offer(new ServiceMetric(now, MetricType.ERROR, responseTime)); + pruneOldMetrics(); + } + + public int getSuccessCount() { + return successCount.get(); + } + + public int getFallbackCount() { + return fallbackCount.get(); + } + + public int getErrorCount() { + return errorCount.get(); + } + + public Instant getLastSuccessTime() { + return lastSuccessTime.get(); + } + + public Instant getLastFailureTime() { + return lastFailureTime.get(); + } + + public Duration getLastResponseTime() { + return lastResponseTime.get(); + } + + /** + * Calculates the success rate of service operations. + * The rate is calculated as successes / total attempts, + * where both fallbacks and errors count as failures. + * + * @return the success rate as a double between 0.0 and 1.0 + */ + public double getSuccessRate() { + int successes = successCount.get(); + int fallbacks = fallbackCount.get(); + int errors = errorCount.get(); + int totalAttempts = successes + fallbacks + errors; + + if (totalAttempts == 0) { + return 0.0; + } + + // Weight fallbacks as partial successes since they provide degraded but functional service + return (successes + (fallbacks * fallbackWeight)) / totalAttempts; + } + + /** + * Resets all monitoring metrics to their initial values. + * This includes success count, error count, fallback count, and timing statistics. + */ + public void reset() { + successCount.set(0); + fallbackCount.set(0); + errorCount.set(0); + lastSuccessTime.set(Instant.now()); + lastFailureTime.set(Instant.now()); + lastResponseTime.set(Duration.ZERO); + metrics.clear(); + } + + /** + * Removes metrics that are older than the configured time window. + * This method is called automatically after each new metric is added + * to maintain a sliding window of recent metrics and prevent unbounded + * memory growth. + */ + private void pruneOldMetrics() { + Instant cutoff = Instant.now().minus(metricWindow); + metrics.removeIf(metric -> metric.timestamp.isBefore(cutoff)); + } +} + diff --git a/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java b/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java index acaa252bc145..b38cfc42e166 100644 --- a/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java +++ b/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java @@ -1,74 +1,140 @@ -package com.iluwatar; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.*; - -class DefaultCircuitBreakerTest { - private DefaultCircuitBreaker circuitBreaker; - private static final int FAILURE_THRESHOLD = 3; - - @BeforeEach - void setUp() { - circuitBreaker = new DefaultCircuitBreaker(FAILURE_THRESHOLD); - } - - @Test - void testInitialState() { - assertFalse(circuitBreaker.isOpen()); - } - - @Test - void testOpenStateAfterFailures() { - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - assertTrue(circuitBreaker.isOpen()); - } - - @Test - void testHalfOpenStateAfterTimeout() throws InterruptedException { - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - assertTrue(circuitBreaker.isOpen()); - - // Wait for reset timeout - Thread.sleep(5100); - assertFalse(circuitBreaker.isOpen()); - } - - @Test - void testSuccessResetsFailureCount() { - circuitBreaker.recordFailure(); - circuitBreaker.recordFailure(); - circuitBreaker.recordSuccess(); - - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - assertTrue(circuitBreaker.isOpen()); - } - - @Test - void testReset() { - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - assertTrue(circuitBreaker.isOpen()); - - circuitBreaker.reset(); - assertFalse(circuitBreaker.isOpen()); - } - - @Test - void testFailureThresholdBoundary() { - for (int i = 0; i < FAILURE_THRESHOLD - 1; i++) { - circuitBreaker.recordFailure(); - assertFalse(circuitBreaker.isOpen()); - } - - circuitBreaker.recordFailure(); - assertTrue(circuitBreaker.isOpen()); - } -} +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Unit tests for {@link DefaultCircuitBreaker}. + * Tests state transitions and behaviors of the circuit breaker pattern implementation. + */ +class DefaultCircuitBreakerTest { + private DefaultCircuitBreaker circuitBreaker; + + private static final int FAILURE_THRESHOLD = 3; + private static final long RESET_TIMEOUT_MS = 5000; + private static final long WAIT_BUFFER = 100; + + @BeforeEach + void setUp() { + circuitBreaker = new DefaultCircuitBreaker(FAILURE_THRESHOLD); + } + + @Nested + @DisplayName("State Transition Tests") + class StateTransitionTests { + @Test + @DisplayName("Should start in CLOSED state") + void initialStateShouldBeClosed() { + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should transition to OPEN after threshold failures") + void shouldTransitionToOpenAfterFailures() { + // When + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + + // Then + assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); + assertFalse(circuitBreaker.allowRequest()); + assertTrue(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should transition to HALF-OPEN after timeout") + void shouldTransitionToHalfOpenAfterTimeout() throws InterruptedException { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + + // When + Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); + + // Then + assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + assertFalse(circuitBreaker.isOpen()); + } + } + + @Nested + @DisplayName("Behavior Tests") + class BehaviorTests { + @Test + @DisplayName("Success should reset failure count") + void successShouldResetFailureCount() { + // Given + circuitBreaker.recordFailure(); + circuitBreaker.recordFailure(); + + // When + circuitBreaker.recordSuccess(); + + // Then + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + + // Additional verification + circuitBreaker.recordFailure(); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Reset should return to initial state") + void resetShouldReturnToInitialState() { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + + // When + circuitBreaker.reset(); + + // Then + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should respect failure threshold boundary") + void shouldRespectFailureThresholdBoundary() { + // When/Then + for (int i = 0; i < FAILURE_THRESHOLD - 1; i++) { + circuitBreaker.recordFailure(); + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertFalse(circuitBreaker.isOpen()); + } + + circuitBreaker.recordFailure(); + assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); + assertTrue(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should allow request in HALF-OPEN state") + void shouldAllowRequestInHalfOpenState() throws InterruptedException { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + + // When + Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); + + // Then + assertTrue(circuitBreaker.allowRequest()); + assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); + } + } +} diff --git a/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java b/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java index 7f54b3481e70..c0721f3e554d 100644 --- a/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java +++ b/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java @@ -1,369 +1,216 @@ -package com.iluwatar; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import java.util.ArrayList; -import java.util.List; -import java.util.concurrent.*; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicBoolean; -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.Mockito.*; - -class FallbackServiceTest { - @Mock private Service primaryService; - @Mock private Service fallbackService; - @Mock private CircuitBreaker circuitBreaker; - private FallbackService fallbackServiceUnderTest; - - @BeforeEach - void setUp() { - MockitoAnnotations.openMocks(this); - fallbackServiceUnderTest = new FallbackService(primaryService, fallbackService, circuitBreaker); - } - - @Test - void testSuccessfulPrimaryService() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenReturn("success"); - - String result = fallbackServiceUnderTest.getData(); - - assertEquals("success", result); - verify(primaryService, times(1)).getData(); - verify(fallbackService, never()).getData(); - verify(circuitBreaker).recordSuccess(); - } - - @Test - void testFallbackWhenPrimaryFails() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenThrow(new TimeoutException()); - when(fallbackService.getData()).thenReturn("fallback"); - - String result = fallbackServiceUnderTest.getData(); - - assertEquals("fallback", result); - verify(primaryService, times(3)).getData(); - verify(fallbackService, times(1)).getData(); - verify(circuitBreaker, times(3)).recordFailure(); - } - - @Test - void testCircuitBreakerOpen() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(true); - when(fallbackService.getData()).thenReturn("fallback"); - - String result = fallbackServiceUnderTest.getData(); - - assertEquals("fallback", result); - verify(primaryService, never()).getData(); - verify(fallbackService, times(1)).getData(); - } - - @Test - void testFallbackServiceFailure() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenThrow(new TimeoutException()); - when(fallbackService.getData()).thenThrow(new Exception("Fallback failed")); - - String result = fallbackServiceUnderTest.getData(); - - assertEquals("Service temporarily unavailable", result); - verify(primaryService, times(3)).getData(); - verify(fallbackService, times(1)).getData(); - } - - @Test - void testServiceClosedState() throws Exception { - fallbackServiceUnderTest.close(); - assertThrows(ServiceException.class, () -> fallbackServiceUnderTest.getData()); - } - - @Test - void testLocalCacheUpdateOnSuccess() throws Exception { - LocalCacheService localCache = new LocalCacheService(); - FallbackService service = new FallbackService(primaryService, localCache, circuitBreaker); - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenReturn("new data"); - - String result = service.getData(); - - assertEquals("new data", result); - assertEquals("new data", localCache.getData()); - } - - @Test - void testMonitoringMetricsAfterMultipleOperations() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()) - .thenReturn("success1") - .thenThrow(new TimeoutException()) - .thenThrow(new TimeoutException()) - .thenThrow(new TimeoutException()) - .thenReturn("success2"); - when(fallbackService.getData()).thenReturn("fallback"); - - // First call - success - String result1 = fallbackServiceUnderTest.getData(); - assertEquals("success1", result1); - - // Second call - fallback after retries - String result2 = fallbackServiceUnderTest.getData(); - assertEquals("fallback", result2); - - // Third call - success - String result3 = fallbackServiceUnderTest.getData(); - assertEquals("success2", result3); - - ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); - assertEquals(2, monitor.getSuccessCount()); - assertEquals(1, monitor.getFallbackCount()); - assertTrue(monitor.getSuccessRate() > 0.6); - } - - @Test - void testHealthCheck() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenThrow(new TimeoutException()); - when(fallbackService.getData()).thenReturn("fallback"); - - // Generate some failing requests - for (int i = 0; i < 10; i++) { - fallbackServiceUnderTest.getData(); - } - - // Wait for health check to run - Thread.sleep(2000); - - ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); - assertTrue(monitor.getSuccessRate() < 0.6); - } - - @Test - void testRetryBehavior() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()) - .thenThrow(new TimeoutException()) - .thenThrow(new TimeoutException()) - .thenReturn("success"); - - String result = fallbackServiceUnderTest.getData(); - - assertEquals("success", result); - verify(primaryService, times(3)).getData(); - verify(fallbackService, never()).getData(); - } - - @Test - void testCircuitBreakerTripping() throws Exception { - when(circuitBreaker.isOpen()) - .thenReturn(false) // First call - .thenReturn(false) // Second call - .thenReturn(true); // Third call - when(primaryService.getData()).thenThrow(new TimeoutException()); - when(fallbackService.getData()).thenReturn("fallback"); - - String result1 = fallbackServiceUnderTest.getData(); - String result2 = fallbackServiceUnderTest.getData(); - String result3 = fallbackServiceUnderTest.getData(); - - assertEquals("fallback", result1); - assertEquals("fallback", result2); - assertEquals("fallback", result3); - - // Verify primary service was called only during first two attempts - verify(primaryService, times(6)).getData(); // 3 retries * 2 attempts - verify(fallbackService, times(3)).getData(); // Called for each attempt - } - - @Test - void testConcurrentRequests() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenReturn("success"); - - // Simulate concurrent requests - Thread[] threads = new Thread[5]; - for (int i = 0; i < 5; i++) { - threads[i] = new Thread(() -> { - try { - fallbackServiceUnderTest.getData(); - } catch (Exception e) { - fail("Concurrent request failed: " + e.getMessage()); - } - }); - threads[i].start(); - } - - // Wait for all threads to complete - for (Thread thread : threads) { - thread.join(); - } - - verify(primaryService, times(5)).getData(); - } - - @Test - void testServiceMetricsAfterMultipleFailures() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenThrow(new TimeoutException()); - when(fallbackService.getData()).thenReturn("fallback"); - - // Generate multiple failures - for (int i = 0; i < 5; i++) { - fallbackServiceUnderTest.getData(); - } - - ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); - assertEquals(0, monitor.getSuccessCount()); - assertEquals(5, monitor.getFallbackCount()); - assertEquals(15, monitor.getErrorCount()); // 3 retries per attempt - } - - @Test - void testGracefulDegradation() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()) - .thenReturn("success") - .thenThrow(new TimeoutException()) - .thenThrow(new RuntimeException()) - .thenThrow(new OutOfMemoryError()); - when(fallbackService.getData()).thenReturn("fallback"); - - // First call succeeds - assertEquals("success", fallbackServiceUnderTest.getData()); - - // Subsequent calls should gracefully degrade to fallback - for (int i = 0; i < 3; i++) { - String result = fallbackServiceUnderTest.getData(); - assertEquals("fallback", result); - } - } - - @Test - void testSystemStability() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenReturn("success"); - when(fallbackService.getData()).thenReturn("fallback"); - - AtomicInteger requestCount = new AtomicInteger(); - AtomicInteger errorCount = new AtomicInteger(); - - long endTime = System.currentTimeMillis() + 5000; // 5 second test - while (System.currentTimeMillis() < endTime) { - try { - fallbackServiceUnderTest.getData(); - requestCount.incrementAndGet(); - } catch (Exception e) { - errorCount.incrementAndGet(); - } - Thread.sleep(50); // Prevent tight loop - } - - assertTrue(requestCount.get() > 0); - assertEquals(0, errorCount.get()); - assertTrue(fallbackServiceUnderTest.getMonitor().getSuccessRate() > 0.95); - } - - @Test - void testResourceExhaustion() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenAnswer(inv -> { - Thread.sleep(100); // Simulate processing time - return "success"; - }); - - // Create many concurrent requests - ExecutorService executor = Executors.newFixedThreadPool(50); - List> futures = new ArrayList<>(); - - for (int i = 0; i < 100; i++) { - futures.add(executor.submit(() -> fallbackServiceUnderTest.getData())); - } - - - - executor.shutdown(); - assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS)); - } - - @Test - void testRecoveryAfterFailure() throws Exception { - // Setup circuit breaker state transitions - when(circuitBreaker.isOpen()) - .thenReturn(false) // Initial attempt - .thenReturn(true) // Circuit open - .thenReturn(false); // Circuit reset - - // Setup primary service behavior - when(primaryService.getData()) - .thenThrow(new TimeoutException()) // Initial failure - .thenThrow(new TimeoutException()) // When circuit opens - .thenThrow(new TimeoutException()) // Third retry - .thenReturn("recovered"); // After reset - - // Setup fallback service behavior - when(fallbackService.getData()) - .thenReturn("fallback") - .thenReturn("fallback") - .thenReturn("fallback"); - - // Initial failure should trigger fallback - String result1 = fallbackServiceUnderTest.getData(); - assertEquals("fallback", result1); - - // Circuit is open, should use fallback without trying primary - String result2 = fallbackServiceUnderTest.getData(); - assertEquals("fallback", result2); - - // Circuit resets, primary service should be tried again - String result3 = fallbackServiceUnderTest.getData(); - assertEquals("recovered", result3); - - // Verify timing of success/failure - ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); - assertTrue(monitor.getLastSuccessTime().isAfter(monitor.getLastFailureTime())); - - // Verify correct number of calls - verify(primaryService, atLeast(3)).getData(); - verify(fallbackService, times(2)).getData(); - } - - @Test - void testReliabilityUnderLoad() throws Exception { - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()).thenReturn("success"); - when(fallbackService.getData()).thenReturn("fallback"); - - int totalRequests = 100; - CountDownLatch latch = new CountDownLatch(totalRequests); - AtomicInteger successCount = new AtomicInteger(); - AtomicInteger failureCount = new AtomicInteger(); - - ExecutorService executor = Executors.newFixedThreadPool(10); - try { - for (int i = 0; i < totalRequests; i++) { - executor.execute(() -> { - try { - fallbackServiceUnderTest.getData(); - successCount.incrementAndGet(); - } catch (Exception e) { - failureCount.incrementAndGet(); - } finally { - latch.countDown(); - } - }); - } - - assertTrue(latch.await(30, TimeUnit.SECONDS)); - assertTrue(successCount.get() >= 85, "Success count should be at least 85%"); - assertTrue(failureCount.get() <= 15, "Failure count should be no more than 15%"); - } finally { - executor.shutdown(); - executor.awaitTermination(5, TimeUnit.SECONDS); - } - } -} +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicInteger; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +/** + * Unit tests for {@link FallbackService}. + * Tests the fallback mechanism, circuit breaker integration, and service stability. + */ +class FallbackServiceTest { + @Mock private Service primaryService; + @Mock private Service fallbackService; + @Mock private CircuitBreaker circuitBreaker; + private FallbackService service; + + private static final int CONCURRENT_THREADS = 5; + private static final int REQUEST_COUNT = 100; + + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + service = new FallbackService(primaryService, fallbackService, circuitBreaker); + } + + @Nested + @DisplayName("Primary Service Tests") + class PrimaryServiceTests { + @Test + @DisplayName("Should use primary service when healthy") + void shouldUsePrimaryServiceWhenHealthy() throws Exception { + // Given + when(circuitBreaker.isOpen()).thenReturn(false); + when(circuitBreaker.allowRequest()).thenReturn(true); // Add this line + when(primaryService.getData()).thenReturn("success"); + doNothing().when(circuitBreaker).recordSuccess(); // Add this line + + // When + String result = service.getData(); + + // Then + assertEquals("success", result); + verify(primaryService).getData(); + verify(fallbackService, never()).getData(); + verify(circuitBreaker).recordSuccess(); + } + + @Test + @DisplayName("Should retry primary service on failure") + void shouldRetryPrimaryServiceOnFailure() throws Exception { + // Given + when(circuitBreaker.isOpen()).thenReturn(false); + when(circuitBreaker.allowRequest()).thenReturn(true); + when(primaryService.getData()) + .thenThrow(new TimeoutException()) + .thenThrow(new TimeoutException()) + .thenReturn("success"); + + // Make sure circuit breaker allows the retry attempts + doNothing().when(circuitBreaker).recordFailure(); + doNothing().when(circuitBreaker).recordSuccess(); + + // When + String result = service.getData(); + + // Then + assertEquals("success", result, "Should return success after retries"); + verify(primaryService, times(3)).getData(); + verify(circuitBreaker, times(2)).recordFailure(); + verify(circuitBreaker).recordSuccess(); + verify(fallbackService, never()).getData(); + } + } + + @Nested + @DisplayName("Fallback Service Tests") + class FallbackServiceTests { + @Test + @DisplayName("Should use fallback when circuit breaker is open") + void shouldUseFallbackWhenCircuitBreakerOpen() throws Exception { + // Given + when(circuitBreaker.isOpen()).thenReturn(true); + when(fallbackService.getData()).thenReturn("fallback"); + + // When + String result = service.getData(); + + // Then + assertEquals("fallback", result); + verify(primaryService, never()).getData(); + verify(fallbackService).getData(); + } + + @Test + @DisplayName("Should handle fallback service failure") + void shouldHandleFallbackServiceFailure() throws Exception { + // Given + when(circuitBreaker.isOpen()).thenReturn(false); + when(circuitBreaker.allowRequest()).thenReturn(true); // Add this line + when(primaryService.getData()) + .thenThrow(new TimeoutException()); + when(fallbackService.getData()) + .thenThrow(new Exception("Fallback failed")); + + // When + String result = service.getData(); + + // Then + assertEquals("Service temporarily unavailable", result); + verify(primaryService, atLeast(1)).getData(); // Changed verification + verify(fallbackService).getData(); + verify(circuitBreaker, atLeast(1)).recordFailure(); // Add verification + } + } + + @Nested + @DisplayName("Service Stability Tests") + class ServiceStabilityTests { + @Test + @DisplayName("Should handle concurrent requests") + void shouldHandleConcurrentRequests() throws Exception { + // Given + when(circuitBreaker.isOpen()).thenReturn(false); + when(primaryService.getData()).thenReturn("success"); + + // When + ExecutorService executor = Executors.newFixedThreadPool(CONCURRENT_THREADS); + CountDownLatch latch = new CountDownLatch(REQUEST_COUNT); + AtomicInteger successCount = new AtomicInteger(); + + // Submit concurrent requests + for (int i = 0; i < REQUEST_COUNT; i++) { + executor.execute(() -> { + try { + service.getData(); + successCount.incrementAndGet(); + } catch (Exception e) { + // Count as failure + } finally { + latch.countDown(); + } + }); + } + + // Then + assertTrue(latch.await(30, TimeUnit.SECONDS)); + assertTrue(successCount.get() >= 85, "Success rate should be at least 85%"); + + executor.shutdown(); + assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); + } + + @Test + @DisplayName("Should maintain monitoring metrics") + void shouldMaintainMonitoringMetrics() throws Exception { + // Given + when(circuitBreaker.isOpen()).thenReturn(false); + when(circuitBreaker.allowRequest()).thenReturn(true); + + // Set up primary service to succeed, then fail, then succeed + when(primaryService.getData()) + .thenReturn("success") + .thenThrow(new TimeoutException("Simulated timeout")) + .thenReturn("success"); + + // Set up fallback service + when(fallbackService.getData()).thenReturn("fallback"); + + // Configure circuit breaker behavior + doNothing().when(circuitBreaker).recordSuccess(); + doNothing().when(circuitBreaker).recordFailure(); + + // When - First call: success from primary + String result1 = service.getData(); + assertEquals("success", result1); + + // Second call: primary fails, use fallback + when(circuitBreaker.allowRequest()).thenReturn(false); // Force fallback + String result2 = service.getData(); + assertEquals("fallback", result2); + + // Third call: back to primary + when(circuitBreaker.allowRequest()).thenReturn(true); + String result3 = service.getData(); + assertEquals("success", result3); + + // Then + ServiceMonitor monitor = service.getMonitor(); + assertEquals(2, monitor.getSuccessCount()); + assertEquals(1, monitor.getErrorCount()); + assertTrue(monitor.getSuccessRate() > 0.5); + + // Verify interactions + verify(primaryService, times(3)).getData(); + verify(fallbackService, times(1)).getData(); + } + } + + @Test + @DisplayName("Should close resources properly") + void shouldCloseResourcesProperly() throws Exception { + // When + service.close(); + + // Then + assertThrows(ServiceException.class, () -> service.getData()); + } +} diff --git a/fallback/src/test/java/com/iluwatar/IntegrationTest.java b/fallback/src/test/java/com/iluwatar/IntegrationTest.java index b3ceb0e25c80..8458b460b05e 100644 --- a/fallback/src/test/java/com/iluwatar/IntegrationTest.java +++ b/fallback/src/test/java/com/iluwatar/IntegrationTest.java @@ -1,320 +1,172 @@ -package com.iluwatar; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - -import java.net.http.HttpClient; -import java.time.Duration; -import java.util.concurrent.*; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicInteger; -import static org.junit.jupiter.api.Assertions.*; - -class IntegrationTest { - private FallbackService fallbackService; - private LocalCacheService cacheService; - private CircuitBreaker circuitBreaker; - private static final int CONCURRENT_REQUESTS = 50; - private static final int THREAD_POOL_SIZE = 10; - - @BeforeEach - void setUp() { - Service remoteService = new RemoteService( - "http://localhost:0", // Invalid port to force failure - HttpClient.newHttpClient() - ); - - cacheService = new LocalCacheService(); - circuitBreaker = new DefaultCircuitBreaker(3); - fallbackService = new FallbackService(remoteService, cacheService, circuitBreaker); - } - - @Test - void testCompleteFailoverFlow() throws Exception { - // First call should try remote service, fail, and fall back to cache - String result1 = fallbackService.getData(); - assertNotNull(result1); - assertTrue(result1.contains("fallback")); - - // Update cache with new data - cacheService.updateCache("default", "updated cache data"); - - // Second call should use updated cache data - String result2 = fallbackService.getData(); - assertEquals("updated cache data", result2); - - // Verify metrics - ServiceMonitor monitor = fallbackService.getMonitor(); - assertEquals(0, monitor.getSuccessCount()); - assertTrue(monitor.getFallbackCount() > 0); - assertTrue(monitor.getErrorCount() > 0); - } - - @Test - void testCircuitBreakerIntegration() throws Exception { - // Make multiple calls to trigger circuit breaker - for (int i = 0; i < 5; i++) { - fallbackService.getData(); - } - - // Verify circuit breaker is open - assertTrue(circuitBreaker.isOpen()); - - // Verify all subsequent calls use fallback without trying primary - String result = fallbackService.getData(); - assertNotNull(result); - assertTrue(result.contains("fallback")); - - // Wait for circuit breaker timeout - Thread.sleep(5100); - - // Verify circuit breaker is reset - assertFalse(circuitBreaker.isOpen()); - } - - @Test - void testPerformanceMetrics() throws Exception { - long startTime = System.currentTimeMillis(); - - // Make multiple service calls - for (int i = 0; i < 3; i++) { - fallbackService.getData(); - } - - long endTime = System.currentTimeMillis(); - Duration totalDuration = Duration.ofMillis(endTime - startTime); - - // Verify performance metrics - ServiceMonitor monitor = fallbackService.getMonitor(); - assertTrue(monitor.getLastResponseTime().compareTo(totalDuration) <= 0); - assertTrue(monitor.getLastFailureTime().isAfter(monitor.getLastSuccessTime())); - } - - @Test - void testResourceCleanup() throws Exception { - // Verify service works before closing - String result = fallbackService.getData(); - assertNotNull(result); - - // Close service - fallbackService.close(); - - // Verify service is closed - assertThrows(ServiceException.class, () -> fallbackService.getData()); - } - - @Test - void testSystemReliability() throws Exception { - AtomicInteger successCount = new AtomicInteger(); - AtomicInteger fallbackCount = new AtomicInteger(); - CountDownLatch latch = new CountDownLatch(CONCURRENT_REQUESTS); - - ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE); - try { - for (int i = 0; i < CONCURRENT_REQUESTS; i++) { - executor.execute(() -> { - try { - String result = fallbackService.getData(); - if (result.contains("fallback")) { - fallbackCount.incrementAndGet(); - } else { - successCount.incrementAndGet(); - } - } catch (Exception e) { - fail("Request failed: " + e.getMessage()); - } finally { - latch.countDown(); - } - }); - } - - assertTrue(latch.await(30, TimeUnit.SECONDS), "Timed out waiting for requests"); - - // Verify system reliability - ServiceMonitor monitor = fallbackService.getMonitor(); - double reliabilityRate = (monitor.getSuccessRate() + - (double)fallbackCount.get() / CONCURRENT_REQUESTS); - assertTrue(reliabilityRate > 0.95, - "Reliability rate should be > 95%, actual: " + (reliabilityRate * 100) + "%"); - } finally { - executor.shutdown(); - assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); - } - } - - @Test - void testLongTermStability() throws Exception { - ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); - AtomicBoolean stable = new AtomicBoolean(true); - AtomicInteger requestCount = new AtomicInteger(); - - try { - ScheduledFuture future = scheduler.scheduleAtFixedRate(() -> { - try { - fallbackService.getData(); - requestCount.incrementAndGet(); - } catch (Exception e) { - stable.set(false); - } - }, 0, 100, TimeUnit.MILLISECONDS); - - // Run for 5 seconds instead of 30 for faster tests - Thread.sleep(5_000); - future.cancel(false); - - assertTrue(stable.get(), "System should remain stable"); - assertTrue(requestCount.get() >= 45, - "Should handle at least 45 requests in 5 seconds"); - assertTrue(fallbackService.getMonitor().getSuccessRate() + - fallbackService.getMonitor().getFallbackCount() / - (double)requestCount.get() > 0.9, - "Combined success and fallback rate should be > 90%"); - } finally { - scheduler.shutdown(); - assertTrue(scheduler.awaitTermination(5, TimeUnit.SECONDS)); - } - } - @Test - void testConcurrentRequestsUnderLoad() throws Exception { - int numThreads = 100; - int requestsPerThread = 100; - CountDownLatch startLatch = new CountDownLatch(1); - CountDownLatch completionLatch = new CountDownLatch(numThreads); - AtomicInteger successCount = new AtomicInteger(0); - AtomicInteger failureCount = new AtomicInteger(0); - - when(circuitBreaker.isOpen()).thenReturn(false); - when(primaryService.getData()) - .thenAnswer(inv -> { - Thread.sleep(5); // Simulate processing time - return "success"; - }); - - ExecutorService executor = Executors.newFixedThreadPool(numThreads); - List> futures = new ArrayList<>(); - - try { - // Create worker threads - for (int i = 0; i < numThreads; i++) { - futures.add(executor.submit(() -> { - try { - startLatch.await(); // Wait for all threads to be ready - for (int j = 0; j < requestsPerThread; j++) { - try { - String result = fallbackServiceUnderTest.getData(); - if (result != null && !result.isEmpty()) { - successCount.incrementAndGet(); - } - } catch (Exception e) { - failureCount.incrementAndGet(); - } - } - } finally { - completionLatch.countDown(); - } - })); - } - - // Start all threads simultaneously - startLatch.countDown(); - - // Wait for completion with timeout - assertTrue(completionLatch.await(30, TimeUnit.SECONDS), - "Test timed out waiting for completion"); - - // Verify results - assertTrue(successCount.get() > numThreads * requestsPerThread * 0.95, - "Success rate should be > 95%"); - assertTrue(failureCount.get() < numThreads * requestsPerThread * 0.05, - "Failure rate should be < 5%"); - - // Check service monitor metrics - ServiceMonitor monitor = fallbackServiceUnderTest.getMonitor(); - assertTrue(monitor.getSuccessRate() > 0.95, - "Service monitor success rate should be > 95%"); - assertTrue(monitor.getLastResponseTime().toMillis() < 1000, - "Response time should be under 1 second"); - - } finally { - executor.shutdown(); - assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); - } - } - - @Test - void testCircuitBreakerBehaviorUnderStress() throws Exception { - AtomicInteger openStateCount = new AtomicInteger(); - AtomicInteger closedStateCount = new AtomicInteger(); - CountDownLatch completionLatch = new CountDownLatch(1); - - when(circuitBreaker.isOpen()).thenAnswer(inv -> { - if (openStateCount.get() > 100) { // Switch to closed after 100 open calls - closedStateCount.incrementAndGet(); - return false; - } - openStateCount.incrementAndGet(); - return true; - }); - - when(primaryService.getData()) - .thenThrow(new TimeoutException()) - .thenThrow(new TimeoutException()) - .thenReturn("recovered"); - when(fallbackService.getData()).thenReturn("fallback"); - - ExecutorService executor = Executors.newFixedThreadPool(10); - try { - // Generate load - for (int i = 0; i < 200; i++) { - executor.submit(() -> { - try { - fallbackServiceUnderTest.getData(); - } catch (Exception ignored) { - } - }); - } - - Thread.sleep(2000); // Allow time for requests to process - - assertTrue(openStateCount.get() >= 100, - "Circuit breaker should have been open at least 100 times"); - assertTrue(closedStateCount.get() > 0, - "Circuit breaker should have transitioned to closed state"); - - verify(fallbackService, atLeast(50)).getData(); - verify(primaryService, atLeast(10)).getData(); - - } finally { - executor.shutdown(); - assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS)); - } - } - - @Test - void testErrorBoundaries() throws Exception { - // Test with null responses - when(primaryService.getData()).thenReturn(null); - when(fallbackService.getData()).thenReturn(null); - - String result = fallbackServiceUnderTest.getData(); - assertEquals("Service temporarily unavailable", result); - - // Test with empty responses - when(primaryService.getData()).thenReturn(""); - when(fallbackService.getData()).thenReturn(""); - - result = fallbackServiceUnderTest.getData(); - assertNotNull(result); - - // Test with very large responses - StringBuilder largeResponse = new StringBuilder(); - for (int i = 0; i < 1000000; i++) { - largeResponse.append("x"); - } - when(primaryService.getData()).thenReturn(largeResponse.toString()); - - result = fallbackServiceUnderTest.getData(); - assertNotNull(result); - assertTrue(result.length() > 0); - } -} +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; + +import java.net.http.HttpClient; +import java.time.Duration; +import java.time.Instant; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicInteger; +import static org.junit.jupiter.api.Assertions.*; + +/** + * Integration tests for the Fallback pattern implementation. + * Tests the interaction between components and system behavior under various conditions. + */ +class IntegrationTest { + private FallbackService fallbackService; + private LocalCacheService cacheService; + private CircuitBreaker circuitBreaker; + + // Test configuration constants + private static final int CONCURRENT_REQUESTS = 50; + private static final int THREAD_POOL_SIZE = 10; + private static final Duration TEST_TIMEOUT = Duration.ofSeconds(30); + private static final String INVALID_SERVICE_URL = "http://localhost:0"; // Force failures + + @BeforeEach + void setUp() { + Service remoteService = new RemoteService(INVALID_SERVICE_URL, HttpClient.newHttpClient()); + cacheService = new LocalCacheService(); + circuitBreaker = new DefaultCircuitBreaker(3); + fallbackService = new FallbackService(remoteService, cacheService, circuitBreaker); + } + + @Nested + @DisplayName("Basic Fallback Flow Tests") + class BasicFallbackTests { + @Test + @DisplayName("Should follow complete fallback flow when primary service fails") + void testCompleteFailoverFlow() throws Exception { + // First call should try remote service, fail, and fall back to cache + String result1 = fallbackService.getData(); + assertNotNull(result1); + assertTrue(result1.contains("fallback"), "Should return fallback response"); + + // Update cache with new data + String updatedData = "updated cache data"; + cacheService.updateCache("default", updatedData); + + // Second call should use updated cache data + String result2 = fallbackService.getData(); + assertEquals(updatedData, result2, "Should return updated cache data"); + + // Verify metrics + ServiceMonitor monitor = fallbackService.getMonitor(); + assertEquals(0, monitor.getSuccessCount(), "Should have no successful primary calls"); + assertTrue(monitor.getFallbackCount() > 0, "Should have recorded fallbacks"); + assertTrue(monitor.getErrorCount() > 0, "Should have recorded errors"); + } + } + + @Nested + @DisplayName("Circuit Breaker Integration Tests") + class CircuitBreakerTests { + @Test + @DisplayName("Should properly transition circuit breaker states") + void testCircuitBreakerIntegration() throws Exception { + // Make calls to trigger circuit breaker + for (int i = 0; i < 5; i++) { + fallbackService.getData(); + } + + assertTrue(circuitBreaker.isOpen(), "Circuit breaker should be open after failures"); + + // Verify fallback behavior when circuit is open + String result = fallbackService.getData(); + assertNotNull(result); + assertTrue(result.contains("fallback"), "Should use fallback when circuit is open"); + + // Wait for circuit reset timeout + Thread.sleep(5100); + assertFalse(circuitBreaker.isOpen(), "Circuit breaker should reset after timeout"); + } + } + + @Nested + @DisplayName("Performance and Reliability Tests") + class PerformanceTests { + @Test + @DisplayName("Should maintain performance metrics") + void testPerformanceMetrics() throws Exception { + Instant startTime = Instant.now(); + + // Make sequential service calls + for (int i = 0; i < 3; i++) { + fallbackService.getData(); + } + + Duration totalDuration = Duration.between(startTime, Instant.now()); + ServiceMonitor monitor = fallbackService.getMonitor(); + + assertTrue(monitor.getLastResponseTime().compareTo(totalDuration) <= 0, + "Response time should be tracked accurately"); + assertTrue(monitor.getLastFailureTime().isAfter(monitor.getLastSuccessTime()), + "Timing of failures should be tracked"); + } + + @Test + @DisplayName("Should handle concurrent requests reliably") + void testSystemReliability() throws Exception { + AtomicInteger successCount = new AtomicInteger(); + AtomicInteger fallbackCount = new AtomicInteger(); + CountDownLatch latch = new CountDownLatch(CONCURRENT_REQUESTS); + + ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE); + try { + // Submit concurrent requests + for (int i = 0; i < CONCURRENT_REQUESTS; i++) { + executor.execute(() -> { + try { + String result = fallbackService.getData(); + if (result.contains("fallback")) { + fallbackCount.incrementAndGet(); + } else { + successCount.incrementAndGet(); + } + } catch (Exception e) { + fail("Request should not fail: " + e.getMessage()); + } finally { + latch.countDown(); + } + }); + } + + assertTrue(latch.await(TEST_TIMEOUT.toSeconds(), TimeUnit.SECONDS), + "Concurrent requests should complete within timeout"); + + // Verify system reliability + ServiceMonitor monitor = fallbackService.getMonitor(); + double reliabilityRate = (monitor.getSuccessRate() + + (double)fallbackCount.get() / CONCURRENT_REQUESTS); + assertTrue(reliabilityRate > 0.95, + String.format("Reliability rate should be > 95%%, actual: %.2f%%", + reliabilityRate * 100)); + } finally { + executor.shutdown(); + assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS), + "Executor should shutdown cleanly"); + } + } + } + + @Nested + @DisplayName("Resource Management Tests") + class ResourceTests { + @Test + @DisplayName("Should properly clean up resources") + void testResourceCleanup() throws Exception { + // Verify service works before closing + String result = fallbackService.getData(); + assertNotNull(result, "Service should work before closing"); + + // Close service and verify it's unusable + fallbackService.close(); + assertThrows(ServiceException.class, () -> fallbackService.getData(), + "Service should throw exception after closing"); + } + } +} diff --git a/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java b/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java index f5e9b281425e..3d6ef5e0a9da 100644 --- a/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java +++ b/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java @@ -1,109 +1,161 @@ -package com.iluwatar; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import java.time.Duration; -import java.time.Instant; -import static org.junit.jupiter.api.Assertions.*; - -class ServiceMonitorTest { - private ServiceMonitor monitor; - - @BeforeEach - void setUp() { - monitor = new ServiceMonitor(); - } - - @Test - void testInitialState() { - assertEquals(0, monitor.getSuccessCount()); - assertEquals(0, monitor.getFallbackCount()); - assertEquals(0, monitor.getErrorCount()); - assertEquals(1.0, monitor.getSuccessRate()); - assertNotNull(monitor.getLastSuccessTime()); - assertNotNull(monitor.getLastFailureTime()); - assertEquals(Duration.ZERO, monitor.getLastResponseTime()); - } - - @Test - void testSuccessRate() { - monitor.recordSuccess(Duration.ofMillis(100)); - monitor.recordSuccess(Duration.ofMillis(100)); - monitor.recordFallback(); - monitor.recordError(); - - assertEquals(2, monitor.getSuccessCount()); - assertEquals(1, monitor.getFallbackCount()); - assertEquals(1, monitor.getErrorCount()); - assertEquals(0.5, monitor.getSuccessRate(), 0.01); - } - - @Test - void testResponseTimeTracking() { - Duration responseTime = Duration.ofMillis(150); - monitor.recordSuccess(responseTime); - assertEquals(responseTime, monitor.getLastResponseTime()); - } - - @Test - void testLastSuccessTime() { - Instant before = Instant.now(); - monitor.recordSuccess(Duration.ofMillis(100)); - Instant after = Instant.now(); - - Instant lastSuccess = monitor.getLastSuccessTime(); - assertTrue(lastSuccess.isAfter(before) || lastSuccess.equals(before)); - assertTrue(lastSuccess.isBefore(after) || lastSuccess.equals(after)); - } - - @Test - void testLastFailureTime() { - Instant before = Instant.now(); - monitor.recordError(); - Instant after = Instant.now(); - - Instant lastFailure = monitor.getLastFailureTime(); - assertTrue(lastFailure.isAfter(before) || lastFailure.equals(before)); - assertTrue(lastFailure.isBefore(after) || lastFailure.equals(after)); - } - - @Test - void testSuccessRateWithOnlyErrors() { - monitor.recordError(); - monitor.recordError(); - monitor.recordError(); - assertEquals(0.0, monitor.getSuccessRate()); - } - - @Test - void testSuccessRateWithOnlyFallbacks() { - monitor.recordFallback(); - monitor.recordFallback(); - monitor.recordFallback(); - assertEquals(0.0, monitor.getSuccessRate()); - } - - @Test - void testSuccessRateWithOnlySuccesses() { - monitor.recordSuccess(Duration.ofMillis(100)); - monitor.recordSuccess(Duration.ofMillis(100)); - monitor.recordSuccess(Duration.ofMillis(100)); - assertEquals(1.0, monitor.getSuccessRate()); - } - - @Test - void testReset() { - monitor.recordSuccess(Duration.ofMillis(100)); - monitor.recordFallback(); - monitor.recordError(); - monitor.reset(); - - assertEquals(0, monitor.getSuccessCount()); - assertEquals(0, monitor.getFallbackCount()); - assertEquals(0, monitor.getErrorCount()); - assertEquals(1.0, monitor.getSuccessRate()); - assertEquals(Duration.ZERO, monitor.getLastResponseTime()); - assertTrue(monitor.getLastSuccessTime().isAfter(Instant.now().minusSeconds(1))); - assertTrue(monitor.getLastFailureTime().isAfter(Instant.now().minusSeconds(1))); - } -} +package com.iluwatar; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import java.time.Duration; +import java.time.Instant; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import static org.junit.jupiter.api.Assertions.*; + +class ServiceMonitorTest { + private ServiceMonitor monitor; + + @BeforeEach + void setUp() { + monitor = new ServiceMonitor(); + } + + @Test + void testInitialState() { + assertEquals(0, monitor.getSuccessCount()); + assertEquals(0, monitor.getFallbackCount()); + assertEquals(0, monitor.getErrorCount()); + assertEquals(0.0, monitor.getSuccessRate()); + assertNotNull(monitor.getLastSuccessTime()); + assertNotNull(monitor.getLastFailureTime()); + assertEquals(Duration.ZERO, monitor.getLastResponseTime()); + } + + @Test + void testResponseTimeTracking() { + Duration responseTime = Duration.ofMillis(150); + monitor.recordSuccess(responseTime); + assertEquals(responseTime, monitor.getLastResponseTime()); + } + + @Test + void testLastSuccessTime() throws InterruptedException { + Instant beforeTest = Instant.now(); + Thread.sleep(1); // Add small delay + monitor.recordSuccess(Duration.ofMillis(100)); + assertTrue(monitor.getLastSuccessTime().isAfter(beforeTest)); + } + + @Test + void testLastFailureTime() throws InterruptedException { + Instant beforeTest = Instant.now(); + Thread.sleep(1); // Add small delay + monitor.recordError(); + assertTrue(monitor.getLastFailureTime().isAfter(beforeTest)); + } + + @Test + void testSuccessRateWithOnlyErrors() { + monitor.recordError(); + monitor.recordError(); + monitor.recordError(); + assertEquals(0.0, monitor.getSuccessRate()); + } + + @Test + void testSuccessRateWithOnlySuccesses() { + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordSuccess(Duration.ofMillis(100)); + assertEquals(1.0, monitor.getSuccessRate()); + } + + @Test + void testReset() { + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordFallback(); + monitor.recordError(); + monitor.reset(); + + assertEquals(0, monitor.getSuccessCount()); + assertEquals(0, monitor.getFallbackCount()); + assertEquals(0, monitor.getErrorCount()); + assertEquals(0.0, monitor.getSuccessRate()); + assertEquals(Duration.ZERO, monitor.getLastResponseTime()); + assertTrue(monitor.getLastSuccessTime().isAfter(Instant.now().minusSeconds(1))); + assertTrue(monitor.getLastFailureTime().isAfter(Instant.now().minusSeconds(1))); + } + + @Test + void testConcurrentOperations() throws Exception { + int threadCount = 10; + CountDownLatch latch = new CountDownLatch(threadCount); + ExecutorService executor = Executors.newFixedThreadPool(threadCount); + + for (int i = 0; i < threadCount; i++) { + executor.submit(() -> { + try { + monitor.recordSuccess(Duration.ofMillis(100)); + } finally { + latch.countDown(); + } + }); + } + + assertTrue(latch.await(5, TimeUnit.SECONDS)); + assertEquals(threadCount, monitor.getSuccessCount()); + executor.shutdown(); + executor.awaitTermination(1, TimeUnit.SECONDS); + } + + @Test + void testMixedOperationsSuccessRate() { + // 60% success rate scenario + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordError(); + monitor.recordError(); + + assertEquals(0.6, monitor.getSuccessRate(), 0.01); + assertEquals(3, monitor.getSuccessCount()); + assertEquals(2, monitor.getErrorCount()); + } + + @Test + void testBasicMetrics() { + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordError(); + monitor.recordFallback(); + + assertEquals(1, monitor.getSuccessCount()); + assertEquals(1, monitor.getErrorCount()); + assertEquals(1, monitor.getFallbackCount()); + assertEquals(Duration.ofMillis(100), monitor.getLastResponseTime()); + } + + @Test + void testConsecutiveFailures() { + int consecutiveFailures = 5; + for (int i = 0; i < consecutiveFailures; i++) { + monitor.recordError(); + } + + assertEquals(consecutiveFailures, monitor.getErrorCount()); + monitor.recordSuccess(Duration.ofMillis(100)); + assertEquals(consecutiveFailures, monitor.getErrorCount()); + assertEquals(1, monitor.getSuccessCount()); + } + + @Test + void testResetBehavior() { + monitor.recordSuccess(Duration.ofMillis(100)); + monitor.recordError(); + monitor.recordFallback(); + + monitor.reset(); + + assertEquals(0, monitor.getSuccessCount()); + assertEquals(0, monitor.getErrorCount()); + assertEquals(0, monitor.getFallbackCount()); + assertEquals(Duration.ZERO, monitor.getLastResponseTime()); + } +} From 4b7253f88406ee7cff487f1843c240e9a45e7955 Mon Sep 17 00:00:00 2001 From: Ahmed Abdelraheem Date: Wed, 11 Dec 2024 00:56:19 +0200 Subject: [PATCH 3/4] all done --- fallback/etc/fallback.urm.png | Bin 0 -> 405778 bytes fallback/etc/fallback.urm.puml | 135 +++++--- fallback/readme.md | 34 ++ .../java/com/iluwatar/{ => fallback}/App.java | 2 +- .../{ => fallback}/CircuitBreaker.java | 2 +- .../{ => fallback}/DefaultCircuitBreaker.java | 39 ++- .../{ => fallback}/FallbackService.java | 2 +- .../{ => fallback}/LocalCacheService.java | 2 +- .../{ => fallback}/RemoteService.java | 2 +- .../com/iluwatar/{ => fallback}/Service.java | 2 +- .../{ => fallback}/ServiceException.java | 2 +- .../{ => fallback}/ServiceMonitor.java | 2 +- .../iluwatar/DefaultCircuitBreakerTest.java | 140 --------- .../fallback/DefaultCircuitBreakerTest.java | 290 ++++++++++++++++++ .../{ => fallback}/FallbackServiceTest.java | 3 +- .../{ => fallback}/IntegrationTest.java | 3 +- .../{ => fallback}/ServiceMonitorTest.java | 4 +- 17 files changed, 461 insertions(+), 203 deletions(-) create mode 100644 fallback/etc/fallback.urm.png create mode 100644 fallback/readme.md rename fallback/src/main/java/com/iluwatar/{ => fallback}/App.java (96%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/CircuitBreaker.java (96%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/DefaultCircuitBreaker.java (87%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/FallbackService.java (99%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/LocalCacheService.java (96%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/RemoteService.java (96%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/Service.java (98%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/ServiceException.java (93%) rename fallback/src/main/java/com/iluwatar/{ => fallback}/ServiceMonitor.java (96%) delete mode 100644 fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java create mode 100644 fallback/src/test/java/com/iluwatar/fallback/DefaultCircuitBreakerTest.java rename fallback/src/test/java/com/iluwatar/{ => fallback}/FallbackServiceTest.java (97%) rename fallback/src/test/java/com/iluwatar/{ => fallback}/IntegrationTest.java (97%) rename fallback/src/test/java/com/iluwatar/{ => fallback}/ServiceMonitorTest.java (96%) diff --git a/fallback/etc/fallback.urm.png b/fallback/etc/fallback.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..210a48724251dc736ea1ef3123a358e5df41ac03 GIT binary patch literal 405778 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

MiQlTW8OnjfshY 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

eC)o_0% zDVIw3{*2Jg!tea?6nBgIL#Zq^agQE35E#2wG^Qb&IA&BZ;-5CPx^d;UX{glbl);1e zFx{k93o|oj^8fWJh-+NjNBDT@#s{B1a3<~-Bm=@UktsyeANTsYEn^CIM1@i?@M+js z#>85yqEANGGEHCeU#GEVm>F;@Lmr1xw4oB09iDhQCRY5F>lxTVDLvW`zo9X{g=pPB z)G>%EneBVXAh5bR!gsT^?INzEr$0ui3TQ~a#$Q=(a$0x?KC!sBc<>kk$Q~06kqsC> zzkcAV%+djN;tJV{E4tZLtc2U|=JsUp_)@Zo**TTeRZi=e)Mv#HVd%MV;X=e+>|FxP z3GdOw6s+D!wVDRcAFrljYNC2NzB@ls`ri$VCaRzs_n!E?xt6dV3B5l_`DGLx7l5HQ7L08K>S$%I-)gRZ(drE1I4t-A%C+H>?% zy{^<$NHPUI;yRn=E&C5m#+7Uc8vMu9n)%2&wu1*TajfBE8e;^_pMij4=ITthW53`z z2BBeZZq5>laI6VX>_$(K9R#9m)XNK6^7}*%T(5&x35v63mUX)h9h!sc4DOA-$G3rT zAWQY<&&UOqmgNIV!!QaO)f7y&g#Zel^vpIAhXB#3E&MY+|58?r76|b6Uk z@v&Dw?3lM~*|NkWhYw|u`~5n4MXpkMMcyhf_4ZYJ^k)I?Q1Di{hFDiq>>r}_!3Cgn zqGP{u+OeftKAH;{Nlh+VWzqNYhXrj+Dzx*(D81*J6!Di%l`D^}71ya=n7BnMO|DR# znlW5|OfT$ka4=D$NZGWE2!=_zfvG6HA!`yDv3vonM&H z)A$A)IQb#hO=>|a?>m|rip{Yk?m%{Gal|qMSJ`rT*sJrz^DQ!)AG+sAwGS{`+O@6HyPR zk&GDTUxbs5NgpiI!k{XyAGl_W5Eq5U%f&^g`TN8Sd1kQOO$deIZ2klnMYv|2$d#OS3{}}?tM4v2W+!b&4Ds#8c3F4Kp67B&klbvF9ao^b!hYTYDR@X28pnj z=*c>w10(MxMG0-{XWVMsEYS|OW4<6KM}ORQKudXy&wCwJ(5FPv_is*XCNTzHjm?_e z8?yAyvN-_r_j%5X;{B%WW|9s7X4233;ad;>auUn!x^tT7W6zO;@Ew42Cahj33ow2d;Qr%7#_4(>j}dt0ULMAOxm1c6N&#YFbWkY$nL-U<^~f zwTs{h0d83e#aMOfnG@Ii1^M{UXPDkHBaWr_v_q!_kTUR1qLWH^JIIHLp)79)#BDTT zqpIP8$176uv+#RuQE$q~nB4zOYleJ&oN)E3T%S|>pNVzbZ~kAnG4L`Mu9udIT86Q~ z^8%a_={6PAc|aL4#PL1jbRBanQ7`XuS^ZMH#>>k)wm-AS120S>bb%#8xdDs$o|c8v z*PwF^3`U}`nL=*%9JpwHrEJnY_`FKyJknVtv{(e?+NUaz?`d|?7P04;=LiUx*;*d9?= zU9GTfTmE+|RNLtsit&@Q6-cNI_Rhy-g(V7ZLws-0W4{-;gunpA(UT0kz2C)AGo-LR zNY2j6$SCRd4+y}nRQ*}3f=)bHgF(BZg3iqP`0<^!K=uoYM5rRnE&jloY}HX01K-QV z1#X<6K4+N5J2^Z1$i*GfO+TQzV_IL}NYJxxAt{z$xR5=d+Cxj2kFD91Z=`Enl7A2- zN@OtM;N&6>Zb6{A z@Q6cSnrCTA;m4tax|2Z*ku zG>lqPgk>_*r-x|0EOGCDgx=Q6YX+P4GKr`{TaK@Uqn&|}3=W=sIBB0AlGDB!8PRx8 zg8cmOfu2d~3bhHsm(Nnnb9!%wTNxaPQ4)^8(Us5lRNlikEn@wk<4H?L0~94|ANQ@X z-#}Df7u$QmAAvy^t$c7R>gW)+#(jfXS-a0Qk0#h#YG(Z2g;mDQ z4G%n&6n&q5jKCOIq!nNp(-3{iAY+_%?VJHF0)`!Wgy*G+mgN+3^731hm4QA<4P^dt zMFG?x_SIj!n3y~0LSG|1pLcbe!igoVe`2pE*Og9V|Ax){bliSMvz_@T$dlU29Mlil z<)|@OabD))&y1BOSw`Y#=VD*B(AR)CGMiYq!?SN;*JQ~9g??6)xtnPsgcV(D>j4$0 z^v+*ls)xnRRbrYn+6N${^Y(5Ca-tAEHNtlnd?#$=rvw`Ook4_mfwx{CCL1 zf|_^XOP{8$P|0;DWbLl+J%-8={cQ&B+`huJLahx#n5O4nTwkB+ucD&T+}f)9n@{!W z6Yyg0n`C97jEX;I;eZVMd=4XvGe+5p`F5 z(Cd#b5V{Ob!mevN*Z+*X#U-!s{JhlpzF&xF|*`0lYTq&e)k>`q~2PsWz?g_zdr;^Otg?;=ZD z%FFfCOoG5^xmsDVca3i&+lc*NKA4crz(@QkZM=-E<gm@B7s57l;h?TQ_7D*y<*_eqnm-Qt%oN6Y+BOR*9ktZ^>aY_PMpXc!rJI}Z8-aa{ zpK6P!%=uNLqe9wjAMDKeKK37A6uK@BoreH0!_@_ZqgOsBqxC=&CDI2<2on(5y^;kc z5~%0%oxe13JKrafCXPn=`S~@|*8uuFCWs2%wJ9-PwiVhf8_8^Fm$P#}Q!TJaup4V~ z!$2%0B~|ea1E!IzIRRTZe*$yC);o~uIBKs!Ce;ge0*@(GQQw*ql=5ds^!T{&@lI`M zLeTibB~b#Yk}RVH8X@Tw04>Xx=`Qvg-9spTi*Fmado-TPe&t;+UgVCHE?e*^Ej(#9 z#)!tVK?sH&=rt2hF|At{TihQt#z1MtVHxA-=t$Ny3<_gx7Sp4jE4Ley^0HIw{{LdJJ?sCJBR zy$ss#&C8(?5Z2LCJ_aH%$)7`ej;qr)ro+{6&VsxUT=@?P9O3nEEu-)X@{bOM4}f~8=_1lq+?qO;Jx3fuyf-w#BD6PZY-+q z=K5S9+@K6G)Y8W@Jkr=p&8~#5@zcvzo};T^V=Zhm0=bM7+^=fE(V^qyq@k+X=;HtF zVmk~#ebO|RG0$GSD9Fq6IB-CF_kAgE8!`>0T_*n*c%;OYyQMsn8Kx|3Qt{P9p|6~R zogYALh0sq?e4V(3&Kc~t>bLAPGW4>KrGg`kB0^S9Zn6YPO{L#bQc~7&NGi@QeIlRo z(0%*%S$QRX!yGG(WQ(Xl=9gLL&oh2)!Un3lV9itY%G|?5Q#?x=^X%}q5UIQV!nSf`Io|ENX=KZs`uWy3CtYrw3KGfHKOC*y}c*9aUnW5I%a10gjErH zmUQl|yu72I3Gdg6j-ScgHt{k*k?49Y^xc^XF&TQbQmT=n{RGy5S4yvzQPX z!EMCwfhsRgPn5eV6r2@PG%rC|HGz77JI$w&nt}T$O!zf~T)truEheZHFLnDLI<#Ar z_uCC4>9%XvHg4L)qWX^0AEMi_{i64O#gM02L1((oS}nJdmXZ>RB!Omal#5etUfebk z{YO8)*5}Q_Lw>LYQf&Tji2|H{S&mc?$wJ4-d>`D4$`3 zf9rwX-=eR<_}k*lEbMP>%>kAjvo}qVpQR<+i+69{+<;H^k`tHft=`SiVTUctY5xJW z7iBc3lV|)$hAknf0D}uw2icN;p*l^CjjJ=7Ye;Po$z-4xN925}pLxF0oj*(BsYCIT z$tD#}{r3GFG(5bq#EposvWp7u)#RCOJqneNot>RWdx(gf9D^^hNOXXj+5wV_^mL~B z&&6W_S12@a-YK{j6ZvdoGV||3=3)ikN^&b!d=wN2eCkr`T>brvtUXbFYD9Z}OQj9{ zT4$)GAz&= zRInz%3Ifa+);LNKJODnzi#C#-r)FYmok1^qQC3hma^Tuyd& z*N%*THO4y>6;42I@_!pf$wDVI#%`oIHwiUVpX7p4Juz&lpkB*=qzzpO*)aC-C|2j* zH`ZYRQwZg=~&h=EQh3hPg;Gow%QaM+X1Y4 z+<`y?pK#n}Ny(%=q>U^a%yX)=ven&bWHOvafr9(euG(CH&6h4O^N zH)u(|k2WXy1;%fV;GETGExAlU^; zr6g-j{Xh+2>0dhzFBhyC#zuX>S2f-Ti0yHpB3} zW$RYCqgE2vkGF91wuEm>I-diD~$mRv(2e5v}YPW<(_e?TRq<|SR?%# zS7O0PXXow%Lmv~^Y)PPwbR+z9N(oM9CHxmpUC_E zs9Czq?C*MYm!rzsl>q7c`U1SYC!|93_V0fKQEc;*qvbcwoIMM7ZF}U`6A;k@1%j$h z!&w{n$yadTICN7pXy_Oj856Dx+EAGw1&F&nr}FxB#Gqd=ECr&8Fhs2%o;r`1cjz|k z<5ZLOsJ?b>YM5>67#UM(+R|J>XpZ0E#@3oc_SOLr@HnpBK-j9nCS!nn|%dINWbpRTN|INFHeqYc)UleEiR4916VOLIMt32~0{CfA~ z0-2w#IjypC%mFEEq7V;Ug)w@8C4VdEOt8@1lcFcaw>>;iPme0%_qFo5 zewAuVEE($UMLy!8m8YX$fCA}wMn^{%6}F8_u0AA>?70c^1D8)HC)0j+`GHCB>({S6 zp%xab=KjouG}F%QM;(nfr5+QLSSsSwnVxkg?SBUF`&GEv8GIZXYHC{1otE#UY%Sj6 z?wK4(3RcIWuEbY6Md=oc22OIiy3o>mhuslF))$UQsh9J4VY`3;3j6~C_|6g|PKGPt zG<1i@p9@pou0FIh)prgzNFCIMh!n%cjN~2Ail2jV2U?TmR@r}KaeDj7BLvEE9Ua@9 zzCLr=9E=^1k;I(`8VML=(!=BU@2~dv@sI9aR8~<5!LaV3!$9VSAu^VA0Ed8T`x8Ds zNK~^1F-lC6(lWsLT=HI-ETAC~DlWOAGA0AVg?_K3{u4Vvi{@)kP7a`_X!6(r$! zyjN)6*})}oHRfM%?`Jr56e2&+b)J7!mke1a0~;)v^h%cBICN zoPf3p4@QQ-zzC;>C|WYXO5CAM2z_zj%);s7RNENp|A}~EJkU2Vz-@}hzgsf<^Q9JK zf52024c;FP+S=N~@CR8A4gqnh@1uB+C zPft$hU$Bw^L<e;0s*hnhK*89)fv3*(?2Q}B=lOlHPcQz0cd9fAW8ehmfSH{o!9c!quNZv| zXba1ey!`;vhqv#?JCBT1?=pLjV7{@z!4POwy?e2&(Krc{mF_b9A{qhwH8@uGb8KcS zZAe!_x7c4C=$MuI3fKtTFezkRPhf1vSFIZmohaTiBz!x4JK39cWgu-y{O_*F|8D9> zf1V*scAFjXc5|S1@blZa5><65;vNLT!2AFfLimU*&{1rM#$hfjd`bT5=NRSAA|;fb znfYyMMK>#K^oK?U0iKDSw-9KY z18IvEp-;mZu?4&R;GMbPjL3}LE-h-~kEeetb45T4poj6I5F%c;# zBSI6A40yA(^}4HLqhCIFu=e&>cJ^n}lK ziUFu;as)XzbnCED;{Lz@$DSv61z76|!{5TCGLsw&Sb7)uq z3p~LMA%tMXii-O~LwU~j0lNsQ2&VMEKn`9#7YmI@XTiObY|`Z8pf?+MxO3UP+dej7 zrOozkLLxGDkbB2fodLU82j6+M!|oU@Diz-g>cDyhY`S-t1yAvh5aa*(fkTLa&KCUZ z%F%DLkT5tNJGR4~&F?j`!fwe3zbtNNvXun#2Jkij zJ@8+@R0*z$tg3t=T=w#CXy_%SEeaUwiy%JrTlx9%I<(cunc0EPxFoAB3)@n99-jw| zaTih-ttQf`v4*vT5lJ2Jt#)?gZ3mn0^xpUgvwo^O6fM5G*_y#Ti9dhgf!HmpLIL|RU?Q|w#Xzcd|RV5okp7O%~ z04e`}#6g&qx57yUE`e>kiVEkf4dMCVpa&@W9Fwo3{WybW-;c}=Z8l0g2652o(ZiO?K3t`&B@`) z-<~Eis7ekepdxQT*fTfN%`WClomEyo_iMyFpb>GUVC~0mM;B-76F^WN8dcTQyp1T1 zcSpUAFwQ1Ddxm*fK~ywWmNXGra@Cj}5O)2@^#$o!iD&k)HV9fl#n7GY7eyyT4n@eZ z6#*sMaycAI0P;*li!eFihAw?<2{(;~oI~-CvXAN?MjQ0BdS8HVGtiP%_T{usKXSU( zkT(+otZ!{?#oph|g49E}gUYRZV4Hm@p{~Bi-agm#dron2fV+Dg+$BR;n(+L^3$jhn z$1E|B%T>$S88Ot{h5LFI-ze}r~FdBquN<>hOuY4(T*gW>=nyTM?H;lU<3xeLQ6IDZT= zVsZZf?VNz&Pj2~~U>5!q^DzFAB{ByuAa+10kY{lMJRuol7|(gr(ZG^1oiy3;p+rjBFw;^k9}AB5oQpY$ z0n?0DLXD?dHLl+>VKz}F-7mnVnf`v#%Uaz%4nN4F%HuMKG!vp%O!59u3~6gJ4kyTx z{uKi8lKQ9u2S+w6P~1r|AXm@|<)31<;H$KGP{4PR)*ORpGQ|eAd~D|okBl7mWqInNa0}t=tFUjHbEg%u8bqo)9d3A}RDQJRJ!<(+} z!c?gU1G{ z1Qva|TaUA^t&2h{gYp|b_xi(KI!JM2l_Kt_|FgU-nl)+&8&br4(_9qe?Y|lG$eSaN!hAMHG zmo52Bu`%010!2Lak1K5}Cg=AVbn{6W%c`c+9==w`>BvwBtE@_LrqQxRV`=N=>XOFq=Klp|8m%e_5w&hV%9W213Lqnw9(CV<% zL92J|(xs$=Ng(8?12K$B`KDr-Ff^+wD`#Jd;}BqDBS-)^6M%bE6u3Oi`n>Y2imfcr zwHQ5s@`b;23Q8n-bTMtN7Kv~gWtZV7sxXq#aJ6P$etzGEX!CV2CdOp8eY=#9l;m4$ z{$`MPfr3#^BXqXpEOhVx9{YF|gS36dj`g%Uh;m4p##p8X956OBvr{tKEL+cP#t~-d z-3!qTX#IyZn^s$lIqT@HY;4Yezv0&S#`i}`^M%-L;(&}kOk%GdOro10%j=wA?ug_< zZ+%G&claN8#T+##z>cBGnGB*{MA7VunD(RUz7L^(}zY=(aF25VC* zY2VvHon5jy&^_Wr1%2s?Vdzy0IN~|4-GaD)!{(d2B4T1YCtqQ(4koXmGM%K}>Y9*v zc}rQ-ygGP7AWc$!B#sn2!(6?lzw=a(75ke(Ue`cWj#E}~?HbjKCA`_7vo~+5XQB3) z+1r0dL}>MuEAB)3V&vc;ShdKcCL^Xy6kZ>|6wBUf8X8e>k$@(jlDi1fa=~WUcEc+2 zg<^cH$!kD~}5 z8dXOlX?v+8PwlYSnYR-YTJcw=b{&XAUWH96Sy_@TBO433N{@%qxvIuSyB?7{75(aJ zyU{**T!)psE9EU#!eP@XS^x=J%nyT4o}`{Q5qGE}6wR)ONbrdY9Z2g_hfW~>{{+_2 zeW@b<8BgF{e@rK-!KY@kXOBseC2wl@hhoeoGt<*-v^CbG{Y$+gfyh%1qr^zH_*HlBhe!6DQ)nq<|-$I6+C)((ofLCuPYH zM{ss5{z};@($6ISoEmBT9p|ky&y;wq`bd+3mB!jyVCwdWT!t&7+{fGPVUpyHF{hs2l;`IZr-=cyv{)t(ca$Dj=Fp%dCFd=YHL5E_828? zJ*bo@O#(Gbo7|2?MUcaT7&&A7@Dn}e7SP-7L#!qq9^&7x%!~dLGny-D*{q(bLk%{E zPmMJ3>2NwE1%Rrd`touJ=oeWEbE$O=V?{*}xEWWmOvu#O2D#eFP%bNyfqNJ81*BQ(#tr2&O{U*u2RI;x*`h)t&~!JT9aNUu3QKsCqn7BdI3{xYuoOBMd#n%lg=j*l&spk zJEXw$(uGd$Im2j`Mqd>_p!fD!38{jhJBlf`LO;A8I5k!QoH@9Tg$4O>GB0#2)V`s~ z%_{vuR_Lr#tQLZA1NL1HBUx$bJjCb>E`Z#8J(mK!>ZBI+5CyTgzyO$O@C=@F7SM~t3_*u7q1r{;aZ@OIHtNbLM#Ffc>( zaUSw_Q1aW1Hy`x%ElCP7dyf7TIud9%pvT$UUr>Ya-tlVzW7e}DKJc@%ckTuvQ-}|G zF7R2w3R%13r71zLINt(b{wMe-a!O5&I@wCsUyj3}yQVz5brkk2C=(DO59G^j=yD|z z9RP={At6z3OE`d-zZ`>P_s#=TGqX#Xa{vg@M+qrV^4G>DE8M3TMwAc>kLK*+E8X_} z|A2oaK+ciKW*GxI18ER+w<(+&e7Q2+@OsR|G6DX7R_b>lCj;`Fp3qU2j%Yy@>exFG zg-)X|`{V5xfxa(ue4iB!(T7%6%BYQ^oS{7n*+Rdtzw{QyoEY)I7Y!q4H^$oK<>ev4 z@Yq5Jt?T8J+!ie=60Mr zr0DKAn9#@=BtBmkKLMXrLPw(9PHth9ZQJ<8n>p3Ibf@IioT0?u zBSx^ZI10{_dIo4ZEz>xiQUI`SIR;GH`M0Gy>+%{1v!4+(^%AoT6~ zyh~MMVwT2Lid_ibIEH=k+R+a@>LB_PRtqG7*X8B4FC%ZKN-o0|l$J`Zqet72nwEL` z>bOUuoEig{D+$dnn(5Md+|$7?E+j-|`8+J8#n)T1jgp3O2v?*E(;}8N^cHMoQN_9u z(LRuL2fV%MUVMR13Cub4xH+DPK(?495qMo-J{(@cu}M$wk>p)cgK9|KXsS9 zMXY;xp&@ThA!}v&=wePY6)ASLN0PJcLg#0m;3{;@-@M-dZ|pHeujpe7YwNC>O%FRL zi~Ea^!;4r(RRAqq8z)Z2U8YawIKI+d!`v9??wja#>e402g(GBT$#I|(d(F+^fjvFs zGbXihqv=T~CMHXgJeZUgmf;0SAu^s1hMGl;4bc}x*x@nTS+kjQVX8DX#7+@-U(>0- z2xQ2;C;j<2IqTiJXx#Gwl|iy)PoN2lO4ZZZxht_i*>>0pIu**TQ%H;~auE&GMU_HX zbsyT4HA$o3>}!H6??30O!$)b$mfibdR*QWK$DgFxd83D3oI;#29dt?T??5x>0$R$J zZe&f|zuunk92z9C4M1DtlC-w0p1$=Z@Z{^CtC~V*nZ>L&Qt4aFrqq`3?%$A7t7pww z+s*EjB5IJH>b}DFhGUD^2`;fRSN%K8yiPTGtQMR$R8$v@^VcTAb_TbPIeUfjaEHWx zZ4+K!JRJOKtg&lshu3)Ub*)w{cB)d2dO&)BnY3BcOP#)jE$th2A6JF(j$0ZlBT6QN~(yM4yv*1_6s5<^{azR>K^h69D7`n*-^;c9!I zi(;`K5T#EZwBLyz;=z{SDfSr*?F8LO(o8J=T%iw6gilFCO5DBm2Li1Z0iPKp3RykJxJcD{`K>DVsC{7 zi8##0E$NOci>eumx6u;<@*50Y7$!2Bw}0#@>BP(>q~^)WqTz`$?z1{IC8hA|>xS^1 zX)+obJi>0H4(I6Nt}y2>&)ABUXloCSd|F>rz10u)xS~1RTMQg(e6M8r0TMMv{S5Q; z6!+wyAZfI$(3bu>`pDmF)`;*|?eg&{WKe;mXbMq!?VRQVx*n;Cm>P8q&u?AMYPX#D zbZ#b=%k$68#J`d$wWm(?RWqJ$h3Y0b3J8$M>!gefJq-=7m(HdSg=L1!&N1vpIO&2~ z=8)}nj^fV!65ZV?>^Q;Q7H`>W7lncYEr{Sa zSj?~+ZScZDRnTT8xAml@>B!t;xmvy{((U$$_PamF&t%%jUL*7=aAYi2Ofgpi!YnK{ zVR+E~fRt-V{@9M*P!3MJ{g}V!ItkisdnWlUJVgKiaA)MmD#{|>@7}$nZ02jZh}_1J z|869vNOQJxG-Es{Kgeo+w6Og%&E%#3 z)RcD`6%O>sD9i^GR1Yj^XLl776Vw?b!GCr; zi@k^rSIvwGsrF&;tp<}-J50vNRq!2|sLtG$ZklL--o{v0OY8WJuXvWICeVH11Bz#? z+1+0Q(*~7Oj<)_HuP(U?4Ck5`TlSb>YP-$uv*Ko#eK}p+T3`aF052pn>_!NhE&ZF3 zk(Nok;6y(xwSYsQ>x`i=8P2I};w(V@#4)#`v<5k)GDiM z>FI5U7%Ui#COiwQ+}y%<1g&Y~mYa^VsJs&&dHn?e$j3R*$~||cmrJ^@?VmArqh1U( z0_;cxOYO~@{ZRgBY4J@#Nxsgo()<&&t~lL>t5<9K_CfLnE%!&w=_wr1p`cAmkDc9L z_07{e9VA^x3Zb&aLb_1+GVl#ETs&qFIbW5W%x0@MnFW6ynB7QU;5bk2-w%W?hXP!c z*(uv`Txb;a!@eKIB3IVXaLe}XQrVk04ty3rmRj9wOPqj7`pFUzr9ngyc)4(zgRjy>-*2uvh;!ryEr_l6d*JA!rIudwW@nFMq%Z z8FLa=aqn&j4>o#(Dl^}vC_ui>?gP8-ZA4KM!5A;goa8B$dF$+%anUjW={>&WMBP8t?@~Ko77Tao57}=}OA%_O8NwfOZymP>Uk4pP_jyXSk2p4J`i5^@bmPXah(uxZ}*1 zqvZ#Hja1)76fhDl7@s#2>uBM~a4L+XxWY8htda&0;B`~fmK^}XD?oB=-wlzvw6P~T zWJt!2jN;0Sy_nvan~p#@c&COAVJAS`uA}5Ch_?XMQGSDMhrK>1I5>l>@s2fATv!!5 zDVa7cEBJPTDDbLI68DJfnA+JEMR(dazaN!ocQ@{|uwO(}*F&v0Kfy9GY zR?&BJd$$P0^ViwViRV_J?U{FxB!w{U=y=mO_inX}@XoTl^YP4|H`?)>UVcU3d823b z4pP^8jagZF`JX?2j64+M%X%1v;{;U@-MJq~;1UCM~1GzdiG%8H_!E($;UBe|3~z)~&6U33{QIUn!6$`^=}s)3 z@EZ~EGQmPu=nVDt^sm&h#kZ#>?{mrR*NSi6c?`CiP8<0ROjwjNv z=g^5_t^?k^vwZ1h$}9+GrWyx~GT#{(Fji6FAQRC)_{T+tn0vsW=90IqihOm|mwh2J zw!jKVlf8n#jH*|;1%BLG6^KIA@#&DvrZ7xLegOVdaryGRlm~81%1!uAVB4de6TTz- z5-lUEEX3hE6BEO~!-9bwPRB)Ndx&M^HD95c$-Ik|v^W4@&NJbQCP$&yYG}|MS-oJ*Xw+!SMD_#(bQ}lt;2}}5f&M~hg)fmu^Tx3LDU6in zt8NrzXJ*n>viQ)2Gd8Nu_)_vXnJ%r_>$~sW_Aq&r}?8lMyA6wB+98`CA@vq?} zSK&OsouaR=|1MR3^=jZPN8jIjs*iU3MBHe1J$+1pnmcO^Q@#!sB5zY9Rr~;;0Hvlz zMt1g7EGK%QaTu{=~{ld%<#TUYF$$Gn_2`Z2krL1P`OO=%^J8olUL zcb0KZU&Zpn^JQkQOAs=h+@^@p6rgAue@lRw{#4S2h2=VLuQDI6hHm& z)hqFEv?%*z1@M{RLg2rXuJ!8GD`XHc-rn$QVF6a4l}m?l;h7(85Nl9Y1yI(7W#C3W4Yn-S^#E`n6*t zF4oA9`hGGmbVaDNFuADa!0Lt^1j4!oHnm5mg05)+ZNy;0`t8sNH^n#ER0I?J2bM}~ zXTJ{9NWg+rv}WI08GbWqWYUo4*@oBER#X{@o`y7}`yv2+IE9~)t5ory+1Ia1c* zmu-%11<=t58U)xk*jg-*IeK^^760;PJflm#8`VTYa-Mj`Yz04H)>*?u%8lHmP;$y# z(S?de3@R%X8JSqUH*eowvkQax9{e66D-Dg!AxVa(u<|znTtOZRLBX6TwlyNLT-u69 z&(Nx1S45Ac-=;q&$dsLZE?cSp7ALi%x23H}R%TIUbTj54{M>li-SAvI(j#%iMUmLl2$T@WvY3E?kGFTVZ>LZVLSD@e!|^6vhO={U z|4&78bu{*JcKKuDwm1DyZ(1a!g);|5sDJZUD4L)zmF(89?}&^j1Uw1Fg`A;$pF2U zi-JIGpDCIqzqilF?mc?MVuR)L#D)^$K0fV>m^EGtQf^VvFij83hfdmGq&uY_GNN(} ztQh1-Ci`*kT{f`<1|AYpeW%o!-qpqBDQ085hta#ZYhV{4Mz1q#wj;Nu`YiI{J`^V4 z^$J_CvnFy{?5^w$QD>Sn(bgDh_wo6^CVq0&f1mgr=%JR<$U()4?e<=3 zE*<~Fw1GFn`r155Q$634xEq8v1i29tD1g%X;$pKM1&E@6)R8IVr3Ktz*V$K&MJ~Sz zxs)?i)uSe9kaQJ(V(rgUFHb7c#Om3{0LT#9r{(FbcTL4eD5l6bpXh_xxGP_pf)>-Zh!+K}Ex zef{W>x`swoW25*{*m(kceG~pUH6Vi+#};Q}9YJE{A?dMhFnWuaTl0*wY5D5~wpN{pnj5e3q~9cbLi@a*KKBK))@fT?JUzp5BM(#MmTVF}VY2}IZV zPOSW_ZH>>^qu)>0_9Z$;QXX;zTAcr`WAXmeA=kDo>+MeAHid&sUh}HMac-_FHklX6 zp3gNdHm-jv!*|Z;Vt$IVm2!FZdySQ)WQXdT5%V0e^-t^|Bu&e`a}>@sNQ0I2^xSs1 z8O&d%JhS_rJJYN1Byh$qJMC;wk-hF-*0n=MwK9&%&%MHGojbBL1MdrD{Ss_Ex7QfS zcwn0w6a2+JQV-~c>(l@NjTD#45e@Mu%(=pt6w81OAO0k#DmMZ=Q;t@T$ zDw615YM|9XUCRN3VtE!o=CvL`%mAeEMLke^4Ozgx+Fw%h3I@oi!xa&|U>UNX_Jw;L z`uX8Fis`G?OQ^No9>&XbCgZTi7NVGlb4sXvOs`LRtR8wagVI-c8(D&(XLAbaf}|nd zJ8m_GsJmRI@clr;t6-~F5J*9Jndj{+Kqlu6eB%=n6Qju*XCQt`SWLhgvHreuwODUVjgbN^dWrEaV7@EG`ad#`6fiMyN$qFZczKN3i2*v2UXT3Sbtc#ABiM zp65eYkGDxiq0oE|RGSHwR*v&IGpCKCJl?k&eU&YDXfIVfaoagF{P_a{To4wPka#dI zBNq1uI3CK6-}3CQW9aEHYolRrKrfN|VPxbg@bJTf=kcGbSC2=jpXWP#DpfYv- zhZq3H-zMNqH$%5n8-xXvzYQ!iB-33yF&E(URb9V+RyRoKf?2>!_?`YZFOjXc7$(tM zW82*f%uodvw% zHP;G{Hgz-RU8c*yV0Iz$!nAR1O&G}?n-e1rI8L0Rc9!WFmGVNsG313+DiUut&#UrE zNnNp5fHHTbPM6;94TfyR>x%xS>1&*j=bvW4d`O5S9`(Z9tN!3l(aWV<``yuANV#1r zJ(EYV-H`ccCE_lcboR;6HNL|N;J{u5 zPn9Xa4c)6)SdM^sx1H)OJAuZ?_FXr}{5}L4kOYy;FFXM=OMJ`S^ksKF@Z-uHVx+BQ zB^Fb9N)a?QGC%g_joDAMnnb6qV||=K)=L}76O1cbnduXim!^~Bn=?_jjU3XoEba1u zC>Tz?f!2bBQ*5OsUw-i)T&P}7mi@>O-->w?;oql+nOiR2kFjwm-sZCX4XWFaNZnBe z8z?ka^0};@spAgk8{iWbzIf#d_csGmXKHgr+$P^rH)?Y-2L5dTf?j1s5Ib$TzX=(k z8?%|&)snMe7|;r{dhj|Jn2F3W7EJaqDCoQrf#j1H69CxJE(+QZf4*0rdvAZR!^P77 zSQZ152|5^{gqc7bot7)%Du=|$mkW8%g8XOh?t+K;}`D&VP&dKTQ=UgGASqSZ)(`TqljbG ziTGBV(`V5YYsyT9%mMwKy`hi5|J9!Jn8`?77@PTcc|(5v*l#Lu2JW{{1fcmSu|pvOLlRIL7(!KoA7SSJj4kQuZFOS@NbcyuQ8?@q zE?Cm%rFb`Crq8mf}1mMf@)0D%7Ur`}Eayb;zAo4i;U#Z{>Yn%pyAY zqm9d;d%DRlEG&Odz$^1bcXy`S_s<_+FS|dC)VOeTq4R@CtOb(YRoNu-?kBPi&|Xq( zmXHbq11vl^{Yc%^E{Tl)cZ6|vHTH7CpoGR>n_WDPB;4EV+|lBJ-m|W@cHN54;Rqu` z8MWn?`{&_SNIyP#o-uv)>(};C%MFe^^$&*|hE%(qphF*MIk!zT?p`PI%?ASX`1$yT zg0~0C>R1G6UXk0VHW#!HtRRJRbj_zdinMtxl7l^>1qe^vw=MOF<3IDPGZ&}K9dKQ? z9b9&i(EqwB2xvIb&SP_d3j%1T2i7Pku9pHZYO%%LbT%0T!B8_gQubzp{ z#WAwJK!&O21trt>OLJv&!C2a zBt!u}t>sIuF`YABX5JcDj23sxf(^d)f5ICOXz-%q^kGh znET!rfE^S@fBjpC;?cS$VGF5P;Eo-|a-qf6^vrP=oY_DJM9mK$agX)P%|?js>t>ge zE3wF-={xhm2iL>FI8u43^fl(c_c*nokm{o4iU+j2= zE@-gn7t-!ao*4{@W!fAqB-e{MTxLEKtIjZo4O~UV4!0Q6++tYEWhM3nIQ#m_rmgZ^ z=qfH-Nji3^R>y^Em8BVbRZEs!75>_;erxDtpToZnD8-Ho!K^u~o|2R!!_$>BdhB{L zG2)bUw>DGvk#h5KV9hzck?YGm+}%sJd+;4woMHsC16J#-G!*|woAvl;PjB=p(1w~g z_n7?Btg+W(YkBbG-aUU%U>ey&ozM0GhZ&!UutL%{%h9m;)YhV)dmE*Q+u0-ts|=S4 zC96jg!{u%4z+wv^4<4FD2av>T6dm3M+UQ)D4bS!*m}h7_GA~JdM%D>t$8vL%4xrUV z;Q~?90aQp$EyttH9xHKcvC|IWC54rU?kYa>jT6xagO}XYzZ%Gjn>!`wz5I@#JL*J= zdPD4OwxhdHmgRUYI!%Kf6TFMxks4*DBE==n>$&|GA2Z3bnOmIO#NcKd9!UC%tTvE` z0)wTvVc{^Yl~cIYa`8Fv#@ee_cYGH`a|c-Yx41~Iy`VTUXX89(-XDsNZc0x_;BT6A zyB1oxs(AD$%f!S0OPH?0Z0K3YDgqlkf}ZT@uw-eEe-(BNZ&|c0W0-_R#dftbVld!S z0O;b*Lvp;_+#MlcQ${{h>PR)6y8OTh(<>4p4CIl$xfVN|{VC8%Nk5x-^CnR%3H8=2 z1Jpc$uo^j3(qU_05PB<(FBc1_YbP3P?rpQL~Tq&uRE$qHkIGMUY_R4I?{= zmCxm0Pn=V-NFZ0i^*XmBmB7Dtun+G@I(jtvTp_W0V)zdJZyWeOe66a3vF zU%>iBk;b%sF5S&?Pjg4S7B(A-+NxoBSlFT07Z zP*8R%raScfbz}4|gM}A!#X7~j#3-EAv5x18RehcM=Bqy7y@@!>rl!eunIv)*(l&OF z6Z7U_`BcCmWs3YUo7vRdUTwL)E$jDG>zX`88VCsDcqS7vj=d6y={TUm@J(v|oU)?g zur`F@Eu1r0a52`1p40+EwTOxEO#SP~qZZ zZm#q=YhaAvTw)sRMtR@nE(PxCr&aGaIYhhI`rK*R2G|bKlg;N23C5lxmbI|o zk8H&$hpD|EHqpa+&@pgtzY3@d&yK)^5)X z$OTb;Xd^Z_4swfXF~PunqR8ZXpb1VSjFrE$<4F2h%@9mk8u zzI(sq<7KG+_>v$J$?A*jujDZ%zIrJs6vdxy6jWZoi=8pYadui_Fy5oreUS_T z0N(`^s2)R|)>c+1fbgwgVGw3HuC!MCl?!Xon(RFOBZX)FK9I)lrl> zVi#X~s;YgRo0AjccK(+%2Q$cDPuGKM4TzQQ>+c^K*#%rL4m-x`D~FDky3w~gOUDLU zu~?r&L>RL2PxkP zlL4DrvL!)PI>`wSKiL0%=*luRn{6xmKW~*D_mvTu%o!}pl39Ftq=8eQ0phMAhXxZY zP-CCGAWljB3AORO5#m58=A){drp0uvs%a#LdbY!^u~!w=f*07hqzWS7IFDn*Qcf{z z5gq?bSoERSZ(8V3zJ!pOp*L@sx!#}}oK)R%!Cpb59orpeY+C#K4QA{R$8y8knZda1 z&d)9Aa-AJEZ|?Y+NP)D~3zQbeJWB9RI0#x!O~C>=Ie2^RAQ3D!Bg=1LWAgu7@@B2H zwJ>ntE+uPmo-ix&f<<)yPeBBXL?M|hBJI(=5M32Xmj;t^@=-$jqQDuGQUCiH{BuR? zAz;U)>=oaSF^#0Q12^erKPHk1HVD0kX3HsqO$jmZV$KgTdZ3y{nmgToY!BoD}y(>Q!1dlTY<~Ps@94j&D%8BKtk|ZP zjV!B}On+b+$6Uma7A(K$p$?X}JkU2h*5C4ft~{pM47(BdyL-F>uLDF&9aiZr-F9I6 zcgUNigTS0@!~OHwV#zfMdw7uLjvXWL)?(yDtwU!8^;&g>hFvyPbT_e$t||ln z!)_L}chdlwP*TOk#8QM@iumEp+<*+9>!vY$4c%TOk<9Gu5_^T-Nd`6+d?gqoh?TyO z&B{^8RWK7E-AUXqEG;|d%o)x>6;DR9C_zoJN;;>d9x84a!z>mSb}_gWLeIcO41|NY zKj5`m+{hD;%7jH_IVVrD2cxgCe)r_!BaAm+oRw)2f=OalM=Zo-lVXgJXPV4vzGCSL z(}mfq)V}>*=a{;nYAFA2ks@}GS|{ar^8ZmUOvCILu#=TdMAHJ><*tUl?>QAL!|VL? z5*`153V+!*gRz*~QMtxdUom-H*?g@X3y%EwZO=eP`s(Vy?oqp}ZNrny{451b*DfL| zUoG$+HOJ&3)-7w;K`iP|!<*)$2%d#_dgf=#h|kvD(_e#cVyAu9F3fj`7|Rivecg!lsMr~4vKsanT*|20LIa;UAw<@|%Awsp z=&b6C>-*OXJ_HL5{5Z`vb|?GBY9lpko(D(&rvY{40d!o>iZldhK&rlog@vGErf)Aw zek=%fqrae}U+hdojwU|pg%|`(J&bVamkcnYu%%(7{`~FRbAG*ALSzM%8PqbdUttzA zUEx5V$o&`-H2$oVAIp)0f3IV0?-8fM6}CrRfqh_iD~Q$IfBE?#HmM{bp$+%p<6@;y z{48b;QLU8-xC?wrXe_u}VQQp2d`2#2ka_ASdLUAT{uU)_mOtO|JmeUZv?1}<)moZUrNA43KI$~Ntv5ZR< z)gsg{sA#)`Hh_~iS*{^=@HEV`fh*DG3xwWpYa{h{_`0cC-9Xw>er~>Jg&@3h z6$k&?{hK8^oYMhEvvG5HS!2WAxzp%30*`sHaXtpis(2!`a56t~VZIuiJY0Ar2l@;0 zaf>Si#V*i|c3OP6#dTmPxZo+*I3{euNUwsufn|%jm0Y>E<8QvOV|Yawy8a1Z+@cas zj1#7*F5_n~al9-WYgg7m5I%>5fxvNM{oq4*CA!yy+S0qOkg09b#vIVR>)7=8YyE-! zqr>4U^Wk&JwIS3DD*Gy^3wc!Y{-LDdi-%Dm6h9KXT87F9N&n%+UwR@)dBwchtPa$t zAE!}}ybeza|G{^^78jo9t=}MsfT`k1QlLQR;5rANF}B43ksP;Hr(0N`yduryyS>)I zb3-X0+{&t|cuwR76NIraFTend91)OUcXJFs2t(u*HtN9}Bw!uKJeqor>2Xi@-&5RX z0hdt{v3$G`=MXSCh-TOlX1;!nZXj#8H1k4B41+vywjux}=vzGNnu{tvwJrou1~<_x)65) zo4`I#4;Dl@3mQ0-&@Dq=K##h^ihomA6otu6@amI9B(;m^oT$ww?@eD!MjIf-vOa2E z7uZo|*{bP;^)3V~vJVXQ>>WhY)z^GpM>ED5-sa7`-5=_Cjs^q=oj1E}UwveQfENwl zRPkL!n)`k}!F#wEpKdT1>rs$4HkM4oi`gMma-7(kJS0hPjnUIfWAlmwg_I)i`yvPO zCLIrizaAr0{R^Vj74eDa?@K;6S=3PQAq~85jUWcF^>@+Sm~XwxH)Y6h+L*#LbWv=< zIdOXwk;Jli)?_pyJpIV_?4b$KB$HFkKj%@u&gbdG2b8hlU(T^56fEMDCQ0xeVC_78 z*pW}v;wDPc9LUYi{_^8XP)BWBq`P->I zGbM1xOHM~ntjl+Kl2H8LRI6Fnv$p;MLDVj2XB{WDn7L3a6e0Y>C3bwq0yzL1Hy-V2 z0wh+im|;-Z1yRMSs`$hs8v(tdtd%@_wh75UYQq-<0N)?P%6WA2&iiG!ej;P9giZB0 zPK>pkfn8*zQDuRJ4hj9l!2PivKI*cToxY_v(}CvjsESHBQQ-wVz2=Z>VAM;hO%Iw| zLd$sC-O1@Mq~~B#oiPQ`HTGIJy0_E;mMez!+zaZtSBuKfMAX+EI!C`2fOV9kG67V! z_#>7lR=OtfZ+_RJ1bO~DhQ6~SZ2%dg=4Xm@igZyxwY^)Iey3ZSwIJT`JE;sjO2Ts|gYQbJVD{`t|H&?=a85OI8A;7xky8<@Bu*p6^^pBn~48J^p zZUi9FOpvYF6!yGbo{jAr#Ghj$8`F)I4 zcmvi;TN&1W1uPEx(P?OpdoYvpCI$KCB0T<*HnIHPyMZDBTBfBTFaw7InfePo59dOp z(b?5-{EuAlV~=~-Nrbr10^^>ymP|!9L=YeDxaK{2$rsRF2-~UQ5LmFEhlTJ%Eg@Az za3vNMfZU|8xP_qcv+1jIC?PtpMS?)CKS!&|_TRWZY` z-Pm#3uzwi7`Rqf2db=0`a=zdb^3Nirwb<4$2ngdgFeDM8c(~>a7cVB+L5N(S!kg4 z?Apb$Qx^vhI$S*X8uOrG73klve-QE5@S zoASST@Py-lAmP`YU?;u{h5$qsBSvMINCuC_O%z*tnc*kC&mkzf^WCT~UcM9-5^9+R zjKFr_sDz(-IP z0k>n3n(0OWF`zYI((+zy-(*&VeJgh|fMB6RsFMzo*U>_*(kIONNdBFr(8SiF&j;|B zRrb2^z!Th39;7mOO51a2{`v+6FqeC=r2%Y$Mm^bq=Q%S@VH`7}<1@gX<2Hw^J+~L_ znr~;$@GJ%pd~qRrw4wF!H_yHY8U`7hn%tiS%9&REar z&52r(^&f;xcx-4y!D&ApBj~ak6OWS&Dl1knuJzlstMx9_MX>#VsRe;i^NC!A-oJ1b z_cmPf>npn0h|`fME+D0v2e+GJueDpl|=Gr=qNkj~8NL1@TRgSmLhs7rrCg z46XvHV`4zX6{K7|agMe1^fD@TB1y^K!_+k9{2A1xKcEHGb+x{}*Z0e_AjYua##?ZB zGo-8t?le&Tj;+V1^@1fkpYUL10PsTt95VkR82mT_p#Rkg2IP6!9kGCT%;aK*NqitJ z{Hdv_f@D&t&{5D24wAUJAclgUP4yCK%cVeZ_f^FFX1FA^EBOz?1fr7PJhCM9S}N+9 z&q@depgjYCA2kCGw6vo~!$Ly5UjW~cq{F4PN>|tSz>tUvr3x{K;2y9a1ccx{ZW6Ng zaESx#-1Xhu%nUu5r>m=9KtLX}yE&gfhjyGz1TjT?y8zTnLL zWAF}4(FGrEj84_pvhXX|_)l$>o3B|OU$2N;&UQAD;PpyyC=<7tT!Xr$RXEiq6{0KT zpjSbmlXumt8TT6lVmi>bv!7<*h_;5tJ$u~3IX!OWG8~K9%Kt~*jt!B9nka>QxIiy2 zdw2Iff0D>vmIL7AbT9>5W;3X)Uj5?Lt4Lg9*ed3~xq8PsV!8|rbU#~OuB5GfZGL_p z-cD4A>jQllh6^hJ;aVBSR8>`B%G`L?2;0E~R4>mWPa3=Ccdc%YMo{VA*EfG5hNvqy zKmWd-BPagAC(oZBo}XDB42F0fx$+ceZ;iZPpqjh{e4uP!hqec)rz4}IaY7fC7JSvz z_-x&1Ym0q5apfVj47}s`XG>_}e^M;@lU2U{Qp0XNDV$&dlY}GMBf=xb?*O_$oLlVbiO`5Ix`O8{Fey3 z8d(){&Z2xroJUDvp>%yMCgKb+T_rf5CevN9C;BfIawFD|xnmu``|0T`@_U^W+^F>E zZjq(5#>sb0#0;FHJ5Z+}#ltLR?@Xao0rJv)?xWs?h+O@Qouj6c(msS=u^(dk5Ggbj!7a(eGR6Bpr9jzbq@)}dDf$ZeE^hRK z)qgR2z<$t*OB#;ti|5aqe1M+4Xj+4TB937w%(KjgXH?F_wcO2BVMEWnw;u<>OD#vPx4F^iM#FQ~tRIhEieLV8z5n)c z@B3E24gN_hy1HvDN21LC9z-jCJoIy%Thb^~u8|W$k@s)jT)1*27`j)eE|G<0X`ui{ zK{ImD0?xCa%`8$?8R#9+;s#*4e$n}ZkBF9D0b|DEhDm&olP>d#JUl#*TT*WGp{Ar0 zLfPaKsj&TSlfcMOhYnqxN_Gr)A};+Bwu1*JXH|Iw1xYy&6l=0;0LOz!=#x;S zOf({kO~dNed#x;aniQXqV71Sh8o(~61s4KVCk;Fd7rn3=(-4OC)1$z0>L3c5$s4CN zGTV))Y6t)pR>=-JhwYI!Zr?r(8PtVnV1bx;=BI7#uqU+vIK}lBc&9fXy%`5q4yEAN z2a}6&Yv$zfbd5nlKI4JEDBK3$WPJm6r6a)8**}(ngA1V2PCvhAc=EVLTe9f?G6k36 zND{F%(TGFg(Sk$S8sGT~qmhY;PS3MrV?MaC5UrluUr2eS4Ss_WVS+uk4yCr7b^CoX z?%;?0+W7V6b=N0<&#e5Qw;mYtB(b#6gY1JYFsjvYe}pNi#&##V}Wftko? z*q(2KE{E=qyJ1Ig@NFDV4BLc=2kk5f=Y%bTxCk_#Lf{7)d$9?(NV2r?zEzr<$5zg! z%5nWuY0^lo=OsQY_PgmdT#`mfQX$%kx|mL`L*s+uj3PNQb-B|75rL6TI7Q%~c?OO% zaJ=b$D+6~`+;YfD!cpioY9EuUpsp_6ftwta32i-GFB*2i{WWY(XlApFOEy?pIh1pt zRCO~DU#m95!sOky>H#vyWylG?G?_7~N`VUQRl<)wTN!%c(2viG^NL?`E;CbRX$e^> zU+7QRV9`~VR%3MxZ8JJU5MRgTl7hlbw_2ZE7N9?Ki$>j$W+%mhZ>?C7kjMi9r{y_H z4dTL&lVWVy;z-3}EU8})V9mkJIINj-1^WGiuWc!r6ZrjZu6a8!{q>d7s>gc1-E$q)16&yXX9&xbhyUf0pvpC+hWzrh~jF(5!$P@gy* zaQM)fFJJT44s+;MPtSSZ4q-LVcW>XyCl!(Z`s>r?Ykp-OW*j%LA<^fA2c~MV#6KD@ zBw)(YzXKaKKcS5dlXJI>9ID^%zV>Yd{!x@6Oc@toR4vB3y9wCy9Wv^U) z3CdP`)fg~Ycp(-5F-RJOCLOSZ#OqxGB7W-KAinY*KaGG9BRNyg6uxL9>dBKJq%~dA z5@My~-HZ;yS_2`)uqtS%<3%}`FTL1sj=LLyG~>0QXXpP*Nma}@+!3S+8ha|@-p;^@%Y@YQ0Ayd6Dfcvj2aNQCph!f2-0oK>M>oD5L^-}ymD@@< zE<1dDAf%0#8us*m2`piD6j!;KnHk0sB9a`<-hnh`V&@q6R-*5DtnsH>$(%HYJ@FJ< zg;)h0y7?CX>xYN17Sbd{uvnMm4*kDb5p^@&1sna;gvTV`t-q0j;=NH|09O4?Bz(GW26Vcq-gru~)ZBH;0(Z^U@cvhi_s& z5`;sIxMB=1LoP9`snzzBtC3Mr-(9Lnf@F;uypTq$DPfTeLYk@lTLJUxp^fNpH}m}R zKT!SO6+dsc)nmbS)Ea+BG`A3l(u(31M64lFsHv@mzEYtNt{K`IfdOY~LSmxF=FKs! z*tX90+O7Q083a))l*k@<#JFVYG7I*!Wp1@1nH?$%q*ds7iMWzAMm-<7*`I>;8UyXDh_S%o@zz?2sKKagLbjAv-3L#I7tke zumSB030V#6d;t^o%{St-^Q{2*!uVfMx-A!kS{LN^URQuD0d76cFFPym)Fpv zY6QR8#y04ju16YxX=Fejq-#?gCAwICS&m{bZ>ig*Pso(4y2pVtoZ(N-$T(uflCrLC z2KAAXQ08pduz}TiPhjB9U5_Mf_aJe^&%I=eAi`Q6_xFpvG0nBbulXp05z-hBhN$N4 z>@%t}WDWFJ&KYYW=XpF*uc18R(f5JV$;9(()=S1{FyeO64zxbd`p^S}(# zCh|JB*!hD>^)>ZHMQ|d+5~*|y*Eb;=?{^zI9Me#T*rBkLLNj`1V_i#&#UB&unB*~2 zg{C+NS6=9Ye6ldph9|DB&uiw3wDu1W8V80ZOfw2I0oki=ZxYuw?<^`#OXCo-BB=h) zgrq69eoYM&(vGBD$G2H-RMP-x#bfK!@-AL{i+@V$C(Yej{~zvCLY)JB-0SOmwtVH4 zwLf0lu)QggO|JtzC&#i?mjTFo(GPAbvZvjJrl{&$f40~G$a%*qO*Z!QmM&PHW_$F`xNN%|cs#qVDs|r2@TzUi@vk-kOwv>%}*6ai12^iJf zF1t5hESE7h9=Ly>?6Mum8xWeNm5e%CYHD0JkutITMf5ljmF{w47p@){Ivw$Uki(qz zRJ&XaZ{@oH%`~(-5+P%)|*Sp8E$}RnW6!wJ6iTq~u0H_bze}+T26`fm-}ieWrVH zbtNDBK81}7_{*VQ)L+@*<>ggiyy#{INhT&$c=5-?p~%8*=qxGJ689nkfw^5g}wH^3vvU&l{M1=TR9U>y@% z(=jkP3IgP`pP$GY^Y`5)x6voEuuDz)X0om4tBmpG-A;aL2Y z_h!`ZexXGvqmahIQD>e|q{+z0bc^ut(0%_t^9G`iK1B#JMLtNiF$6x%{<>M9%54Gnvd?S$WY21zi*pr!`ot;odY+@gXUtlP zftv4t_~)x1lQj_TjMi{q-}@d}1ySKu6QB-Oz)cDjQu}pYdqO6zn)vE#5HUKxxsj&4Vny6K&tvV1v@9Wv?x(V{kOs+= zgNf8%@@6#t81#hpL$?=yr?vwgh64fWTp_EYDJg-^D<%HwLZ|slNYHDD^nAjV-yrSp zU-h4?jFksq^}y%#84r|ogewh?96qm|(LbS1dRY??$G#a8+#q&3oMc%`8KOe$TwaTT z0;die_b&I|bNR9sy=$C|Mk&@m=)h@jTpSrLRsgSeI{5m%3#ftG25@QxUBXiZBPNtB% znwLG+pp?Lvk^Qe}E6f z2SE*ygHe}GfB5hsgx_o<#=;=LF>EDvT&k*?0j`c06B84Y%lYvuWpsREB=|X}Gxb*V zFEKG%*aizk4wt&sRao*15}Qrqm-k=w?F0qsE%v&4CyVVdTX}g0DqC@&XqrgbB6={i zit}7=5ILPkpIZg)P*qdXD54vyj1ky_H-`%OM+&lAR~O1}Ot3BI%gPvb60|!=%$JO~`7tuzk)Rh=0k&;MVtB^F!-MSeE*80p7ls9ytP^J!j=-K@{ z`tMi~L<-zN#{hdCUKjX7q;I%8I5aPO#r_nOG0JODZ*QiiBqSv(?GYEFAvkgGs*wPuE`2od1PN@>`Y&AZ zEbFT&?-Wts-5{mhm0tB|X0uF>K}WBlO9)PPAQbZUw%5w{h~C=fE;_n2FUwXEjcIo8 zBR8fQ?{~~FQcD`KwizG#YP$niVlMXIcKZO#JGXXm;Tpt^*Lmcc@Io!&l(n@9z*Dvpa%V{rrxBTlc1o@S#*{P^yQgq=Z{2#!r-SdE z4M5W(VJMVVBfO-Ouzw0bOv$nLEGVU+Y%Hp>eqsUXaNIRU!-(GtHzdEEzaCQ6P!o?c z*_w7)e&d6o48WkeTN~RXci-L*cYm{H{IeF3md~HxUo0qocSEsMOq7`2#=H3hyg1|C zs4;FN?Py3(n(G*D@5egEAr`j#0$yN`(aw_!gdd*K+{rwD10|0KtC0VA659~|w4o&< z-HFPklyVEnPjDg7f*6l*^?xVAI<>ZEDAI8K=zw2^1Z3tgP6`w*@<|WN&Wd0^36K#e zsAia&rQn-LS!$JQwvpT+8_MDkM2D1K!Z*$RHvwXn`~|ksLzga*%gh}ixb0P{l)}ox zm}TqA^sGzE$~w@(c61zDyU*UmZU6o+I1*T|bDr%!!i#|`273AFg4!8cb}0BHYG8ud z@>-&SB`zkY5sITQx$gr%k8qO!Gvy+1S9H_4C65rUgGC056t3DFR-AByd_YJyzG0(b?G9>FVgbYKk(9u%hfbnvubB z(g(uvcu?uwRyPsTm0QroU3GD!sj~6ap++}Z{sZ)>$edLl9LKbtj2OrQ_ zIeIy8!IznTga9;h5nCK9tEeCi+PlNQVL>5Ns8Igz(|H+T7=d3~w|>exIw> zLRQ52&ARJ7{3SReH+FllVvXCUPYsCr4Ga5LNI_Kez{E4vno{764dL9U6M+0`=~hTL@tr`A!pmEYT==|@WU@P7{ zkKj05(4W+VM3DFP_8&d3q^W}W!6NiU{u=?-z5e)Y{qIf3<@NRZAa(8RR0cV|7Hi!< z;<6WCG6B(lWGu0!M@e0?yN}RcA-8MvjWsSPjD}10`wBHKOJ}}f>-E1 zV6_>t7L~=T^xSD@-h;HK?b*A3xP|oY3Q{^C?&_a1h6 zHatBIxl%+jub9`~y~cmU6jsNX1lvX|-C(W=4GrZWlM(mn+Zna>*1@ND?wm&$c)BgF z%NqU$gdRPIh!;EC+5bUA$Poj+nd0A^T_Q~oH)j0DqW@DqLI?DA5gySY?0D>a{8$q) z&QnmCiepzNOn%of^LKrRwcyafgDuS<0}g%p&?b}?KZ;R;m&@pq9 zO#3&&Rt%g9h<}R{6<8h~KCI#46VLWwZzy`Wbw82Hgqd&1!qhWh668uda~Dc&gefzR7Vr^1gY&KY1 zqj!sYOhNn-w6oUtc}m)f88~z)-CiQ}y#w^!n+5VTN$xP=K#8nY?dstH6)1W9k{E&T zo1OZ9WazP;1k@){x3LCh7jmodbqGQwj98yp0ex!5ZuNU;3h^yOgKPv?r?5XZ4)}vt zx%7t|CWp6UQ&W3Hwr^^3mWZ3>j zoHP*2fVB;ND9A(U3v2P@L@9q!w^;1iQ}KCV_Tl_trL(pKD)8Ur42#dnf?od|w(*tW z(_!P_n0)f~@OKwQn!RV6G0YMZ$U(s6gV;c%LJp!d65JX4UTACX-nmmHb_{;G_P#!m ztBL|C7|73QVnHT^hmqGYoth-#%A!)K$S{!3WE4{b0Edp{>HV`PkXBTo*s(5NViGAjry7){#Uef?)x#oFri# z#75g?N0t_6fu}m9E@iLFMSMo9{=1eTARdtu1ApNmaYP5AoZ1|w;%W5K*Rk&Tu@Vs! z|9CWSg#VeS;!FkQ^}MG?3yW2!FoDJ$Bw;<3*c)3btH;lutE;NEjh7A4O+mPafOm{) z0H_}WV7!QLqj|BkTTE}S_}Cr68wlmbF7C}6hfulf-K?xS{zQ+oPT~>ZqKXA+$sw*! z1Ug`eurby=df3x{MTm^T2f%CoT^${Hdcp9PN{YPLb|SW3O*k|&%DEMb7LeSOrn(-9 zP{3E9Z3sykYqLhe9Yh%arqI7Yx1}*cvvOA=E#neEhw{JuqIArVe>=T880#>USU2!6 zHFx{bV)t6(Arei?zhpwlFvSdsMy^?p4QBZ1$;q^r?B$L`3Hb;(9AqGbWd%kDwEF&t z%#)CeqQ7y&1`Qn@NO#UkAGJhR1??xtT{v#g)Z&!ezRfyyDrnE1^jrE7GlejR;uk{- zCa7fec?j>tSEQO`psg?i$pFRkpE_{UJO&jlt)7k!w*Cy8K(_s4NRmw0;d(;T1Y5&H z%*xG3#ovIb3##3g5DSZV?7|BRTje&eNIkgejDf7C@&6%%0B6L;#f5#5gfe|*@r5CG zozl_ki%&|d*kx3Ct7TF+oq3uo@8rAlEAJRi)=g2>%;1aS`%-OTan50-w34gEI_GZx z$rOQgZPeJUDMP#3JICI5gyimR{Pqw$#6gCVizSEgiH?0 zla2&$>Iiy+V_i?&W%?U!Y|K?**e-v{2t`hjUCru3YpA(O*Zc1wBD_Y57BN}Mi*~$kdx6y*Wl_`#u4b&{BU~>1tS@Y;UPiiEef5E-<=`u zOmFC@t0-eu*y+nR()cvq$X;T`)hU5i+_;{}VZwh;*CjQBllhBg*?Y2Pn(}ri96qI6 zRG#kmrMoZUnRSntvbg58o8_f1#aD3&30{2#g{0(5S!9hd zsEtmmm&rm0je!>;?0cV(O@)!TEo+;GOkL6w48VUBRNL>N&OtC#|4QjY55A?YeeCuz zkpVjCkCggI^jY?Vl&1dzT3137? ztrlI0=9jwSO`-IBr_mm7=LtRix5W*?U&qUwn0FWvde-nE=!laSZdtpy329o>30h<=^}0nU&5O4IVCzeDxH;usk3aIE0MJY2e%Rn8Jm?$f^%7mk9POxx>ba$ z`Hy|k(G78lz1^Uyto*Xdo3UR({EA0yN*&!hdn~<6#XIi2a#?7hElk2;kQ#J1s0C=?ct9%c zz^l68g1ET2h1mWJuGZiI{;yYfNv{zysPC`xZlu2XGC4Z^xaka}JnIi}51QQ0WA~F- zy}zdBvSZvSrrGM!+re@*t>`{re<8>p%TI7%engPc#Dp^U#a7_$r=DP$yBS=nV|MA^v-nMsApN|LRNL_#DhyUdW15R!x>BqJlEgi@69yiQ%$eP8$U zyN>60u77^VbsQbV_j{h7&-?wF_<3Ai<-J5zdl-tNec$+f3_60e54F!!Mmk2u#>v+s zWy(J}R|2_3+E*``6f|ftxI-uwXudw*U5^dF(NP~CKCDRHjG`p_<{EeZp`Y9Q z_KKJA&Yj^oAdnA2cyaqOM3vA!;y$$uP(5Y5JBNp3vjr!S)4n`qqK=Dd6BiO==no5| zEz(U*zklugv)i1L{#2v__gU##ia%p)ENAwmpZ@cHEar2(jV6Oau-KzygVTpH2h*^D z^6%NhxCSdB6Fd8JCpQ~l04+#g9DjoBe7W>C|V(LUqf^zbnR+mPNuj; zdaGG54&HQ27zad2AgA=H$;puwo4Mrbb8S$PlTjRirKEz|@<-_9Rc?7t3g0@Y@XC=t zMaQ^E0=faijvS;h$c3WGJfy8HBrL4fPtZ|VIGK_|ArV))65Qa)%t)IA9T3QJEHW91 zeOwDzk}*v|OaB9tgPH)7ZQjvr;DCvcj4WJH+rTgi?^OU+87G7#1HQ|WdnB8*o^OrD zEL#>N$`5C0(F5(iN1{FfZ^;@IN6>$Ar@y!jFx`cbw=HMk81SM?$RCDXz4}Rz2Jz?# z*@s>@hj`$3@84TLRAG-nA{(tR`_?A;-_`1l>3xKFyF3N51bkH=0v zgZ|=)x1@pl;5mN*gZOGj5n=zop{pu&ypS~I9p!(FX6GLHx{ck251scK;>DVVOTisWYz=my}={9l5A{ zN;L$e4Ktaum|%qYu5Roy<{3wd zcFNu}9prQ$nk~UPZ_!{*5D|44!&%^>->I%6-qmNI%WUgX*tMzDzSo~u=}cV$jfZVh zK2As7Xte{;JB35ex4GOgh}XV|p|gm_RQC2%l+Tx_0ZmUgE&3y)-FNk|8yHPXa0vA9 zzoXV0&@DS?@ZfP!oAG56(y$hC3fsaimm+sZHM}4B4cgf4K<_tvFR|E(!~=>9BC@MI9kFTX-kAR zQ9kio5{60Qutz|EO2eH;t4s^|nU(8_3$ce~5V_D*&r6wfkNk&|U0*|twc?)&Jae2&DvoZ6G2K%E~M%T;jsRwQy2l z-|6!gUtake6O}4qrv|nV6Kvn^afsi2V6a0jH%_h-y+!?jq~r;Tu{;C7tzJYCS?HN~ zizF4D5o8Q+P<7|<@bJ^8m-CCD)x`NTgzprq_UMzG9LFO^5_vYeA{Fxi9BNS4fQ!MO zxP2!nJiIRkGeyMJJ8)jZqCJ3;wVgYu`s=m$_h5rd-L@~lAL+iJ=z<%5E-#lGo~u~Zaasw%HMKZY9{Bjk7%*dmx@kF_l~{^*iHWL; zO(s~}6m6M2lPtq~20==NH?$V8LYhX&9jD)f^tEpUoXNbao`Jb8pn7cCDKm;d{1*T@ zwcO0WqD(A!<<9gS1Ml7;CHovMfNB{L`XIJ)$R;_DHy*NkK{u)!Ltf`i|G@^a0l#`E zdiY<7UWu~j?*XfU_v@Y@a`Q%UK3!V_XH4|P%2?4vx|ICujjex0yH9yldS0sKz6ja` z&m3&E&>mXNTu@c4PqC>`a$y4ttSOTJOseIZJy{VGNFc2qpM{jT9iL6n%5w-~qc~5N9FL6HJ(~Gd~ z*l!bP?3R7(;7asPeU9W$y~UgZ`?Ev;nAwj-e)uX-cl73Eg>m9mqX;G2c!<3q?L2As zu`Ow7%@52z=LZgRd>fcLofLDZxWSQTp&jd@Nrc$)`UR)j!>Eu+QrNjeyLtPY4RsI< zYXoAE~wq?)4iGRMU zhm9>P6r2Y80vb1bstqv6|9Sm4uig{8-@$c1%c?^(Y(qLS{`XZa-P?)XZ9e&;zkgqC zAEtDFyt{G{SFS)<^Wkd3h!4hyAff28k`mk92~12(+N@b0U@X>lcG&|lO{m5VuV$=& zAUkn~K35@pnMeXO4|*3{2=yF=NB#{Yt(CaJ60*tHslOKYJjhvwv-0TR4cOf<)GPIj zO=a#~)hm2&6SU9qH=Tj}D(I*l&=OfQaYe;<5agVA>rlIYhcy)qZYaMm%(i)ZR33oL z4`>P;2anOZ0TBgT_96=mz)sn_QUGF3^fWX`GRU3(b6!QbA66|K?IqZdHq;y!raJN& zXZ{CTeho)k+xjD6;6LC8by^Be!cR#VVmsVe&AF=bpn@& z<%5knRFst41_e z^VU2IoNnSl+}i>k;P|v>ZR>8BaA7~n7c9v7+1=m&(VcDsx-X7Lkyg6DFaV4z3rRDP zlz;=q;oKeyIYjiGF~ zPfx--Ao$O{mem55eXj7t zs8UbdBmItjPm=F~<*OqytQyZOaaY(62gl-!-r95=1=(vC^@sv+OZNj9%qq16G!7h? z*73TG=%qRY>4`O&mSAS!5CH5zM@_wda;0JVlUK=sBNQH^g?K}$zu0_)ZA}F1o&d+z zt&MkS4u;~=ef*-WO#$)jK0ehbJH>@UVMzVV+n%XOzU7(9 zl@orEl8+xhN>LsKh~-3M~<&JDx37n91-`laq#O;01qf}=?lzwhT z0df9=9KO>m4e*vwe_#v2rYS;lym?!T=mVTs50yJ0ie9+zl+_l{w2`8!$%eo0Lx0WL zogD0c;(m9+Bs8=N!})aK{krRvM>t!L7zgs!eBR-*F!?Gy)@BZGbbIhZ1%{YCKw*b& z-+9~kDmBeWwkJraaR##5+YbAai@783UC}!3=vWEP$6Srs$ZiaY=otcbnw8Dv1%E-$ znV;ZJVD1F++wAr7+V|_Or^FQt{e|m`RdxHSJ?y7b&s5Uh6hv!y@c5G&YMyU;jSz%lV+Kn;M%=5tes1 z+QO9AX1q#YO}Ei%CMKE0j808y)0Tt<_G&ibA5c+v(|He4$#5pyhq^%CoWF>9ycIt7 zTlZ)9{I-XF+qAE}65)-Az4{-I`7!!nP@zRw{kM&ga8oWU)!-)u?Le95V7c#yIxT|9-7SZN*h zGYA*}8XWAnwu?}WRg*=%$mo0b6MDq&dxV7Ye7{br^GjUhG_q^ly>XmWo{@>R#MA3C zZrXoQ?AQ0Zm0*;m{SGk~QVD_e&?FKgkWlTmR$)%kQQ8vFat|2CaToM^A{-=4um}4^ zbMsx09^g|n;*wd~8XMIWM1tP6^rortW6x<)ekOpy=CHoLGbuPJRtAQ86UsbNC}Qir zWN?5s7@tk_!13PP+ti&@is>m!L(iRuvc~ZW)#&dnHhDV!jfR)IEy?Fi^W9msw=)+o z@ftpEKrK6_$Y}wgR_Nx#YQqjrzO(sYF(`w*6PivKXQzc#(7bGWOBV#YFNmwb7|-IP zrDSnvP}lXo&~(!mND*R4)J_qG?pa!nam z<07+dH}uN*CAv=CNJwbyZa4z~-*O8XH(}#?26w~?X55m2_ya^UvwcLyw-|aqoJ?q6T%8@tO*dNd= zaWv#$Q1_c7CK{Dpz*yTxX>xKTX(b-Wu~=@RT>kkJ>VaVyeTI+8I+S)3!PGgk;WU|C zwDR&`M({Ks0%G~0VEb)^;dFg&QN>fgVx%7=#}UNcgSif%_DhlFNPt0R;Hun=n9bnR zxkmsVHK^1pp@X>IXV z0yN&zCwrrG?^2X@VCd<~i*Js43}{W@A&O|}pqIQDvP(>?7e8ny-#h%I3P?$WuNWG<%WFo`&%pzt%SIQ!_d7$Rx&L!1Wpl_6%ec&L$hJfZ z_fmZS_O0pEjpABO22-_@_QzzVt-xJ~ii)nhlI7(cy=fC*XdH+LR_TqL&_p|^4VBn9_NN-1%%e06t3%j~M;)?~Ch)@%;f~($g=& zG*EiH)@L&>zhBxwNoeQ{$^Y+Z98GS6dr{GMk>B#fA6zZ~VjS&>g9|S5wuKs8Co(PO z3gbDGjf=4|CV~0#7nvJ$4c}zgPJ1!9XU6#&1*@Jn0I(J!3f3S6q9|P;I?Wkx7f;PW4=^{^F_6g}u>7>E%P?zI2)XT0 z><}k!pk?reE2r*;`DdQ8Ym?fQC#G>#{5d$RYkpw&cBl$^oTXffqKw3o_jEg&d+Xfr z@Mtr>se?PwU%AumFp@@L1gO43iI~N@Mc$&!9wyuBaxCIn0z%BTLblj$uALR@h`+pX zK24djR0H#Pb*|NEp@^#6;(3Bui|-m4HRS&u*Ds)A?i5-5HN3{sboV|4Auv_B(n?5s zOsRH?kFafuK%p(d2?N3)ad2~I*FWi!j=5cW$?t>bbr;P}$B~v+i$MI#S#fqVrm9^% zS>E+$Qh#eRf@2{&lxLwXs(m~E==KrG5w<;i8`Wr!t4Ft&-zd$d(RsQ{qao~1PQtK{ zs|h4e(L2k&VYA2#)d-HP)6vf$89S7Y@KE=YN6%+$1%{z;-}T=!`n+ZE1E#%k7cWU4 zsTSddN=P_^F5t+ak+uO>V=zx;4^j;Oj7Jw_rqMWIsR)y5_-G>GDsUp2IVQ>6`pw+< z{^+VOU|o4zureF}c}|YhQCD&sAT?=H&YNdn*na8EAm0oh7R$cof})93bZ zIrm??iCsCpID<^@<#c?ehkw$|%mVeNn4K@bp#PzSaCIbEwgTJWAo~YkJS~JzDgAe& zRnF?k_kW_pG{c$&n^nicLqu*xuCYXmy1)2&N!ftIt-0HL?Pp!kv+xmqXn~b|U%kAw z7pFHI>ji^4xkqfp$zBYP(`_~aMua7moSs&t4~*qVuC<~0tGkQ!@#C~xKG+-D4C$F@ zu4`1B5nSY5{R3Kd=%}zm&!8X+kpVHVqH@?w;625$Xmy$ynL9@z$GG+oYXf`+pe$-C zroaY5odBd6VxZ(FPu4I#Q=G4QlAY}UA^x%`UpQ7E$AkC5FXO?6{(zcYy&Vib4x#<1 z$U-H`mEdz-RwZ$aGV4vMP$eTwKh%@iR!%dT_kz$TRvUj(=Qn>tnQ@-kd$HN63garg zVHj9ypGbu?L}0s$WtcurBK!hEn$hi|=4BcTp$7O#P_YHMyq1OQfM5(5Yz)e~PP5kh8BZUXzk7#@NWnfEjF-5Vh+fd{Ih) zTV&_5?vki`2ix~V8j)@w3Ty@+-s3W0X$s>MMi}Gyu-@iJuH7|(Fl1#2XuSwdUqM$f z`s%ZZ>Zr+kFnccR?2xeOWjwU|ok-)mcNeg1Nm8;+y(whSi5pM&#`(tv%pdWHG7gx>6U{Nu71J>~&K3gH`6!8k5>OoAAln#p*9W&&n=-e^G z&n|AAkiCu9G&&l5im-zCIi0Cz2ABPymOt~80!bK!bUB*dky=_THF`-orJqeN2wxjY z!Oe3gfS|IDj1p{M=0FeYK3%@<#F~Nm?+^4OXZ3oSGZo|SH5+c7@eAq)SFahvMdKZO zULT)79t{pfQ-V=LF>BXJY4C(Hl6qSnzRUBjG=5op`sr_F4g z|84lDnwEX?X@ov=aWqkW>VK{v!0>PPh^cxX#z}u9NpdGD89U9_Z zFnM+miTpdQg^q1-CHFS|uFPm6*}VVd{PzMiclCv0gCq8)s-Y)W+h{&~Q0P8%fJTj~ zi=bZ5i7j6?D?4z2Jk-gm_ZH-bWvkB28pooa$##<6F}$9W(`!(8`4Mj;hZ#%0uxqrl zybz~;@1+}Cb>t7(tO&h37OhV?ai_EaNJ@d$aeVlK4#7c}j2Q7*2(g$@`uO`X;L1@V`g9%~@0Q zXURd=XVZn_28cx7qE=>~jWf2*E00Iz)PEU`V4chqYib*}x$tM;YVGT+^!x29ev{Q} zO-1n*?!{WaXg7RHpe;dpsO+dFgH3iN_FlZeaN2lydeUy*>|}>0{UGdxC(1qsc zbXVpxaBP@7YkW@rB@`kC*9nDDLJA8nv!%Y(3sRLxi*ek^US3|%TXHh6WtUy zef<1D4@kUXc;fZ-{f5sBo7{fwyXPCL-uL#h zG-LYQaUD{!-)q=17M~82MbA51_KmDCx8g{(JnL}PXW?28r?Vo;WVI@P6Ml$E^Px4#t-p%bC;^n*7+>2*F-doh(H;&LUMElXP zK%F=PcoeKXfaH#jKeIM#D4(#8w}qDa!^jA@RPl%pkqGpWB~t`lgmwMFU4UJ+(0WA$ zWBG@S@~bFOU^+54cMK|uwAexxUzC5~fI>_YpkAzprLbMqr8YvMgLXi3i-=;ICjoE} z5jAG;X9w}h_NAq!Ufb#wiTJJC!IaM#PGQx8!RkdvLvCnV+C^O+A3i+WMx=_(GnR`G}6DGYKoNj~m5YV=FgtNk1>3s6!1tQYK@mR75 zua~^~DRl>YQ}7nNh~k2*^Ge~%z9vG?Pj+O5}(MAdHs58WlxSSD}`-?WWY&0g>QkX z-L*F^bT?O1lEQCKXa^XXgX);A2_NBh`MTA`7Z&|($(l`i_vL1g|d1hzqH+5iEvv@`D@B9F!-$<$yf-QW$92ILxavsM&U3lpIMdj?I z9_mhtk3CKaHLq|ne06)R_N~LggS3kfxjw|A1i$No&vq4mYDF%3bkB-O zI0rlXHYJ~H7r7M9xuB|0k5m@Ro~jj(u!6!sclY(r&fk#Hh+(k0x*EDs*xxZ!4qOG# z+KW&m;BcSR%q?8MzQ%FAOg2h*Go_^+?E2;#KzSmc0$~$vWG<;@g1QlDj*!WsdaSkg zqmZbmjD&=cGg+7kY4gqo8e!x2ZK#aBV$B1X!~DEF+Nh5nozLV=ij93`$(S9HqNlBG zn|lP#-b8C84XK@9$a&$8z$2s4-^DmKD<3=K&OYr@)ZB^#83RLyY_Kg>%BAVo zJFz{t!0(OK;^r|)r*<|~uAfMX5qZL|to**UbqaS3&I6)cMXJoB8>b2%Ig}Gh63ZZI z?YIy>F6|`yN4rN1;eCW^VEG#aTCC@ZxWSOkng4pbQ3+Fy7OPc0%W)lKUL8K{^>-){)gLW3bk*vKIr z@s7waxpBuJ@G?Mem=#EUAuOdXFY)MxCTIsau0`8sJn64e<-bCmB2gC2$%cjT0z^J* z+C41)U*FN4CrC1@Y!@;PEZsvT0oMF4T6>R#Q_kIXg;ru(>>6Pu2c84LUs;88hko!y z328 ziJ}j7!MEj~M`BNY5!@Ia?o2C;N!AFar)%~)!_*|sIiq2r=Z;>bgdT`7-@HRG1}@g| z_+p(fOMCd2ucCP?lv(T$aS4yC%krcD%WIVl1d3t<*9(PR#(~AdPo8JTMG~DKD(_p` zIb!$4c6@e!q43k|`i9xwa?az|w0`oUyqIV6N8U*Q?H}X-7s1GWiu2M$8#BZJvOGsK zi1^<6-d?Xa1*SpOBz@Qm5UoY&q3%ZkV-M0?<1EH;@*+d99|cV~KXEewCi*fmQa?Gp zBY=RooGGpor8aQ6-O(Y08`D!$5zGA=cB+zxIrxJ%CctDI5>isx_VdRVZZ@{o-tAW- zA|%jvfKnWOl}s-}W{dZ$DK{KfY2I0)81)>3^?Z4PpLmV{(gkofo|(r-H4lSJ-mZE? zWl4d&4G{hL6X^_)IX`{%F&%ZimcC!aK`W7vhb5$a++E+-{Ruy0Xxt&D zo};5=>#6o8>nA2h*8ow3+oYAtf%at=eBXLnzIZmE;@SIoN$)R!-7NCsvh7#Y70lhm$pHxm+w7C$WaMJ{qjA!ZlXUPm`7v$FWa zXpm{2BAP=+2#hf>xP>Gj}`+uDTp z>>(&<0>&$N2TBUD4gm6|i^@^vSyNqY#aIJJ8b&T$c{ohOAK3^;<>q(<4B(Dn40{=) zei{juOG9V8TfgfMVvKL%JCFI)ELD{!*&D z$Qo_FJ$pR+{mh{IeAVy0n{_^Wyxr{eeJ<+cM3*TN(mr5QkQF>?3dS-)kx>b*kth3% zuX5F?VpGE;iwv|+OiFuGjbh@D&{+MMA5~8#y42=lT1E2}*T4S}zV|omI`62uoX>fE zhtgw)sI74u@H3739FIA9K_`<~xQ1#>ATf^uIQhI-#vU|^UY2-h@pB7rlPn%+xCsDk zs52fz0V+4%_)k4KsH{jBPx7?_dV!!or_rf_*~K4eQ+R6u7^(Ic%0K`QSNmnC(jeo#;%$mG6%;11kRV(HiX^>L0Tu`j%FjOmGzfZY zIwiNHTesl0FuK-SQV+p5;hGP^bahvR=_Ae`x$`K8TcJ^HZEx2w`MHC7E0{|P%b1Jz#4)vNY#FG9?*pq0Qf?K3Da@)!x~;<(K#_Ocgi2zpcbD(T~xvEw1{aNaqU(DLLuMVUPD&RLy;aF~pbW zb3-qkL0u@XE8RZ`+&jEn0L*O%KbP8-8Nr%kClCvHJqP87C*fciv^!g>oO3vY(sKSj0^|Bbu0uy$L;`*pB(b7ie({dQ*hF zIi3O3-OG4cp@SZ6YU%sL#lH{<7b`26yHFE1G4_^-X8T$L4>j;Wgh)k`U^vr<-=CDi z<2ct2JZ$XJE}e*#IfZ76Z7NfJrDNB4)vL)i?n1`f6j*63PmbaJIJ}abW08J5IsnuI z@4)pZ@!Gn&FIroD=0`|ruP*0|eUaEvL-_t!Sazhpxv+;g*(obzCv$phgnm3WI(_k3 zp2NommCUz&56>4?bg?x3E{o-o-vU1`j&P?M7%6b_`UV2b{&rB?1s-zzT?bZ)gO&la zA~W-|UmVh(wC6zn0Z6R#oS=;*t&cDU;gQIJu7VB8UY9xQZja@evrswF z&Hu;Hmo+<0W|7cB72HbmrJwRpGHcV`VGIG9?Nf0zaoAYsdc^l##f-JiuFy*4 zG!}mIMeThBa5{W+a~pAZ6V`4#w1DV;EnnjsR2QWA07Uxs9iDp%E91|%%AJPw-%Z3M z>*Vug1OXDwot5(;kohx?0v(2{<u`%>tm*d1B- z`?%l`CQHy0)!z}gf{YQxTE2~5xg(BQL!est9xGCZX`nZYF);cbpG2J-M4xR7^I^gN zl(B5yo(4_vK=Fkt(JsrabGMCXpY#pCQvCD!P44XV99``{2c`rum#fKJWN?)*41Lkx zgV`H*ucEyC9-DKRuqBYVJGzXO{v<|dyzBT~FpB|X`HmOj93G9AFQaQJ{j2DFKH;n` z!{RqkF%8BN5DyfSM}<)#fnkTSNv57*Xn1%H>y=aPNGabcbfC%WqY7f{aNWS?BWmT+ zAF+XaNJdgb3Y}XX9t$OQjfkM=lNErv<9I*N98J8%mX)fk|u99;(-Jb1p&;oow3*X5{}ED72^gaR35($iCP7^R4=+(+rPgK!dj+YEy9 z!yf7xOXC|^B(Kwgkl-*gI~yJz{&ln2mF8NW&qW?LVQy-=`Rk$2LS|&74z!A2`emH{ zV9vwq8qO$ipaS3Cb!i-)Gc1^*@tlJY2FxC7A9Kr?Sp_D=0QhR~|Hk3jmc+eTZJ+F4R`ZvEk+$!_z=rz=C9YTOy{6+$jm zHxhtl)94YLuH)PRyN#03a)3}JqmVOK+wW`#C>W$|VBIRU<-mBJawU@^8wbaqA5Ye9 zup92r7Lda7(9zX}c+X2rJ-b)#Kly`;{=jLB=#kj~xV%-Z?wLO9=!ZW6%S?aifc5@J zfI*>TvL|~tQn_uD18WB`XGAee*g&r->q#>BQMdHonq zXZ`SC+q+WRXKHICmr@U~tvFI-ND+>;iTRLjvL{U2FQ72!SM^^pYuVUka;gT#XS;kd z+(Khvz>rR&+RRn&fu6UHhAePsfxPwj#3>D5PS4HNA*`K+^U-T07LPt&w~*qawaXnz z4M)M>ReM?qt2u0Hhu(f{18-8=+dM9a4iJ9W;wJ| zX!8;j5O`|m^izuEIULFBc1SV6HdaSda4rXk>(q5ai5R= z5B1Xl)Dx+2aP9HhsDI^xDXeV3y=-5*6=ahHe_T4E@v?F};XVnZnYJ&K5a`{8rSe%h zW)^(KbTa`&F~pOfGrOIlkR?My!>BSyDJd+BipQ%fVI(csubAuOvYvSdYj4zPnyZhKFU3HC8G4atTKORg9zSbKJ}S5~->syXQ$ zJ{(5WyklamtStdtZDMO+&Fw{A-?dA}Zzf*rWR@L19qu$&7iiZmt0SDZ z5f|zF;KrM_plIgRVd`AqZYin1=V31w)VYlq**$&KPV@tm9(>>TqsY3J<k}{N;((42G7p^Eb&|tCb9zAfan)aym6SYQ=r6U7Tie+U$tWFL z&8u0b79tV;;xj1C*p=ivcdcubpa#tfkT3uY!MzT`&l!ZnR^1c{*-+< zXp%iJ{$c2IXu+U0Pc_<^zY>XU0z)JS3@bFI+k84$fM8%oLblT#RM;vg_%dlvu=6BF z1MDOI9n3SM_$l;AoA;g~ypSrH_oVM0WrvGF>e3(o8dC=BkU*u_RCBIl3BNXnE7Pan z;}^)Z!n-8KwRG+QFJ(@(=G`SJuc!#2@7TBFj7WU7v0IsRHR6o#i3$lV!wI8!ZmOOf zfv$vzc^mPtQ&Xc3!1iG6f4S?CH$rahBbC8*+rYwIbnrbdH<~4E$8v<0z_A`+ zDI5+VJ*fWvi4X3FVIq}T;L5LG;h~`(M7s#~cS;ZKpo#cVEX!Nclzg`&kBc{O?+XyQ zFh&3b#y}BtPp0W&UL3e|LR)sbtFtrfwrwxR99lI!!52C-pe~zVL(F=j5O4TYSYPXT z1jAIBY0KB{mpqrj17@~+)MxZ})Hn{m%37Y;BFL}-%VP6|UJg|+=Haau@LVAL?A!P6 ziJF9~!ki8BqJrB0n8_mi3JByE#8!D}>GYezxA;g#<4Oz0S{(--lT;m z@b*%2xEoLjw$H2mn~uB0n^lbvf|QFHokOHW$sl?>_#5NX>;V@+1lQjA5BvWsb*oW z1Q#SWKn}jciZt=ot=i+yXcM~LzyFPu!Bi~z`}3^Iu9CH#buz~QLSMpQ;TlZ5g_g-z z^8V9_y{bhuq$d=ik^aA1%#;+i`BjR_g{s*fcc?W)5p9p0ENUXcPlD-a0V(LF5X>#E}I9IVThBC zw?qL<-BAywyJs$_tb8*a-LIL#`4ko=Yo% zb^(Mal<~esyf4608I(-#Bno_M5>r!z>U&n32ol-xA<-7$v%?+xFbY`Av`S@45iRgi z3>Rhbb+V}YNyJ4-PL51EvglolCtvVl{Fm{^>ieDX*bM%DoC;T6&;_+C&qVUY2BVJ) z;6OGuV<3APfN)i(5M%ToGY?V9y$Ah?LEI7lp=73HbLlN&f5K-AL!4XT!D!kNtelI! z<|D|0Mg1w{sCOi>Sm5p(-B7zX2Ft)kuBY&L+lqAr-BR2`_$bnr)@Pf|gap7-fpsEXMDK>e zO&~ZbDp*HHrl;jm1f}{(=N4QA&H7zWkWrF3MomwzRkeuO9%3H+DjCn58YeO`GBEhr zDQYeM`h^zakR?UDln5~NfH{qT5(l8-*m1KT?8Vi*d;Zk%4%3HK`y_tA%GY@{V*qk3 ze}DfCo4JJYhAADL)8Ku!GCz9MU0M1|{~O6KrvQ(?J4tg8`dnO7f{@Pc^S~{FlR$4IRD_+AlP`Y$ zkNX>>w2rL6Dqn_cQ7?drn>&^ZOQCUI1sNzAJIoyJXJC)7ziV+qFV5ygAAV*)p$?kk zq|dz1p4HXX-k+N1%kKaWaf&l(k8llS&G4pzPGV}3x7J<&)`G2KzOuh*r`&*hVlr7# zLv8(j7)#{&9^JQd&`}5sET8Z7_`$8@!xOQDSa2dCTlE0xci`}YX#fH6zjTH3Z5<>xPxAq)~Aw&Bh_01Bqv5ogg>|5Nu z`}ddyKHaO?9C^5w&qANvs{AgX_H5|is~-eN)3!cYT4fA%cYkzQU^-^{?E{_w6ZL3i@YHxRQ*8|TyF@+j1ulI zImh`ZP$QdI36(VDn7WA~jMBU6dz4f`yc>9k%F7^3Q#fFUalhS7kk_gl_r5Vk(8mC6SFUZt~T$u~nc%)I1_5g$!VeLGI zO%DQo`>`C$BGY5gVgrmy!956Z)%mN6FXCNBz_=BK5f4_#7U@5W5AIt173Cd9o&=ir z)-V}nG(eWMlK%6%6ItEf!I8zcaWT=+=TQg#6gq%}lQ}Ng)zy6+9dj567Pm4lV8B7c zBItoueUlWNRG7q%u#sPRgp=yQ<(oWnWHj8jnt##+b(;U3dP6Tu^!N9-b>yI+Gi~!Q z#pTN`#N<;+eO$YaH1fg1f~6gBzvr045($LF9Z0>N#*dh<;%f2f#3C>=KXT6B(hI%kqDJ} z#%o0HIFN`uPE|-4SeA=3M?Z%B0mQ+@lM;>EpL(?vWJo1IybC z|0&WpRzqSib6@T3?8LQXQ|tBe?OSiOJuVVsyFxGk=!)LIs;-F@{@+CwymE5OUhq?67cbD zZ7$+WzznRmEIg@Oo6}f)o}xd4;p8%M#SP!C6TYYBb?TDk5Q7I0YU0Rwpt7C!tQ9Bf zEFLx^>#nai5ws(w8u3eq&fpq|z51WOVi)DU*)Xl06X{CVwEqV-Y9QX9E(AQ_n#&Y>vqR!YRVRwLtyht{H}=58OArdEpZP7LVr}e{lbH z1n=`&Q*fLX_w>Y2GWT3qN<3or4q}7Y_8`hWnG+CJ1cw@Ji9Y?g{-L3vDX)p0)Q3h& zb0Ja2i3j57*{jP;5?p{`3}4)liAj^|%`&4$K*_YO^C_hYff@hyuA;5WvGzx8Tl%wh z#yl72i}0f+o~pl1Z0k1#@u>Va!469a8Y2-w3mFt}yLa$7W4aClQTl%XOo7+dK0SQ%24Y;2%wQlf*2TQ=a2A%*C$=O zW@~T%8grjrV;F9IY|Av>D~ z8$P^N$86oR{+cNeo_&xR-3S3!$7ctS^ScMqkx}&P(1J8aoZ3yhpyqkt-}6_X*Uw=A z_!}4SE!Y!cFnCXnjbRiD8pEh54b8osG;J=$^T|k@H^6+SuM6lNB}tW$l_d;=4Z8$w zuixvSM3@nxr}4h#XhI9dYp<*lBK|u^kPX1IkhfmWM$iN)`w8Yvng{}LWuM_t z3W#M>CTz;T?s1zGK(t03e2q^tmWPqe@IDcX_y6Y;D#H_i=%#hBag$;QXg)tGx(jvHpv6# z=p*Eh=(6WqFtx3utkE@xKlFfk^68JQ&v_DUO% zK5%0{4z1OZ_3s+*-{k23YrRiyzPh_!+6lsvZg?~~J|hay(T@0{UH{J)osj)n=a{u( zvvr}*lK3=t!&rf_&RXpmMb#d~|NKQQ0;CwXZTrnlybQ)4ai#SPB)z>f6?qf5d#CcB zEbD!`w;x3is?er&rO4T(ZfuXxiuB7~1xA4L0eC%5O8>8un?wkJN7{wqiLA2nZ%7*C zz|j$;YSkLVvdB@og>eP9elq1vh+(Bhd*DG$a-V@&0G}Wfa!z*mGoL?yhWGQNHR)YG zN+@{KrB7^8bV52X3n>hZ8D6Y#&;gD34z(J5i>^uHTWg(juM zRmZXZp7TLUkd>G*=ksGO?b4k!{dbKwIK)?<4J$0p4z1lAtnvGpEab10aGOW@YN6kT zpL`p9vr~MqV_>~UWBK^b0?IALL)#P1$neseI44B57B^`Ht>1S&Qj|#*(MP^-auuyk zdCWER$TuF-2nx%eZ#PLswQ1#y%k3YMF_F#f##8^48v*3Wd41wpxVxawdKZ>+taR(2CcO&pN+2eO1 zG+W_5zw9N)$JaPGNDyhi?SXXSI1-E~Jj%|&0q&lm1qs*i|3EIl($oMJ;S(+fxuJ6B z*qj`q=?{tn@JJv_gHF3(B*E9AC&$deF#x4AD0-SqA=lPxyg()85T5FbO9Y=yn_=K+ z4_G3`nsya9lr+vys3-C3defG{1tlXl(cGg30Vfo>zLE2Fj;2 z1oCgB@T!nP0C*%;=c800iN|fw%ZIW-BI?w*dq}Mfuf{k2 zt$S#K42ZZR;-%E5Cn5z(&O#ASe_Isr9&%5{KWY$t$9UPS{N^#2D&N@q`i9o2Kzj@@ zxCA5Me;)4cmJ|^wnhb8m5eE-N`Je?S7D8N_JXLw>e0*7u^a%~OnK4(U5J8JJJ$(D< zqJ0aG6vG<_?fAROliv8AzFMe3uYu4|j|TxH!+@>;31M$KbX%$a_3QY42vtuXKOUsAxdrW*Fizcs@)We} zty|dpuJhDwHk@^a(lLw612X=;UuMi}RJ1uKDf^KD2B7xEcF&+c_mF;^W;8^p>VGh9 zSN(o)QJ}Y0w1&>O{^ttU4H9~hj+mZO=AR4I7tCDBD7UxPTN3)ntZ#bO$hTARYYX|e zNRXf(B6}I8Pv$@TS{wN@6eH_Qg`>+zi0GzUrRNfj{xCoCQAlB|74))qin+xh`|^^z zcyGeXHOCBTwtLnU4slA|^z0J0fe^66uz|gXP+Esme&)TUZ*;1xyc}5sqIf)v1MvlX zf#}13?xcMEOFQ+Vpu8%@^H;vV>|tI%M-M3*2QJ7yoMW=}Njlw~{T%RB=K`EKo){gl z_Yr8P$|uom#LA*O2F4?+0Q_b@2n`Azbq(cpr}HN(#Qg$Jn>a!Jb zMU2_|_cUP4-!1UuUk;_>d;hbKwIUhjYb?Hl!d0~|m8~tpt$-1s!}>b&X7@^D!62oK zw9|HaW;_6HRC>g)b!6Fr$<}n~iEAFo?tgt1K(8RY-JH7&Ek9@jOp2)6B`RLS3l+NG z8l4~a-nz6I1MZs>FFNa|-&g&BeA;30{$sPTLmbI{iUV5K5fjakUw6(TC~ z-lk85qoLJIPyw9S{S6oua-s-D$HkEFE!(zXUOz3zs+pJp_&Qg@t_)KZ?!Jc)$7oXaL3PTv4v7&UjN#E%t)0c5PuSR2~V!l zZ41UE{b%tiKZg)t)j>ud6+VL|W*!TxXRK$Ov$V0zC&cVH!DVsX6B4JMsP>4mJKM9L z!7qLXewE=Gb@o#p9(%TT#O-0j)D-&_t%fM~5AHmsfy_)y zct^mIfeec^ADNh#oGi0nF0gtTsFD0o_cL=WkMC2Wr>Tj4)K_eHtA^|~(i&5fz~@Ik zf{;oCO}JGr9Ut9=N+F)>!C!Wrw@#K&oBs6Tn6A$6)6qM^Jcsld)3;!#Fh0p1k@C7u z{X%~G)!(8&zZfYiKfdNDmD3E7D;>u^4Hh^E#tqY;^kW(U%V_^wRAlqc!*gl*9j|N#-6uJ_T z@Xo2??}OF6YeU(F0xn9nD6B~?YaRq9qtV*DVK=w0n_JPQ*LiK}pX0(PbxN zB-9CH^c>RE#XGopfKjU=Q3BpK&DiZkOpjH=z;npj&!Lj-&6_1?l|$aYeqDaJ>f5Px zG51W$L(@Q07gDUkYVV>oz5bfzkQK>lGH^1ZyLSIve>v6T1VjuSN6i;Zyh#HEe|&B? zH~JyDU2k;vtmris$*|Zdj)lJB9|5e|=Qvx*jkG*EL6;SuHB=cE7WEl~g`-)0gs7m>ns|Lbg{&Pp!aO{8aJ@tO?sjkx zvk_nil3$pL9-f;HYB7}EE4Ftps}4p@Vx9F#Nh8vxeSK5_E8IT7w_}HUYEn|({rlY8 zx8J^bvqkDT`~Rl=@dMQEi&B`*`hq#fqyD2|(Xq!5v8Dt$?7f08tAw}1!Q(f5)R{@zIvhiV~D;c~U%9Z4z&UTN^Pv7L{|vnm7K( z4A(u5T|7oI@L#Qh^F#Z`mZs2Ssi~>hG-&BJ-xD|v9Yxayt^1gKN}xH#f=<(nxkk+5 z+mj3FPYutbqrL@cUGrbRZtbyIpx(mGZbx-cvNIFn_<>+QFg+&_7;%@UyQvMlwC{m@*-AQfwAuc{*-KWIdvI% zdD>>A8|XN#538zPmgQRLs;qyxpS}W8jnX`|e#;SyDai%qpET8^l?XAZX6N5TR0zjW zi;+rgdrTP_x4`&*=kEHXC!9)BPbD@snrvX<{3W!mTrPaZ$xKkm%yu z-!%z-6L7c`7eLrzEF_R+-f`!89rOr{OG9h+JXmVfd;x-tkNOBu3)(6|DRDS%JoKD| zV{uWDZ7nk7USE^$dwih^XHRism?{noo3_C2ZwIOoS^$6CR01ILK}wwr61vTsp{WR~ zW@wnUe4im80D7%WU?d3l3j|vkvQX_0U0S<%J%RDz^KJ=+6C>B`dPq)u;rC^fjcgCG zWMpOiI5Tt5vIwkz2s~8NoNve*CG<>#e~X0Kv4!P7HDRS>+x6H*VMEMOM2U@7>nu81 zU?FmELom49N$E>A1_mTMy^&EMw|&p?Cg7JkjTFvXJrKbVwRN^9pU^Noq*cSbV`O9m ze_7Xq&zBbGr@Hu{_^iGRy0)Pu;P=nCn&Zc>Xw~S;lJ0zuwmV!;*GsjE_%QjR zqfd(N@9>~i&|KGbD3jc+qf;+VR3yyTMr&+*_|^EFm~nhbpG%VAi~5B0#A3@6KS((D zD$>4e=>9zHB4AUnFZEqnwsL(0_`M2F_^@3>af1H@yY1-UFd__}$GasCL`t|8F^q!h zxwEya8CA(dbwrDL*v5?JgZ~d*?;X$e|L%_?WM%JBS;fnqAtHP4y`m5rR3wt@t&mkz z_TDKH*+LprDwPl=rI11@zx%5`=bYR3d%nNF&h2*2>HU89dOjYH>$>ji66u6x?=xbi zYc(G{M8|f5ElvE|4rdWWEVH_SHLqf&ig=Ex^DH(v9MRF%HrKCUzSq#v(GlMU%E6NI z6QR@D#f3>ypy&oCHnj+ebv{mr_g|qMn$jyh=uW}eW3A|CPpS(jncOZ~Z5)UoE`&kj z?)+D-Ns2%5hTdFZ#a>PK^w-rrT#S3==Lwz0QTw(eAd3ztUsqDTNwN)M+Osa$&_Gsh zPlH4{m2U8Aix~Fd?@S~U4$d{S4VO8;=Zse*@vG8_E57%9dfR)!=~#TRc{r2fr|0^l zSW#qLHc7Ih@6OH}jg6+)_qF>zs{}vA9oa=%b4hT3Id+McnR)vCd&*Zfp*m=5h>7T! z+jPl+>R{C;eFOwgNE(UaH14{G_EW#l6a^f2oQu&MuMPuO?xs6)On*5y)9;A^Di6DuH^@Lu*+Y~5Ioy(nFq8OT}km0OjOt!BGhH+U3 zf5;YC{33)P%}k~`aPB+XIdPk5@7heO#R2|8gAkf}IP1n=yud17XKiTI6&J+iz+8BK z4VM*gSW2s~w6hYpp+3l8pG5uh+Q zKDLF7OuJ>BrXB$RDD2p*Lz9VcL|#7~v=gao z_`AISO8LkbUrIVNqOZR#S%stKT-CNTJi3C!Gq|hY_v1VGjy8XNdxZ8&Sw#hA$*|F4 z0{~^k+nTW)2OEWY*{C@m0Y8g>KQp6URoI1r8>j$-XA@$#c9MxtK`*lB=nHe@bj_#% z!zUb={*kHVb@(uPXEl6xG9MvsW$k@92fZt_A&&If?b3zEIn@ymyG5gXvgFVP zwuOwpq&6`|MiZT|-0%H9{p{fNl_c?@%Y?VL&uSIE&8khYLwvE54;!LZY=7sa#jV z{1mR2Fcy%YCS9+ps`4%bwUM}wHl+=pp9+63eoKuTM;%E|Bf?bv9O_%&`SJA<>jc3z zylREQ2rdw%ri0|F>1;S!FO8SB81Iv}t2rK|$npH|$M680#^YxJ$OWn%w3GV}W_yvdzoK zDW$nKr}Cd>C|A=3eAV$ZmrJ|^GluR?b@l7pg}y&uzMK8w{yc3Rr^BgG_;p3(HF27SrP%zTC?*4sjsUPKikqLeXkBnjI7 zG;DmCOv$xrP@n*tN^kMjo0vxdTd~M=0UJv`G8J(d#RPAqj?%RTOwLB!NbEuQ3&uVS zQAmK(=9g#w4FF9@$Ei08<0r)F!g6v?ym1=K(1EOYwA1qi4q}7rLDP=W3 z5!;MCZ&H?+L3zAd=@J! z>D~VSc#9w5t!VxJxz;j#>g%PLk+oSBmAyX_KJW1we=%k8_2;uyy@5Ene$k@9PcOHL zmb2J|_ivTZ#VT^hw7FYhSA1=P%zqWy8ccib2I7!;Iz~U)IELaYpXq%bp;6jBIIj9E zQ{F#>*Il*(0D~wY_}7}uU7ZcH8(Z*FmdL1Ch8HLp5gy{NKH@ESsY!`NLU}nk)l&Gb zQCPO+Be{P@YkOG6Wd)>wk9u1~J4eFbAvv|K0g1=sz4 z<#IR^w9|)wh4Jz7KCVyZR-jQovl&^tKh!<97HHGghHc)ed{gq?Org00}Prbt+jFXBy%I|Og-K_x=)mCZJ}!B z^ZTf``gjB9h>KVm%rzeD{BjmS01c;n1^zQ8yssUb&it<$rwDc*x{%HsI$ByDgsBU4 z>?%TODy|_eOG!!DHf(3`#g|9kTZ3=wb~n()oUPMS!vh2UK|y7f`F`E+pf4wGCQ=Ri zwFdqdXf8LvSfSN$eShex)2pL(@8~hywk5^pT@`h8^_c@yGJX0hZkMr;_m>+axZ2wq zM;@m$JFkLbs?-P|hq4>BjridFEP^kmNUh87dhEx*OV0?Ma5h=+>+7{$vwTVyHm>vu zvrYQ1!r-UOVS9DIcS_S)JuBA@%c6eSx;`f8wY0oihyam%lnP(%w8MLL_#&+E(jZ<#Vn`)~*9 zcs;#)#A;_JOz1=m+FLwG+zSzPG;v=56r{I>`G8h|5FvZ!_erqsgn0c14{Vwi(Ou0n;8D9RK1 z3?m&)3V65CXpAT`_=3(i# zH`e3K?|!Tm|NaFpg*|>eiFFf|%0--IWWsH^OD>!gg!$ylRsVgs3}2rrLn`qt?^wzQy#=OMO5CDK&GnA-PO#&{|pOBX~`C(*e?n&%As(Fuq3kHEu! z+gmlf$gxx2%TYig*BFMb6XRB#a^h~r1;vyAqHv}-49u=(?v}l`fr_Oc?G0NV-0gjD z(FRY1cZ;)+YMsLk%IAgmwj9%Rn>>Fn9aV%$Z#b#WshR#IxBxAWrc3hVMK<9Ua^=5V z;?ukXcHm%XUK^n&HnJJ67}X3zR=;4ksB~cYFBT~5`DWSk$@<2;TL*pF+|pkMy_1Z; zICKR93<(0)_gK}Wb58?4{T12*w76Ww(`QuaudjB!sn6Q~9!I>+rKqr2RhS!rs6%5m1$*ngdZ7?@G`jX8 z%eZ#1LbaESQ%+Rg^`Z6lXrEp@N?w(bWW%9YG!W-lx7yHuo>wsXF2RB{>-u$+M(>s9 z{-2P7Xx@C><)ja)_^TU-&DO3>OiaM}hvt^~Lw5<={R#j4JO){rKEackw<4IwFXn5T z`GejaNG6!4v$n&{q1tndp|6p3OXDwz+ms9dKpQ z+BJ9IeKzi1ns;1Hf(9KyrrKz|!X3b*c`Jty?sOcx1UIpuwD^kv1m=+Ti?M3e3rba}_0ogrYBCI@CXw?+L>noFF!FSyB)1n1fpo)#~o)0h%h2 zX?HB7v@BTUz6v&M znws^5s+yXG|B^-cQ(*Y{^feClM~Cm1pAzK(utR>PRv)!o3%-VhGGri7Ezl|ohS;TjK3X#K{VfCA z5~E;4>k1m_A_e8lID3*qyLM&CWo~WZoIU@ZD|S8CsvUXKTPdT4)`f|l|5!Edl+rVX z#p$a14Q)S#i^-h)ky2V>-@Dk{cd*FaroglOWheyUOkZ`&NI z%v(7XKmTFD2tj#b*)x8`{s)i(b>IWwKp{M|C^O}=)R7*38&@eUccLcv)uz<6;Ouo< zQpz1X$MR3AUCzR%93`uUQx9@}?dXeKa=I0amhO%eHvBZwXEp}HUmSQ7y*3z1k+bg8 z-`jiU>{;agS&22uxDZdY^vpUC#Kq-h0Rt0Hkxr~dax`)^-94Bn=H%qWUm+?k4kriO zPr1kVw?N{KTz$i~vK(nWQaBy9NV%|;XBtO9VFKpb-10NEc03oiHSI~_UYL&`iSiLl z1-DyUr>ns_PP>69A?`BdeR>`Urn|jZSw)t(L!`eo*>M>%gXri#&5$p&>}?_cBbbIw z<|kapJgaSZXH|^415Q}8=nqiVe70sg3~FaiX6gR?+l~&HKp#wFDg0C--u>>c)~s6@ zd=Vmg;qBS4?HC(w9($E_%kT>JCcy~qe{mxC1K;Z|fY3GKl&gH%pI+YBZHZOH{3+a$ z3sX}|FiS%A;F^A_CGeB&ug%p@*(VN7<@Mudl(G)I)tjuuA+Z}&M7CfyKg6jJcrA&h3qp3b4w+oDRCyzI^grX9T}*9?-wS6Nl8o;l)NY6l9L5&l3~HJP?&%`s`5HGUE@q9t;nrXUcS8;K zJ-4fM6Bk-h-XV5%HDuL*tni1wwtc%`%}tSG5&QPs>KowK1Rv}ihbYpd&A^*wixCS=K+ZBER3ebPqDf|^o?20l49Pl6sP_fsJy{qvSBP=vM~Yb z;MBb9C1ae;$Ku7=Z?? zU|KHFSbW@jq5ulO$z7v*9$PMwF3jwnc)5E}x%cMcaC}hIkNIb`YIlGEG?SUIIz+={ zcM@upfKbHU^$x;_(s90{d=Pz9kIK-42j{@75fUv^XF_(`yoRtAAuf1bihucF$H?~B zxHbE4^)GU=Ek1M;VI03y!t`OEP3sf-q?8+#XeyBa4-9i!EgYjT*0S*__*w%TLEEHX z7y#vheGo_rD54{{UV|8CKAA>F_l5ei>kHNTL|9iL@uZLXfQaE(gNquYV^Juaz9tS4 zBMvL09y!4+tsu4_+YkzVase-()jpux?#H?n7;kyo+Ok*gdvU#(?uo=m^t2J*pKOMA z*#=#~J{T{6*Pc9lknEN~wR4N&0NZHsv1B6~0sG1p4qWN;U)xvBs}_?7I;5BPMk~-d zvD%6aC6Ni-q^@&uJF^3ACoW*@$b~yrSe%Y0s4&t0u=^#!4=Z493yu-AsjUkKb$_?QUKjpcNYLUk$s_-Yc=W95~;11pS%3MaFJ-n zdgcx`j7T5n64$V>7y*|%QE{s5>n-u;m3MpJHaq>gz&^D#XO|BYypTsp$|PJEeY-xzc9qh8R*W$4>^Cu;`bq+&U7up+%&4yut_0 z03D~^M|#{7A7S}5>TB!m+aqm#NZSDW(q{)11qdXzgzIycnJfvoS*>%pQje~=6p~e= z2NZBl|8SC66W}|mOO?42_n6QLVzZRBwqR#`UV3^XwuZhIXSy(M#r`_fnB!hFub~aE zYFNF2d1!R=k>{qe=HY0W^o{8aP6on6Y}80rjnG#CczWVWoyakiR@*qQyhPsbIJ;&Q zNzZMZhwK@Heb}l5B*cXx=Qza`5!sl-9v(Y)w@BS_efQNwg|8s|u34jdtss*@I&reDOGwvOiFQQf0{fdA zUk0TlcPn%V9l4=D#PXM#rHR^hPr4qa6?d+5i7UX9izi7(4AqO6D{PO8>?egpzJ?~l zgNH#`yM0Rg#ip2THRI3X$w@aQ*??cTYqyTRv?O>YxH*kgSjA2B=VWEQ$N#aEjPA4_ z=F>SsOHFwMdh{;Fm@R8y3r8GUf`|+_8Z{B6;28ht6Nd+vo|+tx6=}o+W7(pv`^k0D zZKrJT>oxC#%9oV)uud)R>%B07EdHk18|L93yT;w$_^C9`mL+Y_mkEFV8ThqdP`y7?x$f{+*ERMNPs?PC75;&mfB(3VxsKN^ zL+kJ~DnWk!{cLxAp6uezxELQ_fAePGnG|R!LGIP)K{rQ(WhqzBAaWY8KAI}usKGt_ zS(_56>c3Ym;U@=Yt3%F`RI@v0m0kba6LAp{rPH5tEX6PrGF&IJj+TAx6zSbKG@sFE zq1rpXM;g1FINNzz4;VSY&!AeBIDd1ow~x=g14;u%f)}q|C8a!O{Db?*udPanT8F-^ z%umdg^v8wd;>!s{iKKb>h+{BdSvD+_fj1I2`5IQmRL^$1(Sb5(wPtVXBqciX@$KkHMdZ)wj~rqssU8_QsO~ z%#Y3$0I|mG#T1`RmUxkvfTVAt%n-Lb;+k;{8J*e9+}u}ChMKF4A2PNhEp>|6m1sPL z9!}E~##1G2Qj?&mm!PZiIy%$^pa@}Im6wn(v5sVaePmXV`H%?8&^_|BaQfx*`ld=C^J_yOFfZahsnFhLiYvIU4RiR%C7Nu}X5CgYXba5XuHQe;X z5Q%!bv}#7_k;jGR;aoL?r2g&hoO@MNh}D?2F!!!SnvpgB_h-AlZ8_k2^IYVYle^^n z=8$@VxJs$P0&?3>S-;8Jv&Ma_$ z5f+J?Xc)WKpII8G{F}r7j}vUr_~#HTYD0|N5BGs0!x}+PKfm+Pk}W;MqYKT)>A@?^ z%vZ}N=44>L#kM0u;fnmBI+87zYHMS3xF7*phUoW24lR1SH)zy`;{PE@?oxO?*KBL;7Rd$6Z==5iPaS-`SysML#?x^0EbF7a!Gx(}xO={rQ2gWf2h(ety#3;M5_~ zU@;i!Z1-Vf-S+riU!O4B2mA+DT9G^690Pg-ASiX~&-g%Bn?F&}sTf=+*cCvz2`44!O93eJTj-SzWG7QQy@xcoEBAdG1c4&F2~{>vdqBgoEv zuD-c$X7F$m!B_f~-a>8!iP9t%9v(EqZ#t073@a5BPSP^mKl z*0)rEh<5DG34sg}l5i3O?fus2d*<&ydc@J!^_BG^`5&X@XqIc_l{=ssgSGfJa_G{R zzR!(pVc>kgR*>Z{_VsOt6qiV+`Ffy-cMr)oXiIdUeD;Me==Ufwgz1j%B{RUVH*egy zgA$I{$l_9QH1hg7U3xCk-b1~auF<8!#m;x3IX=;rKo`3DCTJy7=+U{tKYjPE#Ql?B z5LI5mQPxcARlSUY6rAEEc(W6|r8^9+J%jyxjibq#)OJVp0r2XzRtYrHoY82y7#oEQ zZk=`4PAe!s%YIaufq`LasY`z^wr}p=Px@MGd@3P)o%9CdkAk{7seRqvtWq@c1PeR| z^+(+|ld{8EFeTvYN8OHp?b_lWK}K9z*{ZqA$fgj&bV86q6r16*gH6lYBAxzhC68i8 zryPaWnX3vQSwC{Qj07oY*3kArU#T-YSL$c&!P(kvg?yXTmU19VO<#0MNaPyw27mG3 zeiIY%-<=$wjzP@so^SrlM?OkyGVb`lo^m(N((Zq{gKFZ0%xoQVnfjYD;#tA7Jm!SD z65VsyuO(mw>RBFKCIJCWgk`+7y&k$~4G_u*?X#)28_=1Lp2C&}1QG81=K>%Rn|vke zVd)`14qIn>-1xJ>XO%iC1boHxmp<4Weh}-hVcutrCvqkuW4)#Kk87tlkkJv>1m7IC z3KzX$Xm069VUO$<0C&itur)W|Nd{gxb~uS`3g&_{LhuLakdv+QJ=dfe-y<}dk-!XF z@|lm78qx7q$a=yLg(Y<2vxX}S>c1GXe=IN0Bl!_q2%2c5rNNu$C6zTpd#BH+tbSrT zT8K6`^)r_8Mtc~h_gw%Oj$f~z6&y|1(#;^;5b zTM+;U38TE<1TPb|hNqd0k5=OWy*U$9Dw1>q89J(g$WLi`jl3hD%15w%T(Vp#FPhY6 z44hq9NTK29x{OQTbLz{-kD~Lvf8Y9xe0#n8{Jzf569&noRMkax8BV=>r}gUgl%94o z+bZiz4PW^v1p{4Yst&5W_&7!xba_@X_hWXmKXSs88}C4zVeQuUW-|wi7SY$pFAltE zIidCPVMg50!%(b`#Ux;m?+~_l-?Duz0TP}omTbSofr0QGL}-|r)KeEgwc#n+{cJ}I zfDRj-+?2&@oo6I90GSQvOg%9KooT<_x;FLC^>swgf51VDhuPQUg`;$ncTDUT2kHIp z_q#@Q%`EKg(P!GP1t_gTY>0abRpnshS^EH-C5~Gn0*ID*ew8OvUyPI4xi!F`>bV|q zqfzfi$ieC(z#tLxQ)ePn^Sfm0&oFIMk|>7@ zD#iu|X&%`R`ub*(jhErkL48X`wE~{+RdBjlnxtM$yLL-T(*HQ->+6eV%-A7RKJD)D zv=jW+dxv5U#zME1lt>|s?mmM?dT{3Cu5W&Gn9mp6_`h}c??m5`7rd~{pc8@)aI=70 zwA1htGr{h~zOz5*bR%CdSf<;3acK{+xlMXLCMt~doJz=x#E=H=!~^A9N2QLw{S zR@P}K@k*Ga(r1IkOB1cwFb~i=rbEeD!Z~2Pc;q+q0tDZz){uxXDK#~|@48NEGHmw& zU|GK+@g98epdG~C>6Q=3&S+&grK=nJBao0q`dq@|az~Lt*db zRf=|fv<+F1waW?nx>XQVU6)DMefImj@UmL~dx*iz1010H_p1<8bMUL{%*zK4BzErX zM1fXRv?WaBI=6>BL$XTNgSjl?@e_A!8h|I3kH9kzZ>s*SEMuhH_R+pwVjGIgdx|L? z$a66-;aGyd7N)MWM=-d>#Ka`Th_#BDMU&Afe!$QHC5ZnK^G+gu?tqa>XGaR*WKa-7 zEZQtdb=U18$HT8)6h8-tQ2KJvHTYl}PtJDTM%U!J`O~0VSO@Dn0 z$N>G@(I1;YstUi>iogx+?gE4){bIuQ{qo(&q<|^vwzSaj6ka0;S~6yABJ1|H9^9!p zyMCYWm^NuuFqdIC7B57V)`NVyXMNVJ>^$4V4&R5`p$Jqt)Ha~ka(o%h^PBh{Gzr2p z1=B5%#Yu^s4^V**+&&p|mwAhgr{YZ`Px79?3Y$==AcO5Z^Kb6#;iIkV94>^g;Sr#Bo;!tneDE1TJ*gcvF*b|L71_L)%|!R$=If*{dOgV^!w_wG7WhZ zn#ao(zomEm{l;By_mkd&&IMe!`C;;o(XK9cK*KAuvR0^1U8<+ zb)CI!-Xj92fGz#$Z6pRB!^X(cF)S2YQRui2ZE-L5A6y`9y)pDH+a|+=RMEYg{K_GM zglD;AX(4!8PRCg6UpX%W6&oWwZEk->**4asrTEMZg3wYkGBQ5yIDh^mB_gL8&i4Ri z`tgH9wn8>{yhJt?2ylgmgxRR4?8{mlpDU zzCw$uv~b-{;qv8jh~=!bESiH9D8OT6mYoX5P=}`qE@9O6J;%niDJz8@^>rVNW{c}Y zW;#TSA9UXt}JKXSysOvzhB2!a4`~gQF`2iWZi&OKc z_5$D1ohPu#fd5-dR=lmfJ*K7o#YolnWGW}0EonYd0m|p)tz)@sRI8-14f;^*??IKB zwK26uVjcU4IXUNWIb%sB=kCJe$l}7VAV>!5FVx#DK=)=PL&pDdi;>nG>PdfbG+FZn zRyX1X@?T@u!+si6Oh0R_)g-0ddJ5}R5pWvu4u}m>OpZLGPl_j|kid;&*ndso1lC|- zD=DdKed@FH!?1q1oH>ms8b$|V-YtgG&4(Gq5K%x_{LT&cWZ(sWM(>e*s=W|@OjZFi zN_rC05xg>Iab^f@Gl0w16Ypa6kKy$N>pd+fQgfs3(+5Jtp{hF*W+I)*L-b*P)(?|+ z*Oh6Uxm%u!U`GTAOR?@h+fn}BqG3QT^st4!O`uFxFX+nIqgQ=n@7)8suR?@F z?>vKs`8LMTHG+UZH>_@eT72KMDh!XHQ9#kl6L++qJ zIs>#CIzCYb>D&`Pfo*`~ji+nd{Ik(oRsOu%;oZzkv@z2Df#O0OY(ThX_7vcMl)V*c z5;2IBy?P)N!8S{S9!@jjnY@x(9ko2RcfNnBJfUVPPlul-Q{!2>tYp3Q3X!@~t zru^KhSSULL6;Exj+M=xN0{{sIw;bEn*!S}J%?vda@CHC+q z9#J-tGk82e#hw2Af}gFf_Tai3VMkI*EZ0q9Z{`{Mx6VOTTHVXo2;}=SRga9SDsSm8 z7_vmzn)x#C)jPYhKp(Q>hc_rX;ALi6V#!Z|F;+5j%-y9J4XxAgBo`Y|xM?CrT-zep zM&>y(IY>@PS!li}0=FjJW`ttgJ-wWbq2dhU|NpN-m)j>PzJHvVA+Jk#d%NG7@V{+V z(c%+CJ-VKK4LFYs4^OskY@?AHl*+QCr-3d_9sc5bFwW@ap>Z;-(;M{J5X8UNb_NW0 z95k^}#P?cy@7|5`2}8fIyP2xPe=0KV@U~6*?9yZ9lMN8T1Oe$u&lASrK4cjZq9SRc zS%OjFJciswa%g9vYi@-zZYj%kxkB{N;^~+Vv_a3t$FCR`uk86)G~bt0%H}4lvY{JR zn-0^;n`6xw8jih03dTWCPo2GI_`hK}BQbThWLm0or2T;PHvzkHwJQylwj77t|Km!a z>&f5(oNDZ8CCp0X$crw*AUi+Ne#he%yS{xbM5!KWJ?62ui30HM>bT$SsGXZ7PQ0Lb zn_MGCoOTA99J37P_wy6Q>M7aZ>;t%KQ$%m?U+{qbl(k^Lf3 ze-W*ahf|`$69AnU;_+;DE&^)eqpL*H3B{OFNhEsU}v=hD{m^Yh`VNTeNcfDq}=T+v1CAym7|vYv_Yhv?CB zfo4ohPS&P(H!3o8j}tr#!3WD=>zzBq+{g5zN6#p?a6E_xP? zu@?d{POuHtSg6H&<7V4z{cqC>6gRji>^pw{`sJM~V(=*NnN2t!61XB9Z$1GgZ)!N>K4f0i#c^$be?vuJ#l74sJJKW~M1Z z6HWbS2!$?Z6M#i0mqFZD7Zr#KW66EjCc)~xK(O~<@z@VVG z+e&8^-4JdA1-J04We`mQ`;3W1;rrQHNOea2k0G0I{%Y)Q)4WaxtP&Lw9Obpl0~=qp zO#O=Id5rLF2oWIDwlql?#xn*4HDQ3fb^rU~}_h{a@9Gnj)v3&t0YGV3skVljs&c zpk6T*@RzJJBzIKU@$CALuBIi_4yF_5W`MSV8(<)0gxo^yT?5}TH^b|V1cT&F*na2 z+8v*ezy(_@7z-d`Cj0{5KoupVq_D{_h2hbILQu-3)tbCp+sEq<*>nVeRq$s^aEDq zHsJ=1vkuS`7Ys$tew>~rJG2ae2>K2!OZ4DTo@=m8;N5sf@hOVH5|-hY^&Db_NeSnbe>beGU>LiwLH>KD5X0qZW`A`k%g=?P z5qA|IJpK{vDx<02A?x+rme&|uFz0IP2eZ1RH(akGk5L09PcSDKkY*tUIZ-oM*x|`o z``Mr?&PYE4>9GcSJ>^Sw8kwPyqf7RWz5fU5CQp z?BIRkbkyx7g4X{7*47UIJ$MQC1vr|JV{NviwvKfgoL$pmn$Mp~T9ED{wyXa9yidMR z0mcI6_GQo8P^~2kgfQ*Y#@1bm&~!uKqI|y zT_xS?$Nn}7%jba#mf;cT`0-XwIdQi~-;2AOa~B7+3*!#s+=mZaSN*YcLg>2e6~>4s zDu?>%fK4pRoREgRbVLpl6iWor_+Rh7#S#e$u{=EggRgR*KZOo1ULCn0OqQm2Mz2>9 zH6lO*tm3kYNqV}#r)Wq8Ygbr|=H>B{Z%3#i##9>u*J~+3ik#x|+D+Gl1|n{#b)S)g zV^seMF{g(HU!DAaVT8VvV1?PX2|8BdcP3EK;M2T!Ymlj14v_4ge(>;N z>4OGBG(1_vOe3YJq`W6$a@Lb8K(5|AHvnu{uwPQflO_LfghBNZ45xVwF6$_w0_=65z`{uG5@=4aFJ%| zR3QI7=kLB$EsI1zfxd`{=E3|CS%M3cJ+O+|Xvq9w5!5}7LbibfnT0e(jI zluYyRg*SJekBw!y#tL(S&4j0F&VDt(;J75L*MMu1cPN1s{fx&#Um4n}k9k%zc2X z3LuB!hwEfEHqS9NIGcv%VOnl)&35PP4<$;73QvhLJ-f0sDMIWI1{d%gkWpEmzXx5> zQ>x1N>)&Nizx&Hu72(<&g1o(Fglgz#a-kdqQu zU;tn;IynsZr1@R{;6`&r6JdSK~fQpCmQq% z9}%QwU`hB`h{#Xf zc>Nxw$-sHP+#ox90t8 za&kCZPL`8~P@k-*yZ~Iefux$mYPnSPNNhzU8q(_dX53cmz5m(<1*>rMR7Vj+I{%ov z3xf_Ei23xMIaf3xZ1-;R9q#Rsxi2YR)N#8kEAX|F3E!Xw=`C1;QU5H@VLXbCjRmA> zo8DZ54xL4`364_#FVJ&v@$pGy5Z%?7DApo~q#Z^CY=7O!Z08;j0{>Dnmz)T1tsSb6 zumkBB{3hJfZyOH90fbnPiuVIdZIlMU96ROmE?*WMyhA6jZ#)=VM4-l{kSwTxpAr zRCqlNA+v(QI+LtoVqy*aTqv>1|A(U0X7NT-h}1EvW8+JZ+N|KyVjlF@C9V`+!@7c% zhz_l<8G9T9ks~rA>C*bN#)+eB^T*Ze?(|Yfy5et-kusIkgKn#){jGqHqacFx z6Q4`XOMV@3xg-d=BP+{hOyyA^GD;_~tfH7i%;_0G#1in7Eh@Y{&@zwO@?pk1L`wY1 z$&#qX@3JCLh~xf&n{v4J($6wr0-9WKEr<4>TQO(Q<9sQ{9#VsU}1~- zPA8bSTk!(~+3;v6A)xqW?ems@s155jEcC8*yh*@4fB82&6gi{WBck%tQm)HucxT}^ zM<~wZ85o_5=~!s$i4o+SGMdgYzFUMB5VE7sz5}Vv5sP?bd{zVCD$?P#*@uS?0H=oa+KfXjbgdrwyr95+9ca%P5rcp5Kr|)lvJo?~UX71;^L;|LL?i`m?}Ur4 zk#p*{HS_pbqn*6;@BS;O%3eHO;8E-SvjNX%h#D=9m{p=O<>xKXkO=J4B(;5CiR>D2 zt!Lohq}jvqiT-~DYv4wgDj71*hCfjMRNBAw)yNwd`%QDAY!sAF}lCf8kIbON#VD9FgV!I+}v?`;R-^P z(EcBt?oANbB?Ewn)%mhGOc#OQb8Z2!y(#7;*#E1xiIe6%BN^4mhZ zf!_Ob!HTCty0gD$oj)V}y+dlmys(O717Kzbk1d=yL15ODywR8;lZk4xV{@YeHAB(& zsW+6m@)xl6*zeGxBFpf!aO31P7WCRh%>wh+{ve}7{$bNPJ8?PObDRjIuQcG7-u(4J z{UhhrH4(15)(EYFmA=W4$G5tmBmBkZtaICjEi?;?3!kgpPdXo|oc_$|EX_pLA+D<0 zh5_R5_jvbv^({wP=Mt9Fpj(d3X60Ic`=Csecsr8EX7r)69f(3LbJpZkZ|ci756`?k zAB{fdZyo!W()7O`v;PQQ%K3ZZ*;y{Gr#5}Pgp=ZeLDv|@9OHR zdcYiGj5+b1r0yw3(P_6uLc_kHMP7_ZM2iMi!`sN3&Wfj!(O4;ZI$JDrf8yFZsqaAya;sUif z+ZmFl1z!G`z0hh^Xi>9O3onKL>YT-zkI& z0!Eni6s{;iIqht|2P!j z9Njs$Yg@6Tie0SN&cPKwehrKDZ-= zjP98mm2aD|`h0;HZ~_JksI(9QCf$79fu14|Hk0-(GQu=9HGB1NAWjjbfXaKb_arI* zI6P}%s@2fFl?HH%FEj3T>sVXO4>PuVyc9VjmATBG#(2ZGF)-|2Ee6ev=)Yjh#}}}n zfa>iGYIv*Zwurh^eVBL%p?I@k&4YVt2$=T6hX{mcsNH~nW=gC`Sd#b{>{QzCU#G1u zvRr+qO)tpg0t!Oc;c7uGYV?7Zt0aLK^&$O0ThY)dkO*#2xKZRN+rKy*ttLpRW5a3k ziS4(uO8Nn?7^bQE*L>07On)uO?&kxG9@_UF}4orSy>3e$Y zu1>(575(JPUQ$xhO6~A7nLNfNm|*X;wB&POc~?Xi6AzEr=j5Qb=Qxy^1`X?U7{H%2 zDR;1QUz6+BF7s5mF1?y&h7*8DraUJosm3?rq+JsI?ygfBV3INJ&Gs;g@3(Q^5f3qD z_idcSqS@l;1l4T)1hp?jP{40Uj7?+`G#Q|$)GE|KKkQ86i>jc90ytrLi~0f%>39s8 z|KMYL(W`ruJ}ka6QSu=dnCwL>QPpjdcVWjag^>5e9Qxt|_5Tw-1-XA)!Zn9D@b zon3lpV^hTdELl^<&{E`Bk5%3u9_|$tnI!68|NDg6C*Xu?cU-)7#q~*bZ*S8>Nd0`< zuk~2EhqRW}*GprAg4*7@Iy8%)VvcFt55M`?=5b~cBa%*`mQG|biK+(vNPoDiv3nDF zChlz&rGw_f7@aU!WZzZbua;5s@$7|iq5R4=R+iHOe1L0)R zZ+EcuiENsgG?w;4vvM6-=h#b^B_-*kW!nCP(H zzV|<)UzMy1hYXzuxkK^nd9_-fjT`BVC1NAy^4+}}1&2}+VDvhzaA+5Py51XPwK@@ zyOE6k8Ltn>f_W)p(@*~&WA7c$b>IFE8xbEAvdK(VgGdr(laW0VA|sSSk}Z2=k5DNh zTTv8RMr4%CG8$$fDw2@ue!lg+zTe;dyMOoNzOR3-^KoA1)ye1cdL6Ihc&>xPB}Mz% z7iB>N7U6=-?)qR17`WxQ1;tQx@ZVp-VniGpYv^&#PUZ`o zPq)5}#y3aEx1OoFq7+ymKLixEI{%jr?9Y0psT>sa2er4^)%UGf0L$5nQqmp@k{Ar% zpoKNO1{Ib8eb^v6KT`yg?cne{}#gyWb*R}22P$!_;?D)bdiOhf!>CjDIUh|v<_&l zjKdGXw2C1dExHD;`>AJiHU_cikLu0fa#(nBi|h%EsC(R@6m-~}Zb8~c*CZt>>b$l*FBpn{cqowk2X&$|ETTq- zea&tT>tFri(fzZjq^Un*aGMWKRPR`kpq3{Cq@rp8Se^LzHJ4M#!M$glLW>!@HOTN?ZVw|00c_{M7z6BXOAb2=WifbO$kCcSXl}azu~SKePO=SePT*fP#ld5LuRY zi@ly_rqz2wD_AApH}EIla3_cDBGZ1jJ&sQeIL}5luCuQmu@wS#8w8a(lG=M{Rg=3m zc}{aBrL={pn7(w@ET~#K8B-0o)Of4iKg!Nk5`cEWd7txvHf{Bv1S=^N)N1N*i6%Cs zzE|0?0pj;fF$%5w0+2vx)eW5S5Cr@4sCp!GOLJ3$%7b~y>^lJB8NIY)DkwZ3Cv#Z% z$WMBhs*4(;|H&nFa0BzHd&lPH%7@;G%gbA?Sh`wc-(&gEOP2Ki2r%zZ>9@Zf^Txy7 zWe}EJp&{63U?n{5=UbBXb{=}+SR&MUnKspkKqF>dWJ6~a4L0jj}ceqr>t}z@9 zJ$B&u`uU9=ZV9oNuEYj_zL@-hZdnP5&oDlpLBP&NzJQA&!Gu(B?N|Y=V}6_nA8pU{ z_AfdP4%-&KjWyG~eU2x-w|uwh80LON7gO?buYJQtfhTJVIvYB(q&LP>j|D@q-u^&o z*U`HhM$z+PH`_)_0j^7V)~N^vMpFDx`LTU{!>F*^e6u#*-c@z6rVDwa$xh%>5K@8U z;WtnU%CMu?y4g(ZMx0@o7TW8O5`F>*gmOBbghizPH1$tY{j3Xd4ky+ckT?%`?{K9& z+}-7f60M{}rjq1&kzVnJ^8+Bm25crmM#i1vbjac=zY>u#(JWFU>UuRiUAv2AJR?+R zBtzv;unFA^Nw3tWzaGsWG>Js8qYV3UBA1qqPHNnDv9@+ez`%1n`|STK-vcRoRS6-< zXZhi;I#%O83bWhPF^*%-)pp5r{+-TFbUFTCu(w9ue{9rCrbTm6D+U)s@GztbyUD-O_WI@0tGLV0ctEj&nUN+~-&gR( z7t3bDqy6H}ckbeYFMVoTqVWGzXHB5!Ne-x}suFpinV}AWVo@R6j?x@Mf{#U*OsMM2 z0D2A!%?dL8Y{Um(DDS`JI?|rOL-*o`0|Oc+vsnht29grY=U~C8tW4P;enPoHGF>#um#?;1V*_F5Ov+T zvvgd%>!i#=Xu1`$#%=D&SLM5G71A?`=~YBq?*0wkfS4=;a~iOoxuLz!_RTx7_U#lD zeRGDXMhGo<5nuVpG#X~;eq^|8RV?iNdfKDGF5-SSK0e?vwqerBB*M@w1N^qS_=cx+ z?=%hXju0W~U1xsx=_hm^_qOBwJ<1_~+(j+&Lp*CH^QUntE`4(U`2`yQz9*E-So}I< zOS!>NO?`xGhhg%7LD@iFs79XQ7KZ!L+gq6TUM`Xnk9_-fg8h-9q3$!=2DXO-%*Rd$ zxUwW$NV;}Om{q*E@%7>Bhp)e0{r%|0fiIqNRg_cTkM4MV5YFD~S&(8WybAdFg8HqO zQQjaZ5+IqhdgPJIHPLX|X~?anLLJnt@6Mh#qGEV4o>O`|@^4>%R+p|f)d+>y+YYXL zXTwUugo&h;s&f*z={g6#_-fII^Fmq&hTpg5E2c=DtB*cOc%*H5b4f67Sj_x3&v_5e zkbq(`)p2FFoFA@^%$WJqpGLtxI}52{!8b^^jGlY0Eqhe44Q?J$o04~)-?W$n(XdHW zkuW;s#X<+CFZ_hy*1T2^z83*x0)ySZemxY1WeVBpgD_OzxcW2W)<4UbxxU zx>KyweZRwf4+8uxEsbYH|FaOG&)TPo9qg(1yLawl^yQ+hrQ7!IPkz1X%hK=NG=(Yf z){c|Q0D`g0)~C=XS2#AQS)fL|mn{35OUXK<)lMW*&?jop=W0f6$-GD*RhZlO zst0;@*j)f6&|1|sk8Fa5Z#iLtuqRyIypww+T*}^FUi_6&*MOn(9WSh`?oG(L&uWY9 z#V*hmZyj#E7dw4U{*}n>{@8YNhSq+5UFF{!Hf(537th?Y;a_Zbb4XKwjoD`Q@#WVX z*a*$GpB{T}zV?^0Gx+3lPl0WY=6^Scyr23C1BIt&BhnKOQ?&^OTIW>k{{x8D05La^ zE=5Ue7lM>6KtdG&xq@%Ozds+3-oAsyRz)nEN7QnEZ5ee^$voj+FOH%jQue# zIWpZ}kKF!9RX{IRUv_#|rYB8df8i78$YWV08mAt*mXoQ<%^LGy56!0M_??)p$Zw!7 zn7$ThI2dPUR?&_z1Qbmk9gDBtXA75vBvIMHy7aC0U1H z4_SR(MCSi(gnSHumJNf6ayMf`O~WK)!U^AST6=WgLgn+*1(Ngv93hBonyT4kBlg}G zDKGN@+9_dLVq)Cz{Q2|4Srw|}FxqI1hEQ+MIC!_j&FU0zkX;a>!#|~N#8JZ(#qgfqn4d6bADj>|EKZ3Gq z*R%=CP|Sn^0+@T-f<oXJhLAXRK;IPEH?@)6jL}5k&3iLOf4t^(u{F zuExBq$(qZn6&T?F>xZb&^6KhXC$=~$t%{~82(3DBKaOX5+gejdZ06(M^0W9_*&DI? zd_m*v#FiiJdLO?=ymdcDdnuqjkuWGAsbZ})jfN0Yj1}w3pq#UDD$D5kjfi4JC`Wqehu8fF-zki-kJC&R zo4gIYykwez=+n>EK&dxqaIx+1O$bq*4L-cEJ8%{eL0~?nEi^~nG$bS}{+KzRmB}^0 z88N1$9qyGkyOOU^=pPMr$ix;YI1(^a1Wa`aB$tw1#TF6Qk7p6a7-U37HGs~DsX^55 z08sW+S!*q6Vxzs*Blwr_^D7_3P+}hIq-tUB-_st8Ir9OE^)Rd19hHS@Ffa+F3!PwBdN51C}vqMQupQD6Y{yXoo zg9D-^DSu{MSpX3g{<3;7yr64ge!d}Iqf;vR)wAw5#U(-$No?c$5Ged2s~5{vIaAN* zS3yMH7BOj{lphlYB=@{GYlw+=ZaItAa7ygkmcNiUTDVO$^zl&m9rwaVD5t?BZdRtH zV$rKq)sNP#1`6N!$h*1-_ZLI^+j@`_?k|oDuQ9`UyaxzgT6ixo_;BZqL;43yw4Ft) z>Uz(UBp3ZzG_w=UPCowN_qiOj-qA_pAf5t&LwkfN2&}h83|og3w4tM00kY)vd0D%V zO#0nB4d<=$yymM00$AR;h`re)xBYtOO?FnLb6lhUJT+8IcJFuB-DLf^ad1F)=s<5Y zdm*)J)PQ^CWS{c{7TV8U9|#&FA>1VUq0;-O!I1T?rJLI*AN=t_ z%5lT>EXW}3Vkx6m9+mO#YMC#WQgarn!`ejnK)Lg>*RPaJ`Wb%uGn#OLdN8?Vb;Hxj zw)4*swI4^1tz^zNv@CBSLVo2g@z5VzIpaJM2;%Bf@b7CBak{h;RGI0i9j;_9O+7*#e^jYt2;_t9&K=KC&U@HwpiU=z@;^C{dHx}w!!OPl$p>vsUPcRLQ{lh;27`# zwLcd^6wn=wjX&ioN+7dY{~COdgrQa zGs62lfXKX^;K4}gJE~@zo0|nZEiJFO@b7%(jcikG^7ATz1$ClB5M;oj;&IaOe!rg6 zh1mh+OQVyteuOHhqlD4&RpJvroO+evhJ zy?N|xZ$W(P)|pAXTNa$EN`8teDi8nmB%OdT2=&5{Pa4V{4*zMk$5qDUPQP*;g>G;> zNs}-?a=T0k#N>_H8wxtPIHV7|jbL=Lgc zxa5tD{-$QRCwn8UYCY9&k3p$z2htO|GTLT_DgqG%POzw^4rTcmBFGvlB z#m|4jCnZS}7aLn*R?by!es=O>=``kZhQ}I`>~&rjmoHICO*3OtODV_1t$m zCMGOkFab=chdMxA(1$tlu!O{EiTdrjnT*WLH-or2IS*TMmJW5^q0miBAg$n>Lf%gZ z4t}$5T8upUgWmS{3T6D|IIl!s%D*0Ee=Y5Cd11#vd-Mc^))`%yW$@>IR7~u2`!8V$Mo%q@`4^O#vX>xctFXZe%@Ba%@j3mrlISIj%TVh+8>46)(jC>q0WdgGum<1vd2Dl$<1QUW$#q`O|=@77m*Udld1j#)zW(Ki#k1>qGYN4PAOvVIvIy?@=tEVU&F2@r}DBg4dyeh;!|G)k%gd-aqgxPVCK-TpQYjH^|;EXYCQ$;@Af z+%m5;Vd)@_JY+&@j$`&vz(IE4k)>6XQ8?13O*Bm6LPC@;!(`n}Ds#zH86cK!ZN5ws zK0b_Z#-iVwoW)kyNI)JcZ5E(koBQ3@$AXF*tP*A;Egn5e#sScH;n=AkM^y(sxU#y6 z+(qziT@2197g6?Ky?YmkIcJZWczqWypz+T$GqGp#!Iz*jU>_QC0rmBq^|^2I0)j$x zpQ_wVV_>yPK!-bKlXv)J?)gW{(e(ks2~T#x^7%k==p^2diAy;c*&B|2OP3$Li)ERM z9AND=NzUTLj^5WK$=sa`M4qI4CmtYsuSijL?T|GYm!1iX2`a-z_u&mGY71T)=PUB| zbLo{~w2rz#%_Y)<*uI-obZ`ys!6K^sqj?(fM0@-fgdyWle4Mi=oxIFCOOqzd>Qw;% z`AwAT;F-a@w;u6KHF z&tG3_0-+cLNEiL2V{z}+n75s8scQg=o!xc8F&pkU9IqRRCoW-NgGA#XB$3lOO|x(A z@W~5ax&A=@z>X{ws&>V%ghOEGrtiM2A4fyK>=PF!QC8pt**?3}&Ezt6i(6Def=(6g znmceBVjVYR({a>?XNLjIK0_~Fxgb>xdhitzK=@o0|Gb65I)cPHVKxGlAI9OAn9<7u z_R%1x=^XI$`A5i3=iL8HD)LzlvE*e%voqV1)%LEJXO8HO^(W7+*HH9SOS|-~ghO-d zL(JXQORgse$zF-|vS!R3Z{j$V@p&W5##%bnzws_+bS=gVfko#dGEW5WB=ldmLV9w@ z?rm9r7q`oJP~OC7!7xwvh&oeL{%UtS$!tG#H9L+67DdLpY)x^T;x8Rs^3p$Yq!Sac zqN3uoh+HOu+yZrw$6wVM|KP#Cz-0akB;JwaN#ne$X|+eMyw z-WBsP@|=I#WtBd6xD;>3ezC?)F$`1#=!86STCaB4Bsu}X*YD)r znWG@g7?jp>e~7Q@{j%kOD~tF#pm-^#d&OS!4DOw%GvSFxrU8poF`C;|NPEnDHc$%x zEQrj4ket#MFxQx+B$e!k6q#-dhX zqu|53x{^{3j1}yxrjq9<8OUBX)nrnLAK&%C`H<`aZ7Q)__Ah(7n83g1M+zoK0S=?% z{gOYfV1-%Cs1x~h(E0X{IXfp9Ui^7ni5HD?D&@QV{fCu-UW%ZC%9NG_M2oM_KXMB~LMCo8aH)1CuCRry=ui zsT1FhnDy+j%y@AX9xDNHY`8MMaK{+KN12viWCpqEoaIE0ak+8fCO`Av>IFdaxJ-q@b5&4=NW|srRPEK{@?se_s*yEtJ zt}~ws{_~xWo{fq8axgx9MB>DgB)=gIp@&-scEE2-OJ5)lMJn*0`NUwt>F4c_bz0Op zkWg}@lic3fqv>9A=*m%+gUK~t?Y+-ZS2y?#7z)|(+x@UJ;(G|?DmDvSM_XuaI2wsq)we){d#E;F;cb>{1dpk*aosPfX5@_Z_!ret1(+axR1M!@7paJwEb09~s84Hyj}rS=rSdtb!if{yDb& zEaoOmqDMlGBR-Z`lN~o_NnYy zA`4-v+a7pIV+CElA$AS7r@>A(G7`4=Ab)OpS4$51|Hby|y3O|B%t4$?`=DcPZ9^jg zU7+PHZPp%y1#-)hmv&AR;)3xu|+xPDy;6ycdGS4(_!-M z=4aqJ+Lpp>X@_leE+R)Qnk6-lqGi^N8Cjpu*43BVNj%GS#LnVGmJ0F#=TmhucD3c}vf4`8_3e$D|BIg`?$V`) zB|9x+q{o)QOy{(zr~$ zU#va|j)}eQknuw2wjdN#4c))PVU6C&4JVO8BQZ9@vS4n8r4L!LzOah}Q*&Ug*52-> zq0xe&7;v*jhfas(>W??a?Orw%rJYj1xXx6F4SuOs8z=Fy6iM~1VVGaBhEgpv1%ctW z;!!aPj18T}o8X2tJ>UQXLvhR*_idA)ZNa4zEq(c9D{*X~Wfxr6vcF9uv{soJ;kd(0 zHOtvj!zZ8d#OFSZd3fm5);qzQ{XvVtoSDuCjS36{na6NAEi>p2rreg$ry2mVELPAZ z+g9f@KZa2V!QDuZUPhA>`)RL*%2lrY&;b}3F*kN|6X8*i7Hn%t@u-JF{XbI zD$1m!F0B#Q?2f$m9ULmBtl;(7#MX;R3SvH6?}odC@12&`P(z+JQ6>DFdCKM@OaLy26+| zuy)GaW2aI(n#6D|xzAqmyq&=6@-qJe$wM~|i9ljK&cE(a5Zm-U(&JUVq;4|AoAgY=d!H-7$}HK;PV`1^Cl*+)+}axO`u1;f|Xo(N`Bn92e^oQ4z`%gGX$jb$aWC9s)w9IPZDRd9r|gEKPXc@q zCC_!D87(MQX5>XWI5+^V?}T`agT)rN>z4gH`q;i3zkhxByM6K~I5=Xb0%-%j7e_)8 zE*$!g9)k2TQcPJpEZecqpA&-irEX0=S~uYm3=aEFz1BT*C(M4&E|c#w_(W56n3^(? z6jykwan|r6G3AF~)WZ%4ItGTog^8H1_cH>$2m$DO%wBF57@0-MJqMSNr>P_@y+o}~ zCcF*!T?6!m_UvKyW}Dq@xs$$S>yhlsmo<{%wo&?6cqNs{zkJP>y{TDw4ZjxMFBV&f zO*M)=6yWg0j5EWqxWNEr)sMe0A%zFMx%VF;mvuOKOfJm$kZ+gWYFP)2Vq)!fx&MO1f> zHeRaCx8Ew^+*)W($Ch0zi?Fc}tuG_Kj$W*R)NbI_B4^{|+z%@dw(kPH;}yd~0Q2~; zM5v2Y#gg`9op(Jl^X3j@yzW_BSjZ#uEA+{i5D{ZMf+2CTR1XJ9WlYjjkJT2+D=_v8 zUVm5LJY^J-mfrH_rb+~<>^Gocv7`SV7v<`1o~7S@t;^Qu>=S}k@HHHd+4^MfT;{G$ zz;_73+mDwGvRkyGe*XTc6tmDe8{Gr-LqJ%bPmq&lT5kCR3T2$Xh<6doB73_owP51| zH8pDaWgEAj^YbgS_g;lBZC}OR?&|H?&;sxR*@#OwU<&|fNV7Iwcq3d^xC`Emg-7Fg zSZRT?_bs@VJm{`8azSe~Z@JY&dmk?ioofAtuN3;n3q=3n#wu>26cg_0os7B+ ztA3~&UNi_F$`^!>gc6+ zMmQ!?=nm}$Is<`+z}9gxzK95l7q0y$GxrnQTyEKJh9~)bdwPpaz0jHi`fl0^q#`p0fDuTfK*g2}{rb;u3LB`1itJ2dgq^ zW7?(=FO21VjJa+DqYyvQu?*2I0thWN$fcM>kfzdYnF65mBuPeWuLu}>fC@wqZ&0sl zjpBkOJhMBvn|m|+dKDD=PZjjSUTpWz7B~`|TLEYWb84&_`4SfA(qELSZ{auoYaQYPM-fon#a!Qz z(+aXm{`ch~pGUe)&TX7bm+icyi6#d8(Rn(NV<9CzmF(ggU`TS>K0As|21{P=tjR&ff*-6Sk>fQ&Zl}@M?oo55 zykMy+q0g(}Lk3Iz24i$jx!2Z|#!xt3b4mgPFEPxElu3f+_{%5g3H@nL>g(u0=Nh}q zO7Y=u>`yMb#|2#KCVMY%51u$YIT5}!(T}bfFOxP$<9E7w=XG#~j+4`N!LEr1$>1d(_M+-5g%UDwGG}D+1-l;Qe|!hppw1HBUChX^hbo_olkiG(${CdLU9`OM%Ch;5IHL2iw(;v6NIM4Z?P4(ikl>< z2IFqVuC5}oj`sG@6%B94)2B}Z)dq?ZX5XiQi|BIa@LmyECusEb^wj0F&1*d!jUK_z zmWMqit__BUH*;Wfbcbk(!-wC$C?5OndNKv}?754ekD_2=7eP}RHBT8??~UuAiDR1{ z*+qQi#1sD!o7fDCa1gKuHL{q>U1>UrawH(c@Np`6ulbJHB$S)pfK+*w-DEXmMe>2p zgP(9MDoz+kqsxaFH5ilbgJ6L>}z`Hkkr4h zRBsUT_xC6E3odnp!rP&Bn82Kb)sI%*^IG2{xa>lhw~4rYL&L4|UW~7HS6)j_4!QGf zRu%U2M5`8#SK2>TsEFxQk}9*y#!-0^xab70urOQibwhPn@xLu1I(2T1qv)U3^tA~$IP1i?j zo4_CFa!bK@ltUhcgUmLRaIN4;5Ydbz|94%LaCk+?UU69AWS+$X%rSYwByN5Voo9Js zhCT`ziT_q(5ijNPhZ~ymU9q&aKjmYeLNMvay6tKGo=_KCd-Yp;NS5mOy6os1qy2$K zK|zOHifxXnlF#0wllc@pzYo8hww6{`)Dxw8*Swb6ldpI)Ph(IiOf0$u!j=-BZ_~~@ zoBRKXl%UVxXkkiA&!Wv8+>9S=` zsrnc2fXV_RU?q?r{O{BD7!l-%)`hg>zN3#`u1$7k)vNu4m+ z8>`k=Z^B13a-0jz4=^evBSZt{r+r^vpCBoGg!Aq_FYH{FLsrBCFX4z%ogIY!6(Ko3 zR?!T`3lk`8J&*QS|EO)P#Q=vs^GEKhPumV0;C^+A`%)O&b?6|@+quL^Npgq^FYU&| zsQTaE-@R_>(|QM9%bY3G)D2#HUis%#d}d}QjCn-@(oQeX$c3-@;I{!PCoCe;LH-wg zBIq)2v=q?6jiP~ip78s4JL)Vhz$<{Y-z4IS#3V&TPJ;4>6P%F9#l`f&FNHYC1^ia6 z^++ywh}L2uZvr?T^eUHw?qk2g7QVJNr{FPsoPS_eS^D}RaSXNAfIn#R>(@hQo$#lR znQNJC`fAvMGl?jx!&i9a*ai8A@Vk$XkI!!*ZPc;@EAJJz#nH*>X3*tb)_zdZXlbxziX}im)9mU6CbYHlf2PVifsM$6| z(DFK9<}rEDXOjPF38&_6;1#nx$y1}^ zqAbi+e(da#k~4&iJy{^1OjSZfJvX^ku=D~$btU9B!otE}v$$dmcw~+o-5kC9*zN`X z2kMP`RqiQ=Wt^2kc2c=>dE|?dBjiq&x+X5TxD%SJMAD%LG1b}eC=X_@>npUS0azYY zw2J#>!};I|GaIP_#&PILFvXfM5Yc_WW}F*RW@k@>vjYfU%mmX87ivf--OG@%+1W?- z&o}K=(a_Mqv2IJz9E04<@M$`j=LcGC;0%&$xK!#RGdlMI#Ln#QRs!EGeDGip;MvW{ zo_Os4psrya@;xj7O3KReg#d{2!<4e5{9foUZ2nt^!9hGS_QcBqkIYQ@ChhT$AIzUWU=osI>zN&gz>XQMMe4h z_#kQU${36R8-7GCCUfmMtWuel#$qzfefAOI?Y))$qpTso6E<@`U=)5hO z@fy>{B2unPW73xC8MUy}@9L^6iZtxH8%;OyDmX8`)CM}%N`Hm(w%ibzC0DiRkJ}B+ zL$&8bHlYFT1NII;3Q{%>kGczAVOH?c-k1!KZh9I2l3c3VZZ9P4?ZpacSIa8zt)0>L zWKIt-nueH#T-J|OG$nU3eF2;fxrbco!NmSMjUnqA7Mz{gvyzHlhnk8?@$ck^R+<%~i=*biwW|cu67a+&f7ET( zCU=@~W*p+R5Iqa<c!M>9 za{mV?RXO*I{|~SXq}#`RL&>^hSsfcB_#rBdM5MnU66E8=#Klc#?wY}2m|{B<9x*2JBEk!gq=xuH!5kH_SB!E95|3bGsuJ)Y@sAWcT( z*sA(8S2iUzwR+F*xh-f@c%ev;tfg9mN(63%@TJcDOP4MMY-AQmIrc0`E@pWDoB?U6QG72CJNLH2>r>mbAxe*W=h6x2*BNEM;REm?2 z8JUfGww^}RMg6;X*4D2t!K^I#&V9=dMh=eXe1pF=O8HL&@w4TV2~qL7+L&GxxTcLQ zb?@NSfI^YxbAV+xaOOVBt$DRKYTk7fP<`l*|PjwGh|WYDn79!ocT?Z0W{QZzGkBx_jM+X#?7#kf82(u#Y8(OP28eDl5ho+$66>IxQ~F9@yXXI8AJG%7t(m^vpaxxq=-!?srvCrLEs2kJA|FQ z8~TftiC*;4i;8UI!Z%6omR#?lSTMVl`BA^h{BvV#>}8T9kB}OlSO(r`;F;&Z^P|*) zkV4`fD+Tm;M7IcOusvLi;UAZ#(O0d_p(w6rlrWfK6CHy7|0#rX0_F^yzX+`nbQ^FG z$98mE#CC>=0|E&?eHM0G9%tk7z;!|rIH*9#;+)OJ?WudDZ7x2SyVwXhv zl`Gn$3aA|nd`_R<@px+;#!Y4gCOKl?<&o!rVnwnx$-zqhPbv%rdHPd{6B|5`q^!^0QA8$Pu2IT%<`4j7fPyO?NRP{xHU7#qbj-MaxF6{@ z@msPqf85N2S^H4+NwSJ1|t>Hf|m%%Z#5<`(p+50DZjQ9;To#&n`HN_ zUm!swfqUPPpmnG|mYaB1$7%jIG4T(Z7Dl^rvQu3-A-fEmcVA1U*nwP=9}5IAFO~t( zpujfBG|L~nPhqls+(CoJkP#*1@bueb+a3r~SvWXMpxh9iLddkBq)D_nSGDEenJc3g z6FNZT>;g?O#8~1uL4=A3y=V{1IY)$$Jev4Fow!J+j_1>_$yA}pWyEQ_?8$ioE;*zf zgFwQL5TFiorIHSGHoAgM%NWz$obuIviPu1cTWw6YkD--Le+MyhqTgbUy~*An0)4V@Bl@3nG|0?~xG#Gs!7v;IOwW*E zK?uF;Y`;?6eTRZho=YruV^nzf&-vnysYqonJ#W)>=c8Q1@+Mz`_Jz-ytsX6!mL( z0sjeB1*tM6OaF7Es#~3VzPkKMD!K3yL_(2pt23Z^ti-+E#U`t2I&wurQ!{vJ@FajF zwfk-FR`Fe;4ZtrI<1MFt#-%~>T5?+ShJ#~I7-K13cuPgO{QoLt2(q|iklTn$;x!8D zK3Dj;T@;~Hw&rL0euxV$4gRy;Xcqge`LSzEp9zSv7^|)K7mC`T-+tF51O!G`EbdF1 zLYvNoHz)bvV<}oJ5}VE!tB2!8__)P}b@m}MeWUUx5iS#ZY=qHS|+)j#wb00DAbKrYun+R*V0?7iim_NgV8H@DwG zd}|Eo8+FYtLZv`|lp zncVHV3-&0g)y2i7AY}2#N4$w*RDHB=DMh{lr zfBK|umhJA`%uF4YmFD_t(&dnCVOvS-_CnLm9s_JY?Vt^AC`!fiNu?3A4q}9~@5mL3 zS^Tw}9Ij~u{A}qgwgvsp{f%>lw!nat-L&8}Ld%%TI&CmoWYo96N6m@xpyxy@h;ot} zr!?vn%e9~gNa4RPEnR-&jQC2tcd$(j?sCGqxSjlkVMI6fHti7w{o~DUx^#UBPoAOg zSi=8*BJG%f@6v46wfXkl%jL6W-y;HA#`~&1RX!6xWHu^WZ`x!`{;sayrdj^F>y#>8 zh^9?Ol%~{w+mneB(L`?EjHo7-OksG_z62Fd{n0K{4(s6(1A|vvbIgZ z?ElG}e7npC(n6m9fnI79a|un#hz`eoyenUEa-U$hL@N5=)tA`^GS=VSJc%R($2fiz zuKZ^&n#_m22#??PlfDa+HDOXdU*7IN&*|b{F}LNOXDQqJVV4>19qxnQ^OHEA;I5+! zoL)xDRM9&*rlB!WOY$|E4~Qr-=vUn3wJN_bDRJL*e}VaH(yv$1joOu3-9+0Nf8FlX zQ02#t4?m-)6aN-0>`wl5e-y77@}#e&r=JI?fi*nZNMMWidQuDW zR4a=MN>FhWCp(B_6;jauu);h=0Fv1p5EP4-;_{(MyY6L8xDSAlcRF*)A-@0vqOlM< zTj^a}=DaxZ7BDipV~-C8K6<``JcUAz{TS5V6MGp=30zex{4$SmL&Q36`VGj65*09r zL&CyTzH%7Hpo~ab!3RD%4D1ZLV}>7>k5gru9-OyQ>gOy}7nFe|AlwpGJcL|t^$b1! z8`@@-&sr`W5ukkjOZzz}cnF#buQ}b)?vjYo9OqW%q4ZtXL^COLo!dK5m$93b@wszQ ztMto#Td^(!+#G-o^}`IYi<{&%CSU%3p@lF(q9OQq zI?#0_NC(RlMta&aO}=v>n+l9R(u1<0q9WJL3aHe>O-8c7B0RXKmFOR69-{T+?xZyeb5J~6f zZ|SuWsTpU?O|-o71ZjC~KLmVdh>z{F=LW{cAjGY36<)M(8ORR8>^25sOJ2-Nx@*4v zT-Tp1Td@xb@jRg3+EG`1&l&GJ$G1_Bgq~c}apsP|8pm$ZTebe1x#X?vTfH7_lio7b zAlcX(B|b373^<1g{r@m2gFehQu4lGN+|;W{*}r}OMX#Wyyl+#!Mdgg@=_)suk^Q{B zPgyp~@+z9WEU165b2SO*^)xmhogQ14dQ5s5(2d_Xn1Xj7=|MC0g0Hl!tazTRemeA* z7J1_z02QoViL~O_Atpv^e;;7gxCpxLsVrm@T+(d9d@PEz&@J$?LAiiD>|`4HuaI)* z84HI&({n4j?0SaJ+H$2KdE}y98>+i?q}JsfM?E2Hv>t)N3X^TWLmQRTq%$E{gGveg zs8k;;P`6S))?@!CdEH$x;{pdKrxQNFCiGBCHivezB6I5dp6@Bp5UD@0dCZ{>g@CK7BHW*y73+L>vKn zQQ%VOyp)F6E&Em0l)&5Su8&q{N}ZQ#lre#wij7QQ=VQu*nQ&86Q&XvFY2^FO*%z&- zX{{MML+|t*@B{KcRZwDnCxN9)1vO2O{#>>ZIW^o&RsWF=kAuU^wGyRT=ta7Q=M(`U z7OLxwu_;yewmTGr5L&X{BFwyma+uJ2byXz-?9{jdSxhDpF&3WMHBsjd?v0MTOE{I9 zGjvWCBRTR`@ZUeH20Mo*1h&CTK3O#jPdrRqQ=_BF>*d4c4MkSMh7~~2(%0Fe2Qdhz z+{x{$Su9et(tCTR=qC8UTx<3;mY6*9*1h$*rG^$&?&+YD6KzRWRV2_p^ z_lT5!Hox8p)=UgQlc&tL(q31bN{%m?P-swcz^|S^uyZ>V2ep)z!{A*<$$s}bAXK@* z8ROe(pH^>D=+;ZOqiSk*%8?=;6rZVNWn*e>;YL*y`wXj{eX1}d=5!zAn>=fi zk`<%CYP(dmfy;W7dHe*@-@E{30i-cos%0SMkX=PS@Enbe4||y6z!d7m9N^}$&P>+k z60&>qQpxv_;0W87^>LNYV5?w&b$ z^zr`fmGe$oPb%i?)I-F+{o=sHf#7$~9$q5eWt~ww^&O8UNS*S{8UMF$va z{oGOJzyGQvkV;s{h7E3aw2Lt#3g}3+^0C75<4><2?Ac~(M{Oa+1ywYz zeRuuvyZeN8G)XaR0<8mhm%{3769Z}RI(IE8+m5(D&Fh}Al(YPS)F&5#+l{s-$NDxI z{+C=i>r7BeaF=V*8^zf@?uPVuS(Uw}|jL3H@*$B->^|0R|jp?jK1BLdFsO=ZIV zTmUYM-Wst<`507*d;!th=-}G6Pp3RL6hgY!t@xHupfxkSLV|T4*j(8ra-Ek z&_cmd*fIfNb-5r|Qi*zO{$d=EyCeN;Tsouz-K;$za8{Tinu{U7qtH?Hek-ZqzJy_7 z_p$rBGkJyq6XB8kE!t+RwtK!q-?)aI=(?KqkXzS9-ROGVa~fy>7saVq?;n4lBE)l* zyn-p?#I=ymp))|7gs(sJN$Ry4N9SfBP2`Cbdx-USGgGrwBqwq9ZL`daw@a$xGzgF( zI~uUYGYUK{RH}e?Jl}_U{Ll=EExN1;LhIM1=9}ZS3*zj<>lc_}XH}i9%Xv=F^e9iZ zMm=`PjbqRc{V4E#M`byg@n^H0L%4Jayo#}0s)~6oZL81HBVHap<*5a(O3hrGP4A5w zot2D?xv_n5+6&zrV^`jvPvVb2Agx*Bkw3OYNTEt8SI_dQ*`2P)`+XuKN~RY%zna;f z=ltqt6^(&?rY{vbGz@~3JO^&R95HwPR_Eeh=US8O^3oN{o=TA-sT`Gegn8sHs4Ui) z*6VuCXT@`V3iapBoKSLjyJO)Ujs5lRBYjs{Y6XRFX$Spctakgn%E*$Mvd1lT1BKxP zX2B7oFRzzsGmaPM+%%A}Puy9xPd(}6B3UbCe~iHw_K8?F^6iK>6#o3Y>Wr!GS3kSo zQ-)U=NTFi@+cxUa=_~pU_t-NPYJ691nB0C!MMCJx1}^Hl-3~@|B3;f1ZxPOu(j9DG zSAS#(l3(ybI;m-}a8)<^o3#BXp@$9Otz_Q*?XSUqTbSohL+E4R0XzQ?MDnPup0nr*$OrDJkN@r03=vY zJRN09Lnv*wiwct}_;&LIx*bjX50l6+@KN4QhPMV!JwDrlM2$pXj=vYPtx1>?(^ z1?)~JHoI+EJZ@+`dH-FBXPw$7n>=Uv2PNsB^*c8e-PTFFiBEga9_M#;KOmvum!XQB z>1T2Jp~TT~efQ6@N(0~+H?wCUQ;>G<$^nKiNI|<0_r&q&e&DXA-&?jEP1nlQJ7@9o zBZox07uTkdx)G})hG`rANru=MojaY&G;Um*-q5fLKPHt>(7*A+ZEU61K3PJhDrIPq zN7j7*!jK%*#fJCzllxdmi6En7{irpBk83|$3oS537>vx$|IxlrokkOA*NM!E0eAb$ z{AMf9-f3S7m)b;@7zq^r%8_td0{@*ij)QFG)6$#eH^=@7rGL-A&y=rBF7TtvlbZ%1 zf7|F5iJ@9*A|ksBvR8BrPzztJvXaq-7F!?n5=co*EB^BNch)d*-~^uac6|{ZtP}+P z1|t(5AiIgEJ6&(EbYzsAzv>4yVA)8K2H;}wkBaZhBf|f|VS|y;@-?VjZ3DLxdmJ+c zk=3npBVd6xV!SqV88m^}2ZrX%w*LNVXhO6KL3nXQk}jnPQo?}1aldD?6vvNm-+Z9h zkaBpgj8vnDyiATR2rU1H6JuW)q%wM`pfP|+xHp1Na_zjgH>{YlUveeghGaO--g&&l zwd!$=uJGIZyt190N87EG`Lc-75Q$Kom{ZU!==S)S(A+lE(xPz1`g*Bp^d8l6E&ZC}tC-vpU?n+^j44kRW{6euG@gENU zAO~B0A&JO3RuIv%SAn&+T0g!Z*?`5?^<9ZN_|>g1tXW9qkI|^qTycmR5wg5;B`tP( zS5kx+*A)q_^7;2-5X7De{vdMTmY9E@-T~ov{zpLU?caIwgz01F+ckC`lw%1k>cwz| ziPh_VHM2gS_5Oz>d-tIMAH_`%_MZ`Upe$!+xPFam>Vx~PI#&+!YV2cP+P@HIoY&Cw zQSE)#euF5oOYD5zs)Bnubv{2Mm7i+dJZ<64U(-JIC5Z;&^6zh9oAPuuIAWktD_Xhj zX<+ow{qup*Ruh9&dL+Fc(eiQ8(Ml~z=S19!xvf{3z4o^79*~eI#bl)QQJ~Y2jO-%W zVKrqFM)pli1`a(YZNJoi)@3d-S@f63PFwFT<5P6Km%GCI?Ag260^zgAW@rsvmSfpS zH+3#DpPwCIQsm{0Xx*&6?VcC*V)v!=GhVZ6XZ%McbNng>mX9|WFhX4CMtz>4Rzf3B z$O@mvZajt9#5%vBrzu1reiXFzoEKDO-!XE^c4E@z;NuHMO#78ArJwczoiL!ip25(*=$E9h#Lup*XDZ8_X%zWFNO%geB;^BnUw>OQNY5)}R-ltq@ zn@pi$=*|^?fjpPthzg8djg9vAVN1dBO@}np132Bu8NF)He(g8cX2c)NnWeu!lI{Pp zuiSNVHI-<3j0(w`Xc~rxuTt~M-zjiWq@mOIeDd~QoeE)SH&y=pGXOG>R^CQKQoilX zvCE%QSkIV#uS2DYmOMgKnkn&iSFSJbE_`Ta-1MUtSrJw_Pphf}5MhjH3hYT)YvDfI z)i}fA+Yn0S%v~g!ANDqdSI1@$Z2LsWqk^Iv_4P`5P)CNz4!?I9k86YS?$+Cew_V#9er^G-~w^=Y(qQ6br_ zTeqj!e1hR)>Nz5ZUB>vtx=v(r?7A@17jtOMl7U-hT4e2D3vA-&lNo%0e2jEcl1$Cf*fMeu_y2MG{ph5m3THp4S6J z`p^sC6PrmbNj6hw{V%4HB6+pT2}cR7xfg zKKhw~%DjsARLmmf0H|Cp;EAEKr&rgwZSYFA^MuL8(a=U3feeWtVs{1+4E0&%sN2}( z+f5fG;;qS@Ww6eHkr89)L&5zdgHu@pY_ILdqGiTEK9nZfBMu=C<6Bg$Qs4Z)B zw{cSeAkU$`k(r5EQF*u4C^IDUdEavtQo~t%TlBPzL}ct2tJ3)1Dr+(B<4O<`6wJ@n z+1iTl%dYK#YkzEkMA<^zRhp&!!ZlzIGbc67b^gyI!Us$&Q$90=ZKe@iKk^vcJc)-CUDvEZnPgKqGwHL>as<6F6$^g|EESYk&uzSG<1p zDsg*Qzt}Om`P-M|AG`X;CSOdZFt+4#{aqK~zI-*PqTFBxDxu*TcTW$K_3olTjDb{9 z;9+kXB~B3K4!LAk_c&@3L}T^y(-=rWR^+x8yf=|BFQ2)RdfRjOjA=H7ZrvN*cO|k` z!7>MO>UKeIhh2}&Z)9)>;|l*m@}YW2rZX<{b(qWG_sQ%1tfVH{5>bk*uh>^tv9yyw za`hcd1slQlUwbK47aZT~j%tDzY^q3He`T{as|2Bd!YW$-w zKltwDxKR1{$im}a8Wx*M!H`v=-Tb;tH-@zIg;%Q=ho+EJQOYZCI7WWphxi*4toO`Dv}e#5icxDNkJMV788)9%d^6Ig63 z?`0pGm^j4YZ$|lSt9aFx+J28;we_zQ@8sf2zM~GqgSl&nCb7(#wy9{ zM52?4)yFlEBmqMJ%ik1>EDsdF%8+F;1k}8$JRJw-@!*R@D8J4vgS0p718V3 z@wNVm{@W)TyNr#Lhg6=zmKU;fjd8q~W|CgSV_v2+b(i9He`oz%tK@9xyoe^*Kf|=O z`iNPkeBqkCzYn5x>(d?U=;>L6v!#V4t?&{Jp=9iqD^w+&W*@NkD;_7jXFwtYc$n<` zw%fT#v^hLu?_jt22|y|H7K8B9`mey=HwhU8Nh_iQt-&q*jIgoC$czhbDRnpB)>`&? z&8KIM2HH`S?^=)%8FA*xqs# zC5!z4RQ2P5=%#{k1eFK=3s+plp;e1a1E6A5vI+!lhYdbui{q!l;v2gHkxT|Y1 zM;Y&-$he&cxcL_`Z909BO!dFO#4=&Vo>C#|j=SRFj$jwQ%tw!c!78Fk>!g#IjFq_~ zn$b$K3}**3W(O?21yc@%r51V@x~kaIRNx)a;|xiMHXo4!VD?#ToF~e(9M^S9P zav`bWS(Q<%^h|AhpWOCt$;4J`(pNC?WZ!9!ASrWN_(65H0M;T5*iyNo+%>tuLLIwa z%R}n3=^4ef=dEtuNPbb*9?#E=HDc^^%vrv+PcLu7Y^Joq+#+qz76$Sj%bY%Y!a4y^ zUWLQlrpN^_cAyGVU-X|4lCb`z{GcC$54cRl2N8qmZ#9I^L*vZyED~zSuOA z>hd!8J79TKLUuAe@_!UM9HRfBXTsrgx(;^GM_^c``z3VWU6X$C-?h3Z-E`VfzFjzG z-rztCxii=87ORkqZ9g?mGcJDExK6qXxK6K>76L~&9I&LWGzwYiqkqM{8@#rSZZ%W1 z`DBAR9K2@jcKelDKllTqqB+S#wXAn%{rr&q(&sNhH*-bui@74s~H*ff^ZPAXaBDE9-1B3sRwzk1 z*%)TZRLdH$l0e-^Vc_HEr!7Ly{K>-gslR_CGZ*OZ;)SS5W0$Rfv@Exa6{4CM zKh4}NhyLxrZ(zx{>F&d&7_QaL27OnIrM60E-ny4|npY;bE0DhKpXh9mU!=-q6}Y_H z3M0NS-s~zzf0P1Y^$S!oX6+SLEFO5Wr6

tRp@>lK;;nZ1K_Z|)zzl9ES~BIen0 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�Sn4j)gG$ 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 Vue_tK{O$ek-l3zO{j254e*-xtv26eV literal 0 HcmV?d00001 diff --git a/fallback/etc/fallback.urm.puml b/fallback/etc/fallback.urm.puml index 151db1d973d9..82e07903b953 100644 --- a/fallback/etc/fallback.urm.puml +++ b/fallback/etc/fallback.urm.puml @@ -1,51 +1,65 @@ @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 + - 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 @@ -53,7 +67,7 @@ package com.iluwatar { - healthChecker : ScheduledExecutorService - monitor : ServiceMonitor - rateLimiter : RateLimiter - - closed : boolean + - state : ServiceState + FallbackService(primaryService : Service, fallbackService : Service, circuitBreaker : CircuitBreaker) + getData() : String - executeWithTimeout(task : Callable) : String @@ -61,52 +75,99 @@ package com.iluwatar { - updateFallbackCache(result : String) - startHealthChecker() + close() + + getMonitor() : ServiceMonitor + + getState() : ServiceState + - enum ServiceState { STARTING, RUNNING, DEGRADED, CLOSED } } class LocalCacheService { - - cache : Cache + - cache : Cache + - 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 { + - map : ConcurrentHashMap> + - expiryMs : long + + Cache(expiryMs : long) + + get(key : K) : V + + put(key : K, value : V) + + cleanup() + - record CacheEntry(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 + - lastFailureTime : AtomicReference + - lastResponseTime : AtomicReference - metrics : Queue + - fallbackWeight : double + - metricWindow : Duration + + ServiceMonitor() + + ServiceMonitor(fallbackWeight : double, metricWindow : Duration) + recordSuccess(responseTime : Duration) - + recordError() + recordFallback() - + getMetrics() : List - - 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 + + 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 \ No newline at end of file diff --git a/fallback/readme.md b/fallback/readme.md new file mode 100644 index 000000000000..b7d7a92fd673 --- /dev/null +++ b/fallback/readme.md @@ -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. diff --git a/fallback/src/main/java/com/iluwatar/App.java b/fallback/src/main/java/com/iluwatar/fallback/App.java similarity index 96% rename from fallback/src/main/java/com/iluwatar/App.java rename to fallback/src/main/java/com/iluwatar/fallback/App.java index de7d2c067996..75a08cd54700 100644 --- a/fallback/src/main/java/com/iluwatar/App.java +++ b/fallback/src/main/java/com/iluwatar/fallback/App.java @@ -1,4 +1,4 @@ -package com.iluwatar; +package com.iluwatar.fallback; import java.net.http.HttpClient; import java.time.Duration; diff --git a/fallback/src/main/java/com/iluwatar/CircuitBreaker.java b/fallback/src/main/java/com/iluwatar/fallback/CircuitBreaker.java similarity index 96% rename from fallback/src/main/java/com/iluwatar/CircuitBreaker.java rename to fallback/src/main/java/com/iluwatar/fallback/CircuitBreaker.java index a7a00cb8bfeb..df114d8f51be 100644 --- a/fallback/src/main/java/com/iluwatar/CircuitBreaker.java +++ b/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; /** * Interface defining the contract for a circuit breaker implementation. diff --git a/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java b/fallback/src/main/java/com/iluwatar/fallback/DefaultCircuitBreaker.java similarity index 87% rename from fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java rename to fallback/src/main/java/com/iluwatar/fallback/DefaultCircuitBreaker.java index 62d34acf6002..a8a857ffaca4 100644 --- a/fallback/src/main/java/com/iluwatar/DefaultCircuitBreaker.java +++ b/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; @@ -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,7 +160,9 @@ 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; @@ -152,15 +170,6 @@ public synchronized CircuitState getState() { }; } - /** - * 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. diff --git a/fallback/src/main/java/com/iluwatar/FallbackService.java b/fallback/src/main/java/com/iluwatar/fallback/FallbackService.java similarity index 99% rename from fallback/src/main/java/com/iluwatar/FallbackService.java rename to fallback/src/main/java/com/iluwatar/fallback/FallbackService.java index 4b573ffdba0e..e4a1b847aee0 100644 --- a/fallback/src/main/java/com/iluwatar/FallbackService.java +++ b/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 java.time.Duration; import java.time.Instant; diff --git a/fallback/src/main/java/com/iluwatar/LocalCacheService.java b/fallback/src/main/java/com/iluwatar/fallback/LocalCacheService.java similarity index 96% rename from fallback/src/main/java/com/iluwatar/LocalCacheService.java rename to fallback/src/main/java/com/iluwatar/fallback/LocalCacheService.java index 9eeb6b7a8c8b..8a1af9b10269 100644 --- a/fallback/src/main/java/com/iluwatar/LocalCacheService.java +++ b/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 ch.qos.logback.classic.Logger; import java.time.Duration; diff --git a/fallback/src/main/java/com/iluwatar/RemoteService.java b/fallback/src/main/java/com/iluwatar/fallback/RemoteService.java similarity index 96% rename from fallback/src/main/java/com/iluwatar/RemoteService.java rename to fallback/src/main/java/com/iluwatar/fallback/RemoteService.java index 43dc6eebe7e8..1902b6c629dd 100644 --- a/fallback/src/main/java/com/iluwatar/RemoteService.java +++ b/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; import java.net.URI; import java.net.http.HttpClient; diff --git a/fallback/src/main/java/com/iluwatar/Service.java b/fallback/src/main/java/com/iluwatar/fallback/Service.java similarity index 98% rename from fallback/src/main/java/com/iluwatar/Service.java rename to fallback/src/main/java/com/iluwatar/fallback/Service.java index 994045fc3480..2c5cbba22c8b 100644 --- a/fallback/src/main/java/com/iluwatar/Service.java +++ b/fallback/src/main/java/com/iluwatar/fallback/Service.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. diff --git a/fallback/src/main/java/com/iluwatar/ServiceException.java b/fallback/src/main/java/com/iluwatar/fallback/ServiceException.java similarity index 93% rename from fallback/src/main/java/com/iluwatar/ServiceException.java rename to fallback/src/main/java/com/iluwatar/fallback/ServiceException.java index 51611f72e9b9..dcc4638dae80 100644 --- a/fallback/src/main/java/com/iluwatar/ServiceException.java +++ b/fallback/src/main/java/com/iluwatar/fallback/ServiceException.java @@ -1,4 +1,4 @@ -package com.iluwatar; +package com.iluwatar.fallback; import java.io.Serial; diff --git a/fallback/src/main/java/com/iluwatar/ServiceMonitor.java b/fallback/src/main/java/com/iluwatar/fallback/ServiceMonitor.java similarity index 96% rename from fallback/src/main/java/com/iluwatar/ServiceMonitor.java rename to fallback/src/main/java/com/iluwatar/fallback/ServiceMonitor.java index 53e04f7b01af..82e67d91dd22 100644 --- a/fallback/src/main/java/com/iluwatar/ServiceMonitor.java +++ b/fallback/src/main/java/com/iluwatar/fallback/ServiceMonitor.java @@ -1,4 +1,4 @@ -package com.iluwatar; +package com.iluwatar.fallback; import java.time.Duration; import java.time.Instant; diff --git a/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java b/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java deleted file mode 100644 index b38cfc42e166..000000000000 --- a/fallback/src/test/java/com/iluwatar/DefaultCircuitBreakerTest.java +++ /dev/null @@ -1,140 +0,0 @@ -package com.iluwatar; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Nested; -import static org.junit.jupiter.api.Assertions.*; - -/** - * Unit tests for {@link DefaultCircuitBreaker}. - * Tests state transitions and behaviors of the circuit breaker pattern implementation. - */ -class DefaultCircuitBreakerTest { - private DefaultCircuitBreaker circuitBreaker; - - private static final int FAILURE_THRESHOLD = 3; - private static final long RESET_TIMEOUT_MS = 5000; - private static final long WAIT_BUFFER = 100; - - @BeforeEach - void setUp() { - circuitBreaker = new DefaultCircuitBreaker(FAILURE_THRESHOLD); - } - - @Nested - @DisplayName("State Transition Tests") - class StateTransitionTests { - @Test - @DisplayName("Should start in CLOSED state") - void initialStateShouldBeClosed() { - assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); - assertTrue(circuitBreaker.allowRequest()); - assertFalse(circuitBreaker.isOpen()); - } - - @Test - @DisplayName("Should transition to OPEN after threshold failures") - void shouldTransitionToOpenAfterFailures() { - // When - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - - // Then - assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); - assertFalse(circuitBreaker.allowRequest()); - assertTrue(circuitBreaker.isOpen()); - } - - @Test - @DisplayName("Should transition to HALF-OPEN after timeout") - void shouldTransitionToHalfOpenAfterTimeout() throws InterruptedException { - // Given - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - assertTrue(circuitBreaker.isOpen()); - - // When - Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); - - // Then - assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); - assertTrue(circuitBreaker.allowRequest()); - assertFalse(circuitBreaker.isOpen()); - } - } - - @Nested - @DisplayName("Behavior Tests") - class BehaviorTests { - @Test - @DisplayName("Success should reset failure count") - void successShouldResetFailureCount() { - // Given - circuitBreaker.recordFailure(); - circuitBreaker.recordFailure(); - - // When - circuitBreaker.recordSuccess(); - - // Then - assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); - assertTrue(circuitBreaker.allowRequest()); - - // Additional verification - circuitBreaker.recordFailure(); - assertFalse(circuitBreaker.isOpen()); - } - - @Test - @DisplayName("Reset should return to initial state") - void resetShouldReturnToInitialState() { - // Given - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - assertTrue(circuitBreaker.isOpen()); - - // When - circuitBreaker.reset(); - - // Then - assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); - assertTrue(circuitBreaker.allowRequest()); - assertFalse(circuitBreaker.isOpen()); - } - - @Test - @DisplayName("Should respect failure threshold boundary") - void shouldRespectFailureThresholdBoundary() { - // When/Then - for (int i = 0; i < FAILURE_THRESHOLD - 1; i++) { - circuitBreaker.recordFailure(); - assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); - assertFalse(circuitBreaker.isOpen()); - } - - circuitBreaker.recordFailure(); - assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); - assertTrue(circuitBreaker.isOpen()); - } - - @Test - @DisplayName("Should allow request in HALF-OPEN state") - void shouldAllowRequestInHalfOpenState() throws InterruptedException { - // Given - for (int i = 0; i < FAILURE_THRESHOLD; i++) { - circuitBreaker.recordFailure(); - } - - // When - Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); - - // Then - assertTrue(circuitBreaker.allowRequest()); - assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); - } - } -} diff --git a/fallback/src/test/java/com/iluwatar/fallback/DefaultCircuitBreakerTest.java b/fallback/src/test/java/com/iluwatar/fallback/DefaultCircuitBreakerTest.java new file mode 100644 index 000000000000..4097daeee4ab --- /dev/null +++ b/fallback/src/test/java/com/iluwatar/fallback/DefaultCircuitBreakerTest.java @@ -0,0 +1,290 @@ +package com.iluwatar.fallback; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Unit tests for {@link DefaultCircuitBreaker}. + * Tests state transitions and behaviors of the circuit breaker pattern implementation. + */ +class DefaultCircuitBreakerTest { + private DefaultCircuitBreaker circuitBreaker; + + private static final int FAILURE_THRESHOLD = 3; + private static final long RESET_TIMEOUT_MS = 5000; + private static final long WAIT_BUFFER = 100; + + @BeforeEach + void setUp() { + circuitBreaker = new DefaultCircuitBreaker(FAILURE_THRESHOLD); + } + + @Nested + @DisplayName("State Transition Tests") + class StateTransitionTests { + @Test + @DisplayName("Should start in CLOSED state") + void initialStateShouldBeClosed() { + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should transition to OPEN after threshold failures") + void shouldTransitionToOpenAfterFailures() { + // When + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + + // Then + assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); + assertFalse(circuitBreaker.allowRequest()); + assertTrue(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should transition to HALF-OPEN after timeout") + void shouldTransitionToHalfOpenAfterTimeout() throws InterruptedException { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + + // When + Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); + + // Then + assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + assertFalse(circuitBreaker.isOpen()); + } + } + + @Nested + @DisplayName("Behavior Tests") + class BehaviorTests { + @Test + @DisplayName("Success should reset failure count") + void successShouldResetFailureCount() { + // Given + circuitBreaker.recordFailure(); + circuitBreaker.recordFailure(); + + // When + circuitBreaker.recordSuccess(); + + // Then + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + + // Additional verification + circuitBreaker.recordFailure(); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Reset should return to initial state") + void resetShouldReturnToInitialState() { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + assertTrue(circuitBreaker.isOpen()); + + // When + circuitBreaker.reset(); + + // Then + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + assertFalse(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should respect failure threshold boundary") + void shouldRespectFailureThresholdBoundary() { + // When/Then + for (int i = 0; i < FAILURE_THRESHOLD - 1; i++) { + circuitBreaker.recordFailure(); + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertFalse(circuitBreaker.isOpen()); + } + + circuitBreaker.recordFailure(); + assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); + assertTrue(circuitBreaker.isOpen()); + } + + @Test + @DisplayName("Should allow request in HALF-OPEN state") + void shouldAllowRequestInHalfOpenState() throws InterruptedException { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + + // When + Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); + + // Then + assertTrue(circuitBreaker.allowRequest()); + assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); + } + } + + @Nested + @DisplayName("Recovery Tests") + class RecoveryTests { + @Test + @DisplayName("Should close circuit after sustained success in half-open state") + void shouldCloseAfterSustainedSuccess() throws InterruptedException { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); + assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); + + // When + Thread.sleep(30000); // Wait for MIN_HALF_OPEN_DURATION + circuitBreaker.recordSuccess(); + + // Then + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + assertTrue(circuitBreaker.allowRequest()); + } + + @Test + @DisplayName("Should remain half-open if success duration not met") + void shouldRemainHalfOpenBeforeSuccessDuration() throws InterruptedException { + // Given + for (int i = 0; i < FAILURE_THRESHOLD; i++) { + circuitBreaker.recordFailure(); + } + Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); + + // When + circuitBreaker.recordSuccess(); // Success before MIN_HALF_OPEN_DURATION + + // Then + assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); + } + } + + @Nested + @DisplayName("Edge Case Tests") + class EdgeCaseTests { + @Test + @DisplayName("Should handle rapid state transitions") + void shouldHandleRapidStateTransitions() throws InterruptedException { + // Multiple rapid transitions + for (int i = 0; i < 3; i++) { + // To OPEN + for (int j = 0; j < FAILURE_THRESHOLD; j++) { + circuitBreaker.recordFailure(); + } + assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); + + // To HALF_OPEN + Thread.sleep(RESET_TIMEOUT_MS + WAIT_BUFFER); + assertTrue(circuitBreaker.allowRequest()); + assertEquals(CircuitBreaker.CircuitState.HALF_OPEN, circuitBreaker.getState()); + + // Back to CLOSED + circuitBreaker.reset(); + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + } + } + + @Test + @DisplayName("Should handle boundary conditions for failure threshold") + void shouldHandleFailureThresholdBoundaries() { + // Given/When + for (int i = 0; i < FAILURE_THRESHOLD - 1; i++) { + circuitBreaker.recordFailure(); + // Then - Should still be closed + assertEquals(CircuitBreaker.CircuitState.CLOSED, circuitBreaker.getState()); + } + + // One more failure - Should open + circuitBreaker.recordFailure(); + assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); + + // Additional failures should keep it open + circuitBreaker.recordFailure(); + assertEquals(CircuitBreaker.CircuitState.OPEN, circuitBreaker.getState()); + } + } + + @Nested + @DisplayName("Concurrency Tests") + class ConcurrencyTests { + private static final int THREAD_COUNT = 10; + private static final int OPERATIONS_PER_THREAD = 1000; + + @Test + @DisplayName("Should handle concurrent state transitions safely") + void shouldHandleConcurrentTransitions() throws InterruptedException { + CountDownLatch startLatch = new CountDownLatch(1); + CountDownLatch endLatch = new CountDownLatch(THREAD_COUNT); + AtomicInteger errors = new AtomicInteger(0); + + // Create threads that will perform operations concurrently + List threads = new ArrayList<>(); + for (int i = 0; i < THREAD_COUNT; i++) { + Thread t = new Thread(() -> { + try { + startLatch.await(); // Wait for start signal + for (int j = 0; j < OPERATIONS_PER_THREAD; j++) { + try { + if (j % 2 == 0) { + circuitBreaker.recordFailure(); + } else { + circuitBreaker.recordSuccess(); + } + circuitBreaker.allowRequest(); + circuitBreaker.getState(); + } catch (Exception e) { + errors.incrementAndGet(); + } + } + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } finally { + endLatch.countDown(); + } + }); + threads.add(t); + t.start(); + } + + // Start all threads simultaneously + startLatch.countDown(); + + // Wait for all threads to complete + assertTrue(endLatch.await(30, TimeUnit.SECONDS), + "Concurrent operations should complete within timeout"); + assertEquals(0, errors.get(), "Should handle concurrent operations without errors"); + + // Verify circuit breaker is in a valid state + CircuitBreaker.CircuitState finalState = circuitBreaker.getState(); + assertTrue(EnumSet.allOf(CircuitBreaker.CircuitState.class).contains(finalState), + "Circuit breaker should be in a valid state"); + } + } +} diff --git a/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java b/fallback/src/test/java/com/iluwatar/fallback/FallbackServiceTest.java similarity index 97% rename from fallback/src/test/java/com/iluwatar/FallbackServiceTest.java rename to fallback/src/test/java/com/iluwatar/fallback/FallbackServiceTest.java index c0721f3e554d..74694f298574 100644 --- a/fallback/src/test/java/com/iluwatar/FallbackServiceTest.java +++ b/fallback/src/test/java/com/iluwatar/fallback/FallbackServiceTest.java @@ -1,4 +1,4 @@ -package com.iluwatar; +package com.iluwatar.fallback; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -7,6 +7,7 @@ import org.mockito.Mock; import org.mockito.MockitoAnnotations; + import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; import static org.junit.jupiter.api.Assertions.*; diff --git a/fallback/src/test/java/com/iluwatar/IntegrationTest.java b/fallback/src/test/java/com/iluwatar/fallback/IntegrationTest.java similarity index 97% rename from fallback/src/test/java/com/iluwatar/IntegrationTest.java rename to fallback/src/test/java/com/iluwatar/fallback/IntegrationTest.java index 8458b460b05e..f14da687bc63 100644 --- a/fallback/src/test/java/com/iluwatar/IntegrationTest.java +++ b/fallback/src/test/java/com/iluwatar/fallback/IntegrationTest.java @@ -1,7 +1,8 @@ -package com.iluwatar; +package com.iluwatar.fallback; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; + import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; diff --git a/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java b/fallback/src/test/java/com/iluwatar/fallback/ServiceMonitorTest.java similarity index 96% rename from fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java rename to fallback/src/test/java/com/iluwatar/fallback/ServiceMonitorTest.java index 3d6ef5e0a9da..17a8a9514c4b 100644 --- a/fallback/src/test/java/com/iluwatar/ServiceMonitorTest.java +++ b/fallback/src/test/java/com/iluwatar/fallback/ServiceMonitorTest.java @@ -1,7 +1,9 @@ -package com.iluwatar; +package com.iluwatar.fallback; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; + + import java.time.Duration; import java.time.Instant; import java.util.concurrent.CountDownLatch; From a1a7fbc66dd27d32e0fa940e9054980e2277ac74 Mon Sep 17 00:00:00 2001 From: Ahmed Abdelraheem Date: Wed, 11 Dec 2024 01:00:30 +0200 Subject: [PATCH 4/4] all done --- fallback/readme.md | 34 ---------------------------------- 1 file changed, 34 deletions(-) delete mode 100644 fallback/readme.md diff --git a/fallback/readme.md b/fallback/readme.md deleted file mode 100644 index b7d7a92fd673..000000000000 --- a/fallback/readme.md +++ /dev/null @@ -1,34 +0,0 @@ -# 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.