Author: zothar
Date: 2006-05-24 23:44:20 +0000 (Wed, 24 May 2006)
New Revision: 8860
Modified:
trunk/freenet/src/freenet/clients/http/DarknetConnectionsToadlet.java
trunk/freenet/src/freenet/node/Node.java
trunk/freenet/src/freenet/node/PacketSender.java
trunk/freenet/src/freenet/node/PeerNode.java
Log:
- DarknetConnectionsToadlet no longer "computes" the status of a node, but
instead gets it from a new status tracking variable on PeerNode
- The current CONNECTED/DISCONNECTED/etc status is now logged at level MINOR
once per second
- Several reasons for our node rejecting a peer are now logged at level MINOR
Modified: trunk/freenet/src/freenet/clients/http/DarknetConnectionsToadlet.java
===================================================================
--- trunk/freenet/src/freenet/clients/http/DarknetConnectionsToadlet.java
2006-05-24 21:58:12 UTC (rev 8859)
+++ trunk/freenet/src/freenet/clients/http/DarknetConnectionsToadlet.java
2006-05-24 23:44:20 UTC (rev 8860)
@@ -110,12 +110,6 @@
buf.append(buf2);
}
else {
- final Integer CONNECTED = new Integer(0);
- final Integer BACKED_OFF = new Integer(1);
- final Integer TOO_NEW = new Integer(2);
- final Integer INCOMPATIBLE = new Integer(3);
- final Integer DISCONNECTED = new Integer(4);
-
int numberOfConnected = 0;
int numberOfBackedOff = 0;
int numberOfTooNew = 0;
@@ -135,20 +129,7 @@
Object[] row = new Object[9]; // where [0] is
the pn object!
rows[i] = row;
- Object status;
- if(pn.isConnected()) {
- status = CONNECTED;
- if(routingBackedOffNow) {
- status = BACKED_OFF;
- }
- } else if(pn.hasCompletedHandshake() &&
pn.isVerifiedIncompatibleNewerVersion()) {
- status = TOO_NEW;
- } else if(pn.hasCompletedHandshake() &&
!Version.checkGoodVersion(pn.getVersion())) {
- status = INCOMPATIBLE;
- } else {
- status = DISCONNECTED;
- }
-
+ Object status = new
Integer(pn.getPeerNodeStatus());
String lastBackoffReasonOutputString = "/";
String backoffReason =
pn.getLastBackoffReason();
if( backoffReason != null ) {
@@ -182,24 +163,24 @@
// Convert status codes into status strings
for(int i=0;i<rows.length;i++) {
Object[] row = rows[i];
- Integer x = (Integer) row[1];
- if(x == CONNECTED) {
+ int x = ((Integer) row[1]).intValue();
+ if(x == Node.PEER_NODE_STATUS_CONNECTED) {
row[1] = "<span
class=\"peer_connected\">CONNECTED</span>";
numberOfConnected++;
}
- else if(x == BACKED_OFF) {
+ else if(x ==
Node.PEER_NODE_STATUS_ROUTING_BACKED_OFF) {
row[1] = "<span
class=\"peer_backedoff\">BACKED OFF</span>";
numberOfBackedOff++;
}
- else if(x == TOO_NEW) {
+ else if(x == Node.PEER_NODE_STATUS_TOO_NEW) {
row[1] = "<span
class=\"peer_too_new\">TOO NEW</span>";
numberOfTooNew++;
}
- else if(x == INCOMPATIBLE) {
+ else if(x == Node.PEER_NODE_STATUS_TOO_OLD) {
row[1] = "<span
class=\"peer_incompatible\">INCOMPATIBLE</span>";
numberOfIncompatible++;
}
- else if(x == DISCONNECTED) {
+ else if(x ==
Node.PEER_NODE_STATUS_DISCONNECTED) {
row[1] = "<span
class=\"peer_disconnected\">DISCONNECTED</span>";
numberOfDisconnected++;
}
Modified: trunk/freenet/src/freenet/node/Node.java
===================================================================
--- trunk/freenet/src/freenet/node/Node.java 2006-05-24 21:58:12 UTC (rev
8859)
+++ trunk/freenet/src/freenet/node/Node.java 2006-05-24 23:44:20 UTC (rev
8860)
@@ -464,8 +464,24 @@
private long myARKNumber;
/** FetcherContext for ARKs */
public final FetcherContext arkFetcherContext;
+ /** ARK currently inserting? */
+ private boolean arkCurrentlyInserting = false;
/** ARKFetcher's currently running, by identity */
private final HashMap arkFetchers;
+ /** Next time to log the PeerNode status summary */
+ private long nextPeerNodeStatusLogTime = -1;
+ /** PeerNode status summary log interval (milliseconds) */
+ private final long peerNodeStatusLogInterval = 1000;
+ /** PeerNodes in CONNECTED status, by identity */
+ private final HashMap statusConnectedPeerNodes;
+ /** PeerNodes in BACKED_OFF status, by identity */
+ private final HashMap statusRoutingBackedOffPeerNodes;
+ /** PeerNodes in TOO_NEW status, by identity */
+ private final HashMap statusTooNewPeerNodes;
+ /** PeerNodes in INCOMPATIBLE status, by identity */
+ private final HashMap statusTooOldPeerNodes;
+ /** PeerNodes in DISCONNECTED status, by identity */
+ private final HashMap statusDisconnectedPeerNodes;
private final HashSet runningUIDs;
@@ -514,6 +530,11 @@
static final int EXIT_COULD_NOT_START_TMCI = 19;
public static final int EXIT_DATABASE_REQUIRES_RESTART = 20;
public static final int EXIT_COULD_NOT_START_UPDATER = 21;
+ public static final int PEER_NODE_STATUS_CONNECTED = 1;
+ public static final int PEER_NODE_STATUS_ROUTING_BACKED_OFF = 2;
+ public static final int PEER_NODE_STATUS_TOO_NEW = 3;
+ public static final int PEER_NODE_STATUS_TOO_OLD = 4;
+ public static final int PEER_NODE_STATUS_DISCONNECTED = 5;
public final long bootID;
public final long startupTime;
@@ -856,6 +877,11 @@
transferringRequestSenders = new HashMap();
insertSenders = new HashMap();
arkFetchers = new HashMap();
+ statusConnectedPeerNodes = new HashMap();
+ statusRoutingBackedOffPeerNodes = new HashMap();
+ statusTooNewPeerNodes = new HashMap();
+ statusTooOldPeerNodes = new HashMap();
+ statusDisconnectedPeerNodes = new HashMap();
runningUIDs = new HashSet();
ps = new PacketSender(this);
// FIXME maybe these should persist? They need to be private though,
so after the node/peers split. (bug 51).
@@ -1821,11 +1847,13 @@
lastAcceptedRequest = now;
return false;
}
+ Logger.minor( this, "shouldRejectRequest() == true because
>MAX_PING_TIME");
return true;
}
if(pingTime > SUB_MAX_PING_TIME) {
double x = (pingTime - SUB_MAX_PING_TIME) / (MAX_PING_TIME -
SUB_MAX_PING_TIME);
if(random.nextDouble() < x)
+ Logger.minor( this, "shouldRejectRequest() == true
because >SUB_MAX_PING_TIME");
return true;
}
@@ -1837,11 +1865,13 @@
lastAcceptedRequest = now;
return false;
}
+ Logger.minor( this, "shouldRejectRequest() == true because
>MAX_THROTTLE_DELAY");
return true;
}
if(bwlimitDelayTime > SUB_MAX_THROTTLE_DELAY) {
double x = (pingTime - SUB_MAX_THROTTLE_DELAY) /
(MAX_THROTTLE_DELAY - SUB_MAX_THROTTLE_DELAY);
if(random.nextDouble() < x)
+ Logger.minor( this, "shouldRejectRequest() == true
because >SUB_MAX_THROTTLE_DELAY");
return true;
}
@@ -2642,7 +2672,7 @@
return Fields.hashCode(identityHash);
}
- public boolean setNewestPeerLastGoodVersion( int version ) {
+ public synchronized boolean setNewestPeerLastGoodVersion( int version )
{
if( version > buildOldAgeUserAlert.lastGoodVersion ) {
if( buildOldAgeUserAlert.lastGoodVersion == 0 ) {
alerts.register(buildOldAgeUserAlert);
@@ -2675,7 +2705,7 @@
}
/**
- * How many ARK Fetchers are currently requesting ARKs?
+ * How many ARKFetchers are currently requesting ARKs?
*/
public int getNumARKFetchers() {
return arkFetchers.size();
@@ -2695,4 +2725,194 @@
Logger.error(this, "Removed "+af+" should be "+fetcher+" for
"+identity+" in removeARKFetcher");
}
}
+
+ /**
+ * Add a connected peer to the map
+ */
+ public synchronized void addStatusConnectedPeerNode(String identity,
PeerNode peerNode) {
+ if(statusConnectedPeerNodes.containsKey(identity)) {
+ PeerNode pn = (PeerNode) statusConnectedPeerNodes.get(identity);
+ Logger.error(this, "addStatusConnectedPeerNode(): identity
'"+identity+"' already in statusConnectedPeerNodes as "+pn+" and you want to
add"+peerNode);
+ return;
+ }
+ Logger.minor(this, "addStatusConnectedPeerNode(): adding PeerNode for
"+identity);
+ statusConnectedPeerNodes.put(identity, peerNode);
+ }
+
+ /**
+ * How many peers are currently connected?
+ */
+ public int getNumStatusConnectedPeerNodes() {
+ return statusConnectedPeerNodes.size();
+ }
+
+ /**
+ * Remove a connected node from the map
+ */
+ public synchronized void removeStatusConnectedPeerNode(String identity,
PeerNode peerNode) {
+ if(!statusConnectedPeerNodes.containsKey(identity)) {
+ Logger.error(this, "removeStatusConnectedPeerNode(): identity
'"+identity+"' not in statusConnectedPeerNodes to remove");
+ return;
+ }
+ Logger.minor(this, "removeStatusConnectedPeerNode(): removing PeerNode
for "+identity);
+ PeerNode pn = (PeerNode) statusConnectedPeerNodes.remove(identity);
+ if(pn != peerNode) {
+ Logger.error(this, "Removed "+pn+" should be "+peerNode+" for
"+identity+" in removeStatusConnectedPeerNode");
+ }
+ }
+
+ /**
+ * Add a routing backed off peer to the map
+ */
+ public synchronized void addStatusRoutingBackedOffPeerNode(String
identity, PeerNode peerNode) {
+ if(statusRoutingBackedOffPeerNodes.containsKey(identity)) {
+ PeerNode pn = (PeerNode)
statusRoutingBackedOffPeerNodes.get(identity);
+ Logger.error(this, "addStatusRoutingBackedOffPeerNode():
identity '"+identity+"' already in statusRoutingBackedOffPeerNodes as "+pn+"
and you want to add"+peerNode);
+ return;
+ }
+ Logger.minor(this, "addStatusRoutingBackedOffPeerNode(): adding
PeerNode for "+identity);
+ statusRoutingBackedOffPeerNodes.put(identity, peerNode);
+ }
+
+ /**
+ * How many peers are currently routing backed off?
+ */
+ public int getNumStatusRoutingBackedOffPeerNodes() {
+ return statusRoutingBackedOffPeerNodes.size();
+ }
+
+ /**
+ * Remove a routing backed off node from the map
+ */
+ public synchronized void removeStatusRoutingBackedOffPeerNode(String
identity, PeerNode peerNode) {
+ if(!statusRoutingBackedOffPeerNodes.containsKey(identity)) {
+ Logger.error(this, "removeStatusRoutingBackedOffPeerNode():
identity '"+identity+"' not in statusRoutingBackedOffPeerNodes to remove");
+ return;
+ }
+ Logger.minor(this, "removeStatusRoutingBackedOffPeerNode(): removing
PeerNode for "+identity);
+ PeerNode pn = (PeerNode)
statusRoutingBackedOffPeerNodes.remove(identity);
+ if(pn != peerNode) {
+ Logger.error(this, "Removed "+pn+" should be "+peerNode+" for
"+identity+" in removeStatusRoutingBackedOffPeerNode");
+ }
+ }
+
+ /**
+ * Add a too new peer to the map
+ */
+ public synchronized void addStatusTooNewPeerNode(String identity, PeerNode
peerNode) {
+ if(statusTooNewPeerNodes.containsKey(identity)) {
+ PeerNode pn = (PeerNode) statusTooNewPeerNodes.get(identity);
+ Logger.error(this, "addStatusTooNewPeerNode(): identity
'"+identity+"' already in statusTooNewPeerNodes as "+pn+" and you want to
add"+peerNode);
+ return;
+ }
+ Logger.minor(this, "addStatusTooNewPeerNode(): adding PeerNode for
"+identity);
+ statusTooNewPeerNodes.put(identity, peerNode);
+ }
+
+ /**
+ * How many peers are currently too new?
+ */
+ public int getNumStatusTooNewPeerNodes() {
+ return statusTooNewPeerNodes.size();
+ }
+
+ /**
+ * Remove a too new node from the map
+ */
+ public synchronized void removeStatusTooNewPeerNode(String identity,
PeerNode peerNode) {
+ if(!statusTooNewPeerNodes.containsKey(identity)) {
+ Logger.error(this, "removeStatusTooNewPeerNode(): identity
'"+identity+"' not in statusTooNewPeerNodes to remove");
+ return;
+ }
+ Logger.minor(this, "removeStatusTooNewPeerNode(): removing PeerNode for
"+identity);
+ PeerNode pn = (PeerNode) statusTooNewPeerNodes.remove(identity);
+ if(pn != peerNode) {
+ Logger.error(this, "Removed "+pn+" should be "+peerNode+" for
"+identity+" in removeStatusTooNewPeerNode");
+ }
+ }
+
+ /**
+ * Add a too old peer to the map
+ */
+ public synchronized void addStatusTooOldPeerNode(String identity, PeerNode
peerNode) {
+ if(statusTooOldPeerNodes.containsKey(identity)) {
+ PeerNode pn = (PeerNode) statusTooOldPeerNodes.get(identity);
+ Logger.error(this, "addStatusTooOldPeerNode(): identity
'"+identity+"' already in statusTooOldPeerNodes as "+pn+" and you want to
add"+peerNode);
+ return;
+ }
+ Logger.minor(this, "addStatusTooOldPeerNode(): adding PeerNode for
"+identity);
+ statusTooOldPeerNodes.put(identity, peerNode);
+ }
+
+ /**
+ * How many peers are currently too old?
+ */
+ public int getNumStatusTooOldPeerNodes() {
+ return statusTooOldPeerNodes.size();
+ }
+
+ /**
+ * Remove a too old node from the map
+ */
+ public synchronized void removeStatusTooOldPeerNode(String identity,
PeerNode peerNode) {
+ if(!statusTooOldPeerNodes.containsKey(identity)) {
+ Logger.error(this, "removeStatusTooOldPeerNode(): identity
'"+identity+"' not in statusTooOldPeerNodes to remove");
+ return;
+ }
+ Logger.minor(this, "removeStatusTooOldPeerNode(): removing PeerNode for
"+identity);
+ PeerNode pn = (PeerNode) statusTooOldPeerNodes.remove(identity);
+ if(pn != peerNode) {
+ Logger.error(this, "Removed "+pn+" should be "+peerNode+" for
"+identity+" in removeStatusTooOldPeerNode");
+ }
+ }
+
+ /**
+ * Add a disconnected peer to the map
+ */
+ public synchronized void addStatusDisconnectedPeerNode(String identity,
PeerNode peerNode) {
+ if(statusDisconnectedPeerNodes.containsKey(identity)) {
+ PeerNode pn = (PeerNode)
statusDisconnectedPeerNodes.get(identity);
+ Logger.error(this, "addStatusDisconnectedPeerNode(): identity
'"+identity+"' already in statusDisconnectedPeerNodes as "+pn+" and you want to
add"+peerNode);
+ return;
+ }
+ Logger.minor(this, "addStatusDisconnectedPeerNode(): adding PeerNode
for "+identity);
+ statusDisconnectedPeerNodes.put(identity, peerNode);
+ }
+
+ /**
+ * How many peers are currently disconnected?
+ */
+ public int getNumStatusDisconnectedPeerNodes() {
+ return statusDisconnectedPeerNodes.size();
+ }
+
+ /**
+ * Remove a disconnected node from the map
+ */
+ public synchronized void removeStatusDisconnectedPeerNode(String identity,
PeerNode peerNode) {
+ if(!statusDisconnectedPeerNodes.containsKey(identity)) {
+ Logger.error(this, "removeStatusDisconnectedPeerNode():
identity '"+identity+"' not in statusDisconnectedPeerNodes to remove");
+ return;
+ }
+ Logger.minor(this, "removeStatusDisconnectedPeerNode(): removing
PeerNode for "+identity);
+ PeerNode pn = (PeerNode) statusDisconnectedPeerNodes.remove(identity);
+ if(pn != peerNode) {
+ Logger.error(this, "Removed "+pn+" should be "+peerNode+" for
"+identity+" in removeStatusDisconnectedPeerNode");
+ }
+ }
+
+ /**
+ * Log the current PeerNode status summary if the timer has expired
+ */
+ public void maybeLogPeerNodeStatusSummary(long now) {
+ if(now > nextPeerNodeStatusLogTime) {
+ int numberOfConnected = getNumStatusConnectedPeerNodes();
+ int numberOfRoutingBackedOff = getNumStatusRoutingBackedOffPeerNodes();
+ int numberOfTooNew = getNumStatusTooNewPeerNodes();
+ int numberOfTooOld = getNumStatusTooOldPeerNodes();
+ int numberOfDisconnected = getNumStatusDisconnectedPeerNodes();
+ Logger.minor(this, "Connected: "+numberOfConnected+" Routing Backed
Off: "+numberOfRoutingBackedOff+" Too New: "+numberOfTooNew+" Too Old:
"+numberOfTooOld+" Disconnected: "+numberOfDisconnected);
+ nextPeerNodeStatusLogTime = now + peerNodeStatusLogInterval;
+ }
+ }
}
Modified: trunk/freenet/src/freenet/node/PacketSender.java
===================================================================
--- trunk/freenet/src/freenet/node/PacketSender.java 2006-05-24 21:58:12 UTC
(rev 8859)
+++ trunk/freenet/src/freenet/node/PacketSender.java 2006-05-24 23:44:20 UTC
(rev 8860)
@@ -71,6 +71,7 @@
long nextActionTime = Long.MAX_VALUE;
for(int i=0;i<nodes.length;i++) {
PeerNode pn = nodes[i];
+ pn.setPeerNodeStatus(now);
lastReceivedPacketFromAnyNode =
Math.max(pn.lastReceivedPacketTime(),
lastReceivedPacketFromAnyNode);
if(pn.isConnected()) {
@@ -180,6 +181,8 @@
// Send may have taken some time
now = System.currentTimeMillis();
+
+ node.maybeLogPeerNodeStatusSummary(now);
Vector jobsToRun = null;
Modified: trunk/freenet/src/freenet/node/PeerNode.java
===================================================================
--- trunk/freenet/src/freenet/node/PeerNode.java 2006-05-24 21:58:12 UTC
(rev 8859)
+++ trunk/freenet/src/freenet/node/PeerNode.java 2006-05-24 23:44:20 UTC
(rev 8860)
@@ -209,6 +209,9 @@
/** The time at which we last completed a connection setup. */
private long connectedTime;
+
+ /** The status of this peer node in terms of Node.PEER_NODE_STATUS_* */
+ public int peerNodeStatus = Node.PEER_NODE_STATUS_DISCONNECTED;
/** Holds a String-Long pair that shows which message types (as name) have
been send to this peer. */
private Hashtable localNodeSentMessageTypes = new Hashtable();
@@ -557,12 +560,14 @@
* Disconnected e.g. due to not receiving a packet for ages.
*/
public void disconnected() {
+ long now = System.currentTimeMillis();
Logger.normal(this, "Disconnected "+this);
node.usm.onDisconnect(this);
node.peers.disconnected(this);
synchronized(this) {
// Force renegotiation.
isConnected = false;
+ setPeerNodeStatus(now);
// Prevent sending packets to the node until that happens.
if(currentTracker != null)
currentTracker.disconnected();
@@ -910,6 +915,7 @@
* @return True unless we rejected the handshake, or it failed to parse.
*/
public synchronized boolean completedHandshake(long thisBootID, byte[]
data, int offset, int length, BlockCipher encCipher, byte[] encKey, Peer
replyTo, boolean unverified) {
+ long now = System.currentTimeMillis();
completedHandshake = true;
handshakeCount = 0;
arkFetcher.stop();
@@ -923,27 +929,31 @@
// Treat as invalid version
}
if(reverseInvalidVersion()) {
- verifiedIncompatibleNewerVersion = true;
try {
node.setNewestPeerLastGoodVersion(Version.getArbitraryBuildNumber(lastGoodVersion));
} catch (NumberFormatException e) {
// ignore
}
Logger.normal(this, "Not connecting to "+this+" - reverse invalid
version "+Version.getVersionString()+" for peer's lastGoodversion:
"+lastGoodVersion);
+ verifiedIncompatibleNewerVersion = true;
isConnected = false;
+ setPeerNodeStatus(now);
node.peers.disconnected(this);
return false;
} else {
verifiedIncompatibleNewerVersion = false;
+ setPeerNodeStatus(now);
}
if(invalidVersion()) {
+ Logger.normal(this, "Not connecting to "+this+" - invalid version
"+version);
verifiedIncompatibleOlderVersion = true;
- Logger.normal(this, "Not connecting to "+this+" - invalid version
"+version);
isConnected = false;
+ setPeerNodeStatus(now);
node.peers.disconnected(this);
return false;
} else {
verifiedIncompatibleOlderVersion = false;
+ setPeerNodeStatus(now);
}
KeyTracker newTracker = new KeyTracker(this, encCipher, encKey);
changedIP(replyTo);
@@ -951,6 +961,7 @@
connectedTime = System.currentTimeMillis();
Logger.minor(this, "Changed boot ID from "+bootID+" to
"+thisBootID);
isConnected = false; // Will be reset below
+ setPeerNodeStatus(now);
if(previousTracker != null) {
KeyTracker old = previousTracker;
previousTracker = null;
@@ -977,6 +988,7 @@
if(previousTracker != null)
previousTracker.deprecated();
isConnected = true;
+ setPeerNodeStatus(now);
ctx = null;
}
if(!isConnected)
@@ -1027,6 +1039,7 @@
* if necessary.
*/
public void verified(KeyTracker tracker) {
+ long now = System.currentTimeMillis();
synchronized(this) {
if(tracker == unverifiedTracker) {
Logger.minor(this, "Promoting unverified tracker "+tracker);
@@ -1039,6 +1052,7 @@
currentTracker = unverifiedTracker;
unverifiedTracker = null;
isConnected = true;
+ setPeerNodeStatus(now);
ctx = null;
maybeSendInitialMessages();
} else return;
@@ -1613,7 +1627,48 @@
}
}
+ public int getPeerNodeStatus() {
+ return peerNodeStatus;
+ }
+ public synchronized void setPeerNodeStatus(long now) {
+ int oldPeerNodeStatus = peerNodeStatus;
+ if(isConnected) {
+ peerNodeStatus = Node.PEER_NODE_STATUS_CONNECTED;
+ if(now < routingBackedOffUntil) {
+ peerNodeStatus =
Node.PEER_NODE_STATUS_ROUTING_BACKED_OFF;
+ }
+ } else if(completedHandshake &&
verifiedIncompatibleNewerVersion) {
+ peerNodeStatus = Node.PEER_NODE_STATUS_TOO_NEW;
+ } else if(completedHandshake &&
verifiedIncompatibleOlderVersion) {
+ peerNodeStatus = Node.PEER_NODE_STATUS_TOO_OLD;
+ } else {
+ peerNodeStatus = Node.PEER_NODE_STATUS_DISCONNECTED;
+ }
+ if(peerNodeStatus != oldPeerNodeStatus) {
+ if(oldPeerNodeStatus == Node.PEER_NODE_STATUS_CONNECTED)
+ node.removeStatusConnectedPeerNode(getIdentityString(),
this);
+ else if(oldPeerNodeStatus ==
Node.PEER_NODE_STATUS_ROUTING_BACKED_OFF)
+
node.removeStatusRoutingBackedOffPeerNode(getIdentityString(), this);
+ else if(oldPeerNodeStatus == Node.PEER_NODE_STATUS_TOO_NEW)
+ node.removeStatusTooNewPeerNode(getIdentityString(), this);
+ else if(oldPeerNodeStatus == Node.PEER_NODE_STATUS_TOO_OLD)
+ node.removeStatusTooOldPeerNode(getIdentityString(), this);
+ else if(oldPeerNodeStatus ==
Node.PEER_NODE_STATUS_DISCONNECTED)
+ node.removeStatusDisconnectedPeerNode(getIdentityString(),
this);
+ if(peerNodeStatus == Node.PEER_NODE_STATUS_CONNECTED)
+ node.addStatusConnectedPeerNode(getIdentityString(), this);
+ else if(peerNodeStatus ==
Node.PEER_NODE_STATUS_ROUTING_BACKED_OFF)
+ node.addStatusRoutingBackedOffPeerNode(getIdentityString(),
this);
+ else if(peerNodeStatus == Node.PEER_NODE_STATUS_TOO_NEW)
+ node.addStatusTooNewPeerNode(getIdentityString(), this);
+ else if(peerNodeStatus == Node.PEER_NODE_STATUS_TOO_OLD)
+ node.addStatusTooOldPeerNode(getIdentityString(), this);
+ else if(peerNodeStatus == Node.PEER_NODE_STATUS_DISCONNECTED)
+ node.addStatusDisconnectedPeerNode(getIdentityString(),
this);
+ }
+ }
+
public String getIdentityString() {
return Base64.encode(identity);
}
