PersistentJobRunnerImpl (fred API)

java.lang.Object
- freenet.client.async.PersistentJobRunnerImpl

All Implemented Interfaces:

PersistentJobRunner

Direct Known Subclasses:

ClientLayerPersister
```
public abstract class PersistentJobRunnerImpl
extends java.lang.Object
implements PersistentJobRunner
```
Runs PersistentJob's and periodically, or on demand, suspends all jobs and calls innerCheckpoint().

Nested Class Summary
- Nested classes/interfaces inherited from interface freenet.client.async.PersistentJobRunner
  PersistentJobRunner.CheckpointLock

Field Summary

Fields
Modifier and Type Field and Description

protected java.lang.Object serializeCheckpoints

Fields
Modifier and Type	Field and Description
`protected java.lang.Object`	`serializeCheckpoints`

Constructor Summary

Constructors
Constructor and Description

PersistentJobRunnerImpl(Executor executor, Ticker ticker, long interval)

Constructors
Constructor and Description
`PersistentJobRunnerImpl(Executor executor, Ticker ticker, long interval)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkpointOffThread()`
`void`	`delayedCheckpoint()`
`void`	`disableWrite()`
`protected ClientContext`	`getClientContext()`
`void`	`handleCompletion(boolean ret, int threadPriority)`
`boolean`	`hasLoaded()` Has the queue started yet?
`protected abstract void`	`innerCheckpoint(boolean shutdown)`
`boolean`	`isKilledOrNotLoaded()`
`void`	`killAndWaitForNotRunning()`
`protected void`	`killAndWaitForNotWriting()` Set the killed flag and wait until we are not writing
`PersistentJobRunner.CheckpointLock`	`lock()` Obtain a lock which will prevent checkpointing until it is unlocked.
`protected void`	`onLoading()`
`protected void`	`onStarted(boolean noWrite)`
`void`	`queue(PersistentJob job, int threadPriority)` Start a job immediately unless we are about to write a checkpoint.
`void`	`queueInternal(PersistentJob job)` Start an "internal" job.
`void`	`queueInternal(PersistentJob job, int threadPriority)` Start an "internal" job.
`void`	`queueNormalOrDrop(PersistentJob job)` Queue the job at low thread priority or drop it if persistence is disabled.
`void`	`setCheckpointASAP()` Commit ASAP.
`void`	`shutdown()`
`boolean`	`shuttingDown()` If true, the node is shutting down
`void`	`start(ClientContext context)`
`protected void`	`updateLastCheckpointed()`
`void`	`waitAndCheckpoint()` Wait until a checkpoint has been completed, or if the job runner becomes idle, do it here.
`void`	`waitForIdleAndCheckpoint()` Typically called after shutdown() to wait for current jobs to complete.
`void`	`waitForNotWriting()`

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

Methods inherited from interface freenet.client.async.PersistentJobRunner
newSalt

- Field Detail
  - serializeCheckpoints
```
protected java.lang.Object serializeCheckpoints
```
- Constructor Detail
  - PersistentJobRunnerImpl
```
public PersistentJobRunnerImpl(Executor executor,
                               Ticker ticker,
                               long interval)
```
- Method Detail
  - start
```
public void start(ClientContext context)
```
  - queue
```
public void queue(PersistentJob job,
                  int threadPriority)
           throws PersistenceDisabledException
```
    Description copied from interface: PersistentJobRunner
    
    Start a job immediately unless we are about to write a checkpoint. If we are, queue the job until after the checkpoint has completed. We do not store the jobs, so this should be used for tasks which either are "external" and so will be retried after an unclean shutdown (for example, fetching a block from the datastore or the network), or where we will check for the situation on restart in onResume() (for example, the callback that starts a FEC decode). This should also be used for e.g. freeing on-disk files after a checkpoint.
    
    Specified by:
    
    queue in interface PersistentJobRunner
    
    Parameters:
    
    job - The job to run now or after the checkpoint.
    
    threadPriority - The priority of the job.
    
    Throws:
    
    PersistenceDisabledException - If persistence is disabled.
  - queueInternal
```
public void queueInternal(PersistentJob job,
                          int threadPriority)
                   throws PersistenceDisabledException
```
    Description copied from interface: PersistentJobRunner
    
    Start an "internal" job. We will not checkpoint until all the internal jobs have finished; we do not queue them at all. Hence a series of internal jobs is atomic. This should be used for stuff like creating the next stage of a request, where storing the half-way state would lead to it potentially not restarting properly after shutdown. It MUST NOT be used for events from outside the client layer, including finding blocks in the datastore, on the network etc. FIXME this doesn't queue at all. Come up with a better name! :)
    
    Specified by:
    
    queueInternal in interface PersistentJobRunner
    
    Throws:
    
    PersistenceDisabledException
  - queueInternal
