TestJob (Javadocs [I2P+ 2.13.0+] - API Version 0.9.70+)

java.lang.Object
- net.i2p.router.JobImpl
- - net.i2p.router.tunnel.pool.TestJob

All Implemented Interfaces:
Job
```
public class TestJob
extends JobImpl
```
Repeatedly tests a single tunnel for its lifetime to ensure it remains functional. Sends a garlic-encrypted DeliveryStatusMessage through the tunnel and validates the reply. Now includes adaptive backoff, avoids over-penalizing peers on transient failures, and limits the number of concurrent tunnel tests to avoid overwhelming the router.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`maxQueuedTests`
`(package private) static long`	`TRAFFIC_PROOF_MS` How recently a tunnel must have carried real (non-test) traffic for the pool to clear its FAILING flag and mark it GOOD.

Fields inherited from class net.i2p.router.JobImpl
_id

Constructor Summary
Constructors
Constructor and Description
TestJob(RouterContext ctx, PooledTunnelCreatorConfig cfg, TunnelPool pool)
TestJob.

Constructors
Constructor and Description
`TestJob(RouterContext ctx, PooledTunnelCreatorConfig cfg, TunnelPool pool)` TestJob.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) static int`	`computeMaxTestJobs(int maxQueuedTests, int activeRunners, int numPools)` Test-job capacity derived from the queue state: at least 12 jobs (or 3 per pool), scaled up by active runners, but never above the hard queued limit.
`(package private) static int`	`computeTestPeriod(double successTimeAvgMs, double sendProcessingMs, int outLen, int replyLen, int minPeriod, int maxPeriod)` Compute the tunnel test failure window: how long a test may take before the tunnel is declared failed.
`void`	`dropped()` Called when the job is dropped due to router overload.
`static int`	`getCurrentTestJobCount()` Current number of queued + active test jobs for capacity planning.
`static int`	`getHardLimit(RouterContext ctx)` Hard limit for total TestJob instances (queued + active).
`static int`	`getMaxTestJobs()` Maximum number of queued test jobs allowed before deferring.
`String`	`getName()` The name of this job.
`(package private) static boolean`	`hasValidTunnelIds(PooledTunnelCreatorConfig cfg)` Whether the tunnel config has non-zero tunnel IDs at hop 0, i.e.
`(package private) static boolean`	`isEarlyExpiry(PooledTunnelCreatorConfig cfg, long now)` Whether the tunnel expires so soon it is not worth testing — it has already been pruned for early expiry.
`(package private) static boolean`	`isPingTunnel(PooledTunnelCreatorConfig cfg)` Whether the tunnel belongs to a ping pool, which is short-lived and does not need testing.
`(package private) static boolean`	`isPoolCritical(int activeCount, int target)` Whether a pool is critically low on tunnels: no active tunnels at all, or at most 2 active against a larger target.
`(package private) static boolean`	`isTestQueueOverloaded(boolean critical, int readyCount, int activeRunners, long maxLag, long expeditedLagLimit, int currentTestJobs, int expeditedJobLimit)` Whether the job queue is too backed up to accept another test job.
`boolean`	`isValid()` Check if this TestJob instance is valid and should be queued.
`(package private) static boolean`	`isZeroActivePool(TunnelPool pool)` Whether a client pool has zero active tunnels, i.e.
`void`	`runJob()` Run the tunnel test and report success or failure.
`static boolean`	`shouldSchedule(RouterContext ctx, PooledTunnelCreatorConfig cfg)` Static method to check if a TestJob should be created and scheduled.
`void`	`testSuccessful(int ms)` Called when the tunnel test completes successfully.

Methods inherited from class net.i2p.router.JobImpl
getContext, getJobId, getMadeReadyOn, getTiming, madeReady, requeue, toString

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

- Field Detail
  - maxQueuedTests
```
public static volatile int maxQueuedTests
```
  - TRAFFIC_PROOF_MS
```
static final long TRAFFIC_PROOF_MS
```
    How recently a tunnel must have carried real (non-test) traffic for the pool to clear its FAILING flag and mark it GOOD. Real traffic is proof the tunnel works — a tunnel receiving or sending data has not failed. Only FAILING (not FAILED) tunnels are cleared, so a genuinely dead tunnel still accumulates failures during quiet periods and is removed.
    See Also:
    Constant Field Values
- Constructor Detail
  - TestJob
```
public TestJob(RouterContext ctx,
               PooledTunnelCreatorConfig cfg,
               TunnelPool pool)
