ClientPeerSelector (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.tunnel.pool.ConnectChecker
- - net.i2p.router.tunnel.pool.TunnelPeerSelector
  - - net.i2p.router.tunnel.pool.ClientPeerSelector

```
class ClientPeerSelector
extends TunnelPeerSelector
```
Pick peers randomly out of the fast pool, and put them into tunnels ordered by XOR distance from a random key.

Nested Class Summary
- Nested classes/interfaces inherited from class net.i2p.router.tunnel.pool.TunnelPeerSelector
  TunnelPeerSelector.Excluder

Field Summary
- Fields inherited from class net.i2p.router.tunnel.pool.TunnelPeerSelector
  _firstHopFails, _peerCooldowns, _provenResponders, ATTACK_THRESHOLD, DEGRADED_BUILD_THRESHOLD, FAILURE_MAP_MAX_SIZE, FIRST_HOP_FAIL_COOLDOWN_MS, PEER_SELECTION_COOLDOWN_MS, PROVEN_RESPONDER_WINDOW_MS, STARTUP_WARNING_SUPPRESS_MS
- Fields inherited from class net.i2p.router.tunnel.pool.ConnectChecker
  ANY_V4, ctx, log

Constructor Summary
Constructors
Constructor and Description
ClientPeerSelector(RouterContext context)
Constructor.

Constructors
Constructor and Description
`ClientPeerSelector(RouterContext context)` Constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) static boolean`	`adoptIfFilled(List<Hash> rv, Set<Hash> fallback)` Adopts the fallback peer set when it has candidates: clears the running selection and replaces it with the fallback.
`(package private) static boolean`	`canUseStressFallback(double buildSuccess, boolean useHighCapPrimary, int rvSize)` Whether the selection may use the progressive stress fallbacks and the shortened-tunnel allowance: network stress (build success below the attack threshold) or HighCap-primary mode, with at least one peer already selected.
`(package private) static int`	`compareAcceptance(PeerProfile prof1, PeerProfile prof2)` Acceptance ratio tiers: good (> 0.3) ranks above low (< 0.3), which ranks above dead (<= 0).
`(package private) static int`	`compareActivity(PeerProfile prof1, PeerProfile prof2, long now, long thirtyMinutes)` Peers active within the activity window sort first.
`(package private) static int`	`compareExcluded(Hash p1, Hash p2, Set<Hash> exclude)` Excluded peers sort last; two excluded peers compare equal.
`(package private) static int`	`compareLatency(float lat1, float lat2)` Lower measured tunnel-test latency sorts first; measured beats unknown.
`(package private) static int`	`compareQuality(Hash p1, Hash p2, Set<Hash> exclude, PeerProfile prof1, PeerProfile prof2, long now, long thirtyMinutes)` Full quality comparison cascade.
`(package private) static int`	`compareSlowLatency(float lat1, float lat2)` Peers with tunnel test latency over 15s sort last; when both are slow, the less slow one sorts first.
`(package private) List<Hash>`	`filterByReliability(Set<Hash> candidates, Set<Hash> exclude)` Filter candidates through the reliability gate: a peer must have an adequate acceptance ratio and at least one recent activity or connection signal to remain.
`(package private) List<Hash>`	`filterGhostPeers(List<Hash> peers)` Filter out ghost peers from the selected peer list.
`(package private) List<Hash>`	`finalizeSelection(TunnelPoolSettings settings, List<Hash> rv, boolean isInbound)` Insert self, ghost-filter, strategy post-processing, duplicate re-check, and cooldowns.
`(package private) static int`	`firstHopQualityTier(int attempts, boolean inStartup, int currentTier)` First-hop quality tier for the current attempt: 0 = prefer established peers, 1 = also accept connecting peers, 2 = accept any peer that passed the tier filters.
`(package private) boolean`	`isReliable(PeerProfile profile, long now, long tenMinutes, long thirtyMinutes)` Reliability gate: the acceptance ratio must be at least 0.3, and the peer must show a recent tunnel-test success, recent activity, or an established connection.
`(package private) static boolean`	`isStartupGracePeriod(RouterContext ctx)` Whether the router is still in the startup grace period (first `STARTUP_GRACE_MS` ms of uptime), during which strict first-hop quality gates and soft fallbacks are relaxed because few peers are available and transient transport failures are common.
`(package private) Comparator<Hash>`	`peerQualityComparator(Set<Hash> exclude, long now, long thirtyMinutes)` Build a comparator that orders peers by tunnel-building quality: excluded peers last, then by acceptance ratio, activity recency, and tunnel-test latency.
`List<Hash>`	`selectPeers(TunnelPoolSettings settings)` Returns ENDPOINT FIRST, GATEWAY LAST!!!! In: us ..

Methods inherited from class net.i2p.router.tunnel.pool.TunnelPeerSelector
addFreshCooldownExclusions, allowAsIBGW, allowAsOBEP, allowFirewalledUnderAttack, checkTunnel, compareProven, countKnownCaps, filterSlow, formatExcludedPeers, getActivityWindow, getActivityWindow, getBuildSuccess, getClosestHopExclude, getExclude, getLength, getPeersInPool, getWindowMultiplier, hasConnectivitySignal, hasRecoveredFromFailure, hasTunnelLongerThanOne, hasValidTransportAddress, isDuplicateSequence, isFirstHopFailing, isInStartupGracePeriod, isInStartupGracePeriod, isIPv6Only, isLowAcceptanceRatio, isOutdatedVersion, isProvenResponder, isStalePeer, isStalePeer, isUsableRouterAddress, isZeroHopSettings, keepAlive, matchesExistingTunnel, orderPeers, preConnectTo, prunePeerMaps, recordFirstHopFail, recordPeerFailure, regeneratePeers, relaxedExcludeCaps, selectExplicit, setWindowMultiplier, shouldExclude, shouldExclude, shouldSelectExplicit, supportsNTCP2

Methods inherited from class net.i2p.router.tunnel.pool.ConnectChecker
canConnect, canConnect, canConnect, getInboundMask, getOutboundMask, isNTCPDisabled, isSSUDisabled

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

- Constructor Detail
  - ClientPeerSelector
```
public ClientPeerSelector(RouterContext context)
```
    Constructor.
    Parameters:
    context - the router context
- Method Detail
  - adoptIfFilled
```
static boolean adoptIfFilled(List<Hash> rv,
                             Set<Hash> fallback)
