* Add SLF4J to replace logging to stdout (MR fixes)

psobiech · psobiech · commit f33db5a66029 · 2020-11-28T21:22:12.000+01:00
diff --git a/core/src/main/java/tel/schich/javacan/platform/Platform.java b/core/src/main/java/tel/schich/javacan/platform/Platform.java
@@ -37,7 +37,7 @@
  * Helper class to detect and handle various platforms. Currently only Linux is handled.
  */
 public class Platform {
-    private static final Logger LOG = LoggerFactory.getLogger(Platform.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(Platform.class);
 
     private static final String LIB_PREFIX = "/native";
 
@@ -77,7 +77,7 @@ public static void loadBundledLib(String name) {
         }
 
         final String sourceLibPath = LIB_PREFIX + "/lib" + name + "-" + archSuffix + ".so";
-        LOG.trace("Loading native library for arch {} from {}", arch, sourceLibPath);
+        LOGGER.trace("Loading native library for arch {} from {}", arch, sourceLibPath);
 
         try (InputStream libStream = JavaCAN.class.getResourceAsStream(sourceLibPath)) {
             if (libStream == null) {
diff --git a/core/src/test/java/tel/schich/javacan/test/isotp/IsotpCanSocketOptionsTest.java b/core/src/test/java/tel/schich/javacan/test/isotp/IsotpCanSocketOptionsTest.java
@@ -37,26 +37,26 @@
 import static tel.schich.javacan.test.CanTestHelper.CAN_INTERFACE;
 
 public class IsotpCanSocketOptionsTest {
-    private static final Logger LOG = LoggerFactory.getLogger(IsotpCanSocketOptionsTest.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(IsotpCanSocketOptionsTest.class);
 
     @Test
     void testOptions() throws IOException {
         try (final IsotpCanChannel a = CanChannels.newIsotpChannel()) {
             IsotpOptions opts = a.getOption(OPTS);
-            LOG.debug(String.valueOf(opts));
+            LOGGER.debug(String.valueOf(opts));
             IsotpOptions customizedOpts = IsotpOptions.DEFAULT.withPadding(0xAA);
             a.setOption(OPTS, customizedOpts);
             assertEquals(customizedOpts, a.getOption(OPTS), "What goes in should come out");
 
             IsotpFlowControlOptions flowControlOpts = a.getOption(RECV_FC);
-            LOG.debug(String.valueOf(flowControlOpts));
+            LOGGER.debug(String.valueOf(flowControlOpts));
             IsotpFlowControlOptions customizedFlowControlOpts = IsotpFlowControlOptions.DEFAULT
                     .withBlockSize(1);
             a.setOption(RECV_FC, customizedFlowControlOpts);
             assertEquals(customizedFlowControlOpts, a.getOption(RECV_FC), "What goes in should come out");
 
             IsotpLinkLayerOptions linkLayerOpts = a.getOption(LL_OPTS);
-            LOG.debug(String.valueOf(linkLayerOpts));
+            LOGGER.debug(String.valueOf(linkLayerOpts));
             IsotpLinkLayerOptions customizedLinkLayerOpts = IsotpLinkLayerOptions.DEFAULT
                     .withTransmissionFlags(CanFrame.FD_FLAG_BIT_RATE_SWITCH);
             a.setOption(LL_OPTS, customizedLinkLayerOpts);
diff --git a/epoll/src/main/java/tel/schich/javacan/util/CanBroker.java b/epoll/src/main/java/tel/schich/javacan/util/CanBroker.java
@@ -58,7 +58,7 @@
  * Frames can be send either to individual interfaces or all at once.
  */
 public class CanBroker extends EventLoop<UnixFileDescriptor, RawCanChannel> {
-    private static final Logger LOG = LoggerFactory.getLogger(CanBroker.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(CanBroker.class);
 
     public static final Duration DEFAULT_TIMEOUT = ofMinutes(1);
     private static final CanFilter[] NO_FILTERS = { CanFilter.NONE };
@@ -274,10 +274,10 @@ protected void processEvents(List<IOEvent<UnixFileDescriptor>> events) throws IO
                         readBuffer.clear();
                         handler.handle(raw, raw.read(readBuffer));
                     } else {
-                        LOG.warn("Handler not found for channel: " + ch);
+                        LOGGER.warn("Handler not found for channel: " + ch);
                     }
                 } else {
-                    LOG.warn("Unsupported channel: " + ch);
+                    LOGGER.warn("Unsupported channel: " + ch);
                 }
             }
         }
diff --git a/epoll/src/main/java/tel/schich/javacan/util/EventLoop.java b/epoll/src/main/java/tel/schich/javacan/util/EventLoop.java
@@ -41,7 +41,7 @@
 import java.util.concurrent.ThreadFactory;
 
 public abstract class EventLoop<HandleType, ChannelType extends Channel> implements Closeable {
-    private static final Logger LOG = LoggerFactory.getLogger(CanBroker.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(CanBroker.class);
 
     private final String name;
 
@@ -207,13 +207,13 @@ protected final boolean poll(Duration timeout) throws IOException {
      * @return true if the event loop should continue, false for the event loop to exit
      */
     protected boolean handleException(Thread thread, Throwable t, boolean terminal) {
-        LOG.error("Polling thread failed: " + thread.getName(), t);
-        LOG.warn("Terminating other threads.");
+        LOGGER.error("Polling thread failed: " + thread.getName(), t);
+        LOGGER.warn("Terminating other threads.");
 
         try {
             shutdown();
         } catch (InterruptedException e) {
-            LOG.error("Got interrupted while stopping the threads");
+            LOGGER.error("Got interrupted while stopping the threads");
         }
 
         return true;
diff --git a/epoll/src/main/java/tel/schich/javacan/util/IsotpListener.java b/epoll/src/main/java/tel/schich/javacan/util/IsotpListener.java
@@ -45,7 +45,7 @@
  * for for each specific channel.
  */
 public class IsotpListener extends EventLoop<UnixFileDescriptor, IsotpCanChannel> {
-    private static final Logger LOG = LoggerFactory.getLogger(CanBroker.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(CanBroker.class);
 
     private final ByteBuffer readBuffer = IsotpCanChannel.allocateSufficientMemory();
 
@@ -126,10 +126,10 @@ protected void processEvents(List<IOEvent<UnixFileDescriptor>> events) throws IO
                         readBuffer.flip();
                         handler.handle(isotp, readBuffer.asReadOnlyBuffer());
                     } else {
-                        LOG.warn("Handler not found for channel: " + ch);
+                        LOGGER.warn("Handler not found for channel: " + ch);
                     }
                 } else {
-                    LOG.warn("Unsupported channel: " + ch);
+                    LOGGER.warn("Unsupported channel: " + ch);
                 }
             }
         }
diff --git a/epoll/src/test/java/tel/schich/javacan/test/select/EPollSelectorTest.java b/epoll/src/test/java/tel/schich/javacan/test/select/EPollSelectorTest.java
@@ -50,7 +50,7 @@
 import static tel.schich.javacan.test.CanTestHelper.runDelayed;
 
 public class EPollSelectorTest {
-    private static final Logger LOG = LoggerFactory.getLogger(EPollSelectorTest.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(EPollSelectorTest.class);
 
     @Test
     public void testOpenClose() throws IOException {
@@ -131,12 +131,12 @@ public void testEPollFdReuse() throws IOException, InterruptedException {
 
     private static SelectorRegistration<UnixFileDescriptor, RawCanChannel> configureAndRegisterChannel(IOSelector<UnixFileDescriptor> selector) throws IOException {
         final RawCanChannel ch = CanChannels.newRawChannel(CAN_INTERFACE);
-        LOG.debug("Created channel: " + ch);
+        LOGGER.debug("Created channel: " + ch);
 
         ch.configureBlocking(false);
         ch.setOption(CanSocketOptions.LOOPBACK, true);
         SelectorRegistration<UnixFileDescriptor, RawCanChannel> registration = selector.register(ch, SelectorRegistration.Operation.READ);
-        LOG.debug("Selection key: " + registration);
+        LOGGER.debug("Selection key: " + registration);
 
         return registration;
     }
diff --git a/epoll/src/test/java/tel/schich/javacan/test/util/CanBrokerTest.java b/epoll/src/test/java/tel/schich/javacan/test/util/CanBrokerTest.java
@@ -41,7 +41,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 class CanBrokerTest {
-    private static final Logger LOG = LoggerFactory.getLogger(CanBrokerTest.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(CanBrokerTest.class);
 
     private static final ThreadFactory FACTORY = r -> {
         Thread t = new Thread(r);
@@ -72,7 +72,7 @@ void testLoopback() throws Exception {
         });
 
         brokerB.addDevice(CanTestHelper.CAN_INTERFACE, (d, frame) -> {
-            LOG.debug(String.valueOf(frame));
+            LOGGER.debug(String.valueOf(frame));
         });
         brokerB.send(expected);
 
diff --git a/epoll/src/test/java/tel/schich/javacan/test/util/IsotpListenerTest.java b/epoll/src/test/java/tel/schich/javacan/test/util/IsotpListenerTest.java
@@ -47,7 +47,7 @@
 import static tel.schich.javacan.IsotpAddress.*;
 
 class IsotpListenerTest {
-    private static final Logger LOG = LoggerFactory.getLogger(IsotpListenerTest.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(IsotpListenerTest.class);
 
     @Test
     void testBroker() throws Exception {
@@ -108,7 +108,7 @@ public PingPing(Lock lock, Condition condition, ByteBuffer buf) {
         public void handle(IsotpCanChannel ch, ByteBuffer buffer) {
             int length = buffer.remaining();
             if (length % 200 == 0) {
-                LOG.debug(String.format("(%04d) -> %08X#%s%n", length, ch.getTxAddress().getId(), CanUtils.hexDump(buffer)));
+                LOGGER.debug(String.format("(%04d) -> %08X#%s%n", length, ch.getTxAddress().getId(), CanUtils.hexDump(buffer)));
             }
             buf.clear();
             buf.put(buffer);
@@ -118,7 +118,7 @@ public void handle(IsotpCanChannel ch, ByteBuffer buffer) {
                 ch.write(buf);
             } catch (Exception e) {
                 assertEquals(IllegalArgumentException.class, e.getClass());
-                LOG.debug("Failed to send message", e);
+                LOGGER.debug("Failed to send message", e);
                 lock.lock();
                 try {
                     condition.signalAll();
diff --git a/pom.xml b/pom.xml
@@ -90,6 +90,7 @@
                 <groupId>ch.qos.logback</groupId>
                 <artifactId>logback-classic</artifactId>
                 <version>${logback.version}</version>
+                <scope>test</scope>
             </dependency>
         </dependencies>
     </dependencyManagement>

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@`
`58`	`58`	`* Frames can be send either to individual interfaces or all at once.`
`59`	`59`	`*/`
`60`	`60`	`public class CanBroker extends EventLoop<UnixFileDescriptor, RawCanChannel> {`
`61`		`- private static final Logger LOG = LoggerFactory.getLogger(CanBroker.class);`
	`61`	`+ private static final Logger LOGGER = LoggerFactory.getLogger(CanBroker.class);`
`62`	`62`
`63`	`63`	`public static final Duration DEFAULT_TIMEOUT = ofMinutes(1);`
`64`	`64`	`private static final CanFilter[] NO_FILTERS = { CanFilter.NONE };`
`@@ -274,10 +274,10 @@ protected void processEvents(List<IOEvent<UnixFileDescriptor>> events) throws IO`
`274`	`274`	`readBuffer.clear();`
`275`	`275`	`handler.handle(raw, raw.read(readBuffer));`
`276`	`276`	`} else {`
`277`		`- LOG.warn("Handler not found for channel: " + ch);`
	`277`	`+ LOGGER.warn("Handler not found for channel: " + ch);`
`278`	`278`	`}`
`279`	`279`	`} else {`
`280`		`- LOG.warn("Unsupported channel: " + ch);`
	`280`	`+ LOGGER.warn("Unsupported channel: " + ch);`
`281`	`281`	`}`
`282`	`282`	`}`
`283`	`283`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@`
`45`	`45`	`* for for each specific channel.`
`46`	`46`	`*/`
`47`	`47`	`public class IsotpListener extends EventLoop<UnixFileDescriptor, IsotpCanChannel> {`
`48`		`- private static final Logger LOG = LoggerFactory.getLogger(CanBroker.class);`
	`48`	`+ private static final Logger LOGGER = LoggerFactory.getLogger(CanBroker.class);`
`49`	`49`
`50`	`50`	`private final ByteBuffer readBuffer = IsotpCanChannel.allocateSufficientMemory();`
`51`	`51`
`@@ -126,10 +126,10 @@ protected void processEvents(List<IOEvent<UnixFileDescriptor>> events) throws IO`
`126`	`126`	`readBuffer.flip();`
`127`	`127`	`handler.handle(isotp, readBuffer.asReadOnlyBuffer());`
`128`	`128`	`} else {`
`129`		`- LOG.warn("Handler not found for channel: " + ch);`
	`129`	`+ LOGGER.warn("Handler not found for channel: " + ch);`
`130`	`130`	`}`
`131`	`131`	`} else {`
`132`		`- LOG.warn("Unsupported channel: " + ch);`
	`132`	`+ LOGGER.warn("Unsupported channel: " + ch);`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`}`