From f9d5c32bb9407e4ea1059d9fd9314315e4eb985b Mon Sep 17 00:00:00 2001 From: Mathieu Baudier Date: Sun, 30 Aug 2020 12:15:49 +0200 Subject: [PATCH] UUID utils with version 1 time-based implementation. --- .../src/org/argeo/util/UuidUtils.java | 263 ++++++++++++++++++ 1 file changed, 263 insertions(+) create mode 100644 org.argeo.util/src/org/argeo/util/UuidUtils.java diff --git a/org.argeo.util/src/org/argeo/util/UuidUtils.java b/org.argeo.util/src/org/argeo/util/UuidUtils.java new file mode 100644 index 000000000..54e6b2cb3 --- /dev/null +++ b/org.argeo.util/src/org/argeo/util/UuidUtils.java @@ -0,0 +1,263 @@ +package org.argeo.util; + +import java.net.InetAddress; +import java.net.NetworkInterface; +import java.net.SocketException; +import java.net.UnknownHostException; +import java.security.SecureRandom; +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.ZoneOffset; +import java.util.BitSet; +import java.util.Random; +import java.util.UUID; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Utilities to simplify and extends usage of {@link UUID}. Only variant 1 is + * supported. Focus is clarity of implementation rather than optimisation. + */ +public class UuidUtils { + /** Nil UUID (00000000-0000-0000-0000-000000000000). */ + public final static UUID NIL_UUID = UUID.fromString("00000000-0000-0000-0000-000000000000"); + + private final static SecureRandom RANDOM; + private final static AtomicInteger CLOCK_SEQUENCE; + private final static byte[] HARDWARE_ADDRESS; + static { + RANDOM = new SecureRandom(); + CLOCK_SEQUENCE = new AtomicInteger(RANDOM.nextInt(16384)); + HARDWARE_ADDRESS = getHardwareAddress(); + } + + private static byte[] getHardwareAddress() { + InetAddress localHost; + try { + localHost = InetAddress.getLocalHost(); + try { + NetworkInterface nic = NetworkInterface.getByInetAddress(localHost); + return nic.getHardwareAddress(); + } catch (SocketException e) { + return null; + } + } catch (UnknownHostException e) { + return null; + } + + } + + public static UUID timeBasedUUID() { + return timeBasedUUID(LocalDateTime.now(ZoneOffset.UTC)); + } + + public static UUID timeBasedRandomUUID() { + return timeBasedRandomUUID(LocalDateTime.now(ZoneOffset.UTC), RANDOM); + } + + public static UUID timeBasedUUID(LocalDateTime time) { + if (HARDWARE_ADDRESS == null) + return timeBasedRandomUUID(time, RANDOM); + return timeBasedUUID(time, BitSet.valueOf(HARDWARE_ADDRESS)); + } + + public static UUID timeBasedAddressUUID(LocalDateTime time, NetworkInterface nic) throws SocketException { + byte[] nodeBytes = nic.getHardwareAddress(); + BitSet node = BitSet.valueOf(nodeBytes); + return timeBasedUUID(time, node); + } + + public static UUID timeBasedRandomUUID(LocalDateTime time, Random random) { + byte[] nodeBytes = new byte[6]; + random.nextBytes(nodeBytes); + BitSet node = BitSet.valueOf(nodeBytes); + // set random marker + node.set(0, true); + return timeBasedUUID(time, node); + } + + public static UUID timeBasedUUID(LocalDateTime time, BitSet node) { + // most significant + LocalDateTime start = LocalDateTime.of(1582, 10, 15, 0, 0, 0); + Duration duration = Duration.between(start, time); + + // Number of 100 ns intervals in one second: 1000000000 / 100 = 10000000 + long timeNanos = duration.getSeconds() * 10000000 + duration.getNano() / 100; + BitSet timeBits = BitSet.valueOf(new long[] { timeNanos }); + assert timeBits.length() <= 60; + + int clockSequence; + synchronized (CLOCK_SEQUENCE) { + clockSequence = CLOCK_SEQUENCE.incrementAndGet(); + if (clockSequence > 16384) + CLOCK_SEQUENCE.set(0); + } + BitSet clockSequenceBits = BitSet.valueOf(new long[] { clockSequence }); + + // Build the UUID, bit by bit + // see https://tools.ietf.org/html/rfc4122#section-4.2.2 + // time + BitSet time_low = new BitSet(32); + BitSet time_mid = new BitSet(16); + BitSet time_hi_and_version = new BitSet(16); + + for (int i = 0; i < 60; i++) { + if (i < 32) + time_low.set(i, timeBits.get(i)); + else if (i < 48) + time_mid.set(i - 32, timeBits.get(i)); + else + time_hi_and_version.set(i - 48, timeBits.get(i)); + } + // version + time_hi_and_version.set(12, true); + time_hi_and_version.set(13, false); + time_hi_and_version.set(14, false); + time_hi_and_version.set(15, false); + + // clock sequence + BitSet clk_seq_hi_res = new BitSet(8); + BitSet clk_seq_low = new BitSet(8); + for (int i = 0; i < 8; i++) { + clk_seq_low.set(i, clockSequenceBits.get(i)); + } + for (int i = 8; i < 14; i++) { + clk_seq_hi_res.set(i - 8, clockSequenceBits.get(i)); + } + // variant + clk_seq_hi_res.set(6, false); + clk_seq_hi_res.set(7, true); + +// String str = toHexString(time_low.toLongArray()[0]) + "-" + toHexString(time_mid.toLongArray()[0]) + "-" +// + toHexString(time_hi_and_version.toLongArray()[0]) + "-" +// + toHexString(clock_seq_hi_and_reserved.toLongArray()[0]) + toHexString(clock_seq_low.toLongArray()[0]) +// + "-" + toHexString(node.toLongArray()[0]); +// UUID uuid = UUID.fromString(str); + + BitSet uuidBits = new BitSet(128); + for (int i = 0; i < 128; i++) { + if (i < 48) + uuidBits.set(i, node.get(i)); + else if (i < 56) + uuidBits.set(i, clk_seq_low.get(i - 48)); + else if (i < 64) + uuidBits.set(i, clk_seq_hi_res.get(i - 56)); + else if (i < 80) + uuidBits.set(i, time_hi_and_version.get(i - 64)); + else if (i < 96) + uuidBits.set(i, time_mid.get(i - 80)); + else + uuidBits.set(i, time_low.get(i - 96)); + } + + long[] uuidLongs = uuidBits.toLongArray(); + assert uuidLongs.length == 2; + UUID uuid = new UUID(uuidLongs[1], uuidLongs[0]); + + // tests + assert uuid.node() == node.toLongArray()[0]; + assert uuid.timestamp() == timeNanos; + assert uuid.clockSequence() == clockSequence; + assert uuid.version() == 1; + assert uuid.variant() == 2; + return uuid; + } + + public static String toBinaryString(UUID uuid, int charsPerSegment, char separator) { + String binaryString = toBinaryString(uuid); + StringBuilder sb = new StringBuilder(128 + (128 / charsPerSegment)); + for (int i = 0; i < binaryString.length(); i++) { + if (i != 0 && i % charsPerSegment == 0) + sb.append(separator); + sb.append(binaryString.charAt(i)); + } + return sb.toString(); + } + + public static String toBinaryString(UUID uuid) { + String most = zeroTo64Chars(Long.toBinaryString(uuid.getMostSignificantBits())); + String least = zeroTo64Chars(Long.toBinaryString(uuid.getLeastSignificantBits())); + String binaryString = most + least; + assert binaryString.length() == 128; + return binaryString; + } + + private static String zeroTo64Chars(String str) { + assert str.length() <= 64; + if (str.length() < 64) { + StringBuilder sb = new StringBuilder(64); + for (int i = 0; i < 64 - str.length(); i++) + sb.append('0'); + sb.append(str); + return sb.toString(); + } else + return str; + } + + public static String compactToStd(String compact) { + if (compact.length() != 32) + throw new IllegalArgumentException( + "Compact UUID '" + compact + "' has length " + compact.length() + " and not 32."); + StringBuilder sb = new StringBuilder(36); + for (int i = 0; i < 32; i++) { + if (i == 8 || i == 12 || i == 16 || i == 20) + sb.append('-'); + sb.append(compact.charAt(i)); + } + String std = sb.toString(); + assert std.length() == 36; + assert UUID.fromString(std).toString().equals(std); + return std; + } + + public static UUID compactToUuid(String compact) { + return UUID.fromString(compactToStd(compact)); + } + + public static boolean isRandom(UUID uuid) { + return uuid.version() == 4; + } + + public static boolean isTimeBased(UUID uuid) { + return uuid.version() == 1; + } + + public static boolean isTimeBasedRandom(UUID uuid) { + if (uuid.version() == 1) { + BitSet node = BitSet.valueOf(new long[] { uuid.node() }); + return node.get(0); + } else + return false; + } + + public static boolean isNameBased(UUID uuid) { + return uuid.version() == 3 || uuid.version() == 5; + } + + /** Singleton. */ + private UuidUtils() { + } + + public final static void main(String[] args) { + UUID uuid; + +// uuid= compactToUuid("996b1f5122de4b2f94e49168d32f22d1"); +// System.out.println(uuid.toString() + ", isRandom=" + isRandom(uuid)); + + long begin; + long duration; + begin = System.nanoTime(); + uuid = UUID.randomUUID(); + duration = System.nanoTime() - begin; + System.out.println(uuid.toString() + " in " + duration + " ns, isRandom=" + isRandom(uuid)); + begin = System.nanoTime(); + uuid = timeBasedRandomUUID(); + duration = System.nanoTime() - begin; + System.out.println(uuid.toString() + " in " + duration + " ns, isTimeBasedRandom=" + isTimeBasedRandom(uuid)); +// System.out.println(toBinaryString(uuid, 8, ' ')); +// System.out.println(toBinaryString(uuid, 16, '\n')); + begin = System.nanoTime(); + uuid = timeBasedUUID(); + duration = System.nanoTime() - begin; + System.out.println(uuid.toString() + " in " + duration + " ns, isTimeBasedRandom=" + isTimeBasedRandom(uuid)); + } +} -- 2.30.2