P2P network improvements

common/src/main/java/io/bitsquare/app/Log.java

@@ -48,7 +48,7 @@ public class Log {
         rollingPolicy.start();
 
         triggeringPolicy = new SizeBasedTriggeringPolicy();
-        triggeringPolicy.setMaxFileSize(useDetailedLogging ? "50MB" : "1MB");
+        triggeringPolicy.setMaxFileSize(useDetailedLogging ? "10MB" : "1MB");
         triggeringPolicy.start();
 
         PatternLayoutEncoder encoder = new PatternLayoutEncoder();

common/src/main/java/io/bitsquare/common/util/Utilities.java

@@ -92,7 +92,7 @@ public class Utilities {
         executor.allowCoreThreadTimeOut(true);
         executor.setMaximumPoolSize(maximumPoolSize);
         executor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
-        executor.setRejectedExecutionHandler((r, e) -> log.warn("RejectedExecutionHandler called"));
+        executor.setRejectedExecutionHandler((r, e) -> log.debug("RejectedExecutionHandler called"));
         return executor;
     }
 

common/src/main/java/io/bitsquare/storage/FileManager.java

@@ -50,8 +50,6 @@ import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
 /**
  * Borrowed from BitcoinJ WalletFiles
  * A class that handles atomic and optionally delayed writing of a file to disk.
@@ -67,7 +65,6 @@ public class FileManager<T> {
     private final ScheduledThreadPoolExecutor executor;
     private final AtomicBoolean savePending;
     private final long delay;
-    private final TimeUnit delayTimeUnit;
     private final Callable<Void> saveFileTask;
     private T serializable;
 
@@ -76,7 +73,7 @@ public class FileManager<T> {
     // Constructor
     ///////////////////////////////////////////////////////////////////////////////////////////
 
-    public FileManager(File dir, File storageFile, long delay, TimeUnit delayTimeUnit) {
+    public FileManager(File dir, File storageFile, long delay) {
         this.dir = dir;
         this.storageFile = storageFile;
 
@@ -85,7 +82,6 @@ public class FileManager<T> {
         // File must only be accessed from the auto-save executor from now on, to avoid simultaneous access.
         savePending = new AtomicBoolean();
         this.delay = delay;
-        this.delayTimeUnit = checkNotNull(delayTimeUnit);
 
         saveFileTask = () -> {
             Thread.currentThread().setName("Save-file-task-" + new Random().nextInt(10000));
@@ -126,11 +122,15 @@ public class FileManager<T> {
      * Queues up a save in the background. Useful for not very important wallet changes.
      */
     public void saveLater(T serializable) {
+        saveLater(serializable, delay);
+    }
+
+    public void saveLater(T serializable, long delayInMilli) {
         this.serializable = serializable;
 
         if (savePending.getAndSet(true))
             return;   // Already pending.
-        executor.schedule(saveFileTask, delay, delayTimeUnit);
+        executor.schedule(saveFileTask, delayInMilli, TimeUnit.MILLISECONDS);
     }
 
     public synchronized T read(File file) {

common/src/main/java/io/bitsquare/storage/Storage.java

@@ -27,7 +27,6 @@ import javax.inject.Named;
 import java.io.File;
 import java.io.IOException;
 import java.io.Serializable;
-import java.util.concurrent.TimeUnit;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -82,7 +81,7 @@ public class Storage<T extends Serializable> {
     public T initAndGetPersisted(String fileName) {
         this.fileName = fileName;
         storageFile = new File(dir, fileName);
-        fileManager = new FileManager<>(dir, storageFile, 600, TimeUnit.MILLISECONDS);
+        fileManager = new FileManager<>(dir, storageFile, 600);
 
         return getPersisted();
     }
@@ -97,7 +96,7 @@ public class Storage<T extends Serializable> {
         this.serializable = serializable;
         this.fileName = fileName;
         storageFile = new File(dir, fileName);
-        fileManager = new FileManager<>(dir, storageFile, 600, TimeUnit.MILLISECONDS);
+        fileManager = new FileManager<>(dir, storageFile, 600);
 
         return getPersisted();
     }
@@ -106,6 +105,10 @@ public class Storage<T extends Serializable> {
         queueUpForSave(serializable);
     }
 
+    public void queueUpForSave(long delayInMilli) {
+        queueUpForSave(serializable, delayInMilli);
+    }
+
     // Save delayed and on a background thread
     public void queueUpForSave(T serializable) {
         if (serializable != null) {
@@ -118,6 +121,18 @@ public class Storage<T extends Serializable> {
         }
     }
 
+    public void queueUpForSave(T serializable, long delayInMilli) {
+        if (serializable != null) {
+            log.trace("save " + fileName);
+            checkNotNull(storageFile, "storageFile = null. Call setupFileStorage before using read/write.");
+
+            fileManager.saveLater(serializable, delayInMilli);
+        } else {
+            log.trace("queueUpForSave called but no serializable set");
+        }
+    }
+
+
     public void remove(String fileName) {
         fileManager.removeFile(fileName);
     }