```
    TestJob.
- Method Detail
  - computeMaxTestJobs
```
static int computeMaxTestJobs(int maxQueuedTests,
                              int activeRunners,
                              int numPools)
```
    Test-job capacity derived from the queue state: at least 12 jobs (or 3 per pool), scaled up by active runners, but never above the hard queued limit.
    Parameters:
    maxQueuedTests - hard cap from maxQueuedTests
    activeRunners - current job-queue runner count
    numPools - number of tunnel pools
    Returns:
    the capacity in test jobs
  - computeTestPeriod
```
static int computeTestPeriod(double successTimeAvgMs,
                             double sendProcessingMs,
                             int outLen,
                             int replyLen,
                             int minPeriod,
                             int maxPeriod)
```
    Compute the tunnel test failure window: how long a test may take before the tunnel is declared failed. When a recent successful-test measurement exists, the window is 2x that average — a test answered in ~2.3s is almost certainly dead if it needs more than ~4.6s. Before any measurements exist, fall back to mainline's formula (3x transport send processing + 2.5s per hop), which assumes a slow network so early tests don't false-fail. Always clamped to [minPeriod, maxPeriod], with min <= max enforced by construction so a crossed config can't widen the window unintentionally. The pending-message expiration (and thus the reply selector) is tied to the period itself, so a short window never strands a selector.
    Parameters:
    successTimeAvgMs - average tunnel.testSuccessTime over the last minute, NaN if never measured
    sendProcessingMs - average transport.sendProcessingTime, NaN if unknown
    outLen - outbound tunnel length, <= 0 if no outbound tunnel
    replyLen - reply tunnel length, <= 0 if no reply tunnel
    minPeriod - minTestPeriod config
    maxPeriod - maxTestPeriod config
    Returns:
    the failure window in ms
  - dropped
```
public void dropped()
```
    Called when the job is dropped due to router overload. Ensure we clean up the total job counter when dropped.
    Specified by:
    dropped in interface Job
    Overrides:
    dropped in class JobImpl
  - getCurrentTestJobCount
```
public static int getCurrentTestJobCount()
```
    Current number of queued + active test jobs for capacity planning.
    Returns:
    the current test job count
  - getHardLimit
```
public static int getHardLimit(RouterContext ctx)
```
    Hard limit for total TestJob instances (queued + active). Above this threshold, no new tests are scheduled until count decreases. Prevents ever-increasing backlogs that could cause job lag. Tunable via i2p.tunnel.testJob.hardLimit (default: 512 fast / 384 slow)
    Returns:
    the hard limit
  - getMaxTestJobs
```
public static int getMaxTestJobs()
```
    Maximum number of queued test jobs allowed before deferring.
    Returns:
    the max test jobs
  - getName
```
public String getName()
```
    The name of this job.
    Returns:
    the name
  - hasValidTunnelIds
```
static boolean hasValidTunnelIds(PooledTunnelCreatorConfig cfg)
```
    Whether the tunnel config has non-zero tunnel IDs at hop 0, i.e. the tunnel is fully built and can carry a test message. Outbound tunnels only have a send tunnel ID at hop 0 (the gateway), inbound tunnels only a receive tunnel ID. Any failure reading the IDs (not yet built) is treated as not ready; the caller logs the debug detail.
    Parameters:
    cfg - the tunnel config, never null
    Returns:
    true if the applicable hop-0 ID is non-zero
  - isEarlyExpiry
```
static boolean isEarlyExpiry(PooledTunnelCreatorConfig cfg,
                             long now)
