net.i2p.router.tunnel.pool

## Class AliasedTunnelPool

- java.lang.Object
- - net.i2p.router.tunnel.pool.TunnelPool
  - - net.i2p.router.tunnel.pool.AliasedTunnelPool

-     public class AliasedTunnelPool
      extends TunnelPool

  A tunnel pool with its own settings and Destination, but uses another pool for its tunnels.

- - ### Field Summary

    - ### Fields inherited from class net.i2p.router.tunnel.pool.TunnelPool

      `_alive, _context, _log`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AliasedTunnelPool(RouterContext ctx, TunnelPoolManager mgr, TunnelPoolSettings settings, TunnelPool aliasOf)` Create an aliased tunnel pool.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `addTunnel(TunnelInfo info)` Add a tunnel to the pool.
    `(package private) void` | `buildComplete(PooledTunnelCreatorConfig cfg, BuildExecutor.Result result)` Remove from the _inprogress list and call addTunnel() if result is SUCCESS.
    `(package private) boolean` | `buildFallback()` This will build a fallback tunnel only if: - Exploratory pool: 0-hop fallback allowed - Client pool with allowZeroHop=true AND configured for 0 hops: 0-hop fallback allowed - Client pool configured for 1 hop: 1-hop fallback allowed - Otherwise: build multi-hop tunnel (enforce 2-hop minimum)
    `(package private) PooledTunnelCreatorConfig` | `configureNewTunnel()` This only sets the peers and creation/expiration times in the configuration.
    `(package private) int` | `countHowManyToBuild()` Gather the data to see how many tunnels to build, and then actually compute that value (delegated to the countHowManyToBuild function below)
    `long` | `getLifetimeProcessed()` Total lifetime processed bytes for this pool.
    `TunnelInfo` | `getTunnel(TunnelId gatewayId)` Get a tunnel by its gateway tunnel ID.
    `boolean` | `isAlive()` Is this pool running AND either exploratory, or tracked by the client manager? A pool will be alive but not tracked after the client manager removes it but before all the tunnels have expired.
    `List<PooledTunnelCreatorConfig>` | `listPending()` list of tunnelInfo instances of tunnels currently being built
    `List<TunnelInfo>` | `listTunnels()` Return a list of tunnels in the pool
    `protected LeaseSet` | `locked_buildNewLeaseSet()` Build a leaseSet with the required tunnels that aren't about to expire.
    `(package private) boolean` | `needFallback()` Do we really need more fallbacks? Used to prevent a zillion of them.
    `(package private) void` | `refreshLeaseSet()` noop for outbound and exploratory
    `(package private) void` | `removeTunnel(TunnelInfo info)` Remove a tunnel from the pool.
    `(package private) TunnelInfo` | `selectTunnel()` Pull a random tunnel out of the pool.
    `(package private) TunnelInfo` | `selectTunnel(Hash closestTo)` Return the tunnel from the pool that is XOR-closest to the target.
    `(package private) void` | `shutdown()` Shut down the pool and clean up resources.
    `int` | `size()` duplicate of getTunnelCount(), let's pick one
    `(package private) void` | `startup()` Warning, this may be called more than once (without an intervening shutdown()) if the tunnel is stopped and then restarted by the client manager with the same Destination (i.e.
    `String` | `toString()`
    `(package private) void` | `tunnelFailed(TunnelInfo cfg)` Remove tunnel and blame all peers (not necessarily equally).
    `(package private) void` | `tunnelFailed(TunnelInfo cfg, Hash blamePeer)` Remove the tunnel and blame only one peer.

    - ### Methods inherited from class net.i2p.router.tunnel.pool.TunnelPool

      `buildFinished, buildStarted, canStartBuild, cleanupDuplicatePeerTunnels, getAvgBWPerTunnel, getConcurrentInboundBuilds, getConcurrentOutboundBuilds, getConsecutiveBuildTimeouts, getInProgressCount, getRateName, getSettings, getTotalQuantity, getTunnelCount, setSettings, triggerReplacementBuild`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### AliasedTunnelPool

          AliasedTunnelPool(RouterContext ctx,
                            TunnelPoolManager mgr,
                            TunnelPoolSettings settings,
                            TunnelPool aliasOf)

      Create an aliased tunnel pool.
      Parameters:
        `ctx` - the router context
        `mgr` - the tunnel pool manager
        `settings` - the pool settings
        `aliasOf` - the pool to use for tunnel selection

  - ### Method Detail

    - #### addTunnel

          protected void addTunnel(TunnelInfo info)

      Description copied from class: `TunnelPool`
      Add a tunnel to the pool.
      Overrides:
        `addTunnel` in class `TunnelPool`
      Parameters:
        `info` - the tunnel to add

    - #### buildComplete

          void buildComplete(PooledTunnelCreatorConfig cfg,
                             BuildExecutor.Result result)

      Description copied from class: `TunnelPool`
      Remove from the _inprogress list and call addTunnel() if result is SUCCESS. Updates consecutive build timeout count.
      Overrides:
        `buildComplete` in class `TunnelPool`
      Parameters:
        `cfg` - the completed tunnel configuration
        `result` - the build result

    - #### buildFallback

          boolean buildFallback()

      Description copied from class: `TunnelPool`
      This will build a fallback tunnel only if: - Exploratory pool: 0-hop fallback allowed - Client pool with allowZeroHop=true AND configured for 0 hops: 0-hop fallback allowed - Client pool configured for 1 hop: 1-hop fallback allowed - Otherwise: build multi-hop tunnel (enforce 2-hop minimum)
      Overrides:
        `buildFallback` in class `TunnelPool`
      Returns:
        true if a fallback tunnel is built, false otherwise

    - #### configureNewTunnel

          PooledTunnelCreatorConfig configureNewTunnel()

      Description copied from class: `TunnelPool`
      This only sets the peers and creation/expiration times in the configuration. For the crypto, see BuildRequestor and BuildMessageGenerator.
      Overrides:
        `configureNewTunnel` in class `TunnelPool`
      Returns:
        null on failure

    - #### countHowManyToBuild

          int countHowManyToBuild()

      Description copied from class: `TunnelPool`
      Gather the data to see how many tunnels to build, and then actually compute that value (delegated to the countHowManyToBuild function below)
      Overrides:
        `countHowManyToBuild` in class `TunnelPool`
      Returns:
        the number of tunnels to build

    - #### getLifetimeProcessed

          public long getLifetimeProcessed()

      Description copied from class: `TunnelPool`
      Total lifetime processed bytes for this pool.
      Overrides:
        `getLifetimeProcessed` in class `TunnelPool`
      Returns:
        the total number of bytes processed through this pool

    - #### getTunnel

          public TunnelInfo getTunnel(TunnelId gatewayId)

      Description copied from class: `TunnelPool`
      Get a tunnel by its gateway tunnel ID.
      Overrides:
        `getTunnel` in class `TunnelPool`
      Parameters:
        `gatewayId` - for inbound, the GW rcv tunnel ID; for outbound, the GW send tunnel ID.
      Returns:
        the tunnel with the matching gateway ID, or null if not found

    - #### isAlive

          public boolean isAlive()

      Description copied from class: `TunnelPool`
      Is this pool running AND either exploratory, or tracked by the client manager? A pool will be alive but not tracked after the client manager removes it but before all the tunnels have expired.
      Overrides:
        `isAlive` in class `TunnelPool`
      Returns:
        true if the pool is alive and should be tracked

    - #### listPending

          public List<PooledTunnelCreatorConfig> listPending()

      Description copied from class: `TunnelPool`
      list of tunnelInfo instances of tunnels currently being built
      Overrides:
        `listPending` in class `TunnelPool`
      Returns:
        the list of tunnels currently being built

    - #### listTunnels

          public List<TunnelInfo> listTunnels()

      Description copied from class: `TunnelPool`
      Return a list of tunnels in the pool
      Overrides:
        `listTunnels` in class `TunnelPool`
      Returns:
        A copy of the list of TunnelInfo objects

    - #### locked_buildNewLeaseSet

          protected LeaseSet locked_buildNewLeaseSet()

      Description copied from class: `TunnelPool`
      Build a leaseSet with the required tunnels that aren't about to expire. Caller must synchronize on _tunnels. The returned LeaseSet will be incomplete; it will not have the destination set and will not be signed. Only the leases will be included.
      Overrides:
        `locked_buildNewLeaseSet` in class `TunnelPool`
      Returns:
        null on failure

    - #### needFallback

          boolean needFallback()

      Description copied from class: `TunnelPool`
      Do we really need more fallbacks? Used to prevent a zillion of them. Does not check config, only call if config allows zero hop.
      Overrides:
        `needFallback` in class `TunnelPool`
      Returns:
        true if more fallback tunnels are needed

    - #### refreshLeaseSet

          void refreshLeaseSet()

      Description copied from class: `TunnelPool`
      noop for outbound and exploratory
      Overrides:
        `refreshLeaseSet` in class `TunnelPool`

    - #### removeTunnel

          void removeTunnel(TunnelInfo info)

      Description copied from class: `TunnelPool`
      Remove a tunnel from the pool.
      Overrides:
        `removeTunnel` in class `TunnelPool`
      Parameters:
        `info` - tunnel to remove

    - #### selectTunnel

          TunnelInfo selectTunnel()

      Description copied from class: `TunnelPool`
      Pull a random tunnel out of the pool. If there are none available but the pool is configured to allow 0hop tunnels, this builds a fake one and returns it.
      Overrides:
        `selectTunnel` in class `TunnelPool`
      Returns:
        null on failure, but it should always build and return a fallback

    - #### selectTunnel

          TunnelInfo selectTunnel(Hash closestTo)

      Description copied from class: `TunnelPool`
      Return the tunnel from the pool that is XOR-closest to the target. By using this instead of the random selectTunnel(), we force some locality in OBEP-IBGW connections to minimize those connections network-wide. Does not check for backlogged next peer. Does not return an expired tunnel.
      Overrides:
        `selectTunnel` in class `TunnelPool`
      Parameters:
        `closestTo` - the hash to find the closest tunnel to
      Returns:
        the tunnel closest to the target, or null on failure

    - #### shutdown

          void shutdown()

      Description copied from class: `TunnelPool`
      Shut down the pool and clean up resources.
      Overrides:
        `shutdown` in class `TunnelPool`

    - #### size

          public int size()

      Description copied from class: `TunnelPool`
      duplicate of getTunnelCount(), let's pick one
      Overrides:
        `size` in class `TunnelPool`
      Returns:
        the number of tunnels in the pool

    - #### startup

          void startup()

      Description copied from class: `TunnelPool`
      Warning, this may be called more than once (without an intervening shutdown()) if the tunnel is stopped and then restarted by the client manager with the same Destination (i.e. for servers or clients w/ persistent key, or restarting close-on-idle clients)
      Overrides:
        `startup` in class `TunnelPool`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `TunnelPool`

    - #### tunnelFailed

          void tunnelFailed(TunnelInfo cfg)

      Description copied from class: `TunnelPool`
      Remove tunnel and blame all peers (not necessarily equally). This may be called multiple times from TestJob. Enhanced with intelligent failure analysis and recovery.
      Overrides:
        `tunnelFailed` in class `TunnelPool`
      Parameters:
        `cfg` - the tunnel that failed

    - #### tunnelFailed

          void tunnelFailed(TunnelInfo cfg,
                            Hash blamePeer)

      Description copied from class: `TunnelPool`
      Remove the tunnel and blame only one peer. This may be called multiple times.
      Overrides:
        `tunnelFailed` in class `TunnelPool`
      Parameters:
        `cfg` - the tunnel that failed
        `blamePeer` - the peer to blame