ALT service configuration and run script.

sava-software · Sep 26, 2024 · 1b453d1 · 1b453d1
1 parent 4d7f7c2
commit 1b453d1
Show file tree

Hide file tree

Showing 24 changed files with 233 additions and 239 deletions.
diff --git a/core/src/main/java/module-info.java b/core/src/main/java/module-info.java
@@ -1,17 +1,9 @@
-import software.sava.services.core.request_capacity.trackers.ErrorTrackerFactory;
-import software.sava.services.core.request_capacity.trackers.HttpErrorTrackerFactory;
-
 module software.sava.core_services {
   requires systems.comodal.json_iterator;
 
   requires java.net.http;
   requires java.management;
 
-  uses ErrorTrackerFactory;
-
-  provides ErrorTrackerFactory with
-      HttpErrorTrackerFactory;
-
   exports software.sava.services.core.exceptions;
 
   exports software.sava.services.core.remote.call;
@@ -21,4 +13,9 @@
   exports software.sava.services.core.request_capacity.context;
   exports software.sava.services.core.request_capacity.trackers;
 
+  uses software.sava.services.core.request_capacity.trackers.ErrorTrackerFactory;
+
+  provides software.sava.services.core.request_capacity.trackers.ErrorTrackerFactory with
+      software.sava.services.core.request_capacity.trackers.HttpErrorTrackerFactory;
+
 }
diff --git a/core/src/main/java/software/sava/services/core/remote/call/Call.java b/core/src/main/java/software/sava/services/core/remote/call/Call.java
@@ -59,9 +59,8 @@ static <I, R> Call<R> createCallOrGiveUp(final Supplier<CompletableFuture<R>> ca
   static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
                                    final Function<I, CompletableFuture<R>> call,
                                    final boolean measureCallTime,
-                                   final BalancedErrorHandler<I> balancedErrorHandler,
                                    final String retryLogContext) {
-    return new UncheckedBalancedCall<>(loadBalancer, call, measureCallTime, balancedErrorHandler, retryLogContext);
+    return new UncheckedBalancedCall<>(loadBalancer, call, measureCallTime, retryLogContext);
   }
 
   static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
@@ -70,75 +69,15 @@ static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
                                    final int runtimeWeight,
                                    final int maxTryClaim,
                                    final boolean measureCallTime,
-                                   final BalancedErrorHandler<I> balancedErrorHandler,
                                    final String retryLogContext) {
     return new CourteousBalancedCall<>(
         loadBalancer,
         call,
         callContext, runtimeWeight, maxTryClaim, true, measureCallTime,
-        balancedErrorHandler, retryLogContext
-    );
-  }
-
-  static <I, R> Call<R> createCallOrGiveUp(final LoadBalancer<I> loadBalancer,
-                                           final Function<I, CompletableFuture<R>> call,
-                                           final CallContext callContext,
-                                           final int runtimeWeight,
-                                           final int maxTryClaim,
-                                           final boolean measureCallTime,
-                                           final BalancedErrorHandler<I> balancedErrorHandler,
-                                           final String retryLogContext) {
-    return new CourteousBalancedCall<>(
-        loadBalancer,
-        call,
-        callContext, runtimeWeight, maxTryClaim, false, measureCallTime,
-        balancedErrorHandler, retryLogContext
-    );
-  }
-
-  static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
-                                   final Function<I, CompletableFuture<R>> call,
-                                   final CallContext callContext,
-                                   final int runtimeWeight,
-                                   final boolean measureCallTime,
-                                   final BalancedErrorHandler<I> balancedErrorHandler,
-                                   final String retryLogContext) {
-    return new GreedyBalancedCall<>(
-        loadBalancer,
-        call,
-        callContext, runtimeWeight, measureCallTime,
-        balancedErrorHandler, retryLogContext
-    );
-  }
-
-  static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
-                                   final Function<I, CompletableFuture<R>> call,
-                                   final boolean measureCallTime,
-                                   final String retryLogContext) {
-    return new UncheckedBalancedCall<>(
-        loadBalancer,
-        call,
-        measureCallTime,
-        loadBalancer.defaultErrorHandler(),
         retryLogContext
     );
   }
 
