Release 0.1.4

README.md

@@ -1,10 +1,10 @@
 # MuWire - Easy Anonymous File-Sharing
 
-MuWire is an easy to use file-sharing program which offers anonymity using [I2P technology](http://geti2p.net).
+MuWire is an easy to use file-sharing program which offers anonymity using [I2P technology](http://geti2p.net).  It works on any platform Java works on, including Windows,MacOS,Linux.
 
 It is inspired by the LimeWire Gnutella client and developped by a former LimeWire developer.
 
-The project is in development.  You can find technical documentation in the "doc" folder.
+The first stable release - 0.1.0 is avaiable for download at http://muwire.com.  You can find technical documentation in the "doc" folder.
 
 ### Building
 
@@ -23,17 +23,12 @@ Some of the UI tests will fail because they haven't been written yet :-/
 
 ### Running
 
-You need to have an I2P router up and running on the same machine.  After you build the application, look inside "gui/build/distributions".  Untar/unzip one of the "shadow" files and then run the jar contained inside.  
+You need to have an I2P router up and running on the same machine.  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 use a custom I2CP host and port, create a file $HOME/.MuWire/i2p.properties and put "i2cp.tcp.host=<host>" and "i2cp.tcp.post=<port>" in there.
 
-The first time you run MuWire it will ask you to select a nickname.  This nickname will be displayed with search results, so that others can verify the file was shared by you.
-
-At the moment there are very few nodes on the network, so you will see very few connections and search results.  It is best to leave MuWire running all the time, just like I2P.
+The first time you run MuWire it will ask you to select a nickname.  This nickname will be displayed with search results, so that others can verify the file was shared by you.  It is best to leave MuWire running all the time, just like I2P.
 
 
 ### Known bugs and limitations
 
-* Any shared files get re-hashed on startup
-* Sometimes the list of shared files gets lost 
 * Many UI features you would expect are not there yet
 
-

build.gradle

@@ -3,7 +3,7 @@ subprojects {
 
     dependencies {
         compile 'net.i2p:i2p:0.9.40'
-        compile 'org.codehaus.groovy:groovy-all:2.5.7'
+        compile 'org.codehaus.groovy:groovy-all:2.4.15'
     }
 
     compileGroovy {

cli/build.gradle

@@ -0,0 +1,22 @@
+buildscript {
+
+    repositories {
+        jcenter()
+        mavenLocal()
+    }
+
+    dependencies {
+        classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
+    }
+}
+
+apply plugin : 'application'
+mainClassName = 'com.muwire.cli.Cli'
+apply plugin : 'com.github.johnrengelman.shadow'
+
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
+
+dependencies {
+    compile project(":core")
+}
+

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

@@ -0,0 +1,142 @@
+package com.muwire.cli
+
+import java.util.concurrent.CountDownLatch
+
+import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
+import com.muwire.core.connection.ConnectionAttemptStatus
+import com.muwire.core.connection.ConnectionEvent
+import com.muwire.core.connection.DisconnectionEvent
+import com.muwire.core.files.AllFilesLoadedEvent
+import com.muwire.core.files.FileHashedEvent
+import com.muwire.core.files.FileLoadedEvent
+import com.muwire.core.files.FileSharedEvent
+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 
+        try {
+            core = new Core(props, home, "0.1.4")
+        } 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 
+            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 "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) {
+                latch.countDown()
+            }
+        }
+        core.eventBus.register(AllFilesLoadedEvent.class, fileLoader)
+        core.startServices()
+        
+        println "waiting for files to load"
+        latch.await()
+        // now we begin
+        println "MuWire is ready"
+        
+        filesList = new File(filesList)
+        filesList.withReader { 
+            def toShare = it.readLine()
+            core.eventBus.publish(new FileSharedEvent(file : new File(toShare)))
+        }
+        Runtime.getRuntime().addShutdownHook({
+            println "shutting down.."
+            core.shutdown()
+            println "shutdown."
+        })
+        Thread.sleep(Integer.MAX_VALUE)
+    }
+    
+    static class ConnectionListener {
+        volatile int connections
+        public void onConnectionEvent(ConnectionEvent e) {
+            if (e.status == ConnectionAttemptStatus.SUCCESSFUL)
+                connections++
+        }
+        public void onDisconnectionEvent(DisconnectionEvent e) {
+            connections--
+        }
+    }
+    
+    static class UploadsListener {
+        volatile int uploads
+        public void onUploadEvent(UploadEvent e) {
+            uploads++
+            println "Starting upload of ${e.uploader.file.getName()} to ${e.uploader.request.downloader.getHumanReadableName()}"
+        }
+        public void onUploadFinishedEvent(UploadFinishedEvent e) {
+            uploads--
+            println "Finished upload of ${e.uploader.file.getName()} to ${e.uploader.request.downloader.getHumanReadableName()}"
+        }
+    }
+    
+    static class SharedListener {
+        volatile int shared
+        void onFileHashedEvent(FileHashedEvent e) {
+            if (e.error != null)
+                println "ERROR $e.error"
+            else {
+                println "Shared file : $e.sharedFile.file"
+                shared++
+            }
+        }
+        void onFileLoadedEvent(FileLoadedEvent e) {
+            shared++
+        }
+    }
+}

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

@@ -0,0 +1,166 @@
+package com.muwire.cli
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CountDownLatch
+
+import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
+import com.muwire.core.connection.ConnectionAttemptStatus
+import com.muwire.core.connection.ConnectionEvent
+import com.muwire.core.download.DownloadStartedEvent
+import com.muwire.core.download.Downloader
+import com.muwire.core.download.UIDownloadEvent
+import com.muwire.core.search.QueryEvent
+import com.muwire.core.search.SearchEvent
+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, " + 
+                "how many connections you want before searching" +
+                "and how long to wait for results to arrive"
+                System.exit(1)
+        } else {
+            filesList = args[0]
+            connections = Integer.parseInt(args[1])
+            resultWait = Integer.parseInt(args[2])
+        }
+
+        Core core
+        try {
+            core = new Core(props, home, "0.1.4")
+        } 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(",")
+            UUID uuid = UUID.randomUUID()
+            core.eventBus.register(UIResultEvent.class, new ResultsListener(fileName : split[1]))
+            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)) 
+        }
+        
+        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 ==="
+            downloaders.each {
+                int donePieces = it.donePieces()
+                int totalPieces = it.nPieces
+                int sources = it.activeWorkers.size()
+                def root = Base64.encode(it.infoHash.getRoot())
+                def state = it.getCurrentState()
+                println "file $it.file hash: $root progress: $donePieces/$totalPieces sources: $sources status: $state}"
+                it.resume()
+            }
+            println "==== END ==="
+        } as TimerTask, 60000, 60000)
+        
+        println "waiting for downloads to finish"
+        while(true) {
+            boolean allFinished = true
+            for (Downloader d : downloaders) {
+                allFinished &= d.getCurrentState() == Downloader.DownloadState.FINISHED
+            }
+            if (allFinished)
+                break
+            Thread.sleep(1000)
+        }
+        
+        println "all downloads finished"
+    }
+    
+    static class ResultsHolder {
+        final List<UIResultEvent> results = Collections.synchronizedList(new ArrayList<>())
+        String fileName
+        void add(UIResultEvent e) {
+            results.add(e)
+        }
+        List getResults() {
+            results
+        }
+    }
+    
+    static class ResultsListener {
+        UUID uuid
+        String fileName
+        public onUIResultEvent(UIResultEvent e) {
+            println "got a result for $fileName from ${e.sender.getHumanReadableName()}"
+            ResultsHolder listener = resultsListeners.get(e.uuid)
+            if (listener == null) {
+                listener = new ResultsHolder(fileName : fileName)
+                resultsListeners.put(e.uuid, listener)
+            }
+            listener.add(e)
+        }
+    }
+    
+    static class ConnectionWaiter {
+        CountDownLatch latch
+        public void onConnectionEvent(ConnectionEvent e) {
+            if (e.status == ConnectionAttemptStatus.SUCCESSFUL)
+                latch.countDown()
+        }
+    }
+    
+
+    static class DownloadListener {
+        public void onDownloadStartedEvent(DownloadStartedEvent e) {
+            downloaders.add(e.downloader)
+        }
+    }
+}

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

@@ -10,4 +10,6 @@ class Constants {
     public static final int MAX_HEADERS = 16
     
     public static final float DOWNLOAD_SEQUENTIAL_RATIO = 0.8f
+    
+    public static final String SPLIT_PATTERN = "[\\.,_-]"
 }

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

@@ -32,6 +32,7 @@ import com.muwire.core.search.SearchEvent
 import com.muwire.core.search.SearchManager
 import com.muwire.core.trust.TrustEvent
 import com.muwire.core.trust.TrustService
+import com.muwire.core.update.UpdateClient
 import com.muwire.core.upload.UploadManager
 import com.muwire.core.util.MuWireLogManager
 
