chore: spotless apply

Signed-off-by: Bernd Warmuth <[email protected]>

Author: Bernd Warmuth

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdOptions.java

@@ -1,19 +1,18 @@
 package dev.openfeature.contrib.providers.flagd;
 
+import static dev.openfeature.contrib.providers.flagd.Config.fallBackToEnvOrDefault;
+import static dev.openfeature.contrib.providers.flagd.Config.fromValueProvider;
+
 import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.Connector;
 import dev.openfeature.sdk.EvaluationContext;
 import dev.openfeature.sdk.ImmutableContext;
 import dev.openfeature.sdk.Structure;
 import io.opentelemetry.api.GlobalOpenTelemetry;
 import io.opentelemetry.api.OpenTelemetry;
+import java.util.function.Function;
 import lombok.Builder;
 import lombok.Getter;
 
-import java.util.function.Function;
-
-import static dev.openfeature.contrib.providers.flagd.Config.fallBackToEnvOrDefault;
-import static dev.openfeature.contrib.providers.flagd.Config.fromValueProvider;
-
 /**
  * FlagdOptions is a builder to build flagd provider options.
  */
@@ -66,15 +65,15 @@ public class FlagdOptions {
      * Max cache size.
      */
     @Builder.Default
-    private int maxCacheSize = fallBackToEnvOrDefault(Config.MAX_CACHE_SIZE_ENV_VAR_NAME,
-            Config.DEFAULT_MAX_CACHE_SIZE);
+    private int maxCacheSize =
+            fallBackToEnvOrDefault(Config.MAX_CACHE_SIZE_ENV_VAR_NAME, Config.DEFAULT_MAX_CACHE_SIZE);
 
     /**
      * Backoff interval in milliseconds.
      */
     @Builder.Default
-    private int retryBackoffMs = fallBackToEnvOrDefault(Config.BASE_EVENT_STREAM_RETRY_BACKOFF_MS_ENV_VAR_NAME,
-            Config.BASE_EVENT_STREAM_RETRY_BACKOFF_MS);
+    private int retryBackoffMs = fallBackToEnvOrDefault(
+            Config.BASE_EVENT_STREAM_RETRY_BACKOFF_MS_ENV_VAR_NAME, Config.BASE_EVENT_STREAM_RETRY_BACKOFF_MS);
 
     /**
      * Connection deadline in milliseconds.
@@ -91,16 +90,16 @@ public class FlagdOptions {
      * Defaults to 600000 (10 minutes); recommended to prevent infrastructure from killing idle connections.
      */
     @Builder.Default
-    private int streamDeadlineMs = fallBackToEnvOrDefault(Config.STREAM_DEADLINE_MS_ENV_VAR_NAME,
-            Config.DEFAULT_STREAM_DEADLINE_MS);
+    private int streamDeadlineMs =
+            fallBackToEnvOrDefault(Config.STREAM_DEADLINE_MS_ENV_VAR_NAME, Config.DEFAULT_STREAM_DEADLINE_MS);
 
     /**
      * Grace time period in milliseconds before provider moves from STALE to ERROR.
      * Defaults to 50_000
      */
     @Builder.Default
-    private int streamRetryGracePeriod = fallBackToEnvOrDefault(Config.STREAM_RETRY_GRACE_PERIOD,
-            Config.DEFAULT_STREAM_RETRY_GRACE_PERIOD);
+    private int streamRetryGracePeriod =
+            fallBackToEnvOrDefault(Config.STREAM_RETRY_GRACE_PERIOD, Config.DEFAULT_STREAM_RETRY_GRACE_PERIOD);
     /**
      * Selector to be used with flag sync gRPC contract.
      **/
@@ -112,7 +111,8 @@ public class FlagdOptions {
      * Defaults to 0 (disabled).
      **/
     @Builder.Default
-    private long keepAlive = fallBackToEnvOrDefault(Config.KEEP_ALIVE_MS_ENV_VAR_NAME,
+    private long keepAlive = fallBackToEnvOrDefault(
+            Config.KEEP_ALIVE_MS_ENV_VAR_NAME,
             fallBackToEnvOrDefault(Config.KEEP_ALIVE_MS_ENV_VAR_NAME_OLD, Config.DEFAULT_KEEP_ALIVE));
 
     /**
@@ -122,7 +122,6 @@ public class FlagdOptions {
     @Builder.Default
     private String offlineFlagSourcePath = fallBackToEnvOrDefault(Config.OFFLINE_SOURCE_PATH, null);
 
-
     /**
      * gRPC custom target string.
      *
@@ -133,7 +132,6 @@ public class FlagdOptions {
     @Builder.Default
     private String targetUri = fallBackToEnvOrDefault(Config.TARGET_URI_ENV_VAR_NAME, null);
 
-
     /**
      * Function providing an EvaluationContext to mix into every evaluations.
      * The sync-metadata response
@@ -144,8 +142,8 @@ public class FlagdOptions {
      * By default, the entire sync response (converted to a Structure) is used.
      */
     @Builder.Default
-    private Function<Structure, EvaluationContext> contextEnricher = (syncMetadata) -> new ImmutableContext(
-            syncMetadata.asMap());
+    private Function<Structure, EvaluationContext> contextEnricher =
+            (syncMetadata) -> new ImmutableContext(syncMetadata.asMap());
 
     /**
      * Inject a Custom Connector for fetching flags.
@@ -196,8 +194,8 @@ void prebuild() {
             }
 
             if (port == 0) {
-                port = Integer
-                        .parseInt(fallBackToEnvOrDefault(Config.PORT_ENV_VAR_NAME, determineDefaultPortForResolver()));
+                port = Integer.parseInt(
+                        fallBackToEnvOrDefault(Config.PORT_ENV_VAR_NAME, determineDefaultPortForResolver()));
             }
         }
 

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdProvider.java

@@ -15,12 +15,11 @@
 import dev.openfeature.sdk.ProviderEventDetails;
 import dev.openfeature.sdk.Structure;
 import dev.openfeature.sdk.Value;
-import lombok.extern.slf4j.Slf4j;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Function;
+import lombok.extern.slf4j.Slf4j;
 
 /**
  * OpenFeature provider for flagd.
@@ -56,13 +55,11 @@ public FlagdProvider() {
     public FlagdProvider(final FlagdOptions options) {
         switch (options.getResolverType().asString()) {
             case Config.RESOLVER_IN_PROCESS:
-                this.flagResolver = new InProcessResolver(options, this::isConnected,
-                        this::onConnectionEvent);
+                this.flagResolver = new InProcessResolver(options, this::isConnected, this::onConnectionEvent);
                 break;
             case Config.RESOLVER_RPC:
-                this.flagResolver = new GrpcResolver(options,
-                        new Cache(options.getCacheType(), options.getMaxCacheSize()),
-                        this::onConnectionEvent);
+                this.flagResolver = new GrpcResolver(
+                        options, new Cache(options.getCacheType(), options.getMaxCacheSize()), this::onConnectionEvent);
                 break;
             default:
                 throw new IllegalStateException(
@@ -159,7 +156,7 @@ private boolean isConnected() {
     }
 
     private void onConnectionEvent(ConnectionEvent connectionEvent) {
-        final boolean wasConnected = connected;// WHY the F*** is this false? wasconnected is false ,hence no change
+        final boolean wasConnected = connected; // WHY the F*** is this false? wasconnected is false ,hence no change
         // event will be sent. why is was connected false? not updated via event?
         final boolean isConnected = connected = connectionEvent.isConnected();
 
@@ -189,12 +186,13 @@ private void onConnectionEvent(ConnectionEvent connectionEvent) {
         }
 
         if (connectionEvent.isStale()) {
-            this.emitProviderStale(ProviderEventDetails.builder().message("there has been an error").build());
+            this.emitProviderStale(ProviderEventDetails.builder()
+                    .message("there has been an error")
+                    .build());
         } else {
-            this.emitProviderError(ProviderEventDetails.builder().message("there has been an error").build());
+            this.emitProviderError(ProviderEventDetails.builder()
+                    .message("there has been an error")
+                    .build());
         }
     }
 }
-
-
-

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/resolver/common/ChannelMonitor.java

@@ -3,25 +3,20 @@
 import dev.openfeature.sdk.exceptions.GeneralError;
 import io.grpc.ConnectivityState;
 import io.grpc.ManagedChannel;
-import lombok.extern.slf4j.Slf4j;
-
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
-
+import lombok.extern.slf4j.Slf4j;
 
 /**
  * A utility class to monitor and manage the connectivity state of a gRPC ManagedChannel.
  */
 @Slf4j
 public class ChannelMonitor {
 
-
-    private ChannelMonitor() {
-
-    }
+    private ChannelMonitor() {}
 
     /**
      * Monitors the state of a gRPC channel and triggers the specified callbacks based on state changes.
@@ -31,8 +26,11 @@ private ChannelMonitor() {
      * @param onConnectionReady callback invoked when the channel transitions to a READY state.
      * @param onConnectionLost  callback invoked when the channel transitions to a FAILURE or SHUTDOWN state.
      */
-    public static void monitorChannelState(ConnectivityState expectedState, ManagedChannel channel,
-                                           Runnable onConnectionReady, Runnable onConnectionLost) {
+    public static void monitorChannelState(
+            ConnectivityState expectedState,
+            ManagedChannel channel,
+            Runnable onConnectionReady,
+            Runnable onConnectionLost) {
         channel.notifyWhenStateChanged(expectedState, () -> {
             ConnectivityState currentState = channel.getState(true);
             log.info("Channel state changed to: {}", currentState);
@@ -47,7 +45,6 @@ public static void monitorChannelState(ConnectivityState expectedState, ManagedC
         });
     }
 
-
     /**
      * Waits for the channel to reach a desired state within a specified timeout period.
      *
@@ -58,21 +55,24 @@ public static void monitorChannelState(ConnectivityState expectedState, ManagedC
      * @param unit            the time unit of the timeout.
      * @throws InterruptedException if the current thread is interrupted while waiting.
      */
-    public static void waitForDesiredState(ManagedChannel channel,
-                                           ConnectivityState desiredState,
-                                           Runnable connectCallback,
-                                           long timeout,
-                                           TimeUnit unit) throws InterruptedException {
+    public static void waitForDesiredState(
+            ManagedChannel channel,
+            ConnectivityState desiredState,
+            Runnable connectCallback,
+            long timeout,
+            TimeUnit unit)
+            throws InterruptedException {
         waitForDesiredState(channel, desiredState, connectCallback, new CountDownLatch(1), timeout, unit);
     }
 
-
-    private static void waitForDesiredState(ManagedChannel channel,
-                                            ConnectivityState desiredState,
-                                            Runnable connectCallback,
-                                            CountDownLatch latch,
-                                            long timeout,
-                                            TimeUnit unit) throws InterruptedException {
+    private static void waitForDesiredState(
+            ManagedChannel channel,
+            ConnectivityState desiredState,
+            Runnable connectCallback,
+            CountDownLatch latch,
+            long timeout,
+            TimeUnit unit)
+            throws InterruptedException {
         channel.notifyWhenStateChanged(ConnectivityState.SHUTDOWN, () -> {
             try {
                 ConnectivityState state = channel.getState(true);
@@ -94,12 +94,11 @@ private static void waitForDesiredState(ManagedChannel channel,
 
         // Await the latch or timeout for the state change
         if (!latch.await(timeout, unit)) {
-            throw new GeneralError(String.format("Deadline exceeded. Condition did not complete within the %d "
-                    + "deadline", timeout));
+            throw new GeneralError(String.format(
+                    "Deadline exceeded. Condition did not complete within the %d " + "deadline", timeout));
         }
     }
 
-
     /**
      * Polls the state of a gRPC channel at regular intervals and triggers callbacks upon state changes.
      *
@@ -109,9 +108,12 @@ private static void waitForDesiredState(ManagedChannel channel,
      * @param onConnectionLost  callback invoked when the channel transitions to a FAILURE or SHUTDOWN state.
      * @param pollIntervalMs    the polling interval in milliseconds.
      */
-    public static void pollChannelState(ScheduledExecutorService executor, ManagedChannel channel,
-                                        Runnable onConnectionReady,
-                                        Runnable onConnectionLost, long pollIntervalMs) {
+    public static void pollChannelState(
+            ScheduledExecutorService executor,
+            ManagedChannel channel,
+            Runnable onConnectionReady,
+            Runnable onConnectionLost,
+            long pollIntervalMs) {
 
         AtomicReference<ConnectivityState> lastState = new AtomicReference<>(ConnectivityState.READY);
 
@@ -132,7 +134,6 @@ public static void pollChannelState(ScheduledExecutorService executor, ManagedCh
         executor.scheduleAtFixedRate(pollTask, 0, pollIntervalMs, TimeUnit.MILLISECONDS);
     }
 
-
     /**
      * Polls the channel state at fixed intervals and waits for the channel to reach a desired state within a timeout
      * period.
@@ -146,9 +147,14 @@ public static void pollChannelState(ScheduledExecutorService executor, ManagedCh
      * @return {@code true} if the desired state was reached within the timeout period, {@code false} otherwise.
      * @throws InterruptedException if the current thread is interrupted while waiting.
      */
-    public static boolean pollForDesiredState(ScheduledExecutorService executor, ManagedChannel channel,
-                                              ConnectivityState desiredState, Runnable connectCallback, long timeout,
-                                              TimeUnit unit) throws InterruptedException {
+    public static boolean pollForDesiredState(
+            ScheduledExecutorService executor,
+            ManagedChannel channel,
+            ConnectivityState desiredState,
+            Runnable connectCallback,
+            long timeout,
+            TimeUnit unit)
+            throws InterruptedException {
         CountDownLatch latch = new CountDownLatch(1);
 
         Runnable waitForStateTask = () -> {
@@ -159,8 +165,8 @@ public static boolean pollForDesiredState(ScheduledExecutorService executor, Man
             }
         };
 
-        ScheduledFuture<?> scheduledFuture = executor.scheduleWithFixedDelay(waitForStateTask, 0, 100,
-                TimeUnit.MILLISECONDS);
+        ScheduledFuture<?> scheduledFuture =
+                executor.scheduleWithFixedDelay(waitForStateTask, 0, 100, TimeUnit.MILLISECONDS);
 
         boolean success = latch.await(timeout, unit);
         scheduledFuture.cancel(true);

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/resolver/common/ConnectionEvent.java

@@ -2,7 +2,6 @@
 
 import dev.openfeature.sdk.ImmutableStructure;
 import dev.openfeature.sdk.Structure;
-
 import java.util.Collections;
 import java.util.List;
 
@@ -35,7 +34,9 @@ public class ConnectionEvent {
      * @param connected {@code true} if the connection is established, otherwise {@code false}.
      */
     public ConnectionEvent(boolean connected) {
-        this(connected ? ConnectionState.CONNECTED : ConnectionState.DISCONNECTED, Collections.emptyList(),
+        this(
+                connected ? ConnectionState.CONNECTED : ConnectionState.DISCONNECTED,
+                Collections.emptyList(),
                 new ImmutableStructure());
     }
 
@@ -78,9 +79,10 @@ public ConnectionEvent(ConnectionState connected, Structure syncMetadata) {
      */
     public ConnectionEvent(ConnectionState connectionState, List<String> flagsChanged, Structure syncMetadata) {
         this.connected = connectionState;
-        this.flagsChanged = flagsChanged != null ? flagsChanged : Collections.emptyList();  // Ensure non-null list
-        this.syncMetadata = syncMetadata != null ? new ImmutableStructure(syncMetadata.asMap()) :
-                new ImmutableStructure(); // Ensure valid syncMetadata
+        this.flagsChanged = flagsChanged != null ? flagsChanged : Collections.emptyList(); // Ensure non-null list
+        this.syncMetadata = syncMetadata != null
+                ? new ImmutableStructure(syncMetadata.asMap())
+                : new ImmutableStructure(); // Ensure valid syncMetadata
     }
 
     /**

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/resolver/common/ConnectionState.java

@@ -24,4 +24,4 @@ public enum ConnectionState {
      * The connection has encountered an error and cannot function correctly.
      */
     ERROR,
-}
+}