```
    Adopts the fallback peer set when it has candidates: clears the running selection and replaces it with the fallback. Returns whether the fallback was adopted so callers can log success with the adopted size. Mutates only rv.
    Parameters:
    rv - the running selection, replaced when fallback is non-empty
    fallback - the fallback candidates (self already removed)
    Returns:
    whether the fallback was adopted
  - canUseStressFallback
```
static boolean canUseStressFallback(double buildSuccess,
                                    boolean useHighCapPrimary,
                                    int rvSize)
```
    Whether the selection may use the progressive stress fallbacks and the shortened-tunnel allowance: network stress (build success below the attack threshold) or HighCap-primary mode, with at least one peer already selected. Pure decision — no side effects.
    Parameters:
    buildSuccess - current tunnel build success rate
    useHighCapPrimary - whether the selection prefers high-capacity peers
    rvSize - current number of selected peers
    Returns:
    whether stress fallbacks may be attempted
  - compareAcceptance
```
static int compareAcceptance(PeerProfile prof1,
                             PeerProfile prof2)
```
    Acceptance ratio tiers: good (> 0.3) ranks above low (< 0.3), which ranks above dead (<= 0). Missing profiles default to 1.0.
    Parameters:
    prof1 - first peer's profile, or null
    prof2 - second peer's profile, or null
    Returns:
    negative, zero, or positive
  - compareActivity
```
static int compareActivity(PeerProfile prof1,
                           PeerProfile prof2,
                           long now,
                           long thirtyMinutes)
```
    Peers active within the activity window sort first.
    Parameters:
    prof1 - first peer's profile, or null
    prof2 - second peer's profile, or null
    now - current time from the router clock
    thirtyMinutes - activity window in ms
    Returns:
    negative, zero, or positive
  - compareExcluded
```
static int compareExcluded(Hash p1,
                           Hash p2,
                           Set<Hash> exclude)
```
    Excluded peers sort last; two excluded peers compare equal.
    Parameters:
    p1 - first peer
    p2 - second peer
    exclude - peers to deprioritize, or null
    Returns:
    negative, zero, or positive
  - compareLatency
```
static int compareLatency(float lat1,
                          float lat2)
```
    Lower measured tunnel-test latency sorts first; measured beats unknown.
    Parameters:
    lat1 - first peer's tunnel test time average
    lat2 - second peer's tunnel test time average
    Returns:
    negative, zero, or positive
  - compareQuality
```
static int compareQuality(Hash p1,
                          Hash p2,
                          Set<Hash> exclude,
                          PeerProfile prof1,
                          PeerProfile prof2,
                          long now,
                          long thirtyMinutes)
```
    Full quality comparison cascade. Stage order is significant — each stage short-circuits the ones below it: excluded last, then proven responders (recent successful participation), then acceptance ratio, slow tunnel-test latency, activity recency, and latency.
    Parameters:
    p1 - first peer
    p2 - second peer
    exclude - peers to deprioritize, or null
    prof1 - first peer's profile, or null
    prof2 - second peer's profile, or null
    now - current time from the router clock
    thirtyMinutes - activity window in ms
    Returns:
    negative, zero, or positive
  - compareSlowLatency
```
static int compareSlowLatency(float lat1,
                              float lat2)
