[release] lib-data-range-redis@1.0.0

Initial release of lib-data-range-redis module with pure Java implementation:
- RangeStore interface for time-based range storage similar to Redis ZRANGE
- LocalRangeProvider for in-memory storage
- RedisRangeProvider using Redis sorted sets
- Add module to CI workflows and dependency scanning

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: pditommaso

.github/workflows/build.yml

@@ -68,6 +68,7 @@ jobs:
           bash publish.sh lib-crypto
           bash publish.sh lib-docker-cli
           bash publish.sh lib-data-queue-redis
+          bash publish.sh lib-data-range-redis
           bash publish.sh lib-data-store-future-redis
           bash publish.sh lib-data-store-state-redis
           bash publish.sh lib-data-stream-redis

.github/workflows/generate-submit-dependencies.yml

@@ -19,6 +19,7 @@ jobs:
           "lib-crypto",
           "lib-docker-cli",
           "lib-data-queue-redis",
+          "lib-data-range-redis",
           "lib-data-store-future-redis",
           "lib-data-store-state-redis",
           "lib-data-stream-redis",

README.md

@@ -23,6 +23,7 @@ A collection of reusable Java & Groovy libraries for Seqera platform components.
 ### Messaging & Data Libraries
 - **[lib-cache-tiered-redis](lib-cache-tiered-redis/)** - Two-tier caching with Caffeine (L1) and Redis (L2) for distributed caching
 - **[lib-data-queue-redis](lib-data-queue-redis/)** - Message queue abstraction with Redis and local implementations
+- **[lib-data-range-redis](lib-data-range-redis/)** - Range set storage similar to Redis ZRANGE with local and Redis implementations
 - **[lib-data-store-future-redis](lib-data-store-future-redis/)** - Distributed CompletableFuture store for cross-service async operations
 - **[lib-data-store-state-redis](lib-data-store-state-redis/)** - Distributed state store with atomic operations and counters
 - **[lib-data-stream-redis](lib-data-stream-redis/)** - Message streaming with Redis Streams and local implementations

lib-data-range-redis/README.md

@@ -0,0 +1,110 @@
+# lib-data-range-redis
+
+Time-based range store abstraction with Redis and local implementations. Useful for implementing cron-like services that need to schedule and retrieve entries based on expiration time.
+
+## Installation
+
+Add this dependency to your `build.gradle`:
+
+```gradle
+dependencies {
+    implementation 'io.seqera:lib-data-range-redis:1.0.0'
+}
+```
+
+## Usage
+
+The library provides a `RangeStore` interface for storing entries with a timestamp score, allowing efficient retrieval of entries within a time range. This is particularly useful for implementing scheduled cleanup services or cron-like background tasks.
+
+### Creating a Store
+
+Extend `AbstractRangeStore` to create a concrete store for your use case:
+
+```groovy
+@Singleton
+@CompileStatic
+class ScheduledTaskStore extends AbstractRangeStore {
+
+    ScheduledTaskStore(RangeProvider provider) {
+        super(provider)
+    }
+
+    @Override
+    protected String getKey() {
+        return 'scheduled-tasks/v1:'
+    }
+}
+```
+
+### Implementing a Cron Service
+
+Use the store with a scheduler to implement periodic background tasks:
+
+```groovy
+@Slf4j
+@Context
+@CompileStatic
+class ScheduledTaskService implements Runnable {
+
+    @Inject
+    private TaskScheduler scheduler
+
+    @Inject
+    private ScheduledTaskStore store
+
+    @PostConstruct
+    private init() {
+        // Schedule periodic execution
+        scheduler.scheduleWithFixedDelay(
+                Duration.ofMinutes(1),  // initial delay
+                Duration.ofMinutes(5),  // interval
+                this)
+    }
+
+    @Override
+    void run() {
+        final now = Instant.now()
+        // Retrieve entries with score <= current time (expired entries)
+        final keys = store.getRange(0, now.epochSecond, 100)
+
+        for (String entry : keys) {
+            processEntry(entry)
+        }
+    }
+
+    // Schedule an entry for future processing
+    void scheduleTask(String taskId, Duration delay) {
+        final expirationSecs = Instant.now().plus(delay).epochSecond
+        store.add(taskId, expirationSecs)
+    }
+
+    private void processEntry(String entry) {
+        // Handle the expired entry
+        log.debug "Processing entry: $entry"
+    }
+}
+```
+
+### Key Methods
+
+- `add(String member, double score)` - Add an entry with a timestamp score
+- `getRange(double min, double max, int count)` - Retrieve entries within a score range
+
+The score typically represents epoch seconds, making it easy to schedule entries for future processing.
+
+## Configuration
+
+For Redis implementation, configure the Redis URI in your `application.yml`:
+
+```yaml
+redis:
+  uri: redis://localhost:6379
+```
+
+The library automatically selects `RedisRangeProvider` when `redis.uri` is configured, otherwise falls back to `LocalRangeProvider` for development/testing.
+
+## Testing
+
+```bash
+./gradlew :lib-data-range-redis:test
+```

lib-data-range-redis/VERSION

@@ -0,0 +1 @@
+1.0.0

