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."); }