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
P r o p o u t b o u n d s t a r t u p r e t r i e s

Fields
Modifier and Type	Field and Description
`(package private) static String`	`PROP_OUTBOUND_STARTUP_RETRIES` P r o p o u t b o u n d s t a r t u p r e t r i e s

Constructor Summary
Constructors
Constructor and Description
TunnelPoolManager(RouterContext ctx)

Constructors
Constructor and Description
`TunnelPoolManager(RouterContext ctx)`

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 1, max 8
`(package private) BuildExecutor`	`getExecutor()`
`int`	`getFreeTunnelCount()` how many free inbound tunnels do we have available?
`GhostPeerManager`	`getGhostPeerManager()` Get the ghost peer manager for tracking peers with consistent tunnel build timeouts.
`int`	`getInboundBuildQueueSize()` count how many inbound tunnel requests we have received but not yet processed
`Map<Hash,TunnelPool>`	`getInboundClientPools()` for TunnelRenderer in router console
`int`	`getInboundClientTunnelCount()` how many free inbound client tunnels do we have available?
`int`	`getInboundClientTunnelCount(Hash destination)` Use to verify a tunnel pool is alive.
`TunnelPool`	`getInboundExploratoryPool()` For TunnelRenderer in router console
`TunnelPool`	`getInboundPool(Hash client)`
`TunnelPoolSettings`	`getInboundSettings()` Get the inbound exploratory tunnel pool settings.
`TunnelPoolSettings`	`getInboundSettings(Hash client)` Get settings for a client's inbound tunnel pool.
`long`	`getLastParticipatingExpiration()` Get the expiration time of the last participating tunnel.
`Map<Hash,TunnelPool>`	`getOutboundClientPools()` for TunnelRenderer in router console
`int`	`getOutboundClientTunnelCount()` how many outbound client tunnels do we have available?
`int`	`getOutboundClientTunnelCount(Hash destination)` Use to verify a tunnel pool is alive.
`TunnelPool`	`getOutboundExploratoryPool()` For TunnelRenderer in router console
`TunnelPool`	`getOutboundPool(Hash client)`
`TunnelPoolSettings`	`getOutboundSettings()` Get the outbound exploratory tunnel pool settings.
`TunnelPoolSettings`	`getOutboundSettings(Hash client)` Get settings for a client's outbound tunnel pool.
`int`	`getOutboundTunnelCount()` how many outbound tunnels do we have available?
`int`	`getParticipatingCount()` Get 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()`
`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`	`removeFromExpirationHop(HopConfig cfg)` Remove a participating tunnel from the expiration queue.
`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.
`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)` Set 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)` Set 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)` Set 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

Methods inherited from interface net.i2p.router.Service
renderStatusHTML

- Field Detail
  - PROP_OUTBOUND_STARTUP_RETRIES
```
static final String PROP_OUTBOUND_STARTUP_RETRIES
```
    P r o p o u t b o u n d s t a r t u p r e t r i e s
    See Also:
    Constant Field Values
- Constructor Detail
  - TunnelPoolManager
```
public TunnelPoolManager(RouterContext ctx)
```
    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 1, max 8
    Returns:
    number of build handler threads
  - getExecutor
```
BuildExecutor getExecutor()
```
    Returns:
    the build executor
  - getFreeTunnelCount
```
public int getFreeTunnelCount()
```
    Description copied from interface: TunnelManagerFacade
    how many free inbound tunnels do we have available?
    Specified by:
    getFreeTunnelCount in interface TunnelManagerFacade
    Returns:
    number of valid (non-failed, non-expired) inbound exploratory tunnels
  - getGhostPeerManager
```
public GhostPeerManager getGhostPeerManager()
```
    Description copied from interface: TunnelManagerFacade
    Get the ghost peer manager for tracking peers with consistent tunnel build timeouts.
    Specified by:
    getGhostPeerManager in interface TunnelManagerFacade
    Returns:
    the ghost peer manager for tracking unresponsive peers
  - getInboundBuildQueueSize
```
public int getInboundBuildQueueSize()
```
    Description copied from interface: TunnelManagerFacade
    count how many inbound tunnel requests we have received but not yet processed
    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()
```
    Description copied from interface: TunnelManagerFacade
    how many free inbound client tunnels do we have available?
    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)
```
    Specified by:
    getInboundPool in interface TunnelManagerFacade
    Returns:
    pool or null
  - getInboundSettings
```
public TunnelPoolSettings getInboundSettings()
```
    Get 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()
```
    Get 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()
```
    Description copied from interface: TunnelManagerFacade
    how many outbound client tunnels do we have available?
    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)
```
    Specified by:
    getOutboundPool in interface TunnelManagerFacade
    Returns:
    pool or null
  - getOutboundSettings
```
public TunnelPoolSettings getOutboundSettings()
```
    Get 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()
```
    Description copied from interface: TunnelManagerFacade
    how many outbound tunnels do we have available?
    Specified by:
    getOutboundTunnelCount in interface TunnelManagerFacade
    Returns:
    number of valid (non-failed, non-expired) outbound exploratory tunnels
  - getParticipatingCount
```
public int getParticipatingCount()
```
    Get 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()
```
    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
  - removeFromExpirationHop
```
public void removeFromExpirationHop(HopConfig cfg)
```
    Remove a participating tunnel from the expiration queue. Called when IdleTunnelMonitor drops idle tunnels.
    Parameters:
    cfg - the hop config to remove
  - 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
  - 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(minLatency, 1000ms), 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)
```
    Set 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
  - setInboundSettings
```
public void setInboundSettings(TunnelPoolSettings settings)
```
    Set the inbound exploratory tunnel pool settings.
    Specified by:
    setInboundSettings in interface TunnelManagerFacade
  - 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
  - setOutboundSettings
```
public void setOutboundSettings(TunnelPoolSettings settings)
```
    Set the outbound exploratory tunnel pool settings.
    Specified by:
    setOutboundSettings in interface TunnelManagerFacade
  - 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

Methods inherited from interface net.i2p.router.Service

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

removeFromExpirationHop

removeTunnels

removeTunnels

replaceSlowTunnels

restart

selectAnyInboundTunnel

selectAnyOutboundTunnel

selectInboundExploratoryTunnel

selectInboundTunnel

selectInboundTunnel

selectInboundTunnel

selectOutboundExploratoryTunnel

selectOutboundTunnel

selectOutboundTunnel

selectOutboundTunnel

selectPeersInTooManyTunnels

setBuildHandlerThreads

setInboundSettings

setInboundSettings

setOutboundSettings

setOutboundSettings

shutdown

startup

tunnelFailed