-  static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
-                                   final Function<I, CompletableFuture<R>> call,
-                                   final CallContext callContext,
-                                   final int runtimeWeight,
-                                   final int maxTryClaim,
-                                   final boolean measureCallTime,
-                                   final String retryLogContext) {
-    return new CourteousBalancedCall<>(
-        loadBalancer,
-        call,
-        callContext, runtimeWeight, maxTryClaim, true, measureCallTime,
-        loadBalancer.defaultErrorHandler(), retryLogContext
-    );
-  }
-
   static <I, R> Call<R> createCallOrGiveUp(final LoadBalancer<I> loadBalancer,
                                            final Function<I, CompletableFuture<R>> call,
                                            final CallContext callContext,
@@ -150,7 +89,7 @@ static <I, R> Call<R> createCallOrGiveUp(final LoadBalancer<I> loadBalancer,
         loadBalancer,
         call,
         callContext, runtimeWeight, maxTryClaim, false, measureCallTime,
-        loadBalancer.defaultErrorHandler(), retryLogContext
+        retryLogContext
     );
   }
 
@@ -164,7 +103,7 @@ static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
         loadBalancer,
         call,
         callContext, runtimeWeight, measureCallTime,
-        loadBalancer.defaultErrorHandler(), retryLogContext
+        retryLogContext
     );
   }
 
@@ -178,7 +117,7 @@ static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
         loadBalancer,
         call,
         callContext, callContext.callWeight(), maxTryClaim, true, measureCallTime,
-        loadBalancer.defaultErrorHandler(), retryLogContext
+        retryLogContext
     );
   }
 
@@ -192,7 +131,7 @@ static <I, R> Call<R> createCallOrGiveUp(final LoadBalancer<I> loadBalancer,
         loadBalancer,
         call,
         callContext, callContext.callWeight(), maxTryClaim, false, measureCallTime,
-        loadBalancer.defaultErrorHandler(), retryLogContext
+        retryLogContext
     );
   }
 
@@ -205,7 +144,7 @@ static <I, R> Call<R> createCall(final LoadBalancer<I> loadBalancer,
         loadBalancer,
         call,
         callContext, callContext.callWeight(), measureCallTime,
-        loadBalancer.defaultErrorHandler(), retryLogContext
+        retryLogContext
     );
   }
 

diff --git a/core/src/main/java/software/sava/services/core/remote/call/CourteousBalancedCall.java b/core/src/main/java/software/sava/services/core/remote/call/CourteousBalancedCall.java
@@ -20,9 +20,8 @@ final class CourteousBalancedCall<I, R> extends GreedyBalancedCall<I, R> {
                         final int maxTryClaim,
                         final boolean forceCall,
                         final boolean measureCallTime,
-                        final BalancedErrorHandler<I> balancedErrorHandler,
                         final String retryLogContext) {
-    super(loadBalancer, call, callContext, callWeight, measureCallTime, balancedErrorHandler, retryLogContext);
+    super(loadBalancer, call, callContext, callWeight, measureCallTime, retryLogContext);
     this.maxTryClaim = maxTryClaim;
     this.forceCall = forceCall;
   }

diff --git a/core/src/main/java/software/sava/services/core/remote/call/ErrorHandlerConfig.java b/core/src/main/java/software/sava/services/core/remote/call/ErrorHandlerConfig.java
@@ -19,7 +19,7 @@ public ErrorHandler createHandler() {
     };
   }
 
