NodeStats (fred API)

java.lang.Object
- freenet.node.NodeStats

All Implemented Interfaces:

BlockTransmitter.BlockTimeCallback, Persistable
```
public class NodeStats
extends java.lang.Object
implements Persistable, BlockTransmitter.BlockTimeCallback
```
Node (as opposed to NodeClientCore) level statistics. Includes shouldRejectRequest(), but not limited to stuff required to implement that.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`NodeStats.PeerLoadStats` Stats to send to a single peer so it can determine whether we are likely to reject a request.
`static class`	`NodeStats.RequestType`
`static class`	`NodeStats.TimedStats`

Field Summary

Fields
Modifier and Type	Field and Description
`ByteCounter`	`announceByteCounter`
`DecayingKeyspaceAverage`	`avgCacheCHKLocation`
`DecayingKeyspaceAverage`	`avgCacheCHKSuccess`
`DecayingKeyspaceAverage`	`avgCacheSSKLocation`
`DecayingKeyspaceAverage`	`avgCacheSSKSuccess`
`DecayingKeyspaceAverage`	`avgClientCacheCHKLocation`
`DecayingKeyspaceAverage`	`avgClientCacheCHKSuccess`
`DecayingKeyspaceAverage`	`avgClientCacheSSKLocation`
`DecayingKeyspaceAverage`	`avgClientCacheSSKSuccess`
`protected DecayingKeyspaceAverage`	`avgRequestLocation`
`DecayingKeyspaceAverage`	`avgSlashdotCacheCHKLocation`
`DecayingKeyspaceAverage`	`avgSlashdotCacheCHKSucess`
`DecayingKeyspaceAverage`	`avgSlashdotCacheSSKLocation`
`DecayingKeyspaceAverage`	`avgSlashdotCacheSSKSuccess`
`DecayingKeyspaceAverage`	`avgStoreCHKLocation`
`DecayingKeyspaceAverage`	`avgStoreCHKSuccess`
`DecayingKeyspaceAverage`	`avgStoreSSKLocation`
`DecayingKeyspaceAverage`	`avgStoreSSKSuccess`
`RunningAverage`	`backedOffPercent`
`boolean`	`bwlimitDelayAlertRelevant` bwlimitDelay PeerManagerUserAlert should happen if true
`ByteCounter`	`chkInsertCtr`
`ByteCounter`	`chkRequestCtr`
`Histogram2`	`chkSuccessRatesByLocation`
`static long`	`DEFAULT_MAX_PING_TIME` Maximum overall average ping time.
`static long`	`DEFAULT_SUB_MAX_PING_TIME` Sub-max ping time.
`double`	`furthestCacheCHKSuccess`
`double`	`furthestCacheSSKSuccess`
`double`	`furthestClientCacheCHKSuccess`
`double`	`furthestClientCacheSSKSuccess`
`double`	`furthestSlashdotCacheCHKSuccess`
`double`	`furthestSlashdotCacheSSKSuccess`
`double`	`furthestStoreCHKSuccess`
`double`	`furthestStoreSSKSuccess`
`static long`	`MAX_BWLIMIT_DELAY_TIME_ALERT_DELAY` How long we're over the bwlimitDelayTime threshold before we alert (in milliseconds)
`static long`	`MAX_BWLIMIT_DELAY_TIME_ALERT_THRESHOLD` How high can bwlimitDelayTime be before we alert (in milliseconds)
`static long`	`MAX_INTERREQUEST_TIME` Accept one request every 10 seconds regardless, to ensure we update the block send time.
`static long`	`MAX_NODE_AVERAGE_PING_TIME_ALERT_DELAY` How long we're over the nodeAveragePingTime threshold before we alert (in milliseconds)
`static long`	`MAX_NODE_AVERAGE_PING_TIME_ALERT_THRESHOLD` How high can nodeAveragePingTime be before we alert (in milliseconds)
`static long`	`MAX_THROTTLE_DELAY_BULK`
`static long`	`MAX_THROTTLE_DELAY_RT` Maximum throttled packet delay.
`boolean`	`nodeAveragePingAlertRelevant` nodeAveragePing PeerManagerUserAlert should happen if true
`PeerManager`	`peers`
`protected freenet.node.Persister`	`persister`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingCHKInsertBulk`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingCHKInsertRT`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingCHKRequestBulk`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingCHKRequestRT`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingOverall` Average proportion of requests rejected immediately due to overload
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingSSKInsertBulk`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingSSKInsertRT`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingSSKRequestBulk`
`BootstrappingDecayingRunningAverage`	`pInstantRejectIncomingSSKRequestRT`
`ByteCounter`	`probeRequestCtr`
`ByteCounter`	`resendByteCounter`
`java.lang.ThreadGroup`	`rootThreadGroup`
`ByteCounter`	`routedMessageCtr`
`RunningAverage`	`routingMissDistanceBulk`
`RunningAverage`	`routingMissDistanceLocal`
`RunningAverage`	`routingMissDistanceOverall`
`RunningAverage`	`routingMissDistanceRemote`
`RunningAverage`	`routingMissDistanceRT`
`ByteCounter`	`sskInsertCtr`
`ByteCounter`	`sskRequestCtr`
`static long`	`SUB_MAX_THROTTLE_DELAY_BULK`
`static long`	`SUB_MAX_THROTTLE_DELAY_RT` If the throttled packet delay is less than this, reject no packets; if it's between the two, reject some packets.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`blockTime(long interval, boolean realtime)`
`int`	`calculateMaxTransfersOut(PeerNode peer, boolean realTime, double nonOverheadFraction, int maxTransfersOutUpperLimit)`
`StoreLocationStats`	`chkCacheStats()` View of stats for CHK Cache
`StoreLocationStats`	`chkClientCacheStats()` View of stats for CHK ClientCache
`StoreLocationStats`	`chkSlashDotCacheStats()` View of stats for CHK SlashdotCache
`StoreLocationStats`	`chkStoreStats()` View of stats for CHK Store
`NodeStats.PeerLoadStats`	`createPeerLoadStats(PeerNode peer, int transfersPerInsert, boolean realTimeFlag)`
`void`	`drawNewLoadManagementDelayTimes(HTMLNode content)`
`boolean`	`enableNewLoadManagement(boolean realTimeFlag)`
`void`	`endAnnouncement(long uid)`
`SimpleFieldSet`	`exportVolatileFieldSet()`
`void`	`failedBlockReceive(boolean normalFetch, boolean timeout, boolean realTimeFlag, boolean isLocal)`
`void`	`fillDetailedTimingsBox(HTMLNode html)`
`void`	`fillRemoteRequestHTLsBox(HTMLNode html, boolean realTime)`
`void`	`fillSuccessRateBox(HTMLNode parent)`
`int`	`getActiveThreadCount()`
`int[]`	`getActiveThreadsByPriority()`
`long`	`getAllocationNoticesBytesSent()`
`long`	`getAnnounceBytesPayloadSent()`
`long`	`getAnnounceBytesSent()`
`double`	`getBandwidthLiabilityUsage()`
`double`	`getBwlimitDelayTime()`
`double`	`getBwlimitDelayTimeBulk()`
`double`	`getBwlimitDelayTimeRT()`
`long`	`getChangedIPBytesSent()`
`long`	`getCHKInsertTotalBytesSent()`
`long`	`getCHKRequestTotalBytesSent()`
`int`	`getDarknetSizeEstimate(long timestamp)`
`NodeStats.TimedStats[]`	`getDatabaseJobExecutionStatistics()`
`long`	`getDisconnBytesSent()`
`long`	`getFOAFBytesSent()`
`int[]`	`getIncomingRequestLocation(int[] retval)`
`long`	`getInitialMessagesBytesSent()`
`java.lang.Object[]`	`getKnownLocations(long timestamp)`
`boolean`	`getLocalRejectReasonsTable(HTMLNode table)`
`double`	`getLowerLimit(double upperLimit, int peerCount)`
`NodeStats.TimedStats[]`	`getMandatoryBackoffStatistics(boolean realtime)`
`long`	`getNetworkColoringSentBytes()`
`double`	`getNodeAveragePingTime()`
`long[]`	`getNodeIOStats()`
`long`	`getNodeToNodeBytesSent()`
`byte[]`	`getNoisyRejectStats()`
`long`	`getNotificationOnlyPacketsSentBytes()`
`long`	`getOfferedKeysTotalBytesReceived()`
`long`	`getOfferedKeysTotalBytesSent()`
`long`	`getOffersSentBytesSent()`
`int`	`getOpennetSizeEstimate(long timestamp)`
`int[]`	`getOutgoingLocalRequestLocation(int[] retval)`
`int[]`	`getOutgoingRequestLocation(int[] retval)`
`long`	`getPingSentBytes()`
`long`	`getProbeRequestSentBytes()`
`boolean`	`getRejectReasonsTable(HTMLNode table)`
`long`	`getResendBytesSent()`
`long`	`getRoutedMessageSentBytes()`
`NodeStats.TimedStats[]`	`getRoutingBackoffStatistics(boolean realtime)`
`long`	`getRoutingStatusBytes()`
`freenet.node.NodeStats.RunningRequestsSnapshot`	`getRunningRequestsTo(PeerNode peerNode, int transfersPerInsert, boolean realTimeFlag)`
`long`	`getSentOverhead()`
`double`	`getSentOverheadPerSecond()` The average number of bytes sent per second for things other than requests, inserts, and offer replies.
`long`	`getSSKInsertTotalBytesSent()`
`long`	`getSSKRequestTotalBytesSent()`
`long`	`getSwappingTotalBytesReceived()`
`long`	`getSwappingTotalBytesSent()`
`int`	`getThreadLimit()`
`java.lang.Thread[]`	`getThreads()` Gets a copy of the thread list.
`long`	`getTotalAuthBytesSent()`
`NodeStats.TimedStats[]`	`getTransferBackoffStatistics(boolean realtime)`
`int`	`getTransfersPerAnnounce()`
`long`	`getUOMBytesSent()`
`int[]`	`getWaitingThreadsByPriority()`
`boolean`	`ignoreLocalVsRemoteBandwidthLiability()`
`void`	`insertReceivedBytes(boolean ssk, int x)`
`void`	`insertSentBytes(boolean ssk, int x)`
`boolean`	`isTestnetEnabled()`
`protected java.lang.String`	`l10n(java.lang.String key)`
`protected java.lang.String`	`l10n(java.lang.String key, java.lang.String[] patterns, java.lang.String[] values)`
`long`	`maxPeerPingTime()` If a peer is over this threshold it is considered to be backed off.
`void`	`maybeUpdateNodeIOStats(long now)` Update the node-wide bandwidth I/O stats if the timer has expired
`void`	`maybeUpdatePeerManagerUserAlertStats(long now)` Update peerManagerUserAlertStats if the timer has expired.
`void`	`networkColoringReceivedBytes(int x)`
`void`	`networkColoringSentBytes(int x)`
`void`	`offeredKeysSenderReceivedBytes(int x)`
`void`	`offeredKeysSenderSentBytes(int x)`
`int`	`outwardTransfersPerInsert()`
`NodeStats.PeerLoadStats`	`parseLoadStats(PeerNode source, Message m)`
`SimpleFieldSet`	`persistThrottlesToFieldSet()`
`void`	`pingCounterReceived(int x)`
`void`	`pingCounterSent(int x)`
`double`	`pRejectIncomingInstantly()`
`double`	`pRejectIncomingInstantlyCHKInsertBulk()`
`double`	`pRejectIncomingInstantlyCHKInsertRT()`
`double`	`pRejectIncomingInstantlyCHKRequestBulk()`
`double`	`pRejectIncomingInstantlyCHKRequestRT()`
`double`	`pRejectIncomingInstantlySSKInsertBulk()`
`double`	`pRejectIncomingInstantlySSKInsertRT()`
`double`	`pRejectIncomingInstantlySSKRequestBulk()`
`double`	`pRejectIncomingInstantlySSKRequestRT()`
`double`	`randomNoise(double input, double sigma)` Applies multiplicative Gaussian noise of mean 1.0 and the specified sigma to the input value.
`void`	`reportAllocatedSlot(boolean local)`
`void`	`reportAnnounceForwarded(int forwardedRefs, PeerNode source)`
`void`	`reportAuthBytes(int x)`
`void`	`reportCHKOutcome(long rtt, boolean successful, double location, boolean isRealtime)`
`void`	`reportDatabaseJob(java.lang.String jobType, long executionTimeMiliSeconds)`
`void`	`reportFatalTimeoutInWait(boolean local)`
`void`	`reportIncomingRequestLocation(double loc)`
`void`	`reportMandatoryBackoff(java.lang.String backoffType, long backoffTimeMilliSeconds, boolean realtime)`
`void`	`reportNLMDelay(long waitTime, boolean realTime, boolean local)`
`void`	`reportOutgoingLocalRequestLocation(double loc)`
`void`	`reportOutgoingRequestLocation(double loc)`
`void`	`reportRoutingBackoff(java.lang.String backoffType, long backoffTimeMilliSeconds, boolean realtime)`
`void`	`reportSSKOutcome(long rtt, boolean successful, boolean isRealtime)`
`void`	`reportTransferBackoff(java.lang.String backoffType, long backoffTimeMilliSeconds, boolean realtime)`
`void`	`reportUOMBytesSent(int x)`
`void`	`requestCompleted(boolean succeeded, boolean isRemote, boolean isSSK)`
`void`	`requestReceivedBytes(boolean ssk, int x)`
`void`	`requestSentBytes(boolean ssk, int x)`
`freenet.node.NodeStats.AnnouncementDecision`	`shouldAcceptAnnouncement(long uid)`
`freenet.node.NodeStats.RejectReason`	`shouldRejectRequest(boolean canAcceptAnyway, boolean isInsert, boolean isSSK, boolean isLocal, boolean isOfferReply, PeerNode source, boolean hasInStore, boolean preferInsert, boolean realTimeFlag, UIDTag tag)` Should a request be accepted by this node, based on its local capacity? This includes thread limits and ping times, but more importantly, mechanisms based on predicting worst case bandwidth usage for all running requests, and fairly sharing that capacity between peers.
`StoreLocationStats`	`sskCacheStats()` View of stats for SSK Cache
`StoreLocationStats`	`sskClientCacheStats()` View of stats for SSK ClientCache
`StoreLocationStats`	`sskSlashDotCacheStats()` View of stats for SSK SlashdotCache
`StoreLocationStats`	`sskStoreStats()` View of stats for SSK Store
`void`	`start()`
`void`	`successfulBlockReceive(boolean realTimeFlag, boolean isLocal)`
`void`	`swappingReceivedBytes(int x)`
`void`	`swappingSentBytes(int x)`
`void`	`waitUntilNotOverloaded(boolean isInsert)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_SUB_MAX_PING_TIME
```
public static final long DEFAULT_SUB_MAX_PING_TIME
```
Sub-max ping time. If ping is greater than this, we reject some requests.

DEFAULT_MAX_PING_TIME
```
public static final long DEFAULT_MAX_PING_TIME
```
Maximum overall average ping time. If ping is greater than this, we reject all requests.

MAX_THROTTLE_DELAY_RT
```
public static final long MAX_THROTTLE_DELAY_RT
```
Maximum throttled packet delay. If the throttled packet delay is greater than this, reject all packets.

MAX_THROTTLE_DELAY_BULK

public static final long MAX_THROTTLE_DELAY_BULK

SUB_MAX_THROTTLE_DELAY_RT
```
public static final long SUB_MAX_THROTTLE_DELAY_RT
```
If the throttled packet delay is less than this, reject no packets; if it's between the two, reject some packets.

SUB_MAX_THROTTLE_DELAY_BULK

public static final long SUB_MAX_THROTTLE_DELAY_BULK

MAX_BWLIMIT_DELAY_TIME_ALERT_THRESHOLD
```
public static final long MAX_BWLIMIT_DELAY_TIME_ALERT_THRESHOLD
```
How high can bwlimitDelayTime be before we alert (in milliseconds)

MAX_NODE_AVERAGE_PING_TIME_ALERT_THRESHOLD
```
public static final long MAX_NODE_AVERAGE_PING_TIME_ALERT_THRESHOLD
```
How high can nodeAveragePingTime be before we alert (in milliseconds)

MAX_BWLIMIT_DELAY_TIME_ALERT_DELAY
```
public static final long MAX_BWLIMIT_DELAY_TIME_ALERT_DELAY
```
How long we're over the bwlimitDelayTime threshold before we alert (in milliseconds)

MAX_NODE_AVERAGE_PING_TIME_ALERT_DELAY
```
public static final long MAX_NODE_AVERAGE_PING_TIME_ALERT_DELAY
```
How long we're over the nodeAveragePingTime threshold before we alert (in milliseconds)

MAX_INTERREQUEST_TIME
```
public static final long MAX_INTERREQUEST_TIME
```
Accept one request every 10 seconds regardless, to ensure we update the block send time.

peers
```
public final PeerManager peers
```

bwlimitDelayAlertRelevant
```
public boolean bwlimitDelayAlertRelevant
```
bwlimitDelay PeerManagerUserAlert should happen if true

nodeAveragePingAlertRelevant
```
public boolean nodeAveragePingAlertRelevant
```
nodeAveragePing PeerManagerUserAlert should happen if true

pInstantRejectIncomingOverall
```
public final BootstrappingDecayingRunningAverage pInstantRejectIncomingOverall
```
Average proportion of requests rejected immediately due to overload

pInstantRejectIncomingCHKRequestRT

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingCHKRequestRT

pInstantRejectIncomingSSKRequestRT

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingSSKRequestRT

pInstantRejectIncomingCHKInsertRT

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingCHKInsertRT

pInstantRejectIncomingSSKInsertRT

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingSSKInsertRT

pInstantRejectIncomingCHKRequestBulk

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingCHKRequestBulk

pInstantRejectIncomingSSKRequestBulk

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingSSKRequestBulk

pInstantRejectIncomingCHKInsertBulk

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingCHKInsertBulk

pInstantRejectIncomingSSKInsertBulk

public final BootstrappingDecayingRunningAverage pInstantRejectIncomingSSKInsertBulk

chkSuccessRatesByLocation

public final Histogram2 chkSuccessRatesByLocation

routingMissDistanceLocal

public final RunningAverage routingMissDistanceLocal

routingMissDistanceRemote

public final RunningAverage routingMissDistanceRemote

routingMissDistanceOverall

public final RunningAverage routingMissDistanceOverall

routingMissDistanceBulk

public final RunningAverage routingMissDistanceBulk

routingMissDistanceRT

public final RunningAverage routingMissDistanceRT

backedOffPercent

public final RunningAverage backedOffPercent

avgCacheCHKLocation

public final DecayingKeyspaceAverage avgCacheCHKLocation

avgSlashdotCacheCHKLocation

public final DecayingKeyspaceAverage avgSlashdotCacheCHKLocation

avgStoreCHKLocation

public final DecayingKeyspaceAverage avgStoreCHKLocation

avgStoreCHKSuccess

public final DecayingKeyspaceAverage avgStoreCHKSuccess

furthestCacheCHKSuccess
```
public double furthestCacheCHKSuccess
```

furthestClientCacheCHKSuccess

public double furthestClientCacheCHKSuccess

furthestSlashdotCacheCHKSuccess

public double furthestSlashdotCacheCHKSuccess

furthestStoreCHKSuccess
```
public double furthestStoreCHKSuccess
```

furthestStoreSSKSuccess
```
public double furthestStoreSSKSuccess
```

furthestCacheSSKSuccess
```
public double furthestCacheSSKSuccess
```

furthestClientCacheSSKSuccess

public double furthestClientCacheSSKSuccess

furthestSlashdotCacheSSKSuccess

public double furthestSlashdotCacheSSKSuccess

persister

protected final freenet.node.Persister persister

avgRequestLocation

protected final DecayingKeyspaceAverage avgRequestLocation

rootThreadGroup

public final java.lang.ThreadGroup rootThreadGroup

avgClientCacheCHKLocation

public final DecayingKeyspaceAverage avgClientCacheCHKLocation

avgCacheCHKSuccess

public final DecayingKeyspaceAverage avgCacheCHKSuccess

avgSlashdotCacheCHKSucess

public final DecayingKeyspaceAverage avgSlashdotCacheCHKSucess

avgClientCacheCHKSuccess

public final DecayingKeyspaceAverage avgClientCacheCHKSuccess

avgStoreSSKLocation

public final DecayingKeyspaceAverage avgStoreSSKLocation

avgCacheSSKLocation

public final DecayingKeyspaceAverage avgCacheSSKLocation

avgSlashdotCacheSSKLocation

public final DecayingKeyspaceAverage avgSlashdotCacheSSKLocation

avgClientCacheSSKLocation

public final DecayingKeyspaceAverage avgClientCacheSSKLocation

avgCacheSSKSuccess

public final DecayingKeyspaceAverage avgCacheSSKSuccess

avgSlashdotCacheSSKSuccess

public final DecayingKeyspaceAverage avgSlashdotCacheSSKSuccess

avgClientCacheSSKSuccess

public final DecayingKeyspaceAverage avgClientCacheSSKSuccess

avgStoreSSKSuccess

public final DecayingKeyspaceAverage avgStoreSSKSuccess

resendByteCounter

public final ByteCounter resendByteCounter

announceByteCounter

public final ByteCounter announceByteCounter

sskRequestCtr
```
public ByteCounter sskRequestCtr
```

chkRequestCtr
```
public ByteCounter chkRequestCtr
```

sskInsertCtr
```
public ByteCounter sskInsertCtr
```

chkInsertCtr
```
public ByteCounter chkInsertCtr
```

probeRequestCtr
```
public ByteCounter probeRequestCtr
```

routedMessageCtr
```
public ByteCounter routedMessageCtr
```

Method Detail

l10n

protected java.lang.String l10n(java.lang.String key)

l10n

protected java.lang.String l10n(java.lang.String key,
                                java.lang.String[] patterns,
                                java.lang.String[] values)

start

public void start()
           throws NodeInitException

Throws:: NodeInitException

shouldRejectRequest
```
public freenet.node.NodeStats.RejectReason shouldRejectRequest(boolean canAcceptAnyway,
                                                               boolean isInsert,
                                                               boolean isSSK,
                                                               boolean isLocal,
                                                               boolean isOfferReply,
                                                               PeerNode source,
                                                               boolean hasInStore,
                                                               boolean preferInsert,
                                                               boolean realTimeFlag,
                                                               UIDTag tag)
