move to tool - draft

Signed-off-by: liran2000 <[email protected]>

Author: liran2000

providers/flagd/README.md

@@ -58,9 +58,12 @@ If the `in-process` mode is not used, and before the provider is ready, the `get
 HttpConnector is responsible for polling data from a specified URL at regular intervals.  
 It is leveraging Http cache mechanism with 'ETag' header, then when receiving 304 Not Modified response,
 reducing traffic, reducing rate limits effects and changes updates. Can be enabled via useHttpCache option.  
-One of its benefits is to reduce infrastructure/devops work, without additional containers needed.  
 The implementation is using Java HttpClient.
 
+##### Use cases and benefits
+* Reduce infrastructure/devops work, without additional containers needed.  
+* Use as an additional provider for fallback / internal backup service via multi-provider.
+
 ##### What happens if the Http source is down when application is starting ?
 
 It supports optional fail-safe initialization via cache, such that on initial fetch error following by 

tools/flagd-http-connector/src/main/java/dev/openfeature/contrib/tools/flagd/resolver/process/storage/connector/sync/http/util/ConcurrentUtils.java

@@ -0,0 +1,61 @@
+package dev.openfeature.contrib.tools.flagd.resolver.process.storage.connector.sync.http.util;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Concurrent / Concurrency utilities.
+ *
+ * @author Liran Mendelovich
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@Slf4j
+public class ConcurrentUtils {
+
+    /**
+     * Graceful shutdown a thread pool. <br>
+     * See <a
+     * href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html">
+     * https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html</a>
+     *
+     * @param pool thread pool
+     * @param timeoutSeconds grace period timeout in seconds - timeout can be twice than this value,
+     *     as first it waits for existing tasks to terminate, then waits for cancelled tasks to
+     *     terminate.
+     */
+    public static void shutdownAndAwaitTermination(ExecutorService pool, int timeoutSeconds) {
+        if (pool == null) {
+            return;
+        }
+
+        // Disable new tasks from being submitted
+        pool.shutdown();
+        try {
+
+            // Wait a while for existing tasks to terminate
+            if (!pool.awaitTermination(timeoutSeconds, TimeUnit.SECONDS)) {
+
+                // Cancel currently executing tasks - best effort, based on interrupt handling
+                // implementation.
+                pool.shutdownNow();
+
+                // Wait a while for tasks to respond to being cancelled
+                if (!pool.awaitTermination(timeoutSeconds, TimeUnit.SECONDS)) {
+                    log.error("Thread pool did not shutdown all tasks after the timeout: {} seconds.", timeoutSeconds);
+                }
+            }
+        } catch (InterruptedException e) {
+
+            log.info("Current thread interrupted during shutdownAndAwaitTermination, calling shutdownNow.");
+
+            // (Re-)Cancel if current thread also interrupted
+            pool.shutdownNow();
+
+            // Preserve interrupt status
+            Thread.currentThread().interrupt();
+        }
+    }
+}

tools/flagd-http-connector/src/test/java/dev/openfeature/contrib/tools/flagd/resolver/process/storage/connector/sync/http/HttpCacheFetcherTest.java

@@ -0,0 +1,59 @@
+package dev.openfeature.contrib.tools.flagd.resolver.process.storage.connector.sync.http;
+
+import static dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.sync.http.HttpConnectorTest.delay;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.QueuePayload;
+import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.sync.http.HttpConnector;
+import dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.sync.http.HttpConnectorOptions;
+import java.util.concurrent.BlockingQueue;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Integration test for the HttpConnector class, specifically testing the ability to fetch
+ * raw content from a GitHub URL. This test assumes that integration tests are enabled
+ * and verifies that the HttpConnector can successfully enqueue data from the specified URL.
+ * The test initializes the HttpConnector with specific configurations, waits for data
+ * to be enqueued, and asserts the expected queue size. The connector is shut down
+ * gracefully after the test execution.
+ * As this integration test using external request, it is disabled by default, and not part of the CI build.
+ */
+@Slf4j
+class HttpConnectorIntegrationTest {
+
+    @SneakyThrows
+    @Test
+    void testGithubRawContent() {
+        assumeTrue(parseBoolean("integrationTestsEnabled"));
+        dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.sync.http.HttpConnector connector = null;
+        try {
+            String testUrl = "https://raw.githubusercontent.com/open-feature/java-sdk-contrib/58fe5da7d4e2f6f4ae2c1caf3411a01e84a1dc1a/providers/flagd/version.txt";
+
+            dev.openfeature.contrib.providers.flagd.resolver.process.storage.connector.sync.http.HttpConnectorOptions httpConnectorOptions = HttpConnectorOptions.builder()
+                .url(testUrl)
+                .connectTimeoutSeconds(10)
+                .requestTimeoutSeconds(10)
+                .useHttpCache(true)
+                .pollIntervalSeconds(5)
+                .build();
+            connector = HttpConnector.builder()
+                .httpConnectorOptions(httpConnectorOptions)
+                .build();
+            BlockingQueue<QueuePayload> queue = connector.getStreamQueue();
+            delay(20000);
+            assertEquals(1, queue.size());
+        } finally {
+            if (connector != null) {
+                connector.shutdown();
+            }
+        }
+    }
+
+    public static boolean parseBoolean(String key) {
+        return Boolean.parseBoolean(System.getProperty(key, System.getenv(key)));
+    }
+
+}