## Uses of Interface
net.i2p.router.Job

Packages that use Job
net.i2p.router: The I2P router application handles the I2P network communication.
net.i2p.router.client
net.i2p.router.message
net.i2p.router.networkdb
net.i2p.router.networkdb.kademlia
net.i2p.router.peermanager: The peer manager logs information about the history and quality of network peers.
net.i2p.router.startup: The I2P startup package loads the configuration when I2P is started.
net.i2p.router.transport: The transport system allows the usage of communication layers that are below I2P in the stack, on which I2P messages are sent.
net.i2p.router.tunnel.pool

Uses of Job in net.i2p.router

Subinterfaces of Job in net.i2p.router
`interface` `ReplyJob` Defines an executable task that can be fired off in reply to a message

Classes in net.i2p.router that implement Job
`class` `JobImpl` Base implementation of a Job

Methods in net.i2p.router that return Job
`Job` `HandlerJobBuilder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)` Create a new job to handle the received message.
`Job` `JobQueueRunner.getCurrentJob()`
`Job` `JobQueueRunner.getLastJob()`
`Job` `JobQueue.getLastJob()` retrieve the most recently begin and still currently active job, or null if no jobs are running
`(package private) Job` `JobQueue.getNext()` Blocking call to retrieve the next ready job
`Job` `OutNetMessage.getOnFailedReplyJob()` If the Message selector is specified but it doesn't find a reply before its expiration passes, this job is enqueued.
`Job` `OutNetMessage.getOnFailedSendJob()` If the router could not be reached or the expiration passed, this job is enqueued.
`Job` `OutNetMessage.getOnSendJob()` After the message is successfully passed to the router specified, the given job is enqueued.

Methods in net.i2p.router with parameters of type Job
`void` `JobQueue.addJob(Job job)` Enqueue the specified job
`boolean` `JobQueue.isJobActive(Job job)` Returns `true` if a given job is waiting or running; `false` if the job is finished or doesn't exist in the queue.
`void` `DummyNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`abstract void` `NetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`void` `DummyNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`abstract void` `NetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`void` `JobQueue.removeJob(Job job)`
`void` `DummyClientManagerFacade.requestLeaseSet(Destination dest, LeaseSet set, long timeout, Job onCreateJob, Job onFailedJob)`
`abstract void` `ClientManagerFacade.requestLeaseSet(Destination dest, LeaseSet set, long timeout, Job onCreateJob, Job onFailedJob)` Request that a particular client authorize the Leases contained in the LeaseSet, after which the onCreateJob is queued up.
`void` `OutNetMessage.setOnFailedReplyJob(Job job)`
`void` `OutNetMessage.setOnFailedSendJob(Job job)`
`void` `OutNetMessage.setOnSendJob(Job job)`
`(package private) void` `JobQueue.updateStats(Job job, long doStart, long origStartAfter, long duration)` calculate and update the job timings if it was lagged too much or took too long to run, spit out a warning (and if its really excessive, kill the router)

Uses of Job in net.i2p.router.client

Classes in net.i2p.router.client that implement Job
`(package private) class` `CreateSessionJob` Given an established connection, walk through the process of establishing the lease set.
`(package private) class` `LookupDestJob` Look up the lease of a hash, to convert it to a Destination for the client
`(package private) class` `MessageReceivedJob` Async job to notify the client that a new message is available for them
`(package private) class` `ReportAbuseJob` Async job to send an abuse message to the client
`(package private) class` `RequestLeaseSetJob` Async job to walk the client through generating a lease set.

Methods in net.i2p.router.client that return Job
`Job` `LeaseRequestState.getOnFailed()` what to do if the lease set create fails / times out
`Job` `LeaseRequestState.getOnGranted()` what to do once the lease set is created

Methods in net.i2p.router.client with parameters of type Job
`void` `ClientManager.requestLeaseSet(Destination dest, LeaseSet set, long timeout, Job onCreateJob, Job onFailedJob)` Request that a particular client authorize the Leases contained in the LeaseSet, after which the onCreateJob is queued up.
`void` `ClientManagerFacadeImpl.requestLeaseSet(Destination dest, LeaseSet set, long timeout, Job onCreateJob, Job onFailedJob)` Request that a particular client authorize the Leases contained in the LeaseSet, after which the onCreateJob is queued up.
`(package private) void` `ClientConnectionRunner.requestLeaseSet(LeaseSet set, long expirationTime, Job onCreateJob, Job onFailedJob)` Request that a particular client authorize the Leases contained in the LeaseSet, after which the onCreateJob is queued up.
`void` `LeaseRequestState.setOnFailed(Job jb)`
`void` `LeaseRequestState.setOnGranted(Job jb)`

Constructors in net.i2p.router.client with parameters of type Job
`LeaseRequestState(Job onGranted, Job onFailed, long expiration, LeaseSet requested)`
`RequestLeaseSetJob(RouterContext ctx, ClientConnectionRunner runner, LeaseSet set, long expiration, Job onCreate, Job onFail, LeaseRequestState state)`