```
    Whether the tunnel expires so soon it is not worth testing — it has already been pruned for early expiry.
    Parameters:
    cfg - the tunnel config, never null
    now - current time in ms
    Returns:
    true if the tunnel expires within the early-expiry window
  - isPingTunnel
```
static boolean isPingTunnel(PooledTunnelCreatorConfig cfg)
```
    Whether the tunnel belongs to a ping pool, which is short-lived and does not need testing. Ping pools are named "I2Ping" or "Ping*[n]".
    Parameters:
    cfg - the tunnel config, never null
    Returns:
    true if the pool nickname identifies a ping pool
  - isPoolCritical
```
static boolean isPoolCritical(int activeCount,
                              int target)
```
    Whether a pool is critically low on tunnels: no active tunnels at all, or at most 2 active against a larger target. Critical pools get test priority so replacement tunnels are validated before the pool drains. NOTE: BuildExecutor.calculatePairedBuilds() carries an identical inline predicate — dedupe candidate if either side changes again.
    Parameters:
    activeCount - current active tunnel count
    target - configured total quantity
    Returns:
    true if the pool is critical
  - isTestQueueOverloaded
```
static boolean isTestQueueOverloaded(boolean critical,
                                     int readyCount,
                                     int activeRunners,
                                     long maxLag,
                                     long expeditedLagLimit,
                                     int currentTestJobs,
                                     int expeditedJobLimit)
```
    Whether the job queue is too backed up to accept another test job. Non-critical pools are deferred when the ready queue outruns the runners, the max lag exceeds the (possibly expedited) limit, or the current test job count meets the (possibly expedited) job limit. Critical pools always get through.
    Parameters:
    critical - whether the pool is critical (bypasses the gate)
    readyCount - jobs waiting in the queue
    activeRunners - jobs being processed
    maxLag - measured queue lag in ms
    expeditedLagLimit - lag threshold (doubled for expedited)
    currentTestJobs - running test job count
    expeditedJobLimit - job threshold (1.5x for expedited)
    Returns:
    true if scheduling should be deferred
  - isValid
```
public boolean isValid()
```
    Check if this TestJob instance is valid and should be queued.
    Returns:
    true if valid, false if it should not be queued
  - isZeroActivePool
```
static boolean isZeroActivePool(TunnelPool pool)
```
    Whether a client pool has zero active tunnels, i.e. it is collapsed and its test jobs must bypass the queue cap and per-pool budget. Exploratory pools are never critical — they have no LeaseSet to feed.
    Parameters:
    pool - the pool, may be null (then not critical)
    Returns:
    true if a non-exploratory pool with no active tunnels
  - runJob
```
public void runJob()
```
    Run the tunnel test and report success or failure.
  - shouldSchedule
```
public static boolean shouldSchedule(RouterContext ctx,
                                     PooledTunnelCreatorConfig cfg)
```
    Static method to check if a TestJob should be created and scheduled. This prevents creating invalid job objects that would have timing issues.
    Parameters:
    ctx - the router context
    cfg - the tunnel config
    Returns:
    true if the job should be created and scheduled, false otherwise
  - testSuccessful
```
public void testSuccessful(int ms)
```
    Called when the tunnel test completes successfully. Updates statistics and schedules the next test.
    Parameters:
    ms - time in milliseconds the test took to succeed

Class TestJob

Field Summary

Fields inherited from class net.i2p.router.JobImpl

Constructor Summary

Method Summary

Methods inherited from class net.i2p.router.JobImpl

Methods inherited from class java.lang.Object

Field Detail

maxQueuedTests

TRAFFIC_PROOF_MS

Constructor Detail

TestJob

Method Detail

computeMaxTestJobs

computeTestPeriod

dropped

getCurrentTestJobCount

getHardLimit

getMaxTestJobs

getName

hasValidTunnelIds

isEarlyExpiry

isPingTunnel

isPoolCritical

isTestQueueOverloaded

isValid

isZeroActivePool

runJob

shouldSchedule

testSuccessful