## net.i2p.router.networkdb.kademlia
Class SearchJob

    java.lang.Object
      net.i2p.router.JobImpl
          net.i2p.router.networkdb.kademlia.SearchJob

All Implemented Interfaces:
  Job

Direct Known Subclasses:
  ExploreJob

     class SearchJob

extends JobImpl

Search for a particular key iteratively until we either find a value or we run out of peers

Nested Class Summary
`protected class` `SearchJob.FailedJob` Called when a particular peer failed to respond before the timeout was reached, or if the peer could not be contacted at all.

Field Summary
`protected KademliaNetworkDatabaseFacade` `_facade`
`(package private) static int` `MAX_CLOSEST` only send the 10 closest "dont tell me about" refs
`(package private) static int` `PER_FLOODFILL_PEER_TIMEOUT`

Constructor Summary
`SearchJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, Job onSuccess, Job onFailure, long timeoutMs, boolean keepStats, boolean isLease)` Create a new search for the routingKey specified

Method Summary
`(package private) boolean` `add(Hash peer)`
`int` `addDeferred(Job onFind, Job onFail, long expiration, boolean isLease)`
`protected DatabaseLookupMessage` `buildMessage(long expiration)` We're looking for a router, so lets build the lookup message (no need to tunnel route either, so just have replies sent back to us directly)
`protected DatabaseLookupMessage` `buildMessage(TunnelId replyTunnelId, Hash replyGateway, long expiration)` Build the database search message
`protected void` `continueSearch()` Send a series of searches to the next available peers as selected by the routing table, but making sure no more than SEARCH_BREDTH are outstanding at any time
`(package private) void` `decrementOutstandingFloodfillSearches()`
`protected void` `fail()` Search totally failed
`protected int` `getBredth()` max # of concurrent searches
`long` `getExpiration()`
`protected KademliaNetworkDatabaseFacade` `getFacade()`
`java.lang.String` `getName()` Descriptive name of the task
`protected int` `getPerPeerTimeoutMs()` Let each peer take up to the average successful search RTT
`protected int` `getPerPeerTimeoutMs(Hash peer)`
`protected SearchState` `getState()`
`long` `getTimeoutMs()`
`(package private) static boolean` `isCongested(RouterContext ctx)`
`protected void` `newPeersFound(int numNewPeers)` We've gotten a search reply that contained the specified number of peers that we didn't know about before.
`(package private) static boolean` `onlyQueryFloodfillPeers(RouterContext ctx)`
`(package private) void` `replyFound(DatabaseSearchReplyMessage message, Hash peer)`
`void` `runJob()` Actually perform the task.
`protected void` `searchNext()` Send the next search, or stop if its completed
`protected void` `sendLeaseSearch(RouterInfo router)` we're (probably) searching for a LeaseSet, so to be (overly) cautious, we're sending the request out through a tunnel w/ reply back through another tunnel.
`protected void` `sendRouterSearch(RouterInfo router)` we're searching for a router, so we can just send direct
`protected void` `sendSearch(RouterInfo router)` Send a search to the given peer
`(package private) long` `timeoutMs()`
`java.lang.String` `toString()`
`(package private) boolean` `wasAttempted(Hash peer)`

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

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

Field Detail

### _facade

    protected KademliaNetworkDatabaseFacade _facade

### MAX_CLOSEST

    static final int MAX_CLOSEST

  only send the 10 closest "dont tell me about" refs

  See Also:
    Constant Field Values

### PER_FLOODFILL_PEER_TIMEOUT

    static final int PER_FLOODFILL_PEER_TIMEOUT

See Also:
  Constant Field Values

Constructor Detail

### SearchJob

    public SearchJob(RouterContext context,
                     KademliaNetworkDatabaseFacade facade,
                     Hash key,
                     Job onSuccess,
                     Job onFailure,
                     long timeoutMs,
                     boolean keepStats,
                     boolean isLease)

  Create a new search for the routingKey specified

Method Detail

### runJob

    public void runJob()

  Description copied from interface: `Job`
  Actually perform the task. This call blocks until the Job is complete.

### getState

    protected SearchState getState()

### getFacade

    protected KademliaNetworkDatabaseFacade getFacade()

### getExpiration

    public long getExpiration()

### getTimeoutMs

    public long getTimeoutMs()

### onlyQueryFloodfillPeers

    static boolean onlyQueryFloodfillPeers(RouterContext ctx)

### isCongested

    static boolean isCongested(RouterContext ctx)

### getPerPeerTimeoutMs

    protected int getPerPeerTimeoutMs(Hash peer)

### getPerPeerTimeoutMs

    protected int getPerPeerTimeoutMs()

  Let each peer take up to the average successful search RTT

### searchNext

    protected void searchNext()

  Send the next search, or stop if its completed

### getBredth

    protected int getBredth()

  max # of concurrent searches

### continueSearch

    protected void continueSearch()

  Send a series of searches to the next available peers as selected by the routing table, but making sure no more than SEARCH_BREDTH are outstanding at any time

### sendSearch

    protected void sendSearch(RouterInfo router)

  Send a search to the given peer

### sendLeaseSearch

    protected void sendLeaseSearch(RouterInfo router)

  we're (probably) searching for a LeaseSet, so to be (overly) cautious, we're sending the request out through a tunnel w/ reply back through another tunnel.

### sendRouterSearch

    protected void sendRouterSearch(RouterInfo router)

  we're searching for a router, so we can just send direct

### buildMessage

    protected DatabaseLookupMessage buildMessage(TunnelId replyTunnelId,
                                                 Hash replyGateway,
                                                 long expiration)

  Build the database search message

  Parameters:
    `replyTunnelId` - tunnel to receive replies through
    `replyGateway` - gateway for the reply tunnel
    `expiration` - when the search should stop

### buildMessage

    protected DatabaseLookupMessage buildMessage(long expiration)

  We're looking for a router, so lets build the lookup message (no need to tunnel route either, so just have replies sent back to us directly)

### replyFound

    void replyFound(DatabaseSearchReplyMessage message,
                    Hash peer)

### newPeersFound

    protected void newPeersFound(int numNewPeers)

  We've gotten a search reply that contained the specified number of peers that we didn't know about before.

### fail

    protected void fail()

  Search totally failed

### addDeferred

    public int addDeferred(Job onFind,
                           Job onFail,
                           long expiration,
                           boolean isLease)

### getName

    public java.lang.String getName()

  Description copied from interface: `Job`
  Descriptive name of the task

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `JobImpl`

### wasAttempted

    boolean wasAttempted(Hash peer)

### timeoutMs

    long timeoutMs()

### add

    boolean add(Hash peer)

### decrementOutstandingFloodfillSearches

    void decrementOutstandingFloodfillSearches()