Uses of Job in net.i2p.router.message

Classes in net.i2p.router.message that implement Job
`(package private) class` `HandleGarlicMessageJob` Unencrypt a garlic message and handle each of the cloves - locally destined messages are tossed into the inbound network message pool so they're handled as if they arrived locally.
`class` `OutboundClientMessageOneShotJob` Send a client message out a random outbound tunnel and into a random inbound tunnel on the target leaseSet.
`class` `SendMessageDirectJob`

Methods in net.i2p.router.message that return Job
`Job` `GarlicMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`

Constructors in net.i2p.router.message with parameters of type Job
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, Job onSend, ReplyJob onSuccess, Job onFail, MessageSelector selector, int timeoutMs, int priority)`
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, ReplyJob onSuccess, Job onFail, MessageSelector selector, int timeoutMs, int priority)`

Uses of Job in net.i2p.router.networkdb

Classes in net.i2p.router.networkdb that implement Job
`class` `HandleDatabaseLookupMessageJob` Handle a lookup for a key received from a remote peer.
`class` `HandleDatabaseStoreMessageJob` Receive DatabaseStoreMessage data and store it in the local net db Unused - see kademlia/ for replacement
`class` `PublishLocalRouterInfoJob` Publish the local router's RouterInfo periodically NOTE - this also creates and signs the RI

Methods in net.i2p.router.networkdb that return Job
`Job` `DatabaseStoreMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`Job` `DatabaseLookupMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`

Uses of Job in net.i2p.router.networkdb.kademlia

Classes in net.i2p.router.networkdb.kademlia that implement Job
`(package private) class` `ExpireLeasesJob` Periodically search through all leases to find expired ones, failing those keys and firing up a new search for each (in case we want it later, might as well preemptively fetch it)
`(package private) class` `ExpireRoutersJob` Go through the routing table pick routers that are is out of date, but don't expire routers we're actively connected to.
`(package private) class` `ExploreJob` Search for a particular key iteratively until we either find a value, we run out of peers, or the bucket the key belongs in has sufficient values in it.
`(package private) class` `ExploreKeySelectorJob` Go through the kbuckets and generate random keys for routers in buckets not yet full, attempting to keep a pool of keys we can explore with (at least one per bucket)
`(package private) class` `FloodfillMonitorJob` Simple job to monitor the floodfill pool.
`(package private) class` `FloodfillStoreJob` This extends StoreJob to fire off a FloodfillVerifyStoreJob after success.
`class` `FloodfillVerifyStoreJob` send a netDb lookup to a random floodfill peer - if it is found, great, but if they reply back saying they dont know it, queue up a store of the key to a random floodfill peer again (via FloodfillStoreJob)
`(package private) class` `FloodOnlyLookupMatchJob`
`(package private) class` `FloodOnlyLookupTimeoutJob`

`(package private) class`

`FloodOnlySearchJob`
Try sending a search to some floodfill peers, failing completely if we don't get a match from one of those peers, with no fallback to the kademlia search Exception (a semi-exception, since we still fail completely without fallback): If we don't know any floodfill peers, we ask a couple of peers at random, who will hopefully reply with some floodfill keys.

`class` `FloodSearchJob` Try sending a search to some floodfill peers, but if we don't get a successful match within half the allowed lookup time, give up and start querying through the normal (kademlia) channels.
`class` `HandleFloodfillDatabaseLookupMessageJob` Handle a lookup for a key received from a remote peer.
`class` `HandleFloodfillDatabaseStoreMessageJob` Receive DatabaseStoreMessage data and store it in the local net db
`(package private) class` `HarvesterJob` Simple job to try to keep our peer references up to date by aggressively requerying them every few minutes.
`class` `RepublishLeaseSetJob` Run periodically for each locally created leaseSet to cause it to be republished if the client is still connected.
`(package private) class` `SearchJob` Search for a particular key iteratively until we either find a value or we run out of peers Note that this is rarely if ever used directly, and is primary used by the ExploreJob extension.
`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.
`(package private) class` `SearchReplyJob`
`(package private) class` `SearchUpdateReplyFoundJob` Called after a match to a db search is found
`(package private) class` `SingleLookupJob` Ask the peer who sent us the DSRM for the RouterInfos.
`(package private) class` `SingleSearchJob` Ask a single peer for a single key.
`(package private) class` `StartExplorersJob` Fire off search jobs for random keys from the explore pool, up to MAX_PER_RUN at a time.
`(package private) class` `StoreJob`

Fields in net.i2p.router.networkdb.kademlia declared as Job
`protected Job` `FloodOnlySearchJob._onTimeout`

Fields in net.i2p.router.networkdb.kademlia with type parameters of type Job
`protected List<Job>` `FloodSearchJob._onFailed`
`protected List<Job>` `FloodSearchJob._onFind`