```
    Peers with tunnel test latency over 15s sort last; when both are slow, the less slow one sorts first. 0 latency means no data (unknown).
    Parameters:
    lat1 - first peer's tunnel test time average
    lat2 - second peer's tunnel test time average
    Returns:
    negative, zero, or positive
  - filterByReliability
```
List<Hash> filterByReliability(Set<Hash> candidates,
                               Set<Hash> exclude)
```
    Filter candidates through the reliability gate: a peer must have an adequate acceptance ratio and at least one recent activity or connection signal to remain. The input order is preserved; ranking is left to the caller's quality sort so each reliability signal plays a single role.
    Parameters:
    candidates - peers to filter
    exclude - peers to exclude
    Returns:
    list of peers passing the reliability gate, in input order
  - filterGhostPeers
```
List<Hash> filterGhostPeers(List<Hash> peers)
```
    Filter out ghost peers from the selected peer list. Ghost peers are those with consistent tunnel build timeouts.
    Parameters:
    peers - the list of selected peers (excluding self)
    Returns:
    filtered list without ghost peers; never null
  - finalizeSelection
```
List<Hash> finalizeSelection(TunnelPoolSettings settings,
                             List<Hash> rv,
                             boolean isInbound)
```
    Insert self, ghost-filter, strategy post-processing, duplicate re-check, and cooldowns. Quality-sorts the non-self hops for inbound selections only (see below).
  - firstHopQualityTier
```
static int firstHopQualityTier(int attempts,
                               boolean inStartup,
                               int currentTier)
```
    First-hop quality tier for the current attempt: 0 = prefer established peers, 1 = also accept connecting peers, 2 = accept any peer that passed the tier filters. Escalates with attempts; during the startup grace period the tier never changes. Note the quirk: attempts 4-5 downgrade a tier-2 selection to 1 (preserved verbatim).
    Pure decision — no side effects.
    Parameters:
    attempts - number of quality-check attempts already made
    inStartup - whether the router is in the startup grace period
    currentTier - the tier before this attempt
    Returns:
    the tier for this attempt
  - isReliable
```
boolean isReliable(PeerProfile profile,
                   long now,
                   long tenMinutes,
                   long thirtyMinutes)
```
    Reliability gate: the acceptance ratio must be at least 0.3, and the peer must show a recent tunnel-test success, recent activity, or an established connection. Each signal is consulted exactly once.
    Parameters:
    profile - the peer profile (may be null)
    now - current time from the router clock
    tenMinutes - tunnel-test recency window in ms
    thirtyMinutes - activity recency window in ms
    Returns:
    true if the peer passes the reliability gate
  - isStartupGracePeriod
```
static boolean isStartupGracePeriod(RouterContext ctx)
```
    Whether the router is still in the startup grace period (first STARTUP_GRACE_MS ms of uptime), during which strict first-hop quality gates and soft fallbacks are relaxed because few peers are available and transient transport failures are common.
    Pure decision — no side effects.
    Parameters:
    ctx - the router context
    Returns:
    whether the router is within the startup grace period
  - peerQualityComparator
```
Comparator<Hash> peerQualityComparator(Set<Hash> exclude,
                                       long now,
                                       long thirtyMinutes)
```
    Build a comparator that orders peers by tunnel-building quality: excluded peers last, then by acceptance ratio, activity recency, and tunnel-test latency.
    Stage order is significant — each stage short-circuits the ones below it.
    Parameters:
    exclude - peers to deprioritize, or null
    now - current time from the router clock
    thirtyMinutes - activity window in ms
  - selectPeers
```
public List<Hash> selectPeers(TunnelPoolSettings settings)
```
    Returns ENDPOINT FIRST, GATEWAY LAST!!!! In: us .. closest .. middle .. IBGW Out: OBGW .. middle .. closest .. us
    Specified by:
    selectPeers in class TunnelPeerSelector
    Parameters:
    settings - the tunnel pool settings
    Returns:
    ordered list of Hash objects (one per peer) specifying what order they should appear in a tunnel (ENDPOINT FIRST). This includes the local router in the list. Never null; an empty list means no peers could be selected.

Class ClientPeerSelector

Nested Class Summary

Nested classes/interfaces inherited from class net.i2p.router.tunnel.pool.TunnelPeerSelector

Field Summary

Fields inherited from class net.i2p.router.tunnel.pool.TunnelPeerSelector

Fields inherited from class net.i2p.router.tunnel.pool.ConnectChecker

Constructor Summary

Method Summary

Methods inherited from class net.i2p.router.tunnel.pool.TunnelPeerSelector

Methods inherited from class net.i2p.router.tunnel.pool.ConnectChecker

Methods inherited from class java.lang.Object

Constructor Detail

ClientPeerSelector

Method Detail

adoptIfFilled

canUseStressFallback

compareAcceptance

compareActivity

compareExcluded

compareLatency

compareQuality

compareSlowLatency

filterByReliability

filterGhostPeers

finalizeSelection

firstHopQualityTier

isReliable

isStartupGracePeriod

peerQualityComparator

selectPeers