TunnelPoolManager (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- net.i2p.router.tunnel.pool.TunnelPoolManager

All Implemented Interfaces:
Service, TunnelManagerFacade
```
public class TunnelPoolManager
extends Object
implements TunnelManagerFacade
```
Manage all the exploratory and client tunnel pools. Run the tunnel builder and handler threads.

Field Summary
Fields
Modifier and Type Field and Description
(package private) static String PROP_OUTBOUND_STARTUP_RETRIES
Property: outbound tunnel startup retries.

Fields
Modifier and Type	Field and Description
`(package private) static String`	`PROP_OUTBOUND_STARTUP_RETRIES` Property: outbound tunnel startup retries.

Constructor Summary
Constructors
Constructor and Description
TunnelPoolManager(RouterContext ctx)
Manage tunnel pools for the given router context.

Constructors
Constructor and Description
`TunnelPoolManager(RouterContext ctx)` Manage tunnel pools for the given router context.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addAlias(Destination dest, ClientTunnelSettings settings, Destination existingClient)` Add another destination to the same tunnels.
`void`	`adjustBuildHandlerThreads(int target)` Dynamically adjust BuildHandler thread count to match target.
`(package private) void`	`buildComplete(PooledTunnelCreatorConfig cfg)` Queue a recurring test job if appropriate.
`void`	`buildTunnels(Destination client, ClientTunnelSettings settings)` Used only at session startup.
`int`	`checkAndRecoverPools()` Emergency pool recovery: Check all registered clients have valid tunnel pools.
`boolean`	`disableTunnelTesting()` Tunnel testing status.
`void`	`fail(Hash peer)` Fail all outbound tunnels with this peer as first hop, and all inbound tunnels with this peer as the last hop, baecause we can't contact it any more.
`void`	`forceRemoveTunnels(Hash destination)` Force immediate removal of a pool - used for router shutdown.
`int`	`getBuildHandlerThreadCount()` Actual number of running BuildHandler threads.
`static int`	`getBuildHandlerThreads()` Tuned by Tuner — min 2, max 8
`(package private) BuildExecutor`	`getExecutor()` The build executor.
`int`	`getFreeTunnelCount()` Number of valid (non-failed, non-expired) inbound exploratory tunnels.
`GhostPeerManager`	`getGhostPeerManager()` The ghost peer manager for tracking unresponsive peers.
`int`	`getInboundBuildQueueSize()` Size of the inbound build queue.
`Map<Hash,TunnelPool>`	`getInboundClientPools()` For TunnelRenderer in router console.
`int`	`getInboundClientTunnelCount()` Number of GOOD (tested+passed, non-failed, non-expired) inbound client tunnels across all destinations.
`int`	`getInboundClientTunnelCount(Hash destination)` Use to verify a tunnel pool is alive.
`TunnelPool`	`getInboundExploratoryPool()` For TunnelRenderer in router console
`TunnelPool`	`getInboundPool(Hash client)` Inbound tunnel pool for the given client, or null if none.
`TunnelPoolSettings`	`getInboundSettings()` The inbound exploratory tunnel pool settings.
`TunnelPoolSettings`	`getInboundSettings(Hash client)` Get settings for a client's inbound tunnel pool.
`long`	`getLastParticipatingExpiration()` The expiration time of the last participating tunnel.
`Map<Hash,TunnelPool>`	`getOutboundClientPools()` For TunnelRenderer in router console.
`int`	`getOutboundClientTunnelCount()` Number of GOOD (tested+passed, non-failed, non-expired) outbound client tunnels across all destinations.
`int`	`getOutboundClientTunnelCount(Hash destination)` Use to verify a tunnel pool is alive.
`TunnelPool`	`getOutboundExploratoryPool()` For TunnelRenderer in router console
`TunnelPool`	`getOutboundPool(Hash client)` Outbound tunnel pool for the given client, or null if none.
`TunnelPoolSettings`	`getOutboundSettings()` The outbound exploratory tunnel pool settings.
`TunnelPoolSettings`	`getOutboundSettings(Hash client)` Get settings for a client's outbound tunnel pool.
`int`	`getOutboundTunnelCount()` Number of valid (non-failed, non-expired) outbound exploratory tunnels.
`int`	`getParticipatingCount()` The number of tunnels we're participating in as a gateway or endpoint.
`double`	`getShareRatio()` Get the share ratio of participating tunnels.
`int`	`getUsableInboundClientTunnelCount(Hash destination)` Get USABLE inbound client tunnel count for a specific destination.
`int`	`getUsableOutboundClientTunnelCount(Hash destination)` Get USABLE outbound client tunnel count for a specific destination.
`boolean`	`isFirewalled()` Firewall status.
`(package private) boolean`	`isShutdown()` Whether the manager has been shut down.
`boolean`	`isValidTunnel(Hash client, TunnelInfo tunnel)` Check if a tunnel is valid and belongs to the client's pool.
`void`	`listPools(List<TunnelPool> out)` List of TunnelPool instances currently in play.
`void`	`logPoolHealth()` Log pool health summary for monitoring.
`void`	`pruneAllPools()` Prune excess tunnels from all pools to stay within budget.
`void`	`removeAlias(Destination dest)` Remove a destination for the same tunnels as another.
`(package private) void`	`removeFromExpiration(PooledTunnelCreatorConfig cfg)` Remove a tunnel from the expiration queue to prevent memory leak
`void`	`removeTunnels(Destination dest)` Must be called AFTER deregistration by the client manager.
`void`	`removeTunnels(Hash destination)` This will be called twice, once by the inbound and once by the outbound pool.
`void`	`renderStatusHTML(Writer out)` Required by `Service`; status rendering moved to routerconsole.
`boolean`	`replaceSlowTunnels()` Find and remove tunnels exceeding the latency threshold.
`void`	`restart()` Restart all tunnel handlers and rebuild all tunnels
`TunnelInfo`	`selectAnyInboundTunnel()` Pick a random inbound tunnel from any pool — client pools first, then exploratory.
`TunnelInfo`	`selectAnyOutboundTunnel()` Pick a random outbound tunnel from any pool — client pools first, then exploratory.
`TunnelInfo`	`selectInboundExploratoryTunnel(Hash closestTo)` Pick the inbound exploratory tunnel with the gateway closest to the given hash.
`TunnelInfo`	`selectInboundTunnel()` Pick a random inbound exploratory tunnel.
`TunnelInfo`	`selectInboundTunnel(Hash destination)` Pick a random inbound tunnel from the given destination's pool.
`TunnelInfo`	`selectInboundTunnel(Hash destination, Hash closestTo)` Pick the inbound tunnel with the gateway closest to the given hash from the given destination's pool.
`TunnelInfo`	`selectOutboundExploratoryTunnel(Hash closestTo)` Pick the outbound exploratory tunnel with the endpoint closest to the given hash.
`TunnelInfo`	`selectOutboundTunnel()` Pick a random outbound exploratory tunnel.
`TunnelInfo`	`selectOutboundTunnel(Hash destination)` Pick a random outbound tunnel from the given destination's pool.
`TunnelInfo`	`selectOutboundTunnel(Hash destination, Hash closestTo)` Pick the outbound tunnel with the endpoint closest to the given hash from the given destination's pool.
`Set<Hash>`	`selectPeersInTooManyTunnels()` For reliability reasons, don't allow a peer in more than x% of client and exploratory tunnels.
`static void`	`setBuildHandlerThreads(int val)` The number of build handler threads.
`void`	`setInboundSettings(Hash client, TunnelPoolSettings settings)` Set settings for a client's inbound tunnel pool.
`void`	`setInboundSettings(TunnelPoolSettings settings)` The inbound exploratory tunnel pool settings.
`void`	`setOutboundSettings(Hash client, TunnelPoolSettings settings)` Set settings for a client's outbound tunnel pool.
`void`	`setOutboundSettings(TunnelPoolSettings settings)` The outbound exploratory tunnel pool settings.
`void`	`shutdown()` Cannot be restarted
`void`	`startup()` Start the tunnel pool manager and build initial tunnels
`(package private) void`	`tunnelFailed()` Poke the build executor to build more tunnels.

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

- Field Detail
  - PROP_OUTBOUND_STARTUP_RETRIES
```
static final String PROP_OUTBOUND_STARTUP_RETRIES
```
    Property: outbound tunnel startup retries.
    See Also:
    Constant Field Values
- Constructor Detail
  - TunnelPoolManager
```
public TunnelPoolManager(RouterContext ctx)
```
    Manage tunnel pools for the given router context.
    Parameters:
    ctx - the router context
- Method Detail
  - addAlias
```
public boolean addAlias(Destination dest,
                        ClientTunnelSettings settings,
                        Destination existingClient)
```
    Add another destination to the same tunnels. Must have same encryption key and a different signing key.
    Specified by:
    addAlias in interface TunnelManagerFacade
    Returns:
    success
    Throws:
    IllegalArgumentException - if not
  - adjustBuildHandlerThreads
```
public void adjustBuildHandlerThreads(int target)
```
    Dynamically adjust BuildHandler thread count to match target.
    Parameters:
    target - desired thread count
  - buildComplete
```
void buildComplete(PooledTunnelCreatorConfig cfg)
```
    Queue a recurring test job if appropriate.
  - buildTunnels
```
public void buildTunnels(Destination client,
                         ClientTunnelSettings settings)
```
    Used only at session startup. Do not use to change settings. Do not use for aliased destinations; use addAlias().
    Specified by:
    buildTunnels in interface TunnelManagerFacade
  - checkAndRecoverPools
```
public int checkAndRecoverPools()
```
    Emergency pool recovery: Check all registered clients have valid tunnel pools. Recreates missing pools to prevent service interruption. Called periodically by BuildExecutor.
    Returns:
    number of pools recovered
  - disableTunnelTesting
```
public boolean disableTunnelTesting()
```
    Tunnel testing status.
    Returns:
    true if tunnel testing is disabled
  - fail
```
public void fail(Hash peer)
```
    Fail all outbound tunnels with this peer as first hop, and all inbound tunnels with this peer as the last hop, baecause we can't contact it any more. This is most likely to be triggered by an outbound tunnel.
    Specified by:
    fail in interface TunnelManagerFacade
  - forceRemoveTunnels
```
public void forceRemoveTunnels(Hash destination)
```
    Force immediate removal of a pool - used for router shutdown.
    Parameters:
    destination - the destination
  - getBuildHandlerThreadCount
```
public int getBuildHandlerThreadCount()
```
    Actual number of running BuildHandler threads. May differ from getBuildHandlerThreads() if threads were interrupted or failed to start.
    Returns:
    current build handler thread count
  - getBuildHandlerThreads
```
public static int getBuildHandlerThreads()
```
    Tuned by Tuner — min 2, max 8
    Returns:
    number of build handler threads
  - getExecutor
```
BuildExecutor getExecutor()
```
    The build executor.
    Returns:
    the build executor
  - getFreeTunnelCount
```
public int getFreeTunnelCount()
```
    Number of valid (non-failed, non-expired) inbound exploratory tunnels.
    Specified by:
    getFreeTunnelCount in interface TunnelManagerFacade
    Returns:
    number of valid (non-failed, non-expired) inbound exploratory tunnels
  - getGhostPeerManager
```
public GhostPeerManager getGhostPeerManager()
```
    The ghost peer manager for tracking unresponsive peers.
    Specified by:
    getGhostPeerManager in interface TunnelManagerFacade
    Returns:
    the ghost peer manager for tracking unresponsive peers
  - getInboundBuildQueueSize
```
public int getInboundBuildQueueSize()
```
    Size of the inbound build queue.
    Specified by:
    getInboundBuildQueueSize in interface TunnelManagerFacade
    Returns:
    size of the inbound build queue
  - getInboundClientPools
```
public Map<Hash,TunnelPool> getInboundClientPools()
```
    For TunnelRenderer in router console.
    Specified by:
    getInboundClientPools in interface TunnelManagerFacade
  - getInboundClientTunnelCount
```
public int getInboundClientTunnelCount()
```
    Number of GOOD (tested+passed, non-failed, non-expired) inbound client tunnels across all destinations.
    Specified by:
    getInboundClientTunnelCount in interface TunnelManagerFacade
    Returns:
    number of GOOD (tested+passed, non-failed, non-expired) inbound client tunnels across all destinations
  - getInboundClientTunnelCount
```
public int getInboundClientTunnelCount(Hash destination)
```
    Use to verify a tunnel pool is alive. During bootstrap (no GOOD tunnels yet), counts any valid tunnel (including UNTESTED) so the sidebar shows ok immediately after the first build. Once the pool has established GOOD tunnels, enforces a strict GOOD-only count.
    Specified by:
    getInboundClientTunnelCount in interface TunnelManagerFacade
    Returns:
    number of inbound client tunnels for the given destination
  - getInboundExploratoryPool
```
public TunnelPool getInboundExploratoryPool()
```
    For TunnelRenderer in router console
    Specified by:
    getInboundExploratoryPool in interface TunnelManagerFacade
    Returns:
    non-null
  - getInboundPool
```
public TunnelPool getInboundPool(Hash client)
```
    Description copied from interface: TunnelManagerFacade
    Inbound tunnel pool for the given client, or null if none.
    Specified by:
    getInboundPool in interface TunnelManagerFacade
    Returns:
    pool or null
  - getInboundSettings
```
public TunnelPoolSettings getInboundSettings()
```
    The inbound exploratory tunnel pool settings.
    Specified by:
    getInboundSettings in interface TunnelManagerFacade
    Returns:
    the inbound settings
  - getInboundSettings
```
public TunnelPoolSettings getInboundSettings(Hash client)
```
    Get settings for a client's inbound tunnel pool.
    Specified by:
    getInboundSettings in interface TunnelManagerFacade
    Parameters:
    client - destination hash
    Returns:
    settings or null if not found
  - getLastParticipatingExpiration
```
public long getLastParticipatingExpiration()
```
    The expiration time of the last participating tunnel.
    Specified by:
    getLastParticipatingExpiration in interface TunnelManagerFacade
  - getOutboundClientPools
```
public Map<Hash,TunnelPool> getOutboundClientPools()
```
    For TunnelRenderer in router console.
    Specified by:
    getOutboundClientPools in interface TunnelManagerFacade
  - getOutboundClientTunnelCount
```
public int getOutboundClientTunnelCount()
```
    Number of GOOD (tested+passed, non-failed, non-expired) outbound client tunnels across all destinations.
    Specified by:
    getOutboundClientTunnelCount in interface TunnelManagerFacade
    Returns:
    number of GOOD (tested+passed, non-failed, non-expired) outbound client tunnels across all destinations
  - getOutboundClientTunnelCount
```
public int getOutboundClientTunnelCount(Hash destination)
```
    Use to verify a tunnel pool is alive. During bootstrap (no GOOD tunnels yet), counts any valid tunnel (including UNTESTED) so the sidebar shows ok immediately after the first build. Once the pool has established GOOD tunnels, enforces a strict GOOD-only count — UNTESTED tunnels alone don't keep the indicator green.
    Specified by:
    getOutboundClientTunnelCount in interface TunnelManagerFacade
    Returns:
    number of outbound client tunnels for the given destination
  - getOutboundExploratoryPool
```
public TunnelPool getOutboundExploratoryPool()
```
    For TunnelRenderer in router console
    Specified by:
    getOutboundExploratoryPool in interface TunnelManagerFacade
    Returns:
    non-null
  - getOutboundPool
```
public TunnelPool getOutboundPool(Hash client)
```
    Description copied from interface: TunnelManagerFacade
    Outbound tunnel pool for the given client, or null if none.
    Specified by:
    getOutboundPool in interface TunnelManagerFacade
    Returns:
    pool or null
  - getOutboundSettings
```
public TunnelPoolSettings getOutboundSettings()
```
    The outbound exploratory tunnel pool settings.
    Specified by:
    getOutboundSettings in interface TunnelManagerFacade
    Returns:
    the outbound settings
  - getOutboundSettings
```
public TunnelPoolSettings getOutboundSettings(Hash client)
```
    Get settings for a client's outbound tunnel pool.
    Specified by:
    getOutboundSettings in interface TunnelManagerFacade
    Parameters:
    client - destination hash
    Returns:
    settings or null if not found
  - getOutboundTunnelCount
```
public int getOutboundTunnelCount()
```
    Number of valid (non-failed, non-expired) outbound exploratory tunnels.
    Specified by:
    getOutboundTunnelCount in interface TunnelManagerFacade
    Returns:
    number of valid (non-failed, non-expired) outbound exploratory tunnels
  - getParticipatingCount
```
public int getParticipatingCount()
```
    The number of tunnels we're participating in as a gateway or endpoint.
    Specified by:
    getParticipatingCount in interface TunnelManagerFacade
  - getShareRatio
```
public double getShareRatio()
```
    Get the share ratio of participating tunnels.
    Specified by:
    getShareRatio in interface TunnelManagerFacade
    Returns:
    (number of part. tunnels) / (estimated total number of hops in our expl.+client tunnels) We just use length setting, not variance, for speed
  - getUsableInboundClientTunnelCount
```
public int getUsableInboundClientTunnelCount(Hash destination)
```
    Get USABLE inbound client tunnel count for a specific destination.
    Parameters:
    destination - the client hash
    Returns:
    number of GOOD (tested+passed, non-failed, non-expired) tunnels
  - getUsableOutboundClientTunnelCount
```
public int getUsableOutboundClientTunnelCount(Hash destination)
```
    Get USABLE outbound client tunnel count for a specific destination.
    Parameters:
    destination - the client hash
    Returns:
    number of GOOD (tested+passed, non-failed, non-expired) tunnels
  - isFirewalled
```
public boolean isFirewalled()
```
    Firewall status.
    Returns:
    true if the router is firewalled
  - isShutdown
```
boolean isShutdown()
```
    Whether the manager has been shut down.
    Returns:
    true if the manager has been shut down
  - isValidTunnel
```
public boolean isValidTunnel(Hash client,
                             TunnelInfo tunnel)
```
    Check if a tunnel is valid and belongs to the client's pool.
    Specified by:
    isValidTunnel in interface TunnelManagerFacade
    Parameters:
    client - destination hash
    tunnel - tunnel to validate
    Returns:
    true if the tunnel is valid and belongs to the client's pool
  - listPools
```
public void listPools(List<TunnelPool> out)
```
    List of TunnelPool instances currently in play.
    Specified by:
    listPools in interface TunnelManagerFacade
  - logPoolHealth
```
public void logPoolHealth()
```
    Log pool health summary for monitoring.
  - pruneAllPools
```
public void pruneAllPools()
```
    Prune excess tunnels from all pools to stay within budget. Called periodically from RemoveSlowTunnelsJob to ensure we don't exceed the configured tunnel quantity for any pool.
  - removeAlias
```
public void removeAlias(Destination dest)
```
    Remove a destination for the same tunnels as another.
    Specified by:
    removeAlias in interface TunnelManagerFacade
  - removeFromExpiration
```
void removeFromExpiration(PooledTunnelCreatorConfig cfg)
```
    Remove a tunnel from the expiration queue to prevent memory leak
  - removeTunnels
```
public void removeTunnels(Destination dest)
```
    Must be called AFTER deregistration by the client manager.
    Specified by:
    removeTunnels in interface TunnelManagerFacade
  - removeTunnels
```
public void removeTunnels(Hash destination)
```
    This will be called twice, once by the inbound and once by the outbound pool. Synched with buildTunnels() above. Must be called AFTER deregistration by the client manager. Uses delayed cleanup to allow tunnels to continue operating until they naturally expire. Prevents pool collapse when client disconnects.
    Parameters:
    destination - the destination
  - renderStatusHTML
```
public void renderStatusHTML(Writer out)
                      throws IOException
```
    Required by Service; status rendering moved to routerconsole.
    Specified by:
    renderStatusHTML in interface Service
    Parameters:
    out - the writer to write to
    Throws:
    IOException - if an error occurs writing
  - replaceSlowTunnels
```
public boolean replaceSlowTunnels()
```
    Find and remove tunnels exceeding the latency threshold. Does not blame peers for the removal. Removes all such tunnels per pool if pool has more tunnels than configured quantity, but won't go below the configured quantity. Threshold is either the configured property (in ms), or Math.max(avg latency, DEFAULT_MIN_SLOW_THRESHOLD), whichever is larger.
    Returns:
    true if any tunnels were removed
  - restart
```
public void restart()
```
    Restart all tunnel handlers and rebuild all tunnels
    Specified by:
    restart in interface Service
  - selectAnyInboundTunnel
```
public TunnelInfo selectAnyInboundTunnel()
```
    Pick a random inbound tunnel from any pool — client pools first, then exploratory. Used by BuildRequestor for cross-pool build replies when the requesting pool's own tunnels are unavailable.
    Specified by:
    selectAnyInboundTunnel in interface TunnelManagerFacade
    Returns:
    null if none
  - selectAnyOutboundTunnel
```
public TunnelInfo selectAnyOutboundTunnel()
```
    Pick a random outbound tunnel from any pool — client pools first, then exploratory. Used by BuildRequestor for cross-pool build replies when the requesting pool's own tunnels are unavailable. Client tunnels provide a lower-latency reply path than exploratory.
    Specified by:
    selectAnyOutboundTunnel in interface TunnelManagerFacade
    Returns:
    null if none
  - selectInboundExploratoryTunnel
```
public TunnelInfo selectInboundExploratoryTunnel(Hash closestTo)
```
    Pick the inbound exploratory tunnel with the gateway closest to the given hash. By using this instead of the random selectTunnel(), we force some locality in OBEP-IBGW connections to minimize those connections network-wide.
    Specified by:
    selectInboundExploratoryTunnel in interface TunnelManagerFacade
    Parameters:
    closestTo - non-null
    Returns:
    null if none
  - selectInboundTunnel
```
public TunnelInfo selectInboundTunnel()
```
    Pick a random inbound exploratory tunnel. Warning - selectInboundExploratoryTunnel(Hash) is preferred.
    Specified by:
    selectInboundTunnel in interface TunnelManagerFacade
    Returns:
    null if none
  - selectInboundTunnel
```
public TunnelInfo selectInboundTunnel(Hash destination)
```
    Pick a random inbound tunnel from the given destination's pool. Warning - selectInboundTunnel(Hash, Hash) is preferred.
    Specified by:
    selectInboundTunnel in interface TunnelManagerFacade
    Parameters:
    destination - if null, returns inbound exploratory tunnel
    Returns:
    null if none
  - selectInboundTunnel
```
public TunnelInfo selectInboundTunnel(Hash destination,
                                      Hash closestTo)
```
    Pick the inbound tunnel with the gateway closest to the given hash from the given destination's pool. By using this instead of the random selectTunnel(), we force some locality in OBEP-IBGW connections to minimize those connections network-wide.
    Specified by:
    selectInboundTunnel in interface TunnelManagerFacade
    Parameters:
    destination - if null, returns inbound exploratory tunnel
    closestTo - non-null
    Returns:
    null if none
  - selectOutboundExploratoryTunnel
```
public TunnelInfo selectOutboundExploratoryTunnel(Hash closestTo)
```
    Pick the outbound exploratory tunnel with the endpoint closest to the given hash. By using this instead of the random selectTunnel(), we force some locality in OBEP-IBGW connections to minimize those connections network-wide.
    Specified by:
    selectOutboundExploratoryTunnel in interface TunnelManagerFacade
    Parameters:
    closestTo - non-null
    Returns:
    null if none
  - selectOutboundTunnel
```
public TunnelInfo selectOutboundTunnel()
```
    Pick a random outbound exploratory tunnel. Warning - selectOutboundExploratoryTunnel(Hash) is preferred.
    Specified by:
    selectOutboundTunnel in interface TunnelManagerFacade
    Returns:
    null if none
  - selectOutboundTunnel
```
public TunnelInfo selectOutboundTunnel(Hash destination)
```
    Pick a random outbound tunnel from the given destination's pool. Warning - selectOutboundTunnel(Hash, Hash) is preferred.
    Specified by:
    selectOutboundTunnel in interface TunnelManagerFacade
    Parameters:
    destination - if null, returns outbound exploratory tunnel
    Returns:
    null if none
  - selectOutboundTunnel
```
public TunnelInfo selectOutboundTunnel(Hash destination,
                                       Hash closestTo)
```
    Pick the outbound tunnel with the endpoint closest to the given hash from the given destination's pool. By using this instead of the random selectTunnel(), we force some locality in OBEP-IBGW connections to minimize those connections network-wide.
    Specified by:
    selectOutboundTunnel in interface TunnelManagerFacade
    Parameters:
    destination - if null, returns outbound exploratory tunnel
    closestTo - non-null
    Returns:
    null if none
  - selectPeersInTooManyTunnels
```
public Set<Hash> selectPeersInTooManyTunnels()
```
    For reliability reasons, don't allow a peer in more than x% of client and exploratory tunnels. This also will prevent a single huge-capacity (or malicious) peer from taking all the tunnels in the network (although it would be nice to limit the % of total network tunnels to 10% or so, but that appears to be too low to set as a default here... much lower than 33% will push client tunnels out of the fast tier into high cap or beyond...) Possible improvement - restrict based on count per IP, or IP block, to slightly increase costs of collusion
    Specified by:
    selectPeersInTooManyTunnels in interface TunnelManagerFacade
    Returns:
    Set of peers that should not be allowed in another tunnel
  - setBuildHandlerThreads
```
public static void setBuildHandlerThreads(int val)
```
    The number of build handler threads.
    Parameters:
    val - thread count (clamped 2-8)
  - setInboundSettings
```
public void setInboundSettings(Hash client,
                               TunnelPoolSettings settings)
```
    Set settings for a client's inbound tunnel pool.
    Specified by:
    setInboundSettings in interface TunnelManagerFacade
    Parameters:
    client - destination hash
    settings - the inbound settings
  - setInboundSettings
```
public void setInboundSettings(TunnelPoolSettings settings)
```
    The inbound exploratory tunnel pool settings.
    Specified by:
    setInboundSettings in interface TunnelManagerFacade
    Parameters:
    settings - the inbound settings
  - setOutboundSettings
```
public void setOutboundSettings(Hash client,
                                TunnelPoolSettings settings)
```
    Set settings for a client's outbound tunnel pool.
    Specified by:
    setOutboundSettings in interface TunnelManagerFacade
    Parameters:
    client - destination hash
    settings - the outbound settings
  - setOutboundSettings
```
public void setOutboundSettings(TunnelPoolSettings settings)
```
    The outbound exploratory tunnel pool settings.
    Specified by:
    setOutboundSettings in interface TunnelManagerFacade
    Parameters:
    settings - the outbound settings
  - shutdown
```
public void shutdown()
```
    Cannot be restarted
    Specified by:
    shutdown in interface Service
  - startup
```
public void startup()
```
    Start the tunnel pool manager and build initial tunnels
    Specified by:
    startup in interface Service
  - tunnelFailed
```
void tunnelFailed()
```
    Poke the build executor to build more tunnels.

Class TunnelPoolManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PROP_OUTBOUND_STARTUP_RETRIES

Constructor Detail

TunnelPoolManager

Method Detail

addAlias

adjustBuildHandlerThreads

buildComplete

buildTunnels

checkAndRecoverPools

disableTunnelTesting

fail

forceRemoveTunnels

getBuildHandlerThreadCount

getBuildHandlerThreads

getExecutor

getFreeTunnelCount

getGhostPeerManager

getInboundBuildQueueSize

getInboundClientPools

getInboundClientTunnelCount

getInboundClientTunnelCount

getInboundExploratoryPool

getInboundPool

getInboundSettings

getInboundSettings

getLastParticipatingExpiration

getOutboundClientPools

getOutboundClientTunnelCount

getOutboundClientTunnelCount

getOutboundExploratoryPool

getOutboundPool

getOutboundSettings

getOutboundSettings

getOutboundTunnelCount

getParticipatingCount

getShareRatio

getUsableInboundClientTunnelCount

getUsableOutboundClientTunnelCount

isFirewalled

isShutdown

isValidTunnel

listPools

logPoolHealth

pruneAllPools

removeAlias

removeFromExpiration

removeTunnels

removeTunnels

renderStatusHTML

replaceSlowTunnels

restart

selectAnyInboundTunnel

selectAnyOutboundTunnel

selectInboundExploratoryTunnel

selectInboundTunnel

selectInboundTunnel

selectInboundTunnel

selectOutboundExploratoryTunnel

selectOutboundTunnel

selectOutboundTunnel

selectOutboundTunnel

selectPeersInTooManyTunnels

setBuildHandlerThreads

setInboundSettings

setInboundSettings

setOutboundSettings

setOutboundSettings

shutdown

startup

tunnelFailed