Add Host.getProtocols() and fix addProtocolHandler

libp2p/src/main/kotlin/io/libp2p/core/Host.kt

@@ -81,6 +81,8 @@ interface Host {
      */
     fun addProtocolHandler(protocolBinding: ProtocolBinding<Any>)
 
+    fun getProtocols(): List<ProtocolBinding<Any>>
+
     /**
      * Removes the handler added with [addProtocolHandler]
      */

libp2p/src/main/kotlin/io/libp2p/core/dsl/Builders.kt

@@ -33,6 +33,7 @@ import io.libp2p.transport.tcp.TcpTransport
 import io.netty.channel.ChannelHandler
 import io.netty.handler.logging.LogLevel
 import io.netty.handler.logging.LoggingHandler
+import java.util.concurrent.CopyOnWriteArrayList
 
 typealias TransportCtor = (ConnectionUpgrader) -> Transport
 typealias SecureChannelCtor = (PrivKey, List<StreamMuxer>) -> SecureChannel
@@ -173,7 +174,8 @@ open class Builder {
             }
         }
 
-        val muxers = muxers.map { it.createMuxer(streamMultistreamProtocol, protocols.values) }
+        val updatableProtocols: MutableList<ProtocolBinding<Any>> = CopyOnWriteArrayList(protocols.values)
+        val muxers = muxers.map { it.createMuxer(streamMultistreamProtocol, updatableProtocols) }
 
         val secureChannels = secureChannels.values.map { it(privKey, muxers) }
 
@@ -201,7 +203,7 @@ open class Builder {
             networkImpl,
             addressBook,
             network.listen.map { Multiaddr(it) },
-            protocols.values,
+            updatableProtocols,
             broadcastConnHandler,
             streamVisitors
         )

libp2p/src/main/kotlin/io/libp2p/core/multistream/Multistream.kt

@@ -25,5 +25,5 @@ interface Multistream<TController> : P2PChannelHandler<TController> {
      * For _initiator_ role this is the list of protocols the initiator wants to instantiate.
      * Basically this is either a single protocol or a protocol versions
      */
-    val bindings: MutableList<ProtocolBinding<TController>>
+    val bindings: List<ProtocolBinding<TController>>
 }

libp2p/src/main/kotlin/io/libp2p/host/HostImpl.kt

@@ -78,6 +78,10 @@ class HostImpl(
         protocolHandlers -= protocolBinding
     }
 
+    override fun getProtocols(): List<ProtocolBinding<Any>> {
+        return protocolHandlers
+    }
+
     override fun addConnectionHandler(handler: ConnectionHandler) {
         connectionHandlers += handler
     }

libp2p/src/main/kotlin/io/libp2p/multistream/MultistreamImpl.kt

@@ -6,18 +6,14 @@ import io.libp2p.core.multistream.Multistream
 import io.libp2p.core.multistream.ProtocolBinding
 import java.time.Duration
 import java.util.concurrent.CompletableFuture
-import java.util.concurrent.CopyOnWriteArrayList
 
 class MultistreamImpl<TController>(
-    initList: List<ProtocolBinding<TController>> = listOf(),
+    override val bindings: List<ProtocolBinding<TController>>,
     val preHandler: P2PChannelHandler<*>? = null,
     val postHandler: P2PChannelHandler<*>? = null,
     val negotiationTimeLimit: Duration = DEFAULT_NEGOTIATION_TIME_LIMIT
 ) : Multistream<TController> {
 
-    override val bindings: MutableList<ProtocolBinding<TController>> =
-        CopyOnWriteArrayList(initList)
-
     override fun initChannel(ch: P2PChannel): CompletableFuture<TController> {
         return with(ch) {
             preHandler?.also {

libp2p/src/test/java/io/libp2p/core/HostTestJava.java

@@ -156,6 +156,69 @@ void largePing() throws Exception {
         System.out.println("Server stopped");
     }
 
+    @Test
+    void addPingAfterHostStart() throws Exception {
+        String localListenAddress = "/ip4/127.0.0.1/tcp/40002";
+
+        Host clientHost = new HostBuilder()
+                .transport(TcpTransport::new)
+                .secureChannel((k, m) -> new TlsSecureChannel(k, m, "ECDSA"))
+                .muxer(StreamMuxerProtocol::getYamux)
+                .build();
+
+        Host serverHost = new HostBuilder()
+                .transport(TcpTransport::new)
+                .secureChannel(TlsSecureChannel::new)
+                .muxer(StreamMuxerProtocol::getYamux)
+                .listen(localListenAddress)
+                .build();
+
+        CompletableFuture<Void> clientStarted = clientHost.start();
+        CompletableFuture<Void> serverStarted = serverHost.start();
+        clientStarted.get(5, TimeUnit.SECONDS);
+        System.out.println("Client started");
+        serverStarted.get(5, TimeUnit.SECONDS);
+        System.out.println("Server started");
+
+        Assertions.assertEquals(0, clientHost.listenAddresses().size());
+        Assertions.assertEquals(1, serverHost.listenAddresses().size());
+        Assertions.assertEquals(
+                localListenAddress + "/p2p/" + serverHost.getPeerId(),
+                serverHost.listenAddresses().get(0).toString()
+        );
+
+        serverHost.addProtocolHandler(new Ping());
+
+        StreamPromise<PingController> ping =
+                clientHost.getNetwork().connect(
+                                serverHost.getPeerId(),
+                                new Multiaddr(localListenAddress)
+                        ).thenApply(
+                                it -> it.muxerSession().createStream(new Ping())
+                        )
+                        .get(5, TimeUnit.SECONDS);
+
+        Stream pingStream = ping.getStream().get(5, TimeUnit.SECONDS);
+        System.out.println("Ping stream created");
+        PingController pingCtr = ping.getController().get(5, TimeUnit.SECONDS);
+        System.out.println("Ping controller created");
+
+        for (int i = 0; i < 10; i++) {
+            long latency = pingCtr.ping().get(1, TimeUnit.SECONDS);
+            System.out.println("Ping is " + latency);
+        }
+        pingStream.close().get(5, TimeUnit.SECONDS);
+        System.out.println("Ping stream closed");
+
+        Assertions.assertThrows(ExecutionException.class, () ->
+                pingCtr.ping().get(5, TimeUnit.SECONDS));
+
+        clientHost.stop().get(5, TimeUnit.SECONDS);
+        System.out.println("Client stopped");
+        serverHost.stop().get(5, TimeUnit.SECONDS);
+        System.out.println("Server stopped");
+    }
+
     @Test
     void keyPairGeneration() {
         Pair<PrivKey, PubKey> pair = KeyKt.generateKeyPair(KEY_TYPE.SECP256K1);

libp2p/src/testFixtures/kotlin/io/libp2p/tools/NullHost.kt

@@ -55,6 +55,10 @@ open class NullHost : Host {
         TODO("not implemented")
     }
 
+    override fun getProtocols(): List<ProtocolBinding<Any>> {
+        TODO("not implemented")
+    }
+
     override fun addConnectionHandler(handler: ConnectionHandler) {
         TODO("not implemented")
     }