From 3683a706e3d195858013345220f8f1679fecbfc0 Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Mon, 15 Feb 2021 14:03:26 +0100
Subject: [PATCH 01/11] Use remaining 3 bits to expand generator-id space

---
 .../LocalUniqueIDGeneratorFactory.java        |  4 +-
 .../lable/oss/uniqueid/bytes/Blueprint.java   |  2 +-
 .../lable/oss/uniqueid/bytes/IDBuilder.java   | 11 +--
 .../LocalUniqueIDGeneratorFactoryTest.java    |  2 +-
 .../oss/uniqueid/bytes/IDBuilderTest.java     | 34 +++++++-
 .../lable/oss/uniqueid/etcd/EtcdHelper.java   |  4 +
 .../oss/uniqueid/etcd/ResourceClaim.java      |  9 ++-
 .../uniqueid/etcd/HighGeneratorCountIT.java   | 81 +++++++++++++++++++
 .../uniqueid/etcd/MultipleClusterIdsIT.java   |  2 +-
 9 files changed, 135 insertions(+), 14 deletions(-)
 create mode 100644 uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/HighGeneratorCountIT.java

diff --git a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactory.java b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactory.java
index 8450a2c..fb1232b 100644
--- a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactory.java
+++ b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactory.java
@@ -37,7 +37,7 @@ public class LocalUniqueIDGeneratorFactory {
      * Return the UniqueIDGenerator instance for this specific generator-ID, cluster-ID combination. If one was
      * already created, that is returned.
      *
-     * @param generatorId Generator ID to use (0 ≤ n ≤ 255).
+     * @param generatorId Generator ID to use (0 ≤ n ≤ 2047).
      * @param clusterId   Cluster ID to use (0 ≤ n ≤ 15).
      * @param clock       Clock implementation.
      * @param mode        Generator mode.
@@ -58,7 +58,7 @@ public synchronized static IDGenerator generatorFor(int generatorId, int cluster
      * Return the UniqueIDGenerator instance for this specific generator-ID, cluster-ID combination. If one was
      * already created, that is returned.
      *
-     * @param generatorId Generator ID to use (0 ≤ n ≤ 255).
+     * @param generatorId Generator ID to use (0 ≤ n ≤ 2047).
      * @param clusterId   Cluster ID to use (0 ≤ n ≤ 15).
      * @param mode        Generator mode.
      * @return A thread-safe UniqueIDGenerator instance.
diff --git a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/Blueprint.java b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/Blueprint.java
index 922fed2..b35f65f 100644
--- a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/Blueprint.java
+++ b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/Blueprint.java
@@ -34,7 +34,7 @@ public class Blueprint {
     /**
      * Upper bound (inclusive) of the generator-ID.
      */
-    public final static int MAX_GENERATOR_ID = 255;
+    public final static int MAX_GENERATOR_ID = 2047;
 
     /**
      * Upper bound (inclusive) of the cluster-ID.
diff --git a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/IDBuilder.java b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/IDBuilder.java
index b554da2..2f6b01a 100644
--- a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/IDBuilder.java
+++ b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/bytes/IDBuilder.java
@@ -24,7 +24,7 @@
  * <p>
  * The eight byte ID is composed as follows:
  *
- * <pre>TTTTTTTT TTTTTTTT TTTTTTTT TTTTTTTT TTTTTTTT TTSSSSSS ...MGGGG GGGGCCCC</pre>
+ * <pre>TTTTTTTT TTTTTTTT TTTTTTTT TTTTTTTT TTTTTTTT TTSSSSSS GGGMGGGG GGGGCCCC</pre>
  *
  * <ul>
  * <li><code>T</code>: Timestamp (in milliseconds, bit order depends on mode)
@@ -67,8 +67,9 @@ public static byte[] build(Blueprint blueprint) {
         tsBytes[5] = (byte) or;
 
         // Last two bytes. The mode flag, generator ID, and cluster ID.
-        // [6] ...MGGGG  [7] GGGGCCCC
-        int flagGeneratorCluster = blueprint.getGeneratorId() << 4;
+        // [6] GGGMGGGG  [7] GGGGCCCC
+        int flagGeneratorCluster = (blueprint.getGeneratorId() << 5) & 0xE000;
+        flagGeneratorCluster += (blueprint.getGeneratorId() & 0x00FF) << 4;
         flagGeneratorCluster += blueprint.getClusterId();
         flagGeneratorCluster += blueprint.getMode().getModeMask() << 12;
 
@@ -160,8 +161,8 @@ private static int parseSequenceIdNoChecks(byte[] id) {
     }
 
     private static int parseGeneratorIdNoChecks(byte[] id) {
-        // [6] ....GGGG  [7] GGGG....
-        return (id[7] >> 4 & 0x0F) | (id[6] << 4 & 0xF0);
+        // [6] GGG.GGGG  [7] GGGG....
+        return (id[7] >> 4 & 0x0F) | (id[6] << 3 & 0x0700) | (id[6] << 4 & 0xF0);
     }
 
     private static int parseClusterIdNoChecks(byte[] id) {
diff --git a/uniqueid-core/src/test/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactoryTest.java b/uniqueid-core/src/test/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactoryTest.java
index d4147c4..5262e99 100644
--- a/uniqueid-core/src/test/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactoryTest.java
+++ b/uniqueid-core/src/test/java/org/lable/oss/uniqueid/LocalUniqueIDGeneratorFactoryTest.java
@@ -22,7 +22,7 @@ public class LocalUniqueIDGeneratorFactoryTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void outOfBoundsGeneratorIDTest() {
-        LocalUniqueIDGeneratorFactory.generatorFor(256, 0, Mode.SPREAD);
+        LocalUniqueIDGeneratorFactory.generatorFor(2048, 0, Mode.SPREAD);
     }
 
     @Test(expected = IllegalArgumentException.class)
diff --git a/uniqueid-core/src/test/java/org/lable/oss/uniqueid/bytes/IDBuilderTest.java b/uniqueid-core/src/test/java/org/lable/oss/uniqueid/bytes/IDBuilderTest.java
index 1c04d29..3eea82f 100644
--- a/uniqueid-core/src/test/java/org/lable/oss/uniqueid/bytes/IDBuilderTest.java
+++ b/uniqueid-core/src/test/java/org/lable/oss/uniqueid/bytes/IDBuilderTest.java
@@ -17,6 +17,10 @@
 
 import org.apache.commons.codec.binary.Hex;
 import org.junit.Test;
+import org.lable.oss.uniqueid.ByteArray;
+
+import java.util.HashSet;
+import java.util.Set;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
@@ -41,8 +45,7 @@ public void buildMostlyOnes() {
                 Blueprint.MAX_CLUSTER_ID,
                 Mode.SPREAD
         ));
-        // The "0f" for the 7th byte is due to the reserved bits that are always zero for the SPREAD mode.
-        final String expected = "ffffffffffff0fff";
+        final String expected = "ffffffffffffefff";
 
         // Baseline check, if all ID parts are all ones so is the result (except for the reserved bytes).
         assertThat(Hex.encodeHexString(result), is(expected));
@@ -234,4 +237,31 @@ public void parseIllegalArgument() {
     public void parseIllegalArgumentNull() {
         IDBuilder.parse(null);
     }
+
+    @Test
+    public void fullGeneratorSpace() {
+        // Verify that bitwise operations in IDBuilder work.
+        Set<ByteArray> results = new HashSet<>();
+        for (int generatorId = 0; generatorId <= Blueprint.MAX_GENERATOR_ID; generatorId++) {
+            byte[] result = IDBuilder.build(new Blueprint(
+                    Blueprint.MAX_TIMESTAMP,
+                    Blueprint.MAX_SEQUENCE_COUNTER,
+                    generatorId,
+                    Blueprint.MAX_CLUSTER_ID,
+                    Mode.SPREAD
+            ));
+            results.add(new ByteArray(result));
+
+            result = IDBuilder.build(new Blueprint(
+                    Blueprint.MAX_TIMESTAMP,
+                    Blueprint.MAX_SEQUENCE_COUNTER,
+                    generatorId,
+                    Blueprint.MAX_CLUSTER_ID,
+                    Mode.TIME_SEQUENTIAL
+            ));
+            results.add(new ByteArray(result));
+        }
+
+        assertThat(results.size(), is(2 *(Blueprint.MAX_GENERATOR_ID + 1)));
+    }
 }
\ No newline at end of file
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java
index 9450f1f..2a582b4 100644
--- a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java
@@ -49,6 +49,10 @@ public static void put(Client etcd, String key, int value) throws ExecutionExcep
         etcd.getKVClient().put(asByteSequence(key), asByteSequence(value)).get();
     }
 
+    public static void put(Client etcd, String key) throws ExecutionException, InterruptedException {
+        etcd.getKVClient().put(asByteSequence(key),ByteSequence.EMPTY).get();
+    }
+
     public static void delete(Client etcd, String key) throws ExecutionException, InterruptedException {
         etcd.getKVClient().delete(asByteSequence(key)).get();
     }
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java
index b0ac53b..8a436ec 100644
--- a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java
@@ -186,14 +186,17 @@ public void close(boolean nodeAlreadyDeleted) {
             // Already relinquished nothing to do.
             return;
         }
-        state = State.CLAIM_RELINQUISHED;
 
         logger.debug("Closing resource-claim ({}).", resourceKey(clusterId, generatorId));
 
         // No need to delete the node if the reason we are closing is the deletion of said node.
-        if (nodeAlreadyDeleted) return;
+        if (nodeAlreadyDeleted) {
+            state = State.CLAIM_RELINQUISHED;
+            return;
+        }
 
         if (state == State.HAS_CLAIM) {
+            state = State.CLAIM_RELINQUISHED;
             // Hang on to the claimed resource without using it for a short while to facilitate clock skew.
             // That is, if any participant is generating IDs with a slightly skewed clock, it can generate IDs that
             // overlap with the ones generated by the participant who successfully claims the same resource before or
@@ -206,6 +209,8 @@ public void run() {
                 // Two seconds seems reasonable. The NTP docs state that clocks running more than 128ms out of sync are
                 // rare under normal conditions.
             }, TimeUnit.SECONDS.toMillis(2));
+        } else {
+            state = State.CLAIM_RELINQUISHED;
         }
 
         for (Closeable closeable : closeables) {
diff --git a/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/HighGeneratorCountIT.java b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/HighGeneratorCountIT.java
new file mode 100644
index 0000000..a8a856e
--- /dev/null
+++ b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/HighGeneratorCountIT.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2014 Lable (info@lable.nl)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lable.oss.uniqueid.etcd;
+
+import io.etcd.jetcd.ByteSequence;
+import io.etcd.jetcd.Client;
+import io.etcd.jetcd.launcher.junit4.EtcdClusterResource;
+import org.apache.commons.codec.binary.Hex;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.lable.oss.uniqueid.ByteArray;
+import org.lable.oss.uniqueid.GeneratorException;
+import org.lable.oss.uniqueid.IDGenerator;
+import org.lable.oss.uniqueid.bytes.Blueprint;
+import org.lable.oss.uniqueid.bytes.IDBuilder;
+import org.lable.oss.uniqueid.bytes.Mode;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.lable.oss.uniqueid.etcd.SynchronizedUniqueIDGeneratorFactory.generatorFor;
+
+public class HighGeneratorCountIT {
+    @ClassRule
+    public static final EtcdClusterResource etcd = new EtcdClusterResource("test-etcd", 1);
+
+    final static int CLUSTER_ID_A = 4;
+    final static int CLUSTER_ID_B = 5;
+
+    static Client client;
+
+    @BeforeClass
+    public static void setup() throws InterruptedException, ExecutionException {
+        client = Client.builder()
+                .endpoints(etcd.getClientEndpoints())
+                .namespace(ByteSequence.from("unique-id/", StandardCharsets.UTF_8))
+                .build();
+
+        TestHelper.prepareClusterID(client, CLUSTER_ID_A, CLUSTER_ID_B);
+        for (int i = 0; i < 2047; i++) {
+            EtcdHelper.put(client, "pool/4:" + i);
+        }
+    }
+
+    @Test
+    public void above255Test() throws Exception {
+        IDGenerator generator = generatorFor(client, Mode.TIME_SEQUENTIAL);
+        byte[] result = generator.generate();
+        Blueprint blueprint = IDBuilder.parse(result);
+        assertThat(result.length, is(8));
+        assertThat(blueprint.getClusterId(), is(CLUSTER_ID_A));
+        assertThat(blueprint.getGeneratorId(), is(2047));
+
+        IDGenerator generator2 = generatorFor(client, Mode.TIME_SEQUENTIAL);
+        result = generator2.generate();
+        blueprint = IDBuilder.parse(result);
+        assertThat(result.length, is(8));
+        assertThat(blueprint.getClusterId(), is(CLUSTER_ID_B));
+        assertThat(blueprint.getGeneratorId(), is(0));
+    }
+}
diff --git a/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java
index 6febf29..f7798a1 100644
--- a/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java
+++ b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java
@@ -106,7 +106,7 @@ public void doubleConcurrentTest() throws Exception {
             clusterGeneratorIds.get(clusterId).add(generatorId);
         }
 
-        assertThat(clusterGeneratorIds.get(4).size(), is (256));
+        assertThat(clusterGeneratorIds.get(4).size(), is (2048));
         assertThat(clusterGeneratorIds.get(5).size(), is (1));
     }
 }

From 6bdcf09ea0ad312868afbffcc46fffb129570dc3 Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Tue, 16 Feb 2021 15:58:44 +0100
Subject: [PATCH 02/11] Introduce a resource-claim without keep-a-live

---
 .../lable/oss/uniqueid/AutoRefillStack.java   |   2 -
 .../lable/oss/uniqueid/etcd/EtcdHelper.java   |   8 +
 .../etcd/RegistryBasedGeneratorIdentity.java  | 107 ++++++++
 .../etcd/RegistryBasedResourceClaim.java      | 251 ++++++++++++++++++
 .../oss/uniqueid/etcd/ResourceClaim.java      |  10 -
 .../lable/oss/uniqueid/etcd/ResourcePair.java |  26 ++
 .../etcd/SynchronizedGeneratorIdentity.java   |   2 +-
 .../uniqueid/etcd/MultipleClusterIdsIT.java   |   8 +-
 .../RegistryBasedGeneratorIdentityTest.java   | 127 +++++++++
 9 files changed, 524 insertions(+), 17 deletions(-)
 create mode 100644 uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java
 create mode 100644 uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java
 create mode 100644 uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourcePair.java
 create mode 100644 uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentityTest.java

diff --git a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/AutoRefillStack.java b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/AutoRefillStack.java
index 739fb9a..4ac9bc9 100644
--- a/uniqueid-core/src/main/java/org/lable/oss/uniqueid/AutoRefillStack.java
+++ b/uniqueid-core/src/main/java/org/lable/oss/uniqueid/AutoRefillStack.java
@@ -15,7 +15,6 @@
  */
 package org.lable.oss.uniqueid;
 
-import javax.annotation.PreDestroy;
 import java.io.IOException;
 import java.util.ArrayDeque;
 import java.util.Deque;
@@ -63,7 +62,6 @@ public static IDGenerator decorate(IDGenerator generator, int batchSize) {
         return new AutoRefillStack(generator, batchSize);
     }
 
-    @PreDestroy
     @Override
     public void close() throws IOException {
         generator.close();
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java
index 2a582b4..a33913b 100644
--- a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/EtcdHelper.java
@@ -45,6 +45,14 @@ public static Optional<Integer> getInt(Client etcd, String key) throws Execution
         }
     }
 
+    public static Optional<String> get(Client etcd, String key) throws ExecutionException, InterruptedException {
+        GetResponse getResponse = etcd.getKVClient().get(asByteSequence(key)).get();
+
+        if (getResponse.getCount() == 0) return Optional.empty();
+
+        return Optional.of(getResponse.getKvs().get(0).getValue().toString(StandardCharsets.UTF_8));
+    }
+
     public static void put(Client etcd, String key, int value) throws ExecutionException, InterruptedException {
         etcd.getKVClient().put(asByteSequence(key), asByteSequence(value)).get();
     }
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java
new file mode 100644
index 0000000..a759569
--- /dev/null
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2014 Lable (info@lable.nl)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lable.oss.uniqueid.etcd;
+
+import io.etcd.jetcd.ByteSequence;
+import io.etcd.jetcd.Client;
+import org.lable.oss.uniqueid.GeneratorException;
+import org.lable.oss.uniqueid.GeneratorIdentityHolder;
+import org.lable.oss.uniqueid.bytes.Blueprint;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Holder for a claimed cluster-id and generator-id that once claimed remains claimed without an active connection to
+ * an Etcd cluster. The claim is relinquished upon calling {@link #close()} (where a new connection to Etcd will be
+ * set up briefly).
+ */
+public class RegistryBasedGeneratorIdentity implements GeneratorIdentityHolder {
+    private static final Logger logger = LoggerFactory.getLogger(RegistryBasedGeneratorIdentity.class);
+
+    private final String endpoints;
+    private final String namespace;
+    private final RegistryBasedResourceClaim resourceClaim;
+
+    public RegistryBasedGeneratorIdentity(String endpoints, String namespace, String registryEntry) {
+        this.endpoints = endpoints;
+        this.namespace = namespace;
+
+        try {
+            resourceClaim = acquireResourceClaim(registryEntry, 0);
+        } catch (GeneratorException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static RegistryBasedGeneratorIdentity basedOn(String endpoints, String namespace, String registryEntry)
+            throws IOException {
+        return new RegistryBasedGeneratorIdentity(
+                endpoints, namespace, registryEntry
+        );
+    }
+
+    @Override
+    public int getClusterId() throws GeneratorException {
+        return resourceClaim.getClusterId();
+    }
+
+    @Override
+    public int getGeneratorId() throws GeneratorException {
+        return resourceClaim.getGeneratorId();
+    }
+
+    public String getRegistryEntry() {
+        return resourceClaim.getRegistryEntry();
+    }
+
+    private RegistryBasedResourceClaim acquireResourceClaim(String registryEntry, int retries)
+            throws GeneratorException {
+        try {
+            return RegistryBasedResourceClaim.claim(
+                    this::getEtcdConnection,
+                    Blueprint.MAX_GENERATOR_ID + 1,
+                    registryEntry
+            );
+        } catch (IOException e) {
+            logger.warn(
+                    "Connection to Etcd failed, retrying resource claim acquisition, attempt {}.",
+                    retries + 1
+            );
+            if (retries < 3) {
+                return acquireResourceClaim(registryEntry, retries + 1);
+            } else {
+                throw new GeneratorException(e);
+            }
+        }
+    }
+
+    Client getEtcdConnection() {
+        return Client.builder()
+                .endpoints(endpoints.split(","))
+                .namespace(ByteSequence.from(namespace, StandardCharsets.UTF_8))
+                .build();
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (resourceClaim != null) {
+            resourceClaim.close();
+        }
+    }
+}
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java
new file mode 100644
index 0000000..b2f7054
--- /dev/null
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2014 Lable (info@lable.nl)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lable.oss.uniqueid.etcd;
+
+import io.etcd.jetcd.*;
+import io.etcd.jetcd.kv.GetResponse;
+import io.etcd.jetcd.kv.TxnResponse;
+import io.etcd.jetcd.lease.LeaseGrantResponse;
+import io.etcd.jetcd.lock.LockResponse;
+import io.etcd.jetcd.op.Cmp;
+import io.etcd.jetcd.op.CmpTarget;
+import io.etcd.jetcd.op.Op;
+import io.etcd.jetcd.options.GetOption;
+import io.etcd.jetcd.options.PutOption;
+import io.etcd.jetcd.options.WatchOption;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+public class RegistryBasedResourceClaim {
+    private static final Logger logger = LoggerFactory.getLogger(RegistryBasedResourceClaim.class);
+
+    static final String REGISTRY_PREFIX = "registry/";
+    static final ByteSequence REGISTRY_KEY = ByteSequence.from(REGISTRY_PREFIX, StandardCharsets.UTF_8);
+    static final ByteSequence LOCK_NAME = ByteSequence.from("unique-id-registry-lock", StandardCharsets.UTF_8);
+
+    final Supplier<Client> connectToEtcd;
+    final String registryEntry;
+    final int clusterId;
+    final int generatorId;
+
+    final int poolSize;
+
+    RegistryBasedResourceClaim(Supplier<Client> connectToEtcd, int maxGeneratorCount, String registryEntry)
+            throws IOException {
+        this.registryEntry = registryEntry;
+        this.connectToEtcd = connectToEtcd;
+
+        logger.debug("Acquiring resource-claim…");
+
+        Client etcd = connectToEtcd.get();
+
+        List<Integer> clusterIds = ClusterID.get(etcd);
+
+        Duration timeout = Duration.ofMinutes(5);
+        Instant giveUpAfter = Instant.now().plus(timeout);
+
+        this.poolSize = maxGeneratorCount;
+
+        try {
+            LeaseGrantResponse lease = etcd.getLeaseClient().grant(5).get();
+            long leaseId = lease.getID();
+
+            // Keep the lease alive until we are done.
+            CloseableClient leaseKeepAlive = EtcdHelper.keepLeaseAlive(etcd, leaseId, null);
+
+            // Release the lease when closed.
+
+            // Acquire the lock. This makes sure we are the only process claiming a resource.
+            LockResponse lock;
+            try {
+                lock = etcd.getLockClient()
+                        .lock(LOCK_NAME, leaseId)
+                        .get(timeout.toMillis(), TimeUnit.MILLISECONDS);
+            } catch (TimeoutException e) {
+                throw new IOException("Process timed out.");
+            }
+
+            if (logger.isDebugEnabled()) {
+                logger.debug("Acquired lock: {}.", lock.getKey().toString(StandardCharsets.UTF_8));
+            }
+
+            ResourcePair resourcePair = claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter);
+            this.clusterId = resourcePair.clusterId;
+            this.generatorId = resourcePair.generatorId;
+
+            // Release the lock. If this line is not reached due to exceptions raised, the lock will automatically
+            // be removed when the lease holding it expires.
+            etcd.getLockClient().unlock(lock.getKey()).get();
+
+            leaseKeepAlive.close();
+        } catch (ExecutionException e) {
+            close();
+            throw new IOException(e);
+        } catch (InterruptedException e) {
+            close();
+            Thread.currentThread().interrupt();
+            throw new IOException(e);
+        }
+
+        logger.debug("Resource-claim acquired ({}/{}).", clusterId, generatorId);
+    }
+
+    public static RegistryBasedResourceClaim claim(Supplier<Client> connectToEtcd,
+                                                   int maxGeneratorCount,
+                                                   String registryEntry) throws IOException {
+        return new RegistryBasedResourceClaim(connectToEtcd, maxGeneratorCount, registryEntry);
+    }
+
+    /**
+     * Try to claim an available resource from the resource pool.
+     *
+     * @param etcd              Etcd connection.
+     * @param maxGeneratorCount Maximum number of generators possible.
+     * @param clusterIds        Cluster Ids available to use.
+     * @param giveUpAfter       Give up after this instant in time.
+     * @return The claimed resource.
+     */
+    ResourcePair claimResource(Client etcd, int maxGeneratorCount, List<Integer> clusterIds, Instant giveUpAfter)
+            throws InterruptedException, IOException, ExecutionException {
+
+        logger.debug("Trying to claim a resource.");
+
+        int registrySize = maxGeneratorCount * clusterIds.size();
+
+        GetOption getOptions = GetOption.newBuilder()
+                .withKeysOnly(true)
+                .withPrefix(REGISTRY_KEY)
+                .build();
+        GetResponse get = etcd.getKVClient().get(REGISTRY_KEY, getOptions).get();
+
+        List<ByteSequence> claimedResources = get.getKvs().stream()
+                .map(KeyValue::getKey)
+                .collect(Collectors.toList());
+
+        if (claimedResources.size() >= registrySize) {
+            logger.debug("No resources available at the moment (registry size: {}), waiting.", registrySize);
+            // No resources available. Wait for a resource to become available.
+            final CountDownLatch latch = new CountDownLatch(1);
+            Watch.Watcher watcher = etcd.getWatchClient().watch(
+                    REGISTRY_KEY,
+                    WatchOption.newBuilder().withPrefix(REGISTRY_KEY).build(),
+                    watchResponse -> latch.countDown()
+            );
+            awaitLatchUnlessItTakesTooLong(latch, giveUpAfter);
+            watcher.close();
+            return claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter);
+        }
+
+        // Try to claim an available resource.
+        for (Integer clusterId : clusterIds) {
+            for (int generatorId = 0; generatorId < maxGeneratorCount; generatorId++) {
+                String resourcePathString = resourceKey(clusterId, generatorId);
+                ByteSequence resourcePath = ByteSequence.from(resourcePathString, StandardCharsets.UTF_8);
+                if (!claimedResources.contains(resourcePath)) {
+                    logger.debug("Trying to claim seemingly available resource {}.", resourcePathString);
+                    TxnResponse txnResponse = etcd.getKVClient().txn()
+                            .If(
+                                    // Version == 0 means the key does not exist.
+                                    new Cmp(resourcePath, Cmp.Op.EQUAL, CmpTarget.version(0))
+                            ).Then(
+                                    Op.put(
+                                            resourcePath,
+                                            ByteSequence.from(registryEntry, StandardCharsets.UTF_8),
+                                            PutOption.newBuilder().build()
+                                    )
+                            ).commit().get();
+
+                    if (!txnResponse.isSucceeded()) {
+                        // Failed to claim this resource for some reason.
+                        continue;
+                    }
+
+                    logger.debug("Successfully claimed resource {}.", resourcePathString);
+                    return new ResourcePair(clusterId, generatorId);
+                }
+            }
+        }
+
+        return claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter);
+    }
+
+    static String resourceKey(Integer clusterId, int generatorId) {
+        return REGISTRY_PREFIX + clusterId + ":" + generatorId;
+    }
+
+    private void awaitLatchUnlessItTakesTooLong(CountDownLatch latch, Instant giveUpAfter)
+            throws IOException, InterruptedException {
+        if (giveUpAfter == null) {
+            latch.await();
+        } else {
+            Instant now = Instant.now();
+            if (!giveUpAfter.isAfter(now)) throw new IOException("Process timed out.");
+
+            boolean success = latch.await(Duration.between(now, giveUpAfter).toMillis(), TimeUnit.MILLISECONDS);
+            if (!success) {
+                close();
+                throw new IOException("Process timed out.");
+            }
+        }
+    }
+
+    /**
+     * Relinquish a claimed resource.
+     */
+    private void relinquishResource() {
+        logger.debug("Relinquishing claimed registry resource {}:{}.", clusterId, generatorId);
+
+        Client etcd = connectToEtcd.get();
+        String resourcePathString = resourceKey(clusterId, generatorId);
+        ByteSequence resourcePath = ByteSequence.from(resourcePathString, StandardCharsets.UTF_8);
+
+        try {
+            etcd.getKVClient().delete(resourcePath).get();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (ExecutionException e) {
+            logger.error("Failed to revoke Etcd lease.", e);
+        }
+    }
+
+    public int getClusterId() {
+        return clusterId;
+    }
+
+    public int getGeneratorId() {
+        return generatorId;
+    }
+
+    public void close() {
+        relinquishResource();
+    }
+
+    public String getRegistryEntry() {
+        return registryEntry;
+    }
+}
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java
index 8a436ec..e4bfc25 100644
--- a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourceClaim.java
@@ -347,14 +347,4 @@ public enum State {
         HAS_CLAIM,
         CLAIM_RELINQUISHED
     }
-
-    static class ResourcePair {
-        int clusterId;
-        int generatorId;
-
-        public ResourcePair(Integer clusterId, int generatorId) {
-            this.clusterId = clusterId;
-            this.generatorId = generatorId;
-        }
-    }
 }
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourcePair.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourcePair.java
new file mode 100644
index 0000000..eab60d9
--- /dev/null
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/ResourcePair.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2014 Lable (info@lable.nl)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lable.oss.uniqueid.etcd;
+
+class ResourcePair {
+    int clusterId;
+    int generatorId;
+
+    public ResourcePair(Integer clusterId, int generatorId) {
+        this.clusterId = clusterId;
+        this.generatorId = generatorId;
+    }
+}
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/SynchronizedGeneratorIdentity.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/SynchronizedGeneratorIdentity.java
index 054a5f3..ce6c33b 100644
--- a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/SynchronizedGeneratorIdentity.java
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/SynchronizedGeneratorIdentity.java
@@ -154,7 +154,7 @@ private ResourceClaim acquireResourceClaim(int retries) throws GeneratorExceptio
             );
         } catch (IOException e) {
             logger.warn(
-                    "Connection to ZooKeeper quorum failed, retrying resource claim acquisition, attempt {}.",
+                    "Connection to Etcd failed, retrying resource claim acquisition, attempt {}.",
                     retries + 1
             );
             if (retries < 3) {
diff --git a/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java
index f7798a1..de179c8 100644
--- a/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java
+++ b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/MultipleClusterIdsIT.java
@@ -18,10 +18,7 @@
 import io.etcd.jetcd.ByteSequence;
 import io.etcd.jetcd.Client;
 import io.etcd.jetcd.launcher.junit4.EtcdClusterResource;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
-import org.junit.Rule;
-import org.junit.Test;
+import org.junit.*;
 import org.junit.rules.ExpectedException;
 import org.lable.oss.uniqueid.ByteArray;
 import org.lable.oss.uniqueid.GeneratorException;
@@ -65,6 +62,9 @@ public static void setup() throws InterruptedException, ExecutionException {
     }
 
     @Test
+    @Ignore
+    // This test works, but not on every computer and not always due to the high number of threads.
+    // Run it manually if needed.
     public void doubleConcurrentTest() throws Exception {
         final int threadCount = Blueprint.MAX_GENERATOR_ID + 2;
 
diff --git a/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentityTest.java b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentityTest.java
new file mode 100644
index 0000000..2f6b4b2
--- /dev/null
+++ b/uniqueid-etcd/src/test/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentityTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2014 Lable (info@lable.nl)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lable.oss.uniqueid.etcd;
+
+import io.etcd.jetcd.ByteSequence;
+import io.etcd.jetcd.Client;
+import io.etcd.jetcd.launcher.junit4.EtcdClusterResource;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.lable.oss.uniqueid.BaseUniqueIDGenerator;
+import org.lable.oss.uniqueid.GeneratorException;
+import org.lable.oss.uniqueid.IDGenerator;
+import org.lable.oss.uniqueid.bytes.Mode;
+
+import java.io.IOException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
+
+import static com.github.npathai.hamcrestopt.OptionalMatchers.hasValue;
+import static com.github.npathai.hamcrestopt.OptionalMatchers.isEmpty;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+import static org.lable.oss.uniqueid.etcd.SynchronizedUniqueIDGeneratorFactory.generatorFor;
+
+public class RegistryBasedGeneratorIdentityTest {
+    @Rule
+    public final EtcdClusterResource etcd = new EtcdClusterResource("test-etcd", 1);
+
+    Client client;
+
+    @Before
+    public void before() throws IOException, InterruptedException, ExecutionException {
+        client = Client.builder()
+                .endpoints(etcd.getClientEndpoints())
+                .namespace(ByteSequence.from("unique-id", StandardCharsets.UTF_8))
+                .build();
+
+        TestHelper.prepareClusterID(client, 5);
+    }
+
+    @Test
+    public void simpleTest() throws IOException, GeneratorException, ExecutionException, InterruptedException {
+        RegistryBasedGeneratorIdentity generatorIdentity = RegistryBasedGeneratorIdentity.basedOn(
+                etcd.getClientEndpoints().stream().map(URI::toString).collect(Collectors.joining(",")),
+                "unique-id",
+                "Hello!"
+        );
+
+        int clusterId = generatorIdentity.getClusterId();
+        int generatorId = generatorIdentity.getGeneratorId();
+
+        Optional<String> content =  EtcdHelper.get(client, RegistryBasedResourceClaim.resourceKey(clusterId, generatorId));
+        assertThat(content, hasValue("Hello!"));
+
+        generatorIdentity.close();
+
+        content =  EtcdHelper.get(client, RegistryBasedResourceClaim.resourceKey(clusterId, generatorId));
+        assertThat(content, isEmpty());
+    }
+
+    @Test
+    public void multipleTest() throws IOException, GeneratorException, ExecutionException, InterruptedException {
+        final int threadCount = 4;
+        final int batchSize = 500;
+
+        final CountDownLatch ready = new CountDownLatch(threadCount);
+        final CountDownLatch start = new CountDownLatch(1);
+        final CountDownLatch done = new CountDownLatch(threadCount);
+        final ConcurrentMap<Integer, Deque<byte[]>> result = new ConcurrentHashMap<>(threadCount);
+        final Set<Integer> generatorIds = new HashSet<>();
+
+        for (int i = 0; i < threadCount; i++) {
+            final Integer number = 10 + i;
+            new Thread(() -> {
+                ready.countDown();
+                try {
+                    start.await();
+                    RegistryBasedGeneratorIdentity generatorIdentity = RegistryBasedGeneratorIdentity.basedOn(
+                            etcd.getClientEndpoints().stream().map(URI::toString).collect(Collectors.joining(",")),
+                            "unique-id",
+                            "Hello!"
+                    );
+
+                    IDGenerator generator = new BaseUniqueIDGenerator(generatorIdentity, Mode.SPREAD);
+                    generatorIds.add(generatorIdentity.getGeneratorId());
+                    result.put(number, generator.batch(batchSize));
+                } catch (IOException | InterruptedException | GeneratorException e) {
+                    fail(e.getMessage());
+                }
+                done.countDown();
+            }, String.valueOf(number)).start();
+        }
+
+        ready.await();
+        start.countDown();
+        done.await();
+
+        assertThat(result.size(), is(threadCount));
+        assertThat(generatorIds.size(), is(threadCount));
+
+        for (Map.Entry<Integer, Deque<byte[]>> entry : result.entrySet()) {
+            assertThat(entry.getValue().size(), is(batchSize));
+        }
+    }
+}
\ No newline at end of file

From 5fabb1c8daeab40538240bdd5b094347bb3a7f12 Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Wed, 17 Feb 2021 11:17:38 +0100
Subject: [PATCH 03/11] [maven-release-plugin] prepare release v3.2-beta1

---
 pom.xml                    | 4 ++--
 uniqueid-core/pom.xml      | 2 +-
 uniqueid-etcd/pom.xml      | 2 +-
 uniqueid-zookeeper/pom.xml | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index a0cd353..6c02a6c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
 
   <groupId>org.lable.oss.uniqueid</groupId>
   <artifactId>uniqueid</artifactId>
-  <version>3.2-SNAPSHOT</version>
+  <version>3.2-beta1</version>
   <packaging>pom</packaging>
 
   <name>UniqueID</name>
@@ -65,7 +65,7 @@
     <connection>scm:git:git@github.com:LableOrg/java-uniqueid.git</connection>
     <developerConnection>scm:git:git@github.com:LableOrg/java-uniqueid.git</developerConnection>
     <url>https://github.com/LableOrg/java-uniqueid</url>
-    <tag>HEAD</tag>
+    <tag>v3.2-beta1</tag>
   </scm>
 
   <developers>
diff --git a/uniqueid-core/pom.xml b/uniqueid-core/pom.xml
index 8072009..5a2e86c 100644
--- a/uniqueid-core/pom.xml
+++ b/uniqueid-core/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-SNAPSHOT</version>
+    <version>3.2-beta1</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-etcd/pom.xml b/uniqueid-etcd/pom.xml
index fc7c480..7219042 100644
--- a/uniqueid-etcd/pom.xml
+++ b/uniqueid-etcd/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-SNAPSHOT</version>
+    <version>3.2-beta1</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-zookeeper/pom.xml b/uniqueid-zookeeper/pom.xml
index 86a723d..2726dd8 100644
--- a/uniqueid-zookeeper/pom.xml
+++ b/uniqueid-zookeeper/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-SNAPSHOT</version>
+    <version>3.2-beta1</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 

From 04619bed23fc1b741b5515699978102e0dada124 Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Wed, 17 Feb 2021 11:17:44 +0100
Subject: [PATCH 04/11] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml                    | 4 ++--
 uniqueid-core/pom.xml      | 2 +-
 uniqueid-etcd/pom.xml      | 2 +-
 uniqueid-zookeeper/pom.xml | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index 6c02a6c..c90639b 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
 
   <groupId>org.lable.oss.uniqueid</groupId>
   <artifactId>uniqueid</artifactId>
-  <version>3.2-beta1</version>
+  <version>3.2-beta2-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>UniqueID</name>
@@ -65,7 +65,7 @@
     <connection>scm:git:git@github.com:LableOrg/java-uniqueid.git</connection>
     <developerConnection>scm:git:git@github.com:LableOrg/java-uniqueid.git</developerConnection>
     <url>https://github.com/LableOrg/java-uniqueid</url>
-    <tag>v3.2-beta1</tag>
+    <tag>HEAD</tag>
   </scm>
 
   <developers>
diff --git a/uniqueid-core/pom.xml b/uniqueid-core/pom.xml
index 5a2e86c..2380caa 100644
--- a/uniqueid-core/pom.xml
+++ b/uniqueid-core/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-beta1</version>
+    <version>3.2-beta2-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-etcd/pom.xml b/uniqueid-etcd/pom.xml
index 7219042..e788523 100644
--- a/uniqueid-etcd/pom.xml
+++ b/uniqueid-etcd/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-beta1</version>
+    <version>3.2-beta2-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-zookeeper/pom.xml b/uniqueid-zookeeper/pom.xml
index 2726dd8..b430c7b 100644
--- a/uniqueid-zookeeper/pom.xml
+++ b/uniqueid-zookeeper/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-beta1</version>
+    <version>3.2-beta2-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 

From e9fc667ae56304e4c281812504fb48fac91fea7f Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Thu, 6 May 2021 15:27:25 +0200
Subject: [PATCH 05/11] Fix issue with Etcd lock not releasing

In rare cases the lock appears to get stuck.
---
 .../etcd/RegistryBasedGeneratorIdentity.java  | 37 +++++--
 .../etcd/RegistryBasedResourceClaim.java      | 99 ++++++++++++++-----
 2 files changed, 102 insertions(+), 34 deletions(-)

diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java
index a759569..4f662ec 100644
--- a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedGeneratorIdentity.java
@@ -25,6 +25,7 @@
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.time.Duration;
 
 /**
  * Holder for a claimed cluster-id and generator-id that once claimed remains claimed without an active connection to
@@ -36,11 +37,19 @@ public class RegistryBasedGeneratorIdentity implements GeneratorIdentityHolder {
 
     private final String endpoints;
     private final String namespace;
+    private final Duration acquisitionTimeout;
+    private final boolean waitWhenNoResourcesAvailable;
     private final RegistryBasedResourceClaim resourceClaim;
 
-    public RegistryBasedGeneratorIdentity(String endpoints, String namespace, String registryEntry) {
+    public RegistryBasedGeneratorIdentity(String endpoints,
+                                          String namespace,
+                                          String registryEntry,
+                                          Duration acquisitionTimeout,
+                                          boolean waitWhenNoResourcesAvailable) {
         this.endpoints = endpoints;
         this.namespace = namespace;
+        this.acquisitionTimeout = acquisitionTimeout;
+        this.waitWhenNoResourcesAvailable = waitWhenNoResourcesAvailable;
 
         try {
             resourceClaim = acquireResourceClaim(registryEntry, 0);
@@ -52,7 +61,18 @@ public RegistryBasedGeneratorIdentity(String endpoints, String namespace, String
     public static RegistryBasedGeneratorIdentity basedOn(String endpoints, String namespace, String registryEntry)
             throws IOException {
         return new RegistryBasedGeneratorIdentity(
-                endpoints, namespace, registryEntry
+                endpoints, namespace, registryEntry, Duration.ofMinutes(5), true
+        );
+    }
+
+    public static RegistryBasedGeneratorIdentity basedOn(String endpoints,
+                                                         String namespace,
+                                                         String registryEntry,
+                                                         Duration acquisitionTimeout,
+                                                         boolean waitWhenNoResourcesAvailable)
+            throws IOException {
+        return new RegistryBasedGeneratorIdentity(
+                endpoints, namespace, registryEntry, acquisitionTimeout, waitWhenNoResourcesAvailable
         );
     }
 
@@ -76,16 +96,19 @@ private RegistryBasedResourceClaim acquireResourceClaim(String registryEntry, in
             return RegistryBasedResourceClaim.claim(
                     this::getEtcdConnection,
                     Blueprint.MAX_GENERATOR_ID + 1,
-                    registryEntry
+                    registryEntry,
+                    acquisitionTimeout,
+                    waitWhenNoResourcesAvailable
             );
         } catch (IOException e) {
-            logger.warn(
-                    "Connection to Etcd failed, retrying resource claim acquisition, attempt {}.",
-                    retries + 1
-            );
             if (retries < 3) {
+                logger.warn(
+                        "Connection to Etcd failed, retrying claim acquisition, attempt " + (retries + 1) + ".",
+                        e
+                );
                 return acquireResourceClaim(registryEntry, retries + 1);
             } else {
+                logger.error("Failed to acquire resource claim after attempt " + (retries + 1) + ".", e);
                 throw new GeneratorException(e);
             }
         }
diff --git a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java
index b2f7054..a5ad7a5 100644
--- a/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java
+++ b/uniqueid-etcd/src/main/java/org/lable/oss/uniqueid/etcd/RegistryBasedResourceClaim.java
@@ -15,7 +15,10 @@
  */
 package org.lable.oss.uniqueid.etcd;
 
-import io.etcd.jetcd.*;
+import io.etcd.jetcd.ByteSequence;
+import io.etcd.jetcd.Client;
+import io.etcd.jetcd.KeyValue;
+import io.etcd.jetcd.Watch;
 import io.etcd.jetcd.kv.GetResponse;
 import io.etcd.jetcd.kv.TxnResponse;
 import io.etcd.jetcd.lease.LeaseGrantResponse;
@@ -55,31 +58,35 @@ public class RegistryBasedResourceClaim {
 
     final int poolSize;
 
-    RegistryBasedResourceClaim(Supplier<Client> connectToEtcd, int maxGeneratorCount, String registryEntry)
+    RegistryBasedResourceClaim(Supplier<Client> connectToEtcd,
+                               int maxGeneratorCount,
+                               String registryEntry,
+                               Duration acquisitionTimeout,
+                               boolean waitWhenNoResourcesAvailable)
             throws IOException {
         this.registryEntry = registryEntry;
         this.connectToEtcd = connectToEtcd;
 
-        logger.debug("Acquiring resource-claim…");
+        logger.info("Acquiring resource-claim…");
 
         Client etcd = connectToEtcd.get();
 
         List<Integer> clusterIds = ClusterID.get(etcd);
 
-        Duration timeout = Duration.ofMinutes(5);
+        Duration timeout = acquisitionTimeout == null
+                ? Duration.ofMinutes(5)
+                : acquisitionTimeout;
         Instant giveUpAfter = Instant.now().plus(timeout);
 
         this.poolSize = maxGeneratorCount;
 
+        ResourcePair resourcePair = null;
         try {
-            LeaseGrantResponse lease = etcd.getLeaseClient().grant(5).get();
+            logger.debug("Acquiring lock, timeout is set to {}.", timeout);
+            // Have the lease TTL just a bit after our timeout.
+            LeaseGrantResponse lease = etcd.getLeaseClient().grant(timeout.plusSeconds(5).getSeconds()).get();
             long leaseId = lease.getID();
 
-            // Keep the lease alive until we are done.
-            CloseableClient leaseKeepAlive = EtcdHelper.keepLeaseAlive(etcd, leaseId, null);
-
-            // Release the lease when closed.
-
             // Acquire the lock. This makes sure we are the only process claiming a resource.
             LockResponse lock;
             try {
@@ -90,24 +97,37 @@ public class RegistryBasedResourceClaim {
                 throw new IOException("Process timed out.");
             }
 
+            // Keep the lease alive for another period in order to safely finish claiming the resource.
+            etcd.getLeaseClient().keepAliveOnce(leaseId).get();
+
             if (logger.isDebugEnabled()) {
                 logger.debug("Acquired lock: {}.", lock.getKey().toString(StandardCharsets.UTF_8));
             }
 
-            ResourcePair resourcePair = claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter);
+            resourcePair = claimResource(
+                    etcd, maxGeneratorCount, clusterIds, giveUpAfter, waitWhenNoResourcesAvailable
+            );
             this.clusterId = resourcePair.clusterId;
             this.generatorId = resourcePair.generatorId;
 
-            // Release the lock. If this line is not reached due to exceptions raised, the lock will automatically
-            // be removed when the lease holding it expires.
+            // Explicitly release the lock. If this line is not reached due to exceptions raised, the lock will
+            // automatically be removed when the lease holding it expires.
             etcd.getLockClient().unlock(lock.getKey()).get();
+            if (logger.isDebugEnabled()) {
+                logger.debug("Released lock: {}.", lock.getKey().toString(StandardCharsets.UTF_8));
+            }
 
-            leaseKeepAlive.close();
+            // Revoke the lease instead of letting it time out.
+            etcd.getLeaseClient().revoke(leaseId).get();
         } catch (ExecutionException e) {
-            close();
+            if (resourcePair != null) {
+                close();
+            }
             throw new IOException(e);
         } catch (InterruptedException e) {
-            close();
+            if (resourcePair != null) {
+                close();
+            }
             Thread.currentThread().interrupt();
             throw new IOException(e);
         }
@@ -115,22 +135,42 @@ public class RegistryBasedResourceClaim {
         logger.debug("Resource-claim acquired ({}/{}).", clusterId, generatorId);
     }
 
+    /**
+     * Claim a resource.
+     *
+     * @param connectToEtcd                Provide a connection to Etcd.
+     * @param maxGeneratorCount            Maximum number of generators possible.
+     * @param registryEntry                Metadata stored under the Etcd key.
+     * @param acquisitionTimeout           Abort attempt to claim a resource after this duration.
+     * @param waitWhenNoResourcesAvailable Wait for a resource to become available when all resources are claimed.
+     * @return The resource claim, if successful.
+     * @throws IOException Thrown when the claim could not be acquired.
+     */
     public static RegistryBasedResourceClaim claim(Supplier<Client> connectToEtcd,
                                                    int maxGeneratorCount,
-                                                   String registryEntry) throws IOException {
-        return new RegistryBasedResourceClaim(connectToEtcd, maxGeneratorCount, registryEntry);
+                                                   String registryEntry,
+                                                   Duration acquisitionTimeout,
+                                                   boolean waitWhenNoResourcesAvailable) throws IOException {
+        return new RegistryBasedResourceClaim(
+                connectToEtcd, maxGeneratorCount, registryEntry, acquisitionTimeout, waitWhenNoResourcesAvailable
+        );
     }
 
     /**
      * Try to claim an available resource from the resource pool.
      *
-     * @param etcd              Etcd connection.
-     * @param maxGeneratorCount Maximum number of generators possible.
-     * @param clusterIds        Cluster Ids available to use.
-     * @param giveUpAfter       Give up after this instant in time.
+     * @param etcd                         Etcd connection.
+     * @param maxGeneratorCount            Maximum number of generators possible.
+     * @param clusterIds                   Cluster Ids available to use.
+     * @param giveUpAfter                  Give up after this instant in time.
+     * @param waitWhenNoResourcesAvailable Wait for a resource to become available when all resources are claimed.
      * @return The claimed resource.
      */
-    ResourcePair claimResource(Client etcd, int maxGeneratorCount, List<Integer> clusterIds, Instant giveUpAfter)
+    ResourcePair claimResource(Client etcd,
+                               int maxGeneratorCount,
+                               List<Integer> clusterIds,
+                               Instant giveUpAfter,
+                               boolean waitWhenNoResourcesAvailable)
             throws InterruptedException, IOException, ExecutionException {
 
         logger.debug("Trying to claim a resource.");
@@ -148,7 +188,12 @@ ResourcePair claimResource(Client etcd, int maxGeneratorCount, List<Integer> clu
                 .collect(Collectors.toList());
 
         if (claimedResources.size() >= registrySize) {
-            logger.debug("No resources available at the moment (registry size: {}), waiting.", registrySize);
+            if (!waitWhenNoResourcesAvailable) {
+                throw new IOException(
+                        "No resources available. Giving up as requested. Registry size: " + registrySize + "."
+                );
+            }
+            logger.warn("No resources available at the moment (registry size: {}), waiting.", registrySize);
             // No resources available. Wait for a resource to become available.
             final CountDownLatch latch = new CountDownLatch(1);
             Watch.Watcher watcher = etcd.getWatchClient().watch(
@@ -158,7 +203,7 @@ ResourcePair claimResource(Client etcd, int maxGeneratorCount, List<Integer> clu
             );
             awaitLatchUnlessItTakesTooLong(latch, giveUpAfter);
             watcher.close();
-            return claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter);
+            return claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter, true);
         }
 
         // Try to claim an available resource.
@@ -185,13 +230,13 @@ ResourcePair claimResource(Client etcd, int maxGeneratorCount, List<Integer> clu
                         continue;
                     }
 
-                    logger.debug("Successfully claimed resource {}.", resourcePathString);
+                    logger.info("Successfully claimed resource {}.", resourcePathString);
                     return new ResourcePair(clusterId, generatorId);
                 }
             }
         }
 
-        return claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter);
+        return claimResource(etcd, maxGeneratorCount, clusterIds, giveUpAfter, waitWhenNoResourcesAvailable);
     }
 
     static String resourceKey(Integer clusterId, int generatorId) {

From 424eaea41890b8deb3c96ecaa73c29cb918dde02 Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Tue, 11 May 2021 13:51:22 +0200
Subject: [PATCH 06/11] Bump log4j version (used for testing)

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index c90639b..346a789 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,7 +50,7 @@
     <slf4j.version>1.7.21</slf4j.version>
 
     <!-- For testing only. -->
-    <log4j.version>2.7</log4j.version>
+    <log4j.version>2.13.2</log4j.version>
     <hamcrest.optional>1.0</hamcrest.optional>
   </properties>
 

From f606666579df710072b42e4b3d5779f5869e5aa5 Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Tue, 11 May 2021 13:53:46 +0200
Subject: [PATCH 07/11] [maven-release-plugin] prepare release v3.2

---
 pom.xml                    | 4 ++--
 uniqueid-core/pom.xml      | 2 +-
 uniqueid-etcd/pom.xml      | 2 +-
 uniqueid-zookeeper/pom.xml | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index 346a789..de18858 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
 
   <groupId>org.lable.oss.uniqueid</groupId>
   <artifactId>uniqueid</artifactId>
-  <version>3.2-beta2-SNAPSHOT</version>
+  <version>3.2</version>
   <packaging>pom</packaging>
 
   <name>UniqueID</name>
@@ -65,7 +65,7 @@
     <connection>scm:git:git@github.com:LableOrg/java-uniqueid.git</connection>
     <developerConnection>scm:git:git@github.com:LableOrg/java-uniqueid.git</developerConnection>
     <url>https://github.com/LableOrg/java-uniqueid</url>
-    <tag>HEAD</tag>
+    <tag>v3.2</tag>
   </scm>
 
   <developers>
diff --git a/uniqueid-core/pom.xml b/uniqueid-core/pom.xml
index 2380caa..fa34b43 100644
--- a/uniqueid-core/pom.xml
+++ b/uniqueid-core/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-beta2-SNAPSHOT</version>
+    <version>3.2</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-etcd/pom.xml b/uniqueid-etcd/pom.xml
index e788523..9cf803c 100644
--- a/uniqueid-etcd/pom.xml
+++ b/uniqueid-etcd/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-beta2-SNAPSHOT</version>
+    <version>3.2</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-zookeeper/pom.xml b/uniqueid-zookeeper/pom.xml
index b430c7b..a13f0c8 100644
--- a/uniqueid-zookeeper/pom.xml
+++ b/uniqueid-zookeeper/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2-beta2-SNAPSHOT</version>
+    <version>3.2</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 

From e461ff34a25848d9bef8997e55d692b2f3818f9d Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Tue, 11 May 2021 13:53:51 +0200
Subject: [PATCH 08/11] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml                    | 4 ++--
 uniqueid-core/pom.xml      | 2 +-
 uniqueid-etcd/pom.xml      | 2 +-
 uniqueid-zookeeper/pom.xml | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index de18858..9e8df22 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
 
   <groupId>org.lable.oss.uniqueid</groupId>
   <artifactId>uniqueid</artifactId>
-  <version>3.2</version>
+  <version>3.3-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>UniqueID</name>
@@ -65,7 +65,7 @@
     <connection>scm:git:git@github.com:LableOrg/java-uniqueid.git</connection>
     <developerConnection>scm:git:git@github.com:LableOrg/java-uniqueid.git</developerConnection>
     <url>https://github.com/LableOrg/java-uniqueid</url>
-    <tag>v3.2</tag>
+    <tag>HEAD</tag>
   </scm>
 
   <developers>
diff --git a/uniqueid-core/pom.xml b/uniqueid-core/pom.xml
index fa34b43..b9d2b78 100644
--- a/uniqueid-core/pom.xml
+++ b/uniqueid-core/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2</version>
+    <version>3.3-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-etcd/pom.xml b/uniqueid-etcd/pom.xml
index 9cf803c..8354833 100644
--- a/uniqueid-etcd/pom.xml
+++ b/uniqueid-etcd/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2</version>
+    <version>3.3-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/uniqueid-zookeeper/pom.xml b/uniqueid-zookeeper/pom.xml
index a13f0c8..12aecd1 100644
--- a/uniqueid-zookeeper/pom.xml
+++ b/uniqueid-zookeeper/pom.xml
@@ -20,7 +20,7 @@
   <parent>
     <artifactId>uniqueid</artifactId>
     <groupId>org.lable.oss.uniqueid</groupId>
-    <version>3.2</version>
+    <version>3.3-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 

From 645e8e7c76e4e9f1f267e15f0337bb695278068a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 10 Dec 2021 01:00:56 +0000
Subject: [PATCH 09/11] Bump log4j-core from 2.13.2 to 2.15.0

Bumps log4j-core from 2.13.2 to 2.15.0.

---
updated-dependencies:
- dependency-name: org.apache.logging.log4j:log4j-core
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 9e8df22..8b77058 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,7 +50,7 @@
     <slf4j.version>1.7.21</slf4j.version>
 
     <!-- For testing only. -->
-    <log4j.version>2.13.2</log4j.version>
+    <log4j.version>2.15.0</log4j.version>
     <hamcrest.optional>1.0</hamcrest.optional>
   </properties>
 

From 8ac86adcfe21ebbe54d5a18344cbaca73aa0441e Mon Sep 17 00:00:00 2001
From: Jeroen Hoek <jeroen.hoek@lable.nl>
Date: Tue, 14 Dec 2021 13:18:41 +0100
Subject: [PATCH 10/11] Update log4j again

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 8b77058..19168cf 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,7 +50,7 @@
     <slf4j.version>1.7.21</slf4j.version>
 
     <!-- For testing only. -->
-    <log4j.version>2.15.0</log4j.version>
+    <log4j.version>2.16.0</log4j.version>
     <hamcrest.optional>1.0</hamcrest.optional>
   </properties>
 

From 8d2b6d749adac7b676b9977dd068962be176714c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 4 Jan 2022 16:32:31 +0000
Subject: [PATCH 11/11] Bump log4j-core from 2.16.0 to 2.17.1

Bumps log4j-core from 2.16.0 to 2.17.1.

---
updated-dependencies:
- dependency-name: org.apache.logging.log4j:log4j-core
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 19168cf..7e713db 100644
--- a/pom.xml
+++ b/pom.xml
@@ -50,7 +50,7 @@
     <slf4j.version>1.7.21</slf4j.version>
 
     <!-- For testing only. -->
-    <log4j.version>2.16.0</log4j.version>
+    <log4j.version>2.17.1</log4j.version>
     <hamcrest.optional>1.0</hamcrest.optional>
   </properties>