lib-data-range-redis/build.gradle

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2025, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+plugins {
+    id 'io.seqera.java-library-conventions'
+    id 'io.seqera.groovy-library-conventions'
+    // Micronaut minimal lib
+    // https://micronaut-projects.github.io/micronaut-gradle-plugin/latest/
+    id "io.micronaut.minimal.library" version '4.5.3'
+}
+
+group = 'io.seqera'
+version = "${project.file('VERSION').text.trim()}"
+
+dependencies {
+    implementation 'redis.clients:jedis:5.1.4'
+
+    compileOnly "io.micronaut:micronaut-inject:${micronautCoreVersion}"
+    implementation "ch.qos.logback:logback-classic:1.5.19"
+    implementation "io.micronaut:micronaut-runtime:${micronautCoreVersion}"
+
+    testImplementation testFixtures(project(':lib-fixtures-redis'))
+    testImplementation "org.apache.groovy:groovy:4.0.24"
+    testImplementation "io.micronaut:micronaut-inject-groovy:${micronautCoreVersion}"
+    testImplementation "io.micronaut.test:micronaut-test-spock:${micronautTestVersion}"
+    testImplementation 'org.testcontainers:testcontainers:1.20.6'
+    testRuntimeOnly 'org.yaml:snakeyaml:2.2'
+}
+
+test {
+    useJUnitPlatform()
+}
+
+
+micronaut {
+    version '4.8.3'
+    runtime("netty")
+    processing {
+        incremental(true)
+    }
+    importMicronautPlatform = false
+}

lib-data-range-redis/changelog.txt

@@ -0,0 +1,12 @@
+# lib-data-range-redis changelog
+
+1.0.0 - 14 Jan 2025
+- Initial release of lib-data-range-redis extracted from Wave project
+- Implement RangeStore interface for time-based range storage
+- Add AbstractRangeStore base class for concrete store implementations
+- Add RangeProvider interface for storage backend abstraction
+- Add LocalRangeProvider for in-memory range storage
+- Add RedisRangeProvider implementation using Redis sorted sets
+- Support scheduling entries with timestamp scores for cron-like services
+- Use @Requires(property = 'redis.uri') for conditional bean loading
+- Include comprehensive test suite with Redis testcontainers

lib-data-range-redis/src/main/java/io/seqera/data/range/AbstractRangeStore.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2025, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package io.seqera.data.range;
+
+import java.util.List;
+
+import io.seqera.data.range.impl.RangeProvider;
+
+/**
+ * Abstract implementation for range set similar to Redis {@code zrange}
+ *
+ * @author Paolo Di Tommaso <paolo.ditommaso@gmail.com>
+ */
+public abstract class AbstractRangeStore implements RangeStore {
+
+    private final RangeProvider delegate;
+
+    protected abstract String getKey();
+
+    protected AbstractRangeStore(RangeProvider provider) {
+        this.delegate = provider;
+    }
+
+    @Override
+    public void add(String name, double score) {
+        delegate.add(getKey(), name, score);
+    }
+
+    @Override
+    public List<String> getRange(double min, double max, int count) {
+        return getRange(min, max, count, true);
+    }
+
+    public List<String> getRange(double min, double max, int count, boolean remove) {
+        List<String> result = delegate.getRange(getKey(), min, max, count, remove);
+        return result != null ? result : List.of();
+    }
+}

lib-data-range-redis/src/main/java/io/seqera/data/range/RangeStore.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2025, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package io.seqera.data.range;
+
+import java.util.List;
+
+/**
+ * Define the contract for a storage range set similar to Redis {@code zrange}
+ *
+ * @author Paolo Di Tommaso <paolo.ditommaso@gmail.com>
+ */
+public interface RangeStore {
+
+    void add(String member, double score);
+
+    List<String> getRange(double min, double max, int count);
+}

lib-data-range-redis/src/main/java/io/seqera/data/range/impl/LocalRangeProvider.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2025, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package io.seqera.data.range.impl;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import io.micronaut.context.annotation.Requires;
+import jakarta.inject.Singleton;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Local based implementation for a range set
+ *
+ * @author Paolo Di Tommaso <paolo.ditommaso@gmail.com>
+ */
+@Requires(missingProperty = "redis.uri")
+@Singleton
+public class LocalRangeProvider implements RangeProvider {
+
+    private static final Logger log = LoggerFactory.getLogger(LocalRangeProvider.class);
+
+    private final Map<String, Map<String, Double>> store = new HashMap<>();
+
+    @Override
+    public void add(String key, String element, double score) {
+        Map<String, Double> map = store.computeIfAbsent(key, k -> new HashMap<>());
+        map.put(element, score);
+        log.trace("* add range - store: {}", store);
+    }
+
+    @Override
+    public List<String> getRange(String key, double min, double max, int count, boolean remove) {
+        Map<String, Double> map = store.getOrDefault(key, new HashMap<>());
+        List<String> result = new ArrayList<>();
+
+        // Sort entries by value and iterate
+        List<Map.Entry<String, Double>> sortedEntries = new ArrayList<>(map.entrySet());
+        sortedEntries.sort(Map.Entry.comparingByValue());
+
+        List<String> toRemove = new ArrayList<>();
+        for (Map.Entry<String, Double> entry : sortedEntries) {
+            if (result.size() >= count) {
+                break;
+            }
+            if (entry.getValue() >= min && entry.getValue() <= max) {
+                result.add(entry.getKey());
+                if (remove) {
+                    toRemove.add(entry.getKey());
+                }
+            }
+        }
+
+        // Remove after iteration to avoid ConcurrentModificationException
+        for (String k : toRemove) {
+            map.remove(k);
+        }
+
+        log.trace("* get range result={} - store: {}", result, store);
+        return result;
+    }
+}