```
Should a request be accepted by this node, based on its local capacity? This includes thread limits and ping times, but more importantly, mechanisms based on predicting worst case bandwidth usage for all running requests, and fairly sharing that capacity between peers. Currently there is no mechanism for fairness between request types, this should be implemented on the sender side, and is with new load management. New load management has caused various changes here but that's probably sorted out now, i.e. changes involved in new load management will probably be mainly in PeerNode and RequestSender now.

Parameters:

canAcceptAnyway - Periodically we ignore the ping time and accept a request anyway. This is because the ping time partly depends on whether we have accepted any requests... FIXME this should be reconsidered.

isInsert - Whether this is an insert.

isSSK - Whether this is a request/insert for an SSK.

isLocal - Is this request originated locally? This can affect our estimate of likely bandwidth usage. Whether it should be used is unclear, since an attacker can observe bandwidth usage. It is configurable.

isOfferReply - Is this request actually a GetOfferedKey? This is a non-relayed fetch of a block which we recently offered via ULPRs.

source - The node that sent us this request. This should be null on local requests and non-null on remote requests, but in some parts of the code that doesn't always hold. It *should* hold here, but that needs more checking before we can remove isLocal.

hasInStore - If this is a request, do we have the block in the datastore already? This affects whether we accept it, which gives a significant performance gain. Arguably there is a security issue, although timing attacks are pretty easy anyway, and making requests go further may give attackers more samples...

preferInsert - If true, prefer inserts to requests (slightly). There is a flag for this on inserts. The idea is that when inserts are misrouted this causes long-term problems because the data is stored in the wrong place. New load management should avoid the need for this.

realTimeFlag - Is this a realtime request (low latency, low capacity) or a bulk request (high latency, high capacity)? They are accounted for separately.

Returns:

The reason for rejecting it, or null to accept it.

calculateMaxTransfersOut

public int calculateMaxTransfersOut(PeerNode peer,
                                    boolean realTime,
                                    double nonOverheadFraction,
                                    int maxTransfersOutUpperLimit)

getLowerLimit

public double getLowerLimit(double upperLimit,
                            int peerCount)

outwardTransfersPerInsert

public int outwardTransfersPerInsert()

getBwlimitDelayTimeRT
```
public double getBwlimitDelayTimeRT()
```

getBwlimitDelayTimeBulk

public double getBwlimitDelayTimeBulk()

getBwlimitDelayTime
```
public double getBwlimitDelayTime()
```

getNodeAveragePingTime

public double getNodeAveragePingTime()

getOpennetSizeEstimate

public int getOpennetSizeEstimate(long timestamp)

getDarknetSizeEstimate

public int getDarknetSizeEstimate(long timestamp)

getKnownLocations

public java.lang.Object[] getKnownLocations(long timestamp)

pRejectIncomingInstantly

public double pRejectIncomingInstantly()

pRejectIncomingInstantlyCHKRequestRT

public double pRejectIncomingInstantlyCHKRequestRT()

pRejectIncomingInstantlyCHKInsertRT

public double pRejectIncomingInstantlyCHKInsertRT()

pRejectIncomingInstantlySSKRequestRT

public double pRejectIncomingInstantlySSKRequestRT()

pRejectIncomingInstantlySSKInsertRT

public double pRejectIncomingInstantlySSKInsertRT()

pRejectIncomingInstantlyCHKRequestBulk

public double pRejectIncomingInstantlyCHKRequestBulk()

pRejectIncomingInstantlyCHKInsertBulk

public double pRejectIncomingInstantlyCHKInsertBulk()

pRejectIncomingInstantlySSKRequestBulk

public double pRejectIncomingInstantlySSKRequestBulk()

pRejectIncomingInstantlySSKInsertBulk

public double pRejectIncomingInstantlySSKInsertBulk()

maybeUpdatePeerManagerUserAlertStats
```
public void maybeUpdatePeerManagerUserAlertStats(long now)
```
Update peerManagerUserAlertStats if the timer has expired. Only called from PacketSender so doesn't need sync.

persistThrottlesToFieldSet
```
public SimpleFieldSet persistThrottlesToFieldSet()
```
Specified by:

persistThrottlesToFieldSet in interface Persistable

maybeUpdateNodeIOStats
```
public void maybeUpdateNodeIOStats(long now)
```
Update the node-wide bandwidth I/O stats if the timer has expired

getNodeIOStats
```
public long[] getNodeIOStats()
```

waitUntilNotOverloaded

public void waitUntilNotOverloaded(boolean isInsert)

getActiveThreadCount
```
public int getActiveThreadCount()
```

getActiveThreadsByPriority

public int[] getActiveThreadsByPriority()

getWaitingThreadsByPriority

public int[] getWaitingThreadsByPriority()

getThreadLimit
```
public int getThreadLimit()
```

getThreads
```
public java.lang.Thread[] getThreads()
```
Gets a copy of the thread list. The result might contain null values: The end of the list is marked by a null entry in the array.

exportVolatileFieldSet

public SimpleFieldSet exportVolatileFieldSet()

isTestnetEnabled
```
public boolean isTestnetEnabled()
```

getRejectReasonsTable

public boolean getRejectReasonsTable(HTMLNode table)

getLocalRejectReasonsTable

public boolean getLocalRejectReasonsTable(HTMLNode table)

requestCompleted

public void requestCompleted(boolean succeeded,
                             boolean isRemote,
                             boolean isSSK)

fillSuccessRateBox

public void fillSuccessRateBox(HTMLNode parent)

requestSentBytes

public void requestSentBytes(boolean ssk,
                             int x)

requestReceivedBytes

public void requestReceivedBytes(boolean ssk,
                                 int x)

insertSentBytes

public void insertSentBytes(boolean ssk,
                            int x)

insertReceivedBytes

public void insertReceivedBytes(boolean ssk,
                                int x)

getCHKRequestTotalBytesSent

public long getCHKRequestTotalBytesSent()

getSSKRequestTotalBytesSent

public long getSSKRequestTotalBytesSent()

getCHKInsertTotalBytesSent

public long getCHKInsertTotalBytesSent()

getSSKInsertTotalBytesSent

public long getSSKInsertTotalBytesSent()

offeredKeysSenderReceivedBytes

public void offeredKeysSenderReceivedBytes(int x)

offeredKeysSenderSentBytes

public void offeredKeysSenderSentBytes(int x)

getOfferedKeysTotalBytesReceived

public long getOfferedKeysTotalBytesReceived()

getOfferedKeysTotalBytesSent

public long getOfferedKeysTotalBytesSent()

getOffersSentBytesSent
```
public long getOffersSentBytesSent()
```

swappingReceivedBytes

public void swappingReceivedBytes(int x)

swappingSentBytes
```
public void swappingSentBytes(int x)
```

getSwappingTotalBytesReceived

public long getSwappingTotalBytesReceived()

getSwappingTotalBytesSent

public long getSwappingTotalBytesSent()

reportAuthBytes
```
public void reportAuthBytes(int x)
```

getTotalAuthBytesSent
```
public long getTotalAuthBytesSent()
```

getResendBytesSent
```
public long getResendBytesSent()
```

reportUOMBytesSent

public void reportUOMBytesSent(int x)

getUOMBytesSent
```
public long getUOMBytesSent()
```

getAnnounceBytesSent
```
public long getAnnounceBytesSent()
```

getAnnounceBytesPayloadSent

public long getAnnounceBytesPayloadSent()

getRoutingStatusBytes
```
public long getRoutingStatusBytes()
```

networkColoringReceivedBytes

public void networkColoringReceivedBytes(int x)

networkColoringSentBytes

public void networkColoringSentBytes(int x)

getNetworkColoringSentBytes

public long getNetworkColoringSentBytes()

pingCounterReceived

public void pingCounterReceived(int x)

pingCounterSent
```
public void pingCounterSent(int x)
```

getPingSentBytes
```
public long getPingSentBytes()
```

getProbeRequestSentBytes

public long getProbeRequestSentBytes()

getRoutedMessageSentBytes

public long getRoutedMessageSentBytes()

getDisconnBytesSent
```
public long getDisconnBytesSent()
```

getInitialMessagesBytesSent

public long getInitialMessagesBytesSent()

getChangedIPBytesSent
```
public long getChangedIPBytesSent()
```

getNodeToNodeBytesSent
```
public long getNodeToNodeBytesSent()
```

getAllocationNoticesBytesSent

public long getAllocationNoticesBytesSent()

getFOAFBytesSent
```
public long getFOAFBytesSent()
```

getNotificationOnlyPacketsSentBytes

public long getNotificationOnlyPacketsSentBytes()

getSentOverhead
```
public long getSentOverhead()
```

getSentOverheadPerSecond
```
public double getSentOverheadPerSecond()
```
The average number of bytes sent per second for things other than requests, inserts, and offer replies.

successfulBlockReceive

public void successfulBlockReceive(boolean realTimeFlag,
                                   boolean isLocal)

failedBlockReceive

public void failedBlockReceive(boolean normalFetch,
                               boolean timeout,
                               boolean realTimeFlag,
                               boolean isLocal)

reportIncomingRequestLocation

public void reportIncomingRequestLocation(double loc)

getIncomingRequestLocation

public int[] getIncomingRequestLocation(int[] retval)

reportOutgoingLocalRequestLocation

public void reportOutgoingLocalRequestLocation(double loc)

getOutgoingLocalRequestLocation

public int[] getOutgoingLocalRequestLocation(int[] retval)

reportOutgoingRequestLocation

public void reportOutgoingRequestLocation(double loc)

getOutgoingRequestLocation

public int[] getOutgoingRequestLocation(int[] retval)

reportCHKOutcome

public void reportCHKOutcome(long rtt,
                             boolean successful,
                             double location,
                             boolean isRealtime)

reportSSKOutcome

public void reportSSKOutcome(long rtt,
                             boolean successful,
                             boolean isRealtime)

fillDetailedTimingsBox

public void fillDetailedTimingsBox(HTMLNode html)

fillRemoteRequestHTLsBox

public void fillRemoteRequestHTLsBox(HTMLNode html,
                                     boolean realTime)

reportDatabaseJob

public void reportDatabaseJob(java.lang.String jobType,
                              long executionTimeMiliSeconds)

reportMandatoryBackoff

public void reportMandatoryBackoff(java.lang.String backoffType,
                                   long backoffTimeMilliSeconds,
                                   boolean realtime)

reportRoutingBackoff

public void reportRoutingBackoff(java.lang.String backoffType,
                                 long backoffTimeMilliSeconds,
                                 boolean realtime)

reportTransferBackoff

public void reportTransferBackoff(java.lang.String backoffType,
                                  long backoffTimeMilliSeconds,
                                  boolean realtime)

chkStoreStats
```
public StoreLocationStats chkStoreStats()
```
View of stats for CHK Store

Returns:

stats for CHK Store

chkCacheStats
```
public StoreLocationStats chkCacheStats()
```
View of stats for CHK Cache

Returns:

CHK cache stats

chkSlashDotCacheStats
```
public StoreLocationStats chkSlashDotCacheStats()
```
View of stats for CHK SlashdotCache

Returns:

CHK Slashdotcache stats

chkClientCacheStats
```
public StoreLocationStats chkClientCacheStats()
```
View of stats for CHK ClientCache

Returns:

CHK ClientCache stats

sskStoreStats
```
public StoreLocationStats sskStoreStats()
```
View of stats for SSK Store

Returns:

stats for SSK Store

sskCacheStats
```
public StoreLocationStats sskCacheStats()
```
View of stats for SSK Cache

Returns:

SSK cache stats

sskSlashDotCacheStats
```
public StoreLocationStats sskSlashDotCacheStats()
```
View of stats for SSK SlashdotCache

Returns:

SSK Slashdotcache stats

sskClientCacheStats
```
public StoreLocationStats sskClientCacheStats()
```
View of stats for SSK ClientCache

Returns:

SSK ClientCache stats

getMandatoryBackoffStatistics

public NodeStats.TimedStats[] getMandatoryBackoffStatistics(boolean realtime)

getRoutingBackoffStatistics

public NodeStats.TimedStats[] getRoutingBackoffStatistics(boolean realtime)

getTransferBackoffStatistics

public NodeStats.TimedStats[] getTransferBackoffStatistics(boolean realtime)

getDatabaseJobExecutionStatistics

public NodeStats.TimedStats[] getDatabaseJobExecutionStatistics()

createPeerLoadStats

public NodeStats.PeerLoadStats createPeerLoadStats(PeerNode peer,
                                                   int transfersPerInsert,
                                                   boolean realTimeFlag)

parseLoadStats

public NodeStats.PeerLoadStats parseLoadStats(PeerNode source,
                                              Message m)

getRunningRequestsTo

public freenet.node.NodeStats.RunningRequestsSnapshot getRunningRequestsTo(PeerNode peerNode,
                                                                           int transfersPerInsert,
                                                                           boolean realTimeFlag)

ignoreLocalVsRemoteBandwidthLiability

public boolean ignoreLocalVsRemoteBandwidthLiability()

reportAnnounceForwarded

public void reportAnnounceForwarded(int forwardedRefs,
                                    PeerNode source)

getTransfersPerAnnounce
```
public int getTransfersPerAnnounce()
```

shouldAcceptAnnouncement

public freenet.node.NodeStats.AnnouncementDecision shouldAcceptAnnouncement(long uid)

endAnnouncement

public void endAnnouncement(long uid)

blockTime

public void blockTime(long interval,
                      boolean realtime)

Specified by:: blockTime in interface BlockTransmitter.BlockTimeCallback

maxPeerPingTime
```
public long maxPeerPingTime()
```
If a peer is over this threshold it is considered to be backed off.

reportNLMDelay

public void reportNLMDelay(long waitTime,
                           boolean realTime,
                           boolean local)

drawNewLoadManagementDelayTimes

public void drawNewLoadManagementDelayTimes(HTMLNode content)

reportFatalTimeoutInWait

public void reportFatalTimeoutInWait(boolean local)

reportAllocatedSlot

public void reportAllocatedSlot(boolean local)

enableNewLoadManagement

public boolean enableNewLoadManagement(boolean realTimeFlag)

getNoisyRejectStats
```
public byte[] getNoisyRejectStats()
```
Returns:

Array of 4 bytes, with the percentage rejections for (bulk only): CHK request, SSK request, CHK insert, SSK insert. Negative value = insufficient data. Positive value = percentage rejected. PRECAUTIONS: We update this statistic every 10 minutes. We don't return a value unless we have at least 200 samples. We add Gaussian noise. FIXME SECURITY We should remove this eventually.

randomNoise
```
public final double randomNoise(double input,
                                double sigma)
