Better locking and concurrency support for SocketConnection (serial, network, files, usb)

Author: tresf

src/qz/utils/FileWatcher.java

@@ -11,11 +11,12 @@
 import java.io.IOException;
 import java.io.RandomAccessFile;
 import java.nio.channels.ClosedChannelException;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.*;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class FileWatcher {
 
@@ -24,8 +25,7 @@ public class FileWatcher {
     private static Thread watchThread;
     private static WatchService watchService;
 
-    private static HashSet<FileIO> fileIOs = new HashSet<>();
-
+    private static final Set<FileIO> fileIOs = ConcurrentHashMap.newKeySet();
 
     public synchronized static void startWatchThread() throws IOException {
         if (watchThread != null && watchThread.isAlive()) {
@@ -59,7 +59,7 @@ public synchronized static void startWatchThread() throws IOException {
         watchThread.start();
     }
 
-    public static void registerWatch(FileIO fileIO) throws IOException {
+    public synchronized static void registerWatch(FileIO fileIO) throws IOException {
         fileIO.setWk(fileIO.getAbsolutePath().register(watchService,
                                                        StandardWatchEventKinds.ENTRY_MODIFY,
                                                        StandardWatchEventKinds.ENTRY_CREATE,
@@ -73,7 +73,7 @@ public static void deregisterWatch(FileIO fileIO) {
     }
 
 
-    private synchronized static void fileChanged(Path path, String fileName, String type) throws ClosedChannelException {
+    private static void fileChanged(Path path, String fileName, String type) throws ClosedChannelException {
         Path filePath = path.resolve(fileName);
         for(FileIO fio : fileIOs) {
             if (!fio.isMatch(fileName)) continue;
@@ -109,7 +109,7 @@ private synchronized static String getBytes(Path path, FileIO listener) throws I
             if (listener.isReversed()) { raf.seek(raf.length() - bytes.length); }
             raf.readFully(bytes);
 
-            return new String(bytes, Charset.forName("UTF-8"));
+            return new String(bytes, StandardCharsets.UTF_8);
         }
     }
 
@@ -118,7 +118,7 @@ private synchronized static String getLines(Path path, FileIO listener) throws I
 
         String buffer;
         if (listener.isReversed()) {
-            try(ReversedLinesFileReader reader = new ReversedLinesFileReader(path.toFile())) {
+            try(ReversedLinesFileReader reader = ReversedLinesFileReader.builder().setPath(path).get()) {
                 int count = 0;
                 while((buffer = reader.readLine()) != null && count++ != listener.getLines()) {
                     // Warning, this will strip "\r" from the data

src/qz/ws/SocketConnection.java

@@ -10,7 +10,7 @@
 
 import java.io.IOException;
 import java.nio.file.Path;
-import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class SocketConnection {
 
@@ -19,18 +19,18 @@ public class SocketConnection {
 
     private Certificate certificate;
 
-    private DeviceListener deviceListener;
+    private volatile DeviceListener deviceListener;
 
     // serial port -> open SerialIO
-    private final HashMap<String,SerialIO> openSerialPorts = new HashMap<>();
+    private final ConcurrentHashMap<String,SerialIO> openSerialPorts = new ConcurrentHashMap<>();
     // socket 'host:port' -> open ProtocolIO
-    private final HashMap<String,SocketIO> openNetworkSockets = new HashMap<>();
+    private final ConcurrentHashMap<String,SocketIO> openNetworkSockets = new ConcurrentHashMap<>();
 
     // absolute path -> open file listener
-    private final HashMap<Path,FileIO> openFiles = new HashMap<>();
+    private final ConcurrentHashMap<Path,FileIO> openFiles = new ConcurrentHashMap<>();
 
     // DeviceOptions -> open DeviceIO
-    private final HashMap<DeviceOptions,DeviceIO> openDevices = new HashMap<>();
+    private final ConcurrentHashMap<DeviceOptions,DeviceIO> openDevices = new ConcurrentHashMap<>();
 
 
     public SocketConnection(Certificate cert) {
@@ -46,28 +46,28 @@ public void setCertificate(Certificate newCert) {
     }
 
 
-    public void addSerialPort(String port, SerialIO io) {
+    public synchronized void addSerialPort(String port, SerialIO io) {
         openSerialPorts.put(port, io);
     }
 
-    public SerialIO getSerialPort(String port) {
+    public synchronized SerialIO getSerialPort(String port) {
         return openSerialPorts.get(port);
     }
 
-    public void removeSerialPort(String port) {
+    public synchronized void removeSerialPort(String port) {
         openSerialPorts.remove(port);
     }
 
 
-    public void addNetworkSocket(String location, SocketIO io) {
+    public synchronized void addNetworkSocket(String location, SocketIO io) {
         openNetworkSockets.put(location, io);
     }
 
-    public SocketIO getNetworkSocket(String location) {
+    public synchronized SocketIO getNetworkSocket(String location) {
         return openNetworkSockets.get(location);
     }
 
-    public void removeNetworkSocket(String location) {
+    public synchronized void removeNetworkSocket(String location) {
         openNetworkSockets.remove(location);
     }
 
@@ -87,37 +87,38 @@ public void stopDeviceListening() {
         deviceListener = null;
     }
 
-    public void addFileListener(Path absolute, FileIO listener) {
+    public synchronized void addFileListener(Path absolute, FileIO listener) {
         openFiles.put(absolute, listener);
     }
 
-    public FileIO getFileListener(Path absolute) {
+    public synchronized FileIO getFileListener(Path absolute) {
         return openFiles.get(absolute);
     }
 
-    public void removeFileListener(Path absolute) {
+    public synchronized void removeFileListener(Path absolute) {
         openFiles.remove(absolute);
     }
 
-    public void removeAllFileListeners() {
-        for(Path path : openFiles.keySet()) {
-            openFiles.get(path).close();
-            FileWatcher.deregisterWatch(openFiles.get(path));
+    public synchronized void removeAllFileListeners() {
+        for(FileIO io : openFiles.values()) {
+            if (io != null) {
+                io.close();
+                FileWatcher.deregisterWatch(io);
+            }
         }
-
         openFiles.clear();
     }
 
 
-    public void addDevice(DeviceOptions dOpts, DeviceIO io) {
+    public synchronized void addDevice(DeviceOptions dOpts, DeviceIO io) {
         openDevices.put(dOpts, io);
     }
 
-    public DeviceIO getDevice(DeviceOptions dOpts) {
+    public synchronized DeviceIO getDevice(DeviceOptions dOpts) {
         return openDevices.get(dOpts);
     }
 
-    public void removeDevice(DeviceOptions dOpts) {
+    public synchronized void removeDevice(DeviceOptions dOpts) {
         openDevices.remove(dOpts);
     }