Release 0.4.9

Replace deprecated backticks with $() for command substitution

README.md

@@ -25,7 +25,11 @@ Some of the UI tests will fail because they haven't been written yet :-/
 
 After you build the application, look inside `gui/build/distributions`.  Untar/unzip one of the `shadow` files and then run the jar contained inside by typing `java -jar MuWire-x.y.z.jar` in a terminal or command prompt.  
 
-If you have an I2P router running on the same machine that is all you need to do.  If you use a custom I2CP host and port, create a file `$HOME/.MuWire/i2p.properties` and put `i2cp.tcp.host=<host>` and `i2cp.tcp.port=<port>` in there.
+If you have an I2P router running on the same machine that is all you need to do.  If you use a custom I2CP host and port, create a file `i2p.properties` and put `i2cp.tcp.host=<host>` and `i2cp.tcp.port=<port>` in there.  On Windows that file should go into `%HOME%\AppData\Roaming\MuWire`, on Mac into `$HOME/Library/Application Support/MuWire` and on Linux `$HOME/.MuWire`
 
 If you do not have an I2P router, pass the following switch to the Java process: `-DembeddedRouter=true`.  This will launch MuWire's embedded router.  Be aware that this causes startup to take a lot longer.
 
+### GPG Fingerprint
+471B 9FD4 5517 A5ED 101F  C57D A728 3207 2D52 5E41
+
+You can find the full key at https://keybase.io/zlatinb

build.gradle