```
Applies multiplicative Gaussian noise of mean 1.0 and the specified sigma to the input value.

Parameters:

input - Value to apply noise to.

sigma - Proportion change at one standard deviation.

Returns:

Value +/- Gaussian percentage.

getBandwidthLiabilityUsage

public final double getBandwidthLiabilityUsage()

Class NodeStats

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_SUB_MAX_PING_TIME

DEFAULT_MAX_PING_TIME

MAX_THROTTLE_DELAY_RT

MAX_THROTTLE_DELAY_BULK

SUB_MAX_THROTTLE_DELAY_RT

SUB_MAX_THROTTLE_DELAY_BULK

MAX_BWLIMIT_DELAY_TIME_ALERT_THRESHOLD

MAX_NODE_AVERAGE_PING_TIME_ALERT_THRESHOLD

MAX_BWLIMIT_DELAY_TIME_ALERT_DELAY

MAX_NODE_AVERAGE_PING_TIME_ALERT_DELAY

MAX_INTERREQUEST_TIME

peers

bwlimitDelayAlertRelevant

nodeAveragePingAlertRelevant

pInstantRejectIncomingOverall

pInstantRejectIncomingCHKRequestRT

pInstantRejectIncomingSSKRequestRT

pInstantRejectIncomingCHKInsertRT

pInstantRejectIncomingSSKInsertRT

pInstantRejectIncomingCHKRequestBulk

pInstantRejectIncomingSSKRequestBulk

pInstantRejectIncomingCHKInsertBulk

pInstantRejectIncomingSSKInsertBulk

chkSuccessRatesByLocation

routingMissDistanceLocal

routingMissDistanceRemote

routingMissDistanceOverall

routingMissDistanceBulk

routingMissDistanceRT

backedOffPercent

avgCacheCHKLocation

avgSlashdotCacheCHKLocation

avgStoreCHKLocation

avgStoreCHKSuccess

furthestCacheCHKSuccess

furthestClientCacheCHKSuccess

furthestSlashdotCacheCHKSuccess

furthestStoreCHKSuccess

furthestStoreSSKSuccess

furthestCacheSSKSuccess

furthestClientCacheSSKSuccess

furthestSlashdotCacheSSKSuccess

persister

avgRequestLocation

rootThreadGroup

avgClientCacheCHKLocation

avgCacheCHKSuccess

avgSlashdotCacheCHKSucess

avgClientCacheCHKSuccess

avgStoreSSKLocation

avgCacheSSKLocation

avgSlashdotCacheSSKLocation

avgClientCacheSSKLocation

avgCacheSSKSuccess

avgSlashdotCacheSSKSuccess

avgClientCacheSSKSuccess

avgStoreSSKSuccess

resendByteCounter

announceByteCounter

sskRequestCtr

chkRequestCtr

sskInsertCtr

chkInsertCtr

probeRequestCtr

routedMessageCtr

Method Detail

l10n

l10n

start

shouldRejectRequest

calculateMaxTransfersOut

getLowerLimit

outwardTransfersPerInsert

getBwlimitDelayTimeRT