```
public void queueInternal(PersistentJob job)
```
    Description copied from interface: PersistentJobRunner
    
    Start an "internal" job. We will not checkpoint until all the internal jobs have finished; we do not queue them at all. Hence a series of internal jobs is atomic. This should be used for stuff like creating the next stage of a request, where storing the half-way state would lead to it potentially not restarting properly after shutdown. It MUST NOT be used for events from outside the client layer, including finding blocks in the datastore, on the network etc. Often when we call this we could have continued the job on the same thread. That's not always the best thing to do however, we often move stuff to another job to minimise locking or increase throughput. FIXME this doesn't queue at all. Come up with a better name! :)
    
    Specified by:
    
    queueInternal in interface PersistentJobRunner
  - queueNormalOrDrop
```
public void queueNormalOrDrop(PersistentJob job)
```
    Description copied from interface: PersistentJobRunner
    
    Queue the job at low thread priority or drop it if persistence is disabled.
    
    Specified by:
    
    queueNormalOrDrop in interface PersistentJobRunner
  - handleCompletion
```
public void handleCompletion(boolean ret,
                             int threadPriority)
```
  - delayedCheckpoint
```
public void delayedCheckpoint()
```
  - checkpointOffThread
```
public void checkpointOffThread()
```
  - setCheckpointASAP
```
public void setCheckpointASAP()
```
    Description copied from interface: PersistentJobRunner
    
    Commit ASAP. Can also be set via returning true from a PersistentJob, but it's useful to be able to do it "inline".
    
    Specified by:
    
    setCheckpointASAP in interface PersistentJobRunner
  - updateLastCheckpointed
```
protected void updateLastCheckpointed()
```
  - innerCheckpoint
```
protected abstract void innerCheckpoint(boolean shutdown)
```
  - onLoading
```
protected void onLoading()
```
  - onStarted
```
protected void onStarted(boolean noWrite)
```
  - shutdown
```
public void shutdown()
```
  - shuttingDown
```
public boolean shuttingDown()
```
    Description copied from interface: PersistentJobRunner
    
    If true, the node is shutting down
    
    Specified by:
    
    shuttingDown in interface PersistentJobRunner
  - waitForIdleAndCheckpoint
```
public void waitForIdleAndCheckpoint()
```
    Typically called after shutdown() to wait for current jobs to complete. Does not check killed for this reason.
  - waitAndCheckpoint
```
public void waitAndCheckpoint()
                       throws PersistenceDisabledException
```
    Wait until a checkpoint has been completed, or if the job runner becomes idle, do it here.
    
    Throws:
    
    PersistenceDisabledException
  - killAndWaitForNotWriting
```
protected void killAndWaitForNotWriting()
```
    Set the killed flag and wait until we are not writing
  - waitForNotWriting
```
public void waitForNotWriting()
```
  - killAndWaitForNotRunning
```
public void killAndWaitForNotRunning()
```
  - isKilledOrNotLoaded
```
public boolean isKilledOrNotLoaded()
```
  - hasLoaded
```
public boolean hasLoaded()
```
    Description copied from interface: PersistentJobRunner
    
    Has the queue started yet?
    
    Specified by:
    
    hasLoaded in interface PersistentJobRunner
  - getClientContext
```
protected ClientContext getClientContext()
```
  - lock
```
public PersistentJobRunner.CheckpointLock lock()
                                        throws PersistenceDisabledException
```
    Description copied from interface: PersistentJobRunner
    
    Obtain a lock which will prevent checkpointing until it is unlocked. This counts as a thread, and can be used for e.g. MemoryLimitedJob's that can change persistent data. Like any lock, you MUST use a try/finally block. lock() may block if a checkpoint is in progress or is scheduled.
    
    Specified by:
    
    lock in interface PersistentJobRunner
    
    Throws:
    
    PersistenceDisabledException - If we are unable to lock because the system is shutting down.
  - disableWrite
```
public void disableWrite()
```

Class PersistentJobRunnerImpl

Nested Class Summary

Nested classes/interfaces inherited from interface freenet.client.async.PersistentJobRunner

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface freenet.client.async.PersistentJobRunner

Field Detail

serializeCheckpoints

Constructor Detail

PersistentJobRunnerImpl

Method Detail

start

queue

queueInternal

queueInternal

queueNormalOrDrop

handleCompletion

delayedCheckpoint

checkpointOffThread

setCheckpointASAP

updateLastCheckpointed

innerCheckpoint

onLoading

onStarted

shutdown

shuttingDown

waitForIdleAndCheckpoint

waitAndCheckpoint

killAndWaitForNotWriting

waitForNotWriting

killAndWaitForNotRunning

isKilledOrNotLoaded

hasLoaded

getClientContext

lock

disableWrite