redis
logger.debug("Created RedlockCountDownLatch {} with count {}", latchKey, count);
}
-
+
/**
* Causes the current thread to wait until the latch has counted down to zero.
*
- * If the current count is zero then this method returns immediately.
+ *
+ * If the current count is zero then this method returns immediately.
+ *
*
- * If the current count is greater than zero then the current thread becomes
- * disabled for thread scheduling purposes and lies dormant until the count reaches
- * zero due to invocations of the {@link #countDown} method.
+ *
+ * If the current count is greater than zero then the current thread becomes disabled for thread scheduling purposes
+ * and lies dormant until the count reaches zero due to invocations of the {@link #countDown} method.
+ *
*
- * @throws InterruptedException if the current thread is interrupted while waiting
+ * @throws InterruptedException
+ * if the current thread is interrupted while waiting
*/
public void await() throws InterruptedException {
await(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
}
-
+
/**
- * Causes the current thread to wait until the latch has counted down to zero,
- * unless the specified waiting time elapses.
+ * Causes the current thread to wait until the latch has counted down to zero, unless the specified waiting time
+ * elapses.
*
- * @param timeout the maximum time to wait
- * @param unit the time unit of the timeout
+ * @param timeout
+ * the maximum time to wait
+ * @param unit
+ * the time unit of the timeout
* @return true if the count reached zero, false if the timeout elapsed
- * @throws InterruptedException if the current thread is interrupted while waiting
+ * @throws InterruptedException
+ * if the current thread is interrupted while waiting
*/
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
// Subscribe to notifications if not already subscribed
@@ -165,14 +166,18 @@ public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
return completed;
}
-
+
/**
* Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
*
- * If the current count is greater than zero then it is decremented. If the new count is
- * zero then all waiting threads are re-enabled for thread scheduling purposes.
+ *
+ * If the current count is greater than zero then it is decremented. If the new count is zero then all waiting
+ * threads are re-enabled for thread scheduling purposes.
+ *
*
- * If the current count equals zero then nothing happens.
+ *
+ * If the current count equals zero then nothing happens.
+ *
*/
public void countDown() {
// Decrement the count atomically using Redis DECR
@@ -186,11 +191,9 @@ public void countDown() {
newCount = count;
successfulNodes++;
- logger.debug("Decremented latch {} count to {} on {}",
- latchKey, count, driver.getIdentifier());
+ logger.debug("Decremented latch {} count to {} on {}", latchKey, count, driver.getIdentifier());
} catch (Exception e) {
- logger.debug("Failed to decrement latch count on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.debug("Failed to decrement latch count on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
@@ -205,11 +208,13 @@ public void countDown() {
logger.warn("Failed to decrement latch {} count on quorum of nodes", latchKey);
}
}
-
+
/**
* Returns the current count.
*
- * This method is typically used for debugging and testing purposes.
+ *
+ * This method is typically used for debugging and testing purposes.
+ *
*
* @return the current count
*/
@@ -227,8 +232,7 @@ public long getCount() {
successfulReads++;
}
} catch (Exception e) {
- logger.debug("Failed to read latch count from {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.debug("Failed to read latch count from {}: {}", driver.getIdentifier(), e.getMessage());
}
}
@@ -241,7 +245,7 @@ public long getCount() {
logger.warn("Failed to read latch {} count from quorum of nodes", latchKey);
return 0; // Conservative fallback - assume completed
}
-
+
/**
* Initializes the latch count in Redis.
*/
@@ -255,17 +259,16 @@ private void initializeLatch(int count) {
driver.setex(latchKey, countValue, config.getDefaultLockTimeoutMs() * 10);
successfulNodes++;
} catch (Exception e) {
- logger.warn("Failed to initialize latch on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.warn("Failed to initialize latch on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
if (successfulNodes < config.getQuorum()) {
- logger.warn("Failed to initialize latch {} on quorum of nodes (only {} of {} succeeded)",
- latchKey, successfulNodes, redisDrivers.size());
+ logger.warn("Failed to initialize latch {} on quorum of nodes (only {} of {} succeeded)", latchKey,
+ successfulNodes, redisDrivers.size());
} else {
- logger.debug("Successfully initialized latch {} with count {} on {} nodes",
- latchKey, count, successfulNodes);
+ logger.debug("Successfully initialized latch {} with count {} on {} nodes", latchKey, count,
+ successfulNodes);
}
}
@@ -313,23 +316,26 @@ private void publishZeroNotification() {
for (RedisDriver driver : redisDrivers) {
try {
long subscribers = driver.publish(channelKey, "zero");
- logger.debug("Published zero notification for latch {} to {} subscribers on {}",
- latchKey, subscribers, driver.getIdentifier());
+ logger.debug("Published zero notification for latch {} to {} subscribers on {}", latchKey, subscribers,
+ driver.getIdentifier());
} catch (Exception e) {
- logger.debug("Failed to publish zero notification on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.debug("Failed to publish zero notification on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
}
-
+
/**
* Resets the latch to its initial count.
*
- * Warning: This is not part of the standard CountDownLatch API and should be
- * used with caution. It's provided for scenarios where you need to reuse a latch.
+ *
+ * Warning: This is not part of the standard CountDownLatch API and should be used with caution. It's
+ * provided for scenarios where you need to reuse a latch.
+ *
*
- * This operation is not atomic and may lead to race conditions if called while
- * other threads are waiting or counting down.
+ *
+ * This operation is not atomic and may lead to race conditions if called while other threads are waiting or
+ * counting down.
+ *
*/
public void reset() {
logger.debug("Resetting latch {} to initial count {}", latchKey, initialCount);
@@ -339,8 +345,7 @@ public void reset() {
try {
driver.del(latchKey);
} catch (Exception e) {
- logger.warn("Failed to delete latch on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.warn("Failed to delete latch on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
@@ -351,12 +356,14 @@ public void reset() {
// Reinitialize with the original count
initializeLatch(initialCount);
}
-
+
/**
* Queries if any threads are waiting on this latch.
*
- * Note: In a distributed environment, this is an approximation and may not be
- * accurate due to network delays and the distributed nature of the system.
+ *
+ * Note: In a distributed environment, this is an approximation and may not be accurate due to network delays and
+ * the distributed nature of the system.
+ *
*
* @return true if there may be threads waiting, false otherwise
*/
@@ -365,14 +372,10 @@ public boolean hasQueuedThreads() {
// Return true if count > 0 as a heuristic
return getCount() > 0;
}
-
+
@Override
public String toString() {
- return "RedlockCountDownLatch{" +
- "latchKey='" + latchKey + '\'' +
- ", count=" + getCount() +
- ", initialCount=" + initialCount +
- '}';
+ return "RedlockCountDownLatch{" + "latchKey='" + latchKey + '\'' + ", count=" + getCount() + ", initialCount="
+ + initialCount + '}';
}
}
-
diff --git a/src/main/java/org/codarama/redlock4j/RedlockException.java b/src/main/java/org/codarama/redlock4j/RedlockException.java
index bf712ff..62cf0f0 100644
--- a/src/main/java/org/codarama/redlock4j/RedlockException.java
+++ b/src/main/java/org/codarama/redlock4j/RedlockException.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -27,15 +8,15 @@
* Exception thrown by Redlock operations.
*/
public class RedlockException extends RuntimeException {
-
+
public RedlockException(String message) {
super(message);
}
-
+
public RedlockException(String message, Throwable cause) {
super(message, cause);
}
-
+
public RedlockException(Throwable cause) {
super(cause);
}
diff --git a/src/main/java/org/codarama/redlock4j/RedlockManager.java b/src/main/java/org/codarama/redlock4j/RedlockManager.java
index effde39..ddc1c11 100644
--- a/src/main/java/org/codarama/redlock4j/RedlockManager.java
+++ b/src/main/java/org/codarama/redlock4j/RedlockManager.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -46,38 +27,40 @@
*/
public class RedlockManager implements AutoCloseable {
private static final Logger logger = LoggerFactory.getLogger(RedlockManager.class);
-
+
public enum DriverType {
JEDIS, LETTUCE
}
-
+
private final RedlockConfiguration config;
private final List redisDrivers;
private final DriverType driverType;
private final ExecutorService executorService;
private final ScheduledExecutorService scheduledExecutorService;
private volatile boolean closed = false;
-
+
/**
* Creates a RedlockManager with Jedis drivers.
*
- * @param config the Redlock configuration
+ * @param config
+ * the Redlock configuration
* @return a new RedlockManager instance
*/
public static RedlockManager withJedis(RedlockConfiguration config) {
return new RedlockManager(config, DriverType.JEDIS);
}
-
+
/**
* Creates a RedlockManager with Lettuce drivers.
*
- * @param config the Redlock configuration
+ * @param config
+ * the Redlock configuration
* @return a new RedlockManager instance
*/
public static RedlockManager withLettuce(RedlockConfiguration config) {
return new RedlockManager(config, DriverType.LETTUCE);
}
-
+
private RedlockManager(RedlockConfiguration config, DriverType driverType) {
this.config = config;
this.driverType = driverType;
@@ -93,61 +76,62 @@ private RedlockManager(RedlockConfiguration config, DriverType driverType) {
return t;
});
- logger.info("Created RedlockManager with {} driver and {} Redis nodes",
- driverType, redisDrivers.size());
+ logger.info("Created RedlockManager with {} driver and {} Redis nodes", driverType, redisDrivers.size());
}
-
+
private List createDrivers() {
List drivers = new ArrayList<>();
-
+
for (RedisNodeConfiguration nodeConfig : config.getRedisNodes()) {
try {
RedisDriver driver;
switch (driverType) {
- case JEDIS:
+ case JEDIS :
driver = new JedisRedisDriver(nodeConfig);
break;
- case LETTUCE:
+ case LETTUCE :
driver = new LettuceRedisDriver(nodeConfig);
break;
- default:
+ default :
throw new IllegalArgumentException("Unsupported driver type: " + driverType);
}
-
+
// Test the connection
if (!driver.isConnected()) {
logger.warn("Failed to connect to Redis node: {}", driver.getIdentifier());
driver.close();
continue;
}
-
+
drivers.add(driver);
logger.debug("Successfully connected to Redis node: {}", driver.getIdentifier());
-
+
} catch (Exception e) {
- logger.error("Failed to create driver for Redis node {}:{}",
- nodeConfig.getHost(), nodeConfig.getPort(), e);
+ logger.error("Failed to create driver for Redis node {}:{}", nodeConfig.getHost(), nodeConfig.getPort(),
+ e);
}
}
-
+
if (drivers.isEmpty()) {
throw new RedlockException("Failed to connect to any Redis nodes");
}
-
+
if (drivers.size() < config.getQuorum()) {
- logger.warn("Connected to {} Redis nodes, but quorum requires {}. " +
- "Lock operations may fail.", drivers.size(), config.getQuorum());
+ logger.warn("Connected to {} Redis nodes, but quorum requires {}. " + "Lock operations may fail.",
+ drivers.size(), config.getQuorum());
}
-
+
return drivers;
}
-
+
/**
* Creates a new distributed lock for the given key.
*
- * @param lockKey the key to lock
+ * @param lockKey
+ * the key to lock
* @return a new Lock instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public Lock createLock(String lockKey) {
if (closed) {
@@ -164,9 +148,11 @@ public Lock createLock(String lockKey) {
/**
* Creates a new asynchronous distributed lock for the given key.
*
- * @param lockKey the key to lock
+ * @param lockKey
+ * the key to lock
* @return a new AsyncRedlock instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public AsyncRedlock createAsyncLock(String lockKey) {
if (closed) {
@@ -183,9 +169,11 @@ public AsyncRedlock createAsyncLock(String lockKey) {
/**
* Creates a new RxJava reactive distributed lock for the given key.
*
- * @param lockKey the key to lock
+ * @param lockKey
+ * the key to lock
* @return a new AsyncRedlockImpl instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public RxRedlock createRxLock(String lockKey) {
if (closed) {
@@ -200,12 +188,14 @@ public RxRedlock createRxLock(String lockKey) {
}
/**
- * Creates a comprehensive lock that implements both async and reactive interfaces.
- * This lock supports both CompletionStage and RxJava reactive types.
+ * Creates a comprehensive lock that implements both async and reactive interfaces. This lock supports both
+ * CompletionStage and RxJava reactive types.
*
- * @param lockKey the key to lock
+ * @param lockKey
+ * the key to lock
* @return a new lock instance implementing both AsyncRedlock and AsyncRedlockImpl
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public AsyncRedlockImpl createAsyncRxLock(String lockKey) {
if (closed) {
@@ -220,12 +210,13 @@ public AsyncRedlockImpl createAsyncRxLock(String lockKey) {
}
/**
- * Creates a new distributed fair lock for the given key.
- * Fair locks ensure FIFO ordering for lock acquisition.
+ * Creates a new distributed fair lock for the given key. Fair locks ensure FIFO ordering for lock acquisition.
*
- * @param lockKey the key to lock
+ * @param lockKey
+ * the key to lock
* @return a new FairLock instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public Lock createFairLock(String lockKey) {
if (closed) {
@@ -240,12 +231,14 @@ public Lock createFairLock(String lockKey) {
}
/**
- * Creates a new distributed multi-lock for the given keys.
- * Multi-locks allow atomic acquisition of multiple resources.
+ * Creates a new distributed multi-lock for the given keys. Multi-locks allow atomic acquisition of multiple
+ * resources.
*
- * @param lockKeys the keys to lock atomically
+ * @param lockKeys
+ * the keys to lock atomically
* @return a new MultiLock instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public Lock createMultiLock(List lockKeys) {
if (closed) {
@@ -260,12 +253,14 @@ public Lock createMultiLock(List lockKeys) {
}
/**
- * Creates a new distributed read-write lock for the given key.
- * Read-write locks allow multiple concurrent readers or a single exclusive writer.
+ * Creates a new distributed read-write lock for the given key. Read-write locks allow multiple concurrent readers
+ * or a single exclusive writer.
*
- * @param resourceKey the resource key
+ * @param resourceKey
+ * the resource key
* @return a new RedlockReadWriteLock instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public RedlockReadWriteLock createReadWriteLock(String resourceKey) {
if (closed) {
@@ -280,13 +275,16 @@ public RedlockReadWriteLock createReadWriteLock(String resourceKey) {
}
/**
- * Creates a new distributed semaphore with the specified number of permits.
- * Semaphores control concurrent access to a resource with multiple permits.
+ * Creates a new distributed semaphore with the specified number of permits. Semaphores control concurrent access to
+ * a resource with multiple permits.
*
- * @param semaphoreKey the semaphore key
- * @param permits the number of permits available
+ * @param semaphoreKey
+ * the semaphore key
+ * @param permits
+ * the number of permits available
* @return a new RedlockSemaphore instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public RedlockSemaphore createSemaphore(String semaphoreKey, int permits) {
if (closed) {
@@ -305,13 +303,16 @@ public RedlockSemaphore createSemaphore(String semaphoreKey, int permits) {
}
/**
- * Creates a new distributed countdown latch with the specified count.
- * Countdown latches allow threads to wait until a set of operations completes.
+ * Creates a new distributed countdown latch with the specified count. Countdown latches allow threads to wait until
+ * a set of operations completes.
*
- * @param latchKey the latch key
- * @param count the initial count
+ * @param latchKey
+ * the latch key
+ * @param count
+ * the initial count
* @return a new RedlockCountDownLatch instance
- * @throws RedlockException if the manager is closed
+ * @throws RedlockException
+ * if the manager is closed
*/
public RedlockCountDownLatch createCountDownLatch(String latchKey, int count) {
if (closed) {
@@ -338,7 +339,7 @@ public int getConnectedNodeCount() {
if (closed) {
return 0;
}
-
+
int connected = 0;
for (RedisDriver driver : redisDrivers) {
if (driver.isConnected()) {
@@ -347,7 +348,7 @@ public int getConnectedNodeCount() {
}
return connected;
}
-
+
/**
* Gets the required quorum size.
*
@@ -356,7 +357,7 @@ public int getConnectedNodeCount() {
public int getQuorum() {
return config.getQuorum();
}
-
+
/**
* Checks if the manager has enough connected nodes to potentially acquire locks.
*
@@ -365,7 +366,7 @@ public int getQuorum() {
public boolean isHealthy() {
return !closed && getConnectedNodeCount() >= getQuorum();
}
-
+
/**
* Gets the driver type being used.
*
@@ -374,7 +375,7 @@ public boolean isHealthy() {
public DriverType getDriverType() {
return driverType;
}
-
+
@Override
public void close() {
if (closed) {
diff --git a/src/main/java/org/codarama/redlock4j/RedlockReadWriteLock.java b/src/main/java/org/codarama/redlock4j/RedlockReadWriteLock.java
index af3dbab..73bc251 100644
--- a/src/main/java/org/codarama/redlock4j/RedlockReadWriteLock.java
+++ b/src/main/java/org/codarama/redlock4j/RedlockReadWriteLock.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -36,87 +17,95 @@
import java.util.concurrent.locks.ReadWriteLock;
/**
- * A distributed read-write lock implementation that allows multiple concurrent readers
- * or a single exclusive writer. This is useful for scenarios where reads are frequent
- * and writes are infrequent.
+ * A distributed read-write lock implementation that allows multiple concurrent readers or a single exclusive writer.
+ * This is useful for scenarios where reads are frequent and writes are infrequent.
*
- * Key Features:
+ *
+ * Key Features:
+ *
*
- * - Multiple readers can hold the lock simultaneously
- * - Writers have exclusive access (no readers or other writers)
- * - Readers are blocked while a writer holds the lock
- * - Writers are blocked while any readers or writers hold the lock
+ * - Multiple readers can hold the lock simultaneously
+ * - Writers have exclusive access (no readers or other writers)
+ * - Readers are blocked while a writer holds the lock
+ * - Writers are blocked while any readers or writers hold the lock
*
*
- * Implementation Details:
+ *
+ * Implementation Details:
+ *
*
- * - Uses Redis counters to track the number of active readers
- * - Uses a separate key for the write lock
- * - Readers increment/decrement the reader count atomically
- * - Writers must wait for reader count to reach zero
+ * - Uses Redis counters to track the number of active readers
+ * - Uses a separate key for the write lock
+ * - Readers increment/decrement the reader count atomically
+ * - Writers must wait for reader count to reach zero
*
*
- * Example Usage:
- * {@code
- * RedlockReadWriteLock rwLock = new RedlockReadWriteLock("resource", redisDrivers, config);
+ *
+ * Example Usage:
+ *
*
- * // Reading
- * rwLock.readLock().lock();
- * try {
- * // Multiple threads can read simultaneously
- * readData();
- * } finally {
- * rwLock.readLock().unlock();
- * }
+ *
+ * {
+ * @code
+ * RedlockReadWriteLock rwLock = new RedlockReadWriteLock("resource", redisDrivers, config);
+ *
+ * // Reading
+ * rwLock.readLock().lock();
+ * try {
+ * // Multiple threads can read simultaneously
+ * readData();
+ * } finally {
+ * rwLock.readLock().unlock();
+ * }
*
- * // Writing
- * rwLock.writeLock().lock();
- * try {
- * // Exclusive access for writing
- * writeData();
- * } finally {
- * rwLock.writeLock().unlock();
+ * // Writing
+ * rwLock.writeLock().lock();
+ * try {
+ * // Exclusive access for writing
+ * writeData();
+ * } finally {
+ * rwLock.writeLock().unlock();
+ * }
* }
- * }
+ *
*/
public class RedlockReadWriteLock implements ReadWriteLock {
private static final Logger logger = LoggerFactory.getLogger(RedlockReadWriteLock.class);
-
+
private final String resourceKey;
private final ReadLock readLock;
private final WriteLock writeLock;
-
- public RedlockReadWriteLock(String resourceKey, List redisDrivers,
- RedlockConfiguration config) {
+
+ public RedlockReadWriteLock(String resourceKey, List redisDrivers, RedlockConfiguration config) {
this.resourceKey = resourceKey;
this.readLock = new ReadLock(resourceKey, redisDrivers, config);
this.writeLock = new WriteLock(resourceKey, redisDrivers, config);
}
-
+
@Override
public Lock readLock() {
return readLock;
}
-
+
@Override
public Lock writeLock() {
return writeLock;
}
-
+
/**
* Read lock implementation that allows multiple concurrent readers.
*/
private static class ReadLock implements Lock {
private static final Logger logger = LoggerFactory.getLogger(ReadLock.class);
-
+
private final String readCountKey;
private final String writeLockKey;
private final List redisDrivers;
private final RedlockConfiguration config;
private final SecureRandom secureRandom;
-
+
private final ThreadLocal lockState = new ThreadLocal<>();
-
+
private static class LockState {
final String lockValue;
final long acquisitionTime;
@@ -142,7 +131,7 @@ int decrementHoldCount() {
return --holdCount;
}
}
-
+
ReadLock(String resourceKey, List redisDrivers, RedlockConfiguration config) {
this.readCountKey = resourceKey + ":readers";
this.writeLockKey = resourceKey + ":write";
@@ -150,7 +139,7 @@ int decrementHoldCount() {
this.config = config;
this.secureRandom = new SecureRandom();
}
-
+
@Override
public void lock() {
try {
@@ -162,14 +151,14 @@ public void lock() {
throw new RedlockException("Interrupted while acquiring read lock", e);
}
}
-
+
@Override
public void lockInterruptibly() throws InterruptedException {
if (!tryLock(config.getLockAcquisitionTimeoutMs(), TimeUnit.MILLISECONDS)) {
throw new RedlockException("Failed to acquire read lock within timeout");
}
}
-
+
@Override
public boolean tryLock() {
try {
@@ -179,7 +168,7 @@ public boolean tryLock() {
return false;
}
}
-
+
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
// Check if current thread already holds the lock (reentrancy)
@@ -203,8 +192,8 @@ public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
// Try to increment reader count
String lockValue = generateLockValue();
if (incrementReaderCount(lockValue)) {
- lockState.set(new LockState(lockValue, System.currentTimeMillis(),
- config.getDefaultLockTimeoutMs()));
+ lockState.set(
+ new LockState(lockValue, System.currentTimeMillis(), config.getDefaultLockTimeoutMs()));
logger.debug("Successfully acquired read lock on attempt {}", attempt + 1);
return true;
}
@@ -224,7 +213,7 @@ public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
-
+
@Override
public void unlock() {
LockState state = lockState.get();
@@ -245,7 +234,7 @@ public void unlock() {
lockState.remove();
logger.debug("Successfully released read lock");
}
-
+
private boolean isWriteLockHeld() {
// Check if write lock exists on a quorum of nodes using GET
int nodesWithoutWriteLock = 0;
@@ -256,8 +245,7 @@ private boolean isWriteLockHeld() {
nodesWithoutWriteLock++;
}
} catch (Exception e) {
- logger.debug("Failed to check write lock on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.debug("Failed to check write lock on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
// If a quorum of nodes don't have the write lock, it's not held
@@ -276,19 +264,16 @@ private boolean incrementReaderCount(String lockValue) {
// Set expiration on the counter key to prevent leaks
if (count == 1) {
// First reader, set expiration
- driver.setex(readCountKey, String.valueOf(count),
- config.getDefaultLockTimeoutMs() * 2);
+ driver.setex(readCountKey, String.valueOf(count), config.getDefaultLockTimeoutMs() * 2);
}
// Store the lock value for this reader
- driver.setex(readCountKey + ":" + lockValue, "1",
- config.getDefaultLockTimeoutMs());
+ driver.setex(readCountKey + ":" + lockValue, "1", config.getDefaultLockTimeoutMs());
successfulNodes++;
logger.debug("Incremented reader count to {} on {}", count, driver.getIdentifier());
} catch (Exception e) {
- logger.debug("Failed to increment reader count on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.debug("Failed to increment reader count on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
@@ -312,12 +297,11 @@ private void decrementReaderCount(String lockValue) {
logger.debug("Decremented reader count to {} on {}", count, driver.getIdentifier());
} catch (Exception e) {
- logger.warn("Failed to decrement reader count on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.warn("Failed to decrement reader count on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
}
-
+
private String generateLockValue() {
byte[] bytes = new byte[20];
secureRandom.nextBytes(bytes);
@@ -327,16 +311,16 @@ private String generateLockValue() {
}
return sb.toString();
}
-
+
@Override
public Condition newCondition() {
throw new UnsupportedOperationException("Conditions are not supported");
}
}
-
+
/**
- * Write lock implementation that provides exclusive access.
- * Writers must wait for all readers to finish before acquiring the lock.
+ * Write lock implementation that provides exclusive access. Writers must wait for all readers to finish before
+ * acquiring the lock.
*/
private static class WriteLock implements Lock {
private static final Logger logger = LoggerFactory.getLogger(WriteLock.class);
@@ -435,8 +419,7 @@ private boolean hasActiveReaders() {
nodesWithoutReaders++;
}
} catch (Exception e) {
- logger.debug("Failed to check reader count on {}: {}",
- driver.getIdentifier(), e.getMessage());
+ logger.debug("Failed to check reader count on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
@@ -445,4 +428,3 @@ private boolean hasActiveReaders() {
}
}
}
-
diff --git a/src/main/java/org/codarama/redlock4j/RedlockSemaphore.java b/src/main/java/org/codarama/redlock4j/RedlockSemaphore.java
index 98ae277..91818fa 100644
--- a/src/main/java/org/codarama/redlock4j/RedlockSemaphore.java
+++ b/src/main/java/org/codarama/redlock4j/RedlockSemaphore.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -34,53 +15,62 @@
import java.util.concurrent.TimeUnit;
/**
- * A distributed semaphore implementation that limits the number of concurrent accesses
- * to a shared resource. Unlike a lock which allows only one holder, a semaphore allows
- * a configurable number of permits.
+ * A distributed semaphore implementation that limits the number of concurrent accesses to a shared resource. Unlike a
+ * lock which allows only one holder, a semaphore allows a configurable number of permits.
*
- * Key Features:
+ *
+ * Key Features:
+ *
*
- * - Configurable number of permits
- * - Multiple threads can acquire permits simultaneously
- * - Blocks when no permits are available
- * - Automatic permit release on timeout
+ * - Configurable number of permits
+ * - Multiple threads can acquire permits simultaneously
+ * - Blocks when no permits are available
+ * - Automatic permit release on timeout
*
*
- * Use Cases:
+ *
+ * Use Cases:
+ *
*
- * - Rate limiting: Limit concurrent API calls
- * - Resource pooling: Limit concurrent database connections
- * - Throttling: Control concurrent access to expensive operations
+ * - Rate limiting: Limit concurrent API calls
+ * - Resource pooling: Limit concurrent database connections
+ * - Throttling: Control concurrent access to expensive operations
*
*
- * Example Usage:
- * {@code
- * // Create a semaphore with 5 permits
- * RedlockSemaphore semaphore = new RedlockSemaphore("api-limiter", 5, redisDrivers, config);
+ *
+ * Example Usage:
+ *
*
- * // Acquire a permit
- * if (semaphore.tryAcquire(5, TimeUnit.SECONDS)) {
- * try {
- * // Perform rate-limited operation
- * callExternalAPI();
- * } finally {
- * semaphore.release();
+ *
+ * {
+ * @code
+ * // Create a semaphore with 5 permits
+ * RedlockSemaphore semaphore = new RedlockSemaphore("api-limiter", 5, redisDrivers, config);
+ *
+ * // Acquire a permit
+ * if (semaphore.tryAcquire(5, TimeUnit.SECONDS)) {
+ * try {
+ * // Perform rate-limited operation
+ * callExternalAPI();
+ * } finally {
+ * semaphore.release();
+ * }
* }
* }
- * }
+ *
*/
public class RedlockSemaphore {
private static final Logger logger = LoggerFactory.getLogger(RedlockSemaphore.class);
-
+
private final String semaphoreKey;
private final int maxPermits;
private final List redisDrivers;
private final RedlockConfiguration config;
private final SecureRandom secureRandom;
-
+
// Thread-local storage for permit state
private final ThreadLocal permitState = new ThreadLocal<>();
-
+
private static class PermitState {
final List permitIds; // IDs of acquired permits
final long acquisitionTime;
@@ -96,54 +86,61 @@ boolean isValid() {
return System.currentTimeMillis() < acquisitionTime + validityTime;
}
}
-
+
/**
* Creates a new distributed semaphore.
*
- * @param semaphoreKey the key for this semaphore
- * @param maxPermits the maximum number of permits available
- * @param redisDrivers the Redis drivers to use
- * @param config the Redlock configuration
+ * @param semaphoreKey
+ * the key for this semaphore
+ * @param maxPermits
+ * the maximum number of permits available
+ * @param redisDrivers
+ * the Redis drivers to use
+ * @param config
+ * the Redlock configuration
*/
- public RedlockSemaphore(String semaphoreKey, int maxPermits, List redisDrivers,
- RedlockConfiguration config) {
+ public RedlockSemaphore(String semaphoreKey, int maxPermits, List redisDrivers,
+ RedlockConfiguration config) {
if (maxPermits <= 0) {
throw new IllegalArgumentException("Max permits must be positive");
}
-
+
this.semaphoreKey = semaphoreKey;
this.maxPermits = maxPermits;
this.redisDrivers = redisDrivers;
this.config = config;
this.secureRandom = new SecureRandom();
-
+
logger.debug("Created RedlockSemaphore {} with {} permits", semaphoreKey, maxPermits);
}
-
+
/**
* Acquires a permit, blocking until one is available.
*
- * @throws RedlockException if unable to acquire within the configured timeout
+ * @throws RedlockException
+ * if unable to acquire within the configured timeout
*/
public void acquire() throws InterruptedException {
if (!tryAcquire(config.getLockAcquisitionTimeoutMs(), TimeUnit.MILLISECONDS)) {
throw new RedlockException("Failed to acquire semaphore permit within timeout: " + semaphoreKey);
}
}
-
+
/**
* Acquires the specified number of permits, blocking until they are available.
*
- * @param permits the number of permits to acquire
- * @throws RedlockException if unable to acquire within the configured timeout
+ * @param permits
+ * the number of permits to acquire
+ * @throws RedlockException
+ * if unable to acquire within the configured timeout
*/
public void acquire(int permits) throws InterruptedException {
if (!tryAcquire(permits, config.getLockAcquisitionTimeoutMs(), TimeUnit.MILLISECONDS)) {
- throw new RedlockException("Failed to acquire " + permits + " semaphore permits within timeout: "
- + semaphoreKey);
+ throw new RedlockException(
+ "Failed to acquire " + permits + " semaphore permits within timeout: " + semaphoreKey);
}
}
-
+
/**
* Acquires a permit if one is immediately available.
*
@@ -157,31 +154,36 @@ public boolean tryAcquire() {
return false;
}
}
-
+
/**
* Acquires a permit, waiting up to the specified time if necessary.
*
- * @param timeout the maximum time to wait
- * @param unit the time unit of the timeout
+ * @param timeout
+ * the maximum time to wait
+ * @param unit
+ * the time unit of the timeout
* @return true if a permit was acquired, false if the timeout elapsed
*/
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
return tryAcquire(1, timeout, unit);
}
-
+
/**
* Acquires the specified number of permits, waiting up to the specified time if necessary.
*
- * @param permits the number of permits to acquire
- * @param timeout the maximum time to wait
- * @param unit the time unit of the timeout
+ * @param permits
+ * the number of permits to acquire
+ * @param timeout
+ * the maximum time to wait
+ * @param unit
+ * the time unit of the timeout
* @return true if the permits were acquired, false if the timeout elapsed
*/
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException {
if (permits <= 0 || permits > maxPermits) {
throw new IllegalArgumentException("Invalid number of permits: " + permits);
}
-
+
// Check if current thread already has permits
PermitState currentState = permitState.get();
if (currentState != null && currentState.isValid()) {
@@ -199,10 +201,10 @@ public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws Inter
SemaphoreResult result = attemptAcquire(permits);
if (result.isAcquired()) {
- permitState.set(new PermitState(result.getPermitIds(), System.currentTimeMillis(),
- result.getValidityTimeMs()));
- logger.debug("Successfully acquired {} permit(s) for {} on attempt {}",
- permits, semaphoreKey, attempt + 1);
+ permitState.set(
+ new PermitState(result.getPermitIds(), System.currentTimeMillis(), result.getValidityTimeMs()));
+ logger.debug("Successfully acquired {} permit(s) for {} on attempt {}", permits, semaphoreKey,
+ attempt + 1);
return true;
}
@@ -220,18 +222,19 @@ public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws Inter
return false;
}
-
+
/**
* Releases a permit, returning it to the semaphore.
*/
public void release() {
release(1);
}
-
+
/**
* Releases the specified number of permits.
*
- * @param permits the number of permits to release
+ * @param permits
+ * the number of permits to release
*/
public void release(int permits) {
PermitState state = permitState.get();
@@ -248,39 +251,39 @@ public void release(int permits) {
// Release the specified number of permits
List toRelease = state.permitIds.subList(0, permits);
releasePermits(toRelease);
-
+
// Update or clear state
if (permits >= state.permitIds.size()) {
permitState.remove();
} else {
state.permitIds.subList(0, permits).clear();
}
-
+
logger.debug("Successfully released {} permit(s) for {}", permits, semaphoreKey);
}
-
+
/**
- * Returns the number of permits currently available (approximate).
- * Note: This is an estimate and may not be accurate in a distributed environment.
+ * Returns the number of permits currently available (approximate). Note: This is an estimate and may not be
+ * accurate in a distributed environment.
*/
public int availablePermits() {
// Note: This would require counting active permits across all nodes
// For now, return a placeholder
return maxPermits;
}
-
+
/**
* Attempts to acquire the specified number of permits.
*/
private SemaphoreResult attemptAcquire(int permits) {
List permitIds = new ArrayList<>();
long startTime = System.currentTimeMillis();
-
+
// Try to acquire permits by creating unique keys
for (int i = 0; i < permits; i++) {
String permitId = generatePermitId();
String permitKey = semaphoreKey + ":permit:" + permitId;
-
+
int successfulNodes = 0;
for (RedisDriver driver : redisDrivers) {
try {
@@ -291,7 +294,7 @@ private SemaphoreResult attemptAcquire(int permits) {
logger.debug("Failed to acquire permit on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
-
+
if (successfulNodes >= config.getQuorum()) {
permitIds.add(permitId);
} else {
@@ -300,21 +303,21 @@ private SemaphoreResult attemptAcquire(int permits) {
return new SemaphoreResult(false, 0, new ArrayList<>());
}
}
-
+
long elapsedTime = System.currentTimeMillis() - startTime;
long driftTime = (long) (config.getDefaultLockTimeoutMs() * config.getClockDriftFactor()) + 2;
long validityTime = config.getDefaultLockTimeoutMs() - elapsedTime - driftTime;
-
+
boolean acquired = permitIds.size() == permits && validityTime > 0;
-
+
if (!acquired) {
releasePermits(permitIds);
return new SemaphoreResult(false, 0, new ArrayList<>());
}
-
+
return new SemaphoreResult(true, validityTime, permitIds);
}
-
+
/**
* Releases the specified permits.
*/
@@ -325,13 +328,13 @@ private void releasePermits(List permitIds) {
try {
driver.deleteIfValueMatches(permitKey, permitId);
} catch (Exception e) {
- logger.warn("Failed to release permit {} on {}: {}",
- permitId, driver.getIdentifier(), e.getMessage());
+ logger.warn("Failed to release permit {} on {}: {}", permitId, driver.getIdentifier(),
+ e.getMessage());
}
}
}
}
-
+
private String generatePermitId() {
byte[] bytes = new byte[16];
secureRandom.nextBytes(bytes);
@@ -341,7 +344,7 @@ private String generatePermitId() {
}
return sb.toString();
}
-
+
/**
* Result of a semaphore acquisition attempt.
*/
@@ -369,4 +372,3 @@ List getPermitIds() {
}
}
}
-
diff --git a/src/main/java/org/codarama/redlock4j/async/AsyncRedlock.java b/src/main/java/org/codarama/redlock4j/async/AsyncRedlock.java
index c3037d2..511d2fe 100644
--- a/src/main/java/org/codarama/redlock4j/async/AsyncRedlock.java
+++ b/src/main/java/org/codarama/redlock4j/async/AsyncRedlock.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.async;
@@ -29,58 +10,59 @@
import java.util.concurrent.CompletionStage;
/**
- * Asynchronous distributed lock interface using CompletionStage for non-blocking operations.
- * This interface provides async alternatives to the standard Lock interface methods.
+ * Asynchronous distributed lock interface using CompletionStage for non-blocking operations. This interface provides
+ * async alternatives to the standard Lock interface methods.
*/
public interface AsyncRedlock {
-
+
/**
* Attempts to acquire the lock asynchronously without waiting.
*
* @return a CompletionStage that completes with true if the lock was acquired, false otherwise
*/
CompletionStage tryLockAsync();
-
+
/**
* Attempts to acquire the lock asynchronously with a timeout.
*
- * @param timeout the maximum time to wait for the lock
+ * @param timeout
+ * the maximum time to wait for the lock
* @return a CompletionStage that completes with true if the lock was acquired within the timeout, false otherwise
*/
CompletionStage tryLockAsync(Duration timeout);
-
+
/**
- * Acquires the lock asynchronously, waiting if necessary until the lock becomes available
- * or the acquisition timeout is reached.
+ * Acquires the lock asynchronously, waiting if necessary until the lock becomes available or the acquisition
+ * timeout is reached.
*
* @return a CompletionStage that completes when the lock is acquired
- * @throws RedlockException if the lock cannot be acquired within the configured timeout
+ * @throws RedlockException
+ * if the lock cannot be acquired within the configured timeout
*/
CompletionStage lockAsync();
-
+
/**
* Releases the lock asynchronously.
*
* @return a CompletionStage that completes when the lock is released
*/
CompletionStage unlockAsync();
-
+
/**
- * Checks if the current thread holds this lock.
- * This is a synchronous operation as it only checks local state.
+ * Checks if the current thread holds this lock. This is a synchronous operation as it only checks local state.
*
* @return true if the current thread holds the lock and it's still valid
*/
boolean isHeldByCurrentThread();
-
+
/**
- * Gets the remaining validity time of the lock for the current thread.
- * This is a synchronous operation as it only checks local state.
+ * Gets the remaining validity time of the lock for the current thread. This is a synchronous operation as it only
+ * checks local state.
*
* @return remaining validity time in milliseconds, or 0 if not held or expired
*/
long getRemainingValidityTime();
-
+
/**
* Gets the lock key.
*
@@ -89,9 +71,8 @@ public interface AsyncRedlock {
String getLockKey();
/**
- * Gets the hold count for the async lock.
- * This indicates how many times the lock has been acquired.
- * This is a synchronous operation as it only checks local state.
+ * Gets the hold count for the async lock. This indicates how many times the lock has been acquired. This is a
+ * synchronous operation as it only checks local state.
*
* @return hold count, or 0 if not held
*/
@@ -100,24 +81,26 @@ public interface AsyncRedlock {
/**
* Extends the validity time of the lock asynchronously.
*
- * This method attempts to extend the lock on a quorum of Redis nodes using the same
- * lock value. The extension is only successful if:
+ * This method attempts to extend the lock on a quorum of Redis nodes using the same lock value. The extension is
+ * only successful if:
*
- * - The lock is currently held and valid
- * - The extension succeeds on at least a quorum (N/2+1) of nodes
- * - The new validity time (after accounting for clock drift) is positive
+ * - The lock is currently held and valid
+ * - The extension succeeds on at least a quorum (N/2+1) of nodes
+ * - The new validity time (after accounting for clock drift) is positive
*
*
* Important limitations:
*
- * - Lock extension is for efficiency, not correctness
- * - Does not solve the GC pause problem - use fencing tokens for correctness
- * - Should not be used as a substitute for proper timeout configuration
+ * - Lock extension is for efficiency, not correctness
+ * - Does not solve the GC pause problem - use fencing tokens for correctness
+ * - Should not be used as a substitute for proper timeout configuration
*
*
- * @param additionalTime additional time to extend the lock
+ * @param additionalTime
+ * additional time to extend the lock
* @return a CompletionStage that completes with true if the lock was successfully extended, false otherwise
- * @throws IllegalArgumentException if additionalTime is negative or zero
+ * @throws IllegalArgumentException
+ * if additionalTime is negative or zero
*/
CompletionStage extendAsync(Duration additionalTime);
}
diff --git a/src/main/java/org/codarama/redlock4j/async/AsyncRedlockImpl.java b/src/main/java/org/codarama/redlock4j/async/AsyncRedlockImpl.java
index e072923..35ea450 100644
--- a/src/main/java/org/codarama/redlock4j/async/AsyncRedlockImpl.java
+++ b/src/main/java/org/codarama/redlock4j/async/AsyncRedlockImpl.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.async;
@@ -42,25 +23,25 @@
import java.util.concurrent.*;
/**
- * Implementation supporting both AsyncRedlock and AsyncRedlockImpl interfaces.
- * Provides asynchronous CompletionStage and RxJava reactive capabilities.
+ * Implementation supporting both AsyncRedlock and AsyncRedlockImpl interfaces. Provides asynchronous CompletionStage
+ * and RxJava reactive capabilities.
*/
public class AsyncRedlockImpl implements AsyncRedlock, RxRedlock {
private static final Logger logger = LoggerFactory.getLogger(AsyncRedlockImpl.class);
-
+
private final String lockKey;
private final List redisDrivers;
private final RedlockConfiguration config;
private final SecureRandom secureRandom;
private final ExecutorService executorService;
private final ScheduledExecutorService scheduledExecutorService;
-
+
// Shared lock state for async operations (not thread-local)
private volatile LockStateInfo lockState;
// RxJava subject for lock state changes
private final BehaviorSubject lockStateSubject = BehaviorSubject.createDefault(LockState.RELEASED);
-
+
private static class LockStateInfo {
final String lockValue;
final long acquisitionTime;
@@ -86,10 +67,9 @@ synchronized int decrementHoldCount() {
return --holdCount;
}
}
-
- public AsyncRedlockImpl(String lockKey, List redisDrivers,
- RedlockConfiguration config, ExecutorService executorService,
- ScheduledExecutorService scheduledExecutorService) {
+
+ public AsyncRedlockImpl(String lockKey, List redisDrivers, RedlockConfiguration config,
+ ExecutorService executorService, ScheduledExecutorService scheduledExecutorService) {
this.lockKey = lockKey;
this.redisDrivers = redisDrivers;
this.config = config;
@@ -97,9 +77,9 @@ public AsyncRedlockImpl(String lockKey, List redisDrivers,
this.executorService = executorService;
this.scheduledExecutorService = scheduledExecutorService;
}
-
+
// AsyncRedlock implementation (CompletionStage)
-
+
@Override
public CompletionStage tryLockAsync() {
return CompletableFuture.supplyAsync(() -> {
@@ -108,14 +88,16 @@ public CompletionStage tryLockAsync() {
LockStateInfo currentState = lockState;
if (currentState != null && currentState.isValid()) {
currentState.incrementHoldCount();
- logger.debug("Reentrant async lock acquisition for {} (hold count: {})", lockKey, currentState.holdCount);
+ logger.debug("Reentrant async lock acquisition for {} (hold count: {})", lockKey,
+ currentState.holdCount);
return true;
}
lockStateSubject.onNext(LockState.ACQUIRING);
LockResult result = attemptLock();
if (result.isAcquired()) {
- lockState = new LockStateInfo(result.getLockValue(), System.currentTimeMillis(), result.getValidityTimeMs());
+ lockState = new LockStateInfo(result.getLockValue(), System.currentTimeMillis(),
+ result.getValidityTimeMs());
lockStateSubject.onNext(LockState.ACQUIRED);
logger.debug("Successfully acquired async lock {}", lockKey);
return true;
@@ -130,7 +112,7 @@ public CompletionStage tryLockAsync() {
}
}, executorService);
}
-
+
@Override
public CompletionStage tryLockAsync(Duration timeout) {
long timeoutMs = timeout.toMillis();
@@ -138,57 +120,55 @@ public CompletionStage tryLockAsync(Duration timeout) {
return tryLockWithRetryAsync(timeoutMs, startTime, 0);
}
-
+
private CompletionStage tryLockWithRetryAsync(long timeoutMs, long startTime, int attempt) {
return tryLockAsync().thenCompose(acquired -> {
if (acquired) {
return CompletableFuture.completedFuture(true);
}
-
+
// Check timeout
if (timeoutMs > 0 && (System.currentTimeMillis() - startTime) >= timeoutMs) {
return CompletableFuture.completedFuture(false);
}
-
+
// Check max attempts
if (attempt >= config.getMaxRetryAttempts()) {
return CompletableFuture.completedFuture(false);
}
-
+
// Schedule retry with delay
long delay = config.getRetryDelayMs() + ThreadLocalRandom.current().nextLong(config.getRetryDelayMs());
-
+
CompletableFuture future = new CompletableFuture<>();
scheduledExecutorService.schedule(() -> {
- tryLockWithRetryAsync(timeoutMs, startTime, attempt + 1)
- .whenComplete((result, throwable) -> {
- if (throwable != null) {
- future.completeExceptionally(throwable);
- } else {
- future.complete(result);
- }
- });
+ tryLockWithRetryAsync(timeoutMs, startTime, attempt + 1).whenComplete((result, throwable) -> {
+ if (throwable != null) {
+ future.completeExceptionally(throwable);
+ } else {
+ future.complete(result);
+ }
+ });
}, delay, TimeUnit.MILLISECONDS);
-
+
return future;
});
}
-
+
@Override
public CompletionStage lockAsync() {
- return tryLockAsync(Duration.ofMillis(config.getLockAcquisitionTimeoutMs()))
- .thenCompose(acquired -> {
- if (acquired) {
- return CompletableFuture.completedFuture(null);
- } else {
- CompletableFuture failedFuture = new CompletableFuture<>();
- failedFuture.completeExceptionally(
+ return tryLockAsync(Duration.ofMillis(config.getLockAcquisitionTimeoutMs())).thenCompose(acquired -> {
+ if (acquired) {
+ return CompletableFuture.completedFuture(null);
+ } else {
+ CompletableFuture failedFuture = new CompletableFuture<>();
+ failedFuture.completeExceptionally(
new RedlockException("Failed to acquire lock within timeout: " + lockKey));
- return failedFuture;
- }
- });
+ return failedFuture;
+ }
+ });
}
-
+
@Override
public CompletionStage unlockAsync() {
return CompletableFuture.runAsync(() -> {
@@ -219,47 +199,40 @@ public CompletionStage unlockAsync() {
logger.debug("Successfully released async lock {}", lockKey);
}, executorService);
}
-
+
// AsyncRedlockImpl implementation (RxJava)
-
+
@Override
public Single tryLockRx() {
- return Single.fromCompletionStage(tryLockAsync())
- .subscribeOn(Schedulers.io());
+ return Single.fromCompletionStage(tryLockAsync()).subscribeOn(Schedulers.io());
}
-
+
@Override
public Single tryLockRx(Duration timeout) {
- return Single.fromCompletionStage(tryLockAsync(timeout))
- .subscribeOn(Schedulers.io());
+ return Single.fromCompletionStage(tryLockAsync(timeout)).subscribeOn(Schedulers.io());
}
-
+
@Override
public Completable lockRx() {
- return Completable.fromCompletionStage(lockAsync())
- .subscribeOn(Schedulers.io());
+ return Completable.fromCompletionStage(lockAsync()).subscribeOn(Schedulers.io());
}
-
+
@Override
public Completable unlockRx() {
- return Completable.fromCompletionStage(unlockAsync())
- .subscribeOn(Schedulers.io());
+ return Completable.fromCompletionStage(unlockAsync()).subscribeOn(Schedulers.io());
}
-
+
@Override
public Observable validityObservable(Duration checkInterval) {
return Observable.interval(checkInterval.toMillis(), TimeUnit.MILLISECONDS, Schedulers.io())
- .map(tick -> getRemainingValidityTime())
- .takeWhile(validity -> validity > 0);
+ .map(tick -> getRemainingValidityTime()).takeWhile(validity -> validity > 0);
}
@Override
public Single tryLockWithRetryRx(int maxRetries, Duration retryDelay) {
- return tryLockRx()
- .retry(maxRetries)
- .delay(retryDelay.toMillis(), TimeUnit.MILLISECONDS);
+ return tryLockRx().retry(maxRetries).delay(retryDelay.toMillis(), TimeUnit.MILLISECONDS);
}
-
+
@Override
public Observable lockStateObservable() {
return lockStateSubject.distinctUntilChanged();
@@ -267,12 +240,11 @@ public Observable lockStateObservable() {
@Override
public Single extendRx(Duration additionalTime) {
- return Single.fromCompletionStage(extendAsync(additionalTime))
- .subscribeOn(Schedulers.io());
+ return Single.fromCompletionStage(extendAsync(additionalTime)).subscribeOn(Schedulers.io());
}
// Common methods
-
+
@Override
public boolean isHeldByCurrentThread() {
LockStateInfo state = lockState;
@@ -288,15 +260,14 @@ public long getRemainingValidityTime() {
long remaining = state.acquisitionTime + state.validityTime - System.currentTimeMillis();
return Math.max(0, remaining);
}
-
+
@Override
public String getLockKey() {
return lockKey;
}
/**
- * Gets the hold count for the async lock.
- * This indicates how many times the lock has been acquired.
+ * Gets the hold count for the async lock. This indicates how many times the lock has been acquired.
*
* @return hold count, or 0 if not held
*/
@@ -345,14 +316,15 @@ public CompletionStage extendAsync(Duration additionalTime) {
if (extended) {
// Update lock state with new validity time
- LockStateInfo newState = new LockStateInfo(state.lockValue, System.currentTimeMillis(), newValidityTime);
+ LockStateInfo newState = new LockStateInfo(state.lockValue, System.currentTimeMillis(),
+ newValidityTime);
newState.holdCount = state.holdCount; // Preserve hold count
lockState = newState;
- logger.debug("Successfully extended async lock {} on {}/{} nodes (new validity: {}ms)",
- lockKey, successfulNodes, redisDrivers.size(), newValidityTime);
+ logger.debug("Successfully extended async lock {} on {}/{} nodes (new validity: {}ms)", lockKey,
+ successfulNodes, redisDrivers.size(), newValidityTime);
} else {
- logger.debug("Failed to extend async lock {} - only {}/{} nodes succeeded (quorum: {})",
- lockKey, successfulNodes, redisDrivers.size(), config.getQuorum());
+ logger.debug("Failed to extend async lock {} - only {}/{} nodes succeeded (quorum: {})", lockKey,
+ successfulNodes, redisDrivers.size(), config.getQuorum());
}
return extended;
@@ -360,12 +332,12 @@ public CompletionStage extendAsync(Duration additionalTime) {
}
// Private helper methods
-
+
private LockResult attemptLock() {
String lockValue = generateLockValue();
long startTime = System.currentTimeMillis();
int successfulNodes = 0;
-
+
// Try to acquire the lock on all nodes
for (RedisDriver driver : redisDrivers) {
try {
@@ -376,21 +348,21 @@ private LockResult attemptLock() {
logger.warn("Failed to acquire lock on {}: {}", driver.getIdentifier(), e.getMessage());
}
}
-
+
long elapsedTime = System.currentTimeMillis() - startTime;
long driftTime = (long) (config.getDefaultLockTimeoutMs() * config.getClockDriftFactor()) + 2;
long validityTime = config.getDefaultLockTimeoutMs() - elapsedTime - driftTime;
-
+
boolean acquired = successfulNodes >= config.getQuorum() && validityTime > 0;
-
+
if (!acquired) {
// Release any locks we managed to acquire
releaseLock(lockValue);
}
-
+
return new LockResult(acquired, validityTime, lockValue, successfulNodes, redisDrivers.size());
}
-
+
private void releaseLock(String lockValue) {
for (RedisDriver driver : redisDrivers) {
try {
@@ -400,7 +372,7 @@ private void releaseLock(String lockValue) {
}
}
}
-
+
private String generateLockValue() {
byte[] bytes = new byte[20];
secureRandom.nextBytes(bytes);
diff --git a/src/main/java/org/codarama/redlock4j/async/RxRedlock.java b/src/main/java/org/codarama/redlock4j/async/RxRedlock.java
index beaebae..d67d627 100644
--- a/src/main/java/org/codarama/redlock4j/async/RxRedlock.java
+++ b/src/main/java/org/codarama/redlock4j/async/RxRedlock.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.async;
@@ -29,84 +10,86 @@
import java.time.Duration;
/**
- * RxJava reactive distributed lock interface providing reactive streams for lock operations.
- * This interface uses RxJava 3 reactive types for maximum compatibility with reactive applications.
+ * RxJava reactive distributed lock interface providing reactive streams for lock operations. This interface uses RxJava
+ * 3 reactive types for maximum compatibility with reactive applications.
*/
public interface RxRedlock {
-
+
/**
* Attempts to acquire the lock reactively without waiting.
*
* @return a Single that emits true if the lock was acquired, false otherwise
*/
Single tryLockRx();
-
+
/**
* Attempts to acquire the lock reactively with a timeout.
*
- * @param timeout the maximum time to wait for the lock
+ * @param timeout
+ * the maximum time to wait for the lock
* @return a Single that emits true if the lock was acquired within the timeout, false otherwise
*/
Single tryLockRx(Duration timeout);
-
+
/**
- * Acquires the lock reactively, waiting if necessary until the lock becomes available
- * or the acquisition timeout is reached.
+ * Acquires the lock reactively, waiting if necessary until the lock becomes available or the acquisition timeout is
+ * reached.
*
* @return a Completable that completes when the lock is acquired
*/
Completable lockRx();
-
+
/**
* Releases the lock reactively.
*
* @return a Completable that completes when the lock is released
*/
Completable unlockRx();
-
+
/**
- * Creates a reactive stream that periodically emits the lock validity time.
- * Useful for monitoring lock health in reactive applications.
+ * Creates a reactive stream that periodically emits the lock validity time. Useful for monitoring lock health in
+ * reactive applications.
*
- * @param checkInterval the interval between validity checks
+ * @param checkInterval
+ * the interval between validity checks
* @return an Observable that emits the remaining validity time at each check
*/
Observable validityObservable(Duration checkInterval);
-
+
/**
- * Creates a reactive stream that emits lock acquisition attempts with retry logic.
- * This provides fine-grained control over retry behavior in reactive applications.
+ * Creates a reactive stream that emits lock acquisition attempts with retry logic. This provides fine-grained
+ * control over retry behavior in reactive applications.
*
- * @param maxRetries maximum number of retry attempts
- * @param retryDelay delay between retry attempts
+ * @param maxRetries
+ * maximum number of retry attempts
+ * @param retryDelay
+ * delay between retry attempts
* @return a Single that emits true when lock is acquired, or error if all retries fail
*/
Single tryLockWithRetryRx(int maxRetries, Duration retryDelay);
-
+
/**
- * Creates an observable that emits lock state changes.
- * Useful for monitoring when locks are acquired or released.
+ * Creates an observable that emits lock state changes. Useful for monitoring when locks are acquired or released.
*
* @return an Observable that emits LockState events
*/
Observable lockStateObservable();
-
+
/**
- * Checks if the current thread holds this lock.
- * This is a synchronous operation as it only checks local state.
+ * Checks if the current thread holds this lock. This is a synchronous operation as it only checks local state.
*
* @return true if the current thread holds the lock and it's still valid
*/
boolean isHeldByCurrentThread();
-
+
/**
- * Gets the remaining validity time of the lock for the current thread.
- * This is a synchronous operation as it only checks local state.
+ * Gets the remaining validity time of the lock for the current thread. This is a synchronous operation as it only
+ * checks local state.
*
* @return remaining validity time in milliseconds, or 0 if not held or expired
*/
long getRemainingValidityTime();
-
+
/**
* Gets the lock key.
*
@@ -115,9 +98,8 @@ public interface RxRedlock {
String getLockKey();
/**
- * Gets the hold count for the reactive lock.
- * This indicates how many times the lock has been acquired.
- * This is a synchronous operation as it only checks local state.
+ * Gets the hold count for the reactive lock. This indicates how many times the lock has been acquired. This is a
+ * synchronous operation as it only checks local state.
*
* @return hold count, or 0 if not held
*/
@@ -126,23 +108,25 @@ public interface RxRedlock {
/**
* Extends the validity time of the lock reactively.
*
- * This method attempts to extend the lock on a quorum of Redis nodes using the same
- * lock value. The extension is only successful if:
+ * This method attempts to extend the lock on a quorum of Redis nodes using the same lock value. The extension is
+ * only successful if:
*
- * - The lock is currently held and valid
- * - The extension succeeds on at least a quorum (N/2+1) of nodes
- * - The new validity time (after accounting for clock drift) is positive
+ * - The lock is currently held and valid
+ * - The extension succeeds on at least a quorum (N/2+1) of nodes
+ * - The new validity time (after accounting for clock drift) is positive
*
*
* Important limitations:
*
- * - Lock extension is for efficiency, not correctness
- * - Should not be used as a substitute for proper timeout configuration
+ * - Lock extension is for efficiency, not correctness
+ * - Should not be used as a substitute for proper timeout configuration
*
*
- * @param additionalTime additional time to extend the lock
+ * @param additionalTime
+ * additional time to extend the lock
* @return a Single that emits true if the lock was successfully extended, false otherwise
- * @throws IllegalArgumentException if additionalTime is negative or zero
+ * @throws IllegalArgumentException
+ * if additionalTime is negative or zero
*/
Single extendRx(Duration additionalTime);
@@ -150,10 +134,6 @@ public interface RxRedlock {
* Represents the state of a lock for reactive monitoring.
*/
enum LockState {
- ACQUIRING,
- ACQUIRED,
- RELEASED,
- EXPIRED,
- FAILED
+ ACQUIRING, ACQUIRED, RELEASED, EXPIRED, FAILED
}
}
diff --git a/src/main/java/org/codarama/redlock4j/configuration/RedisNodeConfiguration.java b/src/main/java/org/codarama/redlock4j/configuration/RedisNodeConfiguration.java
index 41387b2..107842a 100644
--- a/src/main/java/org/codarama/redlock4j/configuration/RedisNodeConfiguration.java
+++ b/src/main/java/org/codarama/redlock4j/configuration/RedisNodeConfiguration.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.configuration;
@@ -122,12 +103,7 @@ public RedisNodeConfiguration build() {
@Override
public String toString() {
- return "RedisNodeConfiguration{" +
- "host='" + host + '\'' +
- ", port=" + port +
- ", database=" + database +
- ", connectionTimeoutMs=" + connectionTimeoutMs +
- ", socketTimeoutMs=" + socketTimeoutMs +
- '}';
+ return "RedisNodeConfiguration{" + "host='" + host + '\'' + ", port=" + port + ", database=" + database
+ + ", connectionTimeoutMs=" + connectionTimeoutMs + ", socketTimeoutMs=" + socketTimeoutMs + '}';
}
}
diff --git a/src/main/java/org/codarama/redlock4j/configuration/RedlockConfiguration.java b/src/main/java/org/codarama/redlock4j/configuration/RedlockConfiguration.java
index 7ab16b0..f14bb53 100644
--- a/src/main/java/org/codarama/redlock4j/configuration/RedlockConfiguration.java
+++ b/src/main/java/org/codarama/redlock4j/configuration/RedlockConfiguration.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.configuration;
@@ -93,18 +74,11 @@ public Builder addRedisNode(RedisNodeConfiguration nodeConfig) {
}
public Builder addRedisNode(String host, int port) {
- return addRedisNode(RedisNodeConfiguration.builder()
- .host(host)
- .port(port)
- .build());
+ return addRedisNode(RedisNodeConfiguration.builder().host(host).port(port).build());
}
public Builder addRedisNode(String host, int port, String password) {
- return addRedisNode(RedisNodeConfiguration.builder()
- .host(host)
- .port(port)
- .password(password)
- .build());
+ return addRedisNode(RedisNodeConfiguration.builder().host(host).port(port).password(password).build());
}
public Builder defaultLockTimeout(Duration timeout) {
diff --git a/src/main/java/org/codarama/redlock4j/driver/JedisRedisDriver.java b/src/main/java/org/codarama/redlock4j/driver/JedisRedisDriver.java
index 920b119..28ca816 100644
--- a/src/main/java/org/codarama/redlock4j/driver/JedisRedisDriver.java
+++ b/src/main/java/org/codarama/redlock4j/driver/JedisRedisDriver.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.driver;
@@ -40,29 +21,23 @@
/**
* Jedis implementation of the RedisDriver interface with automatic CAS/CAD detection.
*
- * This driver automatically detects and uses the best available method for each operation:
+ *
+ * This driver automatically detects and uses the best available method for each operation:
*
- * - Native Redis 8.4+ CAS/CAD commands (DELEX, SET IFEQ) when available
- * - Lua script-based operations for older Redis versions
+ * - Native Redis 8.4+ CAS/CAD commands (DELEX, SET IFEQ) when available
+ * - Lua script-based operations for older Redis versions
*
- * Detection happens once at driver initialization.
+ * Detection happens once at driver initialization.
+ *
*/
public class JedisRedisDriver implements RedisDriver {
private static final Logger logger = LoggerFactory.getLogger(JedisRedisDriver.class);
- private static final String DELETE_IF_VALUE_MATCHES_SCRIPT =
- "if redis.call('get', KEYS[1]) == ARGV[1] then " +
- " return redis.call('del', KEYS[1]) " +
- "else " +
- " return 0 " +
- "end";
+ private static final String DELETE_IF_VALUE_MATCHES_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then "
+ + " return redis.call('del', KEYS[1]) " + "else " + " return 0 " + "end";
- private static final String SET_IF_VALUE_MATCHES_SCRIPT =
- "if redis.call('get', KEYS[1]) == ARGV[1] then " +
- " return redis.call('set', KEYS[1], ARGV[2], 'PX', ARGV[3]) " +
- "else " +
- " return nil " +
- "end";
+ private static final String SET_IF_VALUE_MATCHES_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then "
+ + " return redis.call('set', KEYS[1], ARGV[2], 'PX', ARGV[3]) " + "else " + " return nil " + "end";
/**
* Strategy for CAS/CAD operations.
@@ -77,7 +52,7 @@ private enum CADStrategy {
private final JedisPool jedisPool;
private final String identifier;
private final CADStrategy cadStrategy;
-
+
public JedisRedisDriver(RedisNodeConfiguration config) {
this.identifier = "redis://" + config.getHost() + ":" + config.getPort();
@@ -101,12 +76,8 @@ public JedisRedisDriver(RedisNodeConfiguration config) {
try {
java.net.URI redisUri = java.net.URI.create(uriBuilder.toString());
- this.jedisPool = new JedisPool(
- poolConfig,
- redisUri,
- config.getConnectionTimeoutMs(),
- config.getSocketTimeoutMs()
- );
+ this.jedisPool = new JedisPool(poolConfig, redisUri, config.getConnectionTimeoutMs(),
+ config.getSocketTimeoutMs());
} catch (Exception e) {
throw new RuntimeException("Failed to create Jedis pool for " + identifier, e);
}
@@ -119,26 +90,22 @@ public JedisRedisDriver(RedisNodeConfiguration config) {
}
/**
- * Detects whether native CAS/CAD commands are available.
- * This is called once during driver initialization.
+ * Detects whether native CAS/CAD commands are available. This is called once during driver initialization.
*/
private CADStrategy detectCADStrategy() {
try (Jedis jedis = jedisPool.getResource()) {
// Try to execute DELEX on a test key
String testKey = "__redlock4j_cad_test__" + System.currentTimeMillis();
- jedis.sendCommand(
- redis.clients.jedis.Protocol.Command.DELEX,
- testKey, "IFEQ", "test_value"
- );
+ jedis.sendCommand(redis.clients.jedis.Protocol.Command.DELEX, testKey, "IFEQ", "test_value");
logger.debug("Native CAS/CAD commands detected for {}", identifier);
return CADStrategy.NATIVE;
} catch (Exception e) {
- logger.debug("Native CAS/CAD commands not available for {}, using Lua scripts: {}",
- identifier, e.getMessage());
+ logger.debug("Native CAS/CAD commands not available for {}, using Lua scripts: {}", identifier,
+ e.getMessage());
return CADStrategy.SCRIPT;
}
}
-
+
@Override
public boolean setIfNotExists(String key, String value, long expireTimeMs) throws RedisDriverException {
try (Jedis jedis = jedisPool.getResource()) {
@@ -149,15 +116,15 @@ public boolean setIfNotExists(String key, String value, long expireTimeMs) throw
throw new RedisDriverException("Failed to execute SET NX PX command on " + identifier, e);
}
}
-
+
@Override
public boolean deleteIfValueMatches(String key, String expectedValue) throws RedisDriverException {
switch (cadStrategy) {
- case NATIVE:
+ case NATIVE :
return deleteIfValueMatchesNative(key, expectedValue);
- case SCRIPT:
+ case SCRIPT :
return deleteIfValueMatchesScript(key, expectedValue);
- default:
+ default :
throw new IllegalStateException("Unknown CAD strategy: " + cadStrategy);
}
}
@@ -167,10 +134,7 @@ public boolean deleteIfValueMatches(String key, String expectedValue) throws Red
*/
private boolean deleteIfValueMatchesNative(String key, String expectedValue) throws RedisDriverException {
try (Jedis jedis = jedisPool.getResource()) {
- Object result = jedis.sendCommand(
- redis.clients.jedis.Protocol.Command.DELEX,
- key, "IFEQ", expectedValue
- );
+ Object result = jedis.sendCommand(redis.clients.jedis.Protocol.Command.DELEX, key, "IFEQ", expectedValue);
return Long.valueOf(1).equals(result);
} catch (JedisException e) {
throw new RedisDriverException("Failed to execute DELEX command on " + identifier, e);
@@ -182,17 +146,14 @@ private boolean deleteIfValueMatchesNative(String key, String expectedValue) thr
*/
private boolean deleteIfValueMatchesScript(String key, String expectedValue) throws RedisDriverException {
try (Jedis jedis = jedisPool.getResource()) {
- Object result = jedis.eval(
- DELETE_IF_VALUE_MATCHES_SCRIPT,
- Collections.singletonList(key),
- Collections.singletonList(expectedValue)
- );
+ Object result = jedis.eval(DELETE_IF_VALUE_MATCHES_SCRIPT, Collections.singletonList(key),
+ Collections.singletonList(expectedValue));
return Long.valueOf(1).equals(result);
} catch (JedisException e) {
throw new RedisDriverException("Failed to execute delete script on " + identifier, e);
}
}
-
+
@Override
public boolean isConnected() {
try (Jedis jedis = jedisPool.getResource()) {
@@ -202,12 +163,12 @@ public boolean isConnected() {
return false;
}
}
-
+
@Override
public String getIdentifier() {
return identifier;
}
-
+
@Override
public void close() {
if (jedisPool != null && !jedisPool.isClosed()) {
@@ -217,14 +178,14 @@ public void close() {
}
@Override
- public boolean setIfValueMatches(String key, String newValue, String expectedCurrentValue,
- long expireTimeMs) throws RedisDriverException {
+ public boolean setIfValueMatches(String key, String newValue, String expectedCurrentValue, long expireTimeMs)
+ throws RedisDriverException {
switch (cadStrategy) {
- case NATIVE:
+ case NATIVE :
return setIfValueMatchesNative(key, newValue, expectedCurrentValue, expireTimeMs);
- case SCRIPT:
+ case SCRIPT :
return setIfValueMatchesScript(key, newValue, expectedCurrentValue, expireTimeMs);
- default:
+ default :
throw new IllegalStateException("Unknown CAD strategy: " + cadStrategy);
}
}
@@ -232,13 +193,11 @@ public boolean setIfValueMatches(String key, String newValue, String expectedCur
/**
* Sets a key using native SET IFEQ command (Redis 8.4+).
*/
- private boolean setIfValueMatchesNative(String key, String newValue, String expectedCurrentValue,
- long expireTimeMs) throws RedisDriverException {
+ private boolean setIfValueMatchesNative(String key, String newValue, String expectedCurrentValue, long expireTimeMs)
+ throws RedisDriverException {
try (Jedis jedis = jedisPool.getResource()) {
- Object result = jedis.sendCommand(
- redis.clients.jedis.Protocol.Command.SET,
- key, newValue, "IFEQ", expectedCurrentValue, "PX", String.valueOf(expireTimeMs)
- );
+ Object result = jedis.sendCommand(redis.clients.jedis.Protocol.Command.SET, key, newValue, "IFEQ",
+ expectedCurrentValue, "PX", String.valueOf(expireTimeMs));
return "OK".equals(result);
} catch (JedisException e) {
throw new RedisDriverException("Failed to execute SET IFEQ command on " + identifier, e);
@@ -248,14 +207,11 @@ private boolean setIfValueMatchesNative(String key, String newValue, String expe
/**
* Sets a key using Lua script (legacy compatibility).
*/
- private boolean setIfValueMatchesScript(String key, String newValue, String expectedCurrentValue,
- long expireTimeMs) throws RedisDriverException {
+ private boolean setIfValueMatchesScript(String key, String newValue, String expectedCurrentValue, long expireTimeMs)
+ throws RedisDriverException {
try (Jedis jedis = jedisPool.getResource()) {
- Object result = jedis.eval(
- SET_IF_VALUE_MATCHES_SCRIPT,
- Collections.singletonList(key),
- java.util.Arrays.asList(expectedCurrentValue, newValue, String.valueOf(expireTimeMs))
- );
+ Object result = jedis.eval(SET_IF_VALUE_MATCHES_SCRIPT, Collections.singletonList(key),
+ java.util.Arrays.asList(expectedCurrentValue, newValue, String.valueOf(expireTimeMs)));
return "OK".equals(result);
} catch (JedisException e) {
throw new RedisDriverException("Failed to execute SET script on " + identifier, e);
diff --git a/src/main/java/org/codarama/redlock4j/driver/LettuceRedisDriver.java b/src/main/java/org/codarama/redlock4j/driver/LettuceRedisDriver.java
index 34723fe..c1cb6ab 100644
--- a/src/main/java/org/codarama/redlock4j/driver/LettuceRedisDriver.java
+++ b/src/main/java/org/codarama/redlock4j/driver/LettuceRedisDriver.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.driver;
@@ -42,29 +23,23 @@
/**
* Lettuce implementation of the RedisDriver interface with automatic CAS/CAD detection.
*
- * This driver automatically detects and uses the best available method for each operation:
+ *
+ * This driver automatically detects and uses the best available method for each operation:
*
- * - Native Redis 8.4+ CAS/CAD commands (DELEX, SET IFEQ) when available
- * - Lua script-based operations for older Redis versions
+ * - Native Redis 8.4+ CAS/CAD commands (DELEX, SET IFEQ) when available
+ * - Lua script-based operations for older Redis versions
*
- * Detection happens once at driver initialization.
+ * Detection happens once at driver initialization.
+ *
*/
public class LettuceRedisDriver implements RedisDriver {
private static final Logger logger = LoggerFactory.getLogger(LettuceRedisDriver.class);
- private static final String DELETE_IF_VALUE_MATCHES_SCRIPT =
- "if redis.call('get', KEYS[1]) == ARGV[1] then " +
- " return redis.call('del', KEYS[1]) " +
- "else " +
- " return 0 " +
- "end";
+ private static final String DELETE_IF_VALUE_MATCHES_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then "
+ + " return redis.call('del', KEYS[1]) " + "else " + " return 0 " + "end";
- private static final String SET_IF_VALUE_MATCHES_SCRIPT =
- "if redis.call('get', KEYS[1]) == ARGV[1] then " +
- " return redis.call('set', KEYS[1], ARGV[2], 'PX', ARGV[3]) " +
- "else " +
- " return nil " +
- "end";
+ private static final String SET_IF_VALUE_MATCHES_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then "
+ + " return redis.call('set', KEYS[1], ARGV[2], 'PX', ARGV[3]) " + "else " + " return nil " + "end";
/**
* Strategy for CAS/CAD operations.
@@ -87,10 +62,8 @@ public LettuceRedisDriver(RedisNodeConfiguration config) {
}
// Package-private constructor for testing with dependency injection
- LettuceRedisDriver(RedisNodeConfiguration config,
- RedisClient redisClient,
- StatefulRedisConnection connection,
- RedisCommands commands) {
+ LettuceRedisDriver(RedisNodeConfiguration config, RedisClient redisClient,
+ StatefulRedisConnection connection, RedisCommands commands) {
this.identifier = "redis://" + config.getHost() + ":" + config.getPort();
if (redisClient != null && connection != null && commands != null) {
@@ -101,11 +74,8 @@ public LettuceRedisDriver(RedisNodeConfiguration config) {
logger.debug("Created Lettuce driver for {} with injected dependencies", identifier);
} else {
// Create real connections (production)
- RedisURI.Builder uriBuilder = RedisURI.builder()
- .withHost(config.getHost())
- .withPort(config.getPort())
- .withDatabase(config.getDatabase())
- .withTimeout(Duration.ofMillis(config.getConnectionTimeoutMs()));
+ RedisURI.Builder uriBuilder = RedisURI.builder().withHost(config.getHost()).withPort(config.getPort())
+ .withDatabase(config.getDatabase()).withTimeout(Duration.ofMillis(config.getConnectionTimeoutMs()));
if (config.getPassword() != null && !config.getPassword().trim().isEmpty()) {
uriBuilder.withPassword(config.getPassword().toCharArray());
@@ -129,30 +99,25 @@ public LettuceRedisDriver(RedisNodeConfiguration config) {
}
/**
- * Detects whether native CAS/CAD commands are available.
- * This is called once during driver initialization.
+ * Detects whether native CAS/CAD commands are available. This is called once during driver initialization.
*/
private CADStrategy detectCADStrategy() {
try {
// Try to execute DELEX on a test key
String testKey = "__redlock4j_cad_test__" + System.currentTimeMillis();
- commands.dispatch(
- io.lettuce.core.protocol.CommandType.DELEX,
- new io.lettuce.core.output.IntegerOutput<>(io.lettuce.core.codec.StringCodec.UTF8),
- new io.lettuce.core.protocol.CommandArgs<>(io.lettuce.core.codec.StringCodec.UTF8)
- .addKey(testKey)
- .add("IFEQ")
- .add("test_value")
- );
+ commands.dispatch(io.lettuce.core.protocol.CommandType.DELEX,
+ new io.lettuce.core.output.IntegerOutput<>(io.lettuce.core.codec.StringCodec.UTF8),
+ new io.lettuce.core.protocol.CommandArgs<>(io.lettuce.core.codec.StringCodec.UTF8).addKey(testKey)
+ .add("IFEQ").add("test_value"));
logger.debug("Native CAS/CAD commands detected for {}", identifier);
return CADStrategy.NATIVE;
} catch (Exception e) {
- logger.debug("Native CAS/CAD commands not available for {}, using Lua scripts: {}",
- identifier, e.getMessage());
+ logger.debug("Native CAS/CAD commands not available for {}, using Lua scripts: {}", identifier,
+ e.getMessage());
return CADStrategy.SCRIPT;
}
}
-
+
@Override
public boolean setIfNotExists(String key, String value, long expireTimeMs) throws RedisDriverException {
try {
@@ -163,15 +128,15 @@ public boolean setIfNotExists(String key, String value, long expireTimeMs) throw
throw new RedisDriverException("Failed to execute SET NX PX command on " + identifier, e);
}
}
-
+
@Override
public boolean deleteIfValueMatches(String key, String expectedValue) throws RedisDriverException {
switch (cadStrategy) {
- case NATIVE:
+ case NATIVE :
return deleteIfValueMatchesNative(key, expectedValue);
- case SCRIPT:
+ case SCRIPT :
return deleteIfValueMatchesScript(key, expectedValue);
- default:
+ default :
throw new IllegalStateException("Unknown CAD strategy: " + cadStrategy);
}
}
@@ -181,14 +146,10 @@ public boolean deleteIfValueMatches(String key, String expectedValue) throws Red
*/
private boolean deleteIfValueMatchesNative(String key, String expectedValue) throws RedisDriverException {
try {
- Object result = commands.dispatch(
- io.lettuce.core.protocol.CommandType.DELEX,
- new io.lettuce.core.output.IntegerOutput<>(io.lettuce.core.codec.StringCodec.UTF8),
- new io.lettuce.core.protocol.CommandArgs<>(io.lettuce.core.codec.StringCodec.UTF8)
- .addKey(key)
- .add("IFEQ")
- .add(expectedValue)
- );
+ Object result = commands.dispatch(io.lettuce.core.protocol.CommandType.DELEX,
+ new io.lettuce.core.output.IntegerOutput<>(io.lettuce.core.codec.StringCodec.UTF8),
+ new io.lettuce.core.protocol.CommandArgs<>(io.lettuce.core.codec.StringCodec.UTF8).addKey(key)
+ .add("IFEQ").add(expectedValue));
return Long.valueOf(1).equals(result);
} catch (Exception e) {
throw new RedisDriverException("Failed to execute DELEX command on " + identifier, e);
@@ -200,18 +161,14 @@ private boolean deleteIfValueMatchesNative(String key, String expectedValue) thr
*/
private boolean deleteIfValueMatchesScript(String key, String expectedValue) throws RedisDriverException {
try {
- Object result = commands.eval(
- DELETE_IF_VALUE_MATCHES_SCRIPT,
- io.lettuce.core.ScriptOutputType.INTEGER,
- new String[]{key},
- expectedValue
- );
+ Object result = commands.eval(DELETE_IF_VALUE_MATCHES_SCRIPT, io.lettuce.core.ScriptOutputType.INTEGER,
+ new String[]{key}, expectedValue);
return Long.valueOf(1).equals(result);
} catch (Exception e) {
throw new RedisDriverException("Failed to execute delete script on " + identifier, e);
}
}
-
+
@Override
public boolean isConnected() {
try {
@@ -221,12 +178,12 @@ public boolean isConnected() {
return false;
}
}
-
+
@Override
public String getIdentifier() {
return identifier;
}
-
+
@Override
public void close() {
try {
@@ -243,14 +200,14 @@ public void close() {
}
@Override
- public boolean setIfValueMatches(String key, String newValue, String expectedCurrentValue,
- long expireTimeMs) throws RedisDriverException {
+ public boolean setIfValueMatches(String key, String newValue, String expectedCurrentValue, long expireTimeMs)
+ throws RedisDriverException {
switch (cadStrategy) {
- case NATIVE:
+ case NATIVE :
return setIfValueMatchesNative(key, newValue, expectedCurrentValue, expireTimeMs);
- case SCRIPT:
+ case SCRIPT :
return setIfValueMatchesScript(key, newValue, expectedCurrentValue, expireTimeMs);
- default:
+ default :
throw new IllegalStateException("Unknown CAD strategy: " + cadStrategy);
}
}
@@ -258,20 +215,13 @@ public boolean setIfValueMatches(String key, String newValue, String expectedCur
/**
* Sets a key using native SET IFEQ command (Redis 8.4+).
*/
- private boolean setIfValueMatchesNative(String key, String newValue, String expectedCurrentValue,
- long expireTimeMs) throws RedisDriverException {
+ private boolean setIfValueMatchesNative(String key, String newValue, String expectedCurrentValue, long expireTimeMs)
+ throws RedisDriverException {
try {
- String result = commands.dispatch(
- io.lettuce.core.protocol.CommandType.SET,
- new io.lettuce.core.output.StatusOutput<>(io.lettuce.core.codec.StringCodec.UTF8),
- new io.lettuce.core.protocol.CommandArgs<>(io.lettuce.core.codec.StringCodec.UTF8)
- .addKey(key)
- .addValue(newValue)
- .add("IFEQ")
- .add(expectedCurrentValue)
- .add("PX")
- .add(expireTimeMs)
- );
+ String result = commands.dispatch(io.lettuce.core.protocol.CommandType.SET,
+ new io.lettuce.core.output.StatusOutput<>(io.lettuce.core.codec.StringCodec.UTF8),
+ new io.lettuce.core.protocol.CommandArgs<>(io.lettuce.core.codec.StringCodec.UTF8).addKey(key)
+ .addValue(newValue).add("IFEQ").add(expectedCurrentValue).add("PX").add(expireTimeMs));
return "OK".equals(result);
} catch (Exception e) {
throw new RedisDriverException("Failed to execute SET IFEQ command on " + identifier, e);
@@ -281,15 +231,11 @@ private boolean setIfValueMatchesNative(String key, String newValue, String expe
/**
* Sets a key using Lua script (legacy compatibility).
*/
- private boolean setIfValueMatchesScript(String key, String newValue, String expectedCurrentValue,
- long expireTimeMs) throws RedisDriverException {
+ private boolean setIfValueMatchesScript(String key, String newValue, String expectedCurrentValue, long expireTimeMs)
+ throws RedisDriverException {
try {
- Object result = commands.eval(
- SET_IF_VALUE_MATCHES_SCRIPT,
- io.lettuce.core.ScriptOutputType.STATUS,
- new String[]{key},
- expectedCurrentValue, newValue, String.valueOf(expireTimeMs)
- );
+ Object result = commands.eval(SET_IF_VALUE_MATCHES_SCRIPT, io.lettuce.core.ScriptOutputType.STATUS,
+ new String[]{key}, expectedCurrentValue, newValue, String.valueOf(expireTimeMs));
return "OK".equals(result);
} catch (Exception e) {
throw new RedisDriverException("Failed to execute SET script on " + identifier, e);
diff --git a/src/main/java/org/codarama/redlock4j/driver/RedisDriver.java b/src/main/java/org/codarama/redlock4j/driver/RedisDriver.java
index e14f949..cc4f50d 100644
--- a/src/main/java/org/codarama/redlock4j/driver/RedisDriver.java
+++ b/src/main/java/org/codarama/redlock4j/driver/RedisDriver.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.driver;
@@ -27,46 +8,55 @@
import java.util.Set;
/**
- * Abstraction over different Redis client libraries (Jedis, Lettuce).
- * Provides the minimal interface needed for implementing Redlock and advanced locking primitives.
+ * Abstraction over different Redis client libraries (Jedis, Lettuce). Provides the minimal interface needed for
+ * implementing Redlock and advanced locking primitives.
*
- * This interface automatically uses the best available implementation for each operation:
+ *
+ * This interface automatically uses the best available implementation for each operation:
*
- * - Native Redis 8.4+ CAS/CAD commands when available (DELEX, SET IFEQ)
- * - Lua script-based operations for older Redis versions
+ * - Native Redis 8.4+ CAS/CAD commands when available (DELEX, SET IFEQ)
+ * - Lua script-based operations for older Redis versions
*
- * The detection and selection happens automatically at driver initialization.
+ * The detection and selection happens automatically at driver initialization.
+ *
*/
public interface RedisDriver extends AutoCloseable {
-
+
/**
- * Attempts to set a key with a value if the key doesn't exist, with an expiration time.
- * This corresponds to the Redis SET command with NX and PX options.
+ * Attempts to set a key with a value if the key doesn't exist, with an expiration time. This corresponds to the
+ * Redis SET command with NX and PX options.
*
- * @param key the key to set
- * @param value the value to set
- * @param expireTimeMs expiration time in milliseconds
+ * @param key
+ * the key to set
+ * @param value
+ * the value to set
+ * @param expireTimeMs
+ * expiration time in milliseconds
* @return true if the key was set, false if it already existed
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
boolean setIfNotExists(String key, String value, long expireTimeMs) throws RedisDriverException;
/**
- * Deletes a key only if its value matches the expected value.
- * This is used for safe lock release.
+ * Deletes a key only if its value matches the expected value. This is used for safe lock release.
*
- * This method automatically uses the best available implementation:
+ *
+ * This method automatically uses the best available implementation:
*
- * - Redis 8.4+: Native DELEX command for optimal performance
- * - Older versions: Lua script for compatibility
+ * - Redis 8.4+: Native DELEX command for optimal performance
+ * - Older versions: Lua script for compatibility
*
- * The implementation is selected automatically at driver initialization based on
- * Redis server capabilities.
+ * The implementation is selected automatically at driver initialization based on Redis server capabilities.
+ *
*
- * @param key the key to potentially delete
- * @param expectedValue the expected value of the key
+ * @param key
+ * the key to potentially delete
+ * @param expectedValue
+ * the expected value of the key
* @return true if the key was deleted, false if it didn't exist or had a different value
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
boolean deleteIfValueMatches(String key, String expectedValue) throws RedisDriverException;
@@ -91,131 +81,163 @@ public interface RedisDriver extends AutoCloseable {
void close();
/**
- * Sets a key only if its current value matches the expected value.
- * This is used for atomic compare-and-swap operations like lock extension.
+ * Sets a key only if its current value matches the expected value. This is used for atomic compare-and-swap
+ * operations like lock extension.
*
- * This method automatically uses the best available implementation:
+ *
+ * This method automatically uses the best available implementation:
*
- * - Redis 8.4+: Native SET IFEQ command for optimal performance
- * - Older versions: Lua script for compatibility
+ * - Redis 8.4+: Native SET IFEQ command for optimal performance
+ * - Older versions: Lua script for compatibility
*
- * The implementation is selected automatically at driver initialization based on
- * Redis server capabilities.
+ * The implementation is selected automatically at driver initialization based on Redis server capabilities.
+ *
*
- * @param key the key to set
- * @param newValue the new value to set
- * @param expectedCurrentValue the expected current value that must match
- * @param expireTimeMs expiration time in milliseconds
+ * @param key
+ * the key to set
+ * @param newValue
+ * the new value to set
+ * @param expectedCurrentValue
+ * the expected current value that must match
+ * @param expireTimeMs
+ * expiration time in milliseconds
* @return true if the key was set, false if the current value didn't match
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
- boolean setIfValueMatches(String key, String newValue,
- String expectedCurrentValue,
- long expireTimeMs)
+ boolean setIfValueMatches(String key, String newValue, String expectedCurrentValue, long expireTimeMs)
throws RedisDriverException;
// ========== Sorted Set Operations (for Fair Lock) ==========
/**
- * Adds a member to a sorted set with the given score.
- * If the member already exists, its score is updated.
+ * Adds a member to a sorted set with the given score. If the member already exists, its score is updated.
*
- * @param key the sorted set key
- * @param score the score for the member
- * @param member the member to add
+ * @param key
+ * the sorted set key
+ * @param score
+ * the score for the member
+ * @param member
+ * the member to add
* @return true if a new member was added, false if an existing member's score was updated
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
boolean zAdd(String key, double score, String member) throws RedisDriverException;
/**
* Removes a member from a sorted set.
*
- * @param key the sorted set key
- * @param member the member to remove
+ * @param key
+ * the sorted set key
+ * @param member
+ * the member to remove
* @return true if the member was removed, false if it didn't exist
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
boolean zRem(String key, String member) throws RedisDriverException;
/**
* Returns a range of members from a sorted set, ordered by score (ascending).
*
- * @param key the sorted set key
- * @param start the start index (0-based, inclusive)
- * @param stop the stop index (0-based, inclusive, -1 for end)
+ * @param key
+ * the sorted set key
+ * @param start
+ * the start index (0-based, inclusive)
+ * @param stop
+ * the stop index (0-based, inclusive, -1 for end)
* @return list of members in the specified range
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
List zRange(String key, long start, long stop) throws RedisDriverException;
/**
* Returns the score of a member in a sorted set.
*
- * @param key the sorted set key
- * @param member the member to get the score for
+ * @param key
+ * the sorted set key
+ * @param member
+ * the member to get the score for
* @return the score, or null if the member doesn't exist
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
Double zScore(String key, String member) throws RedisDriverException;
/**
* Removes all members from a sorted set with scores less than or equal to the given score.
*
- * @param key the sorted set key
- * @param maxScore the maximum score (inclusive)
+ * @param key
+ * the sorted set key
+ * @param maxScore
+ * the maximum score (inclusive)
* @return the number of members removed
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
long zRemRangeByScore(String key, double minScore, double maxScore) throws RedisDriverException;
// ========== String/Counter Operations (for ReadWriteLock, CountDownLatch) ==========
/**
- * Increments the integer value of a key by one.
- * If the key doesn't exist, it is set to 0 before performing the operation.
+ * Increments the integer value of a key by one. If the key doesn't exist, it is set to 0 before performing the
+ * operation.
*
- * @param key the key to increment
+ * @param key
+ * the key to increment
* @return the value after incrementing
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
long incr(String key) throws RedisDriverException;
/**
- * Decrements the integer value of a key by one.
- * If the key doesn't exist, it is set to 0 before performing the operation.
+ * Decrements the integer value of a key by one. If the key doesn't exist, it is set to 0 before performing the
+ * operation.
*
- * @param key the key to decrement
+ * @param key
+ * the key to decrement
* @return the value after decrementing
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
long decr(String key) throws RedisDriverException;
/**
* Gets the value of a key.
*
- * @param key the key to get
+ * @param key
+ * the key to get
* @return the value, or null if the key doesn't exist
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
String get(String key) throws RedisDriverException;
/**
* Sets a key to a value with an expiration time.
*
- * @param key the key to set
- * @param value the value to set
- * @param expireTimeMs expiration time in milliseconds
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @param key
+ * the key to set
+ * @param value
+ * the value to set
+ * @param expireTimeMs
+ * expiration time in milliseconds
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
void setex(String key, String value, long expireTimeMs) throws RedisDriverException;
/**
* Deletes one or more keys.
*
- * @param keys the keys to delete
+ * @param keys
+ * the keys to delete
* @return the number of keys that were deleted
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
long del(String... keys) throws RedisDriverException;
@@ -224,20 +246,26 @@ boolean setIfValueMatches(String key, String newValue,
/**
* Publishes a message to a channel.
*
- * @param channel the channel to publish to
- * @param message the message to publish
+ * @param channel
+ * the channel to publish to
+ * @param message
+ * the message to publish
* @return the number of clients that received the message
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
long publish(String channel, String message) throws RedisDriverException;
/**
- * Subscribes to one or more channels and processes messages with the given handler.
- * This is a blocking operation that should typically be run in a separate thread.
+ * Subscribes to one or more channels and processes messages with the given handler. This is a blocking operation
+ * that should typically be run in a separate thread.
*
- * @param handler the message handler
- * @param channels the channels to subscribe to
- * @throws RedisDriverException if there's an error communicating with Redis
+ * @param handler
+ * the message handler
+ * @param channels
+ * the channels to subscribe to
+ * @throws RedisDriverException
+ * if there's an error communicating with Redis
*/
void subscribe(MessageHandler handler, String... channels) throws RedisDriverException;
@@ -248,15 +276,18 @@ interface MessageHandler {
/**
* Called when a message is received on a subscribed channel.
*
- * @param channel the channel the message was received on
- * @param message the message content
+ * @param channel
+ * the channel the message was received on
+ * @param message
+ * the message content
*/
void onMessage(String channel, String message);
/**
* Called when an error occurs during subscription.
*
- * @param error the error that occurred
+ * @param error
+ * the error that occurred
*/
void onError(Throwable error);
}
diff --git a/src/main/java/org/codarama/redlock4j/driver/RedisDriverException.java b/src/main/java/org/codarama/redlock4j/driver/RedisDriverException.java
index e5e7996..6f2e7bc 100644
--- a/src/main/java/org/codarama/redlock4j/driver/RedisDriverException.java
+++ b/src/main/java/org/codarama/redlock4j/driver/RedisDriverException.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.driver;
@@ -27,15 +8,15 @@
* Exception thrown when there's an error communicating with Redis through a driver.
*/
public class RedisDriverException extends Exception {
-
+
public RedisDriverException(String message) {
super(message);
}
-
+
public RedisDriverException(String message, Throwable cause) {
super(message, cause);
}
-
+
public RedisDriverException(Throwable cause) {
super(cause);
}
diff --git a/src/test/java/org/codarama/redlock4j/LockExtensionTest.java b/src/test/java/org/codarama/redlock4j/LockExtensionTest.java
index 41aab94..8354c69 100644
--- a/src/test/java/org/codarama/redlock4j/LockExtensionTest.java
+++ b/src/test/java/org/codarama/redlock4j/LockExtensionTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -45,30 +26,25 @@
*/
@ExtendWith(MockitoExtension.class)
public class LockExtensionTest {
-
+
@Mock
private RedisDriver mockDriver1;
-
+
@Mock
private RedisDriver mockDriver2;
-
+
@Mock
private RedisDriver mockDriver3;
-
+
private RedlockConfiguration testConfig;
private List drivers;
-
+
@BeforeEach
void setUp() {
- testConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
+ testConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(30))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .build();
drivers = Arrays.asList(mockDriver1, mockDriver2, mockDriver3);
@@ -77,192 +53,191 @@ void setUp() {
lenient().when(mockDriver2.getIdentifier()).thenReturn("redis://localhost:6380");
lenient().when(mockDriver3.getIdentifier()).thenReturn("redis://localhost:6381");
}
-
+
@Test
public void testExtendSuccess() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock successful extension on all nodes
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock
assertTrue(lock.tryLock());
long initialValidity = lock.getRemainingValidityTime();
-
+
// Extend lock
boolean extended = lock.extend(10000); // Extend by 10 seconds
-
+
assertTrue(extended);
assertTrue(lock.isHeldByCurrentThread());
-
+
// Validity time should be greater after extension
long newValidity = lock.getRemainingValidityTime();
- assertTrue(newValidity > initialValidity,
- "New validity (" + newValidity + ") should be greater than initial (" + initialValidity + ")");
-
+ assertTrue(newValidity > initialValidity,
+ "New validity (" + newValidity + ") should be greater than initial (" + initialValidity + ")");
+
// Verify setIfValueMatches was called on all drivers
verify(mockDriver1).setIfValueMatches(eq("test-key"), anyString(), anyString(), eq(40000L));
verify(mockDriver2).setIfValueMatches(eq("test-key"), anyString(), anyString(), eq(40000L));
verify(mockDriver3).setIfValueMatches(eq("test-key"), anyString(), anyString(), eq(40000L));
}
-
+
@Test
public void testExtendWithQuorum() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock extension succeeds on quorum (2 out of 3)
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock
assertTrue(lock.tryLock());
-
+
// Extend lock - should succeed with quorum
boolean extended = lock.extend(10000);
-
+
assertTrue(extended);
assertTrue(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendFailsWithoutQuorum() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock extension fails on majority (only 1 out of 3 succeeds)
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(false);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock
assertTrue(lock.tryLock());
-
+
// Extend lock - should fail without quorum
boolean extended = lock.extend(10000);
-
+
assertFalse(extended);
// Lock should still be held (original lock not affected)
assertTrue(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendWithoutHoldingLock() {
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Try to extend without holding lock
boolean extended = lock.extend(10000);
-
+
assertFalse(extended);
assertFalse(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendWithNegativeTime() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock
assertTrue(lock.tryLock());
-
+
// Try to extend with negative time
assertThrows(IllegalArgumentException.class, () -> lock.extend(-1000));
}
-
+
@Test
public void testExtendWithZeroTime() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock
assertTrue(lock.tryLock());
-
+
// Try to extend with zero time
assertThrows(IllegalArgumentException.class, () -> lock.extend(0));
}
-
+
@Test
public void testExtendPreservesHoldCount() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock successful extension
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock twice (reentrant)
assertTrue(lock.tryLock());
assertTrue(lock.tryLock());
assertEquals(2, lock.getHoldCount());
-
+
// Extend lock
assertTrue(lock.extend(10000));
-
+
// Hold count should be preserved
assertEquals(2, lock.getHoldCount());
-
+
// Should need to unlock twice
lock.unlock();
assertEquals(1, lock.getHoldCount());
assertTrue(lock.isHeldByCurrentThread());
-
+
lock.unlock();
assertEquals(0, lock.getHoldCount());
assertFalse(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendWithDriverException() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock extension with one driver throwing exception
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong()))
- .thenThrow(new RedisDriverException("Connection failed"));
+ .thenThrow(new RedisDriverException("Connection failed"));
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock
assertTrue(lock.tryLock());
-
+
// Extend should still succeed with quorum (2 out of 3)
boolean extended = lock.extend(10000);
-
+
assertTrue(extended);
assertTrue(lock.isHeldByCurrentThread());
}
}
-
diff --git a/src/test/java/org/codarama/redlock4j/RedlockManagerTest.java b/src/test/java/org/codarama/redlock4j/RedlockManagerTest.java
index 196870f..9cbe5ce 100644
--- a/src/test/java/org/codarama/redlock4j/RedlockManagerTest.java
+++ b/src/test/java/org/codarama/redlock4j/RedlockManagerTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -32,26 +13,20 @@
import static org.junit.jupiter.api.Assertions.*;
/**
- * Unit tests for RedlockManager.
- * These tests focus on the manager's public interface and configuration handling.
+ * Unit tests for RedlockManager. These tests focus on the manager's public interface and configuration handling.
*/
public class RedlockManagerTest {
-
+
private RedlockConfiguration testConfig;
-
+
@BeforeEach
void setUp() {
- testConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(200))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
+ testConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(30))
+ .retryDelay(Duration.ofMillis(200)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .build();
}
-
+
@Test
public void testConfigurationValidation() {
assertNotNull(testConfig);
@@ -61,27 +36,20 @@ public void testConfigurationValidation() {
assertEquals(3, testConfig.getMaxRetryAttempts());
assertEquals(10000, testConfig.getLockAcquisitionTimeoutMs());
}
-
+
@Test
public void testInvalidConfigurationWithTooFewNodes() {
- assertThrows(IllegalArgumentException.class, () ->
- RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .build());
+ assertThrows(IllegalArgumentException.class, () -> RedlockConfiguration.builder()
+ .addRedisNode("localhost", 6379).addRedisNode("localhost", 6380).build());
}
-
+
@Test
public void testInvalidConfigurationWithNegativeTimeout() {
- assertThrows(IllegalArgumentException.class, () ->
- RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(-1))
- .build());
+ assertThrows(IllegalArgumentException.class,
+ () -> RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(-1)).build());
}
-
+
@Test
public void testQuorumCalculation() {
// Test quorum calculation for different node counts
@@ -89,20 +57,14 @@ public void testQuorumCalculation() {
assertEquals(3, (5 / 2) + 1); // 5 nodes -> quorum of 3
assertEquals(4, (7 / 2) + 1); // 7 nodes -> quorum of 4
}
-
+
@Test
public void testConfigurationBuilderPattern() {
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("redis1.example.com", 6379)
- .addRedisNode("redis2.example.com", 6379)
- .addRedisNode("redis3.example.com", 6379)
- .defaultLockTimeout(Duration.ofMinutes(1))
- .retryDelay(Duration.ofMillis(500))
- .maxRetryAttempts(5)
- .clockDriftFactor(0.02)
- .lockAcquisitionTimeout(Duration.ofSeconds(30))
- .build();
-
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("redis1.example.com", 6379)
+ .addRedisNode("redis2.example.com", 6379).addRedisNode("redis3.example.com", 6379)
+ .defaultLockTimeout(Duration.ofMinutes(1)).retryDelay(Duration.ofMillis(500)).maxRetryAttempts(5)
+ .clockDriftFactor(0.02).lockAcquisitionTimeout(Duration.ofSeconds(30)).build();
+
assertNotNull(config);
assertEquals(3, config.getRedisNodes().size());
assertEquals(60000, config.getDefaultLockTimeoutMs());
@@ -111,27 +73,20 @@ public void testConfigurationBuilderPattern() {
assertEquals(0.02, config.getClockDriftFactor(), 0.001);
assertEquals(30000, config.getLockAcquisitionTimeoutMs());
}
-
+
@Test
public void testConfigurationWithCustomClockDrift() {
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .clockDriftFactor(0.05)
- .build();
-
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381).clockDriftFactor(0.05).build();
+
assertEquals(0.05, config.getClockDriftFactor(), 0.001);
}
-
+
@Test
public void testConfigurationDefaults() {
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .build();
-
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381).build();
+
// Test default values
assertEquals(Duration.ofSeconds(30).toMillis(), config.getDefaultLockTimeoutMs());
assertEquals(200, config.getRetryDelayMs());
diff --git a/src/test/java/org/codarama/redlock4j/RedlockTest.java b/src/test/java/org/codarama/redlock4j/RedlockTest.java
index ec3360a..ae3050f 100644
--- a/src/test/java/org/codarama/redlock4j/RedlockTest.java
+++ b/src/test/java/org/codarama/redlock4j/RedlockTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -46,30 +27,25 @@
*/
@ExtendWith(MockitoExtension.class)
public class RedlockTest {
-
+
@Mock
private RedisDriver mockDriver1;
-
+
@Mock
private RedisDriver mockDriver2;
-
+
@Mock
private RedisDriver mockDriver3;
-
+
private RedlockConfiguration testConfig;
private List drivers;
-
+
@BeforeEach
void setUp() {
- testConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
+ testConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(30))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .build();
drivers = Arrays.asList(mockDriver1, mockDriver2, mockDriver3);
@@ -78,121 +54,121 @@ void setUp() {
lenient().when(mockDriver2.getIdentifier()).thenReturn("redis://localhost:6380");
lenient().when(mockDriver3.getIdentifier()).thenReturn("redis://localhost:6381");
}
-
+
@Test
public void testTryLockSuccess() throws RedisDriverException {
// Mock successful lock acquisition on all nodes
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
boolean acquired = lock.tryLock();
-
+
assertTrue(acquired);
assertTrue(lock.isHeldByCurrentThread());
assertTrue(lock.getRemainingValidityTime() > 0);
-
+
// Verify all drivers were called
verify(mockDriver1).setIfNotExists(eq("test-key"), anyString(), eq(30000L));
verify(mockDriver2).setIfNotExists(eq("test-key"), anyString(), eq(30000L));
verify(mockDriver3).setIfNotExists(eq("test-key"), anyString(), eq(30000L));
}
-
+
@Test
public void testTryLockFailureInsufficientNodes() throws RedisDriverException {
// Mock failure on majority of nodes (only 1 success, need 2 for quorum)
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
boolean acquired = lock.tryLock();
-
+
assertFalse(acquired);
assertFalse(lock.isHeldByCurrentThread());
assertEquals(0, lock.getRemainingValidityTime());
-
+
// Verify cleanup - should try to delete the lock that was acquired
verify(mockDriver1, atLeastOnce()).deleteIfValueMatches(eq("test-key"), anyString());
verify(mockDriver2, atLeastOnce()).deleteIfValueMatches(eq("test-key"), anyString());
verify(mockDriver3, atLeastOnce()).deleteIfValueMatches(eq("test-key"), anyString());
}
-
+
@Test
public void testTryLockWithTimeout() throws InterruptedException, RedisDriverException {
// Mock successful lock acquisition on quorum
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
boolean acquired = lock.tryLock(5, TimeUnit.SECONDS);
-
+
assertTrue(acquired);
assertTrue(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testTryLockTimeoutExceeded() throws InterruptedException, RedisDriverException {
// Mock failure on all attempts
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
long startTime = System.currentTimeMillis();
boolean acquired = lock.tryLock(200, TimeUnit.MILLISECONDS);
long elapsedTime = System.currentTimeMillis() - startTime;
-
+
assertFalse(acquired);
assertFalse(lock.isHeldByCurrentThread());
assertTrue(elapsedTime >= 200); // Should respect timeout
}
-
+
@Test
public void testLockSuccess() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
assertDoesNotThrow(lock::lock);
assertTrue(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testLockFailureThrowsException() throws RedisDriverException {
// Mock failure on all nodes
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
RedlockException exception = assertThrows(RedlockException.class, () -> lock.lock());
-
+
assertTrue(exception.getMessage().contains("Failed to acquire lock within timeout"));
}
-
+
@Test
public void testLockInterruptibly() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
assertDoesNotThrow(lock::lockInterruptibly);
assertTrue(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testLockInterruptiblyWithInterruption() throws RedisDriverException {
// Use lenient stubbing to avoid unnecessary stubbing warnings
@@ -210,93 +186,89 @@ public void testLockInterruptiblyWithInterruption() throws RedisDriverException
// Clear interrupt flag
Thread.interrupted();
}
-
+
@Test
public void testUnlockSuccess() throws RedisDriverException {
// First acquire the lock
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
assertTrue(lock.tryLock());
-
+
// Now unlock
lock.unlock();
-
+
assertFalse(lock.isHeldByCurrentThread());
assertEquals(0, lock.getRemainingValidityTime());
-
+
// Verify unlock was called on all drivers
verify(mockDriver1, atLeastOnce()).deleteIfValueMatches(eq("test-key"), anyString());
verify(mockDriver2, atLeastOnce()).deleteIfValueMatches(eq("test-key"), anyString());
verify(mockDriver3, atLeastOnce()).deleteIfValueMatches(eq("test-key"), anyString());
}
-
+
@Test
public void testUnlockWithoutLock() {
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Should not throw exception when unlocking without holding lock
assertDoesNotThrow(lock::unlock);
-
+
assertFalse(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testDriverExceptionDuringLockAcquisition() throws RedisDriverException {
// Mock exception on one driver, success on others
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong()))
- .thenThrow(new RedisDriverException("Connection failed"));
+ .thenThrow(new RedisDriverException("Connection failed"));
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
boolean acquired = lock.tryLock();
-
+
assertTrue(acquired); // Should still succeed with 2/3 nodes
assertTrue(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testDriverExceptionDuringUnlock() throws RedisDriverException {
// First acquire the lock
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
assertTrue(lock.tryLock());
-
+
// Mock exception during unlock
- doThrow(new RedisDriverException("Delete failed")).when(mockDriver1)
- .deleteIfValueMatches(anyString(), anyString());
-
+ doThrow(new RedisDriverException("Delete failed")).when(mockDriver1).deleteIfValueMatches(anyString(),
+ anyString());
+
// Should not throw exception
assertDoesNotThrow(lock::unlock);
-
+
assertFalse(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testNewConditionThrowsUnsupportedOperation() {
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
assertThrows(UnsupportedOperationException.class, lock::newCondition);
}
-
+
@Test
public void testIsHeldByCurrentThreadAfterExpiry() throws RedisDriverException, InterruptedException {
// Use very short timeout for testing expiry with 3 nodes to satisfy validation
- RedlockConfiguration shortConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofMillis(50))
- .retryDelay(Duration.ofMillis(10))
- .maxRetryAttempts(1)
- .build();
+ RedlockConfiguration shortConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381)
+ .defaultLockTimeout(Duration.ofMillis(50)).retryDelay(Duration.ofMillis(10)).maxRetryAttempts(1)
+ .build();
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
@@ -317,14 +289,10 @@ public void testIsHeldByCurrentThreadAfterExpiry() throws RedisDriverException,
@Test
public void testUnlockExpiredLock() throws RedisDriverException, InterruptedException {
// Use very short timeout for testing expiry with 3 nodes to satisfy validation
- RedlockConfiguration shortConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofMillis(50))
- .retryDelay(Duration.ofMillis(10))
- .maxRetryAttempts(1)
- .build();
+ RedlockConfiguration shortConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381)
+ .defaultLockTimeout(Duration.ofMillis(50)).retryDelay(Duration.ofMillis(10)).maxRetryAttempts(1)
+ .build();
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
@@ -344,12 +312,10 @@ public void testUnlockExpiredLock() throws RedisDriverException, InterruptedExce
@Test
public void testRetryLogicWithEventualSuccess() throws RedisDriverException {
// Mock failure on first attempts, success on later attempt
- when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong()))
- .thenReturn(false) // First attempt fails
- .thenReturn(true); // Second attempt succeeds
- when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong()))
- .thenReturn(false) // First attempt fails
- .thenReturn(true); // Second attempt succeeds
+ when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false) // First attempt fails
+ .thenReturn(true); // Second attempt succeeds
+ when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false) // First attempt fails
+ .thenReturn(true); // Second attempt succeeds
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
Redlock lock = new Redlock("test-key", drivers, testConfig);
@@ -384,7 +350,7 @@ public void testClockDriftCalculation() throws RedisDriverException {
// Validity time should be reduced due to elapsed time and clock drift
long remainingTime = lock.getRemainingValidityTime();
assertTrue(remainingTime < 30000); // Should be less than full timeout
- assertTrue(remainingTime > 0); // But still positive
+ assertTrue(remainingTime > 0); // But still positive
}
@Test
diff --git a/src/test/java/org/codarama/redlock4j/ReentrantAsyncRedlockTest.java b/src/test/java/org/codarama/redlock4j/ReentrantAsyncRedlockTest.java
index 9a8b3a4..87e1d00 100644
--- a/src/test/java/org/codarama/redlock4j/ReentrantAsyncRedlockTest.java
+++ b/src/test/java/org/codarama/redlock4j/ReentrantAsyncRedlockTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -52,252 +33,247 @@
*/
@ExtendWith(MockitoExtension.class)
public class ReentrantAsyncRedlockTest {
-
+
@Mock
private RedisDriver mockDriver1;
-
+
@Mock
private RedisDriver mockDriver2;
-
+
@Mock
private RedisDriver mockDriver3;
-
+
private RedlockConfiguration testConfig;
private List drivers;
private ExecutorService executorService;
private ScheduledExecutorService scheduledExecutorService;
-
+
@BeforeEach
void setUp() {
- testConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
-
+ testConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(30))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .build();
+
drivers = Arrays.asList(mockDriver1, mockDriver2, mockDriver3);
executorService = Executors.newFixedThreadPool(4);
scheduledExecutorService = Executors.newScheduledThreadPool(2);
-
+
// Setup default mock behavior
lenient().when(mockDriver1.getIdentifier()).thenReturn("redis://localhost:6379");
lenient().when(mockDriver2.getIdentifier()).thenReturn("redis://localhost:6380");
lenient().when(mockDriver3.getIdentifier()).thenReturn("redis://localhost:6381");
}
-
+
@AfterEach
void tearDown() {
executorService.shutdown();
scheduledExecutorService.shutdown();
}
-
+
@Test
public void testBasicAsyncReentrancy() throws Exception {
// Mock successful lock acquisition on quorum
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
- AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+
+ AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
// First acquisition
CompletionStage firstAcquisition = lock.tryLockAsync();
assertTrue(firstAcquisition.toCompletableFuture().get(5, TimeUnit.SECONDS));
assertTrue(lock.isHeldByCurrentThread());
assertEquals(1, lock.getHoldCount());
-
+
// Second acquisition (reentrant)
CompletionStage secondAcquisition = lock.tryLockAsync();
assertTrue(secondAcquisition.toCompletableFuture().get(5, TimeUnit.SECONDS));
assertTrue(lock.isHeldByCurrentThread());
assertEquals(2, lock.getHoldCount());
-
+
// Third acquisition (reentrant)
CompletionStage thirdAcquisition = lock.tryLockAsync();
assertTrue(thirdAcquisition.toCompletableFuture().get(5, TimeUnit.SECONDS));
assertTrue(lock.isHeldByCurrentThread());
assertEquals(3, lock.getHoldCount());
-
+
// First unlock
CompletionStage firstUnlock = lock.unlockAsync();
firstUnlock.toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(lock.isHeldByCurrentThread());
assertEquals(2, lock.getHoldCount());
-
+
// Second unlock
CompletionStage secondUnlock = lock.unlockAsync();
secondUnlock.toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(lock.isHeldByCurrentThread());
assertEquals(1, lock.getHoldCount());
-
+
// Final unlock
CompletionStage finalUnlock = lock.unlockAsync();
finalUnlock.toCompletableFuture().get(5, TimeUnit.SECONDS);
assertFalse(lock.isHeldByCurrentThread());
assertEquals(0, lock.getHoldCount());
-
+
// Verify Redis operations were called only once (for initial acquisition)
verify(mockDriver1, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
verify(mockDriver2, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
verify(mockDriver3, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
-
+
// Verify unlock was called only once (for final release)
verify(mockDriver1, times(1)).deleteIfValueMatches(anyString(), anyString());
verify(mockDriver2, times(1)).deleteIfValueMatches(anyString(), anyString());
verify(mockDriver3, times(1)).deleteIfValueMatches(anyString(), anyString());
}
-
+
@Test
public void testAsyncReentrantLockWithTimeout() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
- AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+
+ AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
// First acquisition
CompletionStage firstAcquisition = lock.tryLockAsync(Duration.ofSeconds(5));
assertTrue(firstAcquisition.toCompletableFuture().get(10, TimeUnit.SECONDS));
assertEquals(1, lock.getHoldCount());
-
+
// Reentrant acquisition with timeout
CompletionStage secondAcquisition = lock.tryLockAsync(Duration.ofSeconds(5));
assertTrue(secondAcquisition.toCompletableFuture().get(10, TimeUnit.SECONDS));
assertEquals(2, lock.getHoldCount());
-
+
// Unlock both
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertEquals(1, lock.getHoldCount());
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertEquals(0, lock.getHoldCount());
-
+
// Verify Redis operations were called only once
verify(mockDriver1, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
}
-
+
@Test
public void testAsyncReentrantLockWithLockAsync() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
- AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+
+ AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
// First acquisition using lockAsync()
CompletionStage firstLock = lock.lockAsync();
assertDoesNotThrow(() -> firstLock.toCompletableFuture().get(5, TimeUnit.SECONDS));
assertEquals(1, lock.getHoldCount());
-
+
// Reentrant acquisition using tryLockAsync()
CompletionStage secondLock = lock.tryLockAsync();
assertTrue(secondLock.toCompletableFuture().get(5, TimeUnit.SECONDS));
assertEquals(2, lock.getHoldCount());
-
+
// Unlock both
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertEquals(1, lock.getHoldCount());
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertEquals(0, lock.getHoldCount());
}
-
+
@Test
public void testAsyncUnlockWithoutLockDoesNotThrow() throws Exception {
- AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+ AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
// Should not throw exception when unlocking without holding lock
CompletionStage unlock = lock.unlockAsync();
assertDoesNotThrow(() -> unlock.toCompletableFuture().get(5, TimeUnit.SECONDS));
assertEquals(0, lock.getHoldCount());
}
-
+
@Test
public void testRxReentrantLock() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
- AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+
+ AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
// First acquisition using RxJava
Boolean firstResult = lock.tryLockRx().blockingGet();
assertTrue(firstResult);
assertEquals(1, lock.getHoldCount());
-
+
// Reentrant acquisition using RxJava
Boolean secondResult = lock.tryLockRx().blockingGet();
assertTrue(secondResult);
assertEquals(2, lock.getHoldCount());
-
+
// Unlock both using RxJava
assertDoesNotThrow(() -> lock.unlockRx().blockingAwait());
assertEquals(1, lock.getHoldCount());
assertDoesNotThrow(() -> lock.unlockRx().blockingAwait());
assertEquals(0, lock.getHoldCount());
-
+
// Verify Redis operations were called only once
verify(mockDriver1, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
}
-
+
@Test
public void testAsyncReentrantLockValidityTime() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
- AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+
+ AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
// Acquire lock
assertTrue(lock.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS));
long firstValidityTime = lock.getRemainingValidityTime();
assertTrue(firstValidityTime > 0);
-
+
// Reentrant acquisition should not change validity time significantly
assertTrue(lock.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS));
long secondValidityTime = lock.getRemainingValidityTime();
assertTrue(secondValidityTime > 0);
// Should be approximately the same (allowing for small time differences)
assertTrue(Math.abs(firstValidityTime - secondValidityTime) < 1000);
-
+
// Unlock both
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(lock.getRemainingValidityTime() > 0); // Still valid after first unlock
-
+
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertEquals(0, lock.getRemainingValidityTime()); // Should be 0 after final unlock
}
-
+
@Test
public void testAsyncReentrantLockKey() throws Exception {
- AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+ AsyncRedlockImpl lock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
assertEquals("test-key", lock.getLockKey());
-
+
// Lock key should remain the same regardless of hold count
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
assertTrue(lock.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS));
assertEquals("test-key", lock.getLockKey());
-
+
assertTrue(lock.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS));
assertEquals("test-key", lock.getLockKey());
-
+
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
lock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
}
diff --git a/src/test/java/org/codarama/redlock4j/ReentrantLockDemo.java b/src/test/java/org/codarama/redlock4j/ReentrantLockDemo.java
index 4568e0e..155c15d 100644
--- a/src/test/java/org/codarama/redlock4j/ReentrantLockDemo.java
+++ b/src/test/java/org/codarama/redlock4j/ReentrantLockDemo.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -49,213 +30,208 @@
*/
@ExtendWith(MockitoExtension.class)
public class ReentrantLockDemo {
-
+
@Mock
private RedisDriver mockDriver1;
-
+
@Mock
private RedisDriver mockDriver2;
-
+
@Mock
private RedisDriver mockDriver3;
-
+
private RedlockConfiguration testConfig;
private List drivers;
-
+
@BeforeEach
void setUp() {
- testConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
-
+ testConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(30))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .build();
+
drivers = Arrays.asList(mockDriver1, mockDriver2, mockDriver3);
-
+
// Setup default mock behavior
lenient().when(mockDriver1.getIdentifier()).thenReturn("redis://localhost:6379");
lenient().when(mockDriver2.getIdentifier()).thenReturn("redis://localhost:6380");
lenient().when(mockDriver3.getIdentifier()).thenReturn("redis://localhost:6381");
}
-
+
@Test
public void demonstrateReentrantLockUsage() throws RedisDriverException {
// Mock successful lock acquisition on quorum
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("demo-key", drivers, testConfig);
-
+
System.out.println("=== Reentrant Lock Demonstration ===");
-
+
// Method that acquires the lock
performCriticalSection(lock);
-
+
// Verify the lock is fully released
assertFalse(lock.isHeldByCurrentThread());
assertEquals(0, lock.getHoldCount());
-
+
System.out.println("✅ Demonstration completed successfully!");
}
-
+
private void performCriticalSection(Redlock lock) {
System.out.println("🔒 Acquiring lock in performCriticalSection()");
lock.lock();
-
+
try {
System.out.println(" Hold count: " + lock.getHoldCount());
System.out.println(" Is held by current thread: " + lock.isHeldByCurrentThread());
-
+
// Call another method that also needs the same lock
performNestedOperation(lock);
-
+
System.out.println(" Back in performCriticalSection()");
System.out.println(" Hold count: " + lock.getHoldCount());
-
+
} finally {
System.out.println("🔓 Releasing lock in performCriticalSection()");
lock.unlock();
System.out.println(" Hold count after unlock: " + lock.getHoldCount());
}
}
-
+
private void performNestedOperation(Redlock lock) {
System.out.println(" 🔒 Acquiring lock in performNestedOperation() (reentrant)");
lock.lock();
-
+
try {
System.out.println(" Hold count: " + lock.getHoldCount());
System.out.println(" Is held by current thread: " + lock.isHeldByCurrentThread());
-
+
// Call yet another method that needs the lock
performDeeplyNestedOperation(lock);
-
+
System.out.println(" Back in performNestedOperation()");
System.out.println(" Hold count: " + lock.getHoldCount());
-
+
} finally {
System.out.println(" 🔓 Releasing lock in performNestedOperation()");
lock.unlock();
System.out.println(" Hold count after unlock: " + lock.getHoldCount());
}
}
-
+
private void performDeeplyNestedOperation(Redlock lock) {
System.out.println(" 🔒 Acquiring lock in performDeeplyNestedOperation() (reentrant)");
lock.lock();
-
+
try {
System.out.println(" Hold count: " + lock.getHoldCount());
System.out.println(" Is held by current thread: " + lock.isHeldByCurrentThread());
System.out.println(" Performing deeply nested critical work...");
-
+
} finally {
System.out.println(" 🔓 Releasing lock in performDeeplyNestedOperation()");
lock.unlock();
System.out.println(" Hold count after unlock: " + lock.getHoldCount());
}
}
-
+
@Test
public void demonstrateAsyncReentrantLockUsage() throws Exception {
// Mock successful lock acquisition on quorum
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
ExecutorService executorService = Executors.newFixedThreadPool(4);
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
-
+
try {
- AsyncRedlockImpl asyncLock = new AsyncRedlockImpl("async-demo-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+ AsyncRedlockImpl asyncLock = new AsyncRedlockImpl("async-demo-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
System.out.println("\n=== Async Reentrant Lock Demonstration ===");
-
+
// First acquisition
System.out.println("🔒 First async lock acquisition");
assertTrue(asyncLock.tryLockAsync().toCompletableFuture().get());
System.out.println(" Hold count: " + asyncLock.getHoldCount());
-
+
// Second acquisition (reentrant)
System.out.println("🔒 Second async lock acquisition (reentrant)");
assertTrue(asyncLock.tryLockAsync().toCompletableFuture().get());
System.out.println(" Hold count: " + asyncLock.getHoldCount());
-
+
// Third acquisition (reentrant)
System.out.println("🔒 Third async lock acquisition (reentrant)");
assertTrue(asyncLock.tryLockAsync().toCompletableFuture().get());
System.out.println(" Hold count: " + asyncLock.getHoldCount());
-
+
// Release locks
System.out.println("🔓 First async unlock");
asyncLock.unlockAsync().toCompletableFuture().get();
System.out.println(" Hold count: " + asyncLock.getHoldCount());
-
+
System.out.println("🔓 Second async unlock");
asyncLock.unlockAsync().toCompletableFuture().get();
System.out.println(" Hold count: " + asyncLock.getHoldCount());
-
+
System.out.println("🔓 Third async unlock");
asyncLock.unlockAsync().toCompletableFuture().get();
System.out.println(" Hold count: " + asyncLock.getHoldCount());
-
+
assertFalse(asyncLock.isHeldByCurrentThread());
assertEquals(0, asyncLock.getHoldCount());
-
+
System.out.println("✅ Async demonstration completed successfully!");
-
+
} finally {
executorService.shutdown();
scheduledExecutorService.shutdown();
}
}
-
+
@Test
public void demonstrateRxReentrantLockUsage() throws Exception {
// Mock successful lock acquisition on quorum
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
ExecutorService executorService = Executors.newFixedThreadPool(4);
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
-
+
try {
- AsyncRedlockImpl rxLock = new AsyncRedlockImpl("rx-demo-key", drivers, testConfig,
- executorService, scheduledExecutorService);
-
+ AsyncRedlockImpl rxLock = new AsyncRedlockImpl("rx-demo-key", drivers, testConfig, executorService,
+ scheduledExecutorService);
+
System.out.println("\n=== RxJava Reentrant Lock Demonstration ===");
-
+
// First acquisition using RxJava
System.out.println("🔒 First RxJava lock acquisition");
assertTrue(rxLock.tryLockRx().blockingGet());
System.out.println(" Hold count: " + rxLock.getHoldCount());
-
+
// Second acquisition (reentrant) using RxJava
System.out.println("🔒 Second RxJava lock acquisition (reentrant)");
assertTrue(rxLock.tryLockRx().blockingGet());
System.out.println(" Hold count: " + rxLock.getHoldCount());
-
+
// Release locks using RxJava
System.out.println("🔓 First RxJava unlock");
rxLock.unlockRx().blockingAwait();
System.out.println(" Hold count: " + rxLock.getHoldCount());
-
+
System.out.println("🔓 Second RxJava unlock");
rxLock.unlockRx().blockingAwait();
System.out.println(" Hold count: " + rxLock.getHoldCount());
-
+
assertFalse(rxLock.isHeldByCurrentThread());
assertEquals(0, rxLock.getHoldCount());
-
+
System.out.println("✅ RxJava demonstration completed successfully!");
-
+
} finally {
executorService.shutdown();
scheduledExecutorService.shutdown();
diff --git a/src/test/java/org/codarama/redlock4j/ReentrantRedlockTest.java b/src/test/java/org/codarama/redlock4j/ReentrantRedlockTest.java
index 6fc37b7..03539d8 100644
--- a/src/test/java/org/codarama/redlock4j/ReentrantRedlockTest.java
+++ b/src/test/java/org/codarama/redlock4j/ReentrantRedlockTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j;
@@ -50,132 +31,127 @@
*/
@ExtendWith(MockitoExtension.class)
public class ReentrantRedlockTest {
-
+
@Mock
private RedisDriver mockDriver1;
-
+
@Mock
private RedisDriver mockDriver2;
-
+
@Mock
private RedisDriver mockDriver3;
-
+
private RedlockConfiguration testConfig;
private List drivers;
-
+
@BeforeEach
void setUp() {
- testConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
-
+ testConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(30))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .build();
+
drivers = Arrays.asList(mockDriver1, mockDriver2, mockDriver3);
-
+
// Setup default mock behavior
lenient().when(mockDriver1.getIdentifier()).thenReturn("redis://localhost:6379");
lenient().when(mockDriver2.getIdentifier()).thenReturn("redis://localhost:6380");
lenient().when(mockDriver3.getIdentifier()).thenReturn("redis://localhost:6381");
}
-
+
@Test
public void testBasicReentrancy() throws RedisDriverException {
// Mock successful lock acquisition on quorum
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// First acquisition
assertTrue(lock.tryLock());
assertTrue(lock.isHeldByCurrentThread());
assertEquals(1, lock.getHoldCount());
-
+
// Second acquisition (reentrant)
assertTrue(lock.tryLock());
assertTrue(lock.isHeldByCurrentThread());
assertEquals(2, lock.getHoldCount());
-
+
// Third acquisition (reentrant)
assertTrue(lock.tryLock());
assertTrue(lock.isHeldByCurrentThread());
assertEquals(3, lock.getHoldCount());
-
+
// First unlock
lock.unlock();
assertTrue(lock.isHeldByCurrentThread());
assertEquals(2, lock.getHoldCount());
-
+
// Second unlock
lock.unlock();
assertTrue(lock.isHeldByCurrentThread());
assertEquals(1, lock.getHoldCount());
-
+
// Final unlock
lock.unlock();
assertFalse(lock.isHeldByCurrentThread());
assertEquals(0, lock.getHoldCount());
-
+
// Verify Redis operations were called only once (for initial acquisition)
verify(mockDriver1, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
verify(mockDriver2, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
verify(mockDriver3, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
-
+
// Verify unlock was called only once (for final release)
verify(mockDriver1, times(1)).deleteIfValueMatches(anyString(), anyString());
verify(mockDriver2, times(1)).deleteIfValueMatches(anyString(), anyString());
verify(mockDriver3, times(1)).deleteIfValueMatches(anyString(), anyString());
}
-
+
@Test
public void testReentrantLockWithTimeout() throws RedisDriverException, InterruptedException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// First acquisition
assertTrue(lock.tryLock(1, TimeUnit.SECONDS));
assertEquals(1, lock.getHoldCount());
-
+
// Reentrant acquisition with timeout
assertTrue(lock.tryLock(1, TimeUnit.SECONDS));
assertEquals(2, lock.getHoldCount());
-
+
// Unlock both
lock.unlock();
assertEquals(1, lock.getHoldCount());
lock.unlock();
assertEquals(0, lock.getHoldCount());
-
+
// Verify Redis operations were called only once
verify(mockDriver1, times(1)).setIfNotExists(anyString(), anyString(), anyLong());
}
-
+
@Test
public void testReentrantLockAcrossThreads() throws RedisDriverException, InterruptedException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Acquire lock in main thread
assertTrue(lock.tryLock());
assertEquals(1, lock.getHoldCount());
-
+
CountDownLatch latch = new CountDownLatch(1);
AtomicInteger otherThreadHoldCount = new AtomicInteger(-1);
-
+
// Try to access from another thread
Thread otherThread = new Thread(() -> {
// Other thread should not see the lock as held
@@ -184,92 +160,92 @@ public void testReentrantLockAcrossThreads() throws RedisDriverException, Interr
otherThreadHoldCount.set(lock.getHoldCount());
latch.countDown();
});
-
+
otherThread.start();
latch.await(5, TimeUnit.SECONDS);
-
+
// Main thread should still hold the lock
assertTrue(lock.isHeldByCurrentThread());
assertEquals(1, lock.getHoldCount());
assertEquals(0, otherThreadHoldCount.get());
-
+
lock.unlock();
assertFalse(lock.isHeldByCurrentThread());
}
-
+
@Test
public void testUnlockWithoutLockDoesNotThrow() {
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// Should not throw exception when unlocking without holding lock
assertDoesNotThrow(() -> lock.unlock());
assertEquals(0, lock.getHoldCount());
}
-
+
@Test
public void testReentrantLockWithLockMethod() throws RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// First acquisition using lock()
assertDoesNotThrow(() -> lock.lock());
assertEquals(1, lock.getHoldCount());
-
+
// Reentrant acquisition using tryLock()
assertTrue(lock.tryLock());
assertEquals(2, lock.getHoldCount());
-
+
// Unlock both
lock.unlock();
assertEquals(1, lock.getHoldCount());
lock.unlock();
assertEquals(0, lock.getHoldCount());
}
-
+
@Test
public void testReentrantLockWithLockInterruptibly() throws RedisDriverException, InterruptedException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
-
+
// First acquisition using lockInterruptibly()
assertDoesNotThrow(() -> lock.lockInterruptibly());
assertEquals(1, lock.getHoldCount());
-
+
// Reentrant acquisition using lockInterruptibly()
assertDoesNotThrow(() -> lock.lockInterruptibly());
assertEquals(2, lock.getHoldCount());
-
+
// Unlock both
lock.unlock();
assertEquals(1, lock.getHoldCount());
lock.unlock();
assertEquals(0, lock.getHoldCount());
}
-
+
@Test
public void testConcurrentReentrantAccess() throws InterruptedException, RedisDriverException {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(false);
-
+
Redlock lock = new Redlock("test-key", drivers, testConfig);
ExecutorService executor = Executors.newFixedThreadPool(3);
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch completeLatch = new CountDownLatch(3);
-
+
// Acquire lock in main thread
assertTrue(lock.tryLock());
assertEquals(1, lock.getHoldCount());
-
+
// Submit tasks that try to acquire the same lock from different threads
for (int i = 0; i < 3; i++) {
executor.submit(() -> {
@@ -285,14 +261,14 @@ public void testConcurrentReentrantAccess() throws InterruptedException, RedisDr
}
});
}
-
+
startLatch.countDown();
assertTrue(completeLatch.await(5, TimeUnit.SECONDS));
-
+
// Main thread should still hold the lock
assertTrue(lock.isHeldByCurrentThread());
assertEquals(1, lock.getHoldCount());
-
+
lock.unlock();
executor.shutdown();
}
diff --git a/src/test/java/org/codarama/redlock4j/async/AsyncLockExtensionTest.java b/src/test/java/org/codarama/redlock4j/async/AsyncLockExtensionTest.java
index 3b430a5..23d2e8a 100644
--- a/src/test/java/org/codarama/redlock4j/async/AsyncLockExtensionTest.java
+++ b/src/test/java/org/codarama/redlock4j/async/AsyncLockExtensionTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.async;
@@ -65,15 +46,10 @@ public class AsyncLockExtensionTest {
@BeforeEach
void setUp() {
- testConfig = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
+ testConfig = RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(30))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .build();
drivers = Arrays.asList(mockDriver1, mockDriver2, mockDriver3);
executorService = Executors.newFixedThreadPool(2);
@@ -94,58 +70,56 @@ void tearDown() {
scheduledExecutorService.shutdown();
}
}
-
+
@Test
public void testExtendAsyncSuccess() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock successful extension on all nodes
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
-
+
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
// Acquire lock
Boolean acquired = asyncLock.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(acquired);
-
+
long initialValidity = asyncLock.getRemainingValidityTime();
-
+
// Extend lock
- Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10))
- .toCompletableFuture()
- .get(5, TimeUnit.SECONDS);
-
+ Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10)).toCompletableFuture().get(5, TimeUnit.SECONDS);
+
assertTrue(extended);
assertTrue(asyncLock.isHeldByCurrentThread());
-
+
// Validity time should be greater after extension
long newValidity = asyncLock.getRemainingValidityTime();
assertTrue(newValidity > initialValidity,
- "New validity (" + newValidity + ") should be greater than initial (" + initialValidity + ")");
-
+ "New validity (" + newValidity + ") should be greater than initial (" + initialValidity + ")");
+
// Verify setIfValueMatches was called on all drivers
verify(mockDriver1).setIfValueMatches(eq("test-key"), anyString(), anyString(), eq(40000L));
verify(mockDriver2).setIfValueMatches(eq("test-key"), anyString(), anyString(), eq(40000L));
verify(mockDriver3).setIfValueMatches(eq("test-key"), anyString(), anyString(), eq(40000L));
}
-
+
@Test
public void testExtendAsyncWithQuorum() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock extension succeeds on quorum (2 out of 3)
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(false);
-
+
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
// Acquire lock
@@ -153,26 +127,24 @@ public void testExtendAsyncWithQuorum() throws Exception {
assertTrue(acquired);
// Extend lock - should succeed with quorum
- Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10))
- .toCompletableFuture()
- .get(5, TimeUnit.SECONDS);
-
+ Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10)).toCompletableFuture().get(5, TimeUnit.SECONDS);
+
assertTrue(extended);
assertTrue(asyncLock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendAsyncFailsWithoutQuorum() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock extension fails on majority (only 1 out of 3 succeeds)
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(false);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(false);
-
+
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
// Acquire lock
@@ -180,35 +152,31 @@ public void testExtendAsyncFailsWithoutQuorum() throws Exception {
assertTrue(acquired);
// Extend lock - should fail without quorum
- Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10))
- .toCompletableFuture()
- .get(5, TimeUnit.SECONDS);
-
+ Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10)).toCompletableFuture().get(5, TimeUnit.SECONDS);
+
assertFalse(extended);
// Lock should still be held (original lock not affected)
assertTrue(asyncLock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendAsyncWithoutHoldingLock() throws Exception {
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
// Try to extend without holding lock
- Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10))
- .toCompletableFuture()
- .get(5, TimeUnit.SECONDS);
-
+ Boolean extended = asyncLock.extendAsync(Duration.ofSeconds(10)).toCompletableFuture().get(5, TimeUnit.SECONDS);
+
assertFalse(extended);
assertFalse(asyncLock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendAsyncWithNegativeTime() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
// Acquire lock
@@ -217,25 +185,25 @@ public void testExtendAsyncWithNegativeTime() throws Exception {
// Try to extend with negative time
CompletionStage future = asyncLock.extendAsync(Duration.ofSeconds(-1));
-
- ExecutionException exception = assertThrows(ExecutionException.class, () ->
- future.toCompletableFuture().get(5, TimeUnit.SECONDS));
- assertInstanceOf(IllegalArgumentException.class, exception.getCause());
+ ExecutionException exception = assertThrows(ExecutionException.class,
+ () -> future.toCompletableFuture().get(5, TimeUnit.SECONDS));
+
+ assertInstanceOf(IllegalArgumentException.class, exception.getCause());
}
-
+
@Test
public void testExtendRxSuccess() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock successful extension on all nodes
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
-
+
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
// Acquire lock
@@ -248,22 +216,22 @@ public void testExtendRxSuccess() throws Exception {
extendObserver.await(5, TimeUnit.SECONDS);
extendObserver.assertValue(true);
extendObserver.assertComplete();
-
+
assertTrue(asyncLock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendRxWithQuorum() throws Exception {
// Mock successful lock acquisition
when(mockDriver1.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfNotExists(anyString(), anyString(), anyLong())).thenReturn(true);
-
+
// Mock extension succeeds on quorum (2 out of 3)
when(mockDriver1.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver2.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(true);
when(mockDriver3.setIfValueMatches(anyString(), anyString(), anyString(), anyLong())).thenReturn(false);
-
+
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
// Acquire lock
@@ -276,10 +244,10 @@ public void testExtendRxWithQuorum() throws Exception {
extendObserver.await(5, TimeUnit.SECONDS);
extendObserver.assertValue(true);
extendObserver.assertComplete();
-
+
assertTrue(asyncLock.isHeldByCurrentThread());
}
-
+
@Test
public void testExtendRxWithoutHoldingLock() throws Exception {
asyncLock = new AsyncRedlockImpl("test-key", drivers, testConfig, executorService, scheduledExecutorService);
@@ -289,8 +257,7 @@ public void testExtendRxWithoutHoldingLock() throws Exception {
extendObserver.await(5, TimeUnit.SECONDS);
extendObserver.assertValue(false);
extendObserver.assertComplete();
-
+
assertFalse(asyncLock.isHeldByCurrentThread());
}
}
-
diff --git a/src/test/java/org/codarama/redlock4j/async/AsyncRedlockImplTest.java b/src/test/java/org/codarama/redlock4j/async/AsyncRedlockImplTest.java
index 0f3f990..0b3f324 100644
--- a/src/test/java/org/codarama/redlock4j/async/AsyncRedlockImplTest.java
+++ b/src/test/java/org/codarama/redlock4j/async/AsyncRedlockImplTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.async;
@@ -43,109 +24,102 @@
*/
@Testcontainers
public class AsyncRedlockImplTest {
-
+
// Create 3 Redis containers for testing
@Container
static GenericContainer redis1 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
-
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
+
@Container
static GenericContainer redis2 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
-
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
+
@Container
static GenericContainer redis3 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
-
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
+
private static RedlockConfiguration testConfiguration;
-
+
@BeforeAll
static void setUp() {
// Create configuration with dynamic ports from containers
- testConfiguration = RedlockConfiguration.builder()
- .addRedisNode("localhost", redis1.getMappedPort(6379))
- .addRedisNode("localhost", redis2.getMappedPort(6379))
- .addRedisNode("localhost", redis3.getMappedPort(6379))
- .defaultLockTimeout(Duration.ofSeconds(10))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(5))
- .build();
+ testConfiguration = RedlockConfiguration.builder().addRedisNode("localhost", redis1.getMappedPort(6379))
+ .addRedisNode("localhost", redis2.getMappedPort(6379))
+ .addRedisNode("localhost", redis3.getMappedPort(6379)).defaultLockTimeout(Duration.ofSeconds(10))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(5))
+ .build();
}
-
+
@Test
public void testCompletionStageAsyncLock() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
AsyncRedlock asyncLock = manager.createAsyncLock("test-completion-stage-lock");
-
+
// Test async tryLock
CompletionStage lockResult = asyncLock.tryLockAsync();
Boolean acquired = lockResult.toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(acquired, "Should acquire lock asynchronously");
-
+
// Verify lock state
assertTrue(asyncLock.isHeldByCurrentThread(), "Lock should be held by current thread");
assertTrue(asyncLock.getRemainingValidityTime() > 0, "Lock should have remaining validity time");
assertEquals("test-completion-stage-lock", asyncLock.getLockKey());
-
+
// Test async unlock
CompletionStage unlockResult = asyncLock.unlockAsync();
unlockResult.toCompletableFuture().get(5, TimeUnit.SECONDS);
-
+
assertFalse(asyncLock.isHeldByCurrentThread(), "Lock should not be held after unlock");
}
}
-
+
@Test
public void testAsyncLockWithTimeout() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
AsyncRedlock asyncLock = manager.createAsyncLock("test-async-timeout");
-
+
// Test async tryLock with timeout
CompletionStage lockResult = asyncLock.tryLockAsync(Duration.ofSeconds(2));
Boolean acquired = lockResult.toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(acquired, "Should acquire lock with timeout");
-
+
// Test blocking async lock
AsyncRedlock asyncLock2 = manager.createAsyncLock("test-async-blocking");
CompletionStage blockingResult = asyncLock2.lockAsync();
blockingResult.toCompletableFuture().get(10, TimeUnit.SECONDS);
-
+
assertTrue(asyncLock2.isHeldByCurrentThread(), "Blocking lock should be acquired");
-
+
// Cleanup
asyncLock.unlockAsync().toCompletableFuture().get();
asyncLock2.unlockAsync().toCompletableFuture().get();
}
}
-
+
@Test
public void testRxJavaReactiveLock() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
RxRedlock rxLock = manager.createRxLock("test-rxjava-lock");
-
+
// Test RxJava Single tryLock
TestObserver lockObserver = rxLock.tryLockRx().test();
lockObserver.await(5, TimeUnit.SECONDS);
lockObserver.assertComplete();
lockObserver.assertValue(true);
-
+
// Verify lock state
assertTrue(rxLock.isHeldByCurrentThread(), "Lock should be held by current thread");
assertEquals("test-rxjava-lock", rxLock.getLockKey());
-
+
// Test RxJava Completable unlock
TestObserver unlockObserver = rxLock.unlockRx().test();
unlockObserver.await(5, TimeUnit.SECONDS);
unlockObserver.assertComplete();
-
+
assertFalse(rxLock.isHeldByCurrentThread(), "Lock should not be held after unlock");
}
}
-
+
@Test
public void testRxJavaValidityObservable() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
@@ -157,9 +131,12 @@ public void testRxJavaValidityObservable() throws Exception {
lockObserver.assertValue(true);
// Test validity observable - start it immediately after lock acquisition
- TestObserver validityObserver = rxLock.validityObservable(Duration.ofMillis(200))
- .take(2) // Take only 2 emissions to be safe
- .test();
+ TestObserver validityObserver = rxLock.validityObservable(Duration.ofMillis(200)).take(2) // Take only
+ // 2
+ // emissions
+ // to be
+ // safe
+ .test();
// Wait a bit for emissions
validityObserver.await(1, TimeUnit.SECONDS);
@@ -168,23 +145,24 @@ public void testRxJavaValidityObservable() throws Exception {
assertFalse(validityObserver.values().isEmpty(), "Should have at least 1 validity emission");
// All validity values should be positive
- validityObserver.values().forEach(validity ->
- assertTrue(validity > 0, "Validity time should be positive: " + validity));
+ validityObserver.values()
+ .forEach(validity -> assertTrue(validity > 0, "Validity time should be positive: " + validity));
// Cleanup
rxLock.unlockRx().test().await();
}
}
-
+
@Test
public void testRxJavaLockStateObservable() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
RxRedlock rxLock = manager.createRxLock("test-lock-state-observable");
// Subscribe to lock state changes
- TestObserver stateObserver = rxLock.lockStateObservable()
- .take(3) // RELEASED -> ACQUIRING -> ACQUIRED
- .test();
+ TestObserver stateObserver = rxLock.lockStateObservable().take(3) // RELEASED ->
+ // ACQUIRING ->
+ // ACQUIRED
+ .test();
// Small delay to ensure subscription is active
Thread.sleep(100);
@@ -199,84 +177,82 @@ public void testRxJavaLockStateObservable() throws Exception {
assertTrue(stateObserver.values().size() >= 2, "Should have at least 2 state changes");
// First state should be RELEASED (initial state)
- assertEquals(
- RxRedlock.LockState.RELEASED, stateObserver.values().get(0));
+ assertEquals(RxRedlock.LockState.RELEASED, stateObserver.values().get(0));
// Last state should be ACQUIRED (if lock was successful)
RxRedlock.LockState lastState = stateObserver.values().get(stateObserver.values().size() - 1);
assertTrue(lastState == RxRedlock.LockState.ACQUIRED || lastState == RxRedlock.LockState.ACQUIRING,
- "Last state should be ACQUIRED or ACQUIRING, but was: " + lastState);
+ "Last state should be ACQUIRED or ACQUIRING, but was: " + lastState);
// Cleanup
rxLock.unlockRx().test().await();
}
}
-
+
@Test
public void testRxJavaRetryLogic() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
RxRedlock rxLock = manager.createRxLock("test-retry-logic");
-
+
// Test retry with immediate success (should succeed on first try)
TestObserver retryObserver = rxLock.tryLockWithRetryRx(3, Duration.ofMillis(100)).test();
retryObserver.await(5, TimeUnit.SECONDS);
retryObserver.assertComplete();
retryObserver.assertValue(true);
-
+
assertTrue(rxLock.isHeldByCurrentThread(), "Lock should be held after retry success");
-
+
// Cleanup
rxLock.unlockRx().test().await();
}
}
-
+
@Test
public void testCombinedAsyncRxLock() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
AsyncRedlockImpl combinedLock = manager.createAsyncRxLock("test-combined-lock");
-
+
// Test CompletionStage interface
Boolean asyncResult = combinedLock.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(asyncResult, "Should acquire lock via CompletionStage interface");
-
+
// Test RxJava interface on same lock
assertTrue(combinedLock.isHeldByCurrentThread(), "Lock should be held");
-
+
// Test validity observable
- TestObserver validityObserver = combinedLock.validityObservable(Duration.ofMillis(200))
- .take(2)
- .test();
-
+ TestObserver validityObserver = combinedLock.validityObservable(Duration.ofMillis(200)).take(2)
+ .test();
+
validityObserver.await(1, TimeUnit.SECONDS);
validityObserver.assertValueCount(2);
-
+
// Test async unlock
combinedLock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertFalse(combinedLock.isHeldByCurrentThread(), "Lock should not be held after unlock");
}
}
-
+
@Test
public void testConcurrentAsyncOperations() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
AsyncRedlock asyncLock1 = manager.createAsyncLock("concurrent-async-test");
AsyncRedlock asyncLock2 = manager.createAsyncLock("concurrent-async-test"); // Same key
-
+
// First lock should succeed
Boolean acquired1 = asyncLock1.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(acquired1, "First async lock should succeed");
-
+
// Second lock should fail (same resource)
Boolean acquired2 = asyncLock2.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertFalse(acquired2, "Second async lock should fail for same resource");
-
+
// Release first lock
asyncLock1.unlockAsync().toCompletableFuture().get();
-
+
// Now second lock should succeed
Boolean acquired3 = asyncLock2.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(acquired3, "Second lock should succeed after first is released");
-
+
// Cleanup
asyncLock2.unlockAsync().toCompletableFuture().get();
}
diff --git a/src/test/java/org/codarama/redlock4j/configuration/RedlockConfigurationTest.java b/src/test/java/org/codarama/redlock4j/configuration/RedlockConfigurationTest.java
index 568742f..3d01212 100644
--- a/src/test/java/org/codarama/redlock4j/configuration/RedlockConfigurationTest.java
+++ b/src/test/java/org/codarama/redlock4j/configuration/RedlockConfigurationTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.configuration;
@@ -31,15 +12,12 @@
* Unit tests for RedlockConfiguration.
*/
public class RedlockConfigurationTest {
-
+
@Test
public void testBasicConfiguration() {
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .build();
-
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381).build();
+
assertEquals(3, config.getRedisNodes().size());
assertEquals(2, config.getQuorum()); // (3/2) + 1 = 2
assertEquals(Duration.ofSeconds(30).toMillis(), config.getDefaultLockTimeoutMs());
@@ -47,19 +25,13 @@ public void testBasicConfiguration() {
assertEquals(3, config.getMaxRetryAttempts());
assertEquals(0.01, config.getClockDriftFactor(), 0.001);
}
-
+
@Test
public void testCustomConfiguration() {
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("redis1", 6379, "password")
- .addRedisNode("redis2", 6379, "password")
- .addRedisNode("redis3", 6379, "password")
- .defaultLockTimeout(Duration.ofSeconds(60))
- .retryDelay(Duration.ofMillis(500))
- .maxRetryAttempts(5)
- .clockDriftFactor(0.02)
- .lockAcquisitionTimeout(Duration.ofSeconds(20))
- .build();
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("redis1", 6379, "password")
+ .addRedisNode("redis2", 6379, "password").addRedisNode("redis3", 6379, "password")
+ .defaultLockTimeout(Duration.ofSeconds(60)).retryDelay(Duration.ofMillis(500)).maxRetryAttempts(5)
+ .clockDriftFactor(0.02).lockAcquisitionTimeout(Duration.ofSeconds(20)).build();
assertEquals(3, config.getRedisNodes().size());
assertEquals(Duration.ofSeconds(60).toMillis(), config.getDefaultLockTimeoutMs());
@@ -68,18 +40,12 @@ public void testCustomConfiguration() {
assertEquals(0.02, config.getClockDriftFactor(), 0.001);
assertEquals(Duration.ofSeconds(20).toMillis(), config.getLockAcquisitionTimeoutMs());
}
-
+
@Test
public void testNodeConfiguration() {
- RedisNodeConfiguration nodeConfig = RedisNodeConfiguration.builder()
- .host("redis.example.com")
- .port(6380)
- .password("secret")
- .database(1)
- .connectionTimeoutMs(3000)
- .socketTimeoutMs(3000)
- .build();
-
+ RedisNodeConfiguration nodeConfig = RedisNodeConfiguration.builder().host("redis.example.com").port(6380)
+ .password("secret").database(1).connectionTimeoutMs(3000).socketTimeoutMs(3000).build();
+
assertEquals("redis.example.com", nodeConfig.getHost());
assertEquals(6380, nodeConfig.getPort());
assertEquals("secret", nodeConfig.getPassword());
@@ -87,79 +53,60 @@ public void testNodeConfiguration() {
assertEquals(3000, nodeConfig.getConnectionTimeoutMs());
assertEquals(3000, nodeConfig.getSocketTimeoutMs());
}
-
+
@Test
public void testValidationErrors() {
// Test insufficient nodes
assertThrows(IllegalArgumentException.class, () -> {
- RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .build(); // Only 2 nodes, need at least 3
+ RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380).build(); // Only
+ // 2
+ // nodes,
+ // need
+ // at
+ // least
+ // 3
});
-
+
// Test no nodes
assertThrows(IllegalArgumentException.class, () -> RedlockConfiguration.builder().build());
// Test invalid timeout
- assertThrows(IllegalArgumentException.class, () ->
- RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(-1))
- .build());
-
+ assertThrows(IllegalArgumentException.class,
+ () -> RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).defaultLockTimeout(Duration.ofSeconds(-1)).build());
+
// Test invalid clock drift factor
- assertThrows(IllegalArgumentException.class, () ->
- RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .clockDriftFactor(1.5) // > 1.0
- .build());
+ assertThrows(IllegalArgumentException.class,
+ () -> RedlockConfiguration.builder().addRedisNode("localhost", 6379).addRedisNode("localhost", 6380)
+ .addRedisNode("localhost", 6381).clockDriftFactor(1.5) // > 1.0
+ .build());
}
-
+
@Test
public void testNodeConfigurationValidation() {
// Test invalid host
- assertThrows(IllegalArgumentException.class, () ->
- RedisNodeConfiguration.builder()
- .host("")
- .build());
-
+ assertThrows(IllegalArgumentException.class, () -> RedisNodeConfiguration.builder().host("").build());
+
// Test invalid port
- assertThrows(IllegalArgumentException.class, () ->
- RedisNodeConfiguration.builder()
- .host("localhost")
- .port(0)
- .build());
-
- assertThrows(IllegalArgumentException.class, () ->
- RedisNodeConfiguration.builder()
- .host("localhost")
- .port(70000) // > 65535
- .build());
+ assertThrows(IllegalArgumentException.class,
+ () -> RedisNodeConfiguration.builder().host("localhost").port(0).build());
+
+ assertThrows(IllegalArgumentException.class,
+ () -> RedisNodeConfiguration.builder().host("localhost").port(70000) // > 65535
+ .build());
}
-
+
@Test
public void testQuorumCalculation() {
// Test with 3 nodes
- RedlockConfiguration config3 = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .build();
+ RedlockConfiguration config3 = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381).build();
assertEquals(2, config3.getQuorum());
-
+
// Test with 5 nodes
- RedlockConfiguration config5 = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .addRedisNode("localhost", 6382)
- .addRedisNode("localhost", 6383)
- .build();
+ RedlockConfiguration config5 = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381).addRedisNode("localhost", 6382)
+ .addRedisNode("localhost", 6383).build();
assertEquals(3, config5.getQuorum());
}
}
diff --git a/src/test/java/org/codarama/redlock4j/driver/JedisRedisDriverTest.java b/src/test/java/org/codarama/redlock4j/driver/JedisRedisDriverTest.java
index d317e61..b13764f 100644
--- a/src/test/java/org/codarama/redlock4j/driver/JedisRedisDriverTest.java
+++ b/src/test/java/org/codarama/redlock4j/driver/JedisRedisDriverTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.driver;
@@ -30,64 +11,49 @@
import static org.junit.jupiter.api.Assertions.*;
/**
- * Unit tests for JedisRedisDriver.
- * These tests focus on the driver's public interface and configuration handling.
+ * Unit tests for JedisRedisDriver. These tests focus on the driver's public interface and configuration handling.
*/
public class JedisRedisDriverTest {
-
+
private RedisNodeConfiguration testConfig;
private JedisRedisDriver driver;
-
+
@BeforeEach
void setUp() {
- testConfig = RedisNodeConfiguration.builder()
- .host("localhost")
- .port(6379)
- .connectionTimeoutMs(5000)
- .socketTimeoutMs(5000)
- .build();
+ testConfig = RedisNodeConfiguration.builder().host("localhost").port(6379).connectionTimeoutMs(5000)
+ .socketTimeoutMs(5000).build();
}
-
+
@Test
public void testDriverCreationWithBasicConfig() {
driver = new JedisRedisDriver(testConfig);
-
+
assertNotNull(driver);
assertEquals("redis://localhost:6379", driver.getIdentifier());
}
-
+
@Test
public void testDriverCreationWithPassword() {
- RedisNodeConfiguration configWithPassword = RedisNodeConfiguration.builder()
- .host("localhost")
- .port(6379)
- .password("testpass")
- .connectionTimeoutMs(5000)
- .socketTimeoutMs(5000)
- .build();
-
+ RedisNodeConfiguration configWithPassword = RedisNodeConfiguration.builder().host("localhost").port(6379)
+ .password("testpass").connectionTimeoutMs(5000).socketTimeoutMs(5000).build();
+
driver = new JedisRedisDriver(configWithPassword);
-
+
assertNotNull(driver);
assertEquals("redis://localhost:6379", driver.getIdentifier());
}
-
+
@Test
public void testDriverCreationWithDatabase() {
- RedisNodeConfiguration configWithDb = RedisNodeConfiguration.builder()
- .host("localhost")
- .port(6379)
- .database(2)
- .connectionTimeoutMs(5000)
- .socketTimeoutMs(5000)
- .build();
-
+ RedisNodeConfiguration configWithDb = RedisNodeConfiguration.builder().host("localhost").port(6379).database(2)
+ .connectionTimeoutMs(5000).socketTimeoutMs(5000).build();
+
driver = new JedisRedisDriver(configWithDb);
-
+
assertNotNull(driver);
assertEquals("redis://localhost:6379", driver.getIdentifier());
}
-
+
@Test
public void testGetIdentifierFormat() {
// Test identifier format without creating multiple drivers
@@ -95,26 +61,26 @@ public void testGetIdentifierFormat() {
assertEquals("redis://localhost:6379", driver.getIdentifier());
driver.close();
}
-
+
@Test
public void testDriverCreationWithNullConfig() {
assertThrows(NullPointerException.class, () -> {
new JedisRedisDriver(null);
});
}
-
+
@Test
public void testCloseDoesNotThrowException() {
driver = new JedisRedisDriver(testConfig);
-
+
// Should not throw exception even if connection fails
assertDoesNotThrow(() -> driver.close());
}
-
+
@Test
public void testMultipleCloseCallsAreIdempotent() {
driver = new JedisRedisDriver(testConfig);
-
+
// Multiple close calls should not throw exceptions
assertDoesNotThrow(() -> {
driver.close();
diff --git a/src/test/java/org/codarama/redlock4j/driver/LettuceRedisDriverTest.java b/src/test/java/org/codarama/redlock4j/driver/LettuceRedisDriverTest.java
index 53713af..bd86b9b 100644
--- a/src/test/java/org/codarama/redlock4j/driver/LettuceRedisDriverTest.java
+++ b/src/test/java/org/codarama/redlock4j/driver/LettuceRedisDriverTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.driver;
@@ -39,8 +20,7 @@
import static org.mockito.Mockito.*;
/**
- * Unit tests for LettuceRedisDriver using Mockito mocks.
- * These tests do not require a working Redis server.
+ * Unit tests for LettuceRedisDriver using Mockito mocks. These tests do not require a working Redis server.
*/
@ExtendWith(MockitoExtension.class)
public class LettuceRedisDriverTest {
@@ -56,15 +36,11 @@ public class LettuceRedisDriverTest {
private RedisNodeConfiguration testConfig;
private LettuceRedisDriver driver;
-
+
@BeforeEach
void setUp() {
- testConfig = RedisNodeConfiguration.builder()
- .host("localhost")
- .port(6379)
- .connectionTimeoutMs(5000)
- .socketTimeoutMs(5000)
- .build();
+ testConfig = RedisNodeConfiguration.builder().host("localhost").port(6379).connectionTimeoutMs(5000)
+ .socketTimeoutMs(5000).build();
}
@Test
@@ -77,36 +53,26 @@ public void testDriverCreationWithBasicConfig() {
@Test
public void testDriverCreationWithPassword() {
- RedisNodeConfiguration configWithPassword = RedisNodeConfiguration.builder()
- .host("localhost")
- .port(6379)
- .password("testpass")
- .connectionTimeoutMs(5000)
- .socketTimeoutMs(5000)
- .build();
+ RedisNodeConfiguration configWithPassword = RedisNodeConfiguration.builder().host("localhost").port(6379)
+ .password("testpass").connectionTimeoutMs(5000).socketTimeoutMs(5000).build();
driver = new LettuceRedisDriver(configWithPassword, mockRedisClient, mockConnection, mockCommands);
assertNotNull(driver);
assertEquals("redis://localhost:6379", driver.getIdentifier());
}
-
+
@Test
public void testDriverCreationWithDatabase() {
- RedisNodeConfiguration configWithDb = RedisNodeConfiguration.builder()
- .host("localhost")
- .port(6379)
- .database(2)
- .connectionTimeoutMs(5000)
- .socketTimeoutMs(5000)
- .build();
-
+ RedisNodeConfiguration configWithDb = RedisNodeConfiguration.builder().host("localhost").port(6379).database(2)
+ .connectionTimeoutMs(5000).socketTimeoutMs(5000).build();
+
driver = new LettuceRedisDriver(configWithDb, mockRedisClient, mockConnection, mockCommands);
-
+
assertNotNull(driver);
assertEquals("redis://localhost:6379", driver.getIdentifier());
}
-
+
@Test
public void testGetIdentifierFormat() {
// Test identifier format without creating multiple drivers
@@ -114,13 +80,13 @@ public void testGetIdentifierFormat() {
assertEquals("redis://localhost:6379", driver.getIdentifier());
driver.close();
}
-
+
@Test
public void testDriverCreationWithNullConfig() {
- assertThrows(NullPointerException.class, () ->
- new LettuceRedisDriver(null, mockRedisClient, mockConnection, mockCommands));
+ assertThrows(NullPointerException.class,
+ () -> new LettuceRedisDriver(null, mockRedisClient, mockConnection, mockCommands));
}
-
+
@Test
public void testCloseDoesNotThrowException() {
driver = new LettuceRedisDriver(testConfig, mockRedisClient, mockConnection, mockCommands);
@@ -132,7 +98,7 @@ public void testCloseDoesNotThrowException() {
verify(mockConnection).close();
verify(mockRedisClient).shutdown();
}
-
+
@Test
public void testMultipleCloseCallsAreIdempotent() {
driver = new LettuceRedisDriver(testConfig, mockRedisClient, mockConnection, mockCommands);
@@ -178,9 +144,10 @@ public void testSetIfNotExistsException() {
driver = new LettuceRedisDriver(testConfig, mockRedisClient, mockConnection, mockCommands);
when(mockCommands.set(eq("test-key"), eq("test-value"), any(SetArgs.class)))
- .thenThrow(new RuntimeException("Connection failed"));
+ .thenThrow(new RuntimeException("Connection failed"));
- RedisDriverException exception = assertThrows(RedisDriverException.class, () -> driver.setIfNotExists("test-key", "test-value", 10000));
+ RedisDriverException exception = assertThrows(RedisDriverException.class,
+ () -> driver.setIfNotExists("test-key", "test-value", 10000));
assertTrue(exception.getMessage().contains("Failed to execute SET NX PX command"));
assertTrue(exception.getMessage().contains("redis://localhost:6379"));
@@ -218,13 +185,13 @@ public void testDeleteIfValueMatchesFailure() throws RedisDriverException {
public void testDeleteIfValueMatchesException() {
// Mock dispatch() for CAD detection (returns success, indicating native support)
// Then throw exception for the actual delete
- when(mockCommands.dispatch(any(), any(), any()))
- .thenReturn(1L)
- .thenThrow(new RuntimeException("DELEX execution failed"));
+ when(mockCommands.dispatch(any(), any(), any())).thenReturn(1L)
+ .thenThrow(new RuntimeException("DELEX execution failed"));
driver = new LettuceRedisDriver(testConfig, mockRedisClient, mockConnection, mockCommands);
- RedisDriverException exception = assertThrows(RedisDriverException.class, () -> driver.deleteIfValueMatches("test-key", "test-value"));
+ RedisDriverException exception = assertThrows(RedisDriverException.class,
+ () -> driver.deleteIfValueMatches("test-key", "test-value"));
assertTrue(exception.getMessage().contains("Failed to execute DELEX command"));
assertTrue(exception.getMessage().contains("redis://localhost:6379"));
@@ -256,15 +223,9 @@ public void testIsConnectedFailure() {
@Test
public void testGetIdentifierWithDifferentConfigurations() {
- RedisNodeConfiguration config1 = RedisNodeConfiguration.builder()
- .host("redis1.example.com")
- .port(6379)
- .build();
-
- RedisNodeConfiguration config2 = RedisNodeConfiguration.builder()
- .host("redis2.example.com")
- .port(6380)
- .build();
+ RedisNodeConfiguration config1 = RedisNodeConfiguration.builder().host("redis1.example.com").port(6379).build();
+
+ RedisNodeConfiguration config2 = RedisNodeConfiguration.builder().host("redis2.example.com").port(6380).build();
LettuceRedisDriver driver1 = new LettuceRedisDriver(config1, mockRedisClient, mockConnection, mockCommands);
LettuceRedisDriver driver2 = new LettuceRedisDriver(config2, mockRedisClient, mockConnection, mockCommands);
diff --git a/src/test/java/org/codarama/redlock4j/examples/AdvancedLockingExample.java b/src/test/java/org/codarama/redlock4j/examples/AdvancedLockingExample.java
index 4081055..4c77caa 100644
--- a/src/test/java/org/codarama/redlock4j/examples/AdvancedLockingExample.java
+++ b/src/test/java/org/codarama/redlock4j/examples/AdvancedLockingExample.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.examples;
@@ -32,66 +13,58 @@
import java.util.concurrent.locks.Lock;
/**
- * Example demonstrating advanced locking primitives in Redlock4j:
- * - FairLock: FIFO ordering for lock acquisition
- * - MultiLock: Atomic multi-resource locking
- * - ReadWriteLock: Separate read/write locks
- * - Semaphore: Distributed semaphore with permits
- * - CountDownLatch: Distributed countdown latch
+ * Example demonstrating advanced locking primitives in Redlock4j: - FairLock: FIFO ordering for lock acquisition -
+ * MultiLock: Atomic multi-resource locking - ReadWriteLock: Separate read/write locks - Semaphore: Distributed
+ * semaphore with permits - CountDownLatch: Distributed countdown latch
*/
public class AdvancedLockingExample {
-
+
public static void main(String[] args) throws Exception {
// Configure Redis nodes
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(200))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
-
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381)
+ .defaultLockTimeout(Duration.ofSeconds(30)).retryDelay(Duration.ofMillis(200)).maxRetryAttempts(3)
+ .lockAcquisitionTimeout(Duration.ofSeconds(10)).build();
+
try (RedlockManager manager = RedlockManager.withJedis(config)) {
-
+
if (!manager.isHealthy()) {
System.err.println("RedlockManager is not healthy");
return;
}
-
+
System.out.println("=== Advanced Locking Primitives Demo ===\n");
-
+
// 1. Fair Lock Example
demonstrateFairLock(manager);
-
+
// 2. Multi-Lock Example
demonstrateMultiLock(manager);
-
+
// 3. Read-Write Lock Example
demonstrateReadWriteLock(manager);
-
+
// 4. Semaphore Example
demonstrateSemaphore(manager);
-
+
// 5. CountDownLatch Example
demonstrateCountDownLatch(manager);
-
+
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
-
+
/**
* Demonstrates Fair Lock with FIFO ordering.
*/
private static void demonstrateFairLock(RedlockManager manager) throws InterruptedException {
System.out.println("1. FAIR LOCK EXAMPLE");
System.out.println(" Fair locks ensure FIFO ordering for lock acquisition\n");
-
+
Lock fairLock = manager.createFairLock("fair-resource");
-
+
// Simulate multiple threads competing for the lock
Thread t1 = new Thread(() -> {
try {
@@ -108,7 +81,7 @@ private static void demonstrateFairLock(RedlockManager manager) throws Interrupt
Thread.currentThread().interrupt();
}
});
-
+
Thread t2 = new Thread(() -> {
try {
Thread.sleep(100); // Start slightly after t1
@@ -125,27 +98,25 @@ private static void demonstrateFairLock(RedlockManager manager) throws Interrupt
Thread.currentThread().interrupt();
}
});
-
+
t1.start();
t2.start();
t1.join();
t2.join();
-
+
System.out.println();
}
-
+
/**
* Demonstrates Multi-Lock for atomic multi-resource locking.
*/
private static void demonstrateMultiLock(RedlockManager manager) throws InterruptedException {
System.out.println("2. MULTI-LOCK EXAMPLE");
System.out.println(" Multi-locks allow atomic acquisition of multiple resources\n");
-
+
// Lock multiple accounts atomically to prevent deadlocks
- Lock multiLock = manager.createMultiLock(
- Arrays.asList("account:1", "account:2", "account:3")
- );
-
+ Lock multiLock = manager.createMultiLock(Arrays.asList("account:1", "account:2", "account:3"));
+
System.out.println(" Attempting to lock 3 accounts atomically...");
if (multiLock.tryLock(5, TimeUnit.SECONDS)) {
try {
@@ -160,19 +131,19 @@ private static void demonstrateMultiLock(RedlockManager manager) throws Interrup
} else {
System.out.println(" ✗ Failed to acquire all locks");
}
-
+
System.out.println();
}
-
+
/**
* Demonstrates Read-Write Lock for concurrent reads.
*/
private static void demonstrateReadWriteLock(RedlockManager manager) throws InterruptedException {
System.out.println("3. READ-WRITE LOCK EXAMPLE");
System.out.println(" Multiple readers can access simultaneously, writers get exclusive access\n");
-
+
RedlockReadWriteLock rwLock = manager.createReadWriteLock("shared-data");
-
+
// Start multiple reader threads
Thread reader1 = new Thread(() -> {
try {
@@ -189,7 +160,7 @@ private static void demonstrateReadWriteLock(RedlockManager manager) throws Inte
Thread.currentThread().interrupt();
}
});
-
+
Thread reader2 = new Thread(() -> {
try {
Thread.sleep(100);
@@ -206,7 +177,7 @@ private static void demonstrateReadWriteLock(RedlockManager manager) throws Inte
Thread.currentThread().interrupt();
}
});
-
+
Thread writer = new Thread(() -> {
try {
Thread.sleep(200);
@@ -223,31 +194,31 @@ private static void demonstrateReadWriteLock(RedlockManager manager) throws Inte
Thread.currentThread().interrupt();
}
});
-
+
reader1.start();
reader2.start();
writer.start();
-
+
reader1.join();
reader2.join();
writer.join();
-
+
System.out.println();
}
-
+
/**
* Demonstrates Semaphore for rate limiting.
*/
private static void demonstrateSemaphore(RedlockManager manager) throws InterruptedException {
System.out.println("4. SEMAPHORE EXAMPLE");
System.out.println(" Semaphores limit concurrent access to a resource\n");
-
+
// Create a semaphore with 2 permits (max 2 concurrent accesses)
RedlockSemaphore semaphore = manager.createSemaphore("api-limiter", 2);
-
+
System.out.println(" Created semaphore with 2 permits");
System.out.println(" Starting 4 threads that need permits...\n");
-
+
for (int i = 1; i <= 4; i++) {
final int threadNum = i;
new Thread(() -> {
@@ -269,26 +240,26 @@ private static void demonstrateSemaphore(RedlockManager manager) throws Interrup
Thread.currentThread().interrupt();
}
}).start();
-
+
Thread.sleep(100); // Stagger thread starts
}
-
+
Thread.sleep(5000); // Wait for all threads to complete
System.out.println();
}
-
+
/**
* Demonstrates CountDownLatch for coordinating startup.
*/
private static void demonstrateCountDownLatch(RedlockManager manager) throws InterruptedException {
System.out.println("5. COUNTDOWN LATCH EXAMPLE");
System.out.println(" Countdown latches coordinate multi-stage processes\n");
-
+
// Create a latch that waits for 3 services to initialize
RedlockCountDownLatch latch = manager.createCountDownLatch("startup-latch", 3);
-
+
System.out.println(" Waiting for 3 services to initialize...\n");
-
+
// Start 3 service initialization threads
for (int i = 1; i <= 3; i++) {
final int serviceNum = i;
@@ -298,25 +269,24 @@ private static void demonstrateCountDownLatch(RedlockManager manager) throws Int
Thread.sleep(1000 * serviceNum); // Simulate varying init times
System.out.println(" Service " + serviceNum + ": ✓ Initialized");
latch.countDown();
- System.out.println(" Service " + serviceNum + ": Counted down (remaining: " +
- latch.getCount() + ")");
+ System.out.println(
+ " Service " + serviceNum + ": Counted down (remaining: " + latch.getCount() + ")");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}).start();
}
-
+
// Main thread waits for all services
System.out.println(" Main: Waiting for all services...");
boolean completed = latch.await(10, TimeUnit.SECONDS);
-
+
if (completed) {
System.out.println(" Main: ✓ All services initialized! Application ready.");
} else {
System.out.println(" Main: ✗ Timeout waiting for services");
}
-
+
System.out.println();
}
}
-
diff --git a/src/test/java/org/codarama/redlock4j/examples/AsyncRxUsageExample.java b/src/test/java/org/codarama/redlock4j/examples/AsyncRxUsageExample.java
index 73c52d8..7ceac03 100644
--- a/src/test/java/org/codarama/redlock4j/examples/AsyncRxUsageExample.java
+++ b/src/test/java/org/codarama/redlock4j/examples/AsyncRxUsageExample.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.examples;
@@ -39,49 +20,42 @@
import java.util.concurrent.locks.Lock;
/**
- * Comprehensive example demonstrating all available lock APIs:
- * - Standard Java Lock interface
- * - CompletionStage asynchronous API
- * - RxJava reactive API
+ * Comprehensive example demonstrating all available lock APIs: - Standard Java Lock interface - CompletionStage
+ * asynchronous API - RxJava reactive API
*/
public class AsyncRxUsageExample {
-
+
public static void main(String[] args) {
// Configure Redis nodes
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(200))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
-
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381)
+ .defaultLockTimeout(Duration.ofSeconds(30)).retryDelay(Duration.ofMillis(200)).maxRetryAttempts(3)
+ .lockAcquisitionTimeout(Duration.ofSeconds(10)).build();
+
try (RedlockManager redlockManager = RedlockManager.withJedis(config)) {
-
+
// Example 1: Standard Java Lock Interface
demonstrateStandardLock(redlockManager);
-
+
// Example 2: CompletionStage Asynchronous API
demonstrateCompletionStageAsync(redlockManager);
-
+
// Example 3: RxJava Reactive API
demonstrateRxJavaReactive(redlockManager);
-
+
// Example 4: Combined Async/Reactive Lock
demonstrateCombinedLock(redlockManager);
-
+
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
}
-
+
private static void demonstrateStandardLock(RedlockManager manager) {
System.out.println("\n=== Standard Java Lock Interface ===");
-
+
Lock lock = manager.createLock("standard-lock-resource");
-
+
// Traditional lock usage
lock.lock();
try {
@@ -95,7 +69,7 @@ private static void demonstrateStandardLock(RedlockManager manager) {
lock.unlock();
System.out.println("✅ Standard lock released");
}
-
+
// Try lock with timeout
try {
if (lock.tryLock(5, TimeUnit.SECONDS)) {
@@ -110,194 +84,165 @@ private static void demonstrateStandardLock(RedlockManager manager) {
Thread.currentThread().interrupt();
}
}
-
+
private static void demonstrateCompletionStageAsync(RedlockManager manager) {
System.out.println("\n=== CompletionStage Asynchronous API ===");
-
+
AsyncRedlock asyncLock = manager.createAsyncLock("async-resource");
-
+
// Async lock with CompletionStage
CompletionStage lockFuture = asyncLock.tryLockAsync();
-
- lockFuture
- .thenAccept(acquired -> {
- if (acquired) {
- System.out.println("✅ Async lock acquired successfully!");
- System.out.println("Lock key: " + asyncLock.getLockKey());
- System.out.println("Held by current thread: " + asyncLock.isHeldByCurrentThread());
- System.out.println("Remaining validity: " + asyncLock.getRemainingValidityTime() + "ms");
-
- // Simulate async work
- try {
- Thread.sleep(2000);
- System.out.println("Async work completed");
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- }
- } else {
- System.out.println("❌ Failed to acquire async lock");
+
+ lockFuture.thenAccept(acquired -> {
+ if (acquired) {
+ System.out.println("✅ Async lock acquired successfully!");
+ System.out.println("Lock key: " + asyncLock.getLockKey());
+ System.out.println("Held by current thread: " + asyncLock.isHeldByCurrentThread());
+ System.out.println("Remaining validity: " + asyncLock.getRemainingValidityTime() + "ms");
+
+ // Simulate async work
+ try {
+ Thread.sleep(2000);
+ System.out.println("Async work completed");
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
}
- })
- .thenCompose(v -> {
- // Async unlock
- System.out.println("Releasing async lock...");
- return asyncLock.unlockAsync();
- })
- .thenRun(() -> System.out.println("✅ Async lock released successfully!"))
- .exceptionally(throwable -> {
- System.err.println("❌ Async lock error: " + throwable.getMessage());
- return null;
- })
- .toCompletableFuture()
- .join(); // Wait for completion in this example
-
+ } else {
+ System.out.println("❌ Failed to acquire async lock");
+ }
+ }).thenCompose(v -> {
+ // Async unlock
+ System.out.println("Releasing async lock...");
+ return asyncLock.unlockAsync();
+ }).thenRun(() -> System.out.println("✅ Async lock released successfully!")).exceptionally(throwable -> {
+ System.err.println("❌ Async lock error: " + throwable.getMessage());
+ return null;
+ }).toCompletableFuture().join(); // Wait for completion in this example
+
// Async lock with timeout
- asyncLock.tryLockAsync(Duration.ofSeconds(3))
- .thenAccept(acquired -> {
- System.out.println("Async lock with timeout: " + (acquired ? "✅ Success" : "❌ Failed"));
- if (acquired) {
- asyncLock.unlockAsync().toCompletableFuture().join();
- }
- })
- .toCompletableFuture()
- .join();
+ asyncLock.tryLockAsync(Duration.ofSeconds(3)).thenAccept(acquired -> {
+ System.out.println("Async lock with timeout: " + (acquired ? "✅ Success" : "❌ Failed"));
+ if (acquired) {
+ asyncLock.unlockAsync().toCompletableFuture().join();
+ }
+ }).toCompletableFuture().join();
}
-
+
private static void demonstrateRxJavaReactive(RedlockManager manager) {
System.out.println("\n=== RxJava Reactive API ===");
-
+
RxRedlock rxLock = manager.createRxLock("rxjava-resource");
-
+
// RxJava Single for lock acquisition
Single lockSingle = rxLock.tryLockRx();
-
- Disposable lockDisposable = lockSingle
- .subscribe(
- acquired -> {
- if (acquired) {
- System.out.println("✅ RxJava lock acquired successfully!");
- System.out.println("Lock key: " + rxLock.getLockKey());
- System.out.println("Held by current thread: " + rxLock.isHeldByCurrentThread());
-
- // Start RxJava validity monitoring
- startRxValidityMonitoring(rxLock);
-
- // Start lock state monitoring
- startRxLockStateMonitoring(rxLock);
-
- // Simulate work
- try {
- Thread.sleep(4000);
- System.out.println("RxJava work completed");
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- }
-
- // Release lock with RxJava Completable
- Completable unlockCompletable = rxLock.unlockRx();
- Disposable result = unlockCompletable.subscribe(
- () -> System.out.println("✅ RxJava lock released successfully!"),
- throwable -> System.err.println("❌ RxJava unlock error: " + throwable.getMessage())
- );
- } else {
- System.out.println("❌ Failed to acquire RxJava lock");
- }
- },
- throwable -> System.err.println("❌ RxJava lock error: " + throwable.getMessage())
- );
-
+
+ Disposable lockDisposable = lockSingle.subscribe(acquired -> {
+ if (acquired) {
+ System.out.println("✅ RxJava lock acquired successfully!");
+ System.out.println("Lock key: " + rxLock.getLockKey());
+ System.out.println("Held by current thread: " + rxLock.isHeldByCurrentThread());
+
+ // Start RxJava validity monitoring
+ startRxValidityMonitoring(rxLock);
+
+ // Start lock state monitoring
+ startRxLockStateMonitoring(rxLock);
+
+ // Simulate work
+ try {
+ Thread.sleep(4000);
+ System.out.println("RxJava work completed");
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+
+ // Release lock with RxJava Completable
+ Completable unlockCompletable = rxLock.unlockRx();
+ Disposable result = unlockCompletable.subscribe(
+ () -> System.out.println("✅ RxJava lock released successfully!"),
+ throwable -> System.err.println("❌ RxJava unlock error: " + throwable.getMessage()));
+ } else {
+ System.out.println("❌ Failed to acquire RxJava lock");
+ }
+ }, throwable -> System.err.println("❌ RxJava lock error: " + throwable.getMessage()));
+
// Wait for RxJava operations to complete
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
-
+
if (!lockDisposable.isDisposed()) {
lockDisposable.dispose();
}
}
-
+
private static void startRxValidityMonitoring(RxRedlock rxLock) {
System.out.println("📊 Starting RxJava validity monitoring...");
-
+
Observable validityObservable = rxLock.validityObservable(Duration.ofSeconds(1));
-
- Disposable validityDisposable = validityObservable
- .take(3) // Take only 3 emissions
- .subscribe(
- validityTime -> System.out.println("📊 RxJava validity: " + validityTime + "ms remaining"),
- throwable -> System.err.println("❌ RxJava validity error: " + throwable.getMessage()),
- () -> System.out.println("🏁 RxJava validity monitoring completed")
- );
+
+ Disposable validityDisposable = validityObservable.take(3) // Take only 3 emissions
+ .subscribe(validityTime -> System.out.println("📊 RxJava validity: " + validityTime + "ms remaining"),
+ throwable -> System.err.println("❌ RxJava validity error: " + throwable.getMessage()),
+ () -> System.out.println("🏁 RxJava validity monitoring completed"));
}
-
+
private static void startRxLockStateMonitoring(RxRedlock rxLock) {
System.out.println("📊 Starting RxJava lock state monitoring...");
-
+
Observable stateObservable = rxLock.lockStateObservable();
-
- Disposable stateDisposable = stateObservable
- .take(3) // Monitor a few state changes
- .subscribe(
- state -> System.out.println("📊 RxJava lock state: " + state),
- throwable -> System.err.println("❌ RxJava state monitoring error: " + throwable.getMessage()),
- () -> System.out.println("🏁 RxJava state monitoring completed")
- );
+
+ Disposable stateDisposable = stateObservable.take(3) // Monitor a few state changes
+ .subscribe(state -> System.out.println("📊 RxJava lock state: " + state),
+ throwable -> System.err.println("❌ RxJava state monitoring error: " + throwable.getMessage()),
+ () -> System.out.println("🏁 RxJava state monitoring completed"));
}
-
+
private static void demonstrateCombinedLock(RedlockManager manager) {
System.out.println("\n=== Combined Async/Reactive Lock ===");
-
+
AsyncRedlockImpl combinedLock = manager.createAsyncRxLock("combined-resource");
-
+
// Use CompletionStage interface for acquisition
System.out.println("🔄 Acquiring lock via CompletionStage interface...");
- combinedLock.tryLockAsync()
- .thenAccept(acquired -> {
- if (acquired) {
- System.out.println("✅ Lock acquired via CompletionStage interface!");
-
- // Use RxJava interface for monitoring
- System.out.println("📊 Monitoring via RxJava interface...");
- Observable validityObservable = combinedLock.validityObservable(Duration.ofMillis(500));
-
- Disposable monitoringDisposable = validityObservable
- .take(2)
- .subscribe(
- validityTime -> System.out.println("📊 Combined lock validity: " + validityTime + "ms"),
- throwable -> System.err.println("❌ Monitoring error: " + throwable.getMessage()),
- () -> {
- System.out.println("🏁 Combined lock monitoring completed");
-
- // Release via CompletionStage interface
- System.out.println("🔄 Releasing lock via CompletionStage interface...");
- combinedLock.unlockAsync()
- .thenRun(() -> System.out.println("✅ Combined lock released!"))
+ combinedLock.tryLockAsync().thenAccept(acquired -> {
+ if (acquired) {
+ System.out.println("✅ Lock acquired via CompletionStage interface!");
+
+ // Use RxJava interface for monitoring
+ System.out.println("📊 Monitoring via RxJava interface...");
+ Observable validityObservable = combinedLock.validityObservable(Duration.ofMillis(500));
+
+ Disposable monitoringDisposable = validityObservable.take(2).subscribe(
+ validityTime -> System.out.println("📊 Combined lock validity: " + validityTime + "ms"),
+ throwable -> System.err.println("❌ Monitoring error: " + throwable.getMessage()), () -> {
+ System.out.println("🏁 Combined lock monitoring completed");
+
+ // Release via CompletionStage interface
+ System.out.println("🔄 Releasing lock via CompletionStage interface...");
+ combinedLock.unlockAsync().thenRun(() -> System.out.println("✅ Combined lock released!"))
.exceptionally(throwable -> {
System.err.println("❌ Release error: " + throwable.getMessage());
return null;
});
- }
- );
- } else {
- System.out.println("❌ Failed to acquire combined lock");
- }
- })
- .exceptionally(throwable -> {
- System.err.println("❌ Combined lock error: " + throwable.getMessage());
- return null;
- })
- .toCompletableFuture()
- .join();
-
+ });
+ } else {
+ System.out.println("❌ Failed to acquire combined lock");
+ }
+ }).exceptionally(throwable -> {
+ System.err.println("❌ Combined lock error: " + throwable.getMessage());
+ return null;
+ }).toCompletableFuture().join();
+
// Wait for operations to complete
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
-
+
System.out.println("\n🎉 All examples completed!");
}
}
diff --git a/src/test/java/org/codarama/redlock4j/examples/RedlockUsageExample.java b/src/test/java/org/codarama/redlock4j/examples/RedlockUsageExample.java
index 0d88401..3bc49de 100644
--- a/src/test/java/org/codarama/redlock4j/examples/RedlockUsageExample.java
+++ b/src/test/java/org/codarama/redlock4j/examples/RedlockUsageExample.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.examples;
@@ -35,31 +16,26 @@
* Example demonstrating how to use the Redlock implementation.
*/
public class RedlockUsageExample {
-
+
public static void main(String[] args) {
// Configure Redis nodes (minimum 3 for proper Redlock operation)
- RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("localhost", 6379)
- .addRedisNode("localhost", 6380)
- .addRedisNode("localhost", 6381)
- .defaultLockTimeout(Duration.ofSeconds(30))
- .retryDelay(Duration.ofMillis(200))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
- .build();
-
+ RedlockConfiguration config = RedlockConfiguration.builder().addRedisNode("localhost", 6379)
+ .addRedisNode("localhost", 6380).addRedisNode("localhost", 6381)
+ .defaultLockTimeout(Duration.ofSeconds(30)).retryDelay(Duration.ofMillis(200)).maxRetryAttempts(3)
+ .lockAcquisitionTimeout(Duration.ofSeconds(10)).build();
+
// Create RedlockManager with Jedis (or use withLettuce for Lettuce)
try (RedlockManager redlockManager = RedlockManager.withJedis(config)) {
-
+
// Check if the manager is healthy
if (!redlockManager.isHealthy()) {
System.err.println("RedlockManager is not healthy - not enough connected nodes");
return;
}
-
+
// Create a lock for a specific resource
Lock lock = redlockManager.createLock("my-resource-key");
-
+
// Example 1: Simple lock/unlock
System.out.println("Attempting to acquire lock...");
lock.lock();
@@ -75,7 +51,7 @@ public static void main(String[] args) {
lock.unlock();
System.out.println("Lock released.");
}
-
+
// Example 2: Try lock with timeout
System.out.println("\nAttempting to acquire lock with timeout...");
try {
@@ -95,7 +71,7 @@ public static void main(String[] args) {
Thread.currentThread().interrupt();
System.err.println("Lock acquisition interrupted");
}
-
+
// Example 3: Non-blocking try lock
System.out.println("\nAttempting non-blocking lock acquisition...");
if (lock.tryLock()) {
@@ -113,22 +89,22 @@ public static void main(String[] args) {
} else {
System.out.println("Lock is currently held by another process.");
}
-
+
// Example 4: Using Redlock specific methods
if (lock instanceof Redlock) {
Redlock redlock = (Redlock) lock;
-
+
if (redlock.tryLock()) {
try {
System.out.println("\nLock acquired. Checking lock state...");
System.out.println("Is held by current thread: " + redlock.isHeldByCurrentThread());
System.out.println("Remaining validity time: " + redlock.getRemainingValidityTime() + "ms");
-
+
Thread.sleep(1000);
-
+
System.out.println("After 1 second...");
System.out.println("Remaining validity time: " + redlock.getRemainingValidityTime() + "ms");
-
+
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
@@ -137,11 +113,11 @@ public static void main(String[] args) {
}
}
}
-
+
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
}
-
+
System.out.println("\nExample completed.");
}
}
diff --git a/src/test/java/org/codarama/redlock4j/integration/AdvancedLockingIntegrationTest.java b/src/test/java/org/codarama/redlock4j/integration/AdvancedLockingIntegrationTest.java
index 62f6ca3..cb6fdff 100644
--- a/src/test/java/org/codarama/redlock4j/integration/AdvancedLockingIntegrationTest.java
+++ b/src/test/java/org/codarama/redlock4j/integration/AdvancedLockingIntegrationTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.integration;
@@ -49,31 +30,24 @@ public class AdvancedLockingIntegrationTest {
@Container
static GenericContainer redis1 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
@Container
static GenericContainer redis2 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
@Container
static GenericContainer redis3 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
private static RedlockConfiguration testConfiguration;
@BeforeAll
static void setUp() {
- testConfiguration = RedlockConfiguration.builder()
- .addRedisNode("localhost", redis1.getMappedPort(6379))
+ testConfiguration = RedlockConfiguration.builder().addRedisNode("localhost", redis1.getMappedPort(6379))
.addRedisNode("localhost", redis2.getMappedPort(6379))
- .addRedisNode("localhost", redis3.getMappedPort(6379))
- .defaultLockTimeout(Duration.ofSeconds(10))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(5)
- .lockAcquisitionTimeout(Duration.ofSeconds(10))
+ .addRedisNode("localhost", redis3.getMappedPort(6379)).defaultLockTimeout(Duration.ofSeconds(10))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(5).lockAcquisitionTimeout(Duration.ofSeconds(10))
.build();
}
@@ -143,7 +117,7 @@ public void testSemaphoreConcurrentAccess() throws InterruptedException {
int permits = 2;
int threadCount = 5;
RedlockSemaphore semaphore = manager.createSemaphore("test-semaphore-concurrent", permits);
-
+
AtomicInteger successCount = new AtomicInteger(0);
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(threadCount);
@@ -267,7 +241,7 @@ public void testCountDownLatchAwait() throws InterruptedException {
public void testMultipleConcurrentReaders() throws InterruptedException {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
RedlockReadWriteLock rwLock = manager.createReadWriteLock("test-rwlock-concurrent");
-
+
int readerCount = 3;
AtomicInteger concurrentReaders = new AtomicInteger(0);
AtomicInteger maxConcurrent = new AtomicInteger(0);
@@ -279,15 +253,15 @@ public void testMultipleConcurrentReaders() throws InterruptedException {
try (RedlockManager mgr = RedlockManager.withJedis(testConfiguration)) {
RedlockReadWriteLock lock = mgr.createReadWriteLock("test-rwlock-concurrent");
Lock readLock = lock.readLock();
-
+
startLatch.await();
readLock.lock();
-
+
int current = concurrentReaders.incrementAndGet();
maxConcurrent.updateAndGet(max -> Math.max(max, current));
-
+
Thread.sleep(100);
-
+
concurrentReaders.decrementAndGet();
readLock.unlock();
} catch (InterruptedException e) {
@@ -304,4 +278,3 @@ public void testMultipleConcurrentReaders() throws InterruptedException {
}
}
}
-
diff --git a/src/test/java/org/codarama/redlock4j/integration/AsyncRedlockIntegrationTest.java b/src/test/java/org/codarama/redlock4j/integration/AsyncRedlockIntegrationTest.java
index 4eadd8f..403d488 100644
--- a/src/test/java/org/codarama/redlock4j/integration/AsyncRedlockIntegrationTest.java
+++ b/src/test/java/org/codarama/redlock4j/integration/AsyncRedlockIntegrationTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.integration;
@@ -46,118 +27,111 @@
*/
@Testcontainers
public class AsyncRedlockIntegrationTest {
-
+
@Container
static GenericContainer redis1 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
-
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
+
@Container
static GenericContainer redis2 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
-
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
+
@Container
static GenericContainer redis3 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
-
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
+
private static RedlockConfiguration testConfiguration;
-
+
@BeforeAll
static void setUp() {
- testConfiguration = RedlockConfiguration.builder()
- .addRedisNode("localhost", redis1.getMappedPort(6379))
- .addRedisNode("localhost", redis2.getMappedPort(6379))
- .addRedisNode("localhost", redis3.getMappedPort(6379))
- .defaultLockTimeout(Duration.ofSeconds(10))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(5))
- .build();
+ testConfiguration = RedlockConfiguration.builder().addRedisNode("localhost", redis1.getMappedPort(6379))
+ .addRedisNode("localhost", redis2.getMappedPort(6379))
+ .addRedisNode("localhost", redis3.getMappedPort(6379)).defaultLockTimeout(Duration.ofSeconds(10))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(5))
+ .build();
}
-
+
@Test
public void testAsyncLockBasicFunctionality() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
AsyncRedlock asyncLock = manager.createAsyncLock("test-async-basic");
-
+
// Test async tryLock
CompletionStage lockResult = asyncLock.tryLockAsync();
Boolean acquired = lockResult.toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(acquired, "Should acquire lock asynchronously");
-
+
// Verify lock key
assertEquals("test-async-basic", asyncLock.getLockKey());
-
+
// Test async unlock
CompletionStage unlockResult = asyncLock.unlockAsync();
unlockResult.toCompletableFuture().get(5, TimeUnit.SECONDS);
-
+
// Test should complete without exceptions
System.out.println("✅ Async lock test completed successfully");
}
}
-
+
@Test
public void testRxJavaBasicFunctionality() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
RxRedlock rxLock = manager.createRxLock("test-rxjava-basic");
-
+
// Test RxJava Single tryLock
TestObserver lockObserver = rxLock.tryLockRx().test();
lockObserver.await(5, TimeUnit.SECONDS);
lockObserver.assertComplete();
lockObserver.assertValue(true);
-
+
// Verify lock key
assertEquals("test-rxjava-basic", rxLock.getLockKey());
-
+
// Test RxJava Completable unlock
TestObserver unlockObserver = rxLock.unlockRx().test();
unlockObserver.await(5, TimeUnit.SECONDS);
unlockObserver.assertComplete();
-
+
System.out.println("✅ RxJava lock test completed successfully");
}
}
-
+
@Test
public void testCombinedAsyncRxLock() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
AsyncRedlockImpl combinedLock = manager.createAsyncRxLock("test-combined-basic");
-
+
// Test CompletionStage interface
Boolean asyncResult = combinedLock.tryLockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(asyncResult, "Should acquire lock via CompletionStage interface");
-
+
// Test RxJava interface on same lock instance
assertEquals("test-combined-basic", combinedLock.getLockKey());
-
+
// Test async unlock
combinedLock.unlockAsync().toCompletableFuture().get(5, TimeUnit.SECONDS);
-
+
System.out.println("✅ Combined async/reactive lock test completed successfully");
}
}
-
+
@Test
public void testAsyncLockWithTimeout() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
AsyncRedlock asyncLock = manager.createAsyncLock("test-async-timeout");
-
+
// Test async tryLock with timeout
CompletionStage lockResult = asyncLock.tryLockAsync(Duration.ofSeconds(2));
Boolean acquired = lockResult.toCompletableFuture().get(5, TimeUnit.SECONDS);
assertTrue(acquired, "Should acquire lock with timeout");
-
+
// Cleanup
asyncLock.unlockAsync().toCompletableFuture().get();
-
+
System.out.println("✅ Async lock with timeout test completed successfully");
}
}
-
+
@Test
public void testRxJavaValidityObservable() throws Exception {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
@@ -169,9 +143,12 @@ public void testRxJavaValidityObservable() throws Exception {
lockObserver.assertValue(true);
// Test validity observable - start immediately and take fewer emissions
- TestObserver validityObserver = rxLock.validityObservable(Duration.ofMillis(300))
- .take(1) // Take only 1 emission to be safe
- .test();
+ TestObserver validityObserver = rxLock.validityObservable(Duration.ofMillis(300)).take(1) // Take only
+ // 1
+ // emission
+ // to be
+ // safe
+ .test();
validityObserver.await(1, TimeUnit.SECONDS);
@@ -179,8 +156,8 @@ public void testRxJavaValidityObservable() throws Exception {
assertFalse(validityObserver.values().isEmpty(), "Should have at least 1 validity emission");
// All validity values should be positive
- validityObserver.values().forEach(validity ->
- assertTrue(validity > 0, "Validity time should be positive: " + validity));
+ validityObserver.values()
+ .forEach(validity -> assertTrue(validity > 0, "Validity time should be positive: " + validity));
// Cleanup
rxLock.unlockRx().test().await();
@@ -188,28 +165,28 @@ public void testRxJavaValidityObservable() throws Exception {
System.out.println("✅ RxJava validity observable test completed successfully");
}
}
-
+
@Test
public void testFactoryMethods() {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
-
+
// Test all factory methods work
AsyncRedlock asyncLock = manager.createAsyncLock("factory-async");
assertNotNull(asyncLock);
assertEquals("factory-async", asyncLock.getLockKey());
-
+
RxRedlock rxLock = manager.createRxLock("factory-rx");
assertNotNull(rxLock);
assertEquals("factory-rx", rxLock.getLockKey());
-
+
AsyncRedlockImpl combinedLock = manager.createAsyncRxLock("factory-combined");
assertNotNull(combinedLock);
assertEquals("factory-combined", combinedLock.getLockKey());
-
+
// Verify combined lock implements both interfaces
assertInstanceOf(AsyncRedlock.class, combinedLock);
assertInstanceOf(RxRedlock.class, combinedLock);
-
+
System.out.println("✅ Factory methods test completed successfully");
}
}
diff --git a/src/test/java/org/codarama/redlock4j/integration/RedlockIntegrationTest.java b/src/test/java/org/codarama/redlock4j/integration/RedlockIntegrationTest.java
index cc7b9f9..7215f52 100644
--- a/src/test/java/org/codarama/redlock4j/integration/RedlockIntegrationTest.java
+++ b/src/test/java/org/codarama/redlock4j/integration/RedlockIntegrationTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.integration;
@@ -42,8 +23,8 @@
import java.util.concurrent.locks.Lock;
/**
- * Integration tests for Redlock functionality using Testcontainers.
- * These tests automatically spin up Redis containers for testing.
+ * Integration tests for Redlock functionality using Testcontainers. These tests automatically spin up Redis containers
+ * for testing.
*/
@Testcontainers
public class RedlockIntegrationTest {
@@ -51,18 +32,15 @@ public class RedlockIntegrationTest {
// Create 3 Redis containers for Redlock testing
@Container
static GenericContainer redis1 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
@Container
static GenericContainer redis2 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
@Container
static GenericContainer redis3 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
private static RedlockConfiguration testConfiguration;
@@ -74,22 +52,18 @@ static void setUp() {
redis3.start();
// Create configuration with dynamic ports from containers
- testConfiguration = RedlockConfiguration.builder()
- .addRedisNode("localhost", redis1.getMappedPort(6379))
- .addRedisNode("localhost", redis2.getMappedPort(6379))
- .addRedisNode("localhost", redis3.getMappedPort(6379))
- .defaultLockTimeout(Duration.ofSeconds(10))
- .retryDelay(Duration.ofMillis(100))
- .maxRetryAttempts(3)
- .lockAcquisitionTimeout(Duration.ofSeconds(5))
- .build();
+ testConfiguration = RedlockConfiguration.builder().addRedisNode("localhost", redis1.getMappedPort(6379))
+ .addRedisNode("localhost", redis2.getMappedPort(6379))
+ .addRedisNode("localhost", redis3.getMappedPort(6379)).defaultLockTimeout(Duration.ofSeconds(10))
+ .retryDelay(Duration.ofMillis(100)).maxRetryAttempts(3).lockAcquisitionTimeout(Duration.ofSeconds(5))
+ .build();
}
@AfterAll
static void tearDown() {
// Containers are automatically stopped by Testcontainers
}
-
+
@Test
public void testJedisBasicLockOperations() {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
@@ -116,7 +90,7 @@ public void testJedisBasicLockOperations() {
}
}
}
-
+
@Test
public void testLettuceBasicLockOperations() {
try (RedlockManager manager = RedlockManager.withLettuce(testConfiguration)) {
@@ -130,7 +104,7 @@ public void testLettuceBasicLockOperations() {
lock.unlock();
}
}
-
+
@Test
public void testLockTimeout() throws InterruptedException {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
@@ -145,7 +119,7 @@ public void testLockTimeout() throws InterruptedException {
lock.unlock();
}
}
-
+
@Test
public void testConcurrentLockAccess() {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
@@ -166,33 +140,18 @@ public void testConcurrentLockAccess() {
lock2.unlock();
}
}
-
+
@Test
public void testLockWithCustomConfiguration() {
RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode(RedisNodeConfiguration.builder()
- .host("localhost")
- .port(redis1.getMappedPort(6379))
- .connectionTimeoutMs(1000)
- .socketTimeoutMs(1000)
- .build())
- .addRedisNode(RedisNodeConfiguration.builder()
- .host("localhost")
- .port(redis2.getMappedPort(6379))
- .connectionTimeoutMs(1000)
- .socketTimeoutMs(1000)
- .build())
- .addRedisNode(RedisNodeConfiguration.builder()
- .host("localhost")
- .port(redis3.getMappedPort(6379))
- .connectionTimeoutMs(1000)
- .socketTimeoutMs(1000)
- .build())
- .defaultLockTimeout(Duration.ofSeconds(5))
- .retryDelay(Duration.ofMillis(50))
- .maxRetryAttempts(2)
- .clockDriftFactor(0.02)
- .build();
+ .addRedisNode(RedisNodeConfiguration.builder().host("localhost").port(redis1.getMappedPort(6379))
+ .connectionTimeoutMs(1000).socketTimeoutMs(1000).build())
+ .addRedisNode(RedisNodeConfiguration.builder().host("localhost").port(redis2.getMappedPort(6379))
+ .connectionTimeoutMs(1000).socketTimeoutMs(1000).build())
+ .addRedisNode(RedisNodeConfiguration.builder().host("localhost").port(redis3.getMappedPort(6379))
+ .connectionTimeoutMs(1000).socketTimeoutMs(1000).build())
+ .defaultLockTimeout(Duration.ofSeconds(5)).retryDelay(Duration.ofMillis(50)).maxRetryAttempts(2)
+ .clockDriftFactor(0.02).build();
try (RedlockManager manager = RedlockManager.withJedis(config)) {
Lock lock = manager.createLock("custom-config-lock");
@@ -201,7 +160,7 @@ public void testLockWithCustomConfiguration() {
lock.unlock();
}
}
-
+
@Test
public void testManagerLifecycle() {
RedlockManager manager = RedlockManager.withJedis(testConfiguration);
@@ -218,7 +177,7 @@ public void testManagerLifecycle() {
// Should throw exception when trying to create locks after close
assertThrows(RedlockException.class, () -> manager.createLock("should-fail"));
}
-
+
@Test
public void testInvalidLockKey() {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
@@ -226,7 +185,7 @@ public void testInvalidLockKey() {
assertThrows(IllegalArgumentException.class, () -> manager.createLock(null));
// Test empty key
- assertThrows(IllegalArgumentException.class, () ->manager.createLock(""));
+ assertThrows(IllegalArgumentException.class, () -> manager.createLock(""));
// Test whitespace-only key
assertThrows(IllegalArgumentException.class, () -> manager.createLock(" "));
@@ -245,9 +204,7 @@ public void testRedisContainerConnectivity() {
assertTrue(redis2.getMappedPort(6379) > 0, "Redis container 2 should have mapped port");
assertTrue(redis3.getMappedPort(6379) > 0, "Redis container 3 should have mapped port");
- System.out.println("Redis containers running on ports: " +
- redis1.getMappedPort(6379) + ", " +
- redis2.getMappedPort(6379) + ", " +
- redis3.getMappedPort(6379));
+ System.out.println("Redis containers running on ports: " + redis1.getMappedPort(6379) + ", "
+ + redis2.getMappedPort(6379) + ", " + redis3.getMappedPort(6379));
}
}
diff --git a/src/test/java/org/codarama/redlock4j/performance/RedlockPerformanceTest.java b/src/test/java/org/codarama/redlock4j/performance/RedlockPerformanceTest.java
index 9f9a593..ef6aa62 100644
--- a/src/test/java/org/codarama/redlock4j/performance/RedlockPerformanceTest.java
+++ b/src/test/java/org/codarama/redlock4j/performance/RedlockPerformanceTest.java
@@ -1,25 +1,6 @@
/*
- * MIT License
- *
+ * SPDX-License-Identifier: MIT
* Copyright (c) 2025 Codarama
- *
- * 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 org.codarama.redlock4j.performance;
@@ -43,8 +24,8 @@
import java.util.concurrent.locks.Lock;
/**
- * Performance tests for Redlock functionality using Testcontainers.
- * These tests are disabled by default as they are for performance analysis.
+ * Performance tests for Redlock functionality using Testcontainers. These tests are disabled by default as they are for
+ * performance analysis.
*/
@Disabled("Performance tests - enable manually when needed")
@Testcontainers
@@ -53,41 +34,34 @@ public class RedlockPerformanceTest {
// Create 3 Redis containers for performance testing
@Container
static GenericContainer redis1 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
@Container
static GenericContainer redis2 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
@Container
static GenericContainer redis3 = new GenericContainer<>(DockerImageName.parse("redis:7-alpine"))
- .withExposedPorts(6379)
- .withCommand("redis-server", "--appendonly", "yes");
+ .withExposedPorts(6379).withCommand("redis-server", "--appendonly", "yes");
private static RedlockConfiguration testConfiguration;
@BeforeAll
static void setUp() {
// Create configuration with dynamic ports from containers
- testConfiguration = RedlockConfiguration.builder()
- .addRedisNode("localhost", redis1.getMappedPort(6379))
- .addRedisNode("localhost", redis2.getMappedPort(6379))
- .addRedisNode("localhost", redis3.getMappedPort(6379))
- .defaultLockTimeout(Duration.ofSeconds(5))
- .retryDelay(Duration.ofMillis(50))
- .maxRetryAttempts(2)
- .lockAcquisitionTimeout(Duration.ofSeconds(2))
- .build();
+ testConfiguration = RedlockConfiguration.builder().addRedisNode("localhost", redis1.getMappedPort(6379))
+ .addRedisNode("localhost", redis2.getMappedPort(6379))
+ .addRedisNode("localhost", redis3.getMappedPort(6379)).defaultLockTimeout(Duration.ofSeconds(5))
+ .retryDelay(Duration.ofMillis(50)).maxRetryAttempts(2).lockAcquisitionTimeout(Duration.ofSeconds(2))
+ .build();
}
-
+
@Test
public void testLockAcquisitionPerformance() throws InterruptedException {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
int iterations = 1000;
long startTime = System.currentTimeMillis();
-
+
for (int i = 0; i < iterations; i++) {
Lock lock = manager.createLock("perf-test-" + i);
if (lock.tryLock()) {
@@ -99,11 +73,11 @@ public void testLockAcquisitionPerformance() throws InterruptedException {
}
}
}
-
+
long endTime = System.currentTimeMillis();
long totalTime = endTime - startTime;
double avgTime = (double) totalTime / iterations;
-
+
System.out.println("Lock acquisition performance test:");
System.out.println("Total iterations: " + iterations);
System.out.println("Total time: " + totalTime + "ms");
@@ -111,27 +85,27 @@ public void testLockAcquisitionPerformance() throws InterruptedException {
System.out.println("Locks per second: " + String.format("%.2f", 1000.0 / avgTime));
}
}
-
+
@Test
public void testConcurrentLockContention() throws InterruptedException {
try (RedlockManager manager = RedlockManager.withJedis(testConfiguration)) {
int threadCount = 10;
int iterationsPerThread = 100;
String lockKey = "contention-test-lock";
-
+
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(threadCount);
AtomicInteger successfulLocks = new AtomicInteger(0);
AtomicInteger failedLocks = new AtomicInteger(0);
-
+
long startTime = System.currentTimeMillis();
-
+
for (int i = 0; i < threadCount; i++) {
executor.submit(() -> {
try {
startLatch.await(); // Wait for all threads to be ready
-
+
for (int j = 0; j < iterationsPerThread; j++) {
Lock lock = manager.createLock(lockKey);
if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {
@@ -153,54 +127,53 @@ public void testConcurrentLockContention() throws InterruptedException {
}
});
}
-
+
startLatch.countDown(); // Start all threads
endLatch.await(); // Wait for all threads to complete
-
+
long endTime = System.currentTimeMillis();
long totalTime = endTime - startTime;
-
+
executor.shutdown();
-
+
System.out.println("\nConcurrent lock contention test:");
System.out.println("Threads: " + threadCount);
System.out.println("Iterations per thread: " + iterationsPerThread);
System.out.println("Total attempts: " + (threadCount * iterationsPerThread));
System.out.println("Successful locks: " + successfulLocks.get());
System.out.println("Failed locks: " + failedLocks.get());
- System.out.println("Success rate: " + String.format("%.2f",
- (double) successfulLocks.get() / (threadCount * iterationsPerThread) * 100) + "%");
+ System.out.println("Success rate: "
+ + String.format("%.2f", (double) successfulLocks.get() / (threadCount * iterationsPerThread) * 100)
+ + "%");
System.out.println("Total time: " + totalTime + "ms");
- System.out.println("Average time per attempt: " +
- String.format("%.2f", (double) totalTime / (threadCount * iterationsPerThread)) + "ms");
+ System.out.println("Average time per attempt: "
+ + String.format("%.2f", (double) totalTime / (threadCount * iterationsPerThread)) + "ms");
}
}
-
+
@Test
public void testJedisVsLettucePerformance() throws InterruptedException {
int iterations = 500;
// Test Jedis performance
- long jedisTime = testDriverPerformance("Jedis",
- RedlockManager.withJedis(testConfiguration), iterations);
+ long jedisTime = testDriverPerformance("Jedis", RedlockManager.withJedis(testConfiguration), iterations);
// Test Lettuce performance
- long lettuceTime = testDriverPerformance("Lettuce",
- RedlockManager.withLettuce(testConfiguration), iterations);
-
+ long lettuceTime = testDriverPerformance("Lettuce", RedlockManager.withLettuce(testConfiguration), iterations);
+
System.out.println("\nDriver Performance Comparison:");
System.out.println("Jedis total time: " + jedisTime + "ms");
System.out.println("Lettuce total time: " + lettuceTime + "ms");
System.out.println("Jedis avg per lock: " + String.format("%.2f", (double) jedisTime / iterations) + "ms");
System.out.println("Lettuce avg per lock: " + String.format("%.2f", (double) lettuceTime / iterations) + "ms");
-
+
if (jedisTime < lettuceTime) {
System.out.println("Jedis is " + String.format("%.2f", (double) lettuceTime / jedisTime) + "x faster");
} else {
System.out.println("Lettuce is " + String.format("%.2f", (double) jedisTime / lettuceTime) + "x faster");
}
}
-
+
private long testDriverPerformance(String driverName, RedlockManager manager, int iterations)
throws InterruptedException {
try {
@@ -224,34 +197,34 @@ private long testDriverPerformance(String driverName, RedlockManager manager, in
manager.close();
}
}
-
+
@Test
public void testLockValidityTimeAccuracy() throws InterruptedException {
RedlockConfiguration config = RedlockConfiguration.builder()
- .addRedisNode("localhost", redis1.getMappedPort(6379))
- .addRedisNode("localhost", redis2.getMappedPort(6379))
- .addRedisNode("localhost", redis3.getMappedPort(6379))
- .defaultLockTimeout(Duration.ofSeconds(2)) // Short timeout for testing
- .retryDelay(Duration.ofMillis(50))
- .maxRetryAttempts(1)
- .build();
+ .addRedisNode("localhost", redis1.getMappedPort(6379))
+ .addRedisNode("localhost", redis2.getMappedPort(6379))
+ .addRedisNode("localhost", redis3.getMappedPort(6379)).defaultLockTimeout(Duration.ofSeconds(2)) // Short
+ // timeout
+ // for
+ // testing
+ .retryDelay(Duration.ofMillis(50)).maxRetryAttempts(1).build();
try (RedlockManager manager = RedlockManager.withJedis(config)) {
Lock lock = manager.createLock("validity-test-lock");
-
+
if (lock.tryLock() && lock instanceof Redlock) {
Redlock redlock = (Redlock) lock;
-
+
long initialValidity = redlock.getRemainingValidityTime();
System.out.println("\nLock validity time test:");
System.out.println("Initial validity time: " + initialValidity + "ms");
-
+
Thread.sleep(500);
-
+
long afterDelay = redlock.getRemainingValidityTime();
System.out.println("Validity after 500ms: " + afterDelay + "ms");
System.out.println("Actual time passed: " + (initialValidity - afterDelay) + "ms");
-
+
redlock.unlock();
}
}