Methods in net.i2p.router.networkdb.kademlia that return Job
`Job` `FloodfillDatabaseStoreMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`Job` `FloodfillDatabaseLookupMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`

Methods in net.i2p.router.networkdb.kademlia with parameters of type Job
`int` `SearchJob.addDeferred(Job onFind, Job onFail, long expiration, boolean isLease)`
`(package private) void` `FloodSearchJob.addDeferred(Job onFind, Job onFailed, long timeoutMs, boolean isLease)`
`void` `KademliaNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`void` `KademliaNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`(package private) SearchJob` `FloodfillNetworkDatabaseFacade.search(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs, boolean isLease)` Begin a kademlia style search for the key specified, which can take up to timeoutMs and will fire the appropriate jobs on success or timeout (or if the kademlia search completes without any match)

`(package private) SearchJob`

`KademliaNetworkDatabaseFacade.search(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs, boolean isLease)`
Begin a kademlia style search for the key specified, which can take up to timeoutMs and will fire the appropriate jobs on success or timeout (or if the kademlia search completes without any match) Unused - called only by FNDF.searchFull() from FloodSearchJob which is overridden - don't use this.

`void` `FloodfillNetworkDatabaseFacade.sendStore(Hash key, DatabaseEntry ds, Job onSuccess, Job onFailure, long sendTimeout, Set toIgnore)`
`void` `KademliaNetworkDatabaseFacade.sendStore(Hash key, DatabaseEntry ds, Job onSuccess, Job onFailure, long sendTimeout, Set toIgnore)` unused (overridden in FNDF)

Method parameters in net.i2p.router.networkdb.kademlia with type arguments of type Job
`(package private) void` `FloodfillNetworkDatabaseFacade.searchFull(Hash key, List<Job> onFind, List<Job> onFailed, long timeoutMs, boolean isLease)` Ok, the initial set of searches to the floodfill peers timed out, lets fall back on the wider kademlia-style searches Unused - called only by FloodSearchJob which is overridden - don't use this.
`(package private) void` `FloodfillNetworkDatabaseFacade.searchFull(Hash key, List<Job> onFind, List<Job> onFailed, long timeoutMs, boolean isLease)` Ok, the initial set of searches to the floodfill peers timed out, lets fall back on the wider kademlia-style searches Unused - called only by FloodSearchJob which is overridden - don't use this.

Constructors in net.i2p.router.networkdb.kademlia with parameters of type Job
`FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs)` Send a data structure to the floodfills
`FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs, Set<Hash> toSkip)`
`FloodOnlySearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)`
`FloodSearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)`
`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
`StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs)` Send a data structure to the floodfills
`StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DatabaseEntry data, Job onSuccess, Job onFailure, long timeoutMs, Set<Hash> toSkip)`

Uses of Job in net.i2p.router.peermanager

Classes in net.i2p.router.peermanager that implement Job
`class` `PeerTestJob` Grab some peers that we want to test and probe them briefly to get some more accurate and up to date performance data.

Uses of Job in net.i2p.router.startup

Classes in net.i2p.router.startup that implement Job
`class` `BootCommSystemJob` This actually boots almost everything
`class` `BootNetworkDbJob` start up the network database
`class` `BootPeerManagerJob` start up the peer manager
`class` `BuildTrustedLinksJob`
`class` `CreateRouterInfoJob`
`class` `LoadClientAppsJob` Run any client applications specified in clients.config.
`static class` `LoadClientAppsJob.DelayedRunClient`
`class` `LoadRouterInfoJob`
`class` `ReadConfigJob` Simply read the router config
`class` `RebuildRouterInfoJob` This used be called from StartAcceptingClientsJob but is now disabled.
`class` `StartAcceptingClientsJob` start I2CP interface
`class` `StartupJob` The StartupJob should be run once on router startup to initialize the system and set things in motion.

Constructors in net.i2p.router.startup with parameters of type Job
`BuildTrustedLinksJob(RouterContext context, Job next)`
`CreateRouterInfoJob(RouterContext ctx, Job next)`

Uses of Job in net.i2p.router.transport

Classes in net.i2p.router.transport that implement Job
`(package private) class` `GetBidsJob` Retrieve a set of bids for a particular outbound message, and if any are found that meet the message's requirements, register the message as in process and pass it on to the transport for processing

Methods in net.i2p.router.transport with parameters of type Job
`OutNetMessage` `OutboundMessageRegistry.registerPending(MessageSelector replySelector, ReplyJob onReply, Job onTimeout, int timeoutMs)`

Uses of Job in net.i2p.router.tunnel.pool

Classes in net.i2p.router.tunnel.pool that implement Job
`(package private) class` `ExpireJob` This runs twice for each tunnel.
`(package private) class` `TestJob`

Methods in net.i2p.router.tunnel.pool with parameters of type Job
`void` `PooledTunnelCreatorConfig.setExpireJob(Job job)` does nothing, to be deprecated