-  private static ErrorHandlerConfig parseConfig(final JsonIterator ji) {
+  public static ErrorHandlerConfig parseConfig(final JsonIterator ji) {
     final var parser = new Builder();
     ji.testObject(parser);
     return parser.create();

diff --git a/core/src/main/java/software/sava/services/core/remote/call/GreedyBalancedCall.java b/core/src/main/java/software/sava/services/core/remote/call/GreedyBalancedCall.java
@@ -16,9 +16,8 @@ class GreedyBalancedCall<I, R> extends UncheckedBalancedCall<I, R> {
                      final CallContext callContext,
                      final int callWeight,
                      final boolean measureCallTime,
-                     final BalancedErrorHandler<I> balancedErrorHandler,
                      final String retryLogContext) {
-    super(loadBalancer, call, measureCallTime, balancedErrorHandler, retryLogContext);
+    super(loadBalancer, call, measureCallTime, retryLogContext);
     this.callContext = callContext;
     this.callWeight = callWeight;
   }

diff --git a/core/src/main/java/software/sava/services/core/remote/call/UncheckedBalancedCall.java b/core/src/main/java/software/sava/services/core/remote/call/UncheckedBalancedCall.java
@@ -13,20 +13,17 @@ class UncheckedBalancedCall<I, R> implements Call<R> {
   protected final LoadBalancer<I> loadBalancer;
   protected final Function<I, CompletableFuture<R>> call;
   protected final boolean measureCallTime;
-  private final BalancedErrorHandler<I> balancedErrorHandler;
   protected final String retryLogContext;
 
   protected BalancedItem<I> next;
 
   UncheckedBalancedCall(final LoadBalancer<I> loadBalancer,
                         final Function<I, CompletableFuture<R>> call,
                         final boolean measureCallTime,
-                        final BalancedErrorHandler<I> balancedErrorHandler,
                         final String retryLogContext) {
     this.loadBalancer = loadBalancer;
     this.call = call;
     this.measureCallTime = measureCallTime;
-    this.balancedErrorHandler = balancedErrorHandler;
     this.retryLogContext = retryLogContext;
   }
 
@@ -53,7 +50,7 @@ public final R get() {
           return result;
         }
       } catch (final RuntimeException e) {
-        final long sleep = balancedErrorHandler.onError(this.next, ++errorCount, retryLogContext, e, MILLISECONDS);
+        final long sleep = this.next.onError(++errorCount, retryLogContext, e, MILLISECONDS);
         loadBalancer.sort();
         if (sleep < 0) {
           return null;

diff --git a/core/src/main/java/software/sava/services/core/remote/load_balance/ArrayLoadBalancer.java b/core/src/main/java/software/sava/services/core/remote/load_balance/ArrayLoadBalancer.java
@@ -1,28 +1,23 @@
 package software.sava.services.core.remote.load_balance;
 
-import software.sava.services.core.remote.call.BalancedErrorHandler;
-
 import java.util.List;
 import java.util.stream.Stream;
 
 final class ArrayLoadBalancer<T> implements LoadBalancer<T> {
 
   private final BalancedItem<T>[] items;
   private final List<BalancedItem<T>> itemList;
-  private final BalancedErrorHandler<T> defaultErrorHandler;
   private int i;
 
   ArrayLoadBalancer(final List<BalancedItem<T>> itemList,
-                    final BalancedItem<T>[] items,
-                    final BalancedErrorHandler<T> defaultErrorHandler) {
+                    final BalancedItem<T>[] items) {
     this.items = items;
     this.itemList = itemList;
-    this.defaultErrorHandler = defaultErrorHandler;
     this.i = -1;
   }
 
-  ArrayLoadBalancer(final BalancedItem<T>[] items, final BalancedErrorHandler<T> defaultErrorHandler) {
-    this(List.of(items), items, defaultErrorHandler);
+  ArrayLoadBalancer(final BalancedItem<T>[] items) {
+    this(List.of(items), items);
   }
 
   @Override
@@ -128,9 +123,4 @@ public BalancedItem<T> withContext() {
   public List<BalancedItem<T>> items() {
     return this.itemList;
   }
-
-  @Override
-  public BalancedErrorHandler<T> defaultErrorHandler() {
-    return defaultErrorHandler;
-  }
 }
diff --git a/core/src/main/java/software/sava/services/core/remote/load_balance/BalancedItem.java b/core/src/main/java/software/sava/services/core/remote/load_balance/BalancedItem.java
@@ -1,12 +1,17 @@
 package software.sava.services.core.remote.load_balance;
 
+import software.sava.services.core.remote.call.ErrorHandler;
 import software.sava.services.core.request_capacity.CapacityMonitor;
 import software.sava.services.core.request_capacity.CapacityState;
 
+import java.util.concurrent.TimeUnit;
+
 public interface BalancedItem<T> {
 
-  static <T> BalancedItem<T> createItem(final T item, final CapacityMonitor capacityMonitor) {
-    return new ItemContext<>(item, capacityMonitor);
+  static <T> BalancedItem<T> createItem(final T item,
+                                        final CapacityMonitor capacityMonitor,
+                                        final ErrorHandler errorHandler) {
+    return new ItemContext<>(item, capacityMonitor, errorHandler);
   }
 
   void sample(final long sample);
@@ -36,4 +41,9 @@ default void failed() {
   default CapacityState capacityState() {
     return capacityMonitor().capacityState();
   }
+
+  long onError(final int errorCount,
+               final String retryLogContext,
+               final RuntimeException exception,
+               final TimeUnit timeUnit);
 }
diff --git a/core/src/main/java/software/sava/services/core/remote/load_balance/ItemContext.java b/core/src/main/java/software/sava/services/core/remote/load_balance/ItemContext.java
@@ -1,8 +1,10 @@
 package software.sava.services.core.remote.load_balance;
 
+import software.sava.services.core.remote.call.ErrorHandler;
 import software.sava.services.core.request_capacity.CapacityMonitor;
 
 import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicLongArray;
@@ -18,16 +20,20 @@ final class ItemContext<T> implements BalancedItem<T> {
 
   private final T item;
   private final CapacityMonitor capacityMonitor;
+  private final ErrorHandler errorHandler;
   private final AtomicLong failureCount;
   private final AtomicLongArray samples;
   private final AtomicInteger sampleIndex;
   private final AtomicLong sampleMedian;
   private final long[] localSampleArray;
   private long skipped;
 
-  ItemContext(final T item, final CapacityMonitor capacityMonitor) {
+  ItemContext(final T item,
+              final CapacityMonitor capacityMonitor,
+              final ErrorHandler errorHandler) {
     this.item = item;
     this.capacityMonitor = capacityMonitor;
+    this.errorHandler = errorHandler;
     this.failureCount = new AtomicLong();
     this.samples = new AtomicLongArray(NUM_SAMPLES);
     this.sampleIndex = new AtomicInteger(-1);
@@ -103,4 +109,13 @@ public void selected() {
   public CapacityMonitor capacityMonitor() {
     return capacityMonitor;
   }
+
+  @Override
+  public long onError(final int errorCount,
+                      final String retryLogContext,
+                      final RuntimeException exception,
+                      final TimeUnit timeUnit) {
+    failed();
+    return errorHandler.onError(errorCount, retryLogContext, exception, timeUnit);
+  }
 }
diff --git a/core/src/main/java/software/sava/services/core/remote/load_balance/LoadBalancer.java b/core/src/main/java/software/sava/services/core/remote/load_balance/LoadBalancer.java
@@ -7,31 +7,30 @@
 
 public interface LoadBalancer<T> {
 
-  static <T> LoadBalancer<T> createBalancer(final BalancedItem<T> item,
-                                            final BalancedErrorHandler<T> defaultErrorHandler) {
-    return new SingletonLoadBalancer<>(item, List.of(item), defaultErrorHandler);
+  static <T> LoadBalancer<T> createBalancer(final BalancedItem<T> item) {
+    return new SingletonLoadBalancer<>(item, List.of(item));
   }
 
-  static <T> LoadBalancer<T> createBalancer(final BalancedItem<T>[] items,
-                                            final BalancedErrorHandler<T> defaultErrorHandler) {
-    return new ArrayLoadBalancer<>(items, defaultErrorHandler);
+  static <T> LoadBalancer<T> createBalancer(final BalancedItem<T>[] items) {
+    return items.length == 1
+        ? createBalancer(items[0])
+        : new ArrayLoadBalancer<>(items);
   }
 
   @SuppressWarnings("unchecked")
-  static <T> LoadBalancer<T> createBalancer(final List<BalancedItem<T>> items,
-                                            final BalancedErrorHandler<T> defaultErrorHandler) {
-    return new ArrayLoadBalancer<>(items, items.toArray(BalancedItem[]::new), defaultErrorHandler);
+  static <T> LoadBalancer<T> createBalancer(final List<BalancedItem<T>> items) {
+    return createBalancer(items.toArray(BalancedItem[]::new));
   }
 
-  static <T> LoadBalancer<T> createSortedBalancer(final BalancedItem<T>[] items,
-                                                  final BalancedErrorHandler<T> defaultErrorHandler) {
-    return new SortedLoadBalancer<>(items, defaultErrorHandler);
+  static <T> LoadBalancer<T> createSortedBalancer(final BalancedItem<T>[] items) {
+    return items.length == 1
+        ? createBalancer(items[0])
+        : new SortedLoadBalancer<>(items);
   }
 
   @SuppressWarnings("unchecked")
-  static <T> LoadBalancer<T> createSortedBalancer(final List<BalancedItem<T>> items,
-                                                  final BalancedErrorHandler<T> defaultErrorHandler) {
-    return createSortedBalancer(items.toArray(BalancedItem[]::new), defaultErrorHandler);
+  static <T> LoadBalancer<T> createSortedBalancer(final List<BalancedItem<T>> items) {
+    return createSortedBalancer(items.toArray(BalancedItem[]::new));
   }
 
   int size();
@@ -49,6 +48,4 @@ static <T> LoadBalancer<T> createSortedBalancer(final List<BalancedItem<T>> item
   BalancedItem<T> withContext();
 
   List<BalancedItem<T>> items();
-
-  BalancedErrorHandler<T> defaultErrorHandler();
 }