From 656a517057e19eb65efa6848f956da5f9b9ef2a5 Mon Sep 17 00:00:00 2001 From: Manfred Karrer Date: Fri, 22 Aug 2014 18:28:12 +0200 Subject: [PATCH] save last successful bootstrap method and use that afterwards directly (speed up bootstrap when fallbacks are used like port forwarding and relay). Relay mode cause still issues on the server, need to be fixed ba Thomas Bocek (see mailinglist) --- src/main/java/io/bitsquare/BitSquare.java | 2 +- src/main/java/io/bitsquare/SeedNode.java | 3 +- .../java/io/bitsquare/di/BitSquareModule.java | 4 + .../msg/BootstrappedPeerFactory.java | 169 ++++++++++++------ .../java/io/bitsquare/msg/MessageFacade.java | 11 +- src/main/java/io/bitsquare/msg/P2PNode.java | 86 +++------ .../java/io/bitsquare/msg/P2PNodeTest.java | 52 +++++- src/test/java/io/bitsquare/msg/UtilsDHT2.java | 4 +- 8 files changed, 198 insertions(+), 133 deletions(-) diff --git a/src/main/java/io/bitsquare/BitSquare.java b/src/main/java/io/bitsquare/BitSquare.java index 5539e088ed..bd4aa2cc2b 100644 --- a/src/main/java/io/bitsquare/BitSquare.java +++ b/src/main/java/io/bitsquare/BitSquare.java @@ -33,7 +33,7 @@ public class BitSquare extends Application { private static final Logger log = LoggerFactory.getLogger(BitSquare.class); - public static boolean fillFormsWithDummyData = false; + public static boolean fillFormsWithDummyData = true; private static String APP_NAME = "bitsquare"; private static Stage primaryStage; diff --git a/src/main/java/io/bitsquare/SeedNode.java b/src/main/java/io/bitsquare/SeedNode.java index 8ebd285ff3..c108a5876f 100644 --- a/src/main/java/io/bitsquare/SeedNode.java +++ b/src/main/java/io/bitsquare/SeedNode.java @@ -16,7 +16,6 @@ import net.tomp2p.peers.PeerMapChangeListener; import net.tomp2p.peers.PeerStatatistic; import net.tomp2p.relay.FutureRelay; import net.tomp2p.relay.RelayRPC; -import net.tomp2p.tracker.PeerBuilderTracker; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -106,7 +105,7 @@ public class SeedNode extends Thread new PeerBuilderDHT(peer).start(); PeerNAT nodeBehindNat = new PeerBuilderNAT(peer).start(); new RelayRPC(peer); - new PeerBuilderTracker(peer); + //new PeerBuilderTracker(peer); nodeBehindNat.startSetupRelay(new FutureRelay()); log.debug("Peer started. " + peer.peerAddress()); diff --git a/src/main/java/io/bitsquare/di/BitSquareModule.java b/src/main/java/io/bitsquare/di/BitSquareModule.java index e78d0d4e9f..fba70a887b 100644 --- a/src/main/java/io/bitsquare/di/BitSquareModule.java +++ b/src/main/java/io/bitsquare/di/BitSquareModule.java @@ -14,7 +14,9 @@ import io.bitsquare.btc.FeePolicy; import io.bitsquare.btc.WalletFacade; import io.bitsquare.crypto.CryptoFacade; import io.bitsquare.gui.util.BitSquareFormatter; +import io.bitsquare.msg.BootstrappedPeerFactory; import io.bitsquare.msg.MessageFacade; +import io.bitsquare.msg.P2PNode; import io.bitsquare.msg.SeedNodeAddress; import io.bitsquare.settings.Settings; import io.bitsquare.storage.Persistence; @@ -40,6 +42,8 @@ public class BitSquareModule extends AbstractModule bind(BlockChainFacade.class).asEagerSingleton(); bind(MessageFacade.class).asEagerSingleton(); + bind(P2PNode.class).asEagerSingleton(); + bind(BootstrappedPeerFactory.class).asEagerSingleton(); bind(TradeManager.class).asEagerSingleton(); bind(BitSquareFormatter.class).asEagerSingleton(); diff --git a/src/main/java/io/bitsquare/msg/BootstrappedPeerFactory.java b/src/main/java/io/bitsquare/msg/BootstrappedPeerFactory.java index 167ce3a0c1..71424e714f 100644 --- a/src/main/java/io/bitsquare/msg/BootstrappedPeerFactory.java +++ b/src/main/java/io/bitsquare/msg/BootstrappedPeerFactory.java @@ -2,10 +2,14 @@ package io.bitsquare.msg; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.SettableFuture; +import com.google.inject.name.Named; +import io.bitsquare.storage.Persistence; import java.io.IOException; import java.net.InetAddress; +import java.net.UnknownHostException; import java.security.KeyPair; import javax.annotation.concurrent.Immutable; +import javax.inject.Inject; import net.tomp2p.connection.Ports; import net.tomp2p.dht.PeerBuilderDHT; import net.tomp2p.dht.PeerDHT; @@ -38,9 +42,10 @@ public class BootstrappedPeerFactory { private static final Logger log = LoggerFactory.getLogger(BootstrappedPeerFactory.class); - private final KeyPair keyPair; - private final Storage storage; + private KeyPair keyPair; + private Storage storage; private final SeedNodeAddress seedNodeAddress; + private Persistence persistence; private final SettableFuture settableFuture = SettableFuture.create(); @@ -49,19 +54,26 @@ public class BootstrappedPeerFactory // Constructor /////////////////////////////////////////////////////////////////////////////////////////// - /** - * We use localhost as default seed node - */ - public BootstrappedPeerFactory(@NotNull KeyPair keyPair, @NotNull Storage storage) + @Inject + public BootstrappedPeerFactory(Persistence persistence, @Named("defaultSeedNode") SeedNodeAddress.StaticSeedNodeAddresses defaultStaticSeedNodeAddresses) { - this(keyPair, storage, new SeedNodeAddress(SeedNodeAddress.StaticSeedNodeAddresses.LOCALHOST)); + this.persistence = persistence; + this.seedNodeAddress = new SeedNodeAddress(defaultStaticSeedNodeAddresses); } - public BootstrappedPeerFactory(@NotNull KeyPair keyPair, @NotNull Storage storage, @NotNull SeedNodeAddress seedNodeAddress) + + /////////////////////////////////////////////////////////////////////////////////////////// + // Setters + /////////////////////////////////////////////////////////////////////////////////////////// + + public void setKeyPair(@NotNull KeyPair keyPair) { this.keyPair = keyPair; + } + + public void setStorage(@NotNull Storage storage) + { this.storage = storage; - this.seedNodeAddress = seedNodeAddress; } @@ -108,7 +120,39 @@ public class BootstrappedPeerFactory } }); - discover(peerDHT); + // We save last successful bootstrap method. + // Reset it to "default" after 5 start ups. + Object lastSuccessfulBootstrapCounterObject = persistence.read(this, "lastSuccessfulBootstrapCounter"); + int lastSuccessfulBootstrapCounter = 0; + if (lastSuccessfulBootstrapCounterObject != null) + lastSuccessfulBootstrapCounter = (int) lastSuccessfulBootstrapCounterObject; + + if (lastSuccessfulBootstrapCounter > 5) + persistence.write(this, "lastSuccessfulBootstrap", "default"); + + persistence.write(this, "lastSuccessfulBootstrapCounter", lastSuccessfulBootstrapCounter + 1); + + + String lastSuccessfulBootstrap = (String) persistence.read(this, "lastSuccessfulBootstrap"); + if (lastSuccessfulBootstrap == null) + lastSuccessfulBootstrap = "default"; + + log.debug("lastSuccessfulBootstrap = " + lastSuccessfulBootstrap); + switch (lastSuccessfulBootstrap) + { + case "relay": + PeerNAT nodeBehindNat = new PeerBuilderNAT(peerDHT.peer()).start(); + bootstrapWithRelay(peerDHT, nodeBehindNat); + break; + case "startPortForwarding": + FutureDiscover futureDiscover = peerDHT.peer().discover().peerAddress(getBootstrapAddress()).start(); + bootstrapWithPortForwarding(peerDHT, futureDiscover); + break; + case "default": + default: + bootstrap(peerDHT); + break; + } } catch (IOException e) { log.error("Exception: " + e); @@ -118,58 +162,66 @@ public class BootstrappedPeerFactory return settableFuture; } - private void discover(PeerDHT peerDHT) + private PeerAddress getBootstrapAddress() { try { - PeerAddress bootstrapAddress = new PeerAddress(Number160.createHash(seedNodeAddress.getId()), - InetAddress.getByName(seedNodeAddress.getIp()), - seedNodeAddress.getPort(), - seedNodeAddress.getPort()); - // Check if peer is reachable from outside - FutureDiscover futureDiscover = peerDHT.peer().discover().peerAddress(bootstrapAddress).start(); - futureDiscover.addListener(new BaseFutureListener() - { - @Override - public void operationComplete(BaseFuture future) throws Exception - { - if (future.isSuccess()) - { - // We are not behind a NAT and reachable to other peers - log.debug("We are not behind a NAT and reachable to other peers: My address visible to the outside is " + futureDiscover.peerAddress()); - getBootstrapPeerMap(); - settableFuture.set(peerDHT); - } - else - { - log.warn("Discover has failed. Reason: " + futureDiscover.failedReason()); - log.warn("We are probably behind a NAT and not reachable to other peers. We try port forwarding as next step."); - - startPortForwarding(peerDHT, bootstrapAddress, futureDiscover); - } - } - - @Override - public void exceptionCaught(Throwable t) throws Exception - { - log.error("Exception at discover: " + t); - settableFuture.setException(t); - } - }); - } catch (IOException e) + return new PeerAddress(Number160.createHash(seedNodeAddress.getId()), + InetAddress.getByName(seedNodeAddress.getIp()), + seedNodeAddress.getPort(), + seedNodeAddress.getPort()); + } catch (UnknownHostException e) { - log.error("Exception: " + e); - settableFuture.setException(e); + log.error("getBootstrapAddress failed: " + e.getMessage()); + return null; } } - private void startPortForwarding(PeerDHT peerDHT, PeerAddress bootstrapAddress, FutureDiscover futureDiscover) + private void bootstrap(PeerDHT peerDHT) + { + // Check if peer is reachable from outside + FutureDiscover futureDiscover = peerDHT.peer().discover().peerAddress(getBootstrapAddress()).start(); + BootstrappedPeerFactory ref = this; + futureDiscover.addListener(new BaseFutureListener() + { + @Override + public void operationComplete(BaseFuture future) throws Exception + { + if (future.isSuccess()) + { + // We are not behind a NAT and reachable to other peers + log.debug("We are not behind a NAT and reachable to other peers: My address visible to the outside is " + futureDiscover.peerAddress()); + requestBootstrapPeerMap(); + settableFuture.set(peerDHT); + + persistence.write(ref, "lastSuccessfulBootstrap", "default"); + } + else + { + log.warn("Discover has failed. Reason: " + futureDiscover.failedReason()); + log.warn("We are probably behind a NAT and not reachable to other peers. We try port forwarding as next step."); + + bootstrapWithPortForwarding(peerDHT, futureDiscover); + } + } + + @Override + public void exceptionCaught(Throwable t) throws Exception + { + log.error("Exception at discover: " + t); + settableFuture.setException(t); + } + }); + } + + private void bootstrapWithPortForwarding(PeerDHT peerDHT, FutureDiscover futureDiscover) { // Assume we are behind a NAT device PeerNAT nodeBehindNat = new PeerBuilderNAT(peerDHT.peer()).start(); // Try to set up port forwarding with UPNP and NATPMP if peer is not reachable FutureNAT futureNAT = nodeBehindNat.startSetupPortforwarding(futureDiscover); + BootstrappedPeerFactory ref = this; futureNAT.addListener(new BaseFutureListener() { @Override @@ -179,15 +231,17 @@ public class BootstrappedPeerFactory { // Port forwarding has succeed log.debug("Port forwarding was successful. My address visible to the outside is " + futureNAT.peerAddress()); - getBootstrapPeerMap(); + requestBootstrapPeerMap(); settableFuture.set(peerDHT); + + persistence.write(ref, "lastSuccessfulBootstrap", "portForwarding"); } else { log.warn("Port forwarding has failed. Reason: " + futureNAT.failedReason()); log.warn("We try to use a relay as next step."); - prepareRelay(peerDHT, nodeBehindNat, bootstrapAddress); + bootstrapWithRelay(peerDHT, nodeBehindNat); } } @@ -200,7 +254,7 @@ public class BootstrappedPeerFactory }); } - private void prepareRelay(PeerDHT peerDHT, PeerNAT nodeBehindNat, PeerAddress bootstrapAddress) + private void bootstrapWithRelay(PeerDHT peerDHT, PeerNAT nodeBehindNat) { // Last resort: we try to use other peers as relays @@ -211,7 +265,7 @@ public class BootstrappedPeerFactory peer.peerBean().serverPeerAddress(serverPeerAddress); // Find neighbors - FutureBootstrap futureBootstrap = peer.bootstrap().peerAddress(bootstrapAddress).start(); + FutureBootstrap futureBootstrap = peer.bootstrap().peerAddress(getBootstrapAddress()).start(); futureBootstrap.addListener(new BaseFutureListener() { @Override @@ -221,7 +275,7 @@ public class BootstrappedPeerFactory { log.debug("Bootstrap was successful. bootstrapTo = " + futureBootstrap.bootstrapTo()); - setupRelay(peerDHT, nodeBehindNat, bootstrapAddress); + setupRelay(peerDHT, nodeBehindNat, getBootstrapAddress()); } else { @@ -280,6 +334,7 @@ public class BootstrappedPeerFactory { // find neighbors again FutureBootstrap futureBootstrap2 = peerDHT.peer().bootstrap().peerAddress(bootstrapAddress).start(); + BootstrappedPeerFactory ref = this; futureBootstrap2.addListener(new BaseFutureListener() { @Override @@ -288,8 +343,10 @@ public class BootstrappedPeerFactory if (future.isSuccess()) { log.debug("Final bootstrap was successful. bootstrapTo = " + futureBootstrap2.bootstrapTo()); - getBootstrapPeerMap(); + requestBootstrapPeerMap(); settableFuture.set(peerDHT); + + persistence.write(ref, "lastSuccessfulBootstrap", "relay"); } else { @@ -310,7 +367,7 @@ public class BootstrappedPeerFactory // TODO we want to get a list of connected nodes form the seed node and save them locally for future bootstrapping // The seed node should only be used if no other known peers are available - private void getBootstrapPeerMap() + private void requestBootstrapPeerMap() { log.debug("getBootstrapPeerMap"); diff --git a/src/main/java/io/bitsquare/msg/MessageFacade.java b/src/main/java/io/bitsquare/msg/MessageFacade.java index 658659334e..4a29f9b078 100644 --- a/src/main/java/io/bitsquare/msg/MessageFacade.java +++ b/src/main/java/io/bitsquare/msg/MessageFacade.java @@ -1,7 +1,6 @@ package io.bitsquare.msg; import com.google.common.util.concurrent.FutureCallback; -import com.google.inject.name.Named; import io.bitsquare.msg.listeners.*; import io.bitsquare.trade.Offer; import io.bitsquare.trade.protocol.TradeMessage; @@ -65,7 +64,6 @@ public class MessageFacade implements MessageBroker private final List arbitratorListeners = new ArrayList<>(); private final List incomingTradeMessageListeners = new ArrayList<>(); private User user; - private Boolean useDiskStorage; private SeedNodeAddress.StaticSeedNodeAddresses defaultStaticSeedNodeAddresses; @@ -74,11 +72,10 @@ public class MessageFacade implements MessageBroker /////////////////////////////////////////////////////////////////////////////////////////// @Inject - public MessageFacade(User user, @Named("useDiskStorage") Boolean useDiskStorage, @Named("defaultSeedNode") SeedNodeAddress.StaticSeedNodeAddresses defaultStaticSeedNodeAddresses) + public MessageFacade(User user, P2PNode p2pNode) { this.user = user; - this.useDiskStorage = useDiskStorage; - this.defaultStaticSeedNodeAddresses = defaultStaticSeedNodeAddresses; + this.p2pNode = p2pNode; } @@ -88,7 +85,9 @@ public class MessageFacade implements MessageBroker public void init(BootstrapListener bootstrapListener) { - p2pNode = new P2PNode(user.getMessageKeyPair(), useDiskStorage, defaultStaticSeedNodeAddresses, this); + p2pNode.setMessageBroker(this); + p2pNode.setKeyPair(user.getMessageKeyPair()); + p2pNode.start(new FutureCallback() { @Override diff --git a/src/main/java/io/bitsquare/msg/P2PNode.java b/src/main/java/io/bitsquare/msg/P2PNode.java index e942b682cb..ab3b1728ce 100644 --- a/src/main/java/io/bitsquare/msg/P2PNode.java +++ b/src/main/java/io/bitsquare/msg/P2PNode.java @@ -3,8 +3,8 @@ package io.bitsquare.msg; import com.google.common.util.concurrent.FutureCallback; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; +import com.google.inject.name.Named; import io.bitsquare.BitSquare; -import io.bitsquare.util.DSAKeyUtil; import io.bitsquare.util.StorageDirectory; import java.io.File; import java.io.IOException; @@ -13,6 +13,7 @@ import java.security.PublicKey; import java.util.Timer; import java.util.TimerTask; import javax.annotation.Nullable; +import javax.inject.Inject; import net.tomp2p.connection.DSASignatureFactory; import net.tomp2p.dht.*; import net.tomp2p.futures.BaseFuture; @@ -42,7 +43,7 @@ public class P2PNode private Thread bootstrapToServerThread; // just for lightweight client test - public static void main(String[] args) + /* public static void main(String[] args) { P2PNode p2pNode = new P2PNode(DSAKeyUtil.generateKeyPair(), false, SeedNodeAddress.StaticSeedNodeAddresses.DIGITAL_OCEAN, (message, peerAddress) -> log.debug("handleMessage: message= " + message + "/ peerAddress=" + peerAddress)); @@ -63,28 +64,31 @@ public class P2PNode for (; ; ) { } - } + }*/ - private final KeyPair keyPair; + private KeyPair keyPair; private final Boolean useDiskStorage; private final SeedNodeAddress.StaticSeedNodeAddresses defaultStaticSeedNodeAddresses; - private final MessageBroker messageBroker; + private MessageBroker messageBroker; private PeerAddress storedPeerAddress; private PeerDHT peerDHT; private Storage storage; + private BootstrappedPeerFactory bootstrappedPeerFactory; /////////////////////////////////////////////////////////////////////////////////////////// // Constructor /////////////////////////////////////////////////////////////////////////////////////////// - public P2PNode(KeyPair keyPair, Boolean useDiskStorage, SeedNodeAddress.StaticSeedNodeAddresses defaultStaticSeedNodeAddresses, MessageBroker messageBroker) + @Inject + public P2PNode(BootstrappedPeerFactory bootstrappedPeerFactory, + @Named("useDiskStorage") Boolean useDiskStorage, + @Named("defaultSeedNode") SeedNodeAddress.StaticSeedNodeAddresses defaultStaticSeedNodeAddresses) { - this.keyPair = keyPair; + this.bootstrappedPeerFactory = bootstrappedPeerFactory; this.useDiskStorage = useDiskStorage; this.defaultStaticSeedNodeAddresses = defaultStaticSeedNodeAddresses; - this.messageBroker = messageBroker; } // for unit testing @@ -92,11 +96,11 @@ public class P2PNode { this.keyPair = keyPair; this.peerDHT = peerDHT; + peerDHT.peerBean().keyPair(keyPair); messageBroker = (message, peerAddress) -> { }; useDiskStorage = false; defaultStaticSeedNodeAddresses = SeedNodeAddress.StaticSeedNodeAddresses.LOCALHOST; - peerDHT.peerBean().keyPair(keyPair); } @@ -104,63 +108,28 @@ public class P2PNode // Public methods /////////////////////////////////////////////////////////////////////////////////////////// + public void setMessageBroker(MessageBroker messageBroker) + { + this.messageBroker = messageBroker; + } + + public void setKeyPair(@NotNull KeyPair keyPair) + { + this.keyPair = keyPair; + bootstrappedPeerFactory.setKeyPair(keyPair); + } public void start(FutureCallback callback) { useDiscStorage(useDiskStorage); + + bootstrappedPeerFactory.setStorage(storage); setupTimerForIPCheck(); - /* FutureCallback localCallback = new FutureCallback() - { - @Override - public void onSuccess(@Nullable PeerDHT result) - { - log.debug("p2pNode.start success result = " + result); - callback.onSuccess(result); - bootstrapThreadCompleted(); - } - - @Override - public void onFailure(Throwable t) - { - log.error(t.toString()); - callback.onFailure(t); - } - }; */ - - ListenableFuture bootstrapComplete = bootstrap(new SeedNodeAddress(defaultStaticSeedNodeAddresses)); + ListenableFuture bootstrapComplete = bootstrap(); Futures.addCallback(bootstrapComplete, callback); - - // bootstrapToLocalhostThread = runBootstrapThread(localCallback, new SeedNodeAddress(defaultStaticSeedNodeAddresses)); - // bootstrapToServerThread = runBootstrapThread(localCallback, new SeedNodeAddress(SeedNodeAddress.StaticSeedNodeAddresses.DIGITAL_OCEAN)); } - // TODO: start multiple threads for bootstrapping, so we can get it done faster. - - /* public void bootstrapThreadCompleted() - { - if (bootstrapToLocalhostThread != null) - bootstrapToLocalhostThread.interrupt(); - - if (bootstrapToServerThread != null) - bootstrapToServerThread.interrupt(); - } - - private Thread runBootstrapThread(FutureCallback callback, SeedNodeAddress seedNodeAddress) - { - Thread bootstrapThread = new Thread(new Runnable() - { - @Override - public void run() - { - log.debug("runBootstrapThread"); - ListenableFuture bootstrapComplete = bootstrap(seedNodeAddress); - Futures.addCallback(bootstrapComplete, callback); - } - }); - bootstrapThread.start(); - return bootstrapThread; - } */ public void shutDown() { @@ -260,9 +229,8 @@ public class P2PNode // Private /////////////////////////////////////////////////////////////////////////////////////////// - private ListenableFuture bootstrap(SeedNodeAddress seedNodeAddress) + private ListenableFuture bootstrap() { - BootstrappedPeerFactory bootstrappedPeerFactory = new BootstrappedPeerFactory(keyPair, storage, seedNodeAddress); ListenableFuture bootstrapComplete = bootstrappedPeerFactory.start(); Futures.addCallback(bootstrapComplete, new FutureCallback() { diff --git a/src/test/java/io/bitsquare/msg/P2PNodeTest.java b/src/test/java/io/bitsquare/msg/P2PNodeTest.java index f01df87659..c696e22e84 100644 --- a/src/test/java/io/bitsquare/msg/P2PNodeTest.java +++ b/src/test/java/io/bitsquare/msg/P2PNodeTest.java @@ -1,20 +1,18 @@ package io.bitsquare.msg; import java.io.IOException; -import java.security.KeyPair; -import java.security.KeyPairGenerator; +import java.security.*; import java.util.Random; import net.tomp2p.connection.Ports; -import net.tomp2p.dht.FutureGet; -import net.tomp2p.dht.FuturePut; -import net.tomp2p.dht.FutureRemove; -import net.tomp2p.dht.PeerDHT; +import net.tomp2p.dht.*; import net.tomp2p.futures.FutureDirect; +import net.tomp2p.p2p.PeerBuilder; import net.tomp2p.peers.Number160; import net.tomp2p.peers.PeerAddress; import net.tomp2p.rpc.ObjectDataReply; import net.tomp2p.storage.Data; import net.tomp2p.utils.Utils; +import org.junit.Assert; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -156,10 +154,45 @@ public class P2PNodeTest master.shutdown(); } - + @Test + public void testChangeEntryProtectionKey() throws IOException, ClassNotFoundException, NoSuchAlgorithmException, InterruptedException, InvalidKeyException, SignatureException + { + KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA"); + + KeyPair keyPair1 = gen.generateKeyPair(); + KeyPair keyPair2 = gen.generateKeyPair(); + PeerDHT p1 = new PeerBuilderDHT(new PeerBuilder(Number160.createHash(1)).ports(4838) + .keyPair(keyPair1).start()).start(); + PeerDHT p2 = new PeerBuilderDHT(new PeerBuilder(Number160.createHash(2)).ports(4839) + .keyPair(keyPair2).start()).start(); + + p2.peer().bootstrap().peerAddress(p1.peerAddress()).start().awaitUninterruptibly(); + p1.peer().bootstrap().peerAddress(p2.peerAddress()).start().awaitUninterruptibly(); + + Data data = new Data("test").protectEntry(keyPair1); + FuturePut fp1 = p1.put(Number160.createHash("key1")).sign().data(data).start().awaitUninterruptibly(); + Assert.assertTrue(fp1.isSuccess()); + FuturePut fp2 = p2.put(Number160.createHash("key1")).data(data).start().awaitUninterruptibly(); + Assert.assertTrue(!fp2.isSuccess()); + + Data data2 = new Data().protectEntry(keyPair2); + data2.publicKey(keyPair2.getPublic()); + FuturePut fp3 = p1.put(Number160.createHash("key1")).sign().putMeta().data(data2).start().awaitUninterruptibly(); + Assert.assertTrue(fp3.isSuccess()); + + FuturePut fp4 = p2.put(Number160.createHash("key1")).sign().data(data).start().awaitUninterruptibly(); + Assert.assertTrue(fp4.isSuccess()); + + p1.shutdown().awaitUninterruptibly(); + p2.shutdown().awaitUninterruptibly(); + } + + + // @Test public void testAddToListGetList() throws Exception { + PeerDHT[] peers = UtilsDHT2.createNodes(3, rnd, new Ports().tcpPort()); PeerDHT master = peers[0]; PeerDHT client = peers[1]; @@ -178,6 +211,11 @@ public class P2PNodeTest FutureGet futureGet; // client add a value + + KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA"); + KeyPair keyPair1 = gen.generateKeyPair(); + keyPairClient = keyPair1; + node = new P2PNode(keyPairClient, client); locationKey = Number160.createHash("add to list clients location"); data = new Data("add to list client data1"); diff --git a/src/test/java/io/bitsquare/msg/UtilsDHT2.java b/src/test/java/io/bitsquare/msg/UtilsDHT2.java index fdfe0034d3..8104672161 100644 --- a/src/test/java/io/bitsquare/msg/UtilsDHT2.java +++ b/src/test/java/io/bitsquare/msg/UtilsDHT2.java @@ -227,7 +227,7 @@ public class UtilsDHT2 for (int i = 0; i < peers.length; i++) { for (int j = 0; j < peers.length; j++) - peers[i].peer().peerBean().peerMap().peerFound(peers[j].peer().peerAddress(), null); + peers[i].peer().peerBean().peerMap().peerFound(peers[j].peer().peerAddress(), null, null); } System.err.println("perfect routing done."); } @@ -237,7 +237,7 @@ public class UtilsDHT2 for (int i = 0; i < peers.length; i++) { for (int j = 0; j < peers.length; j++) - peers[i].peerBean().peerMap().peerFound(peers[j].peerAddress(), peers[j].peerAddress()); + peers[i].peerBean().peerMap().peerFound(peers[j].peerAddress(), peers[j].peerAddress(), null); } System.err.println("perfect routing done."); }