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

Add maintenance task

Browse Source
This commit is contained in:
Manfred Karrer 2016-01-27 03:38:16 +01:00
parent 579c3797bc
commit c68c06d598
3 changed files with 31 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/main/java/io/bitsquare/arbitration/Arbitrator.java
View File

@ -31,7 +31,7 @@ public final class Arbitrator implements PubKeyProtectedExpirablePayload {
// That object is sent over the wire, so we need to take care of version compatibility.
private static final long serialVersionUID = Version.NETWORK_PROTOCOL_VERSION;
public static final long TTL = 6 * 24 * 60 * 60 * 1000; // 6 days
public static final long TTL = 10 * 24 * 60 * 60 * 1000; // 10 days
// Persisted fields
private final byte[] btcPubKey;

43
network/src/main/java/io/bitsquare/p2p/peers/PeerExchangeManager.java
View File

@ -9,10 +9,7 @@ import io.bitsquare.common.UserThread;
import io.bitsquare.common.util.Utilities;
import io.bitsquare.p2p.Message;
import io.bitsquare.p2p.NodeAddress;
import io.bitsquare.p2p.network.Connection;
import io.bitsquare.p2p.network.ConnectionListener;
import io.bitsquare.p2p.network.MessageListener;
import io.bitsquare.p2p.network.NetworkNode;
import io.bitsquare.p2p.network.*;
import io.bitsquare.p2p.peers.messages.peers.GetPeersRequest;
import io.bitsquare.p2p.peers.messages.peers.GetPeersResponse;
import io.bitsquare.p2p.peers.messages.peers.PeerExchangeMessage;
@ -35,7 +32,7 @@ public class PeerExchangeManager implements MessageListener, ConnectionListener
private final PeerManager peerManager;
private final Set<NodeAddress> seedNodeAddresses;
private final ScheduledThreadPoolExecutor executor;
private Timer continueWithMorePeersTimer, timeoutTimer, checkConnectionsTimer;
private Timer continueWithMorePeersTimer, timeoutTimer, maintainConnectionsTimer;
///////////////////////////////////////////////////////////////////////////////////////////
@ -56,7 +53,7 @@ public class PeerExchangeManager implements MessageListener, ConnectionListener
networkNode.removeMessageListener(this);
stopContinueWithMorePeersTimer();
stopCheckConnectionsTimer();
stopMaintainConnectionsTimer();
stopTimeoutTimer();
MoreExecutors.shutdownAndAwaitTermination(executor, 500, TimeUnit.MILLISECONDS);
}
@ -70,7 +67,7 @@ public class PeerExchangeManager implements MessageListener, ConnectionListener
requestReportedPeers(nodeAddress, new ArrayList<>(seedNodeAddresses));
long delay = new Random().nextInt(60) + 60 * 3; // 3-4 min.
executor.scheduleAtFixedRate(() -> UserThread.execute(this::checkConnections),
executor.scheduleAtFixedRate(() -> UserThread.execute(this::maintainConnections),
delay, delay, TimeUnit.SECONDS);
}
@ -87,8 +84,8 @@ public class PeerExchangeManager implements MessageListener, ConnectionListener
public void onDisconnect(Reason reason, Connection connection) {
// We use a timer to throttle if we get a series of disconnects
// The more connections we have the more relaxed we are with a checkConnections
if (checkConnectionsTimer == null)
checkConnectionsTimer = UserThread.runAfter(this::checkConnections,
if (maintainConnectionsTimer == null)
maintainConnectionsTimer = UserThread.runAfter(this::maintainConnections,
networkNode.getAllConnections().size() * 10, TimeUnit.SECONDS);
@ -241,20 +238,32 @@ public class PeerExchangeManager implements MessageListener, ConnectionListener
// we check if we have at least one seed node connected
private void checkConnections() {
private void maintainConnections() {
Log.traceCall();
stopCheckConnectionsTimer();
stopMaintainConnectionsTimer();
// we want at least 1 seed node connected
Set<Connection> allConnections = networkNode.getConfirmedConnections();
List<Connection> connectedSeedNodes = allConnections.stream()
.filter(peerManager::isSeedNode)
.collect(Collectors.toList());
log.debug("connectedSeedNodes " + connectedSeedNodes);
if (connectedSeedNodes.size() == 0 && !seedNodeAddresses.isEmpty())
requestReportedPeersFromList(new ArrayList<>(seedNodeAddresses));
// We try to get sufficient connections by using reported and persisted peers
if (continueWithMorePeersTimer == null)
continueWithMorePeersTimer = UserThread.runAfterRandomDelay(this::continueWithMorePeers, 10, 20);
// Use all outbound connections for updating reported peers and make sure we keep the connection alive
// Inbound connections should be maintained be the requesting peer
networkNode.getConfirmedConnections().stream()
.filter(c -> c.getPeersNodeAddressOptional().isPresent() &&
c instanceof OutboundConnection).
forEach(c -> UserThread.runAfterRandomDelay(() ->
requestReportedPeers(c.getPeersNodeAddressOptional().get(), new ArrayList<>())
, 3, 5));
}
private HashSet<ReportedPeer> getReportedPeersHashSet(NodeAddress receiverNodeAddress) {
@ -273,10 +282,10 @@ public class PeerExchangeManager implements MessageListener, ConnectionListener
}
}
private void stopCheckConnectionsTimer() {
if (checkConnectionsTimer != null) {
checkConnectionsTimer.cancel();
checkConnectionsTimer = null;
private void stopMaintainConnectionsTimer() {
if (maintainConnectionsTimer != null) {
maintainConnectionsTimer.cancel();
maintainConnectionsTimer = null;
}
}

8
network/src/main/java/io/bitsquare/p2p/peers/PeerManager.java
View File

@ -33,13 +33,13 @@ public class PeerManager implements ConnectionListener, MessageListener {
public static void setMaxConnections(int maxConnections) {
MAX_CONNECTIONS = maxConnections;
MIN_CONNECTIONS = maxConnections - 2;
MAX_CONNECTIONS_EXTENDED_1 = MAX_CONNECTIONS + 5;
MAX_CONNECTIONS_EXTENDED_2 = MAX_CONNECTIONS_EXTENDED_1 + 5;
MIN_CONNECTIONS = maxConnections - 4;
MAX_CONNECTIONS_EXTENDED_1 = MAX_CONNECTIONS + 6;
MAX_CONNECTIONS_EXTENDED_2 = MAX_CONNECTIONS_EXTENDED_1 + 6;
}
static {
setMaxConnections(10);
setMaxConnections(12);
}
private static final int MAX_REPORTED_PEERS = 1000;