@@ -2,7 +2,7 @@ subprojects {
     apply plugin: 'groovy'
 
     dependencies {
-        compile 'net.i2p:i2p:0.9.40'
+        compile 'net.i2p:i2p:0.9.41'
         compile 'org.codehaus.groovy:groovy-all:2.4.15'
     }
 

cli/src/main/groovy/com/muwire/cli/Cli.groovy

@@ -16,66 +16,66 @@ import com.muwire.core.upload.UploadEvent
 import com.muwire.core.upload.UploadFinishedEvent
 
 class Cli {
-    
+
     public static void main(String[] args) {
         def home = System.getProperty("user.home") + File.separator + ".MuWire"
         home = new File(home)
         if (!home.exists())
             home.mkdirs()
-        
+
         def propsFile = new File(home,"MuWire.properties")
         if (!propsFile.exists()) {
             println "create props file ${propsFile.getAbsoluteFile()} before launching MuWire"
             System.exit(1)
         }
-        
+
         def props = new Properties()
         propsFile.withInputStream { props.load(it) }
         props = new MuWireSettings(props)
-        
-        Core core 
+
+        Core core
         try {
-            core = new Core(props, home, "0.4.7")
+            core = new Core(props, home, "0.4.9")
         } catch (Exception bad) {
             bad.printStackTrace(System.out)
             println "Failed to initialize core, exiting"
             System.exit(1)
         }
 
-                
-        
-        
+
+
+
         def filesList
         if (args.length == 0) {
             println "Enter a file containing list of files to share"
             def reader = new BufferedReader(new InputStreamReader(System.in))
             filesList = reader.readLine()
-        } else 
+        } else
             filesList = args[0]
-        
+
         Thread.sleep(1000)
         println "loading shared files from $filesList"
-        
+
         // listener for shared files
         def sharedListener = new SharedListener()
         core.eventBus.register(FileHashedEvent.class, sharedListener)
         core.eventBus.register(FileLoadedEvent.class, sharedListener)
-        
+
         // for connections
         def connectionsListener = new ConnectionListener()
         core.eventBus.register(ConnectionEvent.class, connectionsListener)
         core.eventBus.register(DisconnectionEvent.class, connectionsListener)
-        
+
         // for uploads
         def uploadsListener = new UploadsListener()
         core.eventBus.register(UploadEvent.class, uploadsListener)
         core.eventBus.register(UploadFinishedEvent.class, uploadsListener)
-        
+
         Timer timer = new Timer("status-printer", true)
         timer.schedule({
             println String.valueOf(new Date()) + " Connections $connectionsListener.connections Uploads $uploadsListener.uploads Shared $sharedListener.shared"
         } as TimerTask, 60000, 60000)
-        
+
         def latch = new CountDownLatch(1)
         def fileLoader = new Object() {
             public void onAllFilesLoadedEvent(AllFilesLoadedEvent e) {
@@ -85,14 +85,14 @@ class Cli {
         core.eventBus.register(AllFilesLoadedEvent.class, fileLoader)
         core.startServices()
 
-        core.eventBus.publish(new UILoadedEvent())        
+        core.eventBus.publish(new UILoadedEvent())
         println "waiting for files to load"
         latch.await()
         // now we begin
         println "MuWire is ready"
-        
+
         filesList = new File(filesList)
-        filesList.withReader { 
+        filesList.withReader {
             def toShare = it.readLine()
             core.eventBus.publish(new FileSharedEvent(file : new File(toShare)))
         }
@@ -103,7 +103,7 @@ class Cli {
         })
         Thread.sleep(Integer.MAX_VALUE)
     }
-    
+
     static class ConnectionListener {
         volatile int connections
         public void onConnectionEvent(ConnectionEvent e) {
@@ -114,7 +114,7 @@ class Cli {
             connections--
         }
     }
-    
+
     static class UploadsListener {
         volatile int uploads
         public void onUploadEvent(UploadEvent e) {
@@ -126,7 +126,7 @@ class Cli {
             println String.valueOf(new Date()) + " Finished upload of ${e.uploader.file.getName()} to ${e.uploader.request.downloader.getHumanReadableName()}"
         }
     }
-    
+
     static class SharedListener {
         volatile int shared
         void onFileHashedEvent(FileHashedEvent e) {

cli/src/main/groovy/com/muwire/cli/CliDownloader.groovy

@@ -17,31 +17,31 @@ import com.muwire.core.search.UIResultEvent
 import net.i2p.data.Base64
 
 class CliDownloader {
-    
+
     private static final List<Downloader> downloaders = Collections.synchronizedList(new ArrayList<>())
     private static final Map<UUID,ResultsHolder> resultsListeners = new ConcurrentHashMap<>()
-    
+
     public static void main(String []args) {
         def home = System.getProperty("user.home") + File.separator + ".MuWire"
         home = new File(home)
         if (!home.exists())
             home.mkdirs()
-        
+
         def propsFile = new File(home,"MuWire.properties")
         if (!propsFile.exists()) {
             println "create props file ${propsFile.getAbsoluteFile()} before launching MuWire"
             System.exit(1)
         }
-        
+
         def props = new Properties()
         propsFile.withInputStream { props.load(it) }
         props = new MuWireSettings(props)
-        
+
         def filesList
         int connections
         int resultWait
         if (args.length != 3) {
-            println "Enter a file containing list of hashes of files to download, " + 
+            println "Enter a file containing list of hashes of files to download, " +
                 "how many connections you want before searching" +
                 "and how long to wait for results to arrive"
                 System.exit(1)
@@ -53,24 +53,24 @@ class CliDownloader {
 
         Core core
         try {
-            core = new Core(props, home, "0.4.7")
+            core = new Core(props, home, "0.4.9")
         } catch (Exception bad) {
             bad.printStackTrace(System.out)
             println "Failed to initialize core, exiting"
             System.exit(1)
         }
-        
-        
+
+
         def latch = new CountDownLatch(connections)
         def connectionListener = new ConnectionWaiter(latch : latch)
         core.eventBus.register(ConnectionEvent.class, connectionListener)
-        
+
         core.startServices()
         println "starting to wait until there are $connections connections"
         latch.await()
-        
+
         println "connected, searching for files"
-        
+
         def file = new File(filesList)
         file.eachLine {
             String[] split = it.split(",")
@@ -79,22 +79,22 @@ class CliDownloader {
             def hash = Base64.decode(split[0])
             def searchEvent = new SearchEvent(searchHash : hash, uuid : uuid)
             core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop:true,
-                replyTo: core.me.destination, receivedOn : core.me.destination, originator: core.me)) 
+                replyTo: core.me.destination, receivedOn : core.me.destination, originator: core.me))
         }
-        
+
         println "waiting for results to arrive"
         Thread.sleep(resultWait * 1000)
-        
+
         core.eventBus.register(DownloadStartedEvent.class, new DownloadListener())
         resultsListeners.each { uuid, resultsListener ->
             println "starting download of $resultsListener.fileName from ${resultsListener.getResults().size()} hosts"
             File target = new File(resultsListener.fileName)
-            
+
             core.eventBus.publish(new UIDownloadEvent(target : target, result : resultsListener.getResults()))
         }
-        
+
         Thread.sleep(1000)
-        
+
         Timer timer = new Timer("stats-printer")
         timer.schedule({
             println "==== STATUS UPDATE ==="
@@ -109,7 +109,7 @@ class CliDownloader {
             }
             println "==== END ==="
         } as TimerTask, 60000, 60000)
-        
+
         println "waiting for downloads to finish"
         while(true) {
             boolean allFinished = true
@@ -120,10 +120,10 @@ class CliDownloader {
                 break
             Thread.sleep(1000)
         }
-        
+
         println "all downloads finished"
     }
-    
+
     static class ResultsHolder {
         final List<UIResultEvent> results = Collections.synchronizedList(new ArrayList<>())
         String fileName
@@ -134,7 +134,7 @@ class CliDownloader {
             results
         }
     }
-    
+
     static class ResultsListener {
         UUID uuid
         String fileName
@@ -148,7 +148,7 @@ class CliDownloader {
             listener.add(e)
         }
     }
-    
+
     static class ConnectionWaiter {
         CountDownLatch latch
         public void onConnectionEvent(ConnectionEvent e) {
@@ -156,7 +156,7 @@ class CliDownloader {
                 latch.countDown()
         }
     }
-    
+
 
     static class DownloadListener {
         public void onDownloadStartedEvent(DownloadStartedEvent e) {

cli/src/main/groovy/com/muwire/cli/FileList.groovy

@@ -11,10 +11,10 @@ class FileList {
             println "pass files.json as argument"
             System.exit(1)
         }
-        
+
         def slurper = new JsonSlurper()
         File filesJson = new File(args[0])
-        filesJson.eachLine { 
+        filesJson.eachLine {
             def json = slurper.parseText(it)
             String name = DataUtil.readi18nString(Base64.decode(json.file))
             println "$name,$json.length,$json.pieceSize,$json.infoHash"

core/build.gradle

@@ -2,9 +2,9 @@ apply plugin : 'application'
 mainClassName = 'com.muwire.core.Core'
 applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
 dependencies {
-    compile 'net.i2p:router:0.9.40'
-    compile 'net.i2p.client:mstreaming:0.9.40'
-    compile 'net.i2p.client:streaming:0.9.40'
+    compile 'net.i2p:router:0.9.41'
+    compile 'net.i2p.client:mstreaming:0.9.41'
+    compile 'net.i2p.client:streaming:0.9.41'
 
     testCompile 'org.junit.jupiter:junit-jupiter-api:5.4.2'    
     testCompile 'junit:junit:4.12'

core/src/main/groovy/com/muwire/core/Constants.groovy

@@ -4,10 +4,10 @@ import net.i2p.crypto.SigType
 
 class Constants {
     public static final byte PERSONA_VERSION = (byte)1
-    public static final SigType SIG_TYPE = SigType.EdDSA_SHA512_Ed25519 
-    
+    public static final SigType SIG_TYPE = SigType.EdDSA_SHA512_Ed25519
+
     public static final int MAX_HEADER_SIZE = 0x1 << 14
     public static final int MAX_HEADERS = 16
-    
+
     public static final String SPLIT_PATTERN = "[\\*\\+\\-,\\.:;\\(\\)=_/\\\\\\!\\\"\\\'\\\$%\\|\\[\\]\\{\\}\\?]"
 }

core/src/main/groovy/com/muwire/core/Core.groovy

@@ -20,6 +20,7 @@ import com.muwire.core.download.UIDownloadPausedEvent
 import com.muwire.core.download.UIDownloadResumedEvent
 import com.muwire.core.files.FileDownloadedEvent
 import com.muwire.core.files.FileHashedEvent
+import com.muwire.core.files.FileHashingEvent
 import com.muwire.core.files.FileHasher
 import com.muwire.core.files.FileLoadedEvent
 import com.muwire.core.files.FileManager
@@ -47,6 +48,8 @@ import com.muwire.core.trust.TrustSubscriptionEvent
 import com.muwire.core.update.UpdateClient
 import com.muwire.core.upload.UploadManager
 import com.muwire.core.util.MuWireLogManager
+import com.muwire.core.content.ContentControlEvent
+import com.muwire.core.content.ContentManager
 
 import groovy.util.logging.Log
 import net.i2p.I2PAppContext
@@ -68,13 +71,13 @@ import net.i2p.router.RouterContext
 
 @Log
 public class Core {
-    
+
     final EventBus eventBus
     final Persona me
     final File home
     final Properties i2pOptions
     final MuWireSettings muOptions
-    
+
     private final TrustService trustService
     private final TrustSubscriber trustSubscriber
     private final PersisterService persisterService
@@ -89,20 +92,21 @@ public class Core {
     private final DirectoryWatcher directoryWatcher
     final FileManager fileManager
     final UploadManager uploadManager
-    
+    final ContentManager contentManager
+
     private final Router router
-    
+
     final AtomicBoolean shutdown = new AtomicBoolean()
-        
+
     public Core(MuWireSettings props, File home, String myVersion) {
-        this.home = home		
+        this.home = home
         this.muOptions = props
-        
+
         i2pOptions = new Properties()
         def i2pOptionsFile = new File(home,"i2p.properties")
         if (i2pOptionsFile.exists()) {
             i2pOptionsFile.withInputStream { i2pOptions.load(it) }
-            
+
             if (!i2pOptions.containsKey("inbound.nickname"))
                 i2pOptions["inbound.nickname"] = "MuWire"
                 if (!i2pOptions.containsKey("outbound.nickname"))
@@ -122,7 +126,7 @@ public class Core {
             i2pOptions["i2np.udp.port"] = String.valueOf(port)
             i2pOptionsFile.withOutputStream { i2pOptions.store(it, "") }
         }
-        
+
         if (!props.embeddedRouter) {
             log.info "Initializing I2P context"
             I2PAppContext.getGlobalContext().logManager()
@@ -140,34 +144,34 @@ public class Core {
             routerProps.setProperty("i2np.udp.port", i2pOptions["i2np.udp.port"])
             routerProps.setProperty("i2np.udp.internalPort", i2pOptions["i2np.udp.port"])
             router = new Router(routerProps)
-            I2PAppContext.getGlobalContext().metaClass = new RouterContextMetaClass()
+            router.getContext().setLogManager(new MuWireLogManager())
             router.runRouter()
             while(!router.isRunning())
                 Thread.sleep(100)
         }
-        
-		log.info("initializing I2P socket manager")
-		def i2pClient = new I2PClientFactory().createClient()
-		File keyDat = new File(home, "key.dat")
-		if (!keyDat.exists()) {
-			log.info("Creating new key.dat")
-			keyDat.withOutputStream { 
-				i2pClient.createDestination(it, Constants.SIG_TYPE)
-			}
-		}
-		
-        
+
+        log.info("initializing I2P socket manager")
+        def i2pClient = new I2PClientFactory().createClient()
+        File keyDat = new File(home, "key.dat")
+        if (!keyDat.exists()) {
+            log.info("Creating new key.dat")
+            keyDat.withOutputStream {
+                i2pClient.createDestination(it, Constants.SIG_TYPE)
+            }
+        }
+
+
         // options like tunnel length and quantity
-		I2PSession i2pSession
-		I2PSocketManager socketManager
-		keyDat.withInputStream {
-			socketManager = new I2PSocketManagerFactory().createManager(it, i2pOptions["i2cp.tcp.host"], i2pOptions["i2cp.tcp.port"].toInteger(), i2pOptions)
-		}
-		socketManager.getDefaultOptions().setReadTimeout(60000)
-		socketManager.getDefaultOptions().setConnectTimeout(30000)
+        I2PSession i2pSession
+        I2PSocketManager socketManager
+        keyDat.withInputStream {
+            socketManager = new I2PSocketManagerFactory().createManager(it, i2pOptions["i2cp.tcp.host"], i2pOptions["i2cp.tcp.port"].toInteger(), i2pOptions)
+        }
+        socketManager.getDefaultOptions().setReadTimeout(60000)
+        socketManager.getDefaultOptions().setConnectTimeout(30000)
         socketManager.addDisconnectListener({eventBus.publish(new RouterDisconnectedEvent())} as DisconnectListener)
-		i2pSession = socketManager.getSession()
-		
+        i2pSession = socketManager.getSession()
+
         def destination = new Destination()
         def spk = new SigningPrivateKey(Constants.SIG_TYPE)
         keyDat.withInputStream {
@@ -175,8 +179,8 @@ public class Core {
             def privateKey = new PrivateKey()
             privateKey.readBytes(it)
             spk.readBytes(it)
-		}
-            
+        }
+
         def baos = new ByteArrayOutputStream()
         def daos = new DataOutputStream(baos)
         daos.write(Constants.PERSONA_VERSION)
@@ -193,66 +197,66 @@ public class Core {
         me = new Persona(new ByteArrayInputStream(baos.toByteArray()))
         log.info("Loaded myself as "+me.getHumanReadableName())
 
-		eventBus = new EventBus()
-		
-		log.info("initializing trust service")
-		File goodTrust = new File(home, "trusted")
-		File badTrust = new File(home, "distrusted")
-		trustService = new TrustService(goodTrust, badTrust, 5000)
-		eventBus.register(TrustEvent.class, trustService)
-		
-		
-		log.info "initializing file manager"
-		fileManager = new FileManager(eventBus, props)
-		eventBus.register(FileHashedEvent.class, fileManager)
-		eventBus.register(FileLoadedEvent.class, fileManager)
-		eventBus.register(FileDownloadedEvent.class, fileManager)
-		eventBus.register(FileUnsharedEvent.class, fileManager)
-		eventBus.register(SearchEvent.class, fileManager)
+        eventBus = new EventBus()
+
+        log.info("initializing trust service")
+        File goodTrust = new File(home, "trusted")
+        File badTrust = new File(home, "distrusted")
+        trustService = new TrustService(goodTrust, badTrust, 5000)
+        eventBus.register(TrustEvent.class, trustService)
+
+
+        log.info "initializing file manager"
+        fileManager = new FileManager(eventBus, props)
+        eventBus.register(FileHashedEvent.class, fileManager)
+        eventBus.register(FileLoadedEvent.class, fileManager)
+        eventBus.register(FileDownloadedEvent.class, fileManager)
+        eventBus.register(FileUnsharedEvent.class, fileManager)
+        eventBus.register(SearchEvent.class, fileManager)
         eventBus.register(DirectoryUnsharedEvent.class, fileManager)
-        
+
         log.info("initializing mesh manager")
         MeshManager meshManager = new MeshManager(fileManager, home, props)
         eventBus.register(SourceDiscoveredEvent.class, meshManager)
-		
-		log.info "initializing persistence service"
-		persisterService = new PersisterService(new File(home, "files.json"), eventBus, 15000, fileManager)
+
+        log.info "initializing persistence service"
+        persisterService = new PersisterService(new File(home, "files.json"), eventBus, 15000, fileManager)
         eventBus.register(UILoadedEvent.class, persisterService)
-        
-		log.info("initializing host cache")
-		File hostStorage = new File(home, "hosts.json")
+
+        log.info("initializing host cache")
+        File hostStorage = new File(home, "hosts.json")
         hostCache = new HostCache(trustService,hostStorage, 30000, props, i2pSession.getMyDestination())
-		eventBus.register(HostDiscoveredEvent.class, hostCache)
-		eventBus.register(ConnectionEvent.class, hostCache)
-		
-		log.info("initializing connection manager")
-		connectionManager = props.isLeaf() ? 
-			new LeafConnectionManager(eventBus, me, 3, hostCache, props) : 
+        eventBus.register(HostDiscoveredEvent.class, hostCache)
+        eventBus.register(ConnectionEvent.class, hostCache)
+
+        log.info("initializing connection manager")
+        connectionManager = props.isLeaf() ?
+            new LeafConnectionManager(eventBus, me, 3, hostCache, props) :
             new UltrapeerConnectionManager(eventBus, me, 512, 512, hostCache, trustService, props)
-		eventBus.register(TrustEvent.class, connectionManager)
-		eventBus.register(ConnectionEvent.class, connectionManager)
-		eventBus.register(DisconnectionEvent.class, connectionManager)
+        eventBus.register(TrustEvent.class, connectionManager)
+        eventBus.register(ConnectionEvent.class, connectionManager)
+        eventBus.register(DisconnectionEvent.class, connectionManager)
         eventBus.register(QueryEvent.class, connectionManager)
-		
-		log.info("initializing cache client")
-		cacheClient = new CacheClient(eventBus,hostCache, connectionManager, i2pSession, props, 10000)
-        
+
+        log.info("initializing cache client")
+        cacheClient = new CacheClient(eventBus,hostCache, connectionManager, i2pSession, props, 10000)
+
         log.info("initializing update client")
         updateClient = new UpdateClient(eventBus, i2pSession, myVersion, props, fileManager, me)
         eventBus.register(FileDownloadedEvent.class, updateClient)
         eventBus.register(UIResultBatchEvent.class, updateClient)
-        
-		log.info("initializing connector")
-		I2PConnector i2pConnector = new I2PConnector(socketManager)
-        
-		log.info "initializing results sender"
-		ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me)
-		
-		log.info "initializing search manager"
-		SearchManager searchManager = new SearchManager(eventBus, me, resultsSender)
-		eventBus.register(QueryEvent.class, searchManager)
-		eventBus.register(ResultsEvent.class, searchManager)
-		
+
+        log.info("initializing connector")
+        I2PConnector i2pConnector = new I2PConnector(socketManager)
+
+        log.info "initializing results sender"
+        ResultsSender resultsSender = new ResultsSender(eventBus, i2pConnector, me)
+
+        log.info "initializing search manager"
+        SearchManager searchManager = new SearchManager(eventBus, me, resultsSender)
+        eventBus.register(QueryEvent.class, searchManager)
+        eventBus.register(ResultsEvent.class, searchManager)
+
         log.info("initializing download manager")
         downloadManager = new DownloadManager(eventBus, trustService, meshManager, props, i2pConnector, home, me)
         eventBus.register(UIDownloadEvent.class, downloadManager)
@@ -262,34 +266,39 @@ public class Core {
         eventBus.register(SourceDiscoveredEvent.class, downloadManager)
         eventBus.register(UIDownloadPausedEvent.class, downloadManager)
         eventBus.register(UIDownloadResumedEvent.class, downloadManager)
-                
+
         log.info("initializing upload manager")
         uploadManager = new UploadManager(eventBus, fileManager, meshManager, downloadManager)
-        
+
         log.info("initializing connection establisher")
         connectionEstablisher = new ConnectionEstablisher(eventBus, i2pConnector, props, connectionManager, hostCache)
-        
-		log.info("initializing acceptor")
-		I2PAcceptor i2pAcceptor = new I2PAcceptor(socketManager)
-		connectionAcceptor = new ConnectionAcceptor(eventBus, connectionManager, props, 
+
+        log.info("initializing acceptor")
+        I2PAcceptor i2pAcceptor = new I2PAcceptor(socketManager)
+        connectionAcceptor = new ConnectionAcceptor(eventBus, connectionManager, props,
             i2pAcceptor, hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
-		
+
         log.info("initializing directory watcher")
         directoryWatcher = new DirectoryWatcher(eventBus, fileManager)
         eventBus.register(FileSharedEvent.class, directoryWatcher)
         eventBus.register(AllFilesLoadedEvent.class, directoryWatcher)
         eventBus.register(DirectoryUnsharedEvent.class, directoryWatcher)
-        
+
         log.info("initializing hasher service")
         hasherService = new HasherService(new FileHasher(), eventBus, fileManager)
         eventBus.register(FileSharedEvent.class, hasherService)
-        
+
         log.info("initializing trust subscriber")
         trustSubscriber = new TrustSubscriber(eventBus, i2pConnector, props)
         eventBus.register(UILoadedEvent.class, trustSubscriber)
         eventBus.register(TrustSubscriptionEvent.class, trustSubscriber)
-	}
-    
+        
+        log.info("initializing content manager")
+        contentManager = new ContentManager()
+        eventBus.register(ContentControlEvent.class, contentManager)
+        eventBus.register(QueryEvent.class, contentManager)
+    }
+
     public void startServices() {
         hasherService.start()
         trustService.start()
@@ -302,7 +311,7 @@ public class Core {
         hostCache.waitForLoad()
         updateClient.start()
     }
-    
+
     public void shutdown() {
         if (!shutdown.compareAndSet(false, true)) {
             log.info("already shutting down")
@@ -328,19 +337,6 @@ public class Core {
         }
     }
 
-    static class RouterContextMetaClass extends DelegatingMetaClass {
-        private final Object logManager = new MuWireLogManager()
-        RouterContextMetaClass() {
-            super(RouterContext.class)
-        }
-        
-        Object invokeMethod(Object object, String name, Object[] args) {
-            if (name == "logManager")
-                return logManager
-            super.invokeMethod(object, name, args)
-        }
-    }
-    
     static main(args) {
         def home = System.getProperty("user.home") + File.separator + ".MuWire"
         home = new File(home)
@@ -348,7 +344,7 @@ public class Core {
             log.info("creating home dir")
             home.mkdir()
         }
-        
+
         def props = new Properties()
         def propsFile = new File(home, "MuWire.properties")
         if (propsFile.exists()) {
@@ -364,10 +360,10 @@ public class Core {
                 props.write(it)
             }
         }
-        
-        Core core = new Core(props, home, "0.4.7")
+
+        Core core = new Core(props, home, "0.4.9")
         core.startServices()
-        
+
         // ... at the end, sleep or execute script
         if (args.length == 0) {
             log.info("initialized everything, sleeping")

core/src/main/groovy/com/muwire/core/Event.groovy

@@ -4,17 +4,17 @@ import java.util.concurrent.atomic.AtomicLong
 
 class Event {
 
-	private static final AtomicLong SEQ_NO = new AtomicLong();
-	final long seqNo
-	final long timestamp
-	
-	Event() {
-		seqNo = SEQ_NO.getAndIncrement()
-		timestamp = System.currentTimeMillis()
-	}
-	
-	@Override
-	public String toString() {
-		"seqNo $seqNo timestamp $timestamp"
-	}
+    private static final AtomicLong SEQ_NO = new AtomicLong();
+    final long seqNo
+    final long timestamp
+
+    Event() {
+        seqNo = SEQ_NO.getAndIncrement()
+        timestamp = System.currentTimeMillis()
+    }
+
+    @Override
+    public String toString() {
+        "seqNo $seqNo timestamp $timestamp"
+    }
 }

core/src/main/groovy/com/muwire/core/EventBus.groovy

@@ -10,42 +10,47 @@ import com.muwire.core.files.FileSharedEvent
 import groovy.util.logging.Log
 @Log
 class EventBus {
-	
-	private Map handlers = new HashMap()
-	private final Executor executor = Executors.newSingleThreadExecutor {r ->
-		def rv = new Thread(r)
-		rv.setDaemon(true)
-		rv.setName("event-bus")
-		rv
-	}
 
-	void publish(Event e) {
-		executor.execute({publishInternal(e)} as Runnable)
-	}
-	
-	private void publishInternal(Event e) {
-		log.fine "publishing event $e of type ${e.getClass().getSimpleName()} event $e"
-		def currentHandlers
-		final def clazz = e.getClass()
-		synchronized(this) {
-			currentHandlers = handlers.getOrDefault(clazz, [])
-		}
-		currentHandlers.each {
+    private Map handlers = new HashMap()
+    private final Executor executor = Executors.newSingleThreadExecutor {r ->
+        def rv = new Thread(r)
+        rv.setDaemon(true)
+        rv.setName("event-bus")
+        rv
+    }
+
+    void publish(Event e) {
+        executor.execute({publishInternal(e)} as Runnable)
+    }
+
+    private void publishInternal(Event e) {
+        log.fine "publishing event $e of type ${e.getClass().getSimpleName()} event $e"
+        def currentHandlers
+        final def clazz = e.getClass()
+        synchronized(this) {
+            currentHandlers = handlers.getOrDefault(clazz, [])
+        }
+        currentHandlers.each {
             try {
                 it."on${clazz.getSimpleName()}"(e)
             } catch (Exception bad) {
                 log.log(Level.SEVERE, "exception dispatching event",bad)
             }
-		}
-	}
-	
-	synchronized void register(Class<? extends Event> eventType, def handler) {
-		log.info "Registering $handler for type $eventType"
-		def currentHandlers = handlers.get(eventType)
-		if (currentHandlers == null) {
-			currentHandlers = new CopyOnWriteArrayList()
-			handlers.put(eventType, currentHandlers)
-		}
-		currentHandlers.add handler
-	}
+        }
+    }
+
+    synchronized void register(Class<? extends Event> eventType, def handler) {
+        log.info "Registering $handler for type $eventType"
+        def currentHandlers = handlers.get(eventType)
+        if (currentHandlers == null) {
+            currentHandlers = new CopyOnWriteArrayList()
+            handlers.put(eventType, currentHandlers)
+        }
+        currentHandlers.add handler
+    }
+    
+    synchronized void unregister(Class<? extends Event> eventType, def handler) {
+        log.info("Unregistering $handler for type $eventType")
+        handlers[eventType]?.remove(handler)
+    }
 }

core/src/main/groovy/com/muwire/core/InvalidSignatureException.groovy

@@ -13,5 +13,5 @@ class InvalidSignatureException extends Exception {
     public InvalidSignatureException(Throwable cause) {
         super(cause);
     }
-    
+
 }

core/src/main/groovy/com/muwire/core/MuWireSettings.groovy

@@ -8,7 +8,7 @@ import com.muwire.core.util.DataUtil
 import net.i2p.data.Base64
 
 class MuWireSettings {
-	
+
     final boolean isLeaf
     boolean allowUntrusted
     boolean allowTrustLists
@@ -28,19 +28,21 @@ class MuWireSettings {
     int meshExpiration
     boolean embeddedRouter
     int inBw, outBw
-    
-	MuWireSettings() {
+    Set<String> watchedKeywords
+    Set<String> watchedRegexes
+
+    MuWireSettings() {
         this(new Properties())
     }
-	
-	MuWireSettings(Properties props) {
-		isLeaf = Boolean.valueOf(props.get("leaf","false"))
-		allowUntrusted = Boolean.valueOf(props.getProperty("allowUntrusted","true"))
+
+    MuWireSettings(Properties props) {
+        isLeaf = Boolean.valueOf(props.get("leaf","false"))
+        allowUntrusted = Boolean.valueOf(props.getProperty("allowUntrusted","true"))
         allowTrustLists = Boolean.valueOf(props.getProperty("allowTrustLists","true"))
         trustListInterval = Integer.valueOf(props.getProperty("trustListInterval","1"))
-		crawlerResponse = CrawlerResponse.valueOf(props.get("crawlerResponse","REGISTERED"))
+        crawlerResponse = CrawlerResponse.valueOf(props.get("crawlerResponse","REGISTERED"))
         nickname = props.getProperty("nickname","MuWireUser")
-        downloadLocation = new File((String)props.getProperty("downloadLocation", 
+        downloadLocation = new File((String)props.getProperty("downloadLocation",
             System.getProperty("user.home")))
         downloadRetryInterval = Integer.parseInt(props.getProperty("downloadRetryInterval","1"))
         updateCheckInterval = Integer.parseInt(props.getProperty("updateCheckInterval","24"))
@@ -53,21 +55,21 @@ class MuWireSettings {
         embeddedRouter = Boolean.valueOf(props.getProperty("embeddedRouter","false"))
         inBw = Integer.valueOf(props.getProperty("inBw","256"))
         outBw = Integer.valueOf(props.getProperty("outBw","128"))
-        
-        watchedDirectories = new HashSet<>()
-        if (props.containsKey("watchedDirectories")) {
-            String[] encoded = props.getProperty("watchedDirectories").split(",")
-            encoded.each { watchedDirectories << DataUtil.readi18nString(Base64.decode(it)) }
-        }
-        
+
+        watchedDirectories = readEncodedSet(props, "watchedDirectories")
+        watchedKeywords = readEncodedSet(props, "watchedKeywords")
+        watchedRegexes = readEncodedSet(props, "watchedRegexes")
+
         trustSubscriptions = new HashSet<>()
         if (props.containsKey("trustSubscriptions")) {
-            props.getProperty("trustSubscriptions").split(",").each { 
+            props.getProperty("trustSubscriptions").split(",").each {
                 trustSubscriptions.add(new Persona(new ByteArrayInputStream(Base64.decode(it))))
             }
         }
-	}
-    
+        
+        
+    }
+
     void write(OutputStream out) throws IOException {
         Properties props = new Properties()
         props.setProperty("leaf", isLeaf.toString())
@@ -88,44 +90,59 @@ class MuWireSettings {
         props.setProperty("embeddedRouter", String.valueOf(embeddedRouter))
         props.setProperty("inBw", String.valueOf(inBw))
         props.setProperty("outBw", String.valueOf(outBw))
-        
-        if (!watchedDirectories.isEmpty()) {
-            String encoded = watchedDirectories.stream().
-                map({Base64.encode(DataUtil.encodei18nString(it))}).
-                collect(Collectors.joining(","))
-            props.setProperty("watchedDirectories", encoded)
-        }
-        
+
+        writeEncodedSet(watchedDirectories, "watchedDirectories", props)
+        writeEncodedSet(watchedKeywords, "watchedKeywords", props)
+        writeEncodedSet(watchedRegexes, "watchedRegexes", props)
+
         if (!trustSubscriptions.isEmpty()) {
             String encoded = trustSubscriptions.stream().
                 map({it.toBase64()}).
                 collect(Collectors.joining(","))
             props.setProperty("trustSubscriptions", encoded)
         }
-        
+
         props.store(out, "")
     }
-
-	boolean isLeaf() {
-		isLeaf
-	}
-	
-	boolean allowUntrusted() {
-		allowUntrusted
-	} 
-	
-	void setAllowUntrusted(boolean allowUntrusted) {
-		this.allowUntrusted = allowUntrusted
-	}
-	
-	CrawlerResponse getCrawlerResponse() {
-		crawlerResponse
-	}
-	
-	void setCrawlerResponse(CrawlerResponse crawlerResponse) {
-		this.crawlerResponse = crawlerResponse
-	}
     
+    private static Set<String> readEncodedSet(Properties props, String property) {
+        Set<String> rv = new HashSet<>()
+        if (props.containsKey(property)) {
+            String[] encoded = props.getProperty(property).split(",")
+            encoded.each { rv << DataUtil.readi18nString(Base64.decode(it)) }
+        }
+        rv
+    }
+    
+    private static void writeEncodedSet(Set<String> set, String property, Properties props) {
+        if (set.isEmpty())
+            return
+        String encoded = set.stream().
+            map({Base64.encode(DataUtil.encodei18nString(it))}).
+            collect(Collectors.joining(","))
+        props.setProperty(property, encoded)
+    }
+
+    boolean isLeaf() {
+        isLeaf
+    }
+
+    boolean allowUntrusted() {
+        allowUntrusted
+    }
+
+    void setAllowUntrusted(boolean allowUntrusted) {
+        this.allowUntrusted = allowUntrusted
+    }
+
+    CrawlerResponse getCrawlerResponse() {
+        crawlerResponse
+    }
+
+    void setCrawlerResponse(CrawlerResponse crawlerResponse) {
+        this.crawlerResponse = crawlerResponse
+    }
+
     String getNickname() {
         nickname
     }

core/src/main/groovy/com/muwire/core/Name.groovy

@@ -7,11 +7,11 @@ import java.nio.charset.StandardCharsets
  */
 public class Name {
     final String name
-    
+
     Name(String name) {
         this.name = name
     }
-    
+
     Name(InputStream nameStream) throws IOException {
         DataInputStream dis = new DataInputStream(nameStream)
         int length = dis.readUnsignedShort()
@@ -19,22 +19,22 @@ public class Name {
         dis.readFully(nameBytes)
         this.name = new String(nameBytes, StandardCharsets.UTF_8)
     }
-    
+
     public void write(OutputStream out) throws IOException {
         DataOutputStream dos = new DataOutputStream(out)
         dos.writeShort(name.length())
         dos.write(name.getBytes(StandardCharsets.UTF_8))
     }
-    
+
     public getName() {
         name
     }
-    
+
     @Override
     public int hashCode() {
         name.hashCode()
     }
-    
+
     @Override
     public boolean equals(Object o) {
         if (!(o instanceof Name))

core/src/main/groovy/com/muwire/core/Persona.groovy

@@ -9,7 +9,7 @@ import net.i2p.data.SigningPublicKey
 
 public class Persona {
     private static final int SIG_LEN = Constants.SIG_TYPE.getSigLen()
-    
+
     private final byte version
     private final Name name
     private final Destination destination
@@ -17,12 +17,12 @@ public class Persona {
     private volatile String humanReadableName
     private volatile String base64
     private volatile byte[] payload
-    
+
     public Persona(InputStream personaStream) throws IOException, InvalidSignatureException {
         version = (byte) (personaStream.read() & 0xFF)
         if (version != Constants.PERSONA_VERSION)
             throw new IOException("Unknown version "+version)
-            
+
         name = new Name(personaStream)
         destination = Destination.create(personaStream)
         sig = new byte[SIG_LEN]
@@ -31,7 +31,7 @@ public class Persona {
         if (!verify(version, name, destination, sig))
             throw new InvalidSignatureException(getHumanReadableName() + " didn't verify")
     }
-    
+
     private static boolean verify(byte version, Name name, Destination destination, byte [] sig) {
         ByteArrayOutputStream baos = new ByteArrayOutputStream()
         baos.write(version)
@@ -42,7 +42,7 @@ public class Persona {
         Signature signature = new Signature(Constants.SIG_TYPE, sig)
         DSAEngine.getInstance().verifySignature(signature, payload, spk)
     }
-    
+
     public void write(OutputStream out) throws IOException {
         if (payload == null) {
             ByteArrayOutputStream baos = new ByteArrayOutputStream()
@@ -54,13 +54,13 @@ public class Persona {
         }
         out.write(payload)
     }
-    
+
     public String getHumanReadableName() {
-        if (humanReadableName == null) 
+        if (humanReadableName == null)
             humanReadableName = name.getName() + "@" + destination.toBase32().substring(0,32)
         humanReadableName
     }
-    
+
     public String toBase64() {
         if (base64 == null) {
             def baos = new ByteArrayOutputStream()
@@ -69,12 +69,12 @@ public class Persona {
         }
         base64
     }
-    
+
     @Override
     public int hashCode() {
         name.hashCode() ^ destination.hashCode()
     }
-    
+
     @Override
     public boolean equals(Object o) {
         if (!(o instanceof Persona))
@@ -82,7 +82,7 @@ public class Persona {
         Persona other = (Persona)o
         name.equals(other.name) && destination.equals(other.destination)
     }
-    
+
     public static void main(String []args) {
         if (args.length != 1) {
             println "This utility decodes a bas64-encoded persona"

core/src/main/groovy/com/muwire/core/Service.groovy

@@ -2,12 +2,12 @@ package com.muwire.core
 
 abstract class Service {
 
-	volatile boolean loaded
-	
-	abstract void load()
-	
-	void waitForLoad() {
-		while (!loaded)
-			Thread.sleep(10)
-	}
+    volatile boolean loaded
+
+    abstract void load()
+
+    void waitForLoad() {
+        while (!loaded)
+            Thread.sleep(10)
+    }
 }

core/src/main/groovy/com/muwire/core/connection/Connection.groovy

@@ -21,109 +21,109 @@ import net.i2p.data.Destination
 
 @Log
 abstract class Connection implements Closeable {
-    
+
     private static final int SEARCHES = 10
     private static final long INTERVAL = 1000
 
-	final EventBus eventBus
-	final Endpoint endpoint
-	final boolean incoming
-	final HostCache hostCache
+    final EventBus eventBus
+    final Endpoint endpoint
+    final boolean incoming
+    final HostCache hostCache
     final TrustService trustService
     final MuWireSettings settings
-    	
-	private final AtomicBoolean running = new AtomicBoolean()
-	private final BlockingQueue messages = new LinkedBlockingQueue()
-	private final Thread reader, writer
+
+    private final AtomicBoolean running = new AtomicBoolean()
+    private final BlockingQueue messages = new LinkedBlockingQueue()
+    private final Thread reader, writer
     private final LinkedList<Long> searchTimestamps = new LinkedList<>()
-	
-	protected final String name
-	
-	long lastPingSentTime, lastPongReceivedTime
-	
-	Connection(EventBus eventBus, Endpoint endpoint, boolean incoming, 
+
+    protected final String name
+
+    long lastPingSentTime, lastPongReceivedTime
+
+    Connection(EventBus eventBus, Endpoint endpoint, boolean incoming,
         HostCache hostCache, TrustService trustService, MuWireSettings settings) {
-		this.eventBus = eventBus
-		this.incoming = incoming
-		this.endpoint = endpoint
-		this.hostCache = hostCache
+        this.eventBus = eventBus
+        this.incoming = incoming
+        this.endpoint = endpoint
+        this.hostCache = hostCache
         this.trustService = trustService
         this.settings = settings
-		
-		this.name = endpoint.destination.toBase32().substring(0,8)
-		
-		this.reader = new Thread({readLoop()} as Runnable)
-		this.reader.setName("reader-$name")
-		this.reader.setDaemon(true)
-		
-		this.writer = new Thread({writeLoop()} as Runnable)
-		this.writer.setName("writer-$name")
-		this.writer.setDaemon(true)
-	}
-	
-	/**
-	 * starts the connection threads
-	 */
-	void start() {
-		if (!running.compareAndSet(false, true)) {
-			log.log(Level.WARNING,"$name already running", new Exception())
-			return
-		}
-		reader.start()
-		writer.start()
-	}
-	
-	@Override
-	public void close() {
-		if (!running.compareAndSet(true, false)) {
-			log.log(Level.WARNING, "$name already closed", new Exception() )
-			return
-		}
+
+        this.name = endpoint.destination.toBase32().substring(0,8)
+
+        this.reader = new Thread({readLoop()} as Runnable)
+        this.reader.setName("reader-$name")
+        this.reader.setDaemon(true)
+
+        this.writer = new Thread({writeLoop()} as Runnable)
+        this.writer.setName("writer-$name")
+        this.writer.setDaemon(true)
+    }
+
+    /**
+     * starts the connection threads
+     */
+    void start() {
+        if (!running.compareAndSet(false, true)) {
+            log.log(Level.WARNING,"$name already running", new Exception())
+            return
+        }
+        reader.start()
+        writer.start()
+    }
+
+    @Override
+    public void close() {
+        if (!running.compareAndSet(true, false)) {
+            log.log(Level.WARNING, "$name already closed", new Exception() )
+            return
+        }
         log.info("closing $name")
-		reader.interrupt()
-		writer.interrupt()
-		endpoint.close()
-		eventBus.publish(new DisconnectionEvent(destination: endpoint.destination))
-	}
-	
-	protected void readLoop() {
-		try {
-			while(running.get()) {
-				read()
-			}
-		} catch (SocketTimeoutException e) {
+        reader.interrupt()
+        writer.interrupt()
+        endpoint.close()
+        eventBus.publish(new DisconnectionEvent(destination: endpoint.destination))
+    }
+
+    protected void readLoop() {
+        try {
+            while(running.get()) {
+                read()
+            }
+        } catch (SocketTimeoutException e) {
         } catch (Exception e) {
             log.log(Level.WARNING,"unhandled exception in reader",e)
         } finally {
             close()
         }
-	}
-	
-	protected abstract void read()
-	
-	protected void writeLoop() {
-		try {
-			while(running.get()) {
-				def message = messages.take()
-				write(message)
-			}
-		} catch (Exception e) {
+    }
+
+    protected abstract void read()
+
+    protected void writeLoop() {
+        try {
+            while(running.get()) {
+                def message = messages.take()
+                write(message)
+            }
+        } catch (Exception e) {
             log.log(Level.WARNING, "unhandled exception in writer",e)
         } finally {
             close()
         }
-	}
-	
-	protected abstract void write(def message);
-	
-	void sendPing() {
-		def ping = [:]
-		ping.type = "Ping"
-		ping.version = 1
-		messages.put(ping)
-		lastPingSentTime = System.currentTimeMillis()
-	}
-    
+    }
+
+    protected abstract void write(def message);
+
+    void sendPing() {
+        def ping = [:]
+        ping.type = "Ping"
+        ping.version = 1
+        messages.put(ping)
+        lastPingSentTime = System.currentTimeMillis()
+    }
+
     void sendQuery(QueryEvent e) {
         def query = [:]
         query.type = "Search"
@@ -139,27 +139,27 @@ abstract class Connection implements Closeable {
             query.originator = e.originator.toBase64()
         messages.put(query)
     }
-	
-	protected void handlePing() {
-		log.fine("$name received ping")
-		def pong = [:]
-		pong.type = "Pong"
-		pong.version = 1
-		pong.pongs = hostCache.getGoodHosts(10).collect { d -> d.toBase64() }
-		messages.put(pong)
-	}
-	
-	protected void handlePong(def pong) {
-		log.fine("$name received pong")
-		lastPongReceivedTime = System.currentTimeMillis()
-		if (pong.pongs == null)
-			throw new Exception("Pong doesn't have pongs")
-		pong.pongs.each { 
-			def dest = new Destination(it)
-			eventBus.publish(new HostDiscoveredEvent(destination: dest))
-		}
-	}
-    
+
+    protected void handlePing() {
+        log.fine("$name received ping")
+        def pong = [:]
+        pong.type = "Pong"
+        pong.version = 1
+        pong.pongs = hostCache.getGoodHosts(10).collect { d -> d.toBase64() }
+        messages.put(pong)
+    }
+
+    protected void handlePong(def pong) {
+        log.fine("$name received pong")
+        lastPongReceivedTime = System.currentTimeMillis()
+        if (pong.pongs == null)
+            throw new Exception("Pong doesn't have pongs")
+        pong.pongs.each {
+            def dest = new Destination(it)
+            eventBus.publish(new HostDiscoveredEvent(destination: dest))
+        }
+    }
+
     private boolean throttleSearch() {
         final long now = System.currentTimeMillis()
         if (searchTimestamps.size() < SEARCHES) {
@@ -173,19 +173,19 @@ abstract class Connection implements Closeable {
         searchTimestamps.removeFirst()
         false
     }
-    
+
     protected void handleSearch(def search) {
         if (throttleSearch()) {
             log.info("dropping excessive search")
             return
-        } 
+        }
         UUID uuid = UUID.fromString(search.uuid)
         byte [] infohash = null
         if (search.infohash != null) {
             search.keywords = null
             infohash = Base64.decode(search.infohash)
         }
-            
+
         Destination replyTo = new Destination(search.replyTo)
         TrustLevel trustLevel = trustService.getLevel(replyTo)
         if (trustLevel == TrustLevel.DISTRUSTED) {
@@ -196,7 +196,7 @@ abstract class Connection implements Closeable {
             log.info("dropping search from neutral peer")
             return
         }
-        
+
         Persona originator = null
         if (search.originator != null) {
             originator = new Persona(new ByteArrayInputStream(Base64.decode(search.originator)))
@@ -205,11 +205,11 @@ abstract class Connection implements Closeable {
                 return
             }
         }
-        
+
         boolean oob = false
         if (search.oobInfohash != null)
             oob = search.oobInfohash
-        
+
         SearchEvent searchEvent = new SearchEvent(searchTerms : search.keywords,
                                             searchHash : infohash,
                                             uuid : uuid,
@@ -220,6 +220,6 @@ abstract class Connection implements Closeable {
                                             receivedOn : endpoint.destination,
                                             firstHop : search.firstHop )
         eventBus.publish(event)
-                                            
+
     }
 }

core/src/main/groovy/com/muwire/core/connection/ConnectionAcceptor.groovy

@@ -29,97 +29,97 @@ import groovy.util.logging.Log
 @Log
 class ConnectionAcceptor {
 
-	final EventBus eventBus
-	final UltrapeerConnectionManager manager
-	final MuWireSettings settings
-	final I2PAcceptor acceptor
-	final HostCache hostCache
-	final TrustService trustService
-    final SearchManager searchManager 
+    final EventBus eventBus
+    final UltrapeerConnectionManager manager
+    final MuWireSettings settings
+    final I2PAcceptor acceptor
+    final HostCache hostCache
+    final TrustService trustService
+    final SearchManager searchManager
     final UploadManager uploadManager
     final ConnectionEstablisher establisher
-	
-	final ExecutorService acceptorThread
-	final ExecutorService handshakerThreads
-    
+
+    final ExecutorService acceptorThread
+    final ExecutorService handshakerThreads
+
     private volatile shutdown
-	
-	ConnectionAcceptor(EventBus eventBus, UltrapeerConnectionManager manager,
-		MuWireSettings settings, I2PAcceptor acceptor, HostCache hostCache,
-		TrustService trustService, SearchManager searchManager, UploadManager uploadManager,
+
+    ConnectionAcceptor(EventBus eventBus, UltrapeerConnectionManager manager,
+        MuWireSettings settings, I2PAcceptor acceptor, HostCache hostCache,
+        TrustService trustService, SearchManager searchManager, UploadManager uploadManager,
         ConnectionEstablisher establisher) {
-		this.eventBus = eventBus
-		this.manager = manager
-		this.settings = settings
-		this.acceptor = acceptor
-		this.hostCache = hostCache
-		this.trustService = trustService
+        this.eventBus = eventBus
+        this.manager = manager
+        this.settings = settings
+        this.acceptor = acceptor
+        this.hostCache = hostCache
+        this.trustService = trustService
         this.searchManager = searchManager
         this.uploadManager = uploadManager
-		this.establisher = establisher
-        
-		acceptorThread = Executors.newSingleThreadExecutor { r -> 
-			def rv = new Thread(r)
-			rv.setDaemon(true)
-			rv.setName("acceptor")
-			rv
-		}
-		
-		handshakerThreads = Executors.newCachedThreadPool { r ->
-			def rv = new Thread(r)
-			rv.setDaemon(true)
-			rv.setName("acceptor-processor-${System.currentTimeMillis()}")
-			rv
-		}
-	}
-	
-	void start() {
-		acceptorThread.execute({acceptLoop()} as Runnable)
-	}
-	
-	void stop() {
+        this.establisher = establisher
+
+        acceptorThread = Executors.newSingleThreadExecutor { r ->
+            def rv = new Thread(r)
+            rv.setDaemon(true)
+            rv.setName("acceptor")
+            rv
+        }
+
+        handshakerThreads = Executors.newCachedThreadPool { r ->
+            def rv = new Thread(r)
+            rv.setDaemon(true)
+            rv.setName("acceptor-processor-${System.currentTimeMillis()}")
+            rv
+        }
+    }
+
+    void start() {
+        acceptorThread.execute({acceptLoop()} as Runnable)
+    }
+
+    void stop() {
         shutdown = true
-		acceptorThread.shutdownNow()
-		handshakerThreads.shutdownNow()
-	}
-	
-	private void acceptLoop() {
+        acceptorThread.shutdownNow()
+        handshakerThreads.shutdownNow()
+    }
+
+    private void acceptLoop() {
         try {
-		while(true) {
-			def incoming = acceptor.accept()
-			log.info("accepted connection from ${incoming.destination.toBase32()}")
-			switch(trustService.getLevel(incoming.destination)) {
-				case TrustLevel.TRUSTED : break
-				case TrustLevel.NEUTRAL :
-					if (settings.allowUntrusted())
-						break
-				case TrustLevel.DISTRUSTED :
-					log.info("Disallowing distrusted connection")
-					incoming.close()
-					continue
-			}
-			handshakerThreads.execute({processIncoming(incoming)} as Runnable)
-		}
+        while(true) {
+            def incoming = acceptor.accept()
+            log.info("accepted connection from ${incoming.destination.toBase32()}")
+            switch(trustService.getLevel(incoming.destination)) {
+                case TrustLevel.TRUSTED : break
+                case TrustLevel.NEUTRAL :
+                    if (settings.allowUntrusted())
+                        break
+                case TrustLevel.DISTRUSTED :
+                    log.info("Disallowing distrusted connection")
+                    incoming.close()
+                    continue
+            }
+            handshakerThreads.execute({processIncoming(incoming)} as Runnable)
+        }
         } catch (Exception e) {
             log.log(Level.WARNING, "exception in accept loop",e)
             if (!shutdown)
                 throw e
         }
-	}
-	
-	private void processIncoming(Endpoint e) {
-		InputStream is = e.inputStream
-		try {
-			int read = is.read()
-			switch(read) {
-				case (byte)'M':
+    }
+
+    private void processIncoming(Endpoint e) {
+        InputStream is = e.inputStream
+        try {
+            int read = is.read()
+            switch(read) {
+                case (byte)'M':
                     if (settings.isLeaf())
                         throw new IOException("Incoming connection as leaf")
-					processMuWire(e)
-					break
-				case (byte)'G':
-					processGET(e)
-					break
+                    processMuWire(e)
+                    break
+                case (byte)'G':
+                    processGET(e)
+                    break
                 case (byte)'H':
                     processHashList(e)
                     break
@@ -129,76 +129,76 @@ class ConnectionAcceptor {
                 case (byte)'T':
                     processTRUST(e)
                     break
-				default:
-					throw new Exception("Invalid read $read")
-			}
-		} catch (Exception ex) {
-			log.log(Level.WARNING, "incoming connection failed",ex)
-			e.close()
-			eventBus.publish new ConnectionEvent(endpoint: e, incoming: true, leaf: null, status: ConnectionAttemptStatus.FAILED)
-		}
-	}
-	
-	private void processMuWire(Endpoint e) {
-		byte[] uWire = "uWire ".bytes
-		for (int i = 0; i < uWire.length; i++) {
-			int read = e.inputStream.read()
-			if (read != uWire[i]) {
-				throw new IOException("unexpected value $read at position $i")
-			}
-		}
-        
-		byte[] type = new byte[4]
-		DataInputStream dis = new DataInputStream(e.inputStream)
-		dis.readFully(type)
-                
+                default:
+                    throw new Exception("Invalid read $read")
+            }
+        } catch (Exception ex) {
+            log.log(Level.WARNING, "incoming connection failed",ex)
+            e.close()
+            eventBus.publish new ConnectionEvent(endpoint: e, incoming: true, leaf: null, status: ConnectionAttemptStatus.FAILED)
+        }
+    }
+
+    private void processMuWire(Endpoint e) {
+        byte[] uWire = "uWire ".bytes
+        for (int i = 0; i < uWire.length; i++) {
+            int read = e.inputStream.read()
+            if (read != uWire[i]) {
+                throw new IOException("unexpected value $read at position $i")
+            }
+        }
+
+        byte[] type = new byte[4]
+        DataInputStream dis = new DataInputStream(e.inputStream)
+        dis.readFully(type)
+
         if (type == "leaf".bytes)
             handleIncoming(e, true)
         else if (type == "peer".bytes)
             handleIncoming(e, false)
-        else 
+        else
             throw new IOException("unknown connection type $type")
     }
 
-	private void handleIncoming(Endpoint e, boolean leaf) {
-		boolean accept = !manager.isConnected(e.destination) && 
+    private void handleIncoming(Endpoint e, boolean leaf) {
+        boolean accept = !manager.isConnected(e.destination) &&
             !establisher.isInProgress(e.destination) &&
             (leaf ? manager.hasLeafSlots() : manager.hasPeerSlots())
-		if (accept) {
-			log.info("accepting connection, leaf:$leaf")
-			e.outputStream.write("OK".bytes)
-			e.outputStream.flush()
-			def wrapped = new Endpoint(e.destination, new InflaterInputStream(e.inputStream), new DeflaterOutputStream(e.outputStream, true), e.toClose)
-			eventBus.publish(new ConnectionEvent(endpoint: wrapped, incoming: true, leaf: leaf, status: ConnectionAttemptStatus.SUCCESSFUL))
-		} else {
-			log.info("rejecting connection, leaf:$leaf")
-			e.outputStream.write("REJECT".bytes)
-			def hosts = hostCache.getGoodHosts(10)
-			if (!hosts.isEmpty()) {
-				def json = [:]
-				json.tryHosts = hosts.collect { d -> d.toBase64() }
-				json = JsonOutput.toJson(json)
-				def os = new DataOutputStream(e.outputStream)
-				os.writeShort(json.bytes.length)
-				os.write(json.bytes)
-			}
-			e.outputStream.flush()
-			e.close()
-			eventBus.publish(new ConnectionEvent(endpoint: e, incoming: true, leaf: leaf, status: ConnectionAttemptStatus.REJECTED))
-		}
-	}
-	
-	
-	
-	private void processGET(Endpoint e) {
+        if (accept) {
+            log.info("accepting connection, leaf:$leaf")
+            e.outputStream.write("OK".bytes)
+            e.outputStream.flush()
+            def wrapped = new Endpoint(e.destination, new InflaterInputStream(e.inputStream), new DeflaterOutputStream(e.outputStream, true), e.toClose)
+            eventBus.publish(new ConnectionEvent(endpoint: wrapped, incoming: true, leaf: leaf, status: ConnectionAttemptStatus.SUCCESSFUL))
+        } else {
+            log.info("rejecting connection, leaf:$leaf")
+            e.outputStream.write("REJECT".bytes)
+            def hosts = hostCache.getGoodHosts(10)
+            if (!hosts.isEmpty()) {
+                def json = [:]
+                json.tryHosts = hosts.collect { d -> d.toBase64() }
+                json = JsonOutput.toJson(json)
+                def os = new DataOutputStream(e.outputStream)
+                os.writeShort(json.bytes.length)
+                os.write(json.bytes)
+            }
+            e.outputStream.flush()
+            e.close()
+            eventBus.publish(new ConnectionEvent(endpoint: e, incoming: true, leaf: leaf, status: ConnectionAttemptStatus.REJECTED))
+        }
+    }
+
+
+
+    private void processGET(Endpoint e) {
         byte[] et = new byte[3]
         final DataInputStream dis = new DataInputStream(e.getInputStream())
         dis.readFully(et)
         if (et != "ET ".getBytes(StandardCharsets.US_ASCII))
             throw new IOException("Invalid GET connection")
         uploadManager.processGET(e)
-	}
-    
+    }
+
     private void processHashList(Endpoint e) {
         byte[] ashList = new byte[8]
         final DataInputStream dis = new DataInputStream(e.getInputStream())
@@ -207,7 +207,7 @@ class ConnectionAcceptor {
             throw new IOException("Invalid HASHLIST connection")
         uploadManager.processHashList(e)
     }
-    
+
     private void processPOST(final Endpoint e) throws IOException {
         byte [] ost = new byte[4]
         final DataInputStream dis = new DataInputStream(e.getInputStream())
@@ -246,7 +246,7 @@ class ConnectionAcceptor {
             e.close()
         }
     }
-    
+
     private void processTRUST(Endpoint e) {
         byte[] RUST = new byte[6]
         DataInputStream dis = new DataInputStream(e.getInputStream())
@@ -255,7 +255,7 @@ class ConnectionAcceptor {
             throw new IOException("Invalid TRUST connection")
         String header
         while ((header = DataUtil.readTillRN(dis)) != ""); // ignore headers for now
-        
+
         OutputStream os = e.getOutputStream()
         if (!settings.allowTrustLists) {
             os.write("403 Not Allowed\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
@@ -263,7 +263,7 @@ class ConnectionAcceptor {
             e.close()
             return
         }
-        
+
         os.write("200 OK\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
         List<Persona> good = new ArrayList<>(trustService.good.values())
         int size = Math.min(Short.MAX_VALUE * 2, good.size())
@@ -273,7 +273,7 @@ class ConnectionAcceptor {
         good.each {
             it.write(dos)
         }
-        
+
         List<Persona> bad = new ArrayList<>(trustService.bad.values())
         size = Math.min(Short.MAX_VALUE * 2, bad.size())
         bad = bad.subList(0, size)
@@ -281,9 +281,9 @@ class ConnectionAcceptor {
         bad.each {
             it.write(dos)
         }
-        
+
         dos.flush()
         e.close()
     }
-	
+
 }

core/src/main/groovy/com/muwire/core/connection/ConnectionEstablisher.groovy

@@ -21,164 +21,164 @@ import net.i2p.util.ConcurrentHashSet
 
 @Log
 class ConnectionEstablisher {
-	
-	private static final int CONCURRENT = 4
 
-	final EventBus eventBus
-	final I2PConnector i2pConnector
-	final MuWireSettings settings
-	final ConnectionManager connectionManager
-	final HostCache hostCache
-	
-	final Timer timer
-	final ExecutorService executor
-	
-	final Set inProgress = new ConcurrentHashSet()
-	
+    private static final int CONCURRENT = 4
+
+    final EventBus eventBus
+    final I2PConnector i2pConnector
+    final MuWireSettings settings
+    final ConnectionManager connectionManager
+    final HostCache hostCache
+
+    final Timer timer
+    final ExecutorService executor
+
+    final Set inProgress = new ConcurrentHashSet()
+
     ConnectionEstablisher(){}
-    
-	ConnectionEstablisher(EventBus eventBus, I2PConnector i2pConnector, MuWireSettings settings,
-		ConnectionManager connectionManager, HostCache hostCache) {
-		this.eventBus = eventBus
-		this.i2pConnector = i2pConnector
-		this.settings = settings
-		this.connectionManager = connectionManager
-		this.hostCache = hostCache
-		timer = new Timer("connection-timer",true)
-		executor = Executors.newFixedThreadPool(CONCURRENT, { r -> 
-			def rv = new Thread(r)
-			rv.setDaemon(true)
-			rv.setName("connector-${System.currentTimeMillis()}")
-			rv 
-		} as ThreadFactory)
-	}
-	
-	void start() {
-		timer.schedule({connectIfNeeded()} as TimerTask, 100, 1000)
-	}
-	
-	void stop() {
-		timer.cancel()
-		executor.shutdownNow()
-	}
-	
-	private void connectIfNeeded() {
-		if (!connectionManager.needsConnections())
-			return
-		if (inProgress.size() >= CONCURRENT)
-			return
 
-		def toTry = null
-		for (int i = 0; i < 5; i++) {
-			toTry = hostCache.getHosts(1)
-			if (toTry.isEmpty())
-				return
-			toTry = toTry[0]
-			if (!connectionManager.isConnected(toTry) &&
-				!inProgress.contains(toTry)) {
-				break
-			}
-		}
-		if (toTry == null)
-			return
-		if (!connectionManager.isConnected(toTry) && inProgress.add(toTry))
-			executor.execute({connect(toTry)} as Runnable)
-	}
-	
-	private void connect(Destination toTry) {
-		log.info("starting connect to ${toTry.toBase32()}")
-		try {
-			def endpoint = i2pConnector.connect(toTry)
-			log.info("successful transport connect to ${toTry.toBase32()}")
-			
-			// outgoing handshake
-			endpoint.outputStream.write("MuWire ".bytes)
-			def type = settings.isLeaf() ? "leaf" : "peer"
-			endpoint.outputStream.write(type.bytes)
-			endpoint.outputStream.flush()
-			
-			InputStream is = endpoint.inputStream
-			int read = is.read()
-			if (read == -1) {
-				fail endpoint
-				return
-			}
-			switch(read) {
-				case (byte)'O': readK(endpoint); break
-				case (byte)'R': readEJECT(endpoint); break
-				default :
-					log.warning("unknown response $read")
-					fail endpoint
-			}
-		} catch (Exception e) {
-			log.log(Level.WARNING, "Couldn't connect to ${toTry.toBase32()}", e)
-			def endpoint = new Endpoint(toTry, null, null, null)
-			fail(endpoint)
-		} finally {
-			inProgress.remove(toTry)
-		}
-	}
-	
-	private void fail(Endpoint endpoint) {
-		endpoint.close()
-		eventBus.publish(new ConnectionEvent(endpoint: endpoint, incoming: false, leaf: false, status: ConnectionAttemptStatus.FAILED))
-	}
-	
-	private void readK(Endpoint e) {
-		int read = e.inputStream.read()
-		if (read != 'K') {
-			log.warning("unknown response after O: $read")
-			fail e
-			return
-		}
-		
-		log.info("connection to ${e.destination.toBase32()} established")
-		
-		// wrap into deflater / inflater streams and publish
-		def wrapped = new Endpoint(e.destination, new InflaterInputStream(e.inputStream), new DeflaterOutputStream(e.outputStream, true), e.toClose)
-		eventBus.publish(new ConnectionEvent(endpoint: wrapped, incoming: false, leaf: false, status: ConnectionAttemptStatus.SUCCESSFUL))
-	}
-	
-	private void readEJECT(Endpoint e) {
-		byte[] eject = "EJECT".bytes
-		for (int i = 0; i < eject.length; i++) {
-			int read = e.inputStream.read()
-			if (read != eject[i]) {
-				log.warning("Unknown response after R at position $i")
-				fail e
-				return
-			}
-		}
-		log.info("connection to ${e.destination.toBase32()} rejected")
-		
-		
-		eventBus.publish(new ConnectionEvent(endpoint: e, incoming: false, leaf: false, status: ConnectionAttemptStatus.REJECTED))
-		try {
-			DataInputStream dais = new DataInputStream(e.inputStream)
-			int payloadSize = dais.readUnsignedShort()
-			byte[] payload = new byte[payloadSize]
-			dais.readFully(payload)
+    ConnectionEstablisher(EventBus eventBus, I2PConnector i2pConnector, MuWireSettings settings,
+        ConnectionManager connectionManager, HostCache hostCache) {
+        this.eventBus = eventBus
+        this.i2pConnector = i2pConnector
+        this.settings = settings
+        this.connectionManager = connectionManager
+        this.hostCache = hostCache
+        timer = new Timer("connection-timer",true)
+        executor = Executors.newFixedThreadPool(CONCURRENT, { r ->
+            def rv = new Thread(r)
+            rv.setDaemon(true)
+            rv.setName("connector-${System.currentTimeMillis()}")
+            rv
+        } as ThreadFactory)
+    }
 
-			def json = new JsonSlurper()
-			json = json.parse(payload)
+    void start() {
+        timer.schedule({connectIfNeeded()} as TimerTask, 100, 1000)
+    }
 
-			if (json.tryHosts == null) {
-				log.warning("post-rejection json didn't contain hosts to try")
-				return
-			}
+    void stop() {
+        timer.cancel()
+        executor.shutdownNow()
+    }
+
+    private void connectIfNeeded() {
+        if (!connectionManager.needsConnections())
+            return
+        if (inProgress.size() >= CONCURRENT)
+            return
+
+        def toTry = null
+        for (int i = 0; i < 5; i++) {
+            toTry = hostCache.getHosts(1)
+            if (toTry.isEmpty())
+                return
+            toTry = toTry[0]
+            if (!connectionManager.isConnected(toTry) &&
+                !inProgress.contains(toTry)) {
+                break
+            }
+        }
+        if (toTry == null)
+            return
+        if (!connectionManager.isConnected(toTry) && inProgress.add(toTry))
+            executor.execute({connect(toTry)} as Runnable)
+    }
+
+    private void connect(Destination toTry) {
+        log.info("starting connect to ${toTry.toBase32()}")
+        try {
+            def endpoint = i2pConnector.connect(toTry)
+            log.info("successful transport connect to ${toTry.toBase32()}")
+
+            // outgoing handshake
+            endpoint.outputStream.write("MuWire ".bytes)
+            def type = settings.isLeaf() ? "leaf" : "peer"
+            endpoint.outputStream.write(type.bytes)
+            endpoint.outputStream.flush()
+
+            InputStream is = endpoint.inputStream
+            int read = is.read()
+            if (read == -1) {
+                fail endpoint
+                return
+            }
+            switch(read) {
+                case (byte)'O': readK(endpoint); break
+                case (byte)'R': readEJECT(endpoint); break
+                default :
+                    log.warning("unknown response $read")
+                    fail endpoint
+            }
+        } catch (Exception e) {
+            log.log(Level.WARNING, "Couldn't connect to ${toTry.toBase32()}", e)
+            def endpoint = new Endpoint(toTry, null, null, null)
+            fail(endpoint)
+        } finally {
+            inProgress.remove(toTry)
+        }
+    }
+
+    private void fail(Endpoint endpoint) {
+        endpoint.close()
+        eventBus.publish(new ConnectionEvent(endpoint: endpoint, incoming: false, leaf: false, status: ConnectionAttemptStatus.FAILED))
+    }
+
+    private void readK(Endpoint e) {
+        int read = e.inputStream.read()
+        if (read != 'K') {
+            log.warning("unknown response after O: $read")
+            fail e
+            return
+        }
+
+        log.info("connection to ${e.destination.toBase32()} established")
+
+        // wrap into deflater / inflater streams and publish
+        def wrapped = new Endpoint(e.destination, new InflaterInputStream(e.inputStream), new DeflaterOutputStream(e.outputStream, true), e.toClose)
+        eventBus.publish(new ConnectionEvent(endpoint: wrapped, incoming: false, leaf: false, status: ConnectionAttemptStatus.SUCCESSFUL))
+    }
+
+    private void readEJECT(Endpoint e) {
+        byte[] eject = "EJECT".bytes
+        for (int i = 0; i < eject.length; i++) {
+            int read = e.inputStream.read()
+            if (read != eject[i]) {
+                log.warning("Unknown response after R at position $i")
+                fail e
+                return
+            }
+        }
+        log.info("connection to ${e.destination.toBase32()} rejected")
+
+
+        eventBus.publish(new ConnectionEvent(endpoint: e, incoming: false, leaf: false, status: ConnectionAttemptStatus.REJECTED))
+        try {
+            DataInputStream dais = new DataInputStream(e.inputStream)
+            int payloadSize = dais.readUnsignedShort()
+            byte[] payload = new byte[payloadSize]
+            dais.readFully(payload)
+
+            def json = new JsonSlurper()
+            json = json.parse(payload)
+
+            if (json.tryHosts == null) {
+                log.warning("post-rejection json didn't contain hosts to try")
+                return
+            }
+
+            json.tryHosts.asList().each {
+                Destination suggested = new Destination(it)
+                eventBus.publish(new HostDiscoveredEvent(destination: suggested))
+            }
+        } catch (Exception ignore) {
+            log.log(Level.WARNING,"Problem parsing post-rejection payload",ignore)
+        } finally {
+            // the end
+            e.close()
+        }
+    }
 
-			json.tryHosts.asList().each {
-				Destination suggested = new Destination(it)
-				eventBus.publish(new HostDiscoveredEvent(destination: suggested))
-			}
-		} catch (Exception ignore) {
-			log.log(Level.WARNING,"Problem parsing post-rejection payload",ignore)
-		} finally {
-			// the end
-			e.close()
-		}
-	}
-    
     public boolean isInProgress(Destination d) {
         inProgress.contains(d)
     }

core/src/main/groovy/com/muwire/core/connection/ConnectionEvent.groovy

@@ -6,14 +6,14 @@ import net.i2p.data.Destination
 
 class ConnectionEvent extends Event {
 
-	Endpoint endpoint
-	boolean incoming
-	Boolean leaf // can be null if uknown
-	ConnectionAttemptStatus status
-	
-	@Override
-	public String toString() {
-		"ConnectionEvent ${super.toString()} endpoint: $endpoint incoming: $incoming leaf : $leaf status : $status"
-	}
+    Endpoint endpoint
+    boolean incoming
+    Boolean leaf // can be null if uknown
+    ConnectionAttemptStatus status
+
+    @Override
+    public String toString() {
+        "ConnectionEvent ${super.toString()} endpoint: $endpoint incoming: $incoming leaf : $leaf status : $status"
+    }
 
 }

core/src/main/groovy/com/muwire/core/connection/ConnectionManager.groovy

@@ -11,64 +11,64 @@ import com.muwire.core.trust.TrustLevel
 import net.i2p.data.Destination
 
 abstract class ConnectionManager {
-	
-	private static final int PING_TIME = 20000
 
-	final EventBus eventBus
-	
-	private final Timer timer
-	
-	protected final HostCache hostCache
+    private static final int PING_TIME = 20000
+
+    final EventBus eventBus
+
+    private final Timer timer
+
+    protected final HostCache hostCache
     protected final Persona me
     protected final MuWireSettings settings
-	
-	ConnectionManager() {}
-	
-	ConnectionManager(EventBus eventBus, Persona me, HostCache hostCache, MuWireSettings settings) {
-		this.eventBus = eventBus
+
+    ConnectionManager() {}
+
+    ConnectionManager(EventBus eventBus, Persona me, HostCache hostCache, MuWireSettings settings) {
+        this.eventBus = eventBus
         this.me = me
-		this.hostCache = hostCache
+        this.hostCache = hostCache
         this.settings = settings
-		this.timer = new Timer("connections-pinger",true)
-	}
-	
-	void start() {
-		timer.schedule({sendPings()} as TimerTask, 1000,1000)
-	}
-	
-	void stop() {
-		timer.cancel()
-		getConnections().each { it.close() }
-	}
-	
-	void onTrustEvent(TrustEvent e) {
-		if (e.level == TrustLevel.DISTRUSTED)
-			drop(e.persona.destination)
-	}
-    
-	abstract void drop(Destination d)
-	
-	abstract Collection<Connection> getConnections()
-	
-	protected abstract int getDesiredConnections()
-	
-	boolean needsConnections() {
-		return getConnections().size() < getDesiredConnections()
-	}
-	
-	abstract boolean isConnected(Destination d)
-	
-	abstract void onConnectionEvent(ConnectionEvent e)
-	
-	abstract void onDisconnectionEvent(DisconnectionEvent e)
-    
+        this.timer = new Timer("connections-pinger",true)
+    }
+
+    void start() {
+        timer.schedule({sendPings()} as TimerTask, 1000,1000)
+    }
+
+    void stop() {
+        timer.cancel()
+        getConnections().each { it.close() }
+    }
+
+    void onTrustEvent(TrustEvent e) {
+        if (e.level == TrustLevel.DISTRUSTED)
+            drop(e.persona.destination)
+    }
+
+    abstract void drop(Destination d)
+
+    abstract Collection<Connection> getConnections()
+
+    protected abstract int getDesiredConnections()
+
+    boolean needsConnections() {
+        return getConnections().size() < getDesiredConnections()
+    }
+
+    abstract boolean isConnected(Destination d)
+
+    abstract void onConnectionEvent(ConnectionEvent e)
+
+    abstract void onDisconnectionEvent(DisconnectionEvent e)
+
     abstract void shutdown()
-	
-	protected void sendPings() {
-		final long now = System.currentTimeMillis()
-		getConnections().each { 
-			if (now - it.lastPingSentTime > PING_TIME)
-				it.sendPing()
-		}
-	}
+
+    protected void sendPings() {
+        final long now = System.currentTimeMillis()
+        getConnections().each {
+            if (now - it.lastPingSentTime > PING_TIME)
+                it.sendPing()
+        }
+    }
 }

core/src/main/groovy/com/muwire/core/connection/DisconnectionEvent.groovy

@@ -5,11 +5,11 @@ import com.muwire.core.Event
 import net.i2p.data.Destination
 
 class DisconnectionEvent extends Event {
-	
-	Destination destination
 
-	@Override
-	public String toString() {
-		"DisconnectionEvent ${super.toString()} destination:${destination.toBase32()}"
-	}
+    Destination destination
+
+    @Override
+    public String toString() {
+        "DisconnectionEvent ${super.toString()} destination:${destination.toBase32()}"
+    }
 }

core/src/main/groovy/com/muwire/core/connection/Endpoint.groovy

@@ -8,39 +8,39 @@ import net.i2p.data.Destination
 
 @Log
 class Endpoint implements Closeable {
-	final Destination destination
-	final InputStream inputStream
-	final OutputStream outputStream
+    final Destination destination
+    final InputStream inputStream
+    final OutputStream outputStream
     final def toClose
-	
-	private final AtomicBoolean closed = new AtomicBoolean()
-	
-	Endpoint(Destination destination, InputStream inputStream, OutputStream outputStream, def toClose) {
-		this.destination = destination
-		this.inputStream = inputStream
-		this.outputStream = outputStream
+
+    private final AtomicBoolean closed = new AtomicBoolean()
+
+    Endpoint(Destination destination, InputStream inputStream, OutputStream outputStream, def toClose) {
+        this.destination = destination
+        this.inputStream = inputStream
+        this.outputStream = outputStream
         this.toClose = toClose
-	}
-	
-	@Override
-	public void close() {
-		if (!closed.compareAndSet(false, true)) {
-			log.log(Level.WARNING,"Close loop detected for ${destination.toBase32()}", new Exception())
-			return
-		}
-		if (inputStream != null) {
-			try {inputStream.close()} catch (Exception ignore) {}
-		}
-		if (outputStream != null) {
-			try {outputStream.close()} catch (Exception ignore) {}
-		}
+    }
+
+    @Override
+    public void close() {
+        if (!closed.compareAndSet(false, true)) {
+            log.log(Level.WARNING,"Close loop detected for ${destination.toBase32()}", new Exception())
+            return
+        }
+        if (inputStream != null) {
+            try {inputStream.close()} catch (Exception ignore) {}
+        }
+        if (outputStream != null) {
+            try {outputStream.close()} catch (Exception ignore) {}
+        }
         if (toClose != null) {
             try {toClose.reset()} catch (Exception ignore) {}
         }
-	}
-	
-	@Override
-	public String toString() {
-		"destination: ${destination.toBase32()}"
-	}
-} 
+    }
+
+    @Override
+    public String toString() {
+        "destination: ${destination.toBase32()}"
+    }
+}

core/src/main/groovy/com/muwire/core/connection/I2PAcceptor.groovy

@@ -5,18 +5,18 @@ import net.i2p.client.streaming.I2PSocketManager
 
 class I2PAcceptor {
 
-	final I2PSocketManager socketManager
-	final I2PServerSocket serverSocket
-	
-	I2PAcceptor() {}
-	
-	I2PAcceptor(I2PSocketManager socketManager) {
-		this.socketManager = socketManager
-		this.serverSocket = socketManager.getServerSocket()
-	}
-	
-	Endpoint accept() {
-		def socket = serverSocket.accept()
-		new Endpoint(socket.getPeerDestination(), socket.getInputStream(), socket.getOutputStream(), socket)
-	}
+    final I2PSocketManager socketManager
+    final I2PServerSocket serverSocket
+
+    I2PAcceptor() {}
+
+    I2PAcceptor(I2PSocketManager socketManager) {
+        this.socketManager = socketManager
+        this.serverSocket = socketManager.getServerSocket()
+    }
+
+    Endpoint accept() {
+        def socket = serverSocket.accept()
+        new Endpoint(socket.getPeerDestination(), socket.getInputStream(), socket.getOutputStream(), socket)
+    }
 }

core/src/main/groovy/com/muwire/core/connection/I2PConnector.groovy

@@ -4,18 +4,18 @@ import net.i2p.client.streaming.I2PSocketManager
 import net.i2p.data.Destination
 
 class I2PConnector {
-	
-	final I2PSocketManager socketManager
-	
-	I2PConnector() {}
-	
-	I2PConnector(I2PSocketManager socketManager) {
-		this.socketManager = socketManager
-	}
-	
-	Endpoint connect(Destination dest) {
-		def socket = socketManager.connect(dest)
-		new Endpoint(dest, socket.getInputStream(), socket.getOutputStream(), socket)
-	}
+
+    final I2PSocketManager socketManager
+
+    I2PConnector() {}
+
+    I2PConnector(I2PSocketManager socketManager) {
+        this.socketManager = socketManager
+    }
+
+    Endpoint connect(Destination dest) {
+        def socket = socketManager.connect(dest)
+        new Endpoint(dest, socket.getInputStream(), socket.getOutputStream(), socket)
+    }
 
 }

core/src/main/groovy/com/muwire/core/connection/LeafConnection.groovy

@@ -11,27 +11,27 @@ import com.muwire.core.trust.TrustService
 import net.i2p.data.Destination
 
 /**
- * Connection where the other side is a leaf. 
+ * Connection where the other side is a leaf.
  * Such connections can only be incoming.
  * @author zab
  */
 class LeafConnection extends Connection {
 
-	public LeafConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache, 
+    public LeafConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache,
         TrustService trustService, MuWireSettings settings) {
-		super(eventBus, endpoint, true, hostCache, trustService, settings);
-	}
+        super(eventBus, endpoint, true, hostCache, trustService, settings);
+    }
 
-	@Override
-	protected void read() {
-		// TODO Auto-generated method stub
-		
-	}
+    @Override
+    protected void read() {
+        // TODO Auto-generated method stub
 
-	@Override
-	protected void write(Object message) {
-		// TODO Auto-generated method stub
-		
-	}
+    }
+
+    @Override
+    protected void write(Object message) {
+        // TODO Auto-generated method stub
+
+    }
 
 }

core/src/main/groovy/com/muwire/core/connection/LeafConnectionManager.groovy

@@ -13,68 +13,68 @@ import net.i2p.data.Destination
 
 @Log
 class LeafConnectionManager extends ConnectionManager {
-	
-	final int maxConnections
-	
-	final Map<Destination, UltrapeerConnection> connections = new ConcurrentHashMap()
-	
-	public LeafConnectionManager(EventBus eventBus, Persona me, int maxConnections, 
+
+    final int maxConnections
+
+    final Map<Destination, UltrapeerConnection> connections = new ConcurrentHashMap()
+
+    public LeafConnectionManager(EventBus eventBus, Persona me, int maxConnections,
         HostCache hostCache, MuWireSettings settings) {
-		super(eventBus, me, hostCache, settings)
-		this.maxConnections = maxConnections
-	}
-	
-	@Override
-	public void drop(Destination d) {
-		// TODO Auto-generated method stub
-		
-	}
-    
+        super(eventBus, me, hostCache, settings)
+        this.maxConnections = maxConnections
+    }
+
+    @Override
+    public void drop(Destination d) {
+        // TODO Auto-generated method stub
+
+    }
+
     void onQueryEvent(QueryEvent e) {
         if (me.destination == e.receivedOn) {
             connections.values().each { it.sendQuery(e) }
         }
-            
+
     }
 
-	@Override
-	public Collection<Connection> getConnections() {
-		connections.values()
-	}
+    @Override
+    public Collection<Connection> getConnections() {
+        connections.values()
+    }
 
-	@Override
-	protected int getDesiredConnections() {
-		return maxConnections;
-	}
+    @Override
+    protected int getDesiredConnections() {
+        return maxConnections;
+    }
 
-	@Override
-	public boolean isConnected(Destination d) {
-		connections.containsKey(d)
-	}
+    @Override
+    public boolean isConnected(Destination d) {
+        connections.containsKey(d)
+    }
+
+    @Override
+    public void onConnectionEvent(ConnectionEvent e) {
+        if (e.incoming || e.leaf) {
+            log.severe("Got inconsistent event as a leaf! $e")
+            return
+        }
+        if (e.status != ConnectionAttemptStatus.SUCCESSFUL)
+            return
+
+        Connection c = new UltrapeerConnection(eventBus, e.endpoint)
+        connections.put(e.endpoint.destination, c)
+        c.start()
+    }
+
+    @Override
+    public void onDisconnectionEvent(DisconnectionEvent e) {
+        def removed = connections.remove(e.destination)
+        if (removed == null)
+            log.severe("removed destination not present in connection manager ${e.destination.toBase32()}")
+    }
 
-	@Override
-	public void onConnectionEvent(ConnectionEvent e) {
-		if (e.incoming || e.leaf) {
-			log.severe("Got inconsistent event as a leaf! $e")
-			return
-		}
-		if (e.status != ConnectionAttemptStatus.SUCCESSFUL)
-			return
-			
-		Connection c = new UltrapeerConnection(eventBus, e.endpoint)
-		connections.put(e.endpoint.destination, c)
-		c.start()
-	}
-	
-	@Override 
-	public void onDisconnectionEvent(DisconnectionEvent e) {
-		def removed = connections.remove(e.destination)
-		if (removed == null)
-			log.severe("removed destination not present in connection manager ${e.destination.toBase32()}")
-	}
-	
     @Override
     void shutdown() {
-        
+
     }
 }

core/src/main/groovy/com/muwire/core/connection/PeerConnection.groovy

@@ -20,63 +20,63 @@ import net.i2p.data.Destination
  */
 @Log
 class PeerConnection extends Connection {
-	
-	private final DataInputStream dis
-	private final DataOutputStream dos
-	
-	private final byte[] readHeader = new byte[3]
-	private final byte[] writeHeader = new byte[3]
-	
-	private final JsonSlurper slurper = new JsonSlurper()
 
-	public PeerConnection(EventBus eventBus, Endpoint endpoint,
-			boolean incoming, HostCache hostCache, TrustService trustService,
+    private final DataInputStream dis
+    private final DataOutputStream dos
+
+    private final byte[] readHeader = new byte[3]
+    private final byte[] writeHeader = new byte[3]
+
+    private final JsonSlurper slurper = new JsonSlurper()
+
+    public PeerConnection(EventBus eventBus, Endpoint endpoint,
+            boolean incoming, HostCache hostCache, TrustService trustService,
             MuWireSettings settings) {
-		super(eventBus, endpoint, incoming, hostCache, trustService, settings)
-		this.dis = new DataInputStream(endpoint.inputStream)
-		this.dos = new DataOutputStream(endpoint.outputStream)
-	}
+        super(eventBus, endpoint, incoming, hostCache, trustService, settings)
+        this.dis = new DataInputStream(endpoint.inputStream)
+        this.dos = new DataOutputStream(endpoint.outputStream)
+    }
 
-	@Override
-	protected void read() {
-		dis.readFully(readHeader)
-		int length = DataUtil.readLength(readHeader)
-		log.fine("$name read length $length")
-		
-		byte[] payload = new byte[length]
-		dis.readFully(payload)
-		
-		if ((readHeader[0] & (byte)0x80) == 0x80) {
-			// TODO process binary
-		} else {
-			def json = slurper.parse(payload)
-			if (json.type == null)
-				throw new Exception("missing json type")
-			switch(json.type) {
-				case "Ping" : handlePing(); break;
-				case "Pong" : handlePong(json); break;
+    @Override
+    protected void read() {
+        dis.readFully(readHeader)
+        int length = DataUtil.readLength(readHeader)
+        log.fine("$name read length $length")
+
+        byte[] payload = new byte[length]
+        dis.readFully(payload)
+
+        if ((readHeader[0] & (byte)0x80) == 0x80) {
+            // TODO process binary
+        } else {
+            def json = slurper.parse(payload)
+            if (json.type == null)
+                throw new Exception("missing json type")
+            switch(json.type) {
+                case "Ping" : handlePing(); break;
+                case "Pong" : handlePong(json); break;
                 case "Search": handleSearch(json); break
-				default :
-					throw new Exception("unknown json type ${json.type}")
-			}
-		}
-	}
+                default :
+                    throw new Exception("unknown json type ${json.type}")
+            }
+        }
+    }
 
-	@Override
-	protected void write(Object message) {
-		byte[] payload
-		if (message instanceof Map) {
-			payload = JsonOutput.toJson(message).bytes
-			DataUtil.packHeader(payload.length, writeHeader)
-			log.fine "$name writing message type ${message.type} length $payload.length"
-			writeHeader[0] &= (byte)0x7F
-		} else {
-			// TODO: write binary
-		}
-		
-		dos.write(writeHeader)
-		dos.write(payload)
-		dos.flush()
-	}
+    @Override
+    protected void write(Object message) {
+        byte[] payload
+        if (message instanceof Map) {
+            payload = JsonOutput.toJson(message).bytes
+            DataUtil.packHeader(payload.length, writeHeader)
+            log.fine "$name writing message type ${message.type} length $payload.length"
+            writeHeader[0] &= (byte)0x7F
+        } else {
+            // TODO: write binary
+        }
+
+        dos.write(writeHeader)
+        dos.write(payload)
+        dos.flush()
+    }
 
 }

core/src/main/groovy/com/muwire/core/connection/UltrapeerConnection.groovy

@@ -17,30 +17,30 @@ import net.i2p.data.Destination
  */
 class UltrapeerConnection extends Connection {
 
-	public UltrapeerConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache, TrustService trustService) {
-		super(eventBus, endpoint, false, hostCache, trustService)
-	}
+    public UltrapeerConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache, TrustService trustService) {
+        super(eventBus, endpoint, false, hostCache, trustService)
+    }
 
-	@Override
-	protected void read() {
-		// TODO Auto-generated method stub
-		
-	}
+    @Override
+    protected void read() {
+        // TODO Auto-generated method stub
 
-	@Override
-	protected void write(Object message) {
-		if (message instanceof Map) {
-			writeJsonMessage(message)
-		} else {
-			writeBinaryMessage(message)
-		}
-	}
+    }
 
-	private void writeJsonMessage(def message) {
-		
-	}
-	
-	private void writeBinaryMessage(def message) {
-		
-	}
+    @Override
+    protected void write(Object message) {
+        if (message instanceof Map) {
+            writeJsonMessage(message)
+        } else {
+            writeBinaryMessage(message)
+        }
+    }
+
+    private void writeJsonMessage(def message) {
+
+    }
+
+    private void writeBinaryMessage(def message) {
+
+    }
 }

core/src/main/groovy/com/muwire/core/connection/UltrapeerConnectionManager.groovy

@@ -15,28 +15,28 @@ import net.i2p.data.Destination
 
 @Log
 class UltrapeerConnectionManager extends ConnectionManager {
-	
-	final int maxPeers, maxLeafs
-    final TrustService trustService
-    
-	final Map<Destination, PeerConnection> peerConnections = new ConcurrentHashMap()
-	final Map<Destination, LeafConnection> leafConnections = new ConcurrentHashMap()
-    
-	UltrapeerConnectionManager() {}
 
-	public UltrapeerConnectionManager(EventBus eventBus, Persona me, int maxPeers, int maxLeafs, 
+    final int maxPeers, maxLeafs
+    final TrustService trustService
+
+    final Map<Destination, PeerConnection> peerConnections = new ConcurrentHashMap()
+    final Map<Destination, LeafConnection> leafConnections = new ConcurrentHashMap()
+
+    UltrapeerConnectionManager() {}
+
+    public UltrapeerConnectionManager(EventBus eventBus, Persona me, int maxPeers, int maxLeafs,
         HostCache hostCache, TrustService trustService, MuWireSettings settings) {
-		super(eventBus, me, hostCache, settings)
-		this.maxPeers = maxPeers
-		this.maxLeafs = maxLeafs
+        super(eventBus, me, hostCache, settings)
+        this.maxPeers = maxPeers
+        this.maxLeafs = maxLeafs
         this.trustService = trustService
-	}
-	@Override
-	public void drop(Destination d) {
-		peerConnections.get(d)?.close()
+    }
+    @Override
+    public void drop(Destination d) {
+        peerConnections.get(d)?.close()
         leafConnections.get(d)?.close()
-	}
-    
+    }
+
     void onQueryEvent(QueryEvent e) {
         forwardQueryToLeafs(e)
         if (!e.firstHop)
@@ -50,58 +50,58 @@ class UltrapeerConnectionManager extends ConnectionManager {
         }
     }
 
-	@Override
-	public Collection<Connection> getConnections() {
-		def rv = new ArrayList(peerConnections.size() + leafConnections.size())
-		rv.addAll(peerConnections.values())
-		rv.addAll(leafConnections.values())
-		rv
-	}
-	
-	boolean hasLeafSlots() {
-		leafConnections.size() < maxLeafs
-	}
-	
-	boolean hasPeerSlots() {
-		peerConnections.size() < maxPeers
-	}
-	
-	@Override
-	protected int getDesiredConnections() {
-		return maxPeers / 2;
-	}
-	@Override
-	public boolean isConnected(Destination d) {
-		peerConnections.containsKey(d) || leafConnections.containsKey(d)
-	}
+    @Override
+    public Collection<Connection> getConnections() {
+        def rv = new ArrayList(peerConnections.size() + leafConnections.size())
+        rv.addAll(peerConnections.values())
+        rv.addAll(leafConnections.values())
+        rv
+    }
+
+    boolean hasLeafSlots() {
+        leafConnections.size() < maxLeafs
+    }
+
+    boolean hasPeerSlots() {
+        peerConnections.size() < maxPeers
+    }
+
+    @Override
+    protected int getDesiredConnections() {
+        return maxPeers / 2;
+    }
+    @Override
+    public boolean isConnected(Destination d) {
+        peerConnections.containsKey(d) || leafConnections.containsKey(d)
+    }
+
+    @Override
+    public void onConnectionEvent(ConnectionEvent e) {
+        if (!e.incoming && e.leaf) {
+            log.severe("Inconsistent event $e")
+            return
+        }
+
+        if (e.status != ConnectionAttemptStatus.SUCCESSFUL)
+            return
+
+        Connection c = e.leaf ?
+            new LeafConnection(eventBus, e.endpoint, hostCache, trustService, settings) :
+            new PeerConnection(eventBus, e.endpoint, e.incoming, hostCache, trustService, settings)
+        def map = e.leaf ? leafConnections : peerConnections
+        map.put(e.endpoint.destination, c)
+        c.start()
+    }
+
+    @Override
+    public void onDisconnectionEvent(DisconnectionEvent e) {
+        def removed = peerConnections.remove(e.destination)
+        if (removed == null)
+            removed = leafConnections.remove(e.destination)
+        if (removed == null)
+            log.severe("Removed connection not present in either leaf or peer map ${e.destination.toBase32()}")
+    }
 
-	@Override
-	public void onConnectionEvent(ConnectionEvent e) {
-		if (!e.incoming && e.leaf) {
-			log.severe("Inconsistent event $e")
-			return
-		}
-		
-		if (e.status != ConnectionAttemptStatus.SUCCESSFUL)
-			return
-		
-		Connection c = e.leaf ? 
-			new LeafConnection(eventBus, e.endpoint, hostCache, trustService, settings) : 
-			new PeerConnection(eventBus, e.endpoint, e.incoming, hostCache, trustService, settings)
-		def map = e.leaf ? leafConnections : peerConnections
-		map.put(e.endpoint.destination, c)
-		c.start()
-	}
-	
-	@Override
-	public void onDisconnectionEvent(DisconnectionEvent e) {
-		def removed = peerConnections.remove(e.destination)
-		if (removed == null)
-			removed = leafConnections.remove(e.destination)
-		if (removed == null)
-			log.severe("Removed connection not present in either leaf or peer map ${e.destination.toBase32()}")
-	}
-    
     @Override
     void shutdown() {
         peerConnections.values().stream().parallel().forEach({v -> v.close()})
@@ -109,8 +109,8 @@ class UltrapeerConnectionManager extends ConnectionManager {
         peerConnections.clear()
         leafConnections.clear()
     }
-	
-	void forwardQueryToLeafs(QueryEvent e) {
-		
-	}
+
+    void forwardQueryToLeafs(QueryEvent e) {
+
+    }
 }

core/src/main/groovy/com/muwire/core/content/ContentControlEvent.groovy

@@ -0,0 +1,9 @@
+package com.muwire.core.content
+
+import com.muwire.core.Event
+
+class ContentControlEvent extends Event {
+    String term
+    boolean regex
+    boolean add
+}

core/src/main/groovy/com/muwire/core/content/ContentManager.groovy

@@ -0,0 +1,30 @@
+package com.muwire.core.content
+
+import java.util.concurrent.ConcurrentHashMap
+
+import com.muwire.core.search.QueryEvent
+
+import net.i2p.util.ConcurrentHashSet
+
+class ContentManager {
+
+    Set<Matcher> matchers = new ConcurrentHashSet()    
+    
+    void onContentControlEvent(ContentControlEvent e) {
+        Matcher m
+        if (e.regex)
+            m = new RegexMatcher(e.term)
+        else
+            m = new KeywordMatcher(e.term)
+        if (e.add)
+            matchers.add(m)
+        else
+            matchers.remove(m)
+    }
+    
+    void onQueryEvent(QueryEvent e) {
+        if (e.searchEvent.searchTerms == null)
+            return
+        matchers.each { it.process(e) }
+    }
+}

core/src/main/groovy/com/muwire/core/content/KeywordMatcher.groovy

@@ -0,0 +1,36 @@
+package com.muwire.core.content
+
+class KeywordMatcher extends Matcher {
+    private final String keyword
+    KeywordMatcher(String keyword) {
+        this.keyword = keyword
+    }
+    
+    @Override
+    protected boolean match(List<String> searchTerms) {
+        boolean found = false
+        searchTerms.each { 
+            if (keyword == it)
+                found = true
+        }
+        found
+    }
+    
+    @Override
+    public String getTerm() {
+        keyword
+    }
+    
+    @Override
+    public int hashCode() {
+        keyword.hashCode()
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof KeywordMatcher))
+            return false
+        KeywordMatcher other = (KeywordMatcher) o
+        keyword.equals(other.keyword)
+    }
+}

core/src/main/groovy/com/muwire/core/content/Match.groovy

@@ -0,0 +1,9 @@
+package com.muwire.core.content
+
+import com.muwire.core.Persona
+
+class Match {
+    Persona persona
+    String [] keywords
+    long timestamp
+}

core/src/main/groovy/com/muwire/core/content/Matcher.groovy

@@ -0,0 +1,20 @@
+package com.muwire.core.content
+
+import com.muwire.core.search.QueryEvent
+
+abstract class Matcher {
+    final List<Match> matches = Collections.synchronizedList(new ArrayList<>())
+    final Set<UUID> uuids = new HashSet<>()
+    
+    protected abstract boolean match(List<String> searchTerms);
+    
+    public abstract String getTerm();
+    
+    public void process(QueryEvent qe) {
+        def terms = qe.searchEvent.searchTerms
+        if (match(terms) && uuids.add(qe.searchEvent.uuid)) {
+            long now = System.currentTimeMillis()
+            matches << new Match(persona : qe.originator, keywords : terms, timestamp : now)
+        }
+    }
+}

core/src/main/groovy/com/muwire/core/content/RegexMatcher.groovy

@@ -0,0 +1,35 @@
+package com.muwire.core.content
+
+import java.util.regex.Pattern
+import java.util.stream.Collectors
+
+class RegexMatcher extends Matcher {
+    private final Pattern pattern
+    RegexMatcher(String pattern) {
+        this.pattern = Pattern.compile(pattern)
+    }
+    
+    @Override
+    protected boolean match(List<String> keywords) {
+        String combined = keywords.join(" ")
+        return pattern.matcher(combined).find()
+    }
+    
+    @Override
+    public String getTerm() {
+        pattern.pattern()
+    }
+    
+    @Override
+    public int hashCode() {
+        pattern.pattern().hashCode()
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof RegexMatcher))
+            return false
+        RegexMatcher other = (RegexMatcher) o
+        pattern.pattern() == other.pattern.pattern()
+    }
+}

core/src/main/groovy/com/muwire/core/download/BadHashException.groovy

@@ -21,5 +21,5 @@ class BadHashException extends Exception {
     public BadHashException(Throwable cause) {
         super(cause);
     }
-    
+
 }

core/src/main/groovy/com/muwire/core/download/DownloadManager.groovy

@@ -27,7 +27,7 @@ import java.util.concurrent.Executor
 import java.util.concurrent.Executors
 
 public class DownloadManager {
-    
+
     private final EventBus eventBus
     private final TrustService trustService
     private final MeshManager meshManager
@@ -36,9 +36,9 @@ public class DownloadManager {
     private final Executor executor
     private final File incompletes, home
     private final Persona me
-    
+
     private final Map<InfoHash, Downloader> downloaders = new ConcurrentHashMap<>()
-    
+
     public DownloadManager(EventBus eventBus, TrustService trustService, MeshManager meshManager, MuWireSettings muSettings,
         I2PConnector connector, File home, Persona me) {
         this.eventBus = eventBus
@@ -49,9 +49,9 @@ public class DownloadManager {
         this.incompletes = new File(home,"incompletes")
         this.home = home
         this.me = me
-        
+
         incompletes.mkdir()
-        
+
         this.executor = Executors.newCachedThreadPool({ r ->
             Thread rv = new Thread(r)
             rv.setName("download-worker")
@@ -59,23 +59,23 @@ public class DownloadManager {
             rv
         })
     }
-    
-    
+
+
     public void onUIDownloadEvent(UIDownloadEvent e) {
-        
+
         def size = e.result[0].size
         def infohash = e.result[0].infohash
         def pieceSize = e.result[0].pieceSize
-        
+
         Set<Destination> destinations = new HashSet<>()
-        e.result.each { 
+        e.result.each {
             destinations.add(it.sender.destination)
         }
         destinations.addAll(e.sources)
         destinations.remove(me.destination)
-        
+
         Pieces pieces = getPieces(infohash, size, pieceSize)
-        
+
         def downloader = new Downloader(eventBus, this, me, e.target, size,
             infohash, pieceSize, connector, destinations,
             incompletes, pieces)
@@ -84,24 +84,24 @@ public class DownloadManager {
         executor.execute({downloader.download()} as Runnable)
         eventBus.publish(new DownloadStartedEvent(downloader : downloader))
     }
-    
+
     public void onUIDownloadCancelledEvent(UIDownloadCancelledEvent e) {
         downloaders.remove(e.downloader.infoHash)
         persistDownloaders()
     }
-    
+
     public void onUIDownloadPausedEvent(UIDownloadPausedEvent e) {
         persistDownloaders()
     }
-    
+
     public void onUIDownloadResumedEvent(UIDownloadResumedEvent e) {
         persistDownloaders()
     }
-    
+
     void resume(Downloader downloader) {
         executor.execute({downloader.download() as Runnable})
     }
-    
+
     void onUILoadedEvent(UILoadedEvent e) {
         File downloadsFile = new File(home, "downloads.json")
         if (!downloadsFile.exists())
@@ -111,7 +111,7 @@ public class DownloadManager {
             def json = slurper.parseText(it)
             File file = new File(DataUtil.readi18nString(Base64.decode(json.file)))
             def destinations = new HashSet<>()
-            json.destinations.each { destination -> 
+            json.destinations.each { destination ->
                 destinations.add new Destination(destination)
             }
             InfoHash infoHash
@@ -122,9 +122,9 @@ public class DownloadManager {
                 byte [] root = Base64.decode(json.hashRoot)
                 infoHash = new InfoHash(root)
             }
-            
+
             Pieces pieces = getPieces(infoHash, (long)json.length, json.pieceSizePow2)
-            
+
             def downloader = new Downloader(eventBus, this, me, file, (long)json.length,
                 infoHash, json.pieceSizePow2, connector, destinations, incompletes, pieces)
             if (json.paused != null)
@@ -136,7 +136,7 @@ public class DownloadManager {
             eventBus.publish(new DownloadStartedEvent(downloader : downloader))
         }
     }
-    
+
     private Pieces getPieces(InfoHash infoHash, long length, int pieceSizePow2) {
         int pieceSize = 0x1 << pieceSizePow2
         int nPieces = (int)(length / pieceSize)
@@ -145,7 +145,7 @@ public class DownloadManager {
         Mesh mesh = meshManager.getOrCreate(infoHash, nPieces)
         mesh.pieces
     }
-    
+
     void onSourceDiscoveredEvent(SourceDiscoveredEvent e) {
         Downloader downloader = downloaders.get(e.infoHash)
         if (downloader == null)
@@ -156,19 +156,19 @@ public class DownloadManager {
             case TrustLevel.NEUTRAL: ok = muSettings.allowUntrusted; break
             case TrustLevel.DISTRUSTED: ok = false; break
         }
-        
+
         if (ok)
             downloader.addSource(e.source.destination)
     }
-    
+
     void onFileDownloadedEvent(FileDownloadedEvent e) {
         downloaders.remove(e.downloader.infoHash)
         persistDownloaders()
     }
-    
+
     private void persistDownloaders() {
         File downloadsFile = new File(home,"downloads.json")
-        downloadsFile.withPrintWriter { writer -> 
+        downloadsFile.withPrintWriter { writer ->
             downloaders.values().each { downloader ->
                 if (!downloader.cancelled) {
                     def json = [:]
@@ -180,20 +180,20 @@ public class DownloadManager {
                         destinations << it.toBase64()
                     }
                     json.destinations = destinations
-                    
+
                     InfoHash infoHash = downloader.getInfoHash()
                     if (infoHash.hashList != null)
                         json.hashList = Base64.encode(infoHash.hashList)
                     else
                         json.hashRoot = Base64.encode(infoHash.getRoot())
-                        
+
                     json.paused = downloader.paused
                     writer.println(JsonOutput.toJson(json))
                 }
             }
         }
     }
-    
+
     public void shutdown() {
         downloaders.values().each { it.stop() }
         Downloader.executorService.shutdownNow()

core/src/main/groovy/com/muwire/core/download/DownloadSession.groovy

@@ -14,6 +14,7 @@ import static com.muwire.core.util.DataUtil.readTillRN
 import groovy.util.logging.Log
 
 import java.nio.ByteBuffer
+import java.nio.MappedByteBuffer
 import java.nio.channels.FileChannel
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
@@ -24,7 +25,7 @@ import java.util.logging.Level
 
 @Log
 class DownloadSession {
-    
+
     private final EventBus eventBus
     private final String meB64
     private final Pieces pieces
@@ -37,11 +38,11 @@ class DownloadSession {
     private final MessageDigest digest
 
     private long lastSpeedRead = System.currentTimeMillis()
-    private long dataSinceLastRead    
-    
-    private ByteBuffer mapped
-    
-    DownloadSession(EventBus eventBus, String meB64, Pieces pieces, InfoHash infoHash, Endpoint endpoint, File file, 
+    private long dataSinceLastRead
+
+    private MappedByteBuffer mapped
+
+    DownloadSession(EventBus eventBus, String meB64, Pieces pieces, InfoHash infoHash, Endpoint endpoint, File file,
         int pieceSize, long fileLength, Set<Integer> available) {
         this.eventBus = eventBus
         this.meB64 = meB64
@@ -59,7 +60,7 @@ class DownloadSession {
             System.exit(1)
         }
     }
-    
+
     /**
      * @return if the request will proceed.  The only time it may not
      * is if all the pieces have been claimed by other sessions.
@@ -68,44 +69,46 @@ class DownloadSession {
     public boolean request() throws IOException {
         OutputStream os = endpoint.getOutputStream()
         InputStream is = endpoint.getInputStream()
-        
-        int piece
+
+        int[] pieceAndPosition
         if (available.isEmpty())
-            piece = pieces.claim()
+            pieceAndPosition = pieces.claim()
         else
-            piece = pieces.claim(new HashSet<>(available))
-        if (piece == -1)
+            pieceAndPosition = pieces.claim(new HashSet<>(available))
+        if (pieceAndPosition == null)
             return false
+        int piece = pieceAndPosition[0]
+        int position = pieceAndPosition[1]
+        boolean steal = pieceAndPosition[2] == 1
         boolean unclaim = true
-            
-        log.info("will download piece $piece")
-        
-        long start = piece * pieceSize
-        long end = Math.min(fileLength, start + pieceSize) - 1
-        long length = end - start + 1
-        
+
+        log.info("will download piece $piece from position $position steal $steal")
+
+        long pieceStart = piece * ((long)pieceSize)
+        long end = Math.min(fileLength, pieceStart + pieceSize) - 1
+        long start = pieceStart + position
         String root = Base64.encode(infoHash.getRoot())
-                
+
         try {
             os.write("GET $root\r\n".getBytes(StandardCharsets.US_ASCII))
             os.write("Range: $start-$end\r\n".getBytes(StandardCharsets.US_ASCII))
             os.write("X-Persona: $meB64\r\n".getBytes(StandardCharsets.US_ASCII))
             String xHave = DataUtil.encodeXHave(pieces.getDownloaded(), pieces.nPieces)
-            os.write("X-Have: $xHave\r\n\r\n".getBytes(StandardCharsets.US_ASCII)) 
+            os.write("X-Have: $xHave\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
             os.flush()
             String codeString = readTillRN(is)
             int space = codeString.indexOf(' ')
             if (space > 0)
                 codeString = codeString.substring(0, space)
-            
+
             int code = Integer.parseInt(codeString.trim())
-            
+
             if (code == 404) {
                 log.warning("file not found")
                 endpoint.close()
                 return false
             }
-                
+
             if (!(code == 200 || code == 416)) {
                 log.warning("unknown code $code")
                 endpoint.close()
@@ -120,10 +123,10 @@ class DownloadSession {
                 if (colon == -1 || colon == header.length() - 1)
                     throw new IOException("invalid header $header")
                 String key = header.substring(0, colon)
-                String value = header.substring(colon + 1) 
+                String value = header.substring(colon + 1)
                 headers[key] = value.trim()
             }
-            
+
             // prase X-Alt if present
             if (headers.containsKey("X-Alt")) {
                 headers["X-Alt"].split(",").each {
@@ -136,7 +139,7 @@ class DownloadSession {
             }
 
             // parse X-Have if present
-            if (headers.containsKey("X-Have")) { 
+            if (headers.containsKey("X-Have")) {
                 DataUtil.decodeXHave(headers["X-Have"]).each {
                     available.add(it)
                 }
@@ -147,16 +150,16 @@ class DownloadSession {
                     throw new IOException("Code $code but no X-Have")
                 available.clear()
             }
-            
+
             if (code != 200)
                 return true
-            
+
             String range = headers["Content-Range"]
-            if (range == null) 
+            if (range == null)
                 throw new IOException("Code 200 but no Content-Range")
-            
+
             def group = (range =~ /^(\d+)-(\d+)$/)
-            if (group.size() != 1) 
+            if (group.size() != 1)
                 throw new IOException("invalid Content-Range header $range")
 
             long receivedStart = Long.parseLong(group[0][1])
@@ -167,13 +170,14 @@ class DownloadSession {
                 endpoint.close()
                 return false
             }
-            
+
             // start the download
             FileChannel channel
             try {
                 channel = Files.newByteChannel(file.toPath(), EnumSet.of(StandardOpenOption.READ, StandardOpenOption.WRITE,
-                        StandardOpenOption.SPARSE, StandardOpenOption.CREATE)) // TODO: double-check, maybe CREATE_NEW
-                mapped = channel.map(FileChannel.MapMode.READ_WRITE, start, end - start + 1)
+                        StandardOpenOption.SPARSE, StandardOpenOption.CREATE)) 
+                mapped = channel.map(FileChannel.MapMode.READ_WRITE, pieceStart, end - pieceStart + 1)
+                mapped.position(position)
 
                 byte[] tmp = new byte[0x1 << 13]
                 while(mapped.hasRemaining()) {
@@ -185,35 +189,38 @@ class DownloadSession {
                     synchronized(this) {
                         mapped.put(tmp, 0, read)
                         dataSinceLastRead += read
+                        pieces.markPartial(piece, mapped.position())
                     }
                 }
 
                 mapped.clear()
                 digest.update(mapped)
-                DataUtil.tryUnmap(mapped)
                 byte [] hash = digest.digest()
                 byte [] expected = new byte[32]
                 System.arraycopy(infoHash.getHashList(), piece * 32, expected, 0, 32)
-                if (hash != expected)
-                    throw new BadHashException()
+                if (hash != expected) {
+                    pieces.markPartial(piece, 0)
+                    throw new BadHashException("bad hash on piece $piece")
+                }
             } finally {
                 try { channel?.close() } catch (IOException ignore) {}
+                DataUtil.tryUnmap(mapped)
             }
             pieces.markDownloaded(piece)
             unclaim = false
         } finally {
-            if (unclaim)
+            if (unclaim && !steal) 
                 pieces.unclaim(piece)
         }
         return true
     }
-    
+
     synchronized int positionInPiece() {
         if (mapped == null)
             return 0
         mapped.position()
     }
-    
+
     synchronized int speed() {
         final long now = System.currentTimeMillis()
         long interval = Math.max(1000, now - lastSpeedRead)

core/src/main/groovy/com/muwire/core/download/Downloader.groovy

@@ -29,7 +29,7 @@ import net.i2p.util.ConcurrentHashSet
 public class Downloader {
     public enum DownloadState { CONNECTING, HASHLIST, DOWNLOADING, FAILED, CANCELLED, PAUSED, FINISHED }
     private enum WorkerState { CONNECTING, HASHLIST, DOWNLOADING, FINISHED}
-    
+
     private static final ExecutorService executorService = Executors.newCachedThreadPool({r ->
         Thread rv = new Thread(r)
         rv.setName("download worker")
@@ -38,8 +38,8 @@ public class Downloader {
     })
 
     private final EventBus eventBus
-    private final DownloadManager downloadManager 
-    private final Persona me   
+    private final DownloadManager downloadManager
+    private final Persona me
     private final File file
     private final Pieces pieces
     private final long length
@@ -53,8 +53,8 @@ public class Downloader {
     final int pieceSizePow2
     private final Map<Destination, DownloadWorker> activeWorkers = new ConcurrentHashMap<>()
     private final Set<Destination> successfulDestinations = new ConcurrentHashSet<>()
-    
-    
+
+
     private volatile boolean cancelled, paused
     private final AtomicBoolean eventFired = new AtomicBoolean()
     private boolean piecesFileClosed
@@ -64,8 +64,8 @@ public class Downloader {
     private int speedAvg = 0
     private long timestamp = Instant.now().toEpochMilli()
 
-    public Downloader(EventBus eventBus, DownloadManager downloadManager, 
-        Persona me, File file, long length, InfoHash infoHash, 
+    public Downloader(EventBus eventBus, DownloadManager downloadManager,
+        Persona me, File file, long length, InfoHash infoHash,
         int pieceSizePow2, I2PConnector connector, Set<Destination> destinations,
         File incompletes, Pieces pieces) {
         this.eventBus = eventBus
@@ -87,15 +87,15 @@ public class Downloader {
         // it's easily adjustable by resizing the size of speedArr
         this.speedArr = [ 0, 0, 0, 0, 0 ]
     }
-    
+
     public synchronized InfoHash getInfoHash() {
         infoHash
     }
-    
+
     private synchronized void setInfoHash(InfoHash infoHash) {
         this.infoHash = infoHash
     }
-    
+
     void download() {
         readPieces()
         destinations.each {
@@ -106,33 +106,37 @@ public class Downloader {
             }
         }
     }
-    
+
     void readPieces() {
         if (!piecesFile.exists())
             return
-        piecesFile.eachLine { 
-            int piece = Integer.parseInt(it)
-            pieces.markDownloaded(piece)
+        piecesFile.eachLine {
+            String [] split = it.split(",")
+            int piece = Integer.parseInt(split[0])
+            if (split.length == 1)
+                pieces.markDownloaded(piece)
+            else {
+                int position = Integer.parseInt(split[1])
+                pieces.markPartial(piece, position)
+            }
         }
     }
-    
+
     void writePieces() {
         synchronized(piecesFile) {
             if (piecesFileClosed)
                 return
             piecesFile.withPrintWriter { writer ->
-                pieces.getDownloaded().each { piece ->
-                    writer.println(piece)
-                }
+                pieces.write(writer)
             }
         }
     }
-    
+
     public long donePieces() {
         pieces.donePieces()
     }
-    
-    
+
+
     public int speed() {
         int currSpeed = 0
         if (getCurrentState() == DownloadState.DOWNLOADING) {
@@ -164,15 +168,15 @@ public class Downloader {
 
         speedAvg
     }
-    
+
     public DownloadState getCurrentState() {
         if (cancelled)
             return DownloadState.CANCELLED
         if (paused)
             return DownloadState.PAUSED
-            
+
         boolean allFinished = true
-        activeWorkers.values().each { 
+        activeWorkers.values().each {
             allFinished &= it.currentState == WorkerState.FINISHED
         }
         if (allFinished) {
@@ -180,22 +184,22 @@ public class Downloader {
                 return DownloadState.FINISHED
             return DownloadState.FAILED
         }
-        
+
         // if at least one is downloading...
         boolean oneDownloading = false
-        activeWorkers.values().each { 
+        activeWorkers.values().each {
             if (it.currentState == WorkerState.DOWNLOADING) {
                 oneDownloading = true
-                return 
+                return
             }
         }
-        
+
         if (oneDownloading)
             return DownloadState.DOWNLOADING
-        
+
         // at least one is requesting hashlist
         boolean oneHashlist = false
-        activeWorkers.values().each { 
+        activeWorkers.values().each {
             if (it.currentState == WorkerState.HASHLIST) {
                 oneHashlist = true
                 return
@@ -203,10 +207,10 @@ public class Downloader {
         }
         if (oneHashlist)
             return DownloadState.HASHLIST
-            
+
         return DownloadState.CONNECTING
     }
-    
+
     public void cancel() {
         cancelled = true
         stop()
@@ -217,27 +221,27 @@ public class Downloader {
         incompleteFile.delete()
         pieces.clearAll()
     }
-    
+
     public void pause() {
         paused = true
         stop()
     }
-    
+
     void stop() {
-        activeWorkers.values().each { 
+        activeWorkers.values().each {
             it.cancel()
         }
     }
-    
+
     public int activeWorkers() {
         int active = 0
-        activeWorkers.values().each { 
+        activeWorkers.values().each {
             if (it.currentState != WorkerState.FINISHED)
                 active++
         }
         active
     }
-    
+
     public void resume() {
         paused = false
         readPieces()
@@ -256,7 +260,7 @@ public class Downloader {
             }
         }
     }
-    
+
     void addSource(Destination d) {
         if (activeWorkers.containsKey(d))
             return
@@ -264,7 +268,7 @@ public class Downloader {
         activeWorkers.put(d, newWorker)
         executorService.submit(newWorker)
     }
-    
+
     class DownloadWorker implements Runnable {
         private final Destination destination
         private volatile WorkerState currentState
@@ -272,11 +276,11 @@ public class Downloader {
         private Endpoint endpoint
         private volatile DownloadSession currentSession
         private final Set<Integer> available = new HashSet<>()
-                
+
         DownloadWorker(Destination destination) {
             this.destination = destination
         }
-        
+
         public void run() {
             downloadThread = Thread.currentThread()
             currentState = WorkerState.CONNECTING
@@ -292,7 +296,7 @@ public class Downloader {
                 currentState = WorkerState.DOWNLOADING
                 boolean requestPerformed
                 while(!pieces.isComplete()) {
-                    currentSession = new DownloadSession(eventBus, me.toBase64(), pieces, getInfoHash(), 
+                    currentSession = new DownloadSession(eventBus, me.toBase64(), pieces, getInfoHash(),
                         endpoint, incompleteFile, pieceSize, length, available)
                     requestPerformed = currentSession.request()
                     if (!requestPerformed)
@@ -303,12 +307,17 @@ public class Downloader {
             } catch (Exception bad) {
                 log.log(Level.WARNING,"Exception while downloading",DataUtil.findRoot(bad))
             } finally {
+                writePieces()
                 currentState = WorkerState.FINISHED
                 if (pieces.isComplete() && eventFired.compareAndSet(false, true)) {
                     synchronized(piecesFile) {
                         piecesFileClosed = true
                         piecesFile.delete()
                     }
+                    activeWorkers.values().each { 
+                        if (it.destination != destination)
+                            it.cancel()
+                    }
                     try {
                         Files.move(incompleteFile.toPath(), file.toPath(), StandardCopyOption.ATOMIC_MOVE)
                     } catch (AtomicMoveNotSupportedException e) {
@@ -319,18 +328,18 @@ public class Downloader {
                         new FileDownloadedEvent(
                             downloadedFile : new DownloadedFile(file, getInfoHash(), pieceSizePow2, successfulDestinations),
                         downloader : Downloader.this))
-                            
-                } 
+
+                }
                 endpoint?.close()
             }
         }
-        
+
         int speed() {
             if (currentSession == null)
                 return 0
             currentSession.speed()
         }
-        
+
         void cancel() {
             downloadThread?.interrupt()
         }

core/src/main/groovy/com/muwire/core/download/HashListSession.groovy

@@ -20,32 +20,32 @@ class HashListSession {
     private final String meB64
     private final InfoHash infoHash
     private final Endpoint endpoint
-    
+
     HashListSession(String meB64, InfoHash infoHash, Endpoint endpoint) {
         this.meB64 = meB64
         this.infoHash = infoHash
         this.endpoint = endpoint
     }
-    
+
     InfoHash request() throws IOException {
         InputStream is = endpoint.getInputStream()
         OutputStream os = endpoint.getOutputStream()
-        
+
         String root = Base64.encode(infoHash.getRoot())
         os.write("HASHLIST $root\r\n".getBytes(StandardCharsets.US_ASCII))
         os.write("X-Persona: $meB64\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
         os.flush()
-        
+
         String code = readTillRN(is)
         if (!code.startsWith("200"))
             throw new IOException("unknown code $code")
-        
+
         // parse all headers
         Set<String> headers = new HashSet<>()
         String header
         while((header = readTillRN(is)) != "" && headers.size() < Constants.MAX_HEADERS)
             headers.add(header)
-            
+
         long receivedStart = -1
         long receivedEnd = -1
         for (String receivedHeader : headers) {
@@ -58,10 +58,10 @@ class HashListSession {
             receivedStart = Long.parseLong(group[0][1])
             receivedEnd = Long.parseLong(group[0][2])
         }
-        
+
         if (receivedStart != 0)
             throw new IOException("hashlist started at $receivedStart")
-        
+
         byte[] hashList = new byte[receivedEnd]
         ByteBuffer hashListBuf = ByteBuffer.wrap(hashList)
         byte[] tmp = new byte[0x1 << 13]
@@ -73,7 +73,7 @@ class HashListSession {
                 throw new IOException()
             hashListBuf.put(tmp, 0, read)
         }
-        
+
         InfoHash received = InfoHash.fromHashList(hashList)
         if (received.getRoot() != infoHash.getRoot())
             throw new IOException("fetched list doesn't match root")

core/src/main/groovy/com/muwire/core/download/Pieces.groovy

@@ -5,51 +5,66 @@ class Pieces {
     private final int nPieces
     private final float ratio
     private final Random random = new Random()
-    
+    private final Map<Integer,Integer> partials = new HashMap<>()
+
     Pieces(int nPieces) {
         this(nPieces, 1.0f)
     }
-    
+
     Pieces(int nPieces, float ratio) {
         this.nPieces = nPieces
         this.ratio = ratio
         done = new BitSet(nPieces)
         claimed = new BitSet(nPieces)
     }
-    
-    synchronized int claim() {
+
+    synchronized int[] claim() {
         int claimedCardinality = claimed.cardinality()
-        if (claimedCardinality == nPieces)
-            return -1
-        
+        if (claimedCardinality == nPieces) {
+            // steal
+            int downloadedCardinality = done.cardinality()
+            if (downloadedCardinality == nPieces)
+                return null
+            int rv = done.nextClearBit(0)
+            return [rv, partials.getOrDefault(rv, 0), 1]
+        }
+
         // if fuller than ratio just do sequential
         if ( (1.0f * claimedCardinality) / nPieces > ratio) {
             int rv = claimed.nextClearBit(0)
             claimed.set(rv)
-            return rv
+            return [rv, partials.getOrDefault(rv, 0), 0]
         }
-        
+
         while(true) {
             int start = random.nextInt(nPieces)
             if (claimed.get(start))
                 continue
             claimed.set(start)
-            return start
+            return [start, partials.getOrDefault(start,0), 0]
         }
     }
-    
-    synchronized int claim(Set<Integer> available) {
-        for (int i = claimed.nextSetBit(0); i >= 0; i = claimed.nextSetBit(i+1))
+
+    synchronized int[] claim(Set<Integer> available) {
+        for (int i = done.nextSetBit(0); i >= 0; i = done.nextSetBit(i+1))
             available.remove(i)
         if (available.isEmpty())
-            return -1
-        List<Integer> toList = available.toList()
+            return null
+        Set<Integer> availableCopy = new HashSet<>(available)
+        for (int i = claimed.nextSetBit(0); i >= 0; i = claimed.nextSetBit(i+1))
+            availableCopy.remove(i)
+        if (availableCopy.isEmpty()) {
+            // steal
+            int rv = available.first()
+            return [rv, partials.getOrDefault(rv, 0), 1]
+        }
+        List<Integer> toList = availableCopy.toList()
         Collections.shuffle(toList)
         int rv = toList[0]
         claimed.set(rv)
-        rv
+        [rv, partials.getOrDefault(rv, 0), 0]
     }
-    
+
     synchronized def getDownloaded() {
         def rv = []
         for (int i = done.nextSetBit(0); i >= 0; i = done.nextSetBit(i+1)) {
@@ -57,30 +72,45 @@ class Pieces {
         }
         rv
     }
-    
+
     synchronized void markDownloaded(int piece) {
         done.set(piece)
         claimed.set(piece)
+        partials.remove(piece)
     }
     
+    synchronized void markPartial(int piece, int position) {
+        partials.put(piece, position)
+    }
+
     synchronized void unclaim(int piece) {
         claimed.clear(piece)
     }
-    
+
     synchronized boolean isComplete() {
         done.cardinality() == nPieces
     }
-    
+
     synchronized int donePieces() {
         done.cardinality()
     }
-    
+
     synchronized boolean isDownloaded(int piece) {
         done.get(piece)
     }
-    
+
     synchronized void clearAll() {
         done.clear()
         claimed.clear()
+        partials.clear()
+    }
+    
+    synchronized void write(PrintWriter writer) {
+        for (int i = done.nextSetBit(0); i >= 0; i = done.nextSetBit(i+1)) {
+            writer.println(i)
+        }
+        partials.each { piece, position ->
+            writer.println("$piece,$position")
+        }
     }
 }

core/src/main/groovy/com/muwire/core/download/UIDownloadEvent.groovy

@@ -6,7 +6,7 @@ import com.muwire.core.search.UIResultEvent
 import net.i2p.data.Destination
 
 class UIDownloadEvent extends Event {
-    
+
     UIResultEvent[] result
     Set<Destination> sources
     File target

core/src/main/groovy/com/muwire/core/files/DirectoryWatcher.groovy

@@ -20,9 +20,9 @@ import net.i2p.util.SystemVersion
 
 @Log
 class DirectoryWatcher {
-    
+
     private static final long WAIT_TIME = 1000
-    
+
     private static final WatchEvent.Kind[] kinds
     static {
         if (SystemVersion.isMac())
@@ -30,7 +30,7 @@ class DirectoryWatcher {
         else
             kinds = [ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE]
     }
-    
+
     private final EventBus eventBus
     private final FileManager fileManager
     private final Thread watcherThread, publisherThread
@@ -38,7 +38,7 @@ class DirectoryWatcher {
     private final Map<File, WatchKey> watchedDirectories = new ConcurrentHashMap<>()
     private WatchService watchService
     private volatile boolean shutdown
-    
+
     DirectoryWatcher(EventBus eventBus, FileManager fileManager) {
         this.eventBus = eventBus
         this.fileManager = fileManager
@@ -47,29 +47,29 @@ class DirectoryWatcher {
         this.publisherThread = new Thread({publish()} as Runnable, "watched-files-publisher")
         publisherThread.setDaemon(true)
     }
-    
+
     void onAllFilesLoadedEvent(AllFilesLoadedEvent e) {
         watchService = FileSystems.getDefault().newWatchService()
         watcherThread.start()
         publisherThread.start()
     }
-    
+
     void stop() {
         shutdown = true
         watcherThread?.interrupt()
         publisherThread?.interrupt()
         watchService?.close()
     }
-    
+
     void onFileSharedEvent(FileSharedEvent e) {
         if (!e.file.isDirectory())
             return
         Path path = e.file.getCanonicalFile().toPath()
         WatchKey wk = path.register(watchService, kinds)
         watchedDirectories.put(e.file, wk)
-        
+
     }
-    
+
     void onDirectoryUnsharedEvent(DirectoryUnsharedEvent e) {
         WatchKey wk = watchedDirectories.remove(e.directory)
         wk?.cancel()
@@ -93,7 +93,7 @@ class DirectoryWatcher {
                 throw e
         }
     }
-    
+
 
     private void processCreated(Path parent, Path path) {
         File f= join(parent, path)
@@ -103,13 +103,13 @@ class DirectoryWatcher {
         else
             waitingFiles.put(f, System.currentTimeMillis())
     }
-        
+
     private void processModified(Path parent, Path path) {
         File f = join(parent, path)
         log.fine("modified entry $f")
         waitingFiles.put(f, System.currentTimeMillis())
     }
-    
+
     private void processDeleted(Path parent, Path path) {
         File f = join(parent, path)
         log.fine("deleted entry $f")
@@ -117,12 +117,12 @@ class DirectoryWatcher {
         if (sf != null)
             eventBus.publish(new FileUnsharedEvent(unsharedFile : sf))
     }
-    
+
     private static File join(Path parent, Path path) {
         File parentFile = parent.toFile().getCanonicalFile()
         new File(parentFile, path.toFile().getName()).getCanonicalFile()
     }
-    
+
     private void publish() {
         try {
             while(!shutdown) {

core/src/main/groovy/com/muwire/core/files/FileDownloadedEvent.groovy

@@ -8,5 +8,5 @@ import net.i2p.data.Destination
 
 class FileDownloadedEvent extends Event {
     Downloader downloader
-	DownloadedFile downloadedFile
+    DownloadedFile downloadedFile
 }

core/src/main/groovy/com/muwire/core/files/FileHashedEvent.groovy

@@ -5,12 +5,12 @@ import com.muwire.core.SharedFile
 
 class FileHashedEvent extends Event {
 
-	SharedFile sharedFile
-	String error
-    
+    SharedFile sharedFile
+    String error
+
     @Override
     public String toString() {
         super.toString() + " sharedFile " + sharedFile?.file.getAbsolutePath() + " error: $error"
     }
-    
+
 }

core/src/main/groovy/com/muwire/core/files/FileHasher.groovy

@@ -13,75 +13,75 @@ import java.security.NoSuchAlgorithmException
 
 class FileHasher {
 
-	/** max size of shared file is 128 GB */
-	public static final long MAX_SIZE = 0x1L << 37
-	
-	/**
-	 * @param size of the file to be shared
-	 * @return the size of each piece in power of 2
+    /** max size of shared file is 128 GB */
+    public static final long MAX_SIZE = 0x1L << 37
+
+    /**
+     * @param size of the file to be shared
+     * @return the size of each piece in power of 2
      * piece size is minimum 128 KBytees and maximum 16 MBytes in power of 2 steps (2^17 - 2^24)
      * there can be up to 8192 pieces maximum per file
-	 */
-	static int getPieceSize(long size) {
-		if (size <= 0x1 << 30)
-			return 17
-		
-		for (int i = 31; i <= 37; i++) {
-			if (size <= 0x1L << i) {
-				return i-13
-			}
-		}
-		
-		throw new IllegalArgumentException("File too large $size")
-	}
-	
-	final MessageDigest digest
-	
-	FileHasher() {
-		try {
-			digest = MessageDigest.getInstance("SHA-256")
-		} catch (NoSuchAlgorithmException impossible) {
-			digest = null
-			System.exit(1)
-		}
-	}
-	
-	InfoHash hashFile(File file) {
-		final long length = file.length()
-		final int size = 0x1 << getPieceSize(length)
-		int numPieces = (int) (length / size)
-		if (numPieces * size < length)
-			numPieces++
-			
-		def output = new ByteArrayOutputStream()
-		RandomAccessFile raf = new RandomAccessFile(file, "r")
-		try {
-			MappedByteBuffer buf
-			for (int i = 0; i < numPieces - 1; i++) {
-				buf = raf.getChannel().map(MapMode.READ_ONLY, ((long)size) * i, size)
-				digest.update buf
+     */
+    static int getPieceSize(long size) {
+        if (size <= 0x1 << 30)
+            return 17
+
+        for (int i = 31; i <= 37; i++) {
+            if (size <= 0x1L << i) {
+                return i-13
+            }
+        }
+
+        throw new IllegalArgumentException("File too large $size")
+    }
+
+    final MessageDigest digest
+
+    FileHasher() {
+        try {
+            digest = MessageDigest.getInstance("SHA-256")
+        } catch (NoSuchAlgorithmException impossible) {
+            digest = null
+            System.exit(1)
+        }
+    }
+
+    InfoHash hashFile(File file) {
+        final long length = file.length()
+        final int size = 0x1 << getPieceSize(length)
+        int numPieces = (int) (length / size)
+        if (numPieces * size < length)
+            numPieces++
+
+        def output = new ByteArrayOutputStream()
+        RandomAccessFile raf = new RandomAccessFile(file, "r")
+        try {
+            MappedByteBuffer buf
+            for (int i = 0; i < numPieces - 1; i++) {
+                buf = raf.getChannel().map(MapMode.READ_ONLY, ((long)size) * i, size)
+                digest.update buf
                 DataUtil.tryUnmap(buf)
-				output.write(digest.digest(), 0, 32)
-			}
-			def lastPieceLength = length - (numPieces - 1) * ((long)size)
-			buf = raf.getChannel().map(MapMode.READ_ONLY, length - lastPieceLength, lastPieceLength)
-			digest.update buf
-			output.write(digest.digest(), 0, 32)
-		} finally {
-			raf.close()
-		}
-		
-		byte [] hashList = output.toByteArray()
-		InfoHash.fromHashList(hashList)
-	}
-    
+                output.write(digest.digest(), 0, 32)
+            }
+            def lastPieceLength = length - (numPieces - 1) * ((long)size)
+            buf = raf.getChannel().map(MapMode.READ_ONLY, length - lastPieceLength, lastPieceLength)
+            digest.update buf
+            output.write(digest.digest(), 0, 32)
+        } finally {
+            raf.close()
+        }
+
+        byte [] hashList = output.toByteArray()
+        InfoHash.fromHashList(hashList)
+    }
+
     public static void main(String[] args) {
         if (args.length != 1) {
             println "This utility computes an infohash of a file"
             println "Pass absolute path to a file as an argument"
             System.exit(1)
         }
-        
+
         def file = new File(args[0])
         file = file.getAbsoluteFile()
         def hasher = new FileHasher()

core/src/main/groovy/com/muwire/core/files/FileHashingEvent.groovy

@@ -0,0 +1,15 @@
+package com.muwire.core.files
+
+import com.muwire.core.Event
+import com.muwire.core.SharedFile
+
+class FileHashingEvent extends Event {
+
+    File hashingFile
+
+    @Override
+    public String toString() {
+        super.toString() + " hashingFile " + hashingFile.getAbsolutePath()
+    }
+
+}

core/src/main/groovy/com/muwire/core/files/FileLoadedEvent.groovy

@@ -5,5 +5,5 @@ import com.muwire.core.SharedFile
 
 class FileLoadedEvent extends Event {
 
-	SharedFile loadedFile
+    SharedFile loadedFile
 }

core/src/main/groovy/com/muwire/core/files/FileManager.groovy

@@ -15,129 +15,129 @@ import groovy.util.logging.Log
 class FileManager {
 
 
-	final EventBus eventBus
+    final EventBus eventBus
     final MuWireSettings settings
-	final Map<InfoHash, Set<SharedFile>> rootToFiles = Collections.synchronizedMap(new HashMap<>())
-	final Map<File, SharedFile> fileToSharedFile = Collections.synchronizedMap(new HashMap<>())
-	final Map<String, Set<File>> nameToFiles = new HashMap<>()
-	final SearchIndex index = new SearchIndex()
-	
-	FileManager(EventBus eventBus, MuWireSettings settings) {
+    final Map<InfoHash, Set<SharedFile>> rootToFiles = Collections.synchronizedMap(new HashMap<>())
+    final Map<File, SharedFile> fileToSharedFile = Collections.synchronizedMap(new HashMap<>())
+    final Map<String, Set<File>> nameToFiles = new HashMap<>()
+    final SearchIndex index = new SearchIndex()
+
+    FileManager(EventBus eventBus, MuWireSettings settings) {
         this.settings = settings
-		this.eventBus = eventBus
-	}
-	
+        this.eventBus = eventBus
+    }
+
     void onFileHashedEvent(FileHashedEvent e) {
         if (e.sharedFile != null)
             addToIndex(e.sharedFile)
     }
-	
-	void onFileLoadedEvent(FileLoadedEvent e) {
-		addToIndex(e.loadedFile)
-	}
-	
+
+    void onFileLoadedEvent(FileLoadedEvent e) {
+        addToIndex(e.loadedFile)
+    }
+
     void onFileDownloadedEvent(FileDownloadedEvent e) {
         if (settings.shareDownloadedFiles) {
             addToIndex(e.downloadedFile)
         }
     }
-	
-	private void addToIndex(SharedFile sf) {
+
+    private void addToIndex(SharedFile sf) {
         log.info("Adding shared file " + sf.getFile())
-		InfoHash infoHash = sf.getInfoHash()
-		Set<SharedFile> existing = rootToFiles.get(infoHash)
-		if (existing == null) {
+        InfoHash infoHash = sf.getInfoHash()
+        Set<SharedFile> existing = rootToFiles.get(infoHash)
+        if (existing == null) {
             log.info("adding new root")
-			existing = new HashSet<>()
-			rootToFiles.put(infoHash, existing);
-		}
-		existing.add(sf)
-		fileToSharedFile.put(sf.file, sf)
-		
-		String name = sf.getFile().getName()
-		Set<File> existingFiles = nameToFiles.get(name)
-		if (existingFiles == null) {
-			existingFiles = new HashSet<>()
-			nameToFiles.put(name, existingFiles)
-		}
-		existingFiles.add(sf.getFile())
-		
-		index.add(name)
-	}
-	
-	void onFileUnsharedEvent(FileUnsharedEvent e) {
-		SharedFile sf = e.unsharedFile
-		InfoHash infoHash = sf.getInfoHash()
-		Set<SharedFile> existing = rootToFiles.get(infoHash)
-		if (existing != null) {
-			existing.remove(sf)
-			if (existing.isEmpty()) {
-				rootToFiles.remove(infoHash)
-			}
-		}
-		
-		fileToSharedFile.remove(sf.file)
-		
-		String name = sf.getFile().getName()
-		Set<File> existingFiles = nameToFiles.get(name)
-		if (existingFiles != null) {
-			existingFiles.remove(sf.file)
-			if (existingFiles.isEmpty()) {
-				nameToFiles.remove(name)
-			}
-		}
-		
-		index.remove(name)
-	}
-	
-	Map<File, SharedFile> getSharedFiles() {
+            existing = new HashSet<>()
+            rootToFiles.put(infoHash, existing);
+        }
+        existing.add(sf)
+        fileToSharedFile.put(sf.file, sf)
+
+        String name = sf.getFile().getName()
+        Set<File> existingFiles = nameToFiles.get(name)
+        if (existingFiles == null) {
+            existingFiles = new HashSet<>()
+            nameToFiles.put(name, existingFiles)
+        }
+        existingFiles.add(sf.getFile())
+
+        index.add(name)
+    }
+
+    void onFileUnsharedEvent(FileUnsharedEvent e) {
+        SharedFile sf = e.unsharedFile
+        InfoHash infoHash = sf.getInfoHash()
+        Set<SharedFile> existing = rootToFiles.get(infoHash)
+        if (existing != null) {
+            existing.remove(sf)
+            if (existing.isEmpty()) {
+                rootToFiles.remove(infoHash)
+            }
+        }
+
+        fileToSharedFile.remove(sf.file)
+
+        String name = sf.getFile().getName()
+        Set<File> existingFiles = nameToFiles.get(name)
+        if (existingFiles != null) {
+            existingFiles.remove(sf.file)
+            if (existingFiles.isEmpty()) {
+                nameToFiles.remove(name)
+            }
+        }
+
+        index.remove(name)
+    }
+
+    Map<File, SharedFile> getSharedFiles() {
         synchronized(fileToSharedFile) {
             return new HashMap<>(fileToSharedFile)
         }
-	}
-    
+    }
+
     Set<SharedFile> getSharedFiles(byte []root) {
             return rootToFiles.get(new InfoHash(root))
     }
-	
-	void onSearchEvent(SearchEvent e) {
-		// hash takes precedence
-		ResultsEvent re = null
-		if (e.searchHash != null) {
+
+    void onSearchEvent(SearchEvent e) {
+        // hash takes precedence
+        ResultsEvent re = null
+        if (e.searchHash != null) {
             Set<SharedFile> found
             found = rootToFiles.get new InfoHash(e.searchHash)
             found = filter(found, e.oobInfohash)
-			if (found != null && !found.isEmpty())
-				re = new ResultsEvent(results: found.asList(), uuid: e.uuid, searchEvent: e)
-		} else {
-			def names = index.search e.searchTerms
-			Set<File> files = new HashSet<>()
-			names.each { files.addAll nameToFiles.getOrDefault(it, []) }
-			Set<SharedFile> sharedFiles = new HashSet<>()
-			files.each { sharedFiles.add fileToSharedFile[it] }
+            if (found != null && !found.isEmpty())
+                re = new ResultsEvent(results: found.asList(), uuid: e.uuid, searchEvent: e)
+        } else {
+            def names = index.search e.searchTerms
+            Set<File> files = new HashSet<>()
+            names.each { files.addAll nameToFiles.getOrDefault(it, []) }
+            Set<SharedFile> sharedFiles = new HashSet<>()
+            files.each { sharedFiles.add fileToSharedFile[it] }
             files = filter(sharedFiles, e.oobInfohash)
-			if (!sharedFiles.isEmpty())
-				re = new ResultsEvent(results: sharedFiles.asList(), uuid: e.uuid, searchEvent: e)
-			
-		}
-		
-		if (re != null)
-			eventBus.publish(re)
-	}
-    
+            if (!sharedFiles.isEmpty())
+                re = new ResultsEvent(results: sharedFiles.asList(), uuid: e.uuid, searchEvent: e)
+
+        }
+
+        if (re != null)
+            eventBus.publish(re)
+    }
+
     private static Set<SharedFile> filter(Set<SharedFile> files, boolean oob) {
         if (!oob)
             return files
         Set<SharedFile> rv = new HashSet<>()
-        files.each { 
+        files.each {
             if (it.getPieceSize() != 0)
                 rv.add(it)
         }
         rv
     }
-    
+
     void onDirectoryUnsharedEvent(DirectoryUnsharedEvent e) {
-        e.directory.listFiles().each { 
+        e.directory.listFiles().each {
             if (it.isDirectory())
                 eventBus.publish(new DirectoryUnsharedEvent(directory : it))
             else {

core/src/main/groovy/com/muwire/core/files/FileSharedEvent.groovy

@@ -4,8 +4,8 @@ import com.muwire.core.Event
 
 class FileSharedEvent extends Event {
 
-	File file
-    
+    File file
+
     @Override
     public String toString() {
         return super.toString() + " file: "+file.getAbsolutePath()

core/src/main/groovy/com/muwire/core/files/FileUnsharedEvent.groovy

@@ -4,5 +4,5 @@ import com.muwire.core.Event
 import com.muwire.core.SharedFile
 
 class FileUnsharedEvent extends Event {
-	SharedFile unsharedFile
+    SharedFile unsharedFile
 }

core/src/main/groovy/com/muwire/core/files/HasherService.groovy

@@ -8,40 +8,41 @@ import com.muwire.core.SharedFile
 
 class HasherService {
 
-	final FileHasher hasher
-	final EventBus eventBus
+    final FileHasher hasher
+    final EventBus eventBus
     final FileManager fileManager
-	Executor executor
-	
-	HasherService(FileHasher hasher, EventBus eventBus, FileManager fileManager) {
-		this.hasher = hasher
-		this.eventBus = eventBus
+    Executor executor
+
+    HasherService(FileHasher hasher, EventBus eventBus, FileManager fileManager) {
+        this.hasher = hasher
+        this.eventBus = eventBus
         this.fileManager = fileManager
-	}
-	
-	void start() {
-		executor = Executors.newSingleThreadExecutor()
-	}
-	
-	void onFileSharedEvent(FileSharedEvent evt) {
+    }
+
+    void start() {
+        executor = Executors.newSingleThreadExecutor()
+    }
+
+    void onFileSharedEvent(FileSharedEvent evt) {
         if (fileManager.fileToSharedFile.containsKey(evt.file.getCanonicalFile()))
             return
-		executor.execute( { -> process(evt.file) } as Runnable)
-	}
-	
-	private void process(File f) {
-		f = f.getCanonicalFile()
-		if (f.isDirectory()) {
-			f.listFiles().each {eventBus.publish new FileSharedEvent(file: it) }
-		} else {
-			if (f.length() == 0) {
-				eventBus.publish new FileHashedEvent(error: "Not sharing empty file $f")
-			} else if (f.length() > FileHasher.MAX_SIZE) {
-				eventBus.publish new FileHashedEvent(error: "$f is too large to be shared ${f.length()}")
-			} else {
-				def hash = hasher.hashFile f
-				eventBus.publish new FileHashedEvent(sharedFile: new SharedFile(f, hash, FileHasher.getPieceSize(f.length())))
-			}
-		}
-	}
+        executor.execute( { -> process(evt.file) } as Runnable)
+    }
+
+    private void process(File f) {
+        f = f.getCanonicalFile()
+        if (f.isDirectory()) {
+            f.listFiles().each {eventBus.publish new FileSharedEvent(file: it) }
+        } else {
+            if (f.length() == 0) {
+                eventBus.publish new FileHashedEvent(error: "Not sharing empty file $f")
+            } else if (f.length() > FileHasher.MAX_SIZE) {
+                eventBus.publish new FileHashedEvent(error: "$f is too large to be shared ${f.length()}")
+            } else {
+                eventBus.publish new FileHashingEvent(hashingFile: f)
+                def hash = hasher.hashFile f
+                eventBus.publish new FileHashedEvent(sharedFile: new SharedFile(f, hash, FileHasher.getPieceSize(f.length())))
+            }
+        }
+    }
 }

core/src/main/groovy/com/muwire/core/files/PersisterService.groovy

@@ -23,135 +23,135 @@ import net.i2p.data.Destination
 @Log
 class PersisterService extends Service {
 
-	final File location
-	final EventBus listener
-	final int interval
-	final Timer timer
-	final FileManager fileManager
-	
-	PersisterService(File location, EventBus listener, int interval, FileManager fileManager) {
-		this.location = location
-		this.listener = listener
-		this.interval = interval
-		this.fileManager = fileManager
-		timer = new Timer("file persister", true)
-	}
-	
-	void stop() {
-		timer.cancel()
-	}
+    final File location
+    final EventBus listener
+    final int interval
+    final Timer timer
+    final FileManager fileManager
+
+    PersisterService(File location, EventBus listener, int interval, FileManager fileManager) {
+        this.location = location
+        this.listener = listener
+        this.interval = interval
+        this.fileManager = fileManager
+        timer = new Timer("file persister", true)
+    }
+
+    void stop() {
+        timer.cancel()
+    }
 
     void onUILoadedEvent(UILoadedEvent e) {
         timer.schedule({load()} as TimerTask, 1)
     }
-    	
-	void load() {
-		if (location.exists() && location.isFile()) {
-			def slurper = new JsonSlurper()
-			try {
-				location.eachLine {
-					if (it.trim().length() > 0) {
-						def parsed = slurper.parseText it
-						def event = fromJson parsed
-						if (event != null) {
+
+    void load() {
+        if (location.exists() && location.isFile()) {
+            def slurper = new JsonSlurper()
+            try {
+                location.eachLine {
+                    if (it.trim().length() > 0) {
+                        def parsed = slurper.parseText it
+                        def event = fromJson parsed
+                        if (event != null) {
                             log.fine("loaded file $event.loadedFile.file")
-							listener.publish event
-						}
-					}
-				}
+                            listener.publish event
+                        }
+                    }
+                }
                 listener.publish(new AllFilesLoadedEvent())
-			} catch (IllegalArgumentException|NumberFormatException e) {
+            } catch (IllegalArgumentException|NumberFormatException e) {
                 log.log(Level.WARNING, "couldn't load files",e)
-			}
-		} else {
+            }
+        } else {
             listener.publish(new AllFilesLoadedEvent())
         }
-		timer.schedule({persistFiles()} as TimerTask, 0, interval)
-		loaded = true
-	}
-	
-	private static FileLoadedEvent fromJson(def json) {
-		if (json.file == null || json.length == null || json.infoHash == null || json.hashList == null)
-			throw new IllegalArgumentException()
-		if (!(json.hashList instanceof List))
-			throw new IllegalArgumentException()
-			
-		def file = new File(DataUtil.readi18nString(Base64.decode(json.file)))
-		file = file.getCanonicalFile()
-		if (!file.exists() || file.isDirectory())
-			return null
-		long length = Long.valueOf(json.length)
-		if (length != file.length())
-			return null
-		
-		List hashList = (List) json.hashList
-		ByteArrayOutputStream baos = new ByteArrayOutputStream()
-		hashList.each {
-			byte [] hash = Base64.decode it.toString()
-			if (hash == null)
-				throw new IllegalArgumentException()
-			baos.write hash
-		}
-		byte[] hashListBytes = baos.toByteArray()
-		
-		InfoHash ih = InfoHash.fromHashList(hashListBytes)
-		byte [] root = Base64.decode(json.infoHash.toString())
-		if (root == null)
-			throw new IllegalArgumentException()
-		if (!Arrays.equals(root, ih.getRoot()))
-			return null
-			
+        timer.schedule({persistFiles()} as TimerTask, 0, interval)
+        loaded = true
+    }
+
+    private static FileLoadedEvent fromJson(def json) {
+        if (json.file == null || json.length == null || json.infoHash == null || json.hashList == null)
+            throw new IllegalArgumentException()
+        if (!(json.hashList instanceof List))
+            throw new IllegalArgumentException()
+
+        def file = new File(DataUtil.readi18nString(Base64.decode(json.file)))
+        file = file.getCanonicalFile()
+        if (!file.exists() || file.isDirectory())
+            return null
+        long length = Long.valueOf(json.length)
+        if (length != file.length())
+            return null
+
+        List hashList = (List) json.hashList
+        ByteArrayOutputStream baos = new ByteArrayOutputStream()
+        hashList.each {
+            byte [] hash = Base64.decode it.toString()
+            if (hash == null)
+                throw new IllegalArgumentException()
+            baos.write hash
+        }
+        byte[] hashListBytes = baos.toByteArray()
+
+        InfoHash ih = InfoHash.fromHashList(hashListBytes)
+        byte [] root = Base64.decode(json.infoHash.toString())
+        if (root == null)
+            throw new IllegalArgumentException()
+        if (!Arrays.equals(root, ih.getRoot()))
+            return null
+
         int pieceSize = 0
         if (json.pieceSize != null)
             pieceSize = json.pieceSize
-            
+
         if (json.sources != null) {
-			List sources = (List)json.sources
-			Set<Destination> sourceSet = sources.stream().map({d -> new Destination(d.toString())}).collect Collectors.toSet()
-			DownloadedFile df = new DownloadedFile(file, ih, pieceSize, sourceSet)
-			return new FileLoadedEvent(loadedFile : df)
-		}
-        
-		 
-		SharedFile sf = new SharedFile(file, ih, pieceSize)
-		return new FileLoadedEvent(loadedFile: sf)
-		
-	}
-	
-	private void persistFiles() {
-		def sharedFiles = fileManager.getSharedFiles()
-        
+            List sources = (List)json.sources
+            Set<Destination> sourceSet = sources.stream().map({d -> new Destination(d.toString())}).collect Collectors.toSet()
+            DownloadedFile df = new DownloadedFile(file, ih, pieceSize, sourceSet)
+            return new FileLoadedEvent(loadedFile : df)
+        }
+
+
+        SharedFile sf = new SharedFile(file, ih, pieceSize)
+        return new FileLoadedEvent(loadedFile: sf)
+
+    }
+
+    private void persistFiles() {
+        def sharedFiles = fileManager.getSharedFiles()
+
         File tmp = File.createTempFile("muwire-files", "tmp")
         tmp.deleteOnExit()
-		tmp.withPrintWriter { writer ->
-			sharedFiles.each { k, v ->
-				def json = toJson(k,v)
-				json = JsonOutput.toJson(json)
-				writer.println json
-			}
-		}
+        tmp.withPrintWriter { writer ->
+            sharedFiles.each { k, v ->
+                def json = toJson(k,v)
+                json = JsonOutput.toJson(json)
+                writer.println json
+            }
+        }
         Files.copy(tmp.toPath(), location.toPath(), StandardCopyOption.REPLACE_EXISTING)
         tmp.delete()
-	}
-	
-	private def toJson(File f, SharedFile sf) {
-		def json = [:]
-		json.file = Base64.encode DataUtil.encodei18nString(f.getCanonicalFile().toString())
-		json.length = f.length()
-		InfoHash ih = sf.getInfoHash()
-		json.infoHash = Base64.encode ih.getRoot()
+    }
+
+    private def toJson(File f, SharedFile sf) {
+        def json = [:]
+        json.file = Base64.encode DataUtil.encodei18nString(f.getCanonicalFile().toString())
+        json.length = f.length()
+        InfoHash ih = sf.getInfoHash()
+        json.infoHash = Base64.encode ih.getRoot()
         json.pieceSize = sf.getPieceSize()
-		byte [] tmp = new byte [32]
-		json.hashList = []
-		for (int i = 0;i < ih.getHashList().length / 32; i++) {
-			System.arraycopy(ih.getHashList(), i * 32, tmp, 0, 32)
-			json.hashList.add Base64.encode(tmp)
-		}
-		
-		if (sf instanceof DownloadedFile) {
-			json.sources = sf.sources.stream().map( {d -> d.toBase64()}).collect(Collectors.toList())
-		}
-		
-		json
-	}
+        byte [] tmp = new byte [32]
+        json.hashList = []
+        for (int i = 0;i < ih.getHashList().length / 32; i++) {
+            System.arraycopy(ih.getHashList(), i * 32, tmp, 0, 32)
+            json.hashList.add Base64.encode(tmp)
+        }
+
+        if (sf instanceof DownloadedFile) {
+            json.sources = sf.sources.stream().map( {d -> d.toBase64()}).collect(Collectors.toList())
+        }
+
+        json
+    }
 }

core/src/main/groovy/com/muwire/core/hostcache/CacheClient.groovy

@@ -17,177 +17,177 @@ import net.i2p.data.Destination
 
 @Log
 class CacheClient {
-	
-	private static final int CRAWLER_RETURN = 10
-	
-	final EventBus eventBus
-	final HostCache cache
-	final ConnectionManager manager
-	final I2PSession session
-	final long interval
-	final MuWireSettings settings
-	final Timer timer
 
-	public CacheClient(EventBus eventBus, HostCache cache, 
-		ConnectionManager manager, I2PSession session,
-		MuWireSettings settings, long interval) {
-		this.eventBus = eventBus
-		this.cache = cache
-		this.manager = manager
-		this.session = session
-		this.settings = settings
-		this.interval = interval
-		this.timer = new Timer("hostcache-client",true)
-	}
-	
-	void start() {
-		session.addMuxedSessionListener(new Listener(), I2PSession.PROTO_DATAGRAM, 0)
-		timer.schedule({queryIfNeeded()} as TimerTask, 1, interval)
-	}
-	
-	void stop() {
-		timer.cancel()
-	}
-	
-	private void queryIfNeeded() {
-		if (!manager.getConnections().isEmpty())
-			return
-		if (!cache.getHosts(1).isEmpty())
-			return
-		
-		log.info "Will query hostcaches"	
-		
-		def ping = [type: "Ping", version: 1, leaf: settings.isLeaf()]
-		ping = JsonOutput.toJson(ping)
-		def maker = new I2PDatagramMaker(session)
-		ping = maker.makeI2PDatagram(ping.bytes)
-		def options = new SendMessageOptions()
-		options.setSendLeaseSet(true)
-		CacheServers.getCacheServers().each {
-			log.info "Querying hostcache ${it.toBase32()}"
-			session.sendMessage(it, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 1, 0, options)
-		}
-	}
-	
-	class Listener implements I2PSessionMuxedListener {
-		
-		private final JsonSlurper slurper = new JsonSlurper()
+    private static final int CRAWLER_RETURN = 10
 
-		@Override
-		public void messageAvailable(I2PSession session, int msgId, long size) {
-		}
+    final EventBus eventBus
+    final HostCache cache
+    final ConnectionManager manager
+    final I2PSession session
+    final long interval
+    final MuWireSettings settings
+    final Timer timer
 
-		@Override
-		public void messageAvailable(I2PSession session, int msgId, long size, int proto, int fromport, int toport) {
-			
-			if (proto != I2PSession.PROTO_DATAGRAM) {
-				log.warning "Received unexpected protocol $proto"
-				return
-			}
-			
-			def payload = session.receiveMessage(msgId)
-			def dissector = new I2PDatagramDissector()
-			try {
-				dissector.loadI2PDatagram(payload)
-				def sender = dissector.getSender()
-				log.info("Received something from ${sender.toBase32()}")
-				
-				payload = dissector.getPayload()
-				payload = slurper.parse(payload)
-				
-				if (payload.type == null) {
-					log.warning("type missing")
-					return
-				}
-				
-				switch(payload.type) {
-					case "Pong" : handlePong(sender, payload); break
-					case "CrawlerPing": handleCrawlerPing(session, sender, payload); break
-					default : log.warning("unknown type ${payload.type}")
-				}
-			} catch (Exception e) {
-				log.warning("Invalid datagram $e")
-			}
-		}
+    public CacheClient(EventBus eventBus, HostCache cache,
+        ConnectionManager manager, I2PSession session,
+        MuWireSettings settings, long interval) {
+        this.eventBus = eventBus
+        this.cache = cache
+        this.manager = manager
+        this.session = session
+        this.settings = settings
+        this.interval = interval
+        this.timer = new Timer("hostcache-client",true)
+    }
 
-		@Override
-		public void reportAbuse(I2PSession session, int severity) {
-		}
+    void start() {
+        session.addMuxedSessionListener(new Listener(), I2PSession.PROTO_DATAGRAM, 0)
+        timer.schedule({queryIfNeeded()} as TimerTask, 1, interval)
+    }
 
-		@Override
-		public void disconnected(I2PSession session) {
-			log.severe "I2P session disconnected"
-		}
+    void stop() {
+        timer.cancel()
+    }
 
-		@Override
-		public void errorOccurred(I2PSession session, String message, Throwable error) {
-			log.severe "I2P error occured $message $error"
-		}
-		
-	}
-	
-	private void handlePong(Destination from, def pong) {
-		if (!CacheServers.isRegistered(from)) {
-			log.warning("received pong from non-registered destination")
-			return
-		}
-		
-		if (pong.pongs == null) {
-			log.warning("malformed pong - no pongs")
-			return
-		}
-		
-		pong.pongs.asList().each { 
-			Destination dest = new Destination(it)
-			if (!session.getMyDestination().equals(dest))
-				eventBus.publish(new HostDiscoveredEvent(destination: dest, fromHostcache : true)) 
-		}
-		
-	}
-	
-	private void handleCrawlerPing(I2PSession session, Destination from, def ping) {
-		if (settings.isLeaf()) {
-			log.warning("Received crawler ping but I'm a leaf")
-			return
-		}
-		
-		switch(settings.getCrawlerResponse()) {
-			case CrawlerResponse.NONE:
-				log.info("Responding to crawlers is disabled by user")
-				break
-			case CrawlerResponse.ALL:
-				respondToCrawler(session, from, ping)
-				break;
-			case CrawlerResponse.REGISTERED:
-				if (CacheServers.isRegistered(from))
-					respondToCrawler(session, from, ping)
-				else
-					log.warning("Ignoring crawler ping from non-registered crawler")
-				break
-		}
-	}
-	
-	private void respondToCrawler(I2PSession session, Destination from, def ping) {
-		log.info "responding to crawler ping"
-		
-		def neighbors = manager.getConnections().collect { c -> c.endpoint.destination.toBase64() }
-		Collections.shuffle(neighbors)
-		if (neighbors.size() > CRAWLER_RETURN)
-			neighbors = neighbors[0..CRAWLER_RETURN - 1]
-		
-		def upManager = (UltrapeerConnectionManager) manager;
-		def pong = [:]
-		pong.peers = neighbors
-		pong.uuid = ping.uuid
-		pong.type = "CrawlerPong"
-		pong.version = 1
-		pong.leafSlots = upManager.hasLeafSlots()
-		pong.peerSlots = upManager.hasPeerSlots()
-		pong = JsonOutput.toJson(pong)
-		
-		def maker = new I2PDatagramMaker(session)
-		pong = maker.makeI2PDatagram(pong.bytes)
-		session.sendMessage(from, pong, I2PSession.PROTO_DATAGRAM, 0, 0)
-	}
+    private void queryIfNeeded() {
+        if (!manager.getConnections().isEmpty())
+            return
+        if (!cache.getHosts(1).isEmpty())
+            return
+
+        log.info "Will query hostcaches"
+
+        def ping = [type: "Ping", version: 1, leaf: settings.isLeaf()]
+        ping = JsonOutput.toJson(ping)
+        def maker = new I2PDatagramMaker(session)
+        ping = maker.makeI2PDatagram(ping.bytes)
+        def options = new SendMessageOptions()
+        options.setSendLeaseSet(true)
+        CacheServers.getCacheServers().each {
+            log.info "Querying hostcache ${it.toBase32()}"
+            session.sendMessage(it, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 1, 0, options)
+        }
+    }
+
+    class Listener implements I2PSessionMuxedListener {
+
+        private final JsonSlurper slurper = new JsonSlurper()
+
+        @Override
+        public void messageAvailable(I2PSession session, int msgId, long size) {
+        }
+
+        @Override
+        public void messageAvailable(I2PSession session, int msgId, long size, int proto, int fromport, int toport) {
+
+            if (proto != I2PSession.PROTO_DATAGRAM) {
+                log.warning "Received unexpected protocol $proto"
+                return
+            }
+
+            def payload = session.receiveMessage(msgId)
+            def dissector = new I2PDatagramDissector()
+            try {
+                dissector.loadI2PDatagram(payload)
+                def sender = dissector.getSender()
+                log.info("Received something from ${sender.toBase32()}")
+
+                payload = dissector.getPayload()
+                payload = slurper.parse(payload)
+
+                if (payload.type == null) {
+                    log.warning("type missing")
+                    return
+                }
+
+                switch(payload.type) {
+                    case "Pong" : handlePong(sender, payload); break
+                    case "CrawlerPing": handleCrawlerPing(session, sender, payload); break
+                    default : log.warning("unknown type ${payload.type}")
+                }
+            } catch (Exception e) {
+                log.warning("Invalid datagram $e")
+            }
+        }
+
+        @Override
+        public void reportAbuse(I2PSession session, int severity) {
+        }
+
+        @Override
+        public void disconnected(I2PSession session) {
+            log.severe "I2P session disconnected"
+        }
+
+        @Override
+        public void errorOccurred(I2PSession session, String message, Throwable error) {
+            log.severe "I2P error occured $message $error"
+        }
+
+    }
+
+    private void handlePong(Destination from, def pong) {
+        if (!CacheServers.isRegistered(from)) {
+            log.warning("received pong from non-registered destination")
+            return
+        }
+
+        if (pong.pongs == null) {
+            log.warning("malformed pong - no pongs")
+            return
+        }
+
+        pong.pongs.asList().each {
+            Destination dest = new Destination(it)
+            if (!session.getMyDestination().equals(dest))
+                eventBus.publish(new HostDiscoveredEvent(destination: dest, fromHostcache : true))
+        }
+
+    }
+
+    private void handleCrawlerPing(I2PSession session, Destination from, def ping) {
+        if (settings.isLeaf()) {
+            log.warning("Received crawler ping but I'm a leaf")
+            return
+        }
+
+        switch(settings.getCrawlerResponse()) {
+            case CrawlerResponse.NONE:
+                log.info("Responding to crawlers is disabled by user")
+                break
+            case CrawlerResponse.ALL:
+                respondToCrawler(session, from, ping)
+                break;
+            case CrawlerResponse.REGISTERED:
+                if (CacheServers.isRegistered(from))
+                    respondToCrawler(session, from, ping)
+                else
+                    log.warning("Ignoring crawler ping from non-registered crawler")
+                break
+        }
+    }
+
+    private void respondToCrawler(I2PSession session, Destination from, def ping) {
+        log.info "responding to crawler ping"
+
+        def neighbors = manager.getConnections().collect { c -> c.endpoint.destination.toBase64() }
+        Collections.shuffle(neighbors)
+        if (neighbors.size() > CRAWLER_RETURN)
+            neighbors = neighbors[0..CRAWLER_RETURN - 1]
+
+        def upManager = (UltrapeerConnectionManager) manager;
+        def pong = [:]
+        pong.peers = neighbors
+        pong.uuid = ping.uuid
+        pong.type = "CrawlerPong"
+        pong.version = 1
+        pong.leafSlots = upManager.hasLeafSlots()
+        pong.peerSlots = upManager.hasPeerSlots()
+        pong = JsonOutput.toJson(pong)
+
+        def maker = new I2PDatagramMaker(session)
+        pong = maker.makeI2PDatagram(pong.bytes)
+        session.sendMessage(from, pong, I2PSession.PROTO_DATAGRAM, 0, 0)
+    }
 
 }

core/src/main/groovy/com/muwire/core/hostcache/CacheServers.groovy

@@ -4,21 +4,21 @@ import net.i2p.data.Destination
 
 class CacheServers {
 
-	private static final int TO_GIVE = 3
-	private static Set<Destination> CACHES = [
-			new Destination("Wddh2E6FyyXBF7SvUYHKdN-vjf3~N6uqQWNeBDTM0P33YjiQCOsyedrjmDZmWFrXUJfJLWnCb5bnKezfk4uDaMyj~uvDG~yvLVcFgcPWSUd7BfGgym-zqcG1q1DcM8vfun-US7YamBlmtC6MZ2j-~Igqzmgshita8aLPCfNAA6S6e2UMjjtG7QIXlxpMec75dkHdJlVWbzrk9z8Qgru3YIk0UztYgEwDNBbm9wInsbHhr3HtAfa02QcgRVqRN2PnQXuqUJs7R7~09FZPEviiIcUpkY3FeyLlX1sgQFBeGeA96blaPvZNGd6KnNdgfLgMebx5SSxC-N4KZMSMBz5cgonQF3~m2HHFRSI85zqZNG5X9bJN85t80ltiv1W1es8ZnQW4es11r7MrvJNXz5bmSH641yJIvS6qI8OJJNpFVBIQSXLD-96TayrLQPaYw~uNZ-eXaE6G5dYhiuN8xHsFI1QkdaUaVZnvDGfsRbpS5GtpUbBDbyLkdPurG0i7dN1wAAAA"),
+    private static final int TO_GIVE = 3
+    private static Set<Destination> CACHES = [
+            new Destination("Wddh2E6FyyXBF7SvUYHKdN-vjf3~N6uqQWNeBDTM0P33YjiQCOsyedrjmDZmWFrXUJfJLWnCb5bnKezfk4uDaMyj~uvDG~yvLVcFgcPWSUd7BfGgym-zqcG1q1DcM8vfun-US7YamBlmtC6MZ2j-~Igqzmgshita8aLPCfNAA6S6e2UMjjtG7QIXlxpMec75dkHdJlVWbzrk9z8Qgru3YIk0UztYgEwDNBbm9wInsbHhr3HtAfa02QcgRVqRN2PnQXuqUJs7R7~09FZPEviiIcUpkY3FeyLlX1sgQFBeGeA96blaPvZNGd6KnNdgfLgMebx5SSxC-N4KZMSMBz5cgonQF3~m2HHFRSI85zqZNG5X9bJN85t80ltiv1W1es8ZnQW4es11r7MrvJNXz5bmSH641yJIvS6qI8OJJNpFVBIQSXLD-96TayrLQPaYw~uNZ-eXaE6G5dYhiuN8xHsFI1QkdaUaVZnvDGfsRbpS5GtpUbBDbyLkdPurG0i7dN1wAAAA"),
             new Destination("JC63wJNOqSJmymkj4~UJWywBTvDGikKMoYP0HX2Wz9c5l3otXSkwnxWAFL4cKr~Ygh3BNNi2t93vuLIiI1W8AsE42kR~PwRx~Y-WvIHXR6KUejRmOp-n8WidtjKg9k4aDy428uSOedqXDxys5mpoeQXwDsv1CoPTTwnmb1GWFy~oTGIsCguCl~aJWGnqiKarPO3GJQ~ev-NbvAQzUfC3HeP1e6pdI5CGGjExahTCID5UjpJw8GaDXWlGmYWWH303Xu4x-vAHQy1dJLsOBCn8dZravsn5BKJk~j0POUon45CCx-~NYtaPe0Itt9cMdD2ciC76Rep1D0X0sm1SjlSs8sZ52KmF3oaLZ6OzgI9QLMIyBUrfi41sK5I0qTuUVBAkvW1xr~L-20dYJ9TrbOaOb2-vDIfKaxVi6xQOuhgQDiSBhd3qv2m0xGu-BM9DQYfNA0FdMjnZmqjmji9RMavzQSsVFIbQGLbrLepiEFlb7TseCK5UtRp8TxnG7L4gbYevBQAEAAcAAA==")
-		]
+        ]
 
-	static List<Destination> getCacheServers() {
-		List<Destination> allCaches = new ArrayList<>(CACHES)
-		Collections.shuffle(allCaches)
-		if (allCaches.size() <= TO_GIVE)
-			return allCaches
-		allCaches[0..TO_GIVE-1]
-	}
-	
-	static boolean isRegistered(Destination d) {
-		return CACHES.contains(d)
-	}
+    static List<Destination> getCacheServers() {
+        List<Destination> allCaches = new ArrayList<>(CACHES)
+        Collections.shuffle(allCaches)
+        if (allCaches.size() <= TO_GIVE)
+            return allCaches
+        allCaches[0..TO_GIVE-1]
+    }
+
+    static boolean isRegistered(Destination d) {
+        return CACHES.contains(d)
+    }
 }

core/src/main/groovy/com/muwire/core/hostcache/Host.groovy

@@ -4,42 +4,42 @@ import net.i2p.data.Destination
 
 class Host {
 
-	private static final int MAX_FAILURES = 3
-	
-	final Destination destination
-    private final int clearInterval
-	int failures,successes
-    long lastAttempt
-	
-	public Host(Destination destination, int clearInterval) {
-		this.destination = destination
-        this.clearInterval = clearInterval
-	}
+    private static final int MAX_FAILURES = 3
 
-	synchronized void onConnect() {
-		failures = 0
-		successes++
+    final Destination destination
+    private final int clearInterval
+    int failures,successes
+    long lastAttempt
+
+    public Host(Destination destination, int clearInterval) {
+        this.destination = destination
+        this.clearInterval = clearInterval
+    }
+
+    synchronized void onConnect() {
+        failures = 0
+        successes++
         lastAttempt = System.currentTimeMillis()
-	}
-	
-	synchronized void onFailure() {
-		failures++
-		successes = 0
+    }
+
+    synchronized void onFailure() {
+        failures++
+        successes = 0
         lastAttempt = System.currentTimeMillis()
-	}
-	
-	synchronized boolean isFailed() {
-		failures >= MAX_FAILURES
-	}
-	
-	synchronized boolean hasSucceeded() {
-		successes > 0
-	}
-    
+    }
+
+    synchronized boolean isFailed() {
+        failures >= MAX_FAILURES
+    }
+
+    synchronized boolean hasSucceeded() {
+        successes > 0
+    }
+
     synchronized void clearFailures() {
         failures = 0
     }
-    
+
     synchronized void canTryAgain() {
         System.currentTimeMillis() - lastAttempt > (clearInterval * 60 * 1000)
     }

core/src/main/groovy/com/muwire/core/hostcache/HostCache.groovy

@@ -15,141 +15,141 @@ import net.i2p.data.Destination
 
 class HostCache extends Service {
 
-	final TrustService trustService
-	final File storage
-	final int interval
-	final Timer timer
-	final MuWireSettings settings
-	final Destination myself
-	final Map<Destination, Host> hosts = new ConcurrentHashMap<>()
-	
-	HostCache(){}
-	
-	public HostCache(TrustService trustService, File storage, int interval, 
-		MuWireSettings settings, Destination myself) {
-		this.trustService = trustService
-		this.storage = storage
-		this.interval = interval
-		this.settings = settings
-		this.myself = myself
-		this.timer = new Timer("host-persister",true)
-	}
+    final TrustService trustService
+    final File storage
+    final int interval
+    final Timer timer
+    final MuWireSettings settings
+    final Destination myself
+    final Map<Destination, Host> hosts = new ConcurrentHashMap<>()
 
-	void start() {
-		timer.schedule({load()} as TimerTask, 1)
-	}
-	
-	void stop() {
-		timer.cancel()
-	}
-	
-	void onHostDiscoveredEvent(HostDiscoveredEvent e) {
-		if (myself == e.destination)
-			return
-		if (hosts.containsKey(e.destination)) {
+    HostCache(){}
+
+    public HostCache(TrustService trustService, File storage, int interval,
+        MuWireSettings settings, Destination myself) {
+        this.trustService = trustService
+        this.storage = storage
+        this.interval = interval
+        this.settings = settings
+        this.myself = myself
+        this.timer = new Timer("host-persister",true)
+    }
+
+    void start() {
+        timer.schedule({load()} as TimerTask, 1)
+    }
+
+    void stop() {
+        timer.cancel()
+    }
+
+    void onHostDiscoveredEvent(HostDiscoveredEvent e) {
+        if (myself == e.destination)
+            return
+        if (hosts.containsKey(e.destination)) {
             if (!e.fromHostcache)
                 return
             hosts.get(e.destination).clearFailures()
             return
-		}
-		Host host = new Host(e.destination, settings.hostClearInterval)
-		if (allowHost(host)) {
-			hosts.put(e.destination, host)
-		}
-	}
-	
-	void onConnectionEvent(ConnectionEvent e) {
-		if (e.leaf)
-			return
-		Destination dest = e.endpoint.destination
-		Host host = hosts.get(dest)
-		if (host == null) {
-			host = new Host(dest, settings.hostClearInterval)
-			hosts.put(dest, host)
-		}
+        }
+        Host host = new Host(e.destination, settings.hostClearInterval)
+        if (allowHost(host)) {
+            hosts.put(e.destination, host)
+        }
+    }
 
-		switch(e.status) {
-			case ConnectionAttemptStatus.SUCCESSFUL:
-			case ConnectionAttemptStatus.REJECTED:
-				host.onConnect()
-				break
-			case ConnectionAttemptStatus.FAILED:
-				host.onFailure()
-				break
-		}
-	}
-	
-	List<Destination> getHosts(int n) {
-		List<Destination> rv = new ArrayList<>(hosts.keySet())
-		rv.retainAll {allowHost(hosts[it])}
-		if (rv.size() <= n)
-			return rv
-		Collections.shuffle(rv)
-		rv[0..n-1]
-	}
-	
-	List<Destination> getGoodHosts(int n) {
-		List<Destination> rv = new ArrayList<>(hosts.keySet())
-		rv.retainAll {
-			Host host = hosts[it]
-			allowHost(host) && host.hasSucceeded()
-		}
-		if (rv.size() <= n)
-			return rv
-		Collections.shuffle(rv)
-		rv[0..n-1]
-	}
-	
-	void load() {
-		if (storage.exists()) {
-			JsonSlurper slurper = new JsonSlurper()
-			storage.eachLine {
-				def entry = slurper.parseText(it)
-				Destination dest = new Destination(entry.destination)
-				Host host = new Host(dest, settings.hostClearInterval)
-				host.failures = Integer.valueOf(String.valueOf(entry.failures))
-				host.successes = Integer.valueOf(String.valueOf(entry.successes))
+    void onConnectionEvent(ConnectionEvent e) {
+        if (e.leaf)
+            return
+        Destination dest = e.endpoint.destination
+        Host host = hosts.get(dest)
+        if (host == null) {
+            host = new Host(dest, settings.hostClearInterval)
+            hosts.put(dest, host)
+        }
+
+        switch(e.status) {
+            case ConnectionAttemptStatus.SUCCESSFUL:
+            case ConnectionAttemptStatus.REJECTED:
+                host.onConnect()
+                break
+            case ConnectionAttemptStatus.FAILED:
+                host.onFailure()
+                break
+        }
+    }
+
+    List<Destination> getHosts(int n) {
+        List<Destination> rv = new ArrayList<>(hosts.keySet())
+        rv.retainAll {allowHost(hosts[it])}
+        if (rv.size() <= n)
+            return rv
+        Collections.shuffle(rv)
+        rv[0..n-1]
+    }
+
+    List<Destination> getGoodHosts(int n) {
+        List<Destination> rv = new ArrayList<>(hosts.keySet())
+        rv.retainAll {
+            Host host = hosts[it]
+            allowHost(host) && host.hasSucceeded()
+        }
+        if (rv.size() <= n)
+            return rv
+        Collections.shuffle(rv)
+        rv[0..n-1]
+    }
+
+    void load() {
+        if (storage.exists()) {
+            JsonSlurper slurper = new JsonSlurper()
+            storage.eachLine {
+                def entry = slurper.parseText(it)
+                Destination dest = new Destination(entry.destination)
+                Host host = new Host(dest, settings.hostClearInterval)
+                host.failures = Integer.valueOf(String.valueOf(entry.failures))
+                host.successes = Integer.valueOf(String.valueOf(entry.successes))
                 if (entry.lastAttempt != null)
                     host.lastAttempt = entry.lastAttempt
-				if (allowHost(host))
-					hosts.put(dest, host)
-			}
-		}
-		timer.schedule({save()} as TimerTask, interval, interval)
-		loaded = true
-	}
-	
-	private boolean allowHost(Host host) {
-		if (host.isFailed() && !host.canTryAgain())
-			return false
-		if (host.destination == myself)
-			return false
-		TrustLevel trust = trustService.getLevel(host.destination)
-		switch(trust) {
-			case TrustLevel.DISTRUSTED :
-				return false
-			case TrustLevel.TRUSTED :
-				return true
-			case TrustLevel.NEUTRAL :
-				return settings.allowUntrusted()
-		}
-		false
-	}
-	
-	private void save() {
-		storage.delete()
-		storage.withPrintWriter { writer ->
-			hosts.each { dest, host ->
-				if (allowHost(host)) {
-					def map = [:]
-					map.destination = dest.toBase64()
-					map.failures = host.failures
-					map.successes = host.successes
+                if (allowHost(host))
+                    hosts.put(dest, host)
+            }
+        }
+        timer.schedule({save()} as TimerTask, interval, interval)
+        loaded = true
+    }
+
+    private boolean allowHost(Host host) {
+        if (host.isFailed() && !host.canTryAgain())
+            return false
+        if (host.destination == myself)
+            return false
+        TrustLevel trust = trustService.getLevel(host.destination)
+        switch(trust) {
+            case TrustLevel.DISTRUSTED :
+                return false
+            case TrustLevel.TRUSTED :
+                return true
+            case TrustLevel.NEUTRAL :
+                return settings.allowUntrusted()
+        }
+        false
+    }
+
+    private void save() {
+        storage.delete()
+        storage.withPrintWriter { writer ->
+            hosts.each { dest, host ->
+                if (allowHost(host)) {
+                    def map = [:]
+                    map.destination = dest.toBase64()
+                    map.failures = host.failures
+                    map.successes = host.successes
                     map.lastAttempt = host.lastAttempt
-					def json = JsonOutput.toJson(map)
-					writer.println json
-				}
-			}
-		}
-	}
+                    def json = JsonOutput.toJson(map)
+                    writer.println json
+                }
+            }
+        }
+    }
 }

core/src/main/groovy/com/muwire/core/hostcache/HostDiscoveredEvent.groovy

@@ -6,11 +6,11 @@ import net.i2p.data.Destination
 
 class HostDiscoveredEvent extends Event {
 
-	Destination destination
+    Destination destination
     boolean fromHostcache
-    
-	@Override
-	public String toString() {
-		"HostDiscoveredEvent ${super.toString()} destination:${destination.toBase32()} from hostcache $fromHostcache"
-	}
+
+    @Override
+    public String toString() {
+        "HostDiscoveredEvent ${super.toString()} destination:${destination.toBase32()} from hostcache $fromHostcache"
+    }
 }

core/src/main/groovy/com/muwire/core/mesh/Mesh.groovy

@@ -11,12 +11,12 @@ class Mesh {
     private final InfoHash infoHash
     private final Set<Persona> sources = new ConcurrentHashSet<>()
     private final Pieces pieces
-    
+
     Mesh(InfoHash infoHash, Pieces pieces) {
         this.infoHash = infoHash
         this.pieces = pieces
     }
-    
+
     Set<Persona> getRandom(int n, Persona exclude) {
         List<Persona> tmp = new ArrayList<>(sources)
         tmp.remove(exclude)

core/src/main/groovy/com/muwire/core/mesh/MeshManager.groovy

@@ -16,23 +16,23 @@ import groovy.json.JsonSlurper
 import net.i2p.data.Base64
 
 class MeshManager {
-    
+
     private final Map<InfoHash, Mesh> meshes = Collections.synchronizedMap(new HashMap<>())
     private final FileManager fileManager
     private final File home
     private final MuWireSettings settings
-    
+
     MeshManager(FileManager fileManager, File home, MuWireSettings settings) {
         this.fileManager = fileManager
         this.home = home
         this.settings = settings
         load()
     }
-    
+
     Mesh get(InfoHash infoHash) {
         meshes.get(infoHash)
     }
-    
+
     Mesh getOrCreate(InfoHash infoHash, int nPieces) {
         synchronized(meshes) {
             if (meshes.containsKey(infoHash))
@@ -47,7 +47,7 @@ class MeshManager {
             return rv
         }
     }
-    
+
     void onSourceDiscoveredEvent(SourceDiscoveredEvent e) {
         Mesh mesh = meshes.get(e.infoHash)
         if (mesh == null)
@@ -55,7 +55,7 @@ class MeshManager {
        mesh.sources.add(e.source)
        save()
     }
-    
+
     private void save() {
         File meshFile = new File(home, "mesh.json")
         synchronized(meshes) {
@@ -72,29 +72,29 @@ class MeshManager {
             }
         }
     }
-    
+
     private void load() {
         File meshFile = new File(home, "mesh.json")
         if (!meshFile.exists())
             return
         long now = System.currentTimeMillis()
         JsonSlurper slurper = new JsonSlurper()
-        meshFile.eachLine { 
+        meshFile.eachLine {
             def json = slurper.parseText(it)
             if (now - json.timestamp > settings.meshExpiration * 60 * 1000)
                 return
             InfoHash infoHash = new InfoHash(Base64.decode(json.infoHash))
             Pieces pieces = new Pieces(json.nPieces, settings.downloadSequentialRatio)
-            
+
             Mesh mesh = new Mesh(infoHash, pieces)
-            json.sources.each { source -> 
+            json.sources.each { source ->
                 Persona persona = new Persona(new ByteArrayInputStream(Base64.decode(source)))
                 mesh.sources.add(persona)
             }
-            
-            if (json.xHave != null) 
+
+            if (json.xHave != null)
                 DataUtil.decodeXHave(json.xHave).each { pieces.markDownloaded(it) }
-                
+
             if (!mesh.sources.isEmpty())
                 meshes.put(infoHash, mesh)
         }

core/src/main/groovy/com/muwire/core/search/DeleteEvent.groovy

@@ -6,11 +6,11 @@ import net.i2p.data.Base32
 import net.i2p.data.Destination
 
 class DeleteEvent extends Event {
-	byte [] infoHash
-	Destination leaf
-	
-	@Override
-	public String toString() {
-		"DeleteEvent ${super.toString()} infoHash:${Base32.encode(infoHash)} leaf:${leaf.toBase32()}"
-	}
+    byte [] infoHash
+    Destination leaf
+
+    @Override
+    public String toString() {
+        "DeleteEvent ${super.toString()} infoHash:${Base32.encode(infoHash)} leaf:${leaf.toBase32()}"
+    }
 }

core/src/main/groovy/com/muwire/core/search/InvalidSearchResultException.groovy

@@ -21,5 +21,5 @@ class InvalidSearchResultException extends Exception {
         super(cause);
         // TODO Auto-generated constructor stub
     }
-    
+
 }

core/src/main/groovy/com/muwire/core/search/LeafSearcher.groovy

@@ -6,33 +6,33 @@ import com.muwire.core.connection.UltrapeerConnectionManager
 import net.i2p.data.Destination
 
 class LeafSearcher {
-	
-	final UltrapeerConnectionManager connectionManager
-	final SearchIndex searchIndex = new SearchIndex()
-	
-	final Map<String, Set<byte[]>> fileNameToHashes = new HashMap<>()
-	final Map<byte[], Set<Destination>> hashToLeafs = new HashMap<>()
-	
-	final Map<Destination, Map<byte[], Set<String>>> leafToFiles = new HashMap<>()
-	
-	LeafSearcher(UltrapeerConnectionManager connectionManager) {
-		this.connectionManager = connectionManager
-	}
-	
-	void onUpsertEvent(UpsertEvent e) {
-		// TODO: implement
-	}
-	
-	void onDeleteEvent(DeleteEvent e) {
-		// TODO: implement
-	}
-	
-	void onDisconnectionEvent(DisconnectionEvent e) {
-		// TODO: implement
-	}
-	
-	void onQueryEvent(QueryEvent e) {
-		// TODO: implement
-	}
-	
+
+    final UltrapeerConnectionManager connectionManager
+    final SearchIndex searchIndex = new SearchIndex()
+
+    final Map<String, Set<byte[]>> fileNameToHashes = new HashMap<>()
+    final Map<byte[], Set<Destination>> hashToLeafs = new HashMap<>()
+
+    final Map<Destination, Map<byte[], Set<String>>> leafToFiles = new HashMap<>()
+
+    LeafSearcher(UltrapeerConnectionManager connectionManager) {
+        this.connectionManager = connectionManager
+    }
+
+    void onUpsertEvent(UpsertEvent e) {
+        // TODO: implement
+    }
+
+    void onDeleteEvent(DeleteEvent e) {
+        // TODO: implement
+    }
+
+    void onDisconnectionEvent(DisconnectionEvent e) {
+        // TODO: implement
+    }
+
+    void onQueryEvent(QueryEvent e) {
+        // TODO: implement
+    }
+
 }

core/src/main/groovy/com/muwire/core/search/QueryEvent.groovy

@@ -6,12 +6,12 @@ import com.muwire.core.Persona
 import net.i2p.data.Destination
 
 class QueryEvent extends Event {
-	
+
     SearchEvent searchEvent
-	boolean firstHop
-	Destination replyTo
+    boolean firstHop
+    Destination replyTo
     Persona originator
-	Destination receivedOn
+    Destination receivedOn
 
     String toString() {
         "searchEvent: $searchEvent firstHop:$firstHop, replyTo:${replyTo.toBase32()}" +

core/src/main/groovy/com/muwire/core/search/ResultsEvent.groovy

@@ -6,6 +6,6 @@ import com.muwire.core.SharedFile
 class ResultsEvent extends Event {
 
     SearchEvent searchEvent
-	SharedFile[] results
-	UUID uuid
+    SharedFile[] results
+    UUID uuid
 }

core/src/main/groovy/com/muwire/core/search/ResultsParser.groovy

@@ -26,7 +26,7 @@ class ResultsParser {
         }
 
     }
-    
+
     private static parseV1(Persona p, UUID uuid, def json) {
         if (json.name == null)
             throw new InvalidSearchResultException("name missing")
@@ -55,7 +55,7 @@ class ResultsParser {
             InfoHash parsedIH = InfoHash.fromHashList(hashList)
             if (parsedIH.getRoot() != infoHash)
                 throw new InvalidSearchControlsException("infohash root doesn't match")
-            
+
              return new UIResultEvent( sender : p,
                  name : name,
                  size : size,
@@ -67,7 +67,7 @@ class ResultsParser {
             throw new InvalidSearchResultException("parsing search result failed",e)
         }
     }
-    
+
     private static UIResultEvent parseV2(Persona p, UUID uuid, def json) {
         if (json.name == null)
             throw new InvalidSearchResultException("name missing")
@@ -86,11 +86,11 @@ class ResultsParser {
             if (infoHash.length != InfoHash.SIZE)
                 throw new InvalidSearchResultException("invalid infohash size $infoHash.length")
             int pieceSize = json.pieceSize
-            
+
             Set<Destination> sources = Collections.emptySet()
-            if (json.sources != null) 
+            if (json.sources != null)
                 sources = json.sources.stream().map({new Destination(it)}).collect(Collectors.toSet())
-            
+
             return new UIResultEvent( sender : p,
                 name : name,
                 size : size,

core/src/main/groovy/com/muwire/core/search/ResultsSender.groovy

@@ -25,9 +25,9 @@ import net.i2p.data.Destination
 
 @Log
 class ResultsSender {
-    
+
     private static final AtomicInteger THREAD_NO = new AtomicInteger()
-    
+
     private final Executor executor = Executors.newCachedThreadPool(
         new ThreadFactory() {
             @Override
@@ -38,27 +38,27 @@ class ResultsSender {
                 rv
             }
         })
-    
+
     private final I2PConnector connector
     private final Persona me
     private final EventBus eventBus
-    
+
     ResultsSender(EventBus eventBus, I2PConnector connector, Persona me) {
         this.connector = connector;
         this.eventBus = eventBus
         this.me = me
     }
-    
+
     void sendResults(UUID uuid, SharedFile[] results, Destination target, boolean oobInfohash) {
         log.info("Sending $results.length results for uuid $uuid to ${target.toBase32()} oobInfohash : $oobInfohash")
         if (target.equals(me.destination)) {
-            results.each { 
+            results.each {
                 long length = it.getFile().length()
                 int pieceSize = it.getPieceSize()
                 if (pieceSize == 0)
                     pieceSize = FileHasher.getPieceSize(length)
                 Set<Destination> suggested = Collections.emptySet()
-                if (it instanceof DownloadedFile) 
+                if (it instanceof DownloadedFile)
                     suggested = it.sources
                 def uiResultEvent = new UIResultEvent( sender : me,
                     name : it.getFile().getName(),
@@ -71,17 +71,17 @@ class ResultsSender {
                     eventBus.publish(uiResultEvent)
             }
         } else {
-            executor.execute(new ResultSendJob(uuid : uuid, results : results, 
+            executor.execute(new ResultSendJob(uuid : uuid, results : results,
                 target: target, oobInfohash : oobInfohash))
         }
     }
-    
+
     private class ResultSendJob implements Runnable {
         UUID uuid
         SharedFile [] results
         Destination target
         boolean oobInfohash
-        
+
         @Override
         public void run() {
             try {

core/src/main/groovy/com/muwire/core/search/SearchEvent.groovy

@@ -5,11 +5,11 @@ import com.muwire.core.InfoHash
 
 class SearchEvent extends Event {
 
-	List<String> searchTerms
-	byte [] searchHash
-	UUID uuid
+    List<String> searchTerms
+    byte [] searchHash
+    UUID uuid
     boolean oobInfohash
-    
+
     String toString() {
         def infoHash = null
         if (searchHash != null)

core/src/main/groovy/com/muwire/core/search/SearchIndex.groovy

@@ -4,56 +4,56 @@ import com.muwire.core.Constants
 
 class SearchIndex {
 
-	final Map<String, Set<String>> keywords = new HashMap<>()
-	
-	void add(String string) {
-		String [] split = split(string)
-		split.each {
-			Set<String> existing = keywords.get(it)
-			if (existing == null) {
-				existing = new HashSet<>()
-				keywords.put(it, existing)
-			}
-			existing.add(string)
-		}
-	}
-	
-	void remove(String string) {
-		String [] split = split(string)
-		split.each {
-			Set<String> existing = keywords.get it
-			if (existing != null) {
-				existing.remove(string)
-				if (existing.isEmpty()) {
-					keywords.remove(it)
-				}
-			}
-		}
-	}
-	
-	private static String[] split(String source) {
-		source = source.replaceAll(Constants.SPLIT_PATTERN, " ").toLowerCase()
-		String [] split = source.split(" ")
+    final Map<String, Set<String>> keywords = new HashMap<>()
+
+    void add(String string) {
+        String [] split = split(string)
+        split.each {
+            Set<String> existing = keywords.get(it)
+            if (existing == null) {
+                existing = new HashSet<>()
+                keywords.put(it, existing)
+            }
+            existing.add(string)
+        }
+    }
+
+    void remove(String string) {
+        String [] split = split(string)
+        split.each {
+            Set<String> existing = keywords.get it
+            if (existing != null) {
+                existing.remove(string)
+                if (existing.isEmpty()) {
+                    keywords.remove(it)
+                }
+            }
+        }
+    }
+
+    private static String[] split(String source) {
+        source = source.replaceAll(Constants.SPLIT_PATTERN, " ").toLowerCase()
+        String [] split = source.split(" ")
         def rv = []
         split.each { if (it.length() > 0) rv << it }
         rv.toArray(new String[0])
-	}
-	
-	String[] search(List<String> terms) {
-		Set<String> rv = null;
-		
-		terms.each {
-			Set<String> forWord = keywords.getOrDefault(it,[])
-			if (rv == null) {
-				rv = new HashSet<>(forWord)
-			} else {
-				rv.retainAll(forWord)
-			}
-				
-		}
-		
-		if (rv != null)
-			return rv.asList()
-		[]
-	}
+    }
+
+    String[] search(List<String> terms) {
+        Set<String> rv = null;
+
+        terms.each {
+            Set<String> forWord = keywords.getOrDefault(it,[])
+            if (rv == null) {
+                rv = new HashSet<>(forWord)
+            } else {
+                rv.retainAll(forWord)
+            }
+
+        }
+
+        if (rv != null)
+            return rv.asList()
+        []
+    }
 }

core/src/main/groovy/com/muwire/core/search/SearchManager.groovy

@@ -8,17 +8,17 @@ import net.i2p.data.Destination
 
 @Log
 public class SearchManager {
-    
+
     private static final int EXPIRE_TIME = 60 * 1000 * 1000
     private static final int CHECK_INTERVAL = 60 * 1000
-    
+
     private final EventBus eventBus
     private final Persona me
     private final ResultsSender resultsSender
     private final Map<UUID, QueryEvent> responderAddress = Collections.synchronizedMap(new HashMap<>())
-    
+
     SearchManager(){}
-    
+
     SearchManager(EventBus eventBus, Persona me, ResultsSender resultsSender) {
         this.eventBus = eventBus
         this.me = me
@@ -26,7 +26,7 @@ public class SearchManager {
         Timer timer = new Timer("query-expirer", true)
         timer.schedule({cleanup()} as TimerTask, CHECK_INTERVAL, CHECK_INTERVAL)
     }
-    
+
     void onQueryEvent(QueryEvent event) {
         if (responderAddress.containsKey(event.searchEvent.uuid)) {
             log.info("Dropping duplicate search uuid $event.searchEvent.uuid")
@@ -35,7 +35,7 @@ public class SearchManager {
         responderAddress.put(event.searchEvent.uuid, event)
         eventBus.publish(event.searchEvent)
     }
-    
+
     void onResultsEvent(ResultsEvent event) {
         Destination target = responderAddress.get(event.uuid)?.replyTo
         if (target == null)
@@ -46,11 +46,11 @@ public class SearchManager {
         }
         resultsSender.sendResults(event.uuid, event.results, target, event.searchEvent.oobInfohash)
     }
-    
+
     boolean hasLocalSearch(UUID uuid) {
         me.destination.equals(responderAddress.get(uuid)?.replyTo)
     }
-    
+
     private void cleanup() {
         final long now = System.currentTimeMillis()
         synchronized(responderAddress) {

core/src/main/groovy/com/muwire/core/search/UIResultEvent.groovy

@@ -14,7 +14,7 @@ class UIResultEvent extends Event {
     long size
     InfoHash infohash
     int pieceSize
-    
+
     @Override
     public String toString() {
         super.toString() + "name:$name size:$size sender:${sender.getHumanReadableName()} pieceSize $pieceSize"

core/src/main/groovy/com/muwire/core/search/UnexpectedResultsException.groovy

@@ -18,5 +18,5 @@ class UnexpectedResultsException extends Exception {
     public UnexpectedResultsException(String message) {
         super(message);
     }
-    
+
 }

core/src/main/groovy/com/muwire/core/search/UpsertEvent.groovy

@@ -7,12 +7,12 @@ import net.i2p.data.Destination
 
 class UpsertEvent extends Event {
 
-	Set<String> names
-	byte [] infoHash
-	Destination leaf
-	
-	@Override
-	public String toString() {
-		"UpsertEvent ${super.toString()} names:$names infoHash:${Base32.encode(infoHash)} leaf:${leaf.toBase32()}"
-	}
+    Set<String> names
+    byte [] infoHash
+    Destination leaf
+
+    @Override
+    public String toString() {
+        "UpsertEvent ${super.toString()} names:$names infoHash:${Base32.encode(infoHash)} leaf:${leaf.toBase32()}"
+    }
 }

core/src/main/groovy/com/muwire/core/trust/RemoteTrustList.groovy

@@ -8,19 +8,19 @@ import net.i2p.util.ConcurrentHashSet
 
 class RemoteTrustList {
     public enum Status { NEW, UPDATING, UPDATED, UPDATE_FAILED }
-    
+
     private final Persona persona
     private final Set<Persona> good, bad
     volatile long timestamp
     volatile boolean forceUpdate
     Status status = Status.NEW
-    
+
     RemoteTrustList(Persona persona) {
         this.persona = persona
         good = new ConcurrentHashSet<>()
         bad = new ConcurrentHashSet<>()
     }
-    
+
     @Override
     public boolean equals(Object o) {
         if (!(o instanceof RemoteTrustList))

core/src/main/groovy/com/muwire/core/trust/TrustEvent.groovy

@@ -5,6 +5,6 @@ import com.muwire.core.Persona
 
 class TrustEvent extends Event {
 
-	Persona persona
-	TrustLevel level
+    Persona persona
+    TrustLevel level
 }

core/src/main/groovy/com/muwire/core/trust/TrustService.groovy

@@ -11,87 +11,87 @@ import net.i2p.util.ConcurrentHashSet
 
 class TrustService extends Service {
 
-	final File persistGood, persistBad
-	final long persistInterval
-	
-	final Map<Destination, Persona> good = new ConcurrentHashMap<>()
-	final Map<Destination, Persona> bad = new ConcurrentHashMap<>()
-	
-	final Timer timer
-	
-	TrustService() {}
-	
-	TrustService(File persistGood, File persistBad, long persistInterval) {
-		this.persistBad = persistBad
-		this.persistGood = persistGood
-		this.persistInterval = persistInterval
-		this.timer = new Timer("trust-persister",true)
-	}
-	
-	void start() {
-		timer.schedule({load()} as TimerTask, 1)
-	}
-	
-	void stop() {
-		timer.cancel()
-	}
-	
-	void load() {
-		if (persistGood.exists()) {
-			persistGood.eachLine {
+    final File persistGood, persistBad
+    final long persistInterval
+
+    final Map<Destination, Persona> good = new ConcurrentHashMap<>()
+    final Map<Destination, Persona> bad = new ConcurrentHashMap<>()
+
+    final Timer timer
+
+    TrustService() {}
+
+    TrustService(File persistGood, File persistBad, long persistInterval) {
+        this.persistBad = persistBad
+        this.persistGood = persistGood
+        this.persistInterval = persistInterval
+        this.timer = new Timer("trust-persister",true)
+    }
+
+    void start() {
+        timer.schedule({load()} as TimerTask, 1)
+    }
+
+    void stop() {
+        timer.cancel()
+    }
+
+    void load() {
+        if (persistGood.exists()) {
+            persistGood.eachLine {
                 byte [] decoded = Base64.decode(it)
                 Persona persona = new Persona(new ByteArrayInputStream(decoded))
-				good.put(persona.destination, persona)
-			}
-		}
-		if (persistBad.exists()) {
-			persistBad.eachLine {
+                good.put(persona.destination, persona)
+            }
+        }
+        if (persistBad.exists()) {
+            persistBad.eachLine {
                 byte [] decoded = Base64.decode(it)
                 Persona persona = new Persona(new ByteArrayInputStream(decoded))
                 bad.put(persona.destination, persona)
-			}
-		}
-		timer.schedule({persist()} as TimerTask, persistInterval, persistInterval)
-		loaded = true
-	}
-	
-	private void persist() {
-		persistGood.delete()
-		persistGood.withPrintWriter { writer ->
-			good.each {k,v ->
-				writer.println v.toBase64()
-			}
-		}
-		persistBad.delete()
-		persistBad.withPrintWriter { writer ->
-			bad.each { k,v ->
-				writer.println v.toBase64()
-			}
-		}
-	}
-	
-	TrustLevel getLevel(Destination dest) {
-		if (good.containsKey(dest))
-			return TrustLevel.TRUSTED
-		else if (bad.containsKey(dest))
-			return TrustLevel.DISTRUSTED
-		TrustLevel.NEUTRAL
-	}
-	
-	void onTrustEvent(TrustEvent e) {
-		switch(e.level) {
-			case TrustLevel.TRUSTED:
-				bad.remove(e.persona.destination)
-				good.put(e.persona.destination, e.persona)
-				break
-			case TrustLevel.DISTRUSTED:
-				good.remove(e.persona.destination)
-				bad.put(e.persona.destination, e.persona)
-				break
-			case TrustLevel.NEUTRAL:
-				good.remove(e.persona.destination)
-				bad.remove(e.persona.destination)
-				break
-		}
-	}
+            }
+        }
+        timer.schedule({persist()} as TimerTask, persistInterval, persistInterval)
+        loaded = true
+    }
+
+    private void persist() {
+        persistGood.delete()
+        persistGood.withPrintWriter { writer ->
+            good.each {k,v ->
+                writer.println v.toBase64()
+            }
+        }
+        persistBad.delete()
+        persistBad.withPrintWriter { writer ->
+            bad.each { k,v ->
+                writer.println v.toBase64()
+            }
+        }
+    }
+
+    TrustLevel getLevel(Destination dest) {
+        if (good.containsKey(dest))
+            return TrustLevel.TRUSTED
+        else if (bad.containsKey(dest))
+            return TrustLevel.DISTRUSTED
+        TrustLevel.NEUTRAL
+    }
+
+    void onTrustEvent(TrustEvent e) {
+        switch(e.level) {
+            case TrustLevel.TRUSTED:
+                bad.remove(e.persona.destination)
+                good.put(e.persona.destination, e.persona)
+                break
+            case TrustLevel.DISTRUSTED:
+                good.remove(e.persona.destination)
+                bad.put(e.persona.destination, e.persona)
+                break
+            case TrustLevel.NEUTRAL:
+                good.remove(e.persona.destination)
+                bad.remove(e.persona.destination)
+                break
+        }
+    }
 }

core/src/main/groovy/com/muwire/core/trust/TrustSubscriber.groovy

@@ -22,32 +22,32 @@ class TrustSubscriber {
     private final EventBus eventBus
     private final I2PConnector i2pConnector
     private final MuWireSettings settings
-    
+
     private final Map<Destination, RemoteTrustList> remoteTrustLists = new ConcurrentHashMap<>()
 
     private final Object waitLock = new Object()
     private volatile boolean shutdown
-    private volatile Thread thread    
+    private volatile Thread thread
     private final ExecutorService updateThreads = Executors.newCachedThreadPool()
-    
+
     TrustSubscriber(EventBus eventBus, I2PConnector i2pConnector, MuWireSettings settings) {
         this.eventBus = eventBus
         this.i2pConnector = i2pConnector
         this.settings = settings
     }
-    
+
     void onUILoadedEvent(UILoadedEvent e) {
         thread = new Thread({checkLoop()} as Runnable, "trust-subscriber")
         thread.setDaemon(true)
         thread.start()
     }
-    
+
     void stop() {
         shutdown = true
         thread?.interrupt()
         updateThreads.shutdownNow()
     }
-    
+
     void onTrustSubscriptionEvent(TrustSubscriptionEvent e) {
         if (!e.subscribe) {
             remoteTrustLists.remove(e.persona.destination)
@@ -59,7 +59,7 @@ class TrustSubscriber {
             }
         }
     }
-    
+
     private void checkLoop() {
         try {
             while(!shutdown) {
@@ -82,15 +82,15 @@ class TrustSubscriber {
                 throw e
         }
     }
-    
+
     private class UpdateJob implements Runnable {
-        
+
         private final RemoteTrustList trustList
-        
+
         UpdateJob(RemoteTrustList trustList) {
             this.trustList = trustList
         }
-        
+
         public void run() {
             trustList.status = RemoteTrustList.Status.UPDATING
             eventBus.publish(new TrustSubscriptionUpdatedEvent(trustList : trustList))
@@ -111,44 +111,44 @@ class TrustSubscriber {
             InputStream is = endpoint.getInputStream()
             os.write("TRUST\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
             os.flush()
-            
+
             String codeString = DataUtil.readTillRN(is)
             int space = codeString.indexOf(' ')
             if (space > 0)
                 codeString = codeString.substring(0,space)
             int code = Integer.parseInt(codeString.trim())
-            
+
             if (code != 200) {
                 log.info("couldn't fetch trust list, code $code")
                 return false
             }
-            
+
             // swallow any headers
             String header
             while (( header = DataUtil.readTillRN(is)) != "");
-            
+
             DataInputStream dis = new DataInputStream(is)
-            
+
             Set<Persona> good = new HashSet<>()
             int nGood = dis.readUnsignedShort()
             for (int i = 0; i < nGood; i++) {
                 Persona p = new Persona(dis)
                 good.add(p)
             }
-            
+
             Set<Persona> bad = new HashSet<>()
             int nBad = dis.readUnsignedShort()
             for (int i = 0; i < nBad; i++) {
                 Persona p = new Persona(dis)
                 bad.add(p)
             }
-            
+
             trustList.timestamp = now
             trustList.good.clear()
             trustList.good.addAll(good)
             trustList.bad.clear()
             trustList.bad.addAll(bad)
-            
+
             return true
         } catch (Exception e) {
             log.log(Level.WARNING,"exception fetching trust list from ${trustList.persona.getHumanReadableName()}",e)
@@ -156,6 +156,6 @@ class TrustSubscriber {
         } finally {
             endpoint?.close()
         }
-        
+
     }
 }

core/src/main/groovy/com/muwire/core/update/UpdateClient.groovy

@@ -32,15 +32,15 @@ class UpdateClient {
     final MuWireSettings settings
     final FileManager fileManager
     final Persona me
-    
+
     private final Timer timer
-    
+
     private long lastUpdateCheckTime
-    
+
     private volatile InfoHash updateInfoHash
     private volatile String version, signer
     private volatile boolean updateDownloading
-    
+
     UpdateClient(EventBus eventBus, I2PSession session, String myVersion, MuWireSettings settings, FileManager fileManager, Persona me) {
         this.eventBus = eventBus
         this.session = session
@@ -50,16 +50,16 @@ class UpdateClient {
         this.me = me
         timer = new Timer("update-client",true)
     }
-    
+
     void start() {
         session.addMuxedSessionListener(new Listener(), I2PSession.PROTO_DATAGRAM, 2)
         timer.schedule({checkUpdate()} as TimerTask, 60000, 60 * 60 * 1000)
     }
-    
+
     void stop() {
         timer.cancel()
     }
-    
+
     void onUIResultBatchEvent(UIResultBatchEvent results) {
         if (results.results[0].infohash != updateInfoHash)
             return
@@ -70,14 +70,14 @@ class UpdateClient {
         def downloadEvent = new UIDownloadEvent(result: results.results[0], sources : results.results[0].sources, target : file)
         eventBus.publish(downloadEvent)
     }
- 
+
     void onFileDownloadedEvent(FileDownloadedEvent e) {
         if (e.downloadedFile.infoHash != updateInfoHash)
             return
         updateDownloading = false
         eventBus.publish(new UpdateDownloadedEvent(version : version, signer : signer))
     }
-    
+
     private void checkUpdate() {
         final long now = System.currentTimeMillis()
         if (lastUpdateCheckTime > 0) {
@@ -85,20 +85,20 @@ class UpdateClient {
                 return
         }
         lastUpdateCheckTime = now
-    
+
         log.info("checking for update")
-        
+
         def ping = [version : 1, myVersion : myVersion]
         ping = JsonOutput.toJson(ping)
         def maker = new I2PDatagramMaker(session)
         ping = maker.makeI2PDatagram(ping.bytes)
-        def options = new SendMessageOptions() 
+        def options = new SendMessageOptions()
         options.setSendLeaseSet(true)
-        session.sendMessage(UpdateServers.UPDATE_SERVER, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 2, 0, options)   
+        session.sendMessage(UpdateServers.UPDATE_SERVER, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 2, 0, options)
     }
-    
+
     class Listener implements I2PSessionMuxedListener {
-        
+
         final JsonSlurper slurper = new JsonSlurper()
 
         @Override
@@ -111,7 +111,7 @@ class UpdateClient {
                 log.warning "Received unexpected protocol $proto"
                 return
             }
-            
+
             def payload = session.receiveMessage(msgId)
             def dissector = new I2PDatagramDissector()
             try {
@@ -121,33 +121,33 @@ class UpdateClient {
                     log.warning("received something not from update server " + sender.toBase32())
                     return
                 }
-                
+
                 log.info("Received something from update server")
-                
+
                 payload = dissector.getPayload()
                 payload = slurper.parse(payload)
-                
+
                 if (payload.version == null) {
                     log.warning("version missing")
                     return
                 }
-                
+
                 if (payload.signer == null) {
                     log.warning("signer missing")
                 }
-                
+
                 if (VersionComparator.comp(myVersion, payload.version) >= 0) {
                     log.info("no new version available")
                     return
                 }
-                
+
                 String infoHash
                 if (settings.updateType == "jar") {
                     infoHash = payload.infoHash
                 } else
                     infoHash = payload[settings.updateType]
-                
-              
+
+
                 if (!settings.autoDownloadUpdate) {
                     log.info("new version $payload.version available, publishing event")
                     eventBus.publish(new UpdateAvailableEvent(version : payload.version, signer : payload.signer, infoHash : infoHash))
@@ -167,7 +167,7 @@ class UpdateClient {
                         eventBus.publish(queryEvent)
                     }
                 }
-                
+
             } catch (Exception e) {
                 log.log(Level.WARNING,"Invalid datagram",e)
             }
@@ -186,6 +186,6 @@ class UpdateClient {
         public void errorOccurred(I2PSession session, String message, Throwable error) {
             log.log(Level.SEVERE, message, error)
         }
-        
+
     }
 }

core/src/main/groovy/com/muwire/core/upload/ContentUploader.groovy

@@ -15,12 +15,12 @@ import com.muwire.core.util.DataUtil
 import net.i2p.data.Destination
 
 class ContentUploader extends Uploader {
-    
+
     private final File file
     private final ContentRequest request
     private final Mesh mesh
     private final int pieceSize
-    
+
     ContentUploader(File file, ContentRequest request, Endpoint endpoint, Mesh mesh, int pieceSize) {
         super(endpoint)
         this.file = file
@@ -28,7 +28,7 @@ class ContentUploader extends Uploader {
         this.mesh = mesh
         this.pieceSize = pieceSize
     }
-    
+
     @Override
     void respond() {
         OutputStream os = endpoint.getOutputStream()
@@ -55,7 +55,7 @@ class ContentUploader extends Uploader {
         os.write("Content-Range: $range.start-$range.end\r\n".getBytes(StandardCharsets.US_ASCII))
         writeMesh(request.downloader)
         os.write("\r\n".getBytes(StandardCharsets.US_ASCII))
-        
+
         FileChannel channel = null
         try {
             channel = Files.newByteChannel(file.toPath(), EnumSet.of(StandardOpenOption.READ))
@@ -78,12 +78,12 @@ class ContentUploader extends Uploader {
             }
         }
     }
-    
+
     private void writeMesh(Persona toExclude) {
         String xHave = DataUtil.encodeXHave(mesh.pieces.getDownloaded(), mesh.pieces.nPieces)
         endpoint.getOutputStream().write("X-Have: $xHave\r\n".getBytes(StandardCharsets.US_ASCII))
-        
-        Set<Persona> sources = mesh.getRandom(3, toExclude)
+
+        Set<Persona> sources = mesh.getRandom(9, toExclude)
         if (!sources.isEmpty()) {
             String xAlts = sources.stream().map({ it.toBase64() }).collect(Collectors.joining(","))
             endpoint.getOutputStream().write("X-Alt: $xAlts\r\n".getBytes(StandardCharsets.US_ASCII))

core/src/main/groovy/com/muwire/core/upload/HashListUploader.groovy

@@ -11,19 +11,19 @@ import net.i2p.data.Base64
 class HashListUploader extends Uploader {
     private final InfoHash infoHash
     private final HashListRequest request
-    
+
     HashListUploader(Endpoint endpoint, InfoHash infoHash, HashListRequest request) {
         super(endpoint)
         this.infoHash = infoHash
         mapped = ByteBuffer.wrap(infoHash.getHashList())
         this.request = request
     }
-    
+
     void respond() {
         OutputStream os = endpoint.getOutputStream()
         os.write("200 OK\r\n".getBytes(StandardCharsets.US_ASCII))
         os.write("Content-Range: 0-${mapped.remaining()}\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
-        
+
         byte[]tmp = new byte[0x1 << 13]
         while(mapped.hasRemaining()) {
             int start = mapped.position()
@@ -60,7 +60,7 @@ class HashListUploader extends Uploader {
     public int getTotalPieces() {
         return 1;
     }
-    
+
     @Override
     public long getTotalSize() {
         return -1;

core/src/main/groovy/com/muwire/core/upload/Range.groovy

@@ -2,7 +2,7 @@ package com.muwire.core.upload
 
 class Range {
     final long start, end
-    
+
     Range(long start, long end) {
         this.start = start
         this.end = end

core/src/main/groovy/com/muwire/core/upload/Request.groovy

@@ -12,21 +12,21 @@ import net.i2p.data.Base64
 
 @Log
 class Request {
-    
+
     private static final byte R = "\r".getBytes(StandardCharsets.US_ASCII)[0]
     private static final byte N = "\n".getBytes(StandardCharsets.US_ASCII)[0]
-    
+
     InfoHash infoHash
     Persona downloader
     Map<String, String> headers
-    
+
     static Request parseContentRequest(InfoHash infoHash, InputStream is) throws IOException {
-        
+
         Map<String, String> headers = parseHeaders(is)
-        
+
         if (!headers.containsKey("Range"))
             throw new IOException("Range header not found")
-            
+
         String range = headers.get("Range").trim()
         String[] split = range.split("-")
         if (split.length != 2)
@@ -39,26 +39,26 @@ class Request {
         } catch (NumberFormatException nfe) {
             throw new IOException(nfe)
         }
-        
+
         if (start < 0 || end < start)
             throw new IOException("Invalid range $start - $end")
-        
+
         Persona downloader = null
         if (headers.containsKey("X-Persona")) {
             def encoded = headers["X-Persona"].trim()
             def decoded = Base64.decode(encoded)
             downloader = new Persona(new ByteArrayInputStream(decoded))
         }
-        
+
         int have = 0
         if (headers.containsKey("X-Have")) {
             def encoded = headers["X-Have"].trim()
             have = DataUtil.decodeXHave(encoded).size()
         }
-        new ContentRequest( infoHash : infoHash, range : new Range(start, end), 
+        new ContentRequest( infoHash : infoHash, range : new Range(start, end),
             headers : headers, downloader : downloader, have : have)
     }
-    
+
     static Request parseHashListRequest(InfoHash infoHash, InputStream is) throws IOException {
         Map<String,String> headers = parseHeaders(is)
         Persona downloader = null
@@ -69,7 +69,7 @@ class Request {
         }
         new HashListRequest(infoHash : infoHash, headers : headers, downloader : downloader)
     }
-    
+
     private static Map<String, String> parseHeaders(InputStream is) {
         Map<String,String> headers = new HashMap<>()
         byte [] tmp = new byte[Constants.MAX_HEADER_SIZE]
@@ -81,7 +81,7 @@ class Request {
                 byte read = is.read()
                 if (read == -1)
                     throw new IOException("Stream closed")
-                    
+
                 if (!r && read == N)
                     throw new IOException("Received N before R")
                 if (read == R) {
@@ -90,7 +90,7 @@ class Request {
                     r = true
                     continue
                 }
-                
+
                 if (r && !n) {
                     if (read != N)
                         throw new IOException("R not followed by N")
@@ -101,13 +101,13 @@ class Request {
                     throw new IOException("Header too long")
                 tmp[idx++] = read
             }
-            
+
             if (idx == 0)
                 break
-                
+
             String header = new String(tmp, 0, idx, StandardCharsets.US_ASCII)
             log.fine("Read header $header")
-            
+
             int keyIdx = header.indexOf(":")
             if (keyIdx < 1)
                 throw new IOException("Header key not found")
@@ -119,5 +119,5 @@ class Request {
         }
         headers
     }
-    
+
 }

core/src/main/groovy/com/muwire/core/upload/UploadManager.groovy

@@ -22,17 +22,17 @@ public class UploadManager {
     private final FileManager fileManager
     private final MeshManager meshManager
     private final DownloadManager downloadManager
-    
+
     public UploadManager() {}
-    
-    public UploadManager(EventBus eventBus, FileManager fileManager, 
+
+    public UploadManager(EventBus eventBus, FileManager fileManager,
         MeshManager meshManager, DownloadManager downloadManager) {
         this.eventBus = eventBus
         this.fileManager = fileManager
         this.meshManager = meshManager
         this.downloadManager = downloadManager
     }
-    
+
     public void processGET(Endpoint e) throws IOException {
         byte [] infoHashStringBytes = new byte[44]
         DataInputStream dis = new DataInputStream(e.getInputStream())
@@ -79,10 +79,10 @@ public class UploadManager {
                 e.close()
                 return
             }
-            
-            if (request.have > 0) 
+
+            if (request.have > 0)
                 eventBus.publish(new SourceDiscoveredEvent(infoHash : request.infoHash, source : request.downloader))
-            
+
             Mesh mesh
             File file
             int pieceSize
@@ -96,7 +96,7 @@ public class UploadManager {
                 file = sharedFile.file
                 pieceSize = sharedFile.pieceSize
             }
-                
+
             Uploader uploader = new ContentUploader(file, request, e, mesh, pieceSize)
             eventBus.publish(new UploadEvent(uploader : uploader))
             try {
@@ -106,14 +106,14 @@ public class UploadManager {
             }
         }
     }
-    
+
     public void processHashList(Endpoint e) {
         byte [] infoHashStringBytes = new byte[44]
         DataInputStream dis = new DataInputStream(e.getInputStream())
         dis.readFully(infoHashStringBytes)
         String infoHashString = new String(infoHashStringBytes, StandardCharsets.US_ASCII)
         log.info("Responding to hashlist request for root $infoHashString")
-        
+
         byte [] infoHashRoot = Base64.decode(infoHashString)
         InfoHash infoHash = new InfoHash(infoHashRoot)
         Downloader downloader = downloadManager.downloaders.get(infoHash)
@@ -125,7 +125,7 @@ public class UploadManager {
             e.close()
             return
         }
-        
+
         byte [] rn = new byte[2]
         dis.readFully(rn)
         if (rn != "\r\n".getBytes(StandardCharsets.US_ASCII)) {
@@ -133,14 +133,14 @@ public class UploadManager {
             e.close()
             return
         }
-        
+
         Request request = Request.parseHashListRequest(infoHash, e.getInputStream())
         if (request.downloader != null && request.downloader.destination != e.destination) {
             log.info("Downloader persona doesn't match their destination")
             e.close()
             return
         }
-        
+
         InfoHash fullInfoHash
         if (downloader == null) {
             fullInfoHash = sharedFiles.iterator().next().infoHash
@@ -156,7 +156,7 @@ public class UploadManager {
                 return
             }
         }
-        
+
         Uploader uploader = new HashListUploader(e, fullInfoHash, request)
         eventBus.publish(new UploadEvent(uploader : uploader))
         try {
@@ -164,7 +164,7 @@ public class UploadManager {
         } finally {
             eventBus.publish(new UploadFinishedEvent(uploader : uploader))
         }
-        
+
         // proceed with content
         while(true) {
             byte[] get = new byte[4]
@@ -204,10 +204,10 @@ public class UploadManager {
                 e.close()
                 return
             }
-            
+
             if (request.have > 0)
                 eventBus.publish(new SourceDiscoveredEvent(infoHash : request.infoHash, source : request.downloader))
-            
+
             Mesh mesh
             File file
             int pieceSize

core/src/main/groovy/com/muwire/core/upload/Uploader.groovy

@@ -11,31 +11,31 @@ import com.muwire.core.connection.Endpoint
 abstract class Uploader {
     protected final Endpoint endpoint
     protected ByteBuffer mapped
-    
+
     Uploader(Endpoint endpoint) {
         this.endpoint = endpoint
     }
-    
+
     abstract void respond()
-        
+
     public synchronized int getPosition() {
         if (mapped == null)
             return -1
         mapped.position()
     }
-    
+
     abstract String getName();
-    
+
     /**
      * @return an integer between 0 and 100
      */
     abstract int getProgress();
-    
+
     abstract String getDownloader();
-    
+
     abstract int getDonePieces();
-    
+
     abstract int getTotalPieces();
-    
+
     abstract long getTotalSize();
 }

core/src/main/groovy/com/muwire/core/util/DataUtil.groovy

@@ -10,42 +10,42 @@ import com.muwire.core.Constants
 import net.i2p.data.Base64
 
 class DataUtil {
-	
-	private final static int MAX_SHORT = (0x1 << 16) - 1
 
-	static void writeUnsignedShort(int value, OutputStream os) {
-		if (value > MAX_SHORT || value < 0)
-			throw new IllegalArgumentException("$value invalid")
-		
-		byte lsb = (byte) (value & 0xFF)
-		byte msb = (byte) (value >> 8)
-		
-		os.write(msb)
-		os.write(lsb)	
-	}
-	
-	private final static int MAX_HEADER = 0x7FFFFF
-	
-	static void packHeader(int length, byte [] header) {
-		if (header.length != 3)
-			throw new IllegalArgumentException("header length $header.length")
-		if (length < 0 || length > MAX_HEADER)
-			throw new IllegalArgumentException("length $length")
-		
-		header[2] = (byte) (length & 0xFF)
-		header[1] = (byte) ((length >> 8) & 0xFF)
-		header[0] = (byte) ((length >> 16) & 0x7F)
-	}
-	
-	static int readLength(byte [] header) {
-		if (header.length != 3)
-			throw new IllegalArgumentException("header length $header.length")
-			
-		return (((int)(header[0] & 0x7F)) << 16) |
-				(((int)(header[1] & 0xFF) << 8)) |
-				((int)header[2] & 0xFF)
-	}
-    
+    private final static int MAX_SHORT = (0x1 << 16) - 1
+
+    static void writeUnsignedShort(int value, OutputStream os) {
+        if (value > MAX_SHORT || value < 0)
+            throw new IllegalArgumentException("$value invalid")
+
+        byte lsb = (byte) (value & 0xFF)
+        byte msb = (byte) (value >> 8)
+
+        os.write(msb)
+        os.write(lsb)
+    }
+
+    private final static int MAX_HEADER = 0x7FFFFF
+
+    static void packHeader(int length, byte [] header) {
+        if (header.length != 3)
+            throw new IllegalArgumentException("header length $header.length")
+        if (length < 0 || length > MAX_HEADER)
+            throw new IllegalArgumentException("length $length")
+
+        header[2] = (byte) (length & 0xFF)
+        header[1] = (byte) ((length >> 8) & 0xFF)
+        header[0] = (byte) ((length >> 16) & 0x7F)
+    }
+
+    static int readLength(byte [] header) {
+        if (header.length != 3)
+            throw new IllegalArgumentException("header length $header.length")
+
+        return (((int)(header[0] & 0x7F)) << 16) |
+                (((int)(header[1] & 0xFF) << 8)) |
+                ((int)header[2] & 0xFF)
+    }
+
     static String readi18nString(byte [] encoded) {
         if (encoded.length < 2)
             throw new IllegalArgumentException("encoding too short $encoded.length")
@@ -54,9 +54,9 @@ class DataUtil {
             throw new IllegalArgumentException("encoding doesn't match length, expected $length found $encoded.length")
         byte [] string = new byte[length]
         System.arraycopy(encoded, 2, string, 0, length)
-        new String(string, StandardCharsets.UTF_8) 
+        new String(string, StandardCharsets.UTF_8)
     }
-    
+
     static byte[] encodei18nString(String string) {
         byte [] utf8 = string.getBytes(StandardCharsets.UTF_8)
         if (utf8.length > Short.MAX_VALUE)
@@ -64,11 +64,11 @@ class DataUtil {
         def baos = new ByteArrayOutputStream()
         def daos = new DataOutputStream(baos)
         daos.writeShort((short) utf8.length)
-        daos.write(utf8) 
+        daos.write(utf8)
         daos.close()
         baos.toByteArray()
     }
-    
+
     public static String readTillRN(InputStream is) {
         def baos = new ByteArrayOutputStream()
         while(baos.size() < (Constants.MAX_HEADER_SIZE)) {
@@ -84,7 +84,7 @@ class DataUtil {
         }
         new String(baos.toByteArray(), StandardCharsets.US_ASCII)
     }
-    
+
     public static String encodeXHave(List<Integer> pieces, int totalPieces) {
         int bytes = totalPieces / 8
         if (totalPieces % 8 != 0)
@@ -98,7 +98,7 @@ class DataUtil {
         }
         Base64.encode(raw)
     }
-    
+
     public static List<Integer> decodeXHave(String xHave) {
         byte [] availablePieces = Base64.decode(xHave)
         List<Integer> available = new ArrayList<>()
@@ -112,19 +112,19 @@ class DataUtil {
         }
         available
     }
-    
+
     public static Exception findRoot(Exception e) {
         while(e.getCause() != null)
             e = e.getCause()
         e
     }
-    
+
     public static void tryUnmap(ByteBuffer cb) {
         if (cb==null || !cb.isDirect()) return;
         // we could use this type cast and call functions without reflection code,
         // but static import from sun.* package is risky for non-SUN virtual machine.
         //try { ((sun.nio.ch.DirectBuffer)cb).cleaner().clean(); } catch (Exception ex) { }
-    
+
         // JavaSpecVer: 1.6, 1.7, 1.8, 9, 10
         boolean isOldJDK = System.getProperty("java.specification.version","99").startsWith("1.");
         try {

core/src/main/groovy/com/muwire/core/util/JULLog.groovy

@@ -16,10 +16,10 @@ class JULLog extends Log {
         I2P_TO_JUL.put(Log.ERROR, Level.SEVERE)
         I2P_TO_JUL.put(Log.CRIT, Level.SEVERE)
     }
-    
+
     private final Logger delegate
     private final Level level
-    
+
     public JULLog(Class<?> cls) {
         super(cls)
         delegate = Logger.getLogger(cls.getName())
@@ -31,7 +31,7 @@ class JULLog extends Log {
         delegate = Logger.getLogger(name)
         level = findLevel(delegate)
     }
-    
+
     private static Level findLevel(Logger log) {
         while (log.getLevel() == null)
             log = log.getParent()

core/src/main/groovy/com/muwire/core/util/MuWireLogManager.groovy

@@ -5,14 +5,14 @@ import net.i2p.util.Log
 import net.i2p.util.LogManager
 
 class MuWireLogManager extends LogManager {
-    
+
     private static final Map<Class<?>, Log> classLogs = new HashMap<>()
     private static final Map<String, Log> stringLogs = new HashMap<>()
-    
+
     MuWireLogManager() {
         super(I2PAppContext.getGlobalContext())
     }
-    
+
 
     @Override
     public synchronized Log getLog(Class<?> cls, String name) {
@@ -24,7 +24,7 @@ class MuWireLogManager extends LogManager {
             }
             return rv
         }
-        
+
         Log rv = stringLogs.get(name)
         if (rv == null) {
             rv = new JULLog(name)
@@ -32,5 +32,5 @@ class MuWireLogManager extends LogManager {
         }
         rv
     }
-    
+
 }

core/src/main/java/com/muwire/core/DownloadedFile.java

@@ -7,17 +7,17 @@ import java.util.Set;
 import net.i2p.data.Destination;
 
 public class DownloadedFile extends SharedFile {
-	
-	private final Set<Destination> sources;
 
-	public DownloadedFile(File file, InfoHash infoHash, int pieceSize, Set<Destination> sources) 
-	throws IOException {
-		super(file, infoHash, pieceSize);
-		this.sources = sources;
-	}
-	
-	public Set<Destination> getSources() {
-		return sources;
-	}
+    private final Set<Destination> sources;
+
+    public DownloadedFile(File file, InfoHash infoHash, int pieceSize, Set<Destination> sources)
+    throws IOException {
+        super(file, infoHash, pieceSize);
+        this.sources = sources;
+    }
+
+    public Set<Destination> getSources() {
+        return sources;
+    }
 
 }

core/src/main/java/com/muwire/core/InfoHash.java

@@ -11,83 +11,83 @@ import net.i2p.data.Base64;
 
 public class InfoHash {
 
-	public static final int SIZE = 0x1 << 5;
-	
-	private final byte[] root;
-	private final byte[] hashList;
-	
-	private final int hashCode;
-	
-	public InfoHash(byte[] root, byte[] hashList) {
-		if (root.length != SIZE)
-			throw new IllegalArgumentException("invalid root size "+root.length);
-		if (hashList != null && hashList.length % SIZE != 0) 
-			throw new IllegalArgumentException("invalid hashList size " + hashList.length);
-		this.root = root;
-		this.hashList = hashList;
-		hashCode = root[0] << 24 |
-				root[1] << 16 |
-				root[2] << 8 |
-				root[3];
-	}
-	
-	public InfoHash(byte[] root) {
-		this(root, null);
-	}
-	
-	public InfoHash(String base32) {
-		this(Base32.decode(base32));
-	}
-	
-	public static InfoHash fromHashList(byte []hashList) {
-		try {
-			MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
-			byte[] root = sha256.digest(hashList);
-			return new InfoHash(root, hashList);
-		} catch (NoSuchAlgorithmException impossible) {
-			impossible.printStackTrace();
-			System.exit(1);
-		}
-		return null;
-	}
-	
-	public byte[] getRoot() {
-		return root;
-	}
-	
-	public byte[] getHashList() {
-		return hashList;
-	}
-	
-	@Override
-	public int hashCode() {
-		return hashCode;
-	}
-	
-	@Override
-	public boolean equals(Object o) {
-		if (this == o) {
-			return true;
-		}
-		if (!(o instanceof InfoHash)) {
-			return false;
-		}
-		InfoHash other = (InfoHash) o;
-		return Arrays.equals(root, other.root);
-	}
-	
-	public String toString() {
-		String rv = "InfoHash[root:"+Base64.encode(root) + " hashList:";
-		List<String> b64HashList = new ArrayList<>();
-		if (hashList != null) {       
-		    byte [] tmp = new byte[SIZE];
-		    for (int i = 0; i < hashList.length / SIZE; i++) {
-		        System.arraycopy(hashList, SIZE * i, tmp, 0, SIZE);
-		        b64HashList.add(Base64.encode(tmp));
-		    }
-		}
-		rv += b64HashList.toString();
-		rv += "]";
-		return rv;
-	}
+    public static final int SIZE = 0x1 << 5;
+
+    private final byte[] root;
+    private final byte[] hashList;
+
+    private final int hashCode;
+
+    public InfoHash(byte[] root, byte[] hashList) {
+        if (root.length != SIZE)
+            throw new IllegalArgumentException("invalid root size "+root.length);
+        if (hashList != null && hashList.length % SIZE != 0)
+            throw new IllegalArgumentException("invalid hashList size " + hashList.length);
+        this.root = root;
+        this.hashList = hashList;
+        hashCode = root[0] << 24 |
+                root[1] << 16 |
+                root[2] << 8 |
+                root[3];
+    }
+
+    public InfoHash(byte[] root) {
+        this(root, null);
+    }
+
+    public InfoHash(String base32) {
+        this(Base32.decode(base32));
+    }
+
+    public static InfoHash fromHashList(byte []hashList) {
+        try {
+            MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
+            byte[] root = sha256.digest(hashList);
+            return new InfoHash(root, hashList);
+        } catch (NoSuchAlgorithmException impossible) {
+            impossible.printStackTrace();
+            System.exit(1);
+        }
+        return null;
+    }
+
+    public byte[] getRoot() {
+        return root;
+    }
+
+    public byte[] getHashList() {
+        return hashList;
+    }
+
+    @Override
+    public int hashCode() {
+        return hashCode;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof InfoHash)) {
+            return false;
+        }
+        InfoHash other = (InfoHash) o;
+        return Arrays.equals(root, other.root);
+    }
+
+    public String toString() {
+        String rv = "InfoHash[root:"+Base64.encode(root) + " hashList:";
+        List<String> b64HashList = new ArrayList<>();
+        if (hashList != null) {
+            byte [] tmp = new byte[SIZE];
+            for (int i = 0; i < hashList.length / SIZE; i++) {
+                System.arraycopy(hashList, SIZE * i, tmp, 0, SIZE);
+                b64HashList.add(Base64.encode(tmp));
+            }
+        }
+        rv += b64HashList.toString();
+        rv += "]";
+        return rv;
+    }
 }

core/src/main/java/com/muwire/core/SharedFile.java

@@ -5,60 +5,60 @@ import java.io.IOException;
 
 public class SharedFile {
 
-	private final File file;
-	private final InfoHash infoHash;
-	private final int pieceSize;
-	
-	private final String cachedPath;
-	private final long cachedLength;
-	
-	public SharedFile(File file, InfoHash infoHash, int pieceSize) throws IOException {
-		this.file = file;
-		this.infoHash = infoHash;
-		this.pieceSize = pieceSize;
-		this.cachedPath = file.getAbsolutePath();
-		this.cachedLength = file.length();
-	}
+    private final File file;
+    private final InfoHash infoHash;
+    private final int pieceSize;
 
-	public File getFile() {
-		return file;
-	}
+    private final String cachedPath;
+    private final long cachedLength;
 
-	public InfoHash getInfoHash() {
-		return infoHash;
-	}
-	
-	public int getPieceSize() {
-	    return pieceSize;
-	}
-	
-	public int getNPieces() {
-	    long length = file.length();
-	    int rawPieceSize = 0x1 << pieceSize;
-	    int rv = (int) (length / rawPieceSize);
-	    if (length % rawPieceSize != 0)
-	        rv++;
-	    return rv;
-	}
-	
-	public String getCachedPath() {
-	    return cachedPath;
-	}
-	
-	public long getCachedLength() {
-	    return cachedLength;
-	}
-	
-	@Override
-	public int hashCode() {
-	    return file.hashCode() ^ infoHash.hashCode();
-	}
-	
-	@Override
-	public boolean equals(Object o) {
-	    if (!(o instanceof SharedFile))
-	        return false;
-	    SharedFile other = (SharedFile)o;
-	    return file.equals(other.file) && infoHash.equals(other.infoHash);
-	}
+    public SharedFile(File file, InfoHash infoHash, int pieceSize) throws IOException {
+        this.file = file;
+        this.infoHash = infoHash;
+        this.pieceSize = pieceSize;
+        this.cachedPath = file.getAbsolutePath();
+        this.cachedLength = file.length();
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public InfoHash getInfoHash() {
+        return infoHash;
+    }
+
+    public int getPieceSize() {
+        return pieceSize;
+    }
+
+    public int getNPieces() {
+        long length = file.length();
+        int rawPieceSize = 0x1 << pieceSize;
+        int rv = (int) (length / rawPieceSize);
+        if (length % rawPieceSize != 0)
+            rv++;
+        return rv;
+    }
+
+    public String getCachedPath() {
+        return cachedPath;
+    }
+
+    public long getCachedLength() {
+        return cachedLength;
+    }
+
+    @Override
+    public int hashCode() {
+        return file.hashCode() ^ infoHash.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof SharedFile))
+            return false;
+        SharedFile other = (SharedFile)o;
+        return file.equals(other.file) && infoHash.equals(other.infoHash);
+    }
 }

core/src/main/java/com/muwire/core/connection/ConnectionAttemptStatus.java

@@ -1,5 +1,5 @@
 package com.muwire.core.connection;
 
 public enum ConnectionAttemptStatus {
-	SUCCESSFUL, REJECTED, FAILED
+    SUCCESSFUL, REJECTED, FAILED
 }

core/src/main/java/com/muwire/core/hostcache/CrawlerResponse.java

@@ -6,5 +6,5 @@ package com.muwire.core.hostcache;
  *
  */
 public enum CrawlerResponse {
-	ALL, REGISTERED, NONE
+    ALL, REGISTERED, NONE
 }

core/src/main/java/com/muwire/core/trust/TrustLevel.java

@@ -1,5 +1,5 @@
 package com.muwire.core.trust;
 
 public enum TrustLevel {
-	TRUSTED, NEUTRAL, DISTRUSTED
+    TRUSTED, NEUTRAL, DISTRUSTED
 }

core/src/test/groovy/com/muwire/core/Destinations.groovy

@@ -4,6 +4,6 @@ import net.i2p.data.Destination
 
 class Destinations {
 
-	Destination dest1 = new Destination("KvwWPKMSAtzf7Yruj8TQaHi2jaQpSNsXJskbpmSBTxkcYlDB2GllH~QBu-cs4FSYdaRmKDUUx7793jjnYJgTMbrjqeIL5-BTORZ09n6PUfhSejDpJjdkUxaV1OHRatfYs70RNBv7rvdj1-nXUow5tMfOJtoWVocUoKefUGFQFbJLDDkBqjm1kFyKFZv6m6S6YqXxBgVB1qYicooy67cNQF5HLUFtP15pk5fMDNGz5eNCjPfC~2Gp8FF~OpSy92HT0XN7uAMJykPcbdnWfcvVwqD7eS0K4XEnsqnMPLEiMAhqsugEFiFqtB3Wmm7UHVc03lcAfRhr1e2uZBNFTtM2Uol4MD5sCCKRZVHGcH-WGPSEz0BM5YO~Xi~dQ~N3NVud32PVzhh8xoGcAlhTqMqAbRJndCv-H6NflX90pYmbirCTIDOaR9758mThrqX0d4CwCn4jFXer52l8Qe8CErGoLuB-4LL~Gwrn7R1k7ZQc2PthkqeW8MfigyiN7hZVkul9AAAA")
-	Destination dest2 = new Destination("KvwWPKMSAtzf7Yruj8TQaHi2jaQpSNsXJskbpmSBTxkcYlDB2GllH~QBu-cs4FSYdaRmKDUUx7793jjnYJgTMbrjqeIL5-BTORZ09n6PUfhSejDpJjdkUxaV1OHRatfYs70RNBv7rvdj1-nXUow5tMfOJtoWVocUoKefUGFQFbJLDDkBqjm1kFyKFZv6m6S6YqXxBgVB1qYicooy67cNQF5HLUFtP15pk5fMDNGz5eNCjPfC~2Gp8FF~OpSy92HT0XN7uAMJykPcbdnWfcvVwqD7eS0K4XEnsqnMPLEiMAhqsugEFiFqtB3Wmm7UHVc03lcAfRhr1e2uZBNFTtM2Uol4MD5sCCKRZVHGcH-WGPSEz0BM5YO~Xi~dQ~N3NVud32PVzhh8xoGcAlhTqMqAbRJndCv-H6NflX90pYmbirCTIDOaR9758mThrqX0d4CwCn4jFXer52l8Qe8CErGoLuB-4LL~Gwrn7R1k7ZQc2PthkqeW8MfigyiN7hZVkul8AAAA")
+    Destination dest1 = new Destination("KvwWPKMSAtzf7Yruj8TQaHi2jaQpSNsXJskbpmSBTxkcYlDB2GllH~QBu-cs4FSYdaRmKDUUx7793jjnYJgTMbrjqeIL5-BTORZ09n6PUfhSejDpJjdkUxaV1OHRatfYs70RNBv7rvdj1-nXUow5tMfOJtoWVocUoKefUGFQFbJLDDkBqjm1kFyKFZv6m6S6YqXxBgVB1qYicooy67cNQF5HLUFtP15pk5fMDNGz5eNCjPfC~2Gp8FF~OpSy92HT0XN7uAMJykPcbdnWfcvVwqD7eS0K4XEnsqnMPLEiMAhqsugEFiFqtB3Wmm7UHVc03lcAfRhr1e2uZBNFTtM2Uol4MD5sCCKRZVHGcH-WGPSEz0BM5YO~Xi~dQ~N3NVud32PVzhh8xoGcAlhTqMqAbRJndCv-H6NflX90pYmbirCTIDOaR9758mThrqX0d4CwCn4jFXer52l8Qe8CErGoLuB-4LL~Gwrn7R1k7ZQc2PthkqeW8MfigyiN7hZVkul9AAAA")
+    Destination dest2 = new Destination("KvwWPKMSAtzf7Yruj8TQaHi2jaQpSNsXJskbpmSBTxkcYlDB2GllH~QBu-cs4FSYdaRmKDUUx7793jjnYJgTMbrjqeIL5-BTORZ09n6PUfhSejDpJjdkUxaV1OHRatfYs70RNBv7rvdj1-nXUow5tMfOJtoWVocUoKefUGFQFbJLDDkBqjm1kFyKFZv6m6S6YqXxBgVB1qYicooy67cNQF5HLUFtP15pk5fMDNGz5eNCjPfC~2Gp8FF~OpSy92HT0XN7uAMJykPcbdnWfcvVwqD7eS0K4XEnsqnMPLEiMAhqsugEFiFqtB3Wmm7UHVc03lcAfRhr1e2uZBNFTtM2Uol4MD5sCCKRZVHGcH-WGPSEz0BM5YO~Xi~dQ~N3NVud32PVzhh8xoGcAlhTqMqAbRJndCv-H6NflX90pYmbirCTIDOaR9758mThrqX0d4CwCn4jFXer52l8Qe8CErGoLuB-4LL~Gwrn7R1k7ZQc2PthkqeW8MfigyiN7hZVkul8AAAA")
 }

core/src/test/groovy/com/muwire/core/EventBusTest.groovy

@@ -4,23 +4,23 @@ import org.junit.Test
 
 class EventBusTest {
 
-	class FakeEvent extends Event {}
-	
-	class FakeEventHandler {
-		def onFakeEvent(FakeEvent e) {
-			assert e == fakeEvent
-		}
-	}
-	
-	FakeEvent fakeEvent = new FakeEvent()
-	
-	EventBus bus = new EventBus()
-	def handler = new FakeEventHandler()
-	
-	@Test
-	void testDynamicEvent() {
-		bus.register(FakeEvent.class, handler)
-		bus.publish(fakeEvent)
-	}
+    class FakeEvent extends Event {}
+
+    class FakeEventHandler {
+        def onFakeEvent(FakeEvent e) {
+            assert e == fakeEvent
+        }
+    }
+
+    FakeEvent fakeEvent = new FakeEvent()
+
+    EventBus bus = new EventBus()
+    def handler = new FakeEventHandler()
+
+    @Test
+    void testDynamicEvent() {
+        bus.register(FakeEvent.class, handler)
+        bus.publish(fakeEvent)
+    }
 
 }

core/src/test/groovy/com/muwire/core/InfoHashTest.groovy

@@ -6,11 +6,11 @@ import org.junit.Test
 
 class InfoHashTest {
 
-	@Test
-	void testEmpty() {
-		byte [] empty = new byte[0x1 << 6];
-		def ih = InfoHash.fromHashList(empty)
-		def ih2 = new InfoHash("6ws72qwrniqdaj4y55xngcmxtnbqapjdedm7b2hktay2sj2z7nfq");
-		assertEquals(ih, ih2);
-	}
+    @Test
+    void testEmpty() {
+        byte [] empty = new byte[0x1 << 6];
+        def ih = InfoHash.fromHashList(empty)
+        def ih2 = new InfoHash("6ws72qwrniqdaj4y55xngcmxtnbqapjdedm7b2hktay2sj2z7nfq");
+        assertEquals(ih, ih2);
+    }
 }

core/src/test/groovy/com/muwire/core/Personas.groovy

@@ -5,7 +5,7 @@ import net.i2p.data.Base64
 class Personas {
     private final String encoded1 = "AQADemFiO~pgSoEo8wQfwncYMvBQWkvPY9I7DYUllHp289UE~zBaLdbl~wbliktAUsW-S70f3UeYgHq34~c7zVuUQjgHZ506iG9hX8B9S3a9gQ3CSG0GuDpeNyiXmZkpHp5m8vT9PZ1zMWzxvzZY~fP9yKFKgO4yrso5I9~DGOPeyJZJ4BFsTJDERv41aZqjFLYUBDmeHGgg9RjYy~93h-nQMVYj9JSO3AgowW-ix49rtiKYIXHMa2PxWHUXkUHWJZtIZntNIDEFeMnPdzLxjAl8so2G6pDcTMZPLLwyb73Ee5ZVfxUynPqyp~fIGVP8Rl4rlaGFli2~ATGBz3XY54aObC~0p7us2JnWaTC~oQT5DVDM7gaOO885o-m8BB8b0duzMBelbdnMZFQJ5jIHVKxkC6Niw4fxTOoXTyOqQmVhtK-9xcwxMuN5DF9IewkR5bhpq5rgnfBP5zvyBaAHMq-d3TCOjTsZ-d3liB98xX5p8G5zmS7gfKArQtM5~CcK~AlX-lGLBQAEAAcAAN5MW1Tq983szfZgY1l8tQFqy8I9tdMf7vc1Ktj~TCIvXYw6AYMbMGy3S67FSPLZVmfHEMQKj2KLAdaRKQkHPAY"
     private final String encoded2 = "AQAHemxhdGluYiN~3G-hPoBfJ04mhcC52lC6TYSwWxH-WNWno9Y35JS-WrXlnPsodZtwy96ttEaiKTg-hkRqMsaYKpWar1FwayR6qlo0pZCo5pQOLfR7GIM3~wde0JIBEp8BUpgzF1-QXLhuRG1t7tBbenW2tSgp5jQH61RI-c9flyUlOvf6nrhQMZ3aoviZ4aZW23Fx-ajYQBDk7PIxuyn8qYNwWy3kWOhGan05c54NnumS3XCzQWFDDPlADmco1WROeY9qrwwtmLM8lzDCEtJQXJlk~K5yLbyB63hmAeTK7J4iS6f9nnWv7TbB5r-Z3kC6D9TLYrQbu3h4AAxrqso45P8yHQtKUA4QJicS-6NJoBOnlCCU887wx2k9YSxxwNydlIxb1mZsX65Ke4uY0HDFokZHTzUcxvfLB6G~5JkSPDCyZz~2fREgW2-VXu7gokEdEugkuZRrsiQzyfAOOkv53ti5MzTbMOXinBskSb1vZyN2-XcZNaDJvEqUNj~qpfhe-ov2F7FuwQUABAAHAAAfqq-MneIqWBQY92-sy9Z0s~iQsq6lUFa~sYMdY-5o-94fF8a140dm-emF3rO8vuidUIPNaS-37Rl05mAKUCcB"
-    
+
     Persona persona1 = new Persona(new ByteArrayInputStream(Base64.decode(encoded1)))
     Persona persona2 = new Persona(new ByteArrayInputStream(Base64.decode(encoded2)))
 }

core/src/test/groovy/com/muwire/core/connection/ConnectionAcceptorTest.groovy

@@ -22,386 +22,386 @@ import groovy.mock.interceptor.MockFor
 
 class ConnectionAcceptorTest {
 
-	EventBus eventBus
-	final Destinations destinations = new Destinations()
-	def settings
-	
-	def connectionManagerMock
-	UltrapeerConnectionManager connectionManager
-	
-	def i2pAcceptorMock
-	I2PAcceptor i2pAcceptor
-	
-	def hostCacheMock
-	HostCache hostCache
-	
-	def trustServiceMock
-	TrustService trustService
-    
+    EventBus eventBus
+    final Destinations destinations = new Destinations()
+    def settings
+
+    def connectionManagerMock
+    UltrapeerConnectionManager connectionManager
+
+    def i2pAcceptorMock
+    I2PAcceptor i2pAcceptor
+
+    def hostCacheMock
+    HostCache hostCache
+
+    def trustServiceMock
+    TrustService trustService
+
     def searchManagerMock
     SearchManager searchManager
-    
+
     def uploadManagerMock
     UploadManager uploadManager
-    
+
     def connectionEstablisherMock
     ConnectionEstablisher connectionEstablisher
-	
-	ConnectionAcceptor acceptor
-	List<ConnectionEvent> connectionEvents
-	InputStream inputStream
-	OutputStream outputStream
-	
-	@Before
-	void before() {
-		connectionManagerMock = new MockFor(UltrapeerConnectionManager.class)
-		i2pAcceptorMock = new MockFor(I2PAcceptor.class)
-		hostCacheMock = new MockFor(HostCache.class)
-		trustServiceMock = new MockFor(TrustService.class)
+
+    ConnectionAcceptor acceptor
+    List<ConnectionEvent> connectionEvents
+    InputStream inputStream
+    OutputStream outputStream
+
+    @Before
+    void before() {
+        connectionManagerMock = new MockFor(UltrapeerConnectionManager.class)
+        i2pAcceptorMock = new MockFor(I2PAcceptor.class)
+        hostCacheMock = new MockFor(HostCache.class)
+        trustServiceMock = new MockFor(TrustService.class)
         searchManagerMock = new MockFor(SearchManager.class)
         uploadManagerMock = new MockFor(UploadManager.class)
         connectionEstablisherMock = new MockFor(ConnectionEstablisher.class)
-	}
-	
-	@After
-	void after() {
-		acceptor?.stop()
-		connectionManagerMock.verify connectionManager
-		i2pAcceptorMock.verify i2pAcceptor
-		hostCacheMock.verify hostCache
-		trustServiceMock.verify trustService
+    }
+
+    @After
+    void after() {
+        acceptor?.stop()
+        connectionManagerMock.verify connectionManager
+        i2pAcceptorMock.verify i2pAcceptor
+        hostCacheMock.verify hostCache
+        trustServiceMock.verify trustService
         searchManagerMock.verify searchManager
         uploadManagerMock.verify uploadManager
         connectionEstablisherMock.verify connectionEstablisher
-		Thread.sleep(100)
-	}
-	
-	private void initMocks() {
-		connectionEvents = new CopyOnWriteArrayList()
-		eventBus = new EventBus()
-		def listener = new Object() {
-			void onConnectionEvent(ConnectionEvent e) {
-				connectionEvents.add e
-			}
-		}
-		eventBus.register(ConnectionEvent.class, listener)
-		
-		connectionManager = connectionManagerMock.proxyInstance()
-		i2pAcceptor = i2pAcceptorMock.proxyInstance()
-		hostCache = hostCacheMock.proxyInstance()
-		trustService = trustServiceMock.proxyInstance()
+        Thread.sleep(100)
+    }
+
+    private void initMocks() {
+        connectionEvents = new CopyOnWriteArrayList()
+        eventBus = new EventBus()
+        def listener = new Object() {
+            void onConnectionEvent(ConnectionEvent e) {
+                connectionEvents.add e
+            }
+        }
+        eventBus.register(ConnectionEvent.class, listener)
+
+        connectionManager = connectionManagerMock.proxyInstance()
+        i2pAcceptor = i2pAcceptorMock.proxyInstance()
+        hostCache = hostCacheMock.proxyInstance()
+        trustService = trustServiceMock.proxyInstance()
         searchManager = searchManagerMock.proxyInstance()
         uploadManager = uploadManagerMock.proxyInstance()
         connectionEstablisher = connectionEstablisherMock.proxyInstance()
-		
-		acceptor = new ConnectionAcceptor(eventBus, connectionManager, settings, i2pAcceptor, 
+
+        acceptor = new ConnectionAcceptor(eventBus, connectionManager, settings, i2pAcceptor,
             hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
-		acceptor.start()
-		Thread.sleep(100)
-	}
-	
-	@Test
-	void testSuccessfulLeaf() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {
-				false
-			}
-		}
-		i2pAcceptorMock.demand.accept {
-			def is = new PipedInputStream()
-			outputStream = new PipedOutputStream(is)
-			def os = new PipedOutputStream()
-			inputStream = new PipedInputStream(os)
-			new Endpoint(destinations.dest1, is, os, null)
-		}
-		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        acceptor.start()
+        Thread.sleep(100)
+    }
+
+    @Test
+    void testSuccessfulLeaf() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {
+                false
+            }
+        }
+        i2pAcceptorMock.demand.accept {
+            def is = new PipedInputStream()
+            outputStream = new PipedOutputStream(is)
+            def os = new PipedOutputStream()
+            inputStream = new PipedInputStream(os)
+            new Endpoint(destinations.dest1, is, os, null)
+        }
+        i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
         connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
         }
         connectionManagerMock.demand.hasLeafSlots() { true }
-		trustServiceMock.demand.getLevel { dest ->
-			assert dest == destinations.dest1
-			TrustLevel.TRUSTED
-		}
-		
-		initMocks()
-		
-		outputStream.write("MuWire leaf".bytes)
-		byte [] OK = new byte[2]
-		def dis = new DataInputStream(inputStream)
-		dis.readFully(OK)
-		assert OK == "OK".bytes
-		
-		Thread.sleep(50)
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.status == ConnectionAttemptStatus.SUCCESSFUL
-		assert event.incoming == true
-		assert event.leaf == true
-	}
-	
-	@Test
-	void testSuccessfulPeer() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {
-				false
-			}
-		}
-		i2pAcceptorMock.demand.accept {
-			def is = new PipedInputStream()
-			outputStream = new PipedOutputStream(is)
-			def os = new PipedOutputStream()
-			inputStream = new PipedInputStream(os)
-			new Endpoint(destinations.dest1, is, os, null)
-		}
-		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        trustServiceMock.demand.getLevel { dest ->
+            assert dest == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+
+        initMocks()
+
+        outputStream.write("MuWire leaf".bytes)
+        byte [] OK = new byte[2]
+        def dis = new DataInputStream(inputStream)
+        dis.readFully(OK)
+        assert OK == "OK".bytes
+
+        Thread.sleep(50)
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.status == ConnectionAttemptStatus.SUCCESSFUL
+        assert event.incoming == true
+        assert event.leaf == true
+    }
+
+    @Test
+    void testSuccessfulPeer() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {
+                false
+            }
+        }
+        i2pAcceptorMock.demand.accept {
+            def is = new PipedInputStream()
+            outputStream = new PipedOutputStream(is)
+            def os = new PipedOutputStream()
+            inputStream = new PipedInputStream(os)
+            new Endpoint(destinations.dest1, is, os, null)
+        }
+        i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
         connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
         }
         connectionManagerMock.demand.hasPeerSlots() { true }
-		trustServiceMock.demand.getLevel { dest ->
-			assert dest == destinations.dest1
-			TrustLevel.TRUSTED
-		}
-		
-		initMocks()
-		
-		outputStream.write("MuWire peer".bytes)
-		byte [] OK = new byte[2]
-		def dis = new DataInputStream(inputStream)
-		dis.readFully(OK)
-		assert OK == "OK".bytes
-		
-		Thread.sleep(50)
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.status == ConnectionAttemptStatus.SUCCESSFUL
-		assert event.incoming == true
-		assert event.leaf == false
-	}
-	
-	@Test
-	void testLeafRejectsLeaf() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {
-				true
-			}
-		}
-		i2pAcceptorMock.demand.accept {
-			def is = new PipedInputStream()
-			outputStream = new PipedOutputStream(is)
-			def os = new PipedOutputStream()
-			inputStream = new PipedInputStream(os)
-			new Endpoint(destinations.dest1, is, os, null)
-		}
-		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
-		trustServiceMock.demand.getLevel { dest ->
-			assert dest == destinations.dest1
-			TrustLevel.TRUSTED
-		}
-		
-		initMocks()
-		
-		outputStream.write("MuWire leaf".bytes)
-		outputStream.flush()
-		Thread.sleep(50)
-		assert inputStream.read() == -1
-		
-		Thread.sleep(50)
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.status == ConnectionAttemptStatus.FAILED
-		assert event.incoming == true
-		assert event.leaf == null
-	}
-	
-	@Test
-	void testLeafRejectsPeer() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {
-				true
-			}
-		}
-		i2pAcceptorMock.demand.accept {
-			def is = new PipedInputStream()
-			outputStream = new PipedOutputStream(is)
-			def os = new PipedOutputStream()
-			inputStream = new PipedInputStream(os)
-			new Endpoint(destinations.dest1, is, os, null)
-		}
-		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
-		trustServiceMock.demand.getLevel { dest ->
-			assert dest == destinations.dest1
-			TrustLevel.TRUSTED
-		}
-		
-		initMocks()
-		
-		outputStream.write("MuWire peer".bytes)
-		outputStream.flush()
-		Thread.sleep(50)
-		assert inputStream.read() == -1
-		
-		Thread.sleep(50)
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.status == ConnectionAttemptStatus.FAILED
-		assert event.incoming == true
-		assert event.leaf == null
-	}
-	
-	@Test
-	void testPeerRejectsPeerSlots() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {
-				false
-			}
-		}
-		i2pAcceptorMock.demand.accept {
-			def is = new PipedInputStream()
-			outputStream = new PipedOutputStream(is)
-			def os = new PipedOutputStream()
-			inputStream = new PipedInputStream(os)
-			new Endpoint(destinations.dest1, is, os, null)
-		}
-		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        trustServiceMock.demand.getLevel { dest ->
+            assert dest == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+
+        initMocks()
+
+        outputStream.write("MuWire peer".bytes)
+        byte [] OK = new byte[2]
+        def dis = new DataInputStream(inputStream)
+        dis.readFully(OK)
+        assert OK == "OK".bytes
+
+        Thread.sleep(50)
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.status == ConnectionAttemptStatus.SUCCESSFUL
+        assert event.incoming == true
+        assert event.leaf == false
+    }
+
+    @Test
+    void testLeafRejectsLeaf() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {
+                true
+            }
+        }
+        i2pAcceptorMock.demand.accept {
+            def is = new PipedInputStream()
+            outputStream = new PipedOutputStream(is)
+            def os = new PipedOutputStream()
+            inputStream = new PipedInputStream(os)
+            new Endpoint(destinations.dest1, is, os, null)
+        }
+        i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        trustServiceMock.demand.getLevel { dest ->
+            assert dest == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+
+        initMocks()
+
+        outputStream.write("MuWire leaf".bytes)
+        outputStream.flush()
+        Thread.sleep(50)
+        assert inputStream.read() == -1
+
+        Thread.sleep(50)
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.status == ConnectionAttemptStatus.FAILED
+        assert event.incoming == true
+        assert event.leaf == null
+    }
+
+    @Test
+    void testLeafRejectsPeer() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {
+                true
+            }
+        }
+        i2pAcceptorMock.demand.accept {
+            def is = new PipedInputStream()
+            outputStream = new PipedOutputStream(is)
+            def os = new PipedOutputStream()
+            inputStream = new PipedInputStream(os)
+            new Endpoint(destinations.dest1, is, os, null)
+        }
+        i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        trustServiceMock.demand.getLevel { dest ->
+            assert dest == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+
+        initMocks()
+
+        outputStream.write("MuWire peer".bytes)
+        outputStream.flush()
+        Thread.sleep(50)
+        assert inputStream.read() == -1
+
+        Thread.sleep(50)
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.status == ConnectionAttemptStatus.FAILED
+        assert event.incoming == true
+        assert event.leaf == null
+    }
+
+    @Test
+    void testPeerRejectsPeerSlots() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {
+                false
+            }
+        }
+        i2pAcceptorMock.demand.accept {
+            def is = new PipedInputStream()
+            outputStream = new PipedOutputStream(is)
+            def os = new PipedOutputStream()
+            inputStream = new PipedInputStream(os)
+            new Endpoint(destinations.dest1, is, os, null)
+        }
+        i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
         connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
         }
         connectionManagerMock.demand.hasPeerSlots() { false }
-		trustServiceMock.demand.getLevel { dest ->
-			assert dest == destinations.dest1
-			TrustLevel.TRUSTED
-		}
-		hostCacheMock.ignore.getGoodHosts { n -> [] }
-		
-		initMocks()
-		
-		outputStream.write("MuWire peer".bytes)
-		byte [] OK = new byte[6]
-		def dis = new DataInputStream(inputStream)
-		dis.readFully(OK)
-		assert OK == "REJECT".bytes
-		
-		Thread.sleep(50)
-		assert dis.read() == -1
-		
-		Thread.sleep(50)
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.status == ConnectionAttemptStatus.REJECTED
-		assert event.incoming == true
-		assert event.leaf == false
-	}
-	
-	@Test
-	void testPeerRejectsLeafSlots() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {
-				false
-			}
-		}
-		i2pAcceptorMock.demand.accept {
-			def is = new PipedInputStream()
-			outputStream = new PipedOutputStream(is)
-			def os = new PipedOutputStream()
-			inputStream = new PipedInputStream(os)
-			new Endpoint(destinations.dest1, is, os, null)
-		}
-		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        trustServiceMock.demand.getLevel { dest ->
+            assert dest == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+        hostCacheMock.ignore.getGoodHosts { n -> [] }
+
+        initMocks()
+
+        outputStream.write("MuWire peer".bytes)
+        byte [] OK = new byte[6]
+        def dis = new DataInputStream(inputStream)
+        dis.readFully(OK)
+        assert OK == "REJECT".bytes
+
+        Thread.sleep(50)
+        assert dis.read() == -1
+
+        Thread.sleep(50)
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.status == ConnectionAttemptStatus.REJECTED
+        assert event.incoming == true
+        assert event.leaf == false
+    }
+
+    @Test
+    void testPeerRejectsLeafSlots() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {
+                false
+            }
+        }
+        i2pAcceptorMock.demand.accept {
+            def is = new PipedInputStream()
+            outputStream = new PipedOutputStream(is)
+            def os = new PipedOutputStream()
+            inputStream = new PipedInputStream(os)
+            new Endpoint(destinations.dest1, is, os, null)
+        }
+        i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
         connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
         }
         connectionManagerMock.demand.hasLeafSlots() { false }
-		trustServiceMock.demand.getLevel { dest ->
-			assert dest == destinations.dest1
-			TrustLevel.TRUSTED
-		}
-		hostCacheMock.ignore.getGoodHosts { n -> [] }
-		
-		initMocks()
-		
-		outputStream.write("MuWire leaf".bytes)
-		byte [] OK = new byte[6]
-		def dis = new DataInputStream(inputStream)
-		dis.readFully(OK)
-		assert OK == "REJECT".bytes
-		
-		Thread.sleep(50)
-		assert dis.read() == -1
-		
-		Thread.sleep(50)
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.status == ConnectionAttemptStatus.REJECTED
-		assert event.incoming == true
-		assert event.leaf == true
-	}
-	
-	@Test
-	void testPeerRejectsPeerSuggests() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {
-				false
-			}
-		}
-		i2pAcceptorMock.demand.accept {
-			def is = new PipedInputStream()
-			outputStream = new PipedOutputStream(is)
-			def os = new PipedOutputStream()
-			inputStream = new PipedInputStream(os)
-			new Endpoint(destinations.dest1, is, os, null)
-		}
-		i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
+        trustServiceMock.demand.getLevel { dest ->
+            assert dest == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+        hostCacheMock.ignore.getGoodHosts { n -> [] }
+
+        initMocks()
+
+        outputStream.write("MuWire leaf".bytes)
+        byte [] OK = new byte[6]
+        def dis = new DataInputStream(inputStream)
+        dis.readFully(OK)
+        assert OK == "REJECT".bytes
+
+        Thread.sleep(50)
+        assert dis.read() == -1
+
+        Thread.sleep(50)
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.status == ConnectionAttemptStatus.REJECTED
+        assert event.incoming == true
+        assert event.leaf == true
+    }
+
+    @Test
+    void testPeerRejectsPeerSuggests() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {
+                false
+            }
+        }
+        i2pAcceptorMock.demand.accept {
+            def is = new PipedInputStream()
+            outputStream = new PipedOutputStream(is)
+            def os = new PipedOutputStream()
+            inputStream = new PipedInputStream(os)
+            new Endpoint(destinations.dest1, is, os, null)
+        }
+        i2pAcceptorMock.demand.accept { Thread.sleep(Integer.MAX_VALUE) }
         connectionEstablisherMock.demand.isInProgress(destinations.dest1) { false }
         connectionManagerMock.demand.isConnected { dest ->
             assert dest == destinations.dest1
             false
         }
         connectionManagerMock.demand.hasPeerSlots() { false }
-		trustServiceMock.demand.getLevel { dest ->
-			assert dest == destinations.dest1
-			TrustLevel.TRUSTED
-		}
-		hostCacheMock.ignore.getGoodHosts { n -> [destinations.dest2] }
-		
-		initMocks()
-		
-		outputStream.write("MuWire peer".bytes)
-		byte [] OK = new byte[6]
-		def dis = new DataInputStream(inputStream)
-		dis.readFully(OK)
-		assert OK == "REJECT".bytes
-		
-		short payloadSize = dis.readUnsignedShort()
-		byte[] payload = new byte[payloadSize]
-		dis.readFully(payload)
-		assert dis.read() == -1
-		
-		def json = new JsonSlurper()
-		json = json.parse(payload)
-		assert json.tryHosts != null
-		assert json.tryHosts.size() == 1
-		assert json.tryHosts.contains(destinations.dest2.toBase64())
-		
-		Thread.sleep(50)
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.status == ConnectionAttemptStatus.REJECTED
-	}
+        trustServiceMock.demand.getLevel { dest ->
+            assert dest == destinations.dest1
+            TrustLevel.TRUSTED
+        }
+        hostCacheMock.ignore.getGoodHosts { n -> [destinations.dest2] }
+
+        initMocks()
+
+        outputStream.write("MuWire peer".bytes)
+        byte [] OK = new byte[6]
+        def dis = new DataInputStream(inputStream)
+        dis.readFully(OK)
+        assert OK == "REJECT".bytes
+
+        short payloadSize = dis.readUnsignedShort()
+        byte[] payload = new byte[payloadSize]
+        dis.readFully(payload)
+        assert dis.read() == -1
+
+        def json = new JsonSlurper()
+        json = json.parse(payload)
+        assert json.tryHosts != null
+        assert json.tryHosts.size() == 1
+        assert json.tryHosts.contains(destinations.dest2.toBase64())
+
+        Thread.sleep(50)
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.status == ConnectionAttemptStatus.REJECTED
+    }
 }

core/src/test/groovy/com/muwire/core/connection/ConnectionEstablisherTest.groovy

@@ -17,271 +17,271 @@ import groovy.mock.interceptor.MockFor
 
 class ConnectionEstablisherTest {
 
-	EventBus eventBus
-	final Destinations destinations = new Destinations()
-	List<ConnectionEvent> connectionEvents
-	List<HostDiscoveredEvent> discoveredEvents
-	DataInputStream inputStream
-	DataOutputStream outputStream
-	
-	def i2pConnectorMock
-	I2PConnector i2pConnector
-	
-	MuWireSettings settings
-	
-	def connectionManagerMock
-	ConnectionManager connectionManager
-	
-	def hostCacheMock
-	HostCache hostCache
-	
-	ConnectionEstablisher establisher
-	
-	
-	@Before
-	void before() {
-		connectionEvents = new CopyOnWriteArrayList()
-		discoveredEvents = new CopyOnWriteArrayList()
-		def listener = new Object() {
-			void onConnectionEvent(ConnectionEvent e) {
-				connectionEvents.add(e)
-			}
-			void onHostDiscoveredEvent(HostDiscoveredEvent e) {
-				discoveredEvents.add e
-			}
-		}
-		eventBus = new EventBus()
-		eventBus.register(ConnectionEvent.class, listener)
-		eventBus.register(HostDiscoveredEvent.class, listener)
-		i2pConnectorMock = new MockFor(I2PConnector.class)
-		connectionManagerMock = new MockFor(ConnectionManager.class)
-		hostCacheMock = new MockFor(HostCache.class)
-	}
-	
-	@After
-	void after() {
-		establisher?.stop()
-		i2pConnectorMock.verify i2pConnector
-		connectionManagerMock.verify connectionManager
-		hostCacheMock.verify hostCache
-		Thread.sleep(100)
-	}
-	
-	private void initMocks() {
-		i2pConnector = i2pConnectorMock.proxyInstance()
-		connectionManager = connectionManagerMock.proxyInstance()
-		hostCache = hostCacheMock.proxyInstance()
-		establisher = new ConnectionEstablisher(eventBus, i2pConnector, settings, connectionManager, hostCache)
-		establisher.start()
-		Thread.sleep(250)
-	}
-	
-	
-	@Test
-	void testConnectFails() {
-		settings = new MuWireSettings()
-		connectionManagerMock.ignore.needsConnections {
-			true 
-		}
-		hostCacheMock.ignore.getHosts { num ->
-			assert num == 1
-			[destinations.dest1]
-		}
-		connectionManagerMock.ignore.isConnected { dest ->
-			assert dest == destinations.dest1
-			false
-		}
-		i2pConnectorMock.demand.connect { dest ->
-			assert dest == destinations.dest1
-			throw new IOException()
-		}
-		
-		initMocks()
-		
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.incoming == false
-		assert event.status == ConnectionAttemptStatus.FAILED
-	}
-	
-	@Test
-	void testConnectionSucceedsPeer() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {false}
-		}
-		connectionManagerMock.ignore.needsConnections {
-			true
-		}
-		hostCacheMock.ignore.getHosts { num ->
-			assert num == 1
-			[destinations.dest1]
-		}
-		connectionManagerMock.ignore.isConnected { dest ->
-			assert dest == destinations.dest1
-			false
-		}
-		i2pConnectorMock.demand.connect { dest ->
-			PipedOutputStream os = new PipedOutputStream()
-			inputStream = new DataInputStream(new PipedInputStream(os))
-			PipedInputStream is = new PipedInputStream()
-			outputStream = new DataOutputStream(new PipedOutputStream(is))
-			new Endpoint(dest, is, os, null)
-		}
-		
-		initMocks()
-		
-		byte [] header = new byte[11]
-		inputStream.readFully(header)
-		assert header == "MuWire peer".bytes
-		
-		outputStream.write("OK".bytes)
-		outputStream.flush()
-		
-		Thread.sleep(100)
-		
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.incoming == false
-		assert event.status == ConnectionAttemptStatus.SUCCESSFUL
-		
-	}
-	
-	@Test
-	void testConnectionSucceedsLeaf() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {true}
-		}
-		connectionManagerMock.ignore.needsConnections {
-			true
-		}
-		hostCacheMock.ignore.getHosts { num ->
-			assert num == 1
-			[destinations.dest1]
-		}
-		connectionManagerMock.ignore.isConnected { dest ->
-			assert dest == destinations.dest1
-			false
-		}
-		i2pConnectorMock.demand.connect { dest ->
-			PipedOutputStream os = new PipedOutputStream()
-			inputStream = new DataInputStream(new PipedInputStream(os))
-			PipedInputStream is = new PipedInputStream()
-			outputStream = new DataOutputStream(new PipedOutputStream(is))
-			new Endpoint(dest, is, os, null)
-		}
-		
-		initMocks()
-		
-		byte [] header = new byte[11]
-		inputStream.readFully(header)
-		assert header == "MuWire leaf".bytes
-		
-		outputStream.write("OK".bytes)
-		outputStream.flush()
-		
-		Thread.sleep(100)
-		
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.incoming == false
-		assert event.status == ConnectionAttemptStatus.SUCCESSFUL
-	}
-	
-	@Test
-	void testConnectionRejected() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {false}
-		}
-		connectionManagerMock.ignore.needsConnections {
-			true
-		}
-		hostCacheMock.ignore.getHosts { num ->
-			assert num == 1
-			[destinations.dest1]
-		}
-		connectionManagerMock.ignore.isConnected { dest ->
-			assert dest == destinations.dest1
-			false
-		}
-		i2pConnectorMock.demand.connect { dest ->
-			PipedOutputStream os = new PipedOutputStream()
-			inputStream = new DataInputStream(new PipedInputStream(os))
-			PipedInputStream is = new PipedInputStream()
-			outputStream = new DataOutputStream(new PipedOutputStream(is))
-			new Endpoint(dest, is, os, null)
-		}
-		
-		initMocks()
-		
-		byte [] header = new byte[11]
-		inputStream.readFully(header)
-		assert header == "MuWire peer".bytes
-		
-		outputStream.write("REJECT".bytes)
-		outputStream.flush()
-		
-		Thread.sleep(100)
-		
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.incoming == false
-		assert event.status == ConnectionAttemptStatus.REJECTED
-		assert discoveredEvents.isEmpty()
-	}
-	
-	@Test
-	void testConnectionRejectedSuggestions() {
-		settings = new MuWireSettings() {
-			boolean isLeaf() {false}
-		}
-		connectionManagerMock.ignore.needsConnections {
-			true
-		}
-		hostCacheMock.ignore.getHosts { num ->
-			assert num == 1
-			[destinations.dest1]
-		}
-		connectionManagerMock.ignore.isConnected { dest ->
-			assert dest == destinations.dest1
-			false
-		}
-		i2pConnectorMock.demand.connect { dest ->
-			PipedOutputStream os = new PipedOutputStream()
-			inputStream = new DataInputStream(new PipedInputStream(os))
-			PipedInputStream is = new PipedInputStream()
-			outputStream = new DataOutputStream(new PipedOutputStream(is))
-			new Endpoint(dest, is, os, null)
-		}
-		
-		initMocks()
-		
-		byte [] header = new byte[11]
-		inputStream.readFully(header)
-		assert header == "MuWire peer".bytes
-		
-		outputStream.write("REJECT".bytes)
-		outputStream.flush()
-		
-		def json = [:]
-		json.tryHosts = [destinations.dest2.toBase64()]
-		json = JsonOutput.toJson(json)
-		outputStream.writeShort(json.bytes.length)
-		outputStream.write(json.bytes)
-		outputStream.flush()
-		Thread.sleep(100)
-		
-		assert connectionEvents.size() == 1
-		def event = connectionEvents[0]
-		assert event.endpoint.destination == destinations.dest1
-		assert event.incoming == false
-		assert event.status == ConnectionAttemptStatus.REJECTED
-		
-		assert discoveredEvents.size() == 1
-		event = discoveredEvents[0]
-		assert event.destination == destinations.dest2
-	}
+    EventBus eventBus
+    final Destinations destinations = new Destinations()
+    List<ConnectionEvent> connectionEvents
+    List<HostDiscoveredEvent> discoveredEvents
+    DataInputStream inputStream
+    DataOutputStream outputStream
+
+    def i2pConnectorMock
+    I2PConnector i2pConnector
+
+    MuWireSettings settings
+
+    def connectionManagerMock
+    ConnectionManager connectionManager
+
+    def hostCacheMock
+    HostCache hostCache
+
+    ConnectionEstablisher establisher
+
+
+    @Before
+    void before() {
+        connectionEvents = new CopyOnWriteArrayList()
+        discoveredEvents = new CopyOnWriteArrayList()
+        def listener = new Object() {
+            void onConnectionEvent(ConnectionEvent e) {
+                connectionEvents.add(e)
+            }
+            void onHostDiscoveredEvent(HostDiscoveredEvent e) {
+                discoveredEvents.add e
+            }
+        }
+        eventBus = new EventBus()
+        eventBus.register(ConnectionEvent.class, listener)
+        eventBus.register(HostDiscoveredEvent.class, listener)
+        i2pConnectorMock = new MockFor(I2PConnector.class)
+        connectionManagerMock = new MockFor(ConnectionManager.class)
+        hostCacheMock = new MockFor(HostCache.class)
+    }
+
+    @After
+    void after() {
+        establisher?.stop()
+        i2pConnectorMock.verify i2pConnector
+        connectionManagerMock.verify connectionManager
+        hostCacheMock.verify hostCache
+        Thread.sleep(100)
+    }
+
+    private void initMocks() {
+        i2pConnector = i2pConnectorMock.proxyInstance()
+        connectionManager = connectionManagerMock.proxyInstance()
+        hostCache = hostCacheMock.proxyInstance()
+        establisher = new ConnectionEstablisher(eventBus, i2pConnector, settings, connectionManager, hostCache)
+        establisher.start()
+        Thread.sleep(250)
+    }
+
+
+    @Test
+    void testConnectFails() {
+        settings = new MuWireSettings()
+        connectionManagerMock.ignore.needsConnections {
+            true
+        }
+        hostCacheMock.ignore.getHosts { num ->
+            assert num == 1
+            [destinations.dest1]
+        }
+        connectionManagerMock.ignore.isConnected { dest ->
+            assert dest == destinations.dest1
+            false
+        }
+        i2pConnectorMock.demand.connect { dest ->
+            assert dest == destinations.dest1
+            throw new IOException()
+        }
+
+        initMocks()
+
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.incoming == false
+        assert event.status == ConnectionAttemptStatus.FAILED
+    }
+
+    @Test
+    void testConnectionSucceedsPeer() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {false}
+        }
+        connectionManagerMock.ignore.needsConnections {
+            true
+        }
+        hostCacheMock.ignore.getHosts { num ->
+            assert num == 1
+            [destinations.dest1]
+        }
+        connectionManagerMock.ignore.isConnected { dest ->
+            assert dest == destinations.dest1
+            false
+        }
+        i2pConnectorMock.demand.connect { dest ->
+            PipedOutputStream os = new PipedOutputStream()
+            inputStream = new DataInputStream(new PipedInputStream(os))
+            PipedInputStream is = new PipedInputStream()
+            outputStream = new DataOutputStream(new PipedOutputStream(is))
+            new Endpoint(dest, is, os, null)
+        }
+
+        initMocks()
+
+        byte [] header = new byte[11]
+        inputStream.readFully(header)
+        assert header == "MuWire peer".bytes
+
+        outputStream.write("OK".bytes)
+        outputStream.flush()
+
+        Thread.sleep(100)
+
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.incoming == false
+        assert event.status == ConnectionAttemptStatus.SUCCESSFUL
+
+    }
+
+    @Test
+    void testConnectionSucceedsLeaf() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {true}
+        }
+        connectionManagerMock.ignore.needsConnections {
+            true
+        }
+        hostCacheMock.ignore.getHosts { num ->
+            assert num == 1
+            [destinations.dest1]
+        }
+        connectionManagerMock.ignore.isConnected { dest ->
+            assert dest == destinations.dest1
+            false
+        }
+        i2pConnectorMock.demand.connect { dest ->
+            PipedOutputStream os = new PipedOutputStream()
+            inputStream = new DataInputStream(new PipedInputStream(os))
+            PipedInputStream is = new PipedInputStream()
+            outputStream = new DataOutputStream(new PipedOutputStream(is))
+            new Endpoint(dest, is, os, null)
+        }
+
+        initMocks()
+
+        byte [] header = new byte[11]
+        inputStream.readFully(header)
+        assert header == "MuWire leaf".bytes
+
+        outputStream.write("OK".bytes)
+        outputStream.flush()
+
+        Thread.sleep(100)
+
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.incoming == false
+        assert event.status == ConnectionAttemptStatus.SUCCESSFUL
+    }
+
+    @Test
+    void testConnectionRejected() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {false}
+        }
+        connectionManagerMock.ignore.needsConnections {
+            true
+        }
+        hostCacheMock.ignore.getHosts { num ->
+            assert num == 1
+            [destinations.dest1]
+        }
+        connectionManagerMock.ignore.isConnected { dest ->
+            assert dest == destinations.dest1
+            false
+        }
+        i2pConnectorMock.demand.connect { dest ->
+            PipedOutputStream os = new PipedOutputStream()
+            inputStream = new DataInputStream(new PipedInputStream(os))
+            PipedInputStream is = new PipedInputStream()
+            outputStream = new DataOutputStream(new PipedOutputStream(is))
+            new Endpoint(dest, is, os, null)
+        }
+
+        initMocks()
+
+        byte [] header = new byte[11]
+        inputStream.readFully(header)
+        assert header == "MuWire peer".bytes
+
+        outputStream.write("REJECT".bytes)
+        outputStream.flush()
+
+        Thread.sleep(100)
+
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.incoming == false
+        assert event.status == ConnectionAttemptStatus.REJECTED
+        assert discoveredEvents.isEmpty()
+    }
+
+    @Test
+    void testConnectionRejectedSuggestions() {
+        settings = new MuWireSettings() {
+            boolean isLeaf() {false}
+        }
+        connectionManagerMock.ignore.needsConnections {
+            true
+        }
+        hostCacheMock.ignore.getHosts { num ->
+            assert num == 1
+            [destinations.dest1]
+        }
+        connectionManagerMock.ignore.isConnected { dest ->
+            assert dest == destinations.dest1
+            false
+        }
+        i2pConnectorMock.demand.connect { dest ->
+            PipedOutputStream os = new PipedOutputStream()
+            inputStream = new DataInputStream(new PipedInputStream(os))
+            PipedInputStream is = new PipedInputStream()
+            outputStream = new DataOutputStream(new PipedOutputStream(is))
+            new Endpoint(dest, is, os, null)
+        }
+
+        initMocks()
+
+        byte [] header = new byte[11]
+        inputStream.readFully(header)
+        assert header == "MuWire peer".bytes
+
+        outputStream.write("REJECT".bytes)
+        outputStream.flush()
+
+        def json = [:]
+        json.tryHosts = [destinations.dest2.toBase64()]
+        json = JsonOutput.toJson(json)
+        outputStream.writeShort(json.bytes.length)
+        outputStream.write(json.bytes)
+        outputStream.flush()
+        Thread.sleep(100)
+
+        assert connectionEvents.size() == 1
+        def event = connectionEvents[0]
+        assert event.endpoint.destination == destinations.dest1
+        assert event.incoming == false
+        assert event.status == ConnectionAttemptStatus.REJECTED
+
+        assert discoveredEvents.size() == 1
+        event = discoveredEvents[0]
+        assert event.destination == destinations.dest2
+    }
 }

core/src/test/groovy/com/muwire/core/download/DownloadSessionTest.groovy

@@ -19,48 +19,48 @@ import net.i2p.data.Base64
 import net.i2p.util.ConcurrentHashSet
 
 class DownloadSessionTest {
-    
+
     private EventBus eventBus
     private File source, target
     private InfoHash infoHash
     private Endpoint endpoint
     private Pieces pieces
     private String rootBase64
-    
+
     private DownloadSession session
     private Thread downloadThread
-    
+
     private InputStream fromDownloader, fromUploader
     private OutputStream toDownloader, toUploader
-    
+
     private volatile boolean performed
     private Set<Integer> available = new ConcurrentHashSet<>()
     private volatile IOException thrown
-    
-    
+
+
     @Before
     public void setUp() {
         eventBus = new EventBus()
     }
-    
+
     private void initSession(int size, def claimedPieces = []) {
         Random r = new Random()
         byte [] content = new byte[size]
         r.nextBytes(content)
-        
+
         source = File.createTempFile("source", "tmp")
         source.deleteOnExit()
         def fos = new FileOutputStream(source)
         fos.write(content)
         fos.close()
-        
+
         def hasher = new FileHasher()
         infoHash = hasher.hashFile(source)
         rootBase64 = Base64.encode(infoHash.getRoot())
-        
+
         target = File.createTempFile("target", "tmp")
         int pieceSize = 1 << FileHasher.getPieceSize(size)
-        
+
         int nPieces
         if (size % pieceSize == 0)
             nPieces = size / pieceSize
@@ -68,27 +68,27 @@ class DownloadSessionTest {
             nPieces = size / pieceSize + 1
         pieces = new Pieces(nPieces)
         claimedPieces.each {pieces.claimed.set(it)}
-        
+
         fromDownloader = new PipedInputStream()
         fromUploader = new PipedInputStream()
         toDownloader = new PipedOutputStream(fromUploader)
         toUploader = new PipedOutputStream(fromDownloader)
         endpoint = new Endpoint(null, fromUploader, toUploader, null)
-        
+
         session = new DownloadSession(eventBus, "",pieces, infoHash, endpoint, target, pieceSize, size, available)
         downloadThread = new Thread( { perform() } as Runnable)
         downloadThread.setDaemon(true)
         downloadThread.start()
     }
-    
+
     private void perform() {
-        try { 
+        try {
             performed = session.request()
         } catch (IOException e) {
             thrown = e
         }
     }
-    
+
     @After
     public void teardown() {
         source?.delete()
@@ -96,7 +96,7 @@ class DownloadSessionTest {
         downloadThread?.interrupt()
         Thread.sleep(50)
     }
-    
+
     @Test
     public void testSmallFile() {
         initSession(20)
@@ -105,38 +105,38 @@ class DownloadSessionTest {
         readTillRN(fromDownloader)
         readTillRN(fromDownloader)
         assert "" == readTillRN(fromDownloader)
-        
+
         toDownloader.write("200 OK\r\n".bytes)
         toDownloader.write("Content-Range: 0-19\r\n\r\n".bytes)
         toDownloader.write(source.bytes)
         toDownloader.flush()
-        
+
         Thread.sleep(150)
-        
+
         assert pieces.isComplete()
         assert target.bytes == source.bytes
         assert performed
         assert available.isEmpty()
         assert thrown == null
     }
-    
+
     @Test
     public void testPieceSizeFile() {
         int size = FileHasher.getPieceSize(1)
         size = 1 << size
         initSession(size)
-        
+
         assert "GET $rootBase64" == readTillRN(fromDownloader)
         readTillRN(fromDownloader)
         readTillRN(fromDownloader)
         readTillRN(fromDownloader)
         assert "" == readTillRN(fromDownloader)
-        
+
         toDownloader.write("200 OK\r\n".bytes)
         toDownloader.write(("Content-Range: 0-"+(size - 1)+"\r\n\r\n").bytes)
         toDownloader.write(source.bytes)
         toDownloader.flush()
-        
+
         Thread.sleep(150)
         assert pieces.isComplete()
         assert target.bytes == source.bytes
@@ -144,33 +144,33 @@ class DownloadSessionTest {
         assert available.isEmpty()
         assert thrown == null
     }
-    
+
     @Test
     public void testPieceSizePlusOne() {
         int pieceSize = FileHasher.getPieceSize(1)
         int size = (1 << pieceSize) + 1
         initSession(size)
-        
+
         assert "GET $rootBase64" == readTillRN(fromDownloader)
         String range = readTillRN(fromDownloader)
         def matcher = (range =~ /^Range: (\d+)-(\d+)$/)
         int start = Integer.parseInt(matcher[0][1])
         int end = Integer.parseInt(matcher[0][2])
-        
-        assert (start == 0 && end == ((1 << pieceSize) - 1)) || 
+
+        assert (start == 0 && end == ((1 << pieceSize) - 1)) ||
             (start == (1 << pieceSize) && end == (1 << pieceSize))
-        
+
         readTillRN(fromDownloader)
         readTillRN(fromDownloader)
         assert "" == readTillRN(fromDownloader)
-        
+
         toDownloader.write("200 OK\r\n".bytes)
         toDownloader.write(("Content-Range: $start-$end\r\n\r\n").bytes)
         byte [] piece = new byte[end - start + 1]
         System.arraycopy(source.bytes, start, piece, 0, piece.length)
         toDownloader.write(piece)
         toDownloader.flush()
-        
+
         Thread.sleep(150)
         assert !pieces.isComplete()
         assert 1 == pieces.donePieces()
@@ -178,7 +178,7 @@ class DownloadSessionTest {
         assert available.isEmpty()
         assert thrown == null
     }
-    
+
     @Test
     public void testSmallFileClaimed() {
         initSession(20, [0])
@@ -189,29 +189,29 @@ class DownloadSessionTest {
         assert available.isEmpty()
         assert thrown == null
     }
-    
+
     @Test
     public void testClaimedPiecesAvoided() {
         int pieceSize = FileHasher.getPieceSize(1)
         int size = (1 << pieceSize) * 10
         initSession(size, [1,2,3,4,5,6,7,8,9])
         assert !pieces.claimed.get(0)
-        
+
         assert "GET $rootBase64" == readTillRN(fromDownloader)
         String range = readTillRN(fromDownloader)
         def matcher = (range =~ /^Range: (\d+)-(\d+)$/)
         int start = Integer.parseInt(matcher[0][1])
         int end = Integer.parseInt(matcher[0][2])
-        
+
         assert pieces.claimed.get(0)
         assert start == 0 && end == (1 << pieceSize) - 1
     }
-    
+
     @Test
     public void test416NoHave() {
         initSession(20)
         readAllHeaders(fromDownloader)
-        
+
         toDownloader.write("416 don't have it\r\n\r\n".bytes)
         toDownloader.flush()
         Thread.sleep(150)
@@ -219,45 +219,45 @@ class DownloadSessionTest {
         assert available.isEmpty()
         assert thrown != null
     }
-    
+
     @Test
     public void test416Have() {
         initSession(20)
         readAllHeaders(fromDownloader)
-        
+
         toDownloader.write("416 don't have it\r\n".bytes)
         toDownloader.write("X-Have: ${encodeXHave([0], 1)}\r\n\r\n".bytes)
         toDownloader.flush()
-        
+
         Thread.sleep(150)
         assert performed
         assert available.contains(0)
         assert thrown == null
     }
-    
+
     @Test
     public void test416Have2Pieces() {
         int pieceSize = FileHasher.getPieceSize(1)
         int size = (1 << pieceSize) + 1
         initSession(size)
         readAllHeaders(fromDownloader)
-        
+
         toDownloader.write("416 don't have it\r\n".bytes)
         toDownloader.write("X-Have: ${encodeXHave([1], 2)}\r\n\r\n".bytes)
         toDownloader.flush()
-        
+
         Thread.sleep(150)
         assert performed
         assert available.contains(1)
         assert thrown == null
     }
-    
+
     @Test
     public void test200TwoPieces1Available() {
         int pieceSize = FileHasher.getPieceSize(1)
         int size = (1 << pieceSize) * 9 + 1
         initSession(size)
-        
+
         Set<String> headers = readAllHeaders(fromDownloader)
         def matcher = null
         headers.each {
@@ -267,27 +267,27 @@ class DownloadSessionTest {
         assert matcher.groupCount() > 0
         int start = Integer.parseInt(matcher[0][1])
         int end = Integer.parseInt(matcher[0][2])
-        
-        if (start == 0) 
+
+        if (start == 0)
             fail("inconlcusive")
-        
+
         toDownloader.write("416 don't have it \r\n".bytes)
         toDownloader.write("X-Have: ${encodeXHave([0],2)}\r\n\r\n".bytes)
         toDownloader.flush()
         downloadThread.join()
-        
+
         assert performed
         performed = false
         assert available.contains(0)
         assert thrown == null
-        
+
         // request same session
         downloadThread = new Thread( { perform() } as Runnable)
         downloadThread.setDaemon(true)
         downloadThread.start()
-        
+
         Thread.sleep(150)
-        
+
         headers = readAllHeaders(fromDownloader)
         matcher = null
         headers.each {
@@ -299,7 +299,7 @@ class DownloadSessionTest {
         end = Integer.parseInt(matcher[0][2])
         assert start == 0
     }
-    
+
     @Test
     public void testXAlt() throws Exception {
         Personas personas = new Personas()
@@ -310,19 +310,19 @@ class DownloadSessionTest {
             }
         }
         eventBus.register(SourceDiscoveredEvent.class, listener)
-        
+
         initSession(20)
         readAllHeaders(fromDownloader)
         toDownloader.write("416 don't have it\r\n".bytes)
         toDownloader.write("X-Alt: ${personas.persona1.toBase64()},${personas.persona2.toBase64()}\r\n\r\n".bytes)
         toDownloader.flush()
-        
+
         Thread.sleep(150)
         assert sources.contains(personas.persona1)
         assert sources.contains(personas.persona2)
         assert 2 == sources.size()
     }
-    
+
     private static Set<String> readAllHeaders(InputStream is) {
         Set<String> rv = new HashSet<>()
         String header