BuildExecutor (Javadocs [I2P+ 2.13.0+]

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

All Implemented Interfaces:
Runnable
```
public class BuildExecutor
extends Object
implements Runnable
```
Single threaded controller of the tunnel creation process, spanning all tunnel pools. Essentially, this loops across the pools, sees which want to build tunnels, and fires off the necessary activities if the load allows. If nothing wants to build any tunnels, it waits for a short period before looping again (or until it is told that something changed, such as a tunnel failed, new client started up, or tunnel creation was aborted). Note that 10 minute tunnel expiration is hardcoded in here. As of 0.8.11, inbound request handling is done in a separate thread.

Nested Class Summary
Nested Classes
Modifier and Type Class and Description
(package private) static class BuildExecutor.Result
Build result enumeration.

Nested Classes
Modifier and Type	Class and Description
`(package private) static class`	`BuildExecutor.Result` Build result enumeration.

Constructor Summary
Constructors
Constructor and Description
BuildExecutor(RouterContext ctx, TunnelPoolManager mgr, GhostPeerManager ghostMgr)
Create a new BuildExecutor.

Constructors
Constructor and Description
`BuildExecutor(RouterContext ctx, TunnelPoolManager mgr, GhostPeerManager ghostMgr)` Create a new BuildExecutor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`buildComplete(PooledTunnelCreatorConfig cfg, BuildExecutor.Result result)` Handle a completed tunnel build.
`void`	`buildComplete(PooledTunnelCreatorConfig cfg, BuildExecutor.Result result, String detail)` Handle a completed tunnel build with additional detail.
`(package private) void`	`buildTunnel(PooledTunnelCreatorConfig cfg)` Build a tunnel with the given configuration.
`boolean`	`fullStats()` Check if full statistics are enabled.
`static long`	`getGoodDeficitThrottle(RouterContext ctx)` Get the GOOD deficit throttle interval from config or default (30s).
`static int`	`getMaxConcurrentBuilds()` Get the maximum number of concurrent builds allowed.
`static long`	`getPoolBackoffMs()` Get the pool backoff time in milliseconds.
`static int`	`getPoolFailureThreshold()` Get the pool failure threshold.
`(package private) static int`	`getTunnelLifetime(RouterContext ctx)` Get the tunnel lifetime from config.
`(package private) static int`	`getTunnelTargetBuffer(RouterContext ctx)` Get the target build buffer from config or default (0).
`(package private) boolean`	`isPoolInBackoff(TunnelPool pool)` Check if a pool is in backoff due to consecutive build failures.
`boolean`	`isRunning()` Check if the executor is currently running.
`(package private) PooledTunnelCreatorConfig`	`removeFromBuilding(long id)` This returns the PTCC up to a minute after it 'expired', thus allowing us to still use a tunnel if it was accepted, and to update peer stats.
`(package private) void`	`removePoolState(TunnelPool pool)` Remove failure state for a pool that is being removed.
`void`	`repoll()` Signal the executor to repoll for tunnel building opportunities.
`void`	`restart()` Restart the build executor, clearing recent build state.
`void`	`run()` Starts the tunnel building process in a loop and takes care of error handling.
`static void`	`setMaxConcurrentBuilds(int val)` Set the maximum number of concurrent builds allowed.
`static void`	`setPoolBackoffMs(long val)` Set the pool backoff time in milliseconds.
`static void`	`setPoolFailureThreshold(int val)` Set the pool failure threshold.
`void`	`shutdown()` Cannot be restarted.
`boolean`	`wasRecentlyBuilding(long replyId)` Check if a tunnel build was recently attempted.

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

- Constructor Detail
  - BuildExecutor
```
public BuildExecutor(RouterContext ctx,
                     TunnelPoolManager mgr,
                     GhostPeerManager ghostMgr)
```
    Create a new BuildExecutor.
    Parameters:
    ctx - the router context
    mgr - the tunnel pool manager
    ghostMgr - the ghost peer manager for tracking timeouts
- Method Detail
  - buildComplete
```
public void buildComplete(PooledTunnelCreatorConfig cfg,
                          BuildExecutor.Result result)
```
    Handle a completed tunnel build.
    Parameters:
    cfg - the tunnel configuration that completed
    result - the build result (success, failure, etc.)
  - buildComplete
```
public void buildComplete(PooledTunnelCreatorConfig cfg,
                          BuildExecutor.Result result,
                          String detail)
```
    Handle a completed tunnel build with additional detail.
    Parameters:
    cfg - the tunnel configuration that completed
    result - the build result (success, failure, etc.)
    detail - additional detail on the result
  - buildTunnel
```
void buildTunnel(PooledTunnelCreatorConfig cfg)
```
    Build a tunnel with the given configuration.
    Parameters:
    cfg - the tunnel configuration to build
  - fullStats
```
public boolean fullStats()
```
    Check if full statistics are enabled.
    Returns:
    true if full statistics are enabled
  - getGoodDeficitThrottle
```
public static long getGoodDeficitThrottle(RouterContext ctx)
```
    Get the GOOD deficit throttle interval from config or default (30s). Minimum time between GOOD-tunnel deficit rebuilds for non-critical pools. Tunable via i2p.tunnel.goodDeficitThrottle (default: 30000).
    Parameters:
    ctx - the router context
    Returns:
    the throttle interval in milliseconds
  - getMaxConcurrentBuilds
```
public static int getMaxConcurrentBuilds()
```
    Get the maximum number of concurrent builds allowed.
    Returns:
    maximum concurrent builds
  - getPoolBackoffMs
```
public static long getPoolBackoffMs()
```
    Get the pool backoff time in milliseconds.
    Returns:
    the backoff in ms
  - getPoolFailureThreshold
```
public static int getPoolFailureThreshold()
```
    Get the pool failure threshold.
    Returns:
    the threshold
  - getTunnelLifetime
```
static int getTunnelLifetime(RouterContext ctx)
```
    Get the tunnel lifetime from config. Delegates to TunnelPool.
    Parameters:
    ctx - the router context
    Returns:
    the tunnel lifetime in milliseconds
  - getTunnelTargetBuffer
```
static int getTunnelTargetBuffer(RouterContext ctx)
```
    Get the target build buffer from config or default (0). Extra tunnels to maintain beyond the configured quantity. Tunable via i2p.tunnel.targetBuffer (default: 0).
    Parameters:
    ctx - the router context
    Returns:
    the target buffer count
  - isPoolInBackoff
```
boolean isPoolInBackoff(TunnelPool pool)
```
    Check if a pool is in backoff due to consecutive build failures. Uses a 12s backoff to prevent build storms while allowing recovery before expiring tunnels deplete the pool. On backoff expiry, resets the failure counter so the pool gets a fresh window of attempts. During collapse (0 usable tunnels), backoff is shortened to 4s to allow faster recovery while still preventing build storms.
    Parameters:
    pool - the tunnel pool to check
    Returns:
    true if the pool is in backoff
  - isRunning
```
public boolean isRunning()
```
    Check if the executor is currently running.
    Returns:
    true if running, false otherwise
  - removeFromBuilding
```
PooledTunnelCreatorConfig removeFromBuilding(long id)
```
    This returns the PTCC up to a minute after it 'expired', thus allowing us to still use a tunnel if it was accepted, and to update peer stats. This means that manager.buildComplete() could be called more than once, and a build can be failed or successful after it was timed out, which will affect the stats and profiles. But that's ok. A peer that rejects slowly gets penalized twice, for example.
    Parameters:
    id - the build message ID
    Returns:
    ptcc or null
  - removePoolState
```
void removePoolState(TunnelPool pool)
```
    Remove failure state for a pool that is being removed. Prevents unbounded growth of _poolFailureState and _lastRebuildTime across pool lifecycles.
    Parameters:
    pool - the pool to remove state for
  - repoll
```
public void repoll()
```
    Signal the executor to repoll for tunnel building opportunities.
  - restart
```
public void restart()
```
    Restart the build executor, clearing recent build state.
  - run
```
public void run()
```
    Starts the tunnel building process in a loop and takes care of error handling. Catches a specific fatal error related to Java versioning and ensures the running state is properly reset on exit.
    Specified by:
    run in interface Runnable
  - setMaxConcurrentBuilds
```
public static void setMaxConcurrentBuilds(int val)
```
    Set the maximum number of concurrent builds allowed.
    Parameters:
    val - the maximum concurrent builds
  - setPoolBackoffMs
```
public static void setPoolBackoffMs(long val)
```
    Set the pool backoff time in milliseconds.
    Parameters:
    val - the backoff in ms (1000-60000)
  - setPoolFailureThreshold
```
public static void setPoolFailureThreshold(int val)
```
    Set the pool failure threshold.
    Parameters:
    val - the threshold value (1-20)
  - shutdown
```
public void shutdown()
```
    Cannot be restarted.
  - wasRecentlyBuilding
```
public boolean wasRecentlyBuilding(long replyId)
```
    Check if a tunnel build was recently attempted.
    Parameters:
    replyId - the reply message ID to check
    Returns:
    true if the build was recently attempted, false otherwise

Class BuildExecutor

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BuildExecutor

Method Detail

buildComplete

buildComplete

buildTunnel

fullStats

getGoodDeficitThrottle

getMaxConcurrentBuilds

getPoolBackoffMs

getPoolFailureThreshold

getTunnelLifetime

getTunnelTargetBuffer

isPoolInBackoff

isRunning

removeFromBuilding

removePoolState

repoll

restart

run

setMaxConcurrentBuilds

setPoolBackoffMs

setPoolFailureThreshold

shutdown

wasRecentlyBuilding