Git-Mirrors/haveno
1
0
Fork 0
mirror of https://github.com/haveno-dex/haveno.git synced 2025-03-15 10:26:37 -04:00
Code Issues Packages Projects Releases Wiki Activity

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)

Browse Source
This commit is contained in:
Manfred Karrer 2014-08-22 18:28:12 +02:00
parent 0a9a442baa
commit 656a517057
8 changed files with 198 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/io/bitsquare/BitSquare.java
View File

@ -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;

3
src/main/java/io/bitsquare/SeedNode.java
View File

@ -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());

4
src/main/java/io/bitsquare/di/BitSquareModule.java
View File

@ -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();

169
src/main/java/io/bitsquare/msg/BootstrappedPeerFactory.java
View File

@ -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<PeerDHT> 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<BaseFuture>()
{
@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<BaseFuture>()
{
@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<BaseFuture>()
{
@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<BaseFuture>()
{
@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<BaseFuture>()
{
@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");

11
src/main/java/io/bitsquare/msg/MessageFacade.java
View File

@ -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<ArbitratorListener> arbitratorListeners = new ArrayList<>();
private final List<IncomingTradeMessageListener> 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<PeerDHT>()
{
@Override

86
src/main/java/io/bitsquare/msg/P2PNode.java
View File

@ -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<PeerDHT> callback)
{
useDiscStorage(useDiskStorage);
bootstrappedPeerFactory.setStorage(storage);
setupTimerForIPCheck();
/* FutureCallback<PeerDHT> localCallback = new FutureCallback<PeerDHT>()
{
@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<PeerDHT> bootstrapComplete = bootstrap(new SeedNodeAddress(defaultStaticSeedNodeAddresses));
ListenableFuture<PeerDHT> 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<PeerDHT> callback, SeedNodeAddress seedNodeAddress)
{
Thread bootstrapThread = new Thread(new Runnable()
{
@Override
public void run()
{
log.debug("runBootstrapThread");
ListenableFuture<PeerDHT> bootstrapComplete = bootstrap(seedNodeAddress);
Futures.addCallback(bootstrapComplete, callback);
}
});
bootstrapThread.start();
return bootstrapThread;
} */
public void shutDown()
{
@ -260,9 +229,8 @@ public class P2PNode
// Private
///////////////////////////////////////////////////////////////////////////////////////////
private ListenableFuture<PeerDHT> bootstrap(SeedNodeAddress seedNodeAddress)
private ListenableFuture<PeerDHT> bootstrap()
{
BootstrappedPeerFactory bootstrappedPeerFactory = new BootstrappedPeerFactory(keyPair, storage, seedNodeAddress);
ListenableFuture<PeerDHT> bootstrapComplete = bootstrappedPeerFactory.start();
Futures.addCallback(bootstrapComplete, new FutureCallback<PeerDHT>()
{

52
src/test/java/io/bitsquare/msg/P2PNodeTest.java
View File

@ -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");

4
src/test/java/io/bitsquare/msg/UtilsDHT2.java
View File

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