Fix #55

Author: cowtowncoder

README.md

@@ -26,7 +26,7 @@ JUG is licensed under [Apache License 2.0](http://www.apache.org/licenses/LICENS
 JUG can be used as a command-line tool (via class `com.fasterxml.uuid.Jug`),
 or as a pluggable component.
 
-### Via Maven
+### Maven Dependency
 
 Maven coordinates are:
 
@@ -38,7 +38,7 @@ Maven coordinates are:
 </dependency>
 ```
 
-#### Dependencies
+#### Third-party Dependencies by JUG
 
 The only dependency for JUG is the logging library:
 
@@ -53,7 +53,7 @@ Since version `3.2.0`, JUG defines JDK9+ compatible `module-info.class`, with mo
 
 For direct downloads, check out [Project Wiki](../../wiki).
 
-### Using JUG
+### Using JUG as Library
 
 #### Generating UUIDs
 
@@ -126,6 +126,24 @@ UUID uuidFromStr = UUID.fromString("ebb8e8fe-b1b1-11d7-8adb-00b0d078fa18");
 it is rather slower than JUG version: for more information, read
 [Measuring performance of Java UUID.fromString()](https://cowtowncoder.medium.com/measuring-performance-of-java-uuid-fromstring-or-lack-thereof-d16a910fa32a).
 
+### Using JUG as CLI
+
+JUG jar built under `target/` like:
+
+```
+target/java-uuid-generator-4.1.1-SNAPSHOT.jar
+```
+
+can be invoked directly. To see usage you can do something like:
+
+    java -jar target/java-uuid-generator-4.1.1-SNAPSHOT.jar
+
+and get full instructions, but to generate 5 Random-based UUIDs, you would use:
+
+    java -jar target/java-uuid-generator-4.1.1-SNAPSHOT.jar -c 5 r
+
+(where `-c` (or `--count`) means number of UUIDs to generate, and `r` means Random-based variant)
+
 ## Compatibility
 
 JUG versions 3.1 and later require JDK 1.6 to work, mostly to be able to access local Ethernet MAC address.

pom.xml

@@ -148,6 +148,7 @@ https://stackoverflow.com/questions/37958104/maven-javadoc-no-source-files-for-p
                 org.slf4j;version="[${slf4j.version},2)"
               </Import-Package>
               <Private-Package />
+	      <Main-Class>com.fasterxml.uuid.Jug</Main-Class>
             </instructions>
           </configuration>
        </plugin>

release-notes/VERSION

@@ -13,6 +13,7 @@ Releases
 #52: Add `Generators.egressTimeBasedGenerator()` method that constructs `TimedBasedGenerator`
   with a sensible choice of interface
  (contributed by Paul G)
+ #55: Add `Main-Class` manifest to make jar invoke `Jug` class
 - Fix a minor issue with argument validation for `Jug` tool class
 - Update junit dependency (via oss-parent:41)
 - Update slf4j-api to 1.7.36

src/main/java/com/fasterxml/uuid/UUIDTimer.java

@@ -18,11 +18,9 @@
 import java.io.*;
 import java.util.*;
 
+import com.fasterxml.uuid.impl.LoggerFacade;
 import com.fasterxml.uuid.impl.UUIDUtil;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 /**
  * UUIDTimer produces the time stamps required for time-based UUIDs.
  * It works as outlined in the UUID specification, with following
@@ -75,9 +73,8 @@
  */
 public class UUIDTimer
 {
+    private final LoggerFacade _logger = LoggerFacade.getLogger(getClass());
 
-    private static final Logger logger = LoggerFactory.getLogger(UUIDTimer.class);
-    
     // // // Constants
 
     /**
@@ -247,7 +244,8 @@ public synchronized long getTimestamp()
          * independent of whether we can use it:
          */
         if (systime < _lastSystemTimestamp) {
-            logger.warn("System time going backwards! (got value {}, last {})", systime, _lastSystemTimestamp);
+            _logger.warn("System time going backwards! (got value %d, last %d)",
+                    systime, _lastSystemTimestamp);
             // Let's write it down, still
             _lastSystemTimestamp = systime;
         }
@@ -267,7 +265,7 @@ public synchronized long getTimestamp()
                 long origTime = systime;
                 systime = _lastUsedTimestamp + 1L;
 
-                logger.warn("Timestamp over-run: need to reinitialize random sequence");
+                _logger.warn("Timestamp over-run: need to reinitialize random sequence");
 
                 /* Clock counter is now at exactly the multiplier; no use
                  * just anding its value. So, we better get some random
@@ -371,7 +369,7 @@ protected final void getAndSetTimestamp(byte[] uuidBytes)
      * @param actDiff Number of milliseconds to wait for from current 
      *    time point, to catch up
      */
-    protected static void slowDown(long startTime, long actDiff)
+    protected void slowDown(long startTime, long actDiff)
     {
         /* First, let's determine how long we'd like to wait.
          * This is based on how far ahead are we as of now.
@@ -388,7 +386,7 @@ protected static void slowDown(long startTime, long actDiff)
         } else {
             delay = 5L;
         }
-        logger.warn("Need to wait for {} milliseconds; virtual clock advanced too far in the future", delay);
+        _logger.warn("Need to wait for %d milliseconds; virtual clock advanced too far in the future", delay);
         long waitUntil = startTime + delay;
         int counter = 0;
         do {

src/main/java/com/fasterxml/uuid/impl/LoggerFacade.java

@@ -0,0 +1,72 @@
+package com.fasterxml.uuid.impl;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Wrapper we (only) need to support CLI usage (see {@link com.fasterxml.uuid.Jug}
+ * wherein we do not actually  have logger package included; in which case we
+ * will print warning(s) out to {@code System.err}.
+ * For normal embedded usage no benefits, except if someone forgot their SLF4j API
+ * package. :)
+ *
+ * @since 4.1
+ */
+public class LoggerFacade {
+    private final Class<?> _forClass;
+
+    private WrappedLogger _logger;
+    
+    private LoggerFacade(Class<?> forClass) {
+        _forClass = forClass;
+    }
+
+    public static LoggerFacade getLogger(Class<?> forClass) {
+        return new LoggerFacade(forClass);
+    }
+
+    public void warn(String msg) {
+        _warn(msg);
+    }
+
+    public void warn(String msg, Object arg) {
+        _warn(String.format(msg, arg));
+    }
+
+    public void warn(String msg, Object arg, Object arg2) {
+        _warn(String.format(msg, arg, arg2));
+    }
+
+    private synchronized void _warn(String message) {
+        if (_logger == null) {
+            _logger = WrappedLogger.logger(_forClass);
+        }
+        _logger.warn(message);
+    }
+
+    private static class WrappedLogger {
+        private final Logger _logger;
+
+        private WrappedLogger(Logger l) {
+            _logger = l;
+        }
+
+        public static WrappedLogger logger(Class<?> forClass) {
+            // Why all these contortions? To support case where Slf4j API missing
+            // (or, if it ever fails for not having impl) to just print to STDERR
+            try {
+                return new WrappedLogger(LoggerFactory.getLogger(forClass));
+            } catch (Throwable t) {
+                return new WrappedLogger(null);
+            }
+        }
+
+        public void warn(String message) {
+            if (_logger != null) {
+                _logger.warn(message);
+            } else {
+                System.err.println("WARN: "+message);
+            }
+        }
+    }
+}

src/main/java/com/fasterxml/uuid/impl/NameBasedGenerator.java

@@ -7,9 +7,6 @@
 import com.fasterxml.uuid.StringArgGenerator;
 import com.fasterxml.uuid.UUIDType;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 /**
  * Implementation of UUID generator that uses one of name-based generation methods
  * (variants 3 (MD5) and 5 (SHA1)).
@@ -21,14 +18,13 @@
  */
 public class NameBasedGenerator extends StringArgGenerator
 {
-
-    private static final Logger logger = LoggerFactory.getLogger(NameBasedGenerator.class);
-    
     public final static Charset _utf8;
     static {
         _utf8 = Charset.forName("UTF-8");
     }
-    
+
+    private final LoggerFacade _logger = LoggerFacade.getLogger(getClass());
+
     /**
      * Namespace used when name is a DNS name.
      */
@@ -95,7 +91,7 @@ public NameBasedGenerator(UUID namespace, MessageDigest digester, UUIDType type)
             } else {
                 // Hmmh... error out? Let's default to SHA-1, but log a warning
                 type = UUIDType.NAME_BASED_SHA1;
-                logger.warn("Could not determine type of Digester from '{}'; assuming 'SHA-1' type", typeStr);
+                _logger.warn("Could not determine type of Digester from '%s'; assuming 'SHA-1' type", typeStr);
             }
         }
         _digester = digester;