@@ -54,17 +55,23 @@ public class Core {
     
     final EventBus eventBus
     final Persona me
-
+    final File home
+    final Properties i2pOptions
+    final MuWireSettings muOptions
+    
     private final TrustService trustService
     private final PersisterService persisterService
     private final HostCache hostCache
     private final ConnectionManager connectionManager
     private final CacheClient cacheClient
+    private final UpdateClient updateClient
     private final ConnectionAcceptor connectionAcceptor
     private final ConnectionEstablisher connectionEstablisher
     private final HasherService hasherService
         
-    public Core(MuWireSettings props, File home) {		
+    public Core(MuWireSettings props, File home, String myVersion) {
+        this.home = home		
+        this.muOptions = props
         log.info "Initializing I2P context"
         I2PAppContext.getGlobalContext().logManager()
         I2PAppContext.getGlobalContext()._logManager = new MuWireLogManager()
@@ -79,12 +86,28 @@ public class Core {
 			}
 		}
 		
-		def sysProps = System.getProperties().clone()
-		sysProps["inbound.nickname"] = "MuWire"
+        i2pOptions = new Properties()
+        def i2pOptionsFile = new File(home,"i2p.properties")
+        if (i2pOptionsFile.exists()) {
+            i2pOptionsFile.withInputStream { i2pOptions.load(it) }
+            if (!i2pOptions.hasProperty("inbound.nickname"))
+                i2pOptions["inbound.nickname"] = "MuWire"
+            if (!i2pOptions.hasProperty("outbound.nickname"))
+                i2pOptions["outbound.nickname"] = "MuWire"
+        } else {
+            i2pOptions["inbound.nickname"] = "MuWire"
+            i2pOptions["outbound.nickname"] = "MuWire"
+            i2pOptions["inbound.length"] = "3"
+            i2pOptions["inbound.quantity"] = "2"
+            i2pOptions["outbound.length"] = "3"
+            i2pOptions["outbound.quantity"] = "2"
+        }
+        
+        // options like tunnel length and quantity
 		I2PSession i2pSession
 		I2PSocketManager socketManager
 		keyDat.withInputStream {
-			socketManager = new I2PSocketManagerFactory().createManager(it, sysProps)
+			socketManager = new I2PSocketManagerFactory().createManager(it, i2pOptions)
 		}
 		socketManager.getDefaultOptions().setReadTimeout(60000)
 		socketManager.getDefaultOptions().setConnectTimeout(30000)
@@ -118,14 +141,14 @@ public class Core {
 		eventBus = new EventBus()
 		
 		log.info("initializing trust service")
-		File goodTrust = new File(home, "trust.good")
-		File badTrust = new File(home, "trust.bad")
+		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 fileManager = new FileManager(eventBus)
+		FileManager fileManager = new FileManager(eventBus, props)
 		eventBus.register(FileHashedEvent.class, fileManager)
 		eventBus.register(FileLoadedEvent.class, fileManager)
 		eventBus.register(FileDownloadedEvent.class, fileManager)
@@ -143,7 +166,8 @@ public class Core {
 		
 		log.info("initializing connection manager")
 		connectionManager = props.isLeaf() ? 
-			new LeafConnectionManager(eventBus, me, 3, hostCache) : new UltrapeerConnectionManager(eventBus, me, 512, 512, hostCache, trustService)
+			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)
@@ -152,6 +176,9 @@ public class Core {
 		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)
+        
 		log.info("initializing connector")
 		I2PConnector i2pConnector = new I2PConnector(socketManager)
         
@@ -164,23 +191,25 @@ public class Core {
 		eventBus.register(ResultsEvent.class, searchManager)
 		
         log.info("initializing download manager")
-        DownloadManager downloadManager = new DownloadManager(eventBus, i2pConnector)
+        DownloadManager downloadManager = new DownloadManager(eventBus, i2pConnector, home, me)
         eventBus.register(UIDownloadEvent.class, downloadManager)
+        eventBus.register(UILoadedEvent.class, downloadManager)
+        eventBus.register(FileDownloadedEvent.class, downloadManager)
         
         log.info("initializing upload manager")
         UploadManager uploadManager = new UploadManager(eventBus, fileManager)
         
+        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, 
-            i2pAcceptor, hostCache, trustService, searchManager, uploadManager)
+            i2pAcceptor, hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
 		
         
-        connectionEstablisher = new ConnectionEstablisher(eventBus, i2pConnector, props, connectionManager, hostCache)
-        
         log.info("initializing hasher service")
-        hasherService = new HasherService(new FileHasher(), eventBus)
+        hasherService = new HasherService(new FileHasher(), eventBus, fileManager)
         eventBus.register(FileSharedEvent.class, hasherService)
 	}
     
@@ -195,6 +224,11 @@ public class Core {
         connectionAcceptor.start()
         connectionEstablisher.start()
         hostCache.waitForLoad()
+        updateClient.start()
+    }
+    
+    public void shutdown() {
+        connectionManager.shutdown()
     }
 
     static main(args) {
@@ -221,7 +255,7 @@ public class Core {
             }
         }
         
-        Core core = new Core(props, home)
+        Core core = new Core(props, home, "0.1.4")
         core.startServices()
         
         // ... at the end, sleep or execute script

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

@@ -3,6 +3,7 @@ package com.muwire.core
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.Executor
 import java.util.concurrent.Executors
+import java.util.logging.Level
 
 import com.muwire.core.files.FileSharedEvent
 
@@ -23,14 +24,18 @@ class EventBus {
 	}
 	
 	private void publishInternal(Event e) {
-		log.fine "publishing event $e of type ${e.getClass().getSimpleName()}"
+		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 {
-			it."on${clazz.getSimpleName()}"(e)
+            try {
+                it."on${clazz.getSimpleName()}"(e)
+            } catch (Exception bad) {
+                log.log(Level.SEVERE, "exception dispatching event",bad)
+            }
 		}
 	}
 	

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

@@ -6,10 +6,13 @@ class MuWireSettings {
 	
     final boolean isLeaf
     boolean allowUntrusted
+    int downloadRetryInterval
+    int updateCheckInterval
     String nickname
     File downloadLocation
     String sharedFiles
     CrawlerResponse crawlerResponse
+    boolean shareDownloadedFiles
     
 	MuWireSettings() {
         this(new Properties())
@@ -23,6 +26,9 @@ class MuWireSettings {
         downloadLocation = new File((String)props.getProperty("downloadLocation", 
             System.getProperty("user.home")))
         sharedFiles = props.getProperty("sharedFiles")
+        downloadRetryInterval = Integer.parseInt(props.getProperty("downloadRetryInterval","15"))
+        updateCheckInterval = Integer.parseInt(props.getProperty("updateCheckInterval","36"))
+        shareDownloadedFiles = Boolean.parseBoolean(props.getProperty("shareDownloadedFiles","true"))
 	}
     
     void write(OutputStream out) throws IOException {
@@ -32,6 +38,9 @@ class MuWireSettings {
         props.setProperty("crawlerResponse", crawlerResponse.toString())
         props.setProperty("nickname", nickname)
         props.setProperty("downloadLocation", downloadLocation.getAbsolutePath())
+        props.setProperty("downloadRetryInterval", String.valueOf(downloadRetryInterval))
+        props.setProperty("updateCheckInterval", String.valueOf(updateCheckInterval))
+        props.setProperty("shareDownloadedFiles", String.valueOf(shareDownloadedFiles))
         if (sharedFiles != null)
             props.setProperty("sharedFiles", sharedFiles)
         props.store(out, "")

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

@@ -2,6 +2,7 @@ package com.muwire.core
 
 import net.i2p.crypto.DSAEngine
 import net.i2p.crypto.SigType
+import net.i2p.data.Base64
 import net.i2p.data.Destination
 import net.i2p.data.Signature
 import net.i2p.data.SigningPublicKey
@@ -14,6 +15,7 @@ public class Persona {
     private final Destination destination
     private final byte[] sig
     private volatile String humanReadableName
+    private volatile String base64
     private volatile byte[] payload
     
     public Persona(InputStream personaStream) throws IOException, InvalidSignatureException {
@@ -59,6 +61,15 @@ public class Persona {
         humanReadableName
     }
     
+    public String toBase64() {
+        if (base64 == null) {
+            def baos = new ByteArrayOutputStream()
+            write(baos)
+            base64 = Base64.encode(baos.toByteArray())
+        }
+        base64
+    }
+    
     @Override
     public int hashCode() {
         name.hashCode() ^ destination.hashCode()

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

@@ -0,0 +1,4 @@
+package com.muwire.core
+
+class UILoadedEvent extends Event {
+}

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

@@ -6,6 +6,8 @@ import java.util.concurrent.atomic.AtomicBoolean
 import java.util.logging.Level
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.hostcache.HostDiscoveredEvent
 import com.muwire.core.search.QueryEvent
@@ -14,6 +16,7 @@ import com.muwire.core.trust.TrustLevel
 import com.muwire.core.trust.TrustService
 
 import groovy.util.logging.Log
+import net.i2p.data.Base64
 import net.i2p.data.Destination
 
 @Log
@@ -24,7 +27,8 @@ abstract class Connection implements Closeable {
 	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
@@ -33,12 +37,14 @@ abstract class Connection implements Closeable {
 	
 	long lastPingSentTime, lastPongReceivedTime
 	
-	Connection(EventBus eventBus, Endpoint endpoint, boolean incoming, HostCache hostCache, TrustService trustService) {
+	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.trustService = trustService
+        this.settings = settings
 		
 		this.name = endpoint.destination.toBase32().substring(0,8)
 		
@@ -82,7 +88,6 @@ abstract class Connection implements Closeable {
 				read()
 			}
 		} catch (SocketTimeoutException e) {
-			close()
         } catch (Exception e) {
             log.log(Level.WARNING,"unhandled exception in reader",e)
         } finally {
@@ -120,9 +125,14 @@ abstract class Connection implements Closeable {
         query.type = "Search"
         query.version = 1
         query.uuid = e.searchEvent.getUuid()
-        // TODO: first hop figure out
+        query.firstHop = e.firstHop
         query.keywords = e.searchEvent.getSearchTerms()
-        query.replyTo = e.getReceivedOn().toBase64()
+        query.oobInfohash = e.searchEvent.oobInfohash
+        if (e.searchEvent.searchHash != null)
+            query.infohash = Base64.encode(e.searchEvent.searchHash)
+        query.replyTo = e.replyTo.toBase64()
+        if (e.originator != null)
+            query.originator = e.originator.toBase64()
         messages.put(query)
     }
 	
@@ -148,23 +158,45 @@ abstract class Connection implements Closeable {
     
     protected void handleSearch(def search) {
         UUID uuid = UUID.fromString(search.uuid)
-        if (search.infohash != null)
+        byte [] infohash = null
+        if (search.infohash != null) {
             search.keywords = null
+            infohash = Base64.decode(search.infohash)
+        }
             
         Destination replyTo = new Destination(search.replyTo)
-        if (trustService.getLevel(replyTo) == TrustLevel.DISTRUSTED) {
+        TrustLevel trustLevel = trustService.getLevel(replyTo)
+        if (trustLevel == TrustLevel.DISTRUSTED) {
             log.info "dropping search from distrusted peer"
             return
         }
-        // TODO: add option to respond only to trusted peers
+        if (trustLevel == TrustLevel.NEUTRAL && !settings.allowUntrusted()) {
+            log.info("dropping search from neutral peer")
+            return
+        }
+        
+        Persona originator = null
+        if (search.originator != null) {
+            originator = new Persona(new ByteArrayInputStream(Base64.decode(search.originator)))
+            if (originator.destination != replyTo) {
+                log.info("originator doesn't match destination")
+                return
+            }
+        }
+        
+        boolean oob = false
+        if (search.oobInfohash != null)
+            oob = search.oobInfohash
         
         SearchEvent searchEvent = new SearchEvent(searchTerms : search.keywords,
-                                            searchHash : search.infohash,
-                                            uuid : uuid)
+                                            searchHash : infohash,
+                                            uuid : uuid,
+                                            oobInfohash : oob)
         QueryEvent event = new QueryEvent ( searchEvent : searchEvent,
                                             replyTo : replyTo,
+                                            originator : originator,
                                             receivedOn : endpoint.destination,
-                                            firstHop : Boolean.parseBoolean(search.firstHop) )
+                                            firstHop : search.firstHop )
         eventBus.publish(event)
                                             
     }

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

@@ -34,13 +34,15 @@ class ConnectionAcceptor {
 	final TrustService trustService
     final SearchManager searchManager 
     final UploadManager uploadManager
+    final ConnectionEstablisher establisher
 	
 	final ExecutorService acceptorThread
 	final ExecutorService handshakerThreads
 	
 	ConnectionAcceptor(EventBus eventBus, UltrapeerConnectionManager manager,
 		MuWireSettings settings, I2PAcceptor acceptor, HostCache hostCache,
-		TrustService trustService, SearchManager searchManager, UploadManager uploadManager) {
+		TrustService trustService, SearchManager searchManager, UploadManager uploadManager,
+        ConnectionEstablisher establisher) {
 		this.eventBus = eventBus
 		this.manager = manager
 		this.settings = settings
@@ -49,7 +51,8 @@ class ConnectionAcceptor {
 		this.trustService = trustService
         this.searchManager = searchManager
         this.uploadManager = uploadManager
-		
+		this.establisher = establisher
+        
 		acceptorThread = Executors.newSingleThreadExecutor { r -> 
 			def rv = new Thread(r)
 			rv.setDaemon(true)
@@ -140,7 +143,9 @@ class ConnectionAcceptor {
     }
 
 	private void handleIncoming(Endpoint e, boolean leaf) {
-		boolean accept = !manager.isConnected(e.destination) && (leaf ? manager.hasLeafSlots() : manager.hasPeerSlots())
+		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)
@@ -204,7 +209,7 @@ class ConnectionAcceptor {
                 byte [] payload = new byte[jsonSize]
                 dis.readFully(payload)
                 def json = slurper.parse(payload)
-                eventBus.publish(ResultsParser.parse(sender, json))
+                eventBus.publish(ResultsParser.parse(sender, resultsUUID, json))
             }
         } catch (IOException | UnexpectedResultsException | InvalidSearchResultException bad) {
             log.log(Level.WARNING, "failed to process POST", bad)

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

@@ -35,6 +35,8 @@ class ConnectionEstablisher {
 	
 	final Set inProgress = new ConcurrentHashSet()
 	
+    ConnectionEstablisher(){}
+    
 	ConnectionEstablisher(EventBus eventBus, I2PConnector i2pConnector, MuWireSettings settings,
 		ConnectionManager connectionManager, HostCache hostCache) {
 		this.eventBus = eventBus
@@ -176,4 +178,8 @@ class ConnectionEstablisher {
 			e.close()
 		}
 	}
+    
+    public boolean isInProgress(Destination d) {
+        inProgress.contains(d)
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.muwire.core.connection
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.search.QueryEvent
@@ -19,13 +20,15 @@ abstract class ConnectionManager {
 	
 	protected final HostCache hostCache
     protected final Persona me
+    protected final MuWireSettings settings
 	
 	ConnectionManager() {}
 	
-	ConnectionManager(EventBus eventBus, Persona me, HostCache hostCache) {
+	ConnectionManager(EventBus eventBus, Persona me, HostCache hostCache, MuWireSettings settings) {
 		this.eventBus = eventBus
         this.me = me
 		this.hostCache = hostCache
+        this.settings = settings
 		this.timer = new Timer("connections-pinger",true)
 	}
 	
@@ -40,7 +43,7 @@ abstract class ConnectionManager {
 	
 	void onTrustEvent(TrustEvent e) {
 		if (e.level == TrustLevel.DISTRUSTED)
-			drop(e.destination)
+			drop(e.persona.destination)
 	}
     
 	abstract void drop(Destination d)
@@ -58,6 +61,8 @@ abstract class ConnectionManager {
 	abstract void onConnectionEvent(ConnectionEvent e)
 	
 	abstract void onDisconnectionEvent(DisconnectionEvent e)
+    
+    abstract void shutdown()
 	
 	protected void sendPings() {
 		final long now = System.currentTimeMillis()

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

@@ -4,6 +4,7 @@ import java.io.InputStream
 import java.io.OutputStream
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.trust.TrustService
 
@@ -16,8 +17,9 @@ import net.i2p.data.Destination
  */
 class LeafConnection extends Connection {
 
-	public LeafConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache, TrustService trustService) {
-		super(eventBus, endpoint, true, hostCache, trustService);
+	public LeafConnection(EventBus eventBus, Endpoint endpoint, HostCache hostCache, 
+        TrustService trustService, MuWireSettings settings) {
+		super(eventBus, endpoint, true, hostCache, trustService, settings);
 	}
 
 	@Override

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

@@ -3,6 +3,7 @@ package com.muwire.core.connection
 import java.util.concurrent.ConcurrentHashMap
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.search.QueryEvent
@@ -17,8 +18,9 @@ class LeafConnectionManager extends ConnectionManager {
 	
 	final Map<Destination, UltrapeerConnection> connections = new ConcurrentHashMap()
 	
-	public LeafConnectionManager(EventBus eventBus, Persona me, int maxConnections, HostCache hostCache) {
-		super(eventBus, me, hostCache)
+	public LeafConnectionManager(EventBus eventBus, Persona me, int maxConnections, 
+        HostCache hostCache, MuWireSettings settings) {
+		super(eventBus, me, hostCache, settings)
 		this.maxConnections = maxConnections
 	}
 	
@@ -71,4 +73,8 @@ class LeafConnectionManager extends ConnectionManager {
 			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

@@ -4,6 +4,7 @@ import java.io.InputStream
 import java.io.OutputStream
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.trust.TrustService
 import com.muwire.core.util.DataUtil
@@ -29,8 +30,9 @@ class PeerConnection extends Connection {
 	private final JsonSlurper slurper = new JsonSlurper()
 
 	public PeerConnection(EventBus eventBus, Endpoint endpoint,
-			boolean incoming, HostCache hostCache, TrustService trustService) {
-		super(eventBus, endpoint, incoming, hostCache, trustService)
+			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)
 	}

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

@@ -4,6 +4,7 @@ import java.util.Collection
 import java.util.concurrent.ConcurrentHashMap
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 import com.muwire.core.Persona
 import com.muwire.core.hostcache.HostCache
 import com.muwire.core.search.QueryEvent
@@ -17,15 +18,15 @@ 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, 
-        HostCache hostCache, TrustService trustService) {
-		super(eventBus, me, hostCache)
+        HostCache hostCache, TrustService trustService, MuWireSettings settings) {
+		super(eventBus, me, hostCache, settings)
 		this.maxPeers = maxPeers
 		this.maxLeafs = maxLeafs
         this.trustService = trustService
@@ -85,8 +86,8 @@ class UltrapeerConnectionManager extends ConnectionManager {
 			return
 		
 		Connection c = e.leaf ? 
-			new LeafConnection(eventBus, e.endpoint, hostCache, trustService) : 
-			new PeerConnection(eventBus, e.endpoint, e.incoming, hostCache, trustService)
+			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()
@@ -100,6 +101,14 @@ class UltrapeerConnectionManager extends ConnectionManager {
 		if (removed == null)
 			log.severe("Removed connection not present in either leaf or peer map ${e.destination.toBase32()}")
 	}
+    
+    @Override
+    void shutdown() {
+        peerConnections.each {k,v -> v.close() }
+        leafConnections.each {k,v -> v.close() }
+        peerConnections.clear()
+        leafConnections.clear()
+    }
 	
 	void forwardQueryToLeafs(QueryEvent e) {
 		

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

@@ -0,0 +1,25 @@
+package com.muwire.core.download
+
+class BadHashException extends Exception {
+
+    public BadHashException() {
+        super();
+    }
+
+    public BadHashException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+
+    public BadHashException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public BadHashException(String message) {
+        super(message);
+    }
+
+    public BadHashException(Throwable cause) {
+        super(cause);
+    }
+    
+}

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

@@ -1,7 +1,21 @@
 package com.muwire.core.download
 
 import com.muwire.core.connection.I2PConnector
+import com.muwire.core.files.FileDownloadedEvent
+import com.muwire.core.files.FileHasher
+import com.muwire.core.util.DataUtil
+
+import groovy.json.JsonBuilder
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import net.i2p.data.Base64
+import net.i2p.data.Destination
+import net.i2p.util.ConcurrentHashSet
+
 import com.muwire.core.EventBus
+import com.muwire.core.InfoHash
+import com.muwire.core.Persona
+import com.muwire.core.UILoadedEvent
 
 import java.util.concurrent.Executor
 import java.util.concurrent.Executors
@@ -11,10 +25,20 @@ public class DownloadManager {
     private final EventBus eventBus
     private final I2PConnector connector
     private final Executor executor
+    private final File incompletes, home
+    private final Persona me
     
-    public DownloadManager(EventBus eventBus, I2PConnector connector) {
+    private final Set<Downloader> downloaders = new ConcurrentHashSet<>()
+    
+    public DownloadManager(EventBus eventBus, I2PConnector connector, File home, Persona me) {
         this.eventBus = eventBus
         this.connector = connector
+        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")
@@ -25,9 +49,75 @@ public class DownloadManager {
     
     
     public void onUIDownloadEvent(UIDownloadEvent e) {
-        def downloader = new Downloader(e.target, e.result.size,
-            e.result.infohash, e.result.pieceSize, connector, e.result.sender.destination)
+        
+        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 { 
+            destinations.add(it.sender.destination)
+        }
+        
+        def downloader = new Downloader(eventBus, this, me, e.target, size,
+            infohash, pieceSize, connector, destinations,
+            incompletes)
+        downloaders.add(downloader)
+        persistDownloaders()
         executor.execute({downloader.download()} as Runnable)
         eventBus.publish(new DownloadStartedEvent(downloader : downloader))
     }
+    
+    void resume(Downloader downloader) {
+        executor.execute({downloader.download() as Runnable})
+    }
+    
+    void onUILoadedEvent(UILoadedEvent e) {
+        File downloadsFile = new File(home, "downloads.json")
+        if (!downloadsFile.exists())
+            return
+        def slurper = new JsonSlurper()
+        downloadsFile.eachLine {
+            def json = slurper.parseText(it)
+            File file = new File(DataUtil.readi18nString(Base64.decode(json.file)))
+            def destinations = new HashSet<>()
+            json.destinations.each { destination -> 
+                destinations.add new Destination(destination)
+            }
+            byte[] hashList = Base64.decode(json.hashList)
+            InfoHash infoHash = InfoHash.fromHashList(hashList)
+            def downloader = new Downloader(eventBus, this, me, file, (long)json.length,
+                infoHash, json.pieceSizePow2, connector, destinations, incompletes)
+            downloader.download()
+            eventBus.publish(new DownloadStartedEvent(downloader : downloader))
+        }
+    }
+    
+    void onFileDownloadedEvent(FileDownloadedEvent e) {
+        downloaders.remove(e.downloader)
+        persistDownloaders()
+    }
+    
+    private void persistDownloaders() {
+        File downloadsFile = new File(home,"downloads.json")
+        downloadsFile.withPrintWriter { writer -> 
+            downloaders.each { downloader ->
+                if (!downloader.cancelled) {
+                    def json = [:]
+                    json.file = Base64.encode(DataUtil.encodei18nString(downloader.file.getAbsolutePath()))
+                    json.length = downloader.length
+                    json.pieceSizePow2 = downloader.pieceSizePow2
+                    def destinations = []
+                    downloader.destinations.each {
+                        destinations << it.toBase64()
+                    }
+                    json.destinations = destinations
+                    
+                    json.hashList = Base64.encode(downloader.infoHash.hashList)
+                    
+                    writer.println(JsonOutput.toJson(json))
+                }
+            }
+        }
+    }
 }

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

@@ -20,7 +20,10 @@ import java.security.NoSuchAlgorithmException
 @Log
 class DownloadSession {
     
-    private final Pieces pieces
+    private static int SAMPLES = 10
+    
+    private final String meB64
+    private final Pieces downloaded, claimed
     private final InfoHash infoHash
     private final Endpoint endpoint
     private final File file
@@ -28,11 +31,16 @@ class DownloadSession {
     private final long fileLength
     private final MessageDigest digest
     
+    private final LinkedList<Long> timestamps = new LinkedList<>()
+    private final LinkedList<Integer> reads = new LinkedList<>()
+    
     private ByteBuffer mapped
     
-    DownloadSession(Pieces pieces, InfoHash infoHash, Endpoint endpoint, File file, 
+    DownloadSession(String meB64, Pieces downloaded, Pieces claimed, InfoHash infoHash, Endpoint endpoint, File file, 
         int pieceSize, long fileLength) {
-        this.pieces = pieces
+        this.meB64 = meB64
+        this.downloaded = downloaded
+        this.claimed = claimed
         this.endpoint = endpoint
         this.infoHash = infoHash
         this.file = file
@@ -46,11 +54,31 @@ class DownloadSession {
         }
     }
     
-    public void request() throws IOException {
+    /**
+     * @return if the request will proceed.  The only time it may not
+     * is if all the pieces have been claimed by other sessions.
+     * @throws IOException
+     */
+    public boolean request() throws IOException {
         OutputStream os = endpoint.getOutputStream()
         InputStream is = endpoint.getInputStream()
         
-        int piece = pieces.getRandomPiece()
+        int piece
+        while(true) {
+            piece = downloaded.getRandomPiece()
+            if (claimed.isMarked(piece)) {
+                if (downloaded.donePieces() + claimed.donePieces() == downloaded.nPieces) {
+                    log.info("all pieces claimed")
+                    return false
+                }
+                continue
+            }
+            break
+        }
+        claimed.markDownloaded(piece)
+        
+        log.info("will download piece $piece")
+        
         long start = piece * pieceSize
         long end = Math.min(fileLength, start + pieceSize) - 1
         long length = end - start + 1
@@ -60,7 +88,8 @@ class DownloadSession {
         FileChannel channel
         try {
             os.write("GET $root\r\n".getBytes(StandardCharsets.US_ASCII))
-            os.write("Range: $start-$end\r\n\r\n".getBytes(StandardCharsets.US_ASCII))
+            os.write("Range: $start-$end\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("404 ")) {
@@ -119,6 +148,13 @@ class DownloadSession {
                     throw new IOException()
                 synchronized(this) {
                     mapped.put(tmp, 0, read)
+                    
+                    if (timestamps.size() == SAMPLES) {
+                        timestamps.removeFirst()
+                        reads.removeFirst()
+                    }
+                    timestamps.addLast(System.currentTimeMillis())
+                    reads.addLast(read)
                 }
             }
             
@@ -127,16 +163,15 @@ class DownloadSession {
             byte [] hash = digest.digest()
             byte [] expected = new byte[32]
             System.arraycopy(infoHash.getHashList(), piece * 32, expected, 0, 32)    
-            if (hash != expected) {
-                log.warning("hash mismatch")
-                endpoint.close()
-                return
-            }
+            if (hash != expected) 
+                throw new BadHashException()
             
-            pieces.markDownloaded(piece)        
+            downloaded.markDownloaded(piece)        
         } finally {
+            claimed.clear(piece)
             try { channel?.close() } catch (IOException ignore) {}
         }
+        return true
     }
     
     synchronized int positionInPiece() {
@@ -144,4 +179,26 @@ class DownloadSession {
             return 0
         mapped.position()
     }
+    
+    synchronized int speed() {
+        if (timestamps.size() < SAMPLES)
+            return 0
+        int totalRead = 0
+        int idx = 0
+        final long now = System.currentTimeMillis()
+        
+        while(idx < SAMPLES && timestamps.get(idx) < now - 1000)
+            idx++
+        if (idx == SAMPLES)
+            return 0
+        if (idx == SAMPLES - 1)
+            return reads[idx]
+            
+        long interval = timestamps.last - timestamps[idx]
+        if (interval == 0) 
+            interval = 1
+        for (int i = idx; i < SAMPLES; i++)
+            totalRead += reads[idx]
+        (int)(totalRead * 1000.0 / interval)
+    }
 }

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

@@ -1,34 +1,68 @@
 package com.muwire.core.download
 
 import com.muwire.core.InfoHash
+import com.muwire.core.Persona
 import com.muwire.core.connection.Endpoint
-import com.muwire.core.Constants
-import com.muwire.core.connection.I2PConnector
 
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.logging.Level
+
+import com.muwire.core.Constants
+import com.muwire.core.DownloadedFile
+import com.muwire.core.EventBus
+import com.muwire.core.connection.I2PConnector
+import com.muwire.core.files.FileDownloadedEvent
+
+import groovy.util.logging.Log
 import net.i2p.data.Destination
 
+@Log
 public class Downloader {
-    public enum DownloadState { CONNECTING, DOWNLOADING, FINISHED }
+    public enum DownloadState { CONNECTING, DOWNLOADING, FAILED, CANCELLED, FINISHED }
+    private enum WorkerState { CONNECTING, DOWNLOADING, FINISHED}
     
+    private static final ExecutorService executorService = Executors.newCachedThreadPool({r ->
+        Thread rv = new Thread(r)
+        rv.setName("download worker")
+        rv.setDaemon(true)
+        rv
+    })
+
+    private final EventBus eventBus
+    private final DownloadManager downloadManager 
+    private final Persona me   
     private final File file
-    private final Pieces pieces
+    private final Pieces downloaded, claimed
     private final long length
     private final InfoHash infoHash
     private final int pieceSize
     private final I2PConnector connector
-    private final Destination destination
+    private final Set<Destination> destinations
     private final int nPieces
+    private final File piecesFile
+    final int pieceSizePow2
+    private final Map<Destination, DownloadWorker> activeWorkers = new ConcurrentHashMap<>()
     
-    private Endpoint endpoint
-    private volatile DownloadSession currentSession
-    private volatile DownloadState currentState
     
-    public Downloader(File file, long length, InfoHash infoHash, int pieceSizePow2, I2PConnector connector, Destination destination) {
+    private volatile boolean cancelled
+    private volatile boolean eventFired
+
+    public Downloader(EventBus eventBus, DownloadManager downloadManager, 
+        Persona me, File file, long length, InfoHash infoHash, 
+        int pieceSizePow2, I2PConnector connector, Set<Destination> destinations,
+        File incompletes) {
+        this.eventBus = eventBus
+        this.me = me
+        this.downloadManager = downloadManager
         this.file = file
         this.infoHash = infoHash
         this.length = length
         this.connector = connector
-        this.destination = destination
+        this.destinations = destinations
+        this.piecesFile = new File(incompletes, file.getName()+".pieces")
+        this.pieceSizePow2 = pieceSizePow2
         this.pieceSize = 1 << pieceSizePow2
         
         int nPieces
@@ -38,32 +72,163 @@ public class Downloader {
             nPieces = length / pieceSize + 1
         this.nPieces = nPieces
         
-        pieces = new Pieces(nPieces, Constants.DOWNLOAD_SEQUENTIAL_RATIO)
-        currentState = DownloadState.CONNECTING
+        downloaded = new Pieces(nPieces, Constants.DOWNLOAD_SEQUENTIAL_RATIO)
+        claimed = new Pieces(nPieces)
     }
     
     void download() {
-        Endpoint endpoint = connector.connect(destination)
-        currentState = DownloadState.DOWNLOADING
-        while(!pieces.isComplete()) {
-            currentSession = new DownloadSession(pieces, infoHash, endpoint, file, pieceSize, length)
-            currentSession.request()
+        readPieces()
+        destinations.each {
+            if (it != me.destination) {
+                def worker = new DownloadWorker(it)
+                activeWorkers.put(it, worker)
+                executorService.submit(worker)
+            }
+        }
+    }
+    
+    void readPieces() {
+        if (!piecesFile.exists())
+            return
+        piecesFile.eachLine { 
+            int piece = Integer.parseInt(it)
+            downloaded.markDownloaded(piece)
+        }
+    }
+    
+    void writePieces() {
+        piecesFile.withPrintWriter { writer ->
+            downloaded.getDownloaded().each { piece -> 
+                writer.println(piece)
+            }
         }
-        currentState = DownloadState.FINISHED
-        endpoint.close()
     }
     
     public long donePieces() {
-        pieces.donePieces()
+        downloaded.donePieces()
     }
     
-    public int positionInPiece() {
-        if (currentSession == null)
-            return 0
-        currentSession.positionInPiece()
+    
+    public int speed() {
+        int total = 0
+        if (getCurrentState() == DownloadState.DOWNLOADING) {
+            activeWorkers.values().each {
+                if (it.currentState == WorkerState.DOWNLOADING)
+                    total += it.speed()
+            }
+        }
+        total
     }
     
     public DownloadState getCurrentState() {
-        currentState
+        if (cancelled)
+            return DownloadState.CANCELLED
+        boolean allFinished = true
+        activeWorkers.values().each { 
+            allFinished &= it.currentState == WorkerState.FINISHED
+        }
+        if (allFinished) {
+            if (downloaded.isComplete())
+                return DownloadState.FINISHED
+            return DownloadState.FAILED
+        }
+        
+        // if at least one is downloading...
+        boolean oneDownloading = false
+        activeWorkers.values().each { 
+            if (it.currentState == WorkerState.DOWNLOADING) {
+                oneDownloading = true
+                return 
+            }
+        }
+        
+        if (oneDownloading)
+            return DownloadState.DOWNLOADING
+        
+        return DownloadState.CONNECTING
+    }
+    
+    public void cancel() {
+        cancelled = true
+        activeWorkers.values().each { 
+            it.cancel()
+        }
+    }
+    
+    public int activeWorkers() {
+        int active = 0
+        activeWorkers.values().each { 
+            if (it.currentState != WorkerState.FINISHED)
+                active++
+        }
+        active
+    }
+    
+    public void resume() {
+        destinations.each { destination ->
+            def worker = activeWorkers.get(destination)
+            if (worker != null) {
+                if (worker.currentState == WorkerState.FINISHED) {
+                    def newWorker = new DownloadWorker(destination)
+                    activeWorkers.put(destination, newWorker)
+                    executorService.submit(newWorker)
+                }
+            } else {
+                worker = new DownloadWorker(destination)
+                activeWorkers.put(destination, worker)
+                executorService.submit(worker)
+            }
+        }
+    }
+    
+    class DownloadWorker implements Runnable {
+        private final Destination destination
+        private volatile WorkerState currentState
+        private volatile Thread downloadThread
+        private Endpoint endpoint
+        private volatile DownloadSession currentSession
+                
+        DownloadWorker(Destination destination) {
+            this.destination = destination
+        }
+        
+        public void run() {
+            downloadThread = Thread.currentThread()
+            currentState = WorkerState.CONNECTING
+            Endpoint endpoint = null
+            try {
+                endpoint = connector.connect(destination)
+                currentState = WorkerState.DOWNLOADING
+                boolean requestPerformed
+                while(!downloaded.isComplete()) {
+                    currentSession = new DownloadSession(me.toBase64(), downloaded, claimed, infoHash, endpoint, file, pieceSize, length)
+                    requestPerformed = currentSession.request()
+                    if (!requestPerformed)
+                        break
+                    writePieces()
+                }
+            } catch (Exception bad) {
+                log.log(Level.WARNING,"Exception while downloading",bad)
+            } finally {
+                currentState = WorkerState.FINISHED
+                if (downloaded.isComplete() && !eventFired) {
+                    piecesFile.delete()
+                    eventFired = true
+                    eventBus.publish(new FileDownloadedEvent(downloadedFile : new DownloadedFile(file, infoHash, pieceSize, Collections.emptySet())),
+                        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/Pieces.groovy

@@ -28,19 +28,36 @@ class Pieces {
         
         while(true) {
             int start = random.nextInt(nPieces)
-            while(bitSet.get(start) && ++start < nPieces);
+            if (bitSet.get(start))
+                continue
             return start
         }
     }
     
+    def getDownloaded() {
+        def rv = []
+        for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i+1)) {
+            rv << i
+        }
+        rv
+    }
+    
     synchronized void markDownloaded(int piece) {
         bitSet.set(piece)
     }
     
+    synchronized void clear(int piece) {
+        bitSet.clear(piece)
+    }
+    
     synchronized boolean isComplete() {
         bitSet.cardinality() == nPieces
     }
     
+    synchronized boolean isMarked(int piece) {
+        bitSet.get(piece)
+    }
+    
     synchronized int donePieces() {
         bitSet.cardinality()
     }

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

@@ -5,6 +5,6 @@ import com.muwire.core.search.UIResultEvent
 
 class UIDownloadEvent extends Event {
     
-    UIResultEvent result
+    UIResultEvent[] result
     File target
 }

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

@@ -0,0 +1,6 @@
+package com.muwire.core.files
+
+import com.muwire.core.Event
+
+class AllFilesLoadedEvent extends Event {
+}

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

@@ -2,10 +2,11 @@ package com.muwire.core.files
 
 import com.muwire.core.DownloadedFile
 import com.muwire.core.Event
+import com.muwire.core.download.Downloader
 
 import net.i2p.data.Destination
 
 class FileDownloadedEvent extends Event {
-
+    Downloader downloader
 	DownloadedFile downloadedFile
 }

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

@@ -1,6 +1,9 @@
 package com.muwire.core.files
 
 import com.muwire.core.InfoHash
+
+import net.i2p.data.Base64
+
 import java.nio.MappedByteBuffer
 import java.nio.channels.FileChannel
 import java.nio.channels.FileChannel.MapMode
@@ -17,12 +20,12 @@ class FileHasher {
 	 * @return the size of each piece in power of 2
 	 */
 	static int getPieceSize(long size) {
-		if (size <= 0x1 << 25)
-			return 18
+		if (size <= 0x1 << 27)
+			return 17
 		
-		for (int i = 26; i <= 37; i++) {
+		for (int i = 28; i <= 37; i++) {
 			if (size <= 0x1L << i) {
-				return i-7
+				return i-10
 			}
 		}
 		
@@ -52,11 +55,11 @@ class FileHasher {
 		try {
 			MappedByteBuffer buf
 			for (int i = 0; i < numPieces - 1; i++) {
-				buf = raf.getChannel().map(MapMode.READ_ONLY, size * i, size)
+				buf = raf.getChannel().map(MapMode.READ_ONLY, ((long)size) * i, size)
 				digest.update buf
 				output.write(digest.digest(), 0, 32)
 			}
-			def lastPieceLength = length - (numPieces - 1) * size
+			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)
@@ -67,4 +70,18 @@ class FileHasher {
 		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()
+        def infohash = hasher.hashFile(file)
+        println Base64.encode(infohash.getRoot())
+    }
 }

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

@@ -2,7 +2,9 @@ package com.muwire.core.files
 
 import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
+import com.muwire.core.UILoadedEvent
 import com.muwire.core.search.ResultsEvent
 import com.muwire.core.search.SearchEvent
 import com.muwire.core.search.SearchIndex
@@ -14,27 +16,31 @@ class FileManager {
 
 
 	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) {
+	FileManager(EventBus eventBus, MuWireSettings settings) {
+        this.settings = settings
 		this.eventBus = eventBus
 	}
 	
-	void onFileHashedEvent(FileHashedEvent e) {
-		if (e.sharedFile != null)
-			addToIndex(e.sharedFile)
-	}
+    void onFileHashedEvent(FileHashedEvent e) {
+        if (e.sharedFile != null)
+            addToIndex(e.sharedFile)
+    }
 	
 	void onFileLoadedEvent(FileLoadedEvent e) {
 		addToIndex(e.loadedFile)
 	}
 	
-	void onFileDownloadedEvent(FileDownloadedEvent e) {
-		addToIndex(e.downloadedFile)
-	}
+    void onFileDownloadedEvent(FileDownloadedEvent e) {
+        if (settings.shareDownloadedFiles) {
+            addToIndex(e.downloadedFile)
+        }
+    }
 	
 	private void addToIndex(SharedFile sf) {
         log.info("Adding shared file " + sf.getFile())
@@ -100,6 +106,7 @@ class FileManager {
 		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)
 		} else {
@@ -108,6 +115,7 @@ class FileManager {
 			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)
 			
@@ -116,4 +124,15 @@ class FileManager {
 		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 { 
+            if (it.getPieceSize() != 0)
+                rv.add(it)
+        }
+        rv
+    }
 }

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

@@ -10,11 +10,13 @@ class HasherService {
 
 	final FileHasher hasher
 	final EventBus eventBus
+    final FileManager fileManager
 	Executor executor
 	
-	HasherService(FileHasher hasher, EventBus eventBus) {
+	HasherService(FileHasher hasher, EventBus eventBus, FileManager fileManager) {
 		this.hasher = hasher
 		this.eventBus = eventBus
+        this.fileManager = fileManager
 	}
 	
 	void start() {
@@ -22,6 +24,8 @@ class HasherService {
 	}
 	
 	void onFileSharedEvent(FileSharedEvent evt) {
+        if (fileManager.fileToSharedFile.containsKey(evt.file))
+            return
 		executor.execute( { -> process(evt.file) } as Runnable)
 	}
 	
@@ -36,7 +40,7 @@ class HasherService {
 				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))
+				eventBus.publish new FileHashedEvent(sharedFile: new SharedFile(f, hash, FileHasher.getPieceSize(f.length())))
 			}
 		}
 	}

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

@@ -1,5 +1,8 @@
 package com.muwire.core.files
 
+import java.nio.file.CopyOption
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
 import java.util.logging.Level
 import java.util.stream.Collectors
 
@@ -34,7 +37,7 @@ class PersisterService extends Service {
 	}
 	
 	void start() {
-		timer.schedule({load()} as TimerTask, 1000)
+		timer.schedule({load()} as TimerTask, 1)
 	}
 	
 	void stop() {
@@ -55,6 +58,7 @@ class PersisterService extends Service {
 						}
 					}
 				}
+                listener.publish(new AllFilesLoadedEvent())
 			} catch (IllegalArgumentException|NumberFormatException e) {
                 log.log(Level.WARNING, "couldn't load files",e)
 			}
@@ -94,28 +98,37 @@ class PersisterService extends Service {
 		if (!Arrays.equals(root, ih.getRoot()))
 			return null
 			
-		if (json.sources != 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, sourceSet)
+			DownloadedFile df = new DownloadedFile(file, ih, pieceSize, sourceSet)
 			return new FileLoadedEvent(loadedFile : df)
 		}
+        
 		 
-		SharedFile sf = new SharedFile(file, ih)
+		SharedFile sf = new SharedFile(file, ih, pieceSize)
 		return new FileLoadedEvent(loadedFile: sf)
 		
 	}
 	
 	private void persistFiles() {
-		location.delete()
 		def sharedFiles = fileManager.getSharedFiles()
-		location.withPrintWriter { writer ->
+        
+        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
 			}
 		}
+        Files.copy(tmp.toPath(), location.toPath(), StandardCopyOption.REPLACE_EXISTING)
+        tmp.delete()
 	}
 	
 	private def toJson(File f, SharedFile sf) {
@@ -124,6 +137,7 @@ class PersisterService extends Service {
 		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++) {

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

@@ -65,7 +65,7 @@ class CacheClient {
 		options.setSendLeaseSet(true)
 		CacheServers.getCacheServers().each {
 			log.info "Querying hostcache ${it.toBase32()}"
-			session.sendMessage(it, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 0, 0, options)
+			session.sendMessage(it, ping, 0, ping.length, I2PSession.PROTO_DATAGRAM, 1, 0, options)
 		}
 	}
 	
@@ -140,7 +140,7 @@ class CacheClient {
 		pong.pongs.asList().each { 
 			Destination dest = new Destination(it)
 			if (!session.getMyDestination().equals(dest))
-				eventBus.publish(new HostDiscoveredEvent(destination: dest)) 
+				eventBus.publish(new HostDiscoveredEvent(destination: dest, fromHostcache : true)) 
 		}
 		
 	}

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

@@ -30,4 +30,8 @@ class Host {
 	synchronized boolean hasSucceeded() {
 		successes > 0
 	}
+    
+    synchronized void clearFailures() {
+        failures = 0
+    }
 }

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

@@ -46,8 +46,12 @@ class HostCache extends Service {
 	void onHostDiscoveredEvent(HostDiscoveredEvent e) {
 		if (myself == e.destination)
 			return
-		if (hosts.containsKey(e.destination))
-			return
+		if (hosts.containsKey(e.destination)) {
+            if (!e.fromHostcache)
+                return
+            hosts.get(e.destination).clearFailures()
+            return
+		}
 		Host host = new Host(e.destination)
 		if (allowHost(host)) {
 			hosts.put(e.destination, host)
@@ -55,7 +59,7 @@ class HostCache extends Service {
 	}
 	
 	void onConnectionEvent(ConnectionEvent e) {
-		if (e.incoming || e.leaf)
+		if (e.leaf)
 			return
 		Destination dest = e.endpoint.destination
 		Host host = hosts.get(dest)

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

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

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

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

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

@@ -9,7 +9,7 @@ import com.muwire.core.util.DataUtil
 import net.i2p.data.Base64
 
 class ResultsParser {
-    public static UIResultEvent parse(Persona p, def json) throws InvalidSearchResultException {
+    public static UIResultEvent parse(Persona p, UUID uuid, def json) throws InvalidSearchResultException {
         if (json.type != "Result")
             throw new InvalidSearchResultException("not a result json")
         if (json.version != 1)
@@ -46,7 +46,8 @@ class ResultsParser {
                  name : name,
                  size : size,
                  infohash : parsedIH,
-                 pieceSize : pieceSize)
+                 pieceSize : pieceSize,
+                 uuid : uuid)
         } catch (Exception e) {
             throw new InvalidSearchResultException("parsing search result failed",e)
         }

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

@@ -51,11 +51,15 @@ class ResultsSender {
         if (target.equals(me.destination)) {
             results.each { 
                 long length = it.getFile().length()
+                int pieceSize = it.getPieceSize()
+                if (pieceSize == 0)
+                    pieceSize = FileHasher.getPieceSize(length)
                 def uiResultEvent = new UIResultEvent( sender : me,
                     name : it.getFile().getName(),
                     size : length,
                     infohash : it.getInfoHash(),
-                    pieceSize : FileHasher.getPieceSize(length)
+                    pieceSize : pieceSize,
+                    uuid : uuid
                     )
                     eventBus.publish(uiResultEvent)
             }
@@ -94,7 +98,7 @@ class ResultsSender {
                     obj.name = encodedName
                     obj.infohash = Base64.encode(it.getInfoHash().getRoot())
                     obj.size = it.getFile().length()
-                    obj.pieceSize = FileHasher.getPieceSize(it.getFile().length())
+                    obj.pieceSize = it.getPieceSize()
                     byte [] hashList = it.getInfoHash().getHashList()
                     def hashListB64 = []
                     for (int i = 0; i < hashList.length / InfoHash.SIZE; i++) {

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

@@ -1,10 +1,19 @@
 package com.muwire.core.search
 
 import com.muwire.core.Event
+import com.muwire.core.InfoHash
 
 class SearchEvent extends Event {
 
 	List<String> searchTerms
 	byte [] searchHash
 	UUID uuid
+    boolean oobInfohash
+    
+    String toString() {
+        def infoHash = null
+        if (searchHash != null)
+            infoHash = new InfoHash(searchHash)
+        "searchTerms: $searchTerms searchHash:$infoHash, uuid:$uuid oobInfohash:$oobInfohash"
+    }
 }

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

@@ -1,5 +1,6 @@
 package com.muwire.core.search
 
+import com.muwire.core.Constants
 
 class SearchIndex {
 
@@ -31,7 +32,7 @@ class SearchIndex {
 	}
 	
 	private static String[] split(String source) {
-		source = source.replaceAll("[\\.,_-]", " ")
+		source = source.replaceAll(Constants.SPLIT_PATTERN, " ").toLowerCase()
 		source.split(" ")
 	}
 	
@@ -41,7 +42,7 @@ class SearchIndex {
 		terms.each {
 			Set<String> forWord = keywords.getOrDefault(it,[])
 			if (rv == null) {
-				rv = forWord
+				rv = new HashSet<>(forWord)
 			} else {
 				rv.retainAll(forWord)
 			}

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

@@ -6,6 +6,7 @@ import com.muwire.core.Persona
 
 class UIResultEvent extends Event {
     Persona sender
+    UUID uuid
     String name
     long size
     InfoHash infohash

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

@@ -1,11 +1,10 @@
 package com.muwire.core.trust
 
 import com.muwire.core.Event
-
-import net.i2p.data.Destination
+import com.muwire.core.Persona
 
 class TrustEvent extends Event {
 
-	Destination destination
+	Persona persona
 	TrustLevel level
 }

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

@@ -1,7 +1,11 @@
 package com.muwire.core.trust
 
+import java.util.concurrent.ConcurrentHashMap
+
+import com.muwire.core.Persona
 import com.muwire.core.Service
 
+import net.i2p.data.Base64
 import net.i2p.data.Destination
 import net.i2p.util.ConcurrentHashSet
 
@@ -10,8 +14,8 @@ class TrustService extends Service {
 	final File persistGood, persistBad
 	final long persistInterval
 	
-	final Set<Destination> good = new ConcurrentHashSet<>()
-	final Set<Destination> bad = new ConcurrentHashSet<>()
+	final Map<Destination, Persona> good = new ConcurrentHashMap<>()
+	final Map<Destination, Persona> bad = new ConcurrentHashMap<>()
 	
 	final Timer timer
 	
@@ -35,12 +39,16 @@ class TrustService extends Service {
 	void load() {
 		if (persistGood.exists()) {
 			persistGood.eachLine {
-				good.add(new Destination(it))
+                byte [] decoded = Base64.decode(it)
+                Persona persona = new Persona(new ByteArrayInputStream(decoded))
+				good.put(persona.destination, persona)
 			}
 		}
 		if (persistBad.exists()) {
 			persistBad.eachLine {
-				bad.add(new Destination(it))
+                byte [] decoded = Base64.decode(it)
+                Persona persona = new Persona(new ByteArrayInputStream(decoded))
+                bad.put(persona.destination, persona)
 			}
 		}
 		timer.schedule({persist()} as TimerTask, persistInterval, persistInterval)
@@ -50,22 +58,22 @@ class TrustService extends Service {
 	private void persist() {
 		persistGood.delete()
 		persistGood.withPrintWriter { writer ->
-			good.each {
-				writer.println it.toBase64()
+			good.each {k,v ->
+				writer.println v.toBase64()
 			}
 		}
 		persistBad.delete()
 		persistBad.withPrintWriter { writer ->
-			bad.each { 
-				writer.println it.toBase64()
+			bad.each { k,v ->
+				writer.println v.toBase64()
 			}
 		}
 	}
 	
 	TrustLevel getLevel(Destination dest) {
-		if (good.contains(dest))
+		if (good.containsKey(dest))
 			return TrustLevel.TRUSTED
-		else if (bad.contains(dest))
+		else if (bad.containsKey(dest))
 			return TrustLevel.DISTRUSTED
 		TrustLevel.NEUTRAL
 	}
@@ -73,16 +81,16 @@ class TrustService extends Service {
 	void onTrustEvent(TrustEvent e) {
 		switch(e.level) {
 			case TrustLevel.TRUSTED:
-				bad.remove(e.destination)
-				good.add(e.destination)
+				bad.remove(e.persona.destination)
+				good.put(e.persona.destination, e.persona)
 				break
 			case TrustLevel.DISTRUSTED:
-				good.remove(e.destination)
-				bad.add(e.destination)
+				good.remove(e.persona.destination)
+				bad.put(e.persona.destination, e.persona)
 				break
 			case TrustLevel.NEUTRAL:
-				good.remove(e.destination)
-				bad.remove(e.destination)
+				good.remove(e.persona.destination)
+				bad.remove(e.persona.destination)
 				break
 		}
 	}

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

@@ -0,0 +1,10 @@
+package com.muwire.core.update
+
+import com.muwire.core.Event
+import com.muwire.core.InfoHash
+
+class UpdateAvailableEvent extends Event {
+    String version
+    String signer
+    String infoHash
+}

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

@@ -0,0 +1,132 @@
+package com.muwire.core.update
+
+import java.util.logging.Level
+
+import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
+
+import groovy.json.JsonOutput
+import groovy.json.JsonSlurper
+import groovy.util.logging.Log
+import net.i2p.client.I2PSession
+import net.i2p.client.I2PSessionMuxedListener
+import net.i2p.client.SendMessageOptions
+import net.i2p.client.datagram.I2PDatagramDissector
+import net.i2p.client.datagram.I2PDatagramMaker
+import net.i2p.util.VersionComparator
+
+@Log
+class UpdateClient {
+    final EventBus eventBus
+    final I2PSession session
+    final String myVersion
+    final MuWireSettings settings
+    
+    private final Timer timer
+    
+    private long lastUpdateCheckTime
+    
+    UpdateClient(EventBus eventBus, I2PSession session, String myVersion, MuWireSettings settings) {
+        this.eventBus = eventBus
+        this.session = session
+        this.myVersion = myVersion
+        this.settings = settings
+        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()
+    }
+    
+    private void checkUpdate() {
+        final long now = System.currentTimeMillis()
+        if (lastUpdateCheckTime > 0) {
+            if (now - lastUpdateCheckTime < settings.updateCheckInterval * 60 * 60 * 1000)
+                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() 
+        options.setSendLeaseSet(true)
+        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
+        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()
+                if (sender != UpdateServers.UPDATE_SERVER) {
+                    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
+                }
+                
+                log.info("new version $payload.version available, publishing event")
+                eventBus.publish(new UpdateAvailableEvent(version : payload.version, signer : payload.signer, infoHash : payload.infoHash))
+                
+            } catch (Exception e) {
+                log.log(Level.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.log(Level.SEVERE, message, error)
+        }
+        
+    }
+}

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

@@ -0,0 +1,7 @@
+package com.muwire.core.update
+
+import net.i2p.data.Destination
+
+class UpdateServers {
+    static final Destination UPDATE_SERVER = new Destination("pSWieSRB3czCl3Zz4WpKp4Z8tjv-05zbogRDS7SEnKcSdWOupVwjzQ92GsgQh1VqgoSRk1F8dpZOnHxxz5HFy9D7ri0uFdkMyXdSKoB7IgkkvCfTAyEmeaPwSYnurF3Zk7u286E7YG2rZkQZgJ77tow7ZS0mxFB7Z0Ti-VkZ9~GeGePW~howwNm4iSQACZA0DyTpI8iv5j4I0itPCQRgaGziob~Vfvjk49nd8N4jtaDGo9cEcafikVzQ2OgBgYWL6LRbrrItwuGqsDvITUHWaElUYIDhRQYUq8gYiUA6rwAJputfhFU0J7lIxFR9vVY7YzRvcFckfr0DNI4VQVVlPnRPkUxQa--BlldMaCIppWugjgKLwqiSiHywKpSMlBWgY2z1ry4ueEBo1WEP-mEf88wRk4cFQBCKtctCQnIG2GsnATqTl-VGUAsuzeNWZiFSwXiTy~gQ094yWx-K06fFZUDt4CMiLZVhGlixiInD~34FCRC9LVMtFcqiFB2M-Ql2AAAA")
+}

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

@@ -4,6 +4,7 @@ import java.nio.charset.StandardCharsets
 
 import com.muwire.core.Constants
 import com.muwire.core.InfoHash
+import com.muwire.core.Persona
 
 import groovy.util.logging.Log
 import net.i2p.data.Base64
@@ -16,6 +17,7 @@ class Request {
     
     InfoHash infoHash
     Range range
+    Persona downloader
     Map<String, String> headers
     
     static Request parse(InfoHash infoHash, InputStream is) throws IOException {
@@ -85,7 +87,13 @@ class Request {
         if (start < 0 || end < start)
             throw new IOException("Invalid range $start - $end")
         
-        new Request( infoHash : infoHash, range : new Range(start, end), headers : headers)
+        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))
+        }
+        new Request( infoHash : infoHash, range : new Range(start, end), headers : headers, downloader : downloader)
     }
     
 }

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

@@ -62,6 +62,11 @@ public class UploadManager {
             }
 
             Request request = Request.parse(new InfoHash(infoHashRoot), e.getInputStream())
+            if (request.downloader != null && request.downloader.destination != e.destination) {
+                log.info("Downloader persona doesn't match their destination")
+                e.close()
+                return
+            }
             Uploader uploader = new Uploader(sharedFiles.iterator().next().file, request, e)
             eventBus.publish(new UploadEvent(uploader : uploader))
             try {

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

@@ -55,21 +55,21 @@ class JULLog extends Log {
 
     @Override
     public boolean shouldDebug() {
-        level.intValue().intValue() >= Level.FINE.intValue()
+        level.intValue().intValue() <= Level.FINE.intValue()
     }
 
     @Override
     public boolean shouldInfo() {
-        level.intValue().intValue() >= Level.INFO.intValue()
+        level.intValue().intValue() <= Level.INFO.intValue()
     }
 
     @Override
     public boolean shouldWarn() {
-        level.intValue().intValue() >= Level.WARNING.intValue()
+        level.intValue().intValue() <= Level.WARNING.intValue()
     }
 
     @Override
     public boolean shouldError() {
-        level.intValue().intValue() >= Level.SEVERE.intValue()
+        level.intValue().intValue() <= Level.SEVERE.intValue()
     }
 }

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

@@ -9,8 +9,8 @@ public class DownloadedFile extends SharedFile {
 	
 	private final Set<Destination> sources;
 
-	public DownloadedFile(File file, InfoHash infoHash, Set<Destination> sources) {
-		super(file, infoHash);
+	public DownloadedFile(File file, InfoHash infoHash, int pieceSize, Set<Destination> sources) {
+		super(file, infoHash, pieceSize);
 		this.sources = sources;
 	}
 	

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

@@ -7,6 +7,7 @@ import java.util.Arrays;
 import java.util.List;
 
 import net.i2p.data.Base32;
+import net.i2p.data.Base64;
 
 public class InfoHash {
 
@@ -76,14 +77,16 @@ public class InfoHash {
 	}
 	
 	public String toString() {
-		String rv = "InfoHash[root:"+Base32.encode(root) + " hashList:";
-		List<String> b32HashList = new ArrayList<>(hashList.length / SIZE);
-		byte [] tmp = new byte[SIZE];
-		for (int i = 0; i < hashList.length / SIZE; i++) {
-			System.arraycopy(hashList, SIZE * i, tmp, 0, SIZE);
-			b32HashList.add(Base32.encode(tmp));
+		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 += b32HashList.toString();
+		rv += b64HashList.toString();
 		rv += "]";
 		return rv;
 	}

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

@@ -6,10 +6,12 @@ public class SharedFile {
 
 	private final File file;
 	private final InfoHash infoHash;
+	private final int pieceSize;
 	
-	public SharedFile(File file, InfoHash infoHash) {
+	public SharedFile(File file, InfoHash infoHash, int pieceSize) {
 		this.file = file;
 		this.infoHash = infoHash;
+		this.pieceSize = pieceSize;
 	}
 
 	public File getFile() {
@@ -20,4 +22,7 @@ public class SharedFile {
 		return infoHash;
 	}
 	
+	public int getPieceSize() {
+	    return pieceSize;
+	}
 }

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

@@ -0,0 +1,11 @@
+package com.muwire.core
+
+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

@@ -43,6 +43,9 @@ class ConnectionAcceptorTest {
     
     def uploadManagerMock
     UploadManager uploadManager
+    
+    def connectionEstablisherMock
+    ConnectionEstablisher connectionEstablisher
 	
 	ConnectionAcceptor acceptor
 	List<ConnectionEvent> connectionEvents
@@ -57,6 +60,7 @@ class ConnectionAcceptorTest {
 		trustServiceMock = new MockFor(TrustService.class)
         searchManagerMock = new MockFor(SearchManager.class)
         uploadManagerMock = new MockFor(UploadManager.class)
+        connectionEstablisherMock = new MockFor(ConnectionEstablisher.class)
 	}
 	
 	@After
@@ -68,6 +72,7 @@ class ConnectionAcceptorTest {
 		trustServiceMock.verify trustService
         searchManagerMock.verify searchManager
         uploadManagerMock.verify uploadManager
+        connectionEstablisherMock.verify connectionEstablisher
 		Thread.sleep(100)
 	}
 	
@@ -87,8 +92,10 @@ class ConnectionAcceptorTest {
 		trustService = trustServiceMock.proxyInstance()
         searchManager = searchManagerMock.proxyInstance()
         uploadManager = uploadManagerMock.proxyInstance()
+        connectionEstablisher = connectionEstablisherMock.proxyInstance()
 		
-		acceptor = new ConnectionAcceptor(eventBus, connectionManager, settings, i2pAcceptor, hostCache, trustService, searchManager, uploadManager)
+		acceptor = new ConnectionAcceptor(eventBus, connectionManager, settings, i2pAcceptor, 
+            hostCache, trustService, searchManager, uploadManager, connectionEstablisher)
 		acceptor.start()
 		Thread.sleep(100)
 	}
@@ -108,6 +115,7 @@ class ConnectionAcceptorTest {
 			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
@@ -150,6 +158,7 @@ class ConnectionAcceptorTest {
 			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
@@ -264,6 +273,7 @@ class ConnectionAcceptorTest {
 			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
@@ -310,6 +320,7 @@ class ConnectionAcceptorTest {
 			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
@@ -356,6 +367,7 @@ class ConnectionAcceptorTest {
 			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

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

@@ -15,7 +15,7 @@ class DownloadSessionTest {
     private File source, target
     private InfoHash infoHash
     private Endpoint endpoint
-    private Pieces pieces
+    private Pieces pieces, claimed
     private String rootBase64
     
     private DownloadSession session
@@ -24,7 +24,7 @@ class DownloadSessionTest {
     private InputStream fromDownloader, fromUploader
     private OutputStream toDownloader, toUploader
     
-    private void initSession(int size) {
+    private void initSession(int size, def claimedPieces = []) {
         Random r = new Random()
         byte [] content = new byte[size]
         r.nextBytes(content)
@@ -48,6 +48,8 @@ class DownloadSessionTest {
         else
             nPieces = size / pieceSize + 1
         pieces = new Pieces(nPieces)
+        claimed = new Pieces(nPieces)
+        claimedPieces.each {claimed.markDownloaded(it)}
         
         fromDownloader = new PipedInputStream()
         fromUploader = new PipedInputStream()
@@ -55,7 +57,7 @@ class DownloadSessionTest {
         toUploader = new PipedOutputStream(fromDownloader)
         endpoint = new Endpoint(null, fromUploader, toUploader, null)
         
-        session = new DownloadSession(pieces, infoHash, endpoint, target, pieceSize, size)
+        session = new DownloadSession("",pieces, claimed, infoHash, endpoint, target, pieceSize, size)
         downloadThread = new Thread( { session.request() } as Runnable)
         downloadThread.setDaemon(true)
         downloadThread.start()
@@ -74,6 +76,7 @@ class DownloadSessionTest {
         initSession(20)
         assert "GET $rootBase64" == readTillRN(fromDownloader)
         assert "Range: 0-19" == readTillRN(fromDownloader)
+        readTillRN(fromDownloader)
         assert "" == readTillRN(fromDownloader)
         
         toDownloader.write("200 OK\r\n".bytes)
@@ -95,6 +98,7 @@ class DownloadSessionTest {
         
         assert "GET $rootBase64" == readTillRN(fromDownloader)
         readTillRN(fromDownloader)
+        readTillRN(fromDownloader)
         assert "" == readTillRN(fromDownloader)
         
         toDownloader.write("200 OK\r\n".bytes)
@@ -122,6 +126,7 @@ class DownloadSessionTest {
         assert (start == 0 && end == ((1 << pieceSize) - 1)) || 
             (start == (1 << pieceSize) && end == (1 << pieceSize))
         
+        readTillRN(fromDownloader)
         assert "" == readTillRN(fromDownloader)
         
         toDownloader.write("200 OK\r\n".bytes)
@@ -135,4 +140,29 @@ class DownloadSessionTest {
         assert !pieces.isComplete()
         assert 1 == pieces.donePieces()
     }
+    
+    @Test
+    public void testSmallFileClaimed() {
+        initSession(20, [0])
+        long now = System.currentTimeMillis()
+        downloadThread.join(100)
+        assert 100 > (System.currentTimeMillis() - now)
+    }
+    
+    @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 !claimed.isMarked(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 claimed.isMarked(0)
+        assert start == 0 && end == (1 << pieceSize) - 1
+    }
 }

core/src/test/groovy/com/muwire/core/files/FileHasherTest.groovy

@@ -24,9 +24,9 @@ class FileHasherTest extends GroovyTestCase {
 	
 	@Test
 	void testPieceSize() {
-		assert 18 == FileHasher.getPieceSize(1000000)
-		assert 20 == FileHasher.getPieceSize(100000000)
-		assert 30 == FileHasher.getPieceSize(FileHasher.MAX_SIZE)
+		assert 17 == FileHasher.getPieceSize(1000000)
+		assert 17 == FileHasher.getPieceSize(100000000)
+		assert 27 == FileHasher.getPieceSize(FileHasher.MAX_SIZE)
 		shouldFail IllegalArgumentException, {
 			FileHasher.getPieceSize(Long.MAX_VALUE)
 		}
@@ -48,7 +48,7 @@ class FileHasherTest extends GroovyTestCase {
 		fos.write b
 		fos.close()
 		def ih = hasher.hashFile tmp
-		assert ih.getHashList().length == 32
+		assert ih.getHashList().length == 64
 	}
 	
 	@Test
@@ -58,7 +58,7 @@ class FileHasherTest extends GroovyTestCase {
 		fos.write b
 		fos.close()
 		def ih = hasher.hashFile tmp
-		assert ih.getHashList().length == 64
+		assert ih.getHashList().length == 96
 	}
 	
 	@Test
@@ -68,7 +68,7 @@ class FileHasherTest extends GroovyTestCase {
 		fos.write b
 		fos.close()
 		def ih = hasher.hashFile tmp
-		assert ih.getHashList().length == 64
+		assert ih.getHashList().length == 128
 	}
 	
 	@Test
@@ -78,6 +78,6 @@ class FileHasherTest extends GroovyTestCase {
 		fos.write b
 		fos.close()
 		def ih = hasher.hashFile tmp
-		assert ih.getHashList().length == 32 * 3
+		assert ih.getHashList().length == 160
 	}
 }

core/src/test/groovy/com/muwire/core/files/FileManagerTest.groovy

@@ -5,6 +5,7 @@ import org.junit.Test
 
 import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
 import com.muwire.core.search.ResultsEvent
 import com.muwire.core.search.SearchEvent
@@ -26,7 +27,7 @@ class FileManagerTest {
 	void before() {
 		eventBus = new EventBus()
 		eventBus.register(ResultsEvent.class, listener)
-		manager = new FileManager(eventBus)
+		manager = new FileManager(eventBus, new MuWireSettings())
 		results = null
 	}
 	
@@ -34,7 +35,7 @@ class FileManagerTest {
 	void testHash1Result() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih, 0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -53,8 +54,8 @@ class FileManagerTest {
 	@Test
 	void testHash2Results() {
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(new File("a b.c"), ih)
-		SharedFile sf2 = new SharedFile(new File("d e.f"), ih)
+		SharedFile sf1 = new SharedFile(new File("a b.c"), ih, 0)
+		SharedFile sf2 = new SharedFile(new File("d e.f"), ih, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf1)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf2)
 
@@ -75,7 +76,7 @@ class FileManagerTest {
 	void testHash0Results() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih, 0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -89,7 +90,7 @@ class FileManagerTest {
 	void testKeyword1Result() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih,0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -107,12 +108,12 @@ class FileManagerTest {
 	void testKeyword2Results() {
 		File f1 = new File("a b.c")
 		InfoHash ih1 = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(f1, ih1)
+		SharedFile sf1 = new SharedFile(f1, ih1, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf1)
 		
 		File f2 = new File("c d.e")
 		InfoHash ih2 = InfoHash.fromHashList(new byte[64])
-		SharedFile sf2 = new SharedFile(f2, ih2)
+		SharedFile sf2 = new SharedFile(f2, ih2, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf2)
 		
 		UUID uuid = UUID.randomUUID()
@@ -130,7 +131,7 @@ class FileManagerTest {
 	void testKeyword0Results() {
 		File f = new File("a b.c")
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf = new SharedFile(f,ih)
+		SharedFile sf = new SharedFile(f,ih,0)
 		FileHashedEvent fhe = new FileHashedEvent(sharedFile: sf)
 		manager.onFileHashedEvent(fhe)
 		
@@ -143,8 +144,8 @@ class FileManagerTest {
 	@Test
 	void testRemoveFileExistingHash() {
 		InfoHash ih = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(new File("a b.c"), ih)
-		SharedFile sf2 = new SharedFile(new File("d e.f"), ih)
+		SharedFile sf1 = new SharedFile(new File("a b.c"), ih, 0)
+		SharedFile sf2 = new SharedFile(new File("d e.f"), ih, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf1)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile : sf2)
 		
@@ -161,12 +162,12 @@ class FileManagerTest {
 	void testRemoveFile() {
 		File f1 = new File("a b.c")
 		InfoHash ih1 = InfoHash.fromHashList(new byte[32])
-		SharedFile sf1 = new SharedFile(f1, ih1)
+		SharedFile sf1 = new SharedFile(f1, ih1, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf1)
 		
 		File f2 = new File("c d.e")
 		InfoHash ih2 = InfoHash.fromHashList(new byte[64])
-		SharedFile sf2 = new SharedFile(f2, ih2)
+		SharedFile sf2 = new SharedFile(f2, ih2, 0)
 		manager.onFileLoadedEvent new FileLoadedEvent(loadedFile: sf2)
 		
 		manager.onFileUnsharedEvent new FileUnsharedEvent(unsharedFile: sf2)

core/src/test/groovy/com/muwire/core/files/HasherServiceTest.groovy

@@ -8,6 +8,7 @@ import org.junit.Before
 import org.junit.Test
 
 import com.muwire.core.EventBus
+import com.muwire.core.MuWireSettings
 
 class HasherServiceTest {
 
@@ -24,7 +25,7 @@ class HasherServiceTest {
 	void before() {
         eventBus = new EventBus()
 		hasher = new FileHasher()
-		service = new HasherService(hasher, eventBus)
+		service = new HasherService(hasher, eventBus, new FileManager(eventBus, new MuWireSettings()))
         eventBus.register(FileHashedEvent.class, listener)
 		service.start()
 	}

core/src/test/groovy/com/muwire/core/files/PersisterServiceLoadingTest.groovy

@@ -99,7 +99,7 @@ class PersisterServiceLoadingTest {
 		FileHasher fh = new FileHasher()
 		InfoHash ih1 = fh.hashFile(sharedFile1)
 		
-		assert ih1.getHashList().length == 2 * 32
+		assert ih1.getHashList().length == 96
 		
 		def json = [:]
 		json.file = getSharedFileJsonName(sharedFile1)
@@ -111,7 +111,9 @@ class PersisterServiceLoadingTest {
 		String hash1 = Base64.encode(tmp)
 		System.arraycopy(ih1.getHashList(), 32, tmp, 0, 32)
 		String hash2 = Base64.encode(tmp)
-		json.hashList = [hash1, hash2]
+        System.arraycopy(ih1.getHashList(), 64, tmp, 0, 32)
+        String hash3 = Base64.encode(tmp)
+		json.hashList = [hash1, hash2, hash3]
 		
 		json = JsonOutput.toJson(json)
 		

core/src/test/groovy/com/muwire/core/files/PersisterServiceSavingTest.groovy

@@ -8,6 +8,7 @@ import com.muwire.core.Destinations
 import com.muwire.core.DownloadedFile
 import com.muwire.core.EventBus
 import com.muwire.core.InfoHash
+import com.muwire.core.MuWireSettings
 import com.muwire.core.SharedFile
 import com.muwire.core.util.DataUtil
 
@@ -31,7 +32,7 @@ class PersisterServiceSavingTest {
 		f = new File("build.gradle")
 		f = f.getCanonicalFile()
 		ih = fh.hashFile(f)
-		fileSource = new FileManager(eventBus) {
+		fileSource = new FileManager(eventBus, new MuWireSettings()) {
 					Map<File, SharedFile> getSharedFiles() {
 						Map<File, SharedFile> rv = new HashMap<>()
 						rv.put(f, sf)
@@ -54,7 +55,7 @@ class PersisterServiceSavingTest {
 	
 	@Test
 	void testSavingSharedFile() {
-		sf = new SharedFile(f, ih)
+		sf = new SharedFile(f, ih, 0)
 		
 		ps = new PersisterService(persisted, eventBus, 100, fileSource)
 		ps.start()
@@ -73,7 +74,7 @@ class PersisterServiceSavingTest {
 	@Test
 	void testSavingDownloadedFile() {
 		Destinations dests = new Destinations()
-		sf = new DownloadedFile(f, ih, new HashSet([dests.dest1, dests.dest2]))
+		sf = new DownloadedFile(f, ih, 0, new HashSet([dests.dest1, dests.dest2]))
 		
 		ps = new PersisterService(persisted, eventBus, 100, fileSource)
 		ps.start()

core/src/test/groovy/com/muwire/core/search/SearchIndexTest.groovy

@@ -30,7 +30,18 @@ class SearchIndexTest {
 		assert found.size() == 2
 		assert found.contains("a b.c")
 		assert found.contains("c d.e")
+        
 	}
+    
+    @Test
+    public void testDrillDownDoesNotModifyIndex() {
+        initIndex(["a b.c", "c d.e"])
+        index.search(["c","e"])
+        def found = index.search(["c"])
+        assert found.size() == 2
+        assert found.contains("a b.c")
+        assert found.contains("c d.e")
+    }
 	
 	@Test
 	void testDrillDown() {

core/src/test/groovy/com/muwire/core/trust/TrustServiceTest.groovy

@@ -5,14 +5,17 @@ import org.junit.Before
 import org.junit.Test
 
 import com.muwire.core.Destinations
+import com.muwire.core.Persona
+import com.muwire.core.Personas
 
+import net.i2p.data.Base64
 import net.i2p.data.Destination
 
 class TrustServiceTest {
 
 	TrustService service
 	File persistGood, persistBad
-	Destinations dests = new Destinations()
+	Personas personas = new Personas()
 	
 	@Before
 	void before() {
@@ -33,51 +36,50 @@ class TrustServiceTest {
 	
 	@Test
 	void testEmpty() {
-		assert TrustLevel.NEUTRAL == service.getLevel(dests.dest1)
-		assert TrustLevel.NEUTRAL == service.getLevel(dests.dest2)
+		assert TrustLevel.NEUTRAL == service.getLevel(personas.persona1.destination)
+		assert TrustLevel.NEUTRAL == service.getLevel(personas.persona2.destination)
 	}
 	
 	@Test
 	void testOnEvent() {
-		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, destination: dests.dest1)
-		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, destination: dests.dest2)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, persona: personas.persona1)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, persona: personas.persona2)
 		
-		assert TrustLevel.TRUSTED == service.getLevel(dests.dest1)
-		assert TrustLevel.DISTRUSTED == service.getLevel(dests.dest2)
+		assert TrustLevel.TRUSTED == service.getLevel(personas.persona1.destination)
+		assert TrustLevel.DISTRUSTED == service.getLevel(personas.persona2.destination)
 	}
 	
 	@Test 
 	void testPersist() {
-		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, destination: dests.dest1)
-		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, destination: dests.dest2)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.TRUSTED, persona: personas.persona1)
+		service.onTrustEvent new TrustEvent(level: TrustLevel.DISTRUSTED, persona: personas.persona2)
 		
 		Thread.sleep(250)
 		def trusted = new HashSet<>()
 		persistGood.eachLine {
-			trusted.add(new Destination(it))
+			trusted.add(new Persona(new ByteArrayInputStream(Base64.decode(it))))
 		}
 		def distrusted = new HashSet<>()
 		persistBad.eachLine {
-			distrusted.add(new Destination(it))
+			distrusted.add(new Persona(new ByteArrayInputStream(Base64.decode(it))))
 		}
 		
 		assert trusted.size() == 1
-		assert trusted.contains(dests.dest1)
+		assert trusted.contains(personas.persona1)
 		assert distrusted.size() == 1
-		assert distrusted.contains(dests.dest2)
+		assert distrusted.contains(personas.persona2)
 	}
 	
 	@Test
 	void testLoad() {
 		service.stop()
-		persistGood.append("${dests.dest1.toBase64()}\n")
-		persistBad.append("${dests.dest2.toBase64()}\n")
+		persistGood.append("${personas.persona1.toBase64()}\n")
+		persistBad.append("${personas.persona2.toBase64()}\n")
 		service = new TrustService(persistGood, persistBad, 100)
 		service.start()
-		Thread.sleep(10)
+		Thread.sleep(50)
 		
-		assert TrustLevel.TRUSTED == service.getLevel(dests.dest1)
-		assert TrustLevel.DISTRUSTED == service.getLevel(dests.dest2)
-
+		assert TrustLevel.TRUSTED == service.getLevel(personas.persona1.destination)
+		assert TrustLevel.DISTRUSTED == service.getLevel(personas.persona2.destination)
 	}
 }

doc/infohash-upgrade.md

@@ -0,0 +1,37 @@
+# InfoHash Upgrade
+
+An infohash is a list of hashes of the pieces of the file.  In MuWire 0.1.0 the piece size is determined by policy based on the file size, with the intention being to keep the list of hashes to maximum 128 in number.  The reason for this is that infohashes get returned with search results, and smaller piece size will result in larger infohash which will slow down the transmission of search results.
+
+### The problem
+
+This presents the following problem - larger files have larger piece sizes: a 2GB file will have a 16MB piece size, a 4GB file 32MB and so on.  Pieces are atomic, i.e. if a download fails halfway through a piece it will resume since the beginning of the piece.  Unfortunately in the current state of I2P the failure rate of streaming connections is too high and transmitting an entire piece over a single connection is not likely to succeed as the size of the piece increases.  This makes downloading multi-gigabyte files nearly impossible.
+
+### Out-of-band request proposal
+
+Barring any improvement to the reliability of I2P connections, the following approach can be used to enable smaller piece sizes and the corresponding increase in download success rate of large files:
+
+* Search results do carry the full infohash of the file, instead they carry just the root and the number of 32-byte hashes in the infohash
+* When a downloader begins a download, it issues a request for the full infohash first.  Only after that is fetched and verified, the download proceeds as usual.
+
+Such approach is more complicated in nature than the current simplistic one, but it has the additional benefit of reducing the size of search results.
+
+### Wire protocol changes
+
+A new request method - "HASHLIST" is introduced.  It is immediately followed by the Base64 encoded root of the infohash and '\r\n'.  The request may contain HTTP headers in the same format as in HTTP 1.1.  One such header may be the X-Persona header, but that is optional.  After all the headers a blank line with just '\r\n' is sent.
+
+The response is identical to that of regular GET request, with the same response codes.  The response may also carry headers, and is also followed by a blank line with '\r\n'.  What follows immediately after that is a binary representation of the hashlist.  After sending the full hashlist, the uploader keeps the connection open in anticipation of the first content GET request.
+
+The downloader verifies the hashlist by hashing it with SHA256 and comparing it to the advertised infohash root.  If there is a match, it proceeds with the rest of the download as in MuWire 0.1.0.
+
+### Necessary changes to MuWire 0.1.0
+
+To accommodate this proposal in a backwards compatible manner, it is necessary to first de-hardcode the piece count computation logic which is currently hardcoded in a few places.  Then it is necessary to:
+
+* persist the piece size to disk when a file is being shared so that it can be returned in search results
+* search queries need to carry a flag of some kind that indicates support for out-of-band infohash support
+  * that in turn requires nodes to support passing of that flag as the queries are being routed through the network
+* the returned results need to indicate whether they are returning a full infohash or just a root; the "version" field in the json can be used for that
+
+### Roadmap
+
+Support for this proposal is currently intended for MuWire 0.2.0.  However, in order to make rollout smooth, in MuWire 0.1.1 support for the first two items will be introduced.  Since there already are users on the network who have shared files without persisting the size of their pieces on disk, those files will not be eligible to participate in this scheme unless re-shared (which implies re-hashing).

doc/wire-protocol.md

@@ -131,12 +131,18 @@ Sent by a leaf or ultrapeer when performing a search.  Contains the reply-to per
     firstHop: false,
     keywords : ["keyword1","keyword2"...]
     infohash: "asdfasdf...",
-    replyTo : "asdfasf...b64"
+    replyTo : "asdfasf...b64",
+    originator : "asfasdf...",
+    "oobHashlist" : true
 }
 ```
 
 A search can contain either the query entered by the user in the UI or the infohash if the user is looking for a specific file.  If both are present, the infohash takes precedence and the keyword query is ignored.
 
+The "originator" field contains the Base64-encoded persona of the originator of the query.  It is used for display purposes only.  The I2P destination in that persona must match the one in the "replyTo" field.
+
+The oobHashlist flag indicates support for out-of-band hashlist delivery, which is not yet implemented.  Nevertheless, this flag gets propagated through the network for future-proofing.
+
 ### Ultrapeer to leaf
 
 The "Search" message is also sent from an ultrapeer to a leaf.

gradle.properties

@@ -1,5 +1,5 @@
 group         = com.muwire
-version       = 0.0.2
+version       = 0.1.4
 groovyVersion = 2.4.15
 slf4jVersion  = 1.7.25
 spockVersion  = 1.1-groovy-2.4

gui/build.gradle

@@ -41,6 +41,7 @@ griffon {
 }
 
 mainClassName = 'com.muwire.gui.Launcher'
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']
 
 apply from: 'gradle/publishing.gradle'
 apply from: 'gradle/code-coverage.gradle'
@@ -58,6 +59,7 @@ dependencies {
     compile "org.codehaus.griffon:griffon-guice:${griffon.version}"
 
     runtime "org.slf4j:slf4j-simple:${slf4jVersion}"
+    runtime "javax.annotation:javax.annotation-api:1.3.2"
 
     testCompile "org.codehaus.griffon:griffon-fest-test:${griffon.version}"
     testCompile "org.spockframework:spock-core:${spockVersion}"

gui/griffon-app/conf/Config.groovy

@@ -16,4 +16,14 @@ mvcGroups {
         view = 'com.muwire.gui.MainFrameView'
         controller = 'com.muwire.gui.MainFrameController'
     }
-}
+    'SearchTab' {
+        model = 'com.muwire.gui.SearchTabModel'
+        view = 'com.muwire.gui.SearchTabView'
+        controller = 'com.muwire.gui.SearchTabController'
+    }
+    'Options' {
+        model = 'com.muwire.gui.OptionsModel'
+        view = 'com.muwire.gui.OptionsView'
+        controller = 'com.muwire.gui.OptionsController'
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/MainFrameController.groovy

@@ -3,11 +3,16 @@ package com.muwire.gui
 import griffon.core.GriffonApplication
 import griffon.core.artifact.GriffonController
 import griffon.core.controller.ControllerAction
+import griffon.core.mvc.MVCGroup
+import griffon.core.mvc.MVCGroupConfiguration
 import griffon.inject.MVCMember
 import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.Base64
+
 import javax.annotation.Nonnull
 import javax.inject.Inject
 
+import com.muwire.core.Constants
 import com.muwire.core.Core
 import com.muwire.core.download.DownloadStartedEvent
 import com.muwire.core.download.UIDownloadEvent
@@ -29,35 +34,148 @@ class MainFrameController {
     
     @ControllerAction
     void search() {
+        def cardsPanel = builder.getVariable("cards-panel")
+        cardsPanel.getLayout().show(cardsPanel, "search window")
+        
         def search = builder.getVariable("search-field").text
-        def searchEvent = new SearchEvent(searchTerms : [search], uuid : UUID.randomUUID())
+        def uuid = UUID.randomUUID()
+        Map<String, Object> params = new HashMap<>()
+        params["search-terms"] = search
+        params["uuid"] = uuid.toString()
+        def group = mvcGroup.createMVCGroup("SearchTab", uuid.toString(), params)
+        model.results[uuid.toString()] = group
+
+        def searchEvent
+        if (model.hashSearch) {
+            searchEvent = new SearchEvent(searchHash : Base64.decode(search), uuid : uuid)
+        } else {
+            // this can be improved a lot
+            def replaced = search.toLowerCase().trim().replaceAll(Constants.SPLIT_PATTERN, " ")
+            def terms = replaced.split(" ")
+            searchEvent = new SearchEvent(searchTerms : terms, uuid : uuid, oobInfohash: false)
+        }
         core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop : true, 
-            replyTo: core.me.destination, receivedOn: core.me.destination))
+            replyTo: core.me.destination, receivedOn: core.me.destination,
+            originator : core.me))
+    }
+    
+    void search(String infoHash, String tabTitle) {
+        def cardsPanel = builder.getVariable("cards-panel")
+        cardsPanel.getLayout().show(cardsPanel, "search window")
+        def uuid = UUID.randomUUID()
+        Map<String, Object> params = new HashMap<>()
+        params["search-terms"] = tabTitle
+        params["uuid"] = uuid.toString()
+        def group = mvcGroup.createMVCGroup("SearchTab", uuid.toString(), params)
+        model.results[uuid.toString()] = group
+        
+        def searchEvent = new SearchEvent(searchHash : Base64.decode(infoHash), uuid:uuid)
+        core.eventBus.publish(new QueryEvent(searchEvent : searchEvent, firstHop : true,
+            replyTo: core.me.destination, receivedOn: core.me.destination,
+            originator : core.me))
     }
     
     private def selectedResult() {
-        def resultsTable = builder.getVariable("results-table")
-        int row = resultsTable.getSelectedRow()
-        model.results[row]
+        def selected = builder.getVariable("result-tabs").getSelectedComponent()
+        def group = selected.getClientProperty("mvc-group")
+        def table = selected.getClientProperty("results-table")
+        int row = table.getSelectedRow()
+        if (row == -1)
+            return
+        def sortEvt = group.view.lastSortEvent
+        if (sortEvt != null) {
+            row = sortEvt.convertPreviousRowIndexToModel(row)
+        }
+        group.model.results[row]        
+    }
+    
+    private int selectedDownload() {
+        def selected = builder.getVariable("downloads-table").getSelectedRow()
+        def sortEvt = mvcGroup.view.lastDownloadSortEvent
+        if (sortEvt != null)
+            selected = sortEvt.convertPreviousRowIndexToModel(selected)
+        selected
     }
     
     @ControllerAction
     void download() {
         def result = selectedResult()
-        def file = new File(application.context.get("muwire-settings").downloadLocation, result.name) 
-        core.eventBus.publish(new UIDownloadEvent(result : result, target : file))
+        if (result == null)
+            return // TODO disable button
+            
+        def file = new File(application.context.get("muwire-settings").downloadLocation, result.name)
+        
+        def selected = builder.getVariable("result-tabs").getSelectedComponent()
+        def group = selected.getClientProperty("mvc-group")
+        
+        def resultsBucket = group.model.hashBucket[result.infohash]
+         
+        core.eventBus.publish(new UIDownloadEvent(result : resultsBucket, target : file))
     }
     
     @ControllerAction
     void trust() {
         def result = selectedResult()
-        core.eventBus.publish( new TrustEvent(destination : result.sender.destination, level : TrustLevel.TRUSTED))
+        if (result == null)
+            return // TODO disable button
+        core.eventBus.publish( new TrustEvent(persona : result.sender, level : TrustLevel.TRUSTED))
     }
     
     @ControllerAction
     void distrust() {
         def result = selectedResult()
-        core.eventBus.publish( new TrustEvent(destination : result.sender.destination, level : TrustLevel.DISTRUSTED))
+        if (result == null)
+            return // TODO disable button
+        core.eventBus.publish( new TrustEvent(persona : result.sender, level : TrustLevel.DISTRUSTED))
+    }
+    
+    @ControllerAction 
+    void cancel() {
+        def downloader = model.downloads[selectedDownload()].downloader
+        downloader.cancel()
+    }
+    
+    @ControllerAction
+    void resume() {
+        def downloader = model.downloads[selectedDownload()].downloader
+        downloader.resume()
+    }
+
+    private void markTrust(String tableName, TrustLevel level, def list) {
+        int row = builder.getVariable(tableName).getSelectedRow()
+        if (row < 0)
+            return
+        core.eventBus.publish(new TrustEvent(persona : list[row], level : level))
+    }
+    
+    @ControllerAction
+    void markTrusted() {
+        markTrust("distrusted-table", TrustLevel.TRUSTED, model.distrusted)
+    }
+    
+    @ControllerAction
+    void markNeutralFromDistrusted() {
+        markTrust("distrusted-table", TrustLevel.NEUTRAL, model.distrusted)
+    }
+    
+    @ControllerAction
+    void markDistrusted() {
+        markTrust("trusted-table", TrustLevel.DISTRUSTED, model.trusted)
+    }
+    
+    @ControllerAction
+    void markNeutralFromTrusted() {
+        markTrust("trusted-table", TrustLevel.NEUTRAL, model.trusted)
+    }
+    
+    @ControllerAction
+    void keywordSearch() {
+        model.hashSearch = false
+    }
+    
+    @ControllerAction
+    void hashSearch() {
+        model.hashSearch = true
     }
     
     void mvcGroupInit(Map<String, String> args) {

gui/griffon-app/controllers/com/muwire/gui/OptionsController.groovy

@@ -0,0 +1,77 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+import com.muwire.core.Core
+
+@ArtifactProviderFor(GriffonController)
+class OptionsController {
+    @MVCMember @Nonnull
+    OptionsModel model
+    @MVCMember @Nonnull
+    OptionsView view
+
+    @ControllerAction
+    void save() {
+        String text
+        Core core = application.context.get("core")
+        
+        def i2pProps = core.i2pOptions
+        
+        text = view.inboundLengthField.text
+        model.inboundLength = text
+        i2pProps["inbound.length"] = text
+        
+        text = view.inboundQuantityField.text
+        model.inboundQuantity = text
+        i2pProps["inbound.quantity"] = text
+        
+        text = view.outboundQuantityField.text
+        model.outboundQuantity = text
+        i2pProps["outbound.quantity"] = text
+        
+        text = view.outboundLengthField.text
+        model.outboundLength = text
+        i2pProps["outbound.length"] = text
+        
+        File i2pSettingsFile = new File(core.home, "i2p.properties")
+        i2pSettingsFile.withOutputStream { 
+            i2pProps.store(it,"")
+        }
+                
+        text = view.retryField.text
+        model.downloadRetryInterval = text
+
+        def settings = application.context.get("muwire-settings")
+        settings.downloadRetryInterval = Integer.valueOf(text)
+
+        text = view.updateField.text
+        model.updateCheckInterval = text
+        settings.updateCheckInterval = Integer.valueOf(text)
+
+        boolean onlyTrusted = view.allowUntrustedCheckbox.model.isSelected()
+        model.onlyTrusted = onlyTrusted
+        settings.setAllowUntrusted(!onlyTrusted)
+        
+        boolean shareDownloaded = view.shareDownloadedCheckbox.model.isSelected()
+        model.shareDownloadedFiles = shareDownloaded
+        settings.shareDownloadedFiles = shareDownloaded
+                        
+        File settingsFile = new File(core.home, "MuWire.properties")
+        settingsFile.withOutputStream { 
+            settings.write(it)
+        }
+        
+        cancel()
+    }
+    
+    @ControllerAction
+    void cancel() {
+        view.d.setVisible(false)
+        mvcGroup.destroy()
+    }
+}

gui/griffon-app/controllers/com/muwire/gui/SearchTabController.groovy

@@ -0,0 +1,11 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonController
+import griffon.core.controller.ControllerAction
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonController)
+class SearchTabController {
+}

gui/griffon-app/lifecycle/Initialize.groovy

@@ -8,6 +8,7 @@ import com.muwire.core.MuWireSettings
 
 import javax.annotation.Nonnull
 import javax.inject.Inject
+import javax.swing.JTable
 
 import static griffon.util.GriffonApplicationUtils.isMacOSX
 import static groovy.swing.SwingBuilder.lookAndFeel
@@ -21,7 +22,11 @@ class Initialize extends AbstractLifecycleHandler {
 
     @Override
     void execute() {
-        lookAndFeel((isMacOSX ? 'system' : 'nimbus'), 'gtk', ['metal', [boldFonts: false]])
+        if (isMacOSX()) {
+            lookAndFeel('nimbus') // otherwise the file chooser doesn't open???
+        } else {
+            lookAndFeel('system', 'gtk')
+        }
     }
 }
 

gui/griffon-app/lifecycle/Ready.groovy

@@ -1,10 +1,13 @@
 import griffon.core.GriffonApplication
+import griffon.core.env.Metadata
 import groovy.util.logging.Log
+import net.i2p.util.SystemVersion
 
 import org.codehaus.griffon.runtime.core.AbstractLifecycleHandler
 
 import com.muwire.core.Core
 import com.muwire.core.MuWireSettings
+import com.muwire.core.UILoadedEvent
 import com.muwire.core.files.FileSharedEvent
 
 import javax.annotation.Nonnull
@@ -16,9 +19,13 @@ import static griffon.util.GriffonApplicationUtils.isMacOSX
 import static groovy.swing.SwingBuilder.lookAndFeel
 
 import java.beans.PropertyChangeEvent
+import java.util.logging.Level
 
 @Log
 class Ready extends AbstractLifecycleHandler {
+    
+    @Inject Metadata metadata
+    
     @Inject
     Ready(@Nonnull GriffonApplication application) {
         super(application)
@@ -27,11 +34,15 @@ class Ready extends AbstractLifecycleHandler {
     @Override
     void execute() {
         log.info "starting core services"
-        def home = System.getProperty("user.home") + File.separator + ".MuWire"
+        def portableHome = System.getProperty("portable.home")
+        def home = portableHome == null ? 
+            selectHome() :
+            portableHome
+            
         home = new File(home)
         if (!home.exists()) {
-            log.info("creating home dir")
-            home.mkdir()
+            log.info("creating home dir $home")
+            home.mkdirs()
         }
         
         def props = new Properties()
@@ -63,8 +74,13 @@ class Ready extends AbstractLifecycleHandler {
                 nickname = nickname.trim()
                 break
             }
+            props.setNickname(nickname)
             
-            while(true) {
+            
+            def portableDownloads = System.getProperty("portable.downloads")
+            if (portableDownloads != null) {
+                props.downloadLocation = new File(portableDownloads)
+            } else {
                 def chooser = new JFileChooser()
                 chooser.setDialogTitle("Select a directory where downloads will be saved")
                 chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY)
@@ -74,15 +90,22 @@ class Ready extends AbstractLifecycleHandler {
                     System.exit(0)
                 }
                 props.downloadLocation = chooser.getSelectedFile()
-                break
             }
-            props.setNickname(nickname)
+            
             propsFile.withOutputStream {
                 props.write(it)
             }
         }
         
-        Core core = new Core(props, home)
+        Core core
+        try {
+            core = new Core(props, home, metadata["application.version"])
+        } catch (Exception bad) {
+            log.log(Level.SEVERE,"couldn't initialize core",bad)
+            JOptionPane.showMessageDialog(null, "Couldn't connect to I2P router.  Make sure I2P is running and restart MuWire",
+                "Can't connect to I2P router", JOptionPane.WARNING_MESSAGE)
+            System.exit(0)
+        }
         core.startServices()
         application.context.put("muwire-settings", props)
         application.context.put("core",core)
@@ -95,6 +118,28 @@ class Ready extends AbstractLifecycleHandler {
                 core.eventBus.publish(new FileSharedEvent(file : new File(it)))
             }
         }
+        
+        core.eventBus.publish(new UILoadedEvent())
+    }
+    
+    private static String selectHome() {
+        def home = new File(System.properties["user.home"])
+        def defaultHome = new File(home, ".MuWire")
+        if (defaultHome.exists())
+            return defaultHome.getAbsolutePath()
+        if (SystemVersion.isMac()) { 
+            def library = new File(home, "Library")
+            def appSupport = new File(library, "Application Support")
+            def muwire = new File(appSupport,"MuWire")
+            return muwire.getAbsolutePath()
+        }
+        if (SystemVersion.isWindows()) {
+            def appData = new File(home,"AppData")
+            def roaming = new File(appData, "Roaming")
+            def muwire = new File(roaming, "MuWire")
+            return muwire.getAbsolutePath()
+        }
+        defaultHome.getAbsolutePath()
     }
 }
 

gui/griffon-app/lifecycle/Shutdown.groovy

@@ -0,0 +1,25 @@
+
+import javax.annotation.Nonnull
+import javax.inject.Inject
+
+import org.codehaus.griffon.runtime.core.AbstractLifecycleHandler
+
+import com.muwire.core.Core
+
+import griffon.core.GriffonApplication
+import groovy.util.logging.Log
+
+@Log
+class Shutdown extends AbstractLifecycleHandler {
+    @Inject
+    Shutdown(@Nonnull GriffonApplication application) {
+        super(application)
+    }
+    
+    @Override
+    void execute() {
+        log.info("shutting down")
+        Core core = application.context.get("core")
+        core.shutdown()
+    }
+}

gui/griffon-app/models/com/muwire/gui/MainFrameModel.groovy

@@ -1,50 +1,97 @@
 package com.muwire.gui
 
+import java.util.concurrent.ConcurrentHashMap
+
 import javax.annotation.Nonnull
 import javax.inject.Inject
+import javax.swing.JOptionPane
 import javax.swing.JTable
 
 import com.muwire.core.Core
 import com.muwire.core.InfoHash
+import com.muwire.core.Persona
 import com.muwire.core.connection.ConnectionAttemptStatus
 import com.muwire.core.connection.ConnectionEvent
 import com.muwire.core.connection.DisconnectionEvent
 import com.muwire.core.download.DownloadStartedEvent
+import com.muwire.core.download.Downloader
+import com.muwire.core.files.FileDownloadedEvent
 import com.muwire.core.files.FileHashedEvent
 import com.muwire.core.files.FileLoadedEvent
 import com.muwire.core.files.FileSharedEvent
+import com.muwire.core.search.QueryEvent
 import com.muwire.core.search.UIResultEvent
 import com.muwire.core.trust.TrustEvent
 import com.muwire.core.trust.TrustService
+import com.muwire.core.update.UpdateAvailableEvent
 import com.muwire.core.upload.UploadEvent
 import com.muwire.core.upload.UploadFinishedEvent
 
 import griffon.core.GriffonApplication
 import griffon.core.artifact.GriffonModel
+import griffon.core.env.Metadata
+import griffon.core.mvc.MVCGroup
 import griffon.inject.MVCMember
 import griffon.transform.FXObservable
 import griffon.transform.Observable
+import net.i2p.data.Destination
 import griffon.metadata.ArtifactProviderFor
 
 @ArtifactProviderFor(GriffonModel)
 class MainFrameModel {
+    @Inject Metadata metadata
     @MVCMember @Nonnull
     FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    MainFrameController controller
     @Inject @Nonnull GriffonApplication application
     @Observable boolean coreInitialized = false
     
-    @Observable def results = []
-    @Observable def downloads = []
-    @Observable def uploads = []
-    @Observable def shared = []
+    def results = new ConcurrentHashMap<>()
+    def downloads = []
+    def uploads = []
+    def shared = []
+    def connectionList = []
+    def searches = new LinkedList()
+    def trusted = []
+    def distrusted = []
+    
+    boolean hashSearch
+    
     @Observable int connections
     @Observable String me
+    @Observable boolean searchButtonsEnabled
+    @Observable boolean cancelButtonEnabled
+    @Observable boolean retryButtonEnabled
     
     private final Set<InfoHash> infoHashes = new HashSet<>()
 
     volatile Core core    
+
+    private long lastRetryTime = System.currentTimeMillis()
+        
+    void updateTablePreservingSelection(String tableName) {
+        def downloadTable = builder.getVariable(tableName)
+        int selectedRow = downloadTable.getSelectedRow()
+        downloadTable.model.fireTableDataChanged()
+        downloadTable.selectionModel.setSelectionInterval(selectedRow,selectedRow)
+    }
     
     void mvcGroupInit(Map<String, Object> args) {
+        
+        Timer timer = new Timer("download-pumper", true)
+        timer.schedule({
+            runInsideUIAsync {
+                if (!mvcGroup.alive)
+                    return
+                builder.getVariable("uploads-table")?.model.fireTableDataChanged()
+                
+                updateTablePreservingSelection("downloads-table")
+                updateTablePreservingSelection("trusted-table")
+                updateTablePreservingSelection("distrusted-table")
+            }
+        }, 1000, 1000)
+
         application.addPropertyChangeListener("core", {e ->
             coreInitialized = (e.getNewValue() != null)
             core = e.getNewValue()
@@ -58,22 +105,42 @@ class MainFrameModel {
             core.eventBus.register(UploadEvent.class, this)
             core.eventBus.register(UploadFinishedEvent.class, this)
             core.eventBus.register(TrustEvent.class, this)
-        })
-        Timer timer = new Timer("download-pumper", true)
-        timer.schedule({
+            core.eventBus.register(QueryEvent.class, this)
+            core.eventBus.register(UpdateAvailableEvent.class, this)
+            core.eventBus.register(FileDownloadedEvent.class, this)
+            
+            timer.schedule({
+                int retryInterval = application.context.get("muwire-settings").downloadRetryInterval
+                if (retryInterval > 0) {
+                    retryInterval *= 60000
+                    long now = System.currentTimeMillis()
+                    if (now - lastRetryTime > retryInterval) {
+                        lastRetryTime = now
+                        runInsideUIAsync {
+                            downloads.each {
+                                def state = it.downloader.currentState
+                                if (state == Downloader.DownloadState.FAILED || 
+                                    state == Downloader.DownloadState.DOWNLOADING)
+                                    it.downloader.resume()
+                                updateTablePreservingSelection("downloads-table")
+                            }
+                        }
+
+                    }
+                }
+            }, 60000, 60000)
+            
             runInsideUIAsync {
-                builder.getVariable("downloads-table").model.fireTableDataChanged()
-                builder.getVariable("uploads-table").model.fireTableDataChanged()
+                trusted.addAll(core.trustService.good.values())
+                distrusted.addAll(core.trustService.bad.values())
             }
-        }, 1000, 1000)
+        })
+        
     }
     
     void onUIResultEvent(UIResultEvent e) {
-        runInsideUIAsync {
-            results << e
-            JTable table = builder.getVariable("results-table")
-            table.model.fireTableDataChanged()
-        }
+        MVCGroup resultsGroup = results.get(e.uuid)
+        resultsGroup?.model.handleResult(e)
     }
     
     void onDownloadStartedEvent(DownloadStartedEvent e) {
@@ -83,14 +150,34 @@ class MainFrameModel {
     }
     
     void onConnectionEvent(ConnectionEvent e) {
+        if (e.getStatus() != ConnectionAttemptStatus.SUCCESSFUL)
+            return
         runInsideUIAsync {
             connections = core.connectionManager.getConnections().size()
+            
+            if (connections > 0) {
+                def topPanel = builder.getVariable("top-panel")
+                topPanel.getLayout().show(topPanel, "top-search-panel")
+            }
+            
+            connectionList.add(e.endpoint.destination)
+            JTable table = builder.getVariable("connections-table")
+            table.model.fireTableDataChanged()
         }
     }
     
     void onDisconnectionEvent(DisconnectionEvent e) {
         runInsideUIAsync {
             connections = core.connectionManager.getConnections().size()
+            
+            if (connections == 0) {
+                def topPanel = builder.getVariable("top-panel")
+                topPanel.getLayout().show(topPanel, "top-connect-panel")
+            }
+            
+            connectionList.remove(e.destination)
+            JTable table = builder.getVariable("connections-table")
+            table.model.fireTableDataChanged()
         }
     }
     
@@ -136,7 +223,66 @@ class MainFrameModel {
     
     void onTrustEvent(TrustEvent e) {
         runInsideUIAsync {
-            JTable table = builder.getVariable("results-table")
+            
+            trusted.clear()
+            trusted.addAll(core.trustService.good.values())
+            distrusted.clear()
+            distrusted.addAll(core.trustService.bad.values())
+            
+            updateTablePreservingSelection("trusted-table")
+            updateTablePreservingSelection("distrusted-table")
+            
+            results.values().each { 
+                it.view.pane.getClientProperty("results-table")?.model.fireTableDataChanged()
+            }
+        }
+    }
+    
+    void onQueryEvent(QueryEvent e) {
+        if (e.replyTo == core.me.destination)
+            return
+        StringBuilder sb = new StringBuilder()
+        e.searchEvent.searchTerms?.each {
+            sb.append(it)
+            sb.append(" ")
+        }
+        def search = sb.toString()
+        if (search.trim().size() == 0)
+            return
+        runInsideUIAsync {
+            searches.addFirst(new IncomingSearch(search : search, replyTo : e.replyTo, originator : e.originator))
+            while(searches.size() > 200)
+                searches.removeLast()
+            JTable table = builder.getVariable("searches-table")
+            table.model.fireTableDataChanged()
+        }
+    }
+    
+    class IncomingSearch {
+        String search
+        Destination replyTo
+        Persona originator
+    }
+    
+    void onUpdateAvailableEvent(UpdateAvailableEvent e) {
+        runInsideUIAsync {
+            
+            int option = JOptionPane.showConfirmDialog(null, 
+                "MuWire $e.version is available from $e.signer.  You have "+ metadata["application.version"]+" Update?",
+                "New MuWire version availble", JOptionPane.OK_CANCEL_OPTION)
+            if (option == JOptionPane.CANCEL_OPTION)
+                return
+            controller.search(e.infoHash,"MuWire update")
+        }
+    }
+    
+    void onFileDownloadedEvent(FileDownloadedEvent e) {
+        if (!core.muOptions.shareDownloadedFiles)
+            return
+        infoHashes.add(e.downloadedFile.infoHash)
+        runInsideUIAsync {
+            shared << e.downloadedFile
+            JTable table = builder.getVariable("shared-files-table")
             table.model.fireTableDataChanged()
         }
     }

gui/griffon-app/models/com/muwire/gui/OptionsModel.groovy

@@ -0,0 +1,36 @@
+package com.muwire.gui
+
+import com.muwire.core.Core
+import com.muwire.core.MuWireSettings
+
+import griffon.core.artifact.GriffonModel
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class OptionsModel {
+    @Observable String downloadRetryInterval 
+    @Observable String updateCheckInterval
+    @Observable boolean onlyTrusted
+    @Observable boolean shareDownloadedFiles
+    
+    // i2p options
+    @Observable String inboundLength
+    @Observable String inboundQuantity
+    @Observable String outboundLength
+    @Observable String outboundQuantity
+    
+    void mvcGroupInit(Map<String, String> args) {
+        MuWireSettings settings = application.context.get("muwire-settings")
+        downloadRetryInterval = settings.downloadRetryInterval
+        updateCheckInterval = settings.updateCheckInterval
+        onlyTrusted = !settings.allowUntrusted()
+        shareDownloadedFiles = settings.shareDownloadedFiles
+        
+        Core core = application.context.get("core")
+        inboundLength = core.i2pOptions["inbound.length"]
+        inboundQuantity = core.i2pOptions["inbound.quantity"]
+        outboundLength = core.i2pOptions["outbound.length"]
+        outboundQuantity = core.i2pOptions["outbound.quantity"]
+    }
+}

gui/griffon-app/models/com/muwire/gui/SearchTabModel.groovy

@@ -0,0 +1,50 @@
+package com.muwire.gui
+
+import javax.annotation.Nonnull
+import javax.inject.Inject
+import javax.swing.JTable
+
+import com.muwire.core.Core
+import com.muwire.core.search.UIResultEvent
+
+import griffon.core.artifact.GriffonModel
+import griffon.core.mvc.MVCGroup
+import griffon.inject.MVCMember
+import griffon.transform.Observable
+import griffon.metadata.ArtifactProviderFor
+
+@ArtifactProviderFor(GriffonModel)
+class SearchTabModel {
+    @MVCMember @Nonnull
+    FactoryBuilderSupport builder
+    
+    Core core
+    String uuid
+    def results = []
+    def hashBucket = [:]
+    
+    
+    void mvcGroupInit(Map<String, String> args) {
+        core = mvcGroup.parentGroup.model.core
+        mvcGroup.parentGroup.model.results[UUID.fromString(uuid)] = mvcGroup
+    }
+    
+    void mvcGroupDestroy() {
+        mvcGroup.parentGroup.model.results.remove(uuid)
+    }
+    
+    void handleResult(UIResultEvent e) {
+        runInsideUIAsync {
+            def bucket = hashBucket.get(e.infohash)
+            if (bucket == null) {
+                bucket = []
+                hashBucket[e.infohash] = bucket
+            }
+            bucket << e
+                            
+            results << e
+            JTable table = builder.getVariable("results-table")
+            table.model.fireTableDataChanged()
+        }
+    }
+}

gui/griffon-app/views/com/muwire/gui/MainFrameView.groovy

@@ -3,15 +3,21 @@ package com.muwire.gui
 import griffon.core.artifact.GriffonView
 import griffon.inject.MVCMember
 import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.DataHelper
 
 import javax.swing.BorderFactory
 import javax.swing.Box
 import javax.swing.BoxLayout
 import javax.swing.JFileChooser
+import javax.swing.JLabel
 import javax.swing.JSplitPane
+import javax.swing.ListSelectionModel
 import javax.swing.SwingConstants
 import javax.swing.border.Border
+import javax.swing.table.DefaultTableCellRenderer
 
+import com.muwire.core.Constants
+import com.muwire.core.download.Downloader
 import com.muwire.core.files.FileSharedEvent
 
 import java.awt.BorderLayout
@@ -20,6 +26,7 @@ import java.awt.FlowLayout
 import java.awt.GridBagConstraints
 import java.awt.GridBagLayout
 import java.awt.Insets
+import java.nio.charset.StandardCharsets
 
 import javax.annotation.Nonnull
 
@@ -30,6 +37,9 @@ class MainFrameView {
     @MVCMember @Nonnull
     MainFrameModel model
     
+    def downloadsTable
+    def lastDownloadSortEvent
+    
     void initUI() {
         builder.with {
             application(size : [1024,768], id: 'main-frame',
@@ -41,6 +51,11 @@ class MainFrameView {
                 imageIcon('/griffon-icon-16x16.png').image],
             pack : false,
             visible : bind { model.coreInitialized }) {
+                menuBar {
+                    menu (text : "Options") {
+                        menuItem("Configuration", actionPerformed : {mvcGroup.createMVCGroup("Options")})
+                    }
+                }
                 borderLayout()
                 panel (border: etchedBorder(), constraints : BorderLayout.NORTH) {
                     borderLayout()
@@ -48,15 +63,31 @@ class MainFrameView {
                         gridLayout(rows:1, cols: 2)
                         button(text: "Searches", actionPerformed : showSearchWindow)
                         button(text: "Uploads", actionPerformed : showUploadsWindow)
+                        button(text: "Monitor", actionPerformed : showMonitorWindow)
+                        button(text: "Trust", actionPerformed : showTrustWindow)
                     }
-                    panel(constraints: BorderLayout.CENTER) {
-                        borderLayout()
-                        label("Enter search here:", constraints: BorderLayout.WEST)
-                        textField(id: "search-field", constraints: BorderLayout.CENTER, action : searchAction)
-                        
-                    }
-                    panel( constraints: BorderLayout.EAST) {
-                        button(text: "Search", searchAction)
+                    panel(id: "top-panel", constraints: BorderLayout.CENTER) {
+                        cardLayout()
+                        label(constraints : "top-connect-panel",
+                            text : "        MuWire is connecting, please wait.  You will be able to search soon.") // TODO: real padding
+                        panel(constraints : "top-search-panel") {
+                            borderLayout()
+                            panel(constraints: BorderLayout.CENTER) {
+                                borderLayout()
+                                label("        Enter search here:", constraints: BorderLayout.WEST) // TODO: fix this
+                                textField(id: "search-field", constraints: BorderLayout.CENTER, action : searchAction)
+
+                            }
+                            panel( constraints: BorderLayout.EAST) {
+                                panel {
+                                    buttonGroup(id : "searchButtonGroup") 
+                                    radioButton(text : "Keywords", selected : true, buttonGroup : searchButtonGroup, keywordSearchAction)
+                                    radioButton(text : "Hash", selected : false, buttonGroup : searchButtonGroup, hashSearchAction)
+                                    
+                                }
+                                button(text: "Search", searchAction)
+                            }
+                        }
                     }
                 }
                 panel (id: "cards-panel", constraints : BorderLayout.CENTER) {
@@ -67,44 +98,36 @@ class MainFrameView {
                         continuousLayout : true, constraints : BorderLayout.CENTER) {
                             panel (constraints : JSplitPane.TOP) {
                                 borderLayout()
-                                scrollPane (constraints : BorderLayout.CENTER){
-                                    table(id : "results-table") {
-                                        tableModel(list: model.results) {
-                                            closureColumn(header: "Name", type: String, read : {row -> row.name})
-                                            closureColumn(header: "Size", preferredWidth: 150, type: Long, read : {row -> row.size})
-                                            closureColumn(header: "Sender", type: String, read : {row -> row.sender.getHumanReadableName()})
-                                            closureColumn(header: "Trust", type: String, read : {row ->
-                                              model.core.trustService.getLevel(row.sender.destination)  
-                                            })
-                                        }
-                                    }
-                                }
+                                tabbedPane(id : "result-tabs", constraints: BorderLayout.CENTER)
                                 panel(constraints : BorderLayout.SOUTH) {
-                                    button(text : "Download", downloadAction)
-                                    button(text : "Trust", trustAction)
-                                    button(text : "Distrust", distrustAction)
+                                    button(text : "Download", enabled : bind {model.searchButtonsEnabled}, downloadAction)
+                                    button(text : "Trust", enabled: bind {model.searchButtonsEnabled }, trustAction)
+                                    button(text : "Distrust", enabled : bind {model.searchButtonsEnabled}, distrustAction)
                                 }
                             }
                             panel (constraints : JSplitPane.BOTTOM) {
                                 borderLayout()
                                 scrollPane (constraints : BorderLayout.CENTER) {
-                                    table(id : "downloads-table") {
+                                    downloadsTable = table(id : "downloads-table", autoCreateRowSorter : true) {
                                         tableModel(list: model.downloads) {
-                                            closureColumn(header: "Name", type: String, read : {row -> row.downloader.file.getName()})
-                                            closureColumn(header: "Status", type: String, read : {row -> row.downloader.getCurrentState()})
-                                            closureColumn(header: "Progress", type: String, read: { row ->
+                                            closureColumn(header: "Name", preferredWidth: 350, type: String, read : {row -> row.downloader.file.getName()})
+                                            closureColumn(header: "Status", preferredWidth: 50, type: String, read : {row -> row.downloader.getCurrentState().toString()})
+                                            closureColumn(header: "Progress", preferredWidth: 20, type: String, read: { row ->
                                                 int pieces = row.downloader.nPieces
                                                 int done = row.downloader.donePieces()
                                                 "$done/$pieces pieces"
                                             })
-                                            closureColumn(header: "Piece", type: String, read: { row ->
-                                                int position = row.downloader.positionInPiece()
-                                                int pieceSize = row.downloader.pieceSize // TODO: fix for last piece
-                                                "$position/$pieceSize bytes"
+                                            closureColumn(header: "Sources", preferredWidth : 10, type: Integer, read : {row -> row.downloader.activeWorkers()})
+                                            closureColumn(header: "Speed", preferredWidth: 50, type:String, read :{row -> 
+                                                DataHelper.formatSize2Decimal(row.downloader.speed(), false) + "B/sec"
                                             })
                                         }
                                     }
                                 }
+                                panel (constraints : BorderLayout.SOUTH) {
+                                    button(text: "Cancel", enabled : bind {model.cancelButtonEnabled }, cancelAction )
+                                    button(text: "Retry", enabled : bind {model.retryButtonEnabled}, resumeAction)
+                                }
                             }
                         }
                     }
@@ -113,20 +136,23 @@ class MainFrameView {
                         panel {
                             borderLayout()
                             panel (constraints : BorderLayout.NORTH) {
-                                button(text : "Shared files", actionPerformed : shareFiles)
+                                button(text : "Click here to share files", actionPerformed : shareFiles)
                             }
                             scrollPane ( constraints : BorderLayout.CENTER) {
-                                table(id : "shared-files-table") {
+                                table(id : "shared-files-table", autoCreateRowSorter: true) {
                                      tableModel(list : model.shared) {
-                                         closureColumn(header : "Name", type : String, read : {row -> row.file.getAbsolutePath()})
-                                         closureColumn(header : "Size", type : Long, read : {row -> row.file.length()})
+                                         closureColumn(header : "Name", preferredWidth : 550, type : String, read : {row -> row.file.getAbsolutePath()})
+                                         closureColumn(header : "Size", preferredWidth : 50, type : String, 
+                                             read : {row -> DataHelper.formatSize2Decimal(row.file.length(),false) + "B"})
                                      }   
                                 }
                             }
                         }
                         panel {
                             borderLayout()
-                            label("Uploads", constraints : BorderLayout.NORTH)
+                            panel (constraints : BorderLayout.NORTH){
+                                label("Uploads")
+                            }
                             scrollPane (constraints : BorderLayout.CENTER) {
                                 table(id : "uploads-table") {
                                     tableModel(list : model.uploads) {
@@ -138,11 +164,86 @@ class MainFrameView {
                                             int percent = (int)((position * 100.0) / total)
                                             "$percent%"
                                         })
+                                        closureColumn(header : "Downloader", type : String, read : { row -> 
+                                            row.request.downloader?.getHumanReadableName()
+                                        })
                                     }
                                 }
                             }
                         }
                     }
+                    panel (constraints: "monitor window") {
+                        gridLayout(rows : 1, cols : 2)
+                        panel {
+                            borderLayout()
+                            panel (constraints : BorderLayout.NORTH){
+                                label("Connections")
+                            }
+                            scrollPane(constraints : BorderLayout.CENTER) {
+                                table(id : "connections-table") {
+                                    tableModel(list : model.connectionList) {
+                                        closureColumn(header : "Destination", type: String, read : { row -> row.toBase32() })
+                                    }
+                                }
+                            }
+                        }
+                        panel {
+                            borderLayout()
+                            panel (constraints : BorderLayout.NORTH){
+                                label("Incoming searches")
+                            }
+                            scrollPane(constraints : BorderLayout.CENTER) {
+                                table(id : "searches-table") {
+                                    tableModel(list : model.searches) {
+                                        closureColumn(header : "Keywords", type : String, read : { 
+                                            sanitized = it.search.replace('<', ' ')
+                                            sanitized 
+                                        })
+                                        closureColumn(header : "From", type : String, read : {
+                                            if (it.originator != null) {
+                                                return it.originator.getHumanReadableName()
+                                            } else {
+                                                return it.replyTo.toBase32()
+                                            }
+                                        })
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    panel(constraints : "trust window") {
+                        gridLayout(rows: 1, cols :2)
+                        panel (border : etchedBorder()){
+                            borderLayout()
+                            scrollPane(constraints : BorderLayout.CENTER) {
+                                table(id : "trusted-table", autoCreateRowSorter : true) {
+                                    tableModel(list : model.trusted) {
+                                        closureColumn(header : "Trusted Users", type : String, read : { it.getHumanReadableName() } )
+                                    }
+                                }
+                            }
+                            panel (constraints : BorderLayout.EAST) {
+                                gridBagLayout()
+                                button(text : "Mark Neutral", constraints : gbc(gridx: 0, gridy: 0), markNeutralFromTrustedAction)
+                                button(text : "Mark Distrusted", constraints : gbc(gridx: 0, gridy:1), markDistrustedAction)
+                            }
+                        }
+                        panel (border : etchedBorder()){
+                            borderLayout()
+                            scrollPane(constraints : BorderLayout.CENTER) {
+                                table(id : "distrusted-table", autoCreateRowSorter : true) {
+                                    tableModel(list : model.distrusted) {
+                                        closureColumn(header: "Distrusted Users", type : String, read : { it.getHumanReadableName() } )
+                                    }
+                                }
+                            }
+                            panel(constraints : BorderLayout.WEST) {
+                                gridBagLayout()
+                                button(text: "Mark Neutral", constraints: gbc(gridx: 0, gridy: 0), markNeutralFromDistrustedAction)
+                                button(text: "Mark Trusted", constraints : gbc(gridx: 0, gridy : 1), markTrustedAction)
+                            }
+                        }
+                    }
                 }
                 panel (border: etchedBorder(), constraints : BorderLayout.SOUTH) {
                     borderLayout()
@@ -156,7 +257,44 @@ class MainFrameView {
             }
         }
     }
+    
+    void mvcGroupInit(Map<String, String> args) {
+        def downloadsTable = builder.getVariable("downloads-table")
+        def selectionModel = downloadsTable.getSelectionModel()
+        selectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
+        selectionModel.addListSelectionListener({
+            int selectedRow = selectedDownloaderRow()
+            def downloader = model.downloads[selectedRow].downloader
+            switch(downloader.getCurrentState()) {
+                case Downloader.DownloadState.CONNECTING :
+                case Downloader.DownloadState.DOWNLOADING :
+                model.cancelButtonEnabled = true
+                model.retryButtonEnabled = false
+                break
+                case Downloader.DownloadState.FAILED:
+                model.cancelButtonEnabled = false
+                model.retryButtonEnabled = true
+                break
+                default:
+                model.cancelButtonEnabled = false
+                model.retryButtonEnabled = false
+            }
+        })
+        
+        def centerRenderer = new DefaultTableCellRenderer()
+        centerRenderer.setHorizontalAlignment(JLabel.CENTER)
+        downloadsTable.setDefaultRenderer(Integer.class, centerRenderer)
+        
+        downloadsTable.rowSorter.addRowSorterListener({evt -> lastDownloadSortEvent = evt})
+    }
 
+    int selectedDownloaderRow() {
+        int selected = builder.getVariable("downloads-table").getSelectedRow()
+        if (lastDownloadSortEvent != null)
+            selected = lastDownloadSortEvent.convertPreviousRowIndexToModel(selected)
+        selected
+    }
+    
     def showSearchWindow = {
         def cardsPanel = builder.getVariable("cards-panel")
         cardsPanel.getLayout().show(cardsPanel, "search window")
@@ -167,6 +305,16 @@ class MainFrameView {
         cardsPanel.getLayout().show(cardsPanel, "uploads window")
     }
     
+    def showMonitorWindow = {
+        def cardsPanel = builder.getVariable("cards-panel")
+        cardsPanel.getLayout().show(cardsPanel,"monitor window")
+    }
+    
+    def showTrustWindow = {
+        def cardsPanel = builder.getVariable("cards-panel")
+        cardsPanel.getLayout().show(cardsPanel,"trust window")
+    }
+    
     def shareFiles = {
         def chooser = new JFileChooser()
         chooser.setDialogTitle("Select file or directory to share")

gui/griffon-app/views/com/muwire/gui/OptionsView.groovy

@@ -0,0 +1,103 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonView
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+
+import javax.swing.JDialog
+import javax.swing.JPanel
+import javax.swing.JTabbedPane
+import javax.swing.SwingConstants
+
+import java.awt.BorderLayout
+import java.awt.event.WindowAdapter
+import java.awt.event.WindowEvent
+
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonView)
+class OptionsView {
+    @MVCMember @Nonnull
+    FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    OptionsModel model
+
+    def d
+    def p
+    def i
+    def retryField
+    def updateField
+    def allowUntrustedCheckbox
+    def shareDownloadedCheckbox
+    
+    def inboundLengthField
+    def inboundQuantityField
+    def outboundLengthField
+    def outboundQuantityField
+
+    def buttonsPanel    
+    
+    def mainFrame
+    
+    void initUI() {
+        mainFrame = application.windowManager.findWindow("main-frame")
+        d = new JDialog(mainFrame, "Options", true)
+        d.setResizable(false)
+        p = builder.panel {
+            gridBagLayout()
+            label(text : "Retry failed downloads every", constraints : gbc(gridx: 0, gridy: 0))
+            retryField = textField(text : bind { model.downloadRetryInterval }, columns : 2, constraints : gbc(gridx: 1, gridy: 0))
+            label(text : "minutes", constraints : gbc(gridx : 2, gridy: 0))
+            
+            label(text : "Check for updates every", constraints : gbc(gridx : 0, gridy: 1))
+            updateField = textField(text : bind {model.updateCheckInterval }, columns : 2, constraints : gbc(gridx : 1, gridy: 1))
+            label(text : "hours", constraints : gbc(gridx: 2, gridy : 1))
+
+            label(text : "Allow only trusted connections", constraints : gbc(gridx: 0, gridy : 2))
+            allowUntrustedCheckbox = checkBox(selected : bind {model.onlyTrusted}, constraints : gbc(gridx: 1, gridy : 2))
+            
+            label(text : "Share downloaded files", constraints : gbc(gridx : 0, gridy:3))
+            shareDownloadedCheckbox = checkBox(selected : bind {model.shareDownloadedFiles}, constraints : gbc(gridx :1, gridy:3))
+                        
+        }
+        i = builder.panel {
+            gridBagLayout()
+            label(text : "Changing these settings requires a restart", constraints : gbc(gridx : 0, gridy : 0, gridwidth: 2))
+            label(text : "Inbound Length", constraints : gbc(gridx:0, gridy:1))
+            inboundLengthField = textField(text : bind {model.inboundLength}, columns : 2, constraints : gbc(gridx:1, gridy:1))
+            label(text : "Inbound Quantity", constraints : gbc(gridx:0, gridy:2))
+            inboundQuantityField = textField(text : bind {model.inboundQuantity}, columns : 2, constraints : gbc(gridx:1, gridy:2))
+            label(text : "Outbound Length", constraints : gbc(gridx:0, gridy:3))
+            outboundLengthField = textField(text : bind {model.outboundLength}, columns : 2, constraints : gbc(gridx:1, gridy:3))
+            label(text : "Outbound Quantity", constraints : gbc(gridx:0, gridy:4))
+            outboundQuantityField = textField(text : bind {model.outboundQuantity}, columns : 2, constraints : gbc(gridx:1, gridy:4))
+        }
+        buttonsPanel = builder.panel {
+            gridBagLayout()
+            button(text : "Save", constraints : gbc(gridx : 1, gridy: 2), saveAction)
+            button(text : "Cancel", constraints : gbc(gridx : 2, gridy: 2), cancelAction)
+        }
+    }
+    
+    void mvcGroupInit(Map<String,String> args) {
+        def tabbedPane = new JTabbedPane()
+        tabbedPane.addTab("MuWire Options", p)
+        tabbedPane.addTab("I2P Options", i)
+                
+        JPanel panel = new JPanel()
+        panel.setLayout(new BorderLayout())
+        panel.add(tabbedPane, BorderLayout.CENTER)
+        panel.add(buttonsPanel, BorderLayout.SOUTH)
+                
+        d.getContentPane().add(panel)
+        d.pack()
+        d.setLocationRelativeTo(mainFrame)
+        d.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE)
+        d.addWindowListener(new WindowAdapter() {
+            public void windowClosed(WindowEvent e) {
+                mvcGroup.destroy()
+            }
+        })
+        d.show()
+    }
+}

gui/griffon-app/views/com/muwire/gui/SearchTabView.groovy

@@ -0,0 +1,98 @@
+package com.muwire.gui
+
+import griffon.core.artifact.GriffonView
+import griffon.core.mvc.MVCGroup
+import griffon.inject.MVCMember
+import griffon.metadata.ArtifactProviderFor
+import net.i2p.data.DataHelper
+
+import javax.swing.JLabel
+import javax.swing.ListSelectionModel
+import javax.swing.SwingConstants
+import javax.swing.table.DefaultTableCellRenderer
+
+import java.awt.BorderLayout
+
+import javax.annotation.Nonnull
+
+@ArtifactProviderFor(GriffonView)
+class SearchTabView {
+    @MVCMember @Nonnull
+    FactoryBuilderSupport builder
+    @MVCMember @Nonnull
+    SearchTabModel model
+
+    def pane 
+    def parent
+    def searchTerms
+    def resultsTable
+    def lastSortEvent
+    
+    void initUI() {
+        builder.with {
+            def resultsTable
+            def pane = scrollPane {
+                resultsTable = table(id : "results-table", autoCreateRowSorter : true) {
+                    tableModel(list: model.results) {
+                        closureColumn(header: "Name", preferredWidth: 350, type: String, read : {row -> row.name.replace('<','_')})
+                        closureColumn(header: "Size", preferredWidth: 50, type: String, read : {row -> DataHelper.formatSize2Decimal(row.size, false)+"B"})
+                        closureColumn(header: "Sources", preferredWidth: 10, type : Integer, read : { row -> model.hashBucket[row.infohash].size()})
+                        closureColumn(header: "Sender", preferredWidth: 170, type: String, read : {row -> row.sender.getHumanReadableName()})
+                        closureColumn(header: "Trust", preferredWidth: 50, type: String, read : {row ->
+                          model.core.trustService.getLevel(row.sender.destination).toString()
+                        })
+                    }
+                }
+            }
+            
+            this.pane = pane
+            this.pane.putClientProperty("mvc-group", mvcGroup)
+            this.pane.putClientProperty("results-table",resultsTable)
+
+            this.resultsTable = resultsTable
+                        
+            def selectionModel = resultsTable.getSelectionModel()
+            selectionModel.setSelectionMode(ListSelectionModel.SINGLE_SELECTION)
+            selectionModel.addListSelectionListener( {
+                mvcGroup.parentGroup.model.searchButtonsEnabled = true
+            })
+        }
+    }
+    
+    void mvcGroupInit(Map<String, String> args) {
+        searchTerms = args["search-terms"]
+        parent = mvcGroup.parentGroup.view.builder.getVariable("result-tabs")
+        parent.addTab(searchTerms, pane)
+        int index = parent.indexOfComponent(pane)
+        parent.setSelectedIndex(index)
+        
+        def tabPanel
+        builder.with { 
+            tabPanel = panel {
+                borderLayout()
+                panel {
+                    label(text : searchTerms, constraints : BorderLayout.CENTER)
+                }
+                button(icon : imageIcon("/close_tab.png"), preferredSize : [20,20], constraints : BorderLayout.EAST, // TODO: in osx is probably WEST
+                    actionPerformed : closeTab )
+            }
+        }
+        
+        parent.setTabComponentAt(index, tabPanel)
+        
+        def centerRenderer = new DefaultTableCellRenderer()
+        centerRenderer.setHorizontalAlignment(JLabel.CENTER)
+        resultsTable.columnModel.getColumn(1).setCellRenderer(centerRenderer)
+        resultsTable.setDefaultRenderer(Integer.class,centerRenderer)
+        resultsTable.columnModel.getColumn(4).setCellRenderer(centerRenderer)
+        
+        resultsTable.rowSorter.addRowSorterListener({ evt -> lastSortEvent = evt})
+    }
+    
+    def closeTab = {
+        int index = parent.indexOfTab(searchTerms)
+        parent.removeTabAt(index)
+        mvcGroup.parentGroup.model.searchButtonsEnabled = false
+        mvcGroup.destroy()
+    }
+}

gui/src/integration-test/groovy/com/muwire/gui/OptionsIntegrationTest.groovy

@@ -0,0 +1,25 @@
+package com.muwire.gui
+
+import griffon.core.test.GriffonFestRule
+import org.fest.swing.fixture.FrameFixture
+import org.junit.Rule
+import org.junit.Test
+
+import static org.junit.Assert.fail
+
+class OptionsIntegrationTest {
+    static {
+        System.setProperty('griffon.swing.edt.violations.check', 'true')
+        System.setProperty('griffon.swing.edt.hang.monitor', 'true')
+    }
+
+    @Rule
+    public final GriffonFestRule fest = new GriffonFestRule()
+
+    private FrameFixture window
+
+    @Test
+    void smokeTest() {
+        fail('Not implemented yet!')
+    }
+}

gui/src/integration-test/groovy/com/muwire/gui/SearchTabIntegrationTest.groovy

@@ -0,0 +1,25 @@
+package com.muwire.gui
+
+import griffon.core.test.GriffonFestRule
+import org.fest.swing.fixture.FrameFixture
+import org.junit.Rule
+import org.junit.Test
+
+import static org.junit.Assert.fail
+
+class SearchTabIntegrationTest {
+    static {
+        System.setProperty('griffon.swing.edt.violations.check', 'true')
+        System.setProperty('griffon.swing.edt.hang.monitor', 'true')
+    }
+
+    @Rule
+    public final GriffonFestRule fest = new GriffonFestRule()
+
+    private FrameFixture window
+
+    @Test
+    void smokeTest() {
+        fail('Not implemented yet!')
+    }
+}

gui/src/test/groovy/com/muwire/gui/OptionsControllerTest.groovy

@@ -0,0 +1,21 @@
+package com.muwire.gui
+
+import griffon.core.test.GriffonUnitRule
+import griffon.core.test.TestFor
+import org.junit.Rule
+import org.junit.Test
+
+import static org.junit.Assert.fail
+
+@TestFor(OptionsController)
+class OptionsControllerTest {
+    private OptionsController controller
+
+    @Rule
+    public final GriffonUnitRule griffon = new GriffonUnitRule()
+
+    @Test
+    void smokeTest() {
+        fail('Not yet implemented!')
+    }
+}

gui/src/test/groovy/com/muwire/gui/SearchTabControllerTest.groovy

@@ -0,0 +1,21 @@
+package com.muwire.gui
+
+import griffon.core.test.GriffonUnitRule
+import griffon.core.test.TestFor
+import org.junit.Rule
+import org.junit.Test
+
+import static org.junit.Assert.fail
+
+@TestFor(SearchTabController)
+class SearchTabControllerTest {
+    private SearchTabController controller
+
+    @Rule
+    public final GriffonUnitRule griffon = new GriffonUnitRule()
+
+    @Test
+    void smokeTest() {
+        fail('Not yet implemented!')
+    }
+}

host-cache/build.gradle

@@ -1,2 +1,3 @@
 apply plugin : 'application'
 mainClassName = 'com.muwire.hostcache.HostCache'
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']

host-cache/src/main/groovy/com/muwire/hostcache/Crawler.groovy

@@ -1,9 +1,12 @@
 package com.muwire.hostcache
 
+import java.util.logging.Level
 import java.util.stream.Collectors
 
+import groovy.util.logging.Log
 import net.i2p.data.Destination
 
+@Log
 class Crawler {
 
     final def pinger
@@ -22,12 +25,14 @@ class Crawler {
     
     synchronized def handleCrawlerPong(pong, Destination source) {
         if (!inFlight.containsKey(source)) {
+            log.info("response from host that hasn't been crawled")
             return
         }
         Host host = inFlight.remove(source)
         
         if (pong.uuid == null || pong.leafSlots == null || pong.peerSlots == null || pong.peers == null) {
             hostPool.fail(host)
+            log.info("invalid crawler pong")
             return
         }
         
@@ -40,6 +45,7 @@ class Crawler {
         }
         
         if (!uuid.equals(currentUUID)) {
+            log.info("uuid mismatch")
             hostPool.fail(host)
             return
         }
@@ -50,7 +56,9 @@ class Crawler {
         def peers
         try {
             peers = pong.peers.stream().map({b64 -> new Destination(b64)}).collect(Collectors.toSet())
+            log.info("received ${peers.size()} peers")
         } catch (Exception e) {
+            log.log(Level.WARNING,"couldn't parse peers", e)
             hostPool.fail(host)
             return
         }

host-cache/src/main/groovy/com/muwire/hostcache/HostCache.groovy

@@ -1,9 +1,11 @@
 package com.muwire.hostcache
 
+import java.util.logging.Level
 import java.util.stream.Collectors
 
 import groovy.json.JsonOutput
 import groovy.json.JsonSlurper
+import groovy.util.logging.Log
 import net.i2p.client.I2PClientFactory
 import net.i2p.client.I2PSession
 import net.i2p.client.I2PSessionMuxedListener
@@ -12,6 +14,7 @@ import net.i2p.client.datagram.I2PDatagramMaker
 import net.i2p.util.SystemVersion
 import net.i2p.data.*
 
+@Log
 public class HostCache {
 
     public static void main(String[] args) {
@@ -53,7 +56,7 @@ public class HostCache {
         myDest = session.getMyDestination()
         
 		// initialize hostpool and crawler
-		HostPool hostPool = new HostPool(3, 60 * 1000 * 1000)
+		HostPool hostPool = new HostPool(3, 60 * 60 * 1000)
 		Pinger pinger = new Pinger(session)
 		Crawler crawler = new Crawler(pinger, hostPool, 5)
 		
@@ -64,7 +67,7 @@ public class HostCache {
         session.addMuxedSessionListener(new Listener(hostPool: hostPool, toReturn: 2, crawler: crawler), 
             I2PSession.PROTO_DATAGRAM, I2PSession.PORT_ANY)
         session.connect()
-        println "INFO: connected, going to sleep"
+        log.info("connected, going to sleep")
         Thread.sleep(Integer.MAX_VALUE)
         
     }
@@ -77,16 +80,16 @@ public class HostCache {
         
         void reportAbuse(I2PSession sesison, int severity) {}
         void disconnected(I2PSession session) {
-            println "ERROR: session disconnected, exiting"
+            log.severe("session disconnected, exiting")
             System.exit(1)
         }
         void errorOccurred(I2PSession session, String message, Throwable error) {
-            println "ERROR: ${message} ${error}"
+            log.warning("${message} ${error}")
         }
         void messageAvailable(I2PSession session, int msgId, long size, int proto,
             int fromport, int toport) {
             if (proto != I2PSession.PROTO_DATAGRAM) {
-                println "WARN: received unexpected protocol ${proto}"
+                log.warning("received unexpected protocol ${proto}")
                 return
             }
 
@@ -95,19 +98,19 @@ public class HostCache {
             try {
                 dissector.loadI2PDatagram(payload)
                 def sender = dissector.getSender()
-                println "INFO: Received something from ${sender.toBase32()}"
+                def b32 = sender.toBase32()
                 
                 payload = dissector.getPayload()
                 payload = json.parse(payload)
                 if (payload.type == null) {
-                    println "WARN: type field missing"
+                    log.warning("type field missing from $b32")
                     return
                 }
                 switch(payload.type) {
-                    case "Ping" : 
-                    println "Ping"
+                    case "Ping" :
+                    log.info("ping from $b32") 
 					if (payload.leaf == null) {
-						println "WARN: ping didn't specify if leaf"
+						log.warning("ping didn't specify if leaf from $b32")
 						return
 					}
 					payload.leaf = Boolean.parseBoolean(payload.leaf.toString())
@@ -116,14 +119,14 @@ public class HostCache {
 					respond(session, sender, payload)
                     break
                     case "CrawlerPong":
-                    println "CrawlerPong"
+                    log.info("CrawlerPong from $b32")
 					crawler.handleCrawlerPong(payload, sender)
                     break
                     default:
-                    println "WARN: Unexpected message type ${payload.type}, dropping"
+                    log.warning("Unexpected message type ${payload.type}, dropping from $b32")
                 }
             } catch (Exception dfe) {
-                println "WARN: invalid datagram ${dfe}"
+                log.log(Level.WARNING,"invalid datagram", dfe)
             } 
         }
         void messageAvailable(I2PSession session, int msgId, long size) {

settings.gradle

@@ -1,4 +1,6 @@
 include 'pinger'
 include 'host-cache'
+include 'update-server'
 include 'core'
 include 'gui'
+include 'cli'

update-server/build.gradle

@@ -0,0 +1,3 @@
+apply plugin : 'application'
+mainClassName = 'com.muwire.update.UpdateServer'
+applicationDefaultJvmArgs = ['-Djava.util.logging.config.file=logging.properties']

update-server/src/main/groovy/com/muwire/update/UpdateServer.groovy

@@ -0,0 +1,107 @@
+package com.muwire.update
+
+import java.util.logging.Level
+
+import groovy.json.JsonSlurper
+import groovy.util.logging.Log
+import net.i2p.client.I2PClientFactory
+import net.i2p.client.I2PSession
+import net.i2p.client.I2PSessionMuxedListener
+import net.i2p.client.datagram.I2PDatagramDissector
+import net.i2p.client.datagram.I2PDatagramMaker
+
+
+@Log
+class UpdateServer {
+    public static void main(String[] args) {
+        def home = System.getProperty("user.home") + "/.MuWireUpdateServer"
+        home = new File(home)
+        if (!home.exists())
+            home.mkdirs()
+        
+        def keyFile = new File(home, "key.dat")
+        
+        def i2pClientFactory = new I2PClientFactory()
+        def i2pClient = i2pClientFactory.createClient()
+        
+        def myDest
+        def session
+        if (!keyFile.exists()) {
+            def os = new FileOutputStream(keyFile);
+            myDest = i2pClient.createDestination(os)
+            os.close()
+            log.info "No key.dat file was found, so creating a new destination."
+            log.info "This is the destination you want to give out for your new UpdateServer"
+            log.info myDest.toBase64()
+        }
+        
+        def update = new File(home, "update.json")
+        if (!update.exists()) {
+            log.warning("update file doesn't exist, exiting")
+            System.exit(1)
+        }
+        
+        def props = System.getProperties().clone()
+        props.putAt("inbound.nickname", "MuWire UpdateServer")
+        session = i2pClient.createSession(new FileInputStream(keyFile), props)
+        myDest = session.getMyDestination()
+        
+        session.addMuxedSessionListener(new Listener(update), I2PSession.PROTO_DATAGRAM, I2PSession.PORT_ANY)
+        session.connect()
+        log.info("Connected, going to sleep")
+        Thread.sleep(Integer.MAX_VALUE)
+        
+    }
+    
+    static class Listener implements I2PSessionMuxedListener {
+        
+        private final File json
+        private final def slurper = new JsonSlurper()
+        Listener(File json) {
+            this.json = json
+        }
+
+        @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 uknown protocol $proto")
+                return
+            }
+            
+            def payload = session.receiveMessage(msgId)
+            def dissector = new I2PDatagramDissector()
+            try {
+                dissector.loadI2PDatagram(payload)
+                def sender = dissector.getSender()
+                payload = slurper.parse(dissector.getPayload())
+                log.info("Got an update ping from "+sender.toBase32() + " reported version "+payload?.myVersion)
+                
+                def maker = new I2PDatagramMaker(session)
+                def response = maker.makeI2PDatagram(json.bytes)
+                session.sendMessage(sender, response, I2PSession.PROTO_DATAGRAM, 0, 2)
+            } catch (Exception e) {
+                log.log(Level.WARNING, "exception responding to update request",e)
+            }
+        }
+
+        @Override
+        public void reportAbuse(I2PSession session, int severity) {
+        }
+
+        @Override
+        public void disconnected(I2PSession session) {
+            Log.severe("Disconnected from I2P router")
+            System.exit(1)
+        }
+
+        @Override
+        public void errorOccurred(I2PSession session, String message, Throwable error) {
+            log.log(Level.SEVERE, message, error)
+        }
+        
+    }
+}