See: Description
| Interface | Description |
|---|---|
| BlockSet |
A set of KeyBlock's.
|
| ClientBaseCallback |
A client process.
|
| ClientGetCallback |
Internal callback interface for requests.
|
| ClientGetState |
A ClientGetState.
|
| ClientPutCallback |
Internal callback interface for inserts (including site inserts).
|
| ClientPutState |
ClientPutState
Represents a state in the insert process.
|
| ClientRequestSchedulerGroup |
Logical grouping for a single "request" for scheduling purposes.
|
| DownloadCache | |
| FileGetCompletionCallback |
If a request will return the downloaded data to a file (not a temporary file), and if the data
doesn't need decompressing or filtering, and if we are doing the final stage of the download, we
can create a file in the same directory and use it for temporary storage, then when the download
completes call onSuccess(), which will check the hashes and then rename the file.
|
| GetCompletionCallback |
Callback called when part of a get request completes - either with a
StreamGenerator full of data, or with an error.
|
| HasKeyListener |
Interface to show that we can create a KeyListener callback.
|
| HealingQueue | |
| KeyListener |
Transient object created on startup for persistent requests (or at creation
time for non-persistent requests), to monitor the stream of successfully
fetched keys.
|
| KeySalter |
This is a separate interface so we don't need to pass the scheduler where it's not needed.
|
| PersistentClientCallback |
Fetches which may be persistent need getClientDetail() so that we can save that data to the
file a splitfile download is using, so that it can be recovered later.
|
| PersistentJob |
A task that affects persistent state.
|
| PersistentJobRunner |
We need to be able to suspend execution of jobs changing persistent state in order to write
it to disk consistently.
|
| PersistentJobRunner.CheckpointLock | |
| PutCompletionCallback |
Callback called when part of a put request completes.
|
| RequestSelectionTreeNode |
Something that can have a CooldownCacheItem: Anything in the request selection tree, including
the actual requests at the bottom (but ClientRequestSelector isn't actually a
RequestSelectionTreeNode at the moment, the root is the priorities in the array on
ClientRequestSelector; FIXME consistency with RGA.root etc).
|
| SnoopBucket | |
| SnoopMetadata | |
| SplitFileFetcherStorageCallback |
Callback used by SplitFileFetcherStorage.
|
| SplitFileInserterStorageCallback |
Callback interface for a SplitFileInserterStorage.
|
| StreamGenerator |
Writes an underlying data structure to an output stream.
|
| USKCallback |
USK callback interface.
|
| USKFetcherCallback |
Callback interface for USK fetches.
|
| USKFetcherTagCallback | |
| USKManager.HintCallback | |
| USKProgressCallback | |
| USKRetrieverCallback |
Interface implemented by USKRetriever clients.
|
| WantsCooldownCallback |
Interface for requests that require a callback when they go into cooldown.
|
| Class | Description |
|---|---|
| BaseClientGetter | |
| BaseClientPutter |
Base class for inserts, including site inserts, at the level of a ClientRequester.
|
| BaseManifestPutter |
Base class for site insertion.
|
| BaseSingleFileFetcher |
Base class implements most of what is needed for fetching a single block.
|
| BinaryBlob | |
| BinaryBlobInserter | |
| BinaryBlobWriter |
Helper class to write FBlobs.
|
| CacheFetchResult | |
| ChosenBlock |
A single selected request, including everything needed to execute it.
|
| ChosenBlockImpl | |
| ClientContext |
Object passed in to client-layer operations, containing references to essential but mostly transient
objects such as the schedulers and the FEC queue.
|
| ClientGetter |
A high level data request.
|
| ClientGetWorkerThread |
A thread which does postprocessing of decompressed data, in particular,
writing it to its final destination.
|
| ClientLayerPersister |
Top level of persistence mechanism for ClientRequest's (persistent downloads and uploads).
|
| ClientPutter |
A high level insert.
|
| ClientRequester |
A high level request or insert.
|
| ClientRequestScheduler |
Every X seconds, the RequestSender calls the ClientRequestScheduler to
ask for a request to start.
|
| ClientRequestSelector |
The global request queue.
|
| CompatibilityAnalyser | |
| ContainerInserter |
Insert a bunch of files as single Archive with .metadata
pack the container/archive, then hand it off to SimpleFileInserter
TODO persistence
TODO add a MAX_SIZE for the final container(file)
|
| CooldownBlockChooser |
A block chooser including support for cooldown
|
| DatastoreChecker | |
| DefaultManifestPutter |
The default manifest putter.
|
| DumperSnoopMetadata | |
| InsertCompressor |
Compress a file in order to insert it.
|
| ManifestElement | Deprecated |
| ManifestPutter | |
| MultiPutCompletionCallback | |
| OfferedKeysList |
All the keys at a given priority which we have received key offers from other nodes for.
|
| PersistentJobRunnerImpl |
Runs PersistentJob's and periodically, or on demand, suspends all jobs and calls
innerCheckpoint().
|
| PersistentStatsPutter |
Add/alter the containers contained in the database, so that
the upload/download statistics persist.
|
| PlainManifestPutter |
plain/dumb manifest putter: every file item is a redirect (no containers at all)
|
| ReadBucketAndFreeInputStream | |
| SimpleBlockChooser |
Tracks which blocks have been completed, how many attempts have been made for which blocks,
allows choosing a random block, failing a block etc.
|
| SimpleBlockSet |
Simple BlockSet implementation, keeps all keys in RAM.
|
| SimpleHealingQueue | |
| SimpleSingleFileFetcher |
Fetch a single block file.
|
| SingleBlockInserter |
Insert a single block.
|
| SingleFileFetcher |
Does most of the complicated metadata handling for fetching single files.
|
| SingleFileFetcher.MyUSKFetcherCallback | |
| SingleFileStreamGenerator |
Writes a
Bucket to an output stream. |
| SingleKeyListener | |
| SplitFileFetcher |
Splitfile fetcher based on keeping as much state as possible, and in particular the downloaded blocks,
in a single file.
|
| SplitFileFetcherCrossSegmentStorage |
Cross-segments are "in parallel" with the main segments, an interlaced Reed-Solomon scheme
similar to that used on CD's, allowing us to fill in blocks from other segments.
|
| SplitFileFetcherGet |
Actually does the splitfile fetch.
|
| SplitFileFetcherKeyListener | |
| SplitFileFetcherSegmentBlockChooser | |
| SplitFileFetcherSegmentSendableRequestItem | |
| SplitFileFetcherSegmentStorage |
Represents a single segment, in memory and on disk.
|
| SplitFileFetcherStorage |
Stores the state for a SplitFileFetcher, persisted to a LockableRandomAccessBuffer (i.e.
|
| SplitFileInserter |
Top level class for a splitfile insert.
|
| SplitFileInserterCrossSegmentStorage | |
| SplitFileInserterSegmentBlockChooser |
Tracks retry count and completion status for blocks in an insert segment.
|
| SplitFileInserterSegmentStorage |
A single segment within a splitfile to be inserted.
|
| SplitFileInserterSender |
Interface to the low level insertion code for inserting a splitfile.
|
| SplitFileInserterStorage |
Similar to SplitFileFetcherStorage.
|
| SplitFileSegmentKeys |
Contains the keys for a splitfile segment, in an efficient compressed form.
|
| USKDateHint |
Utility class for date-based edition hints
|
| USKFetcher |
On 0.7, this shouldn't however take more than 10 seconds or so; these are SSKs
we are talking about.
|
| USKFetcherWrapper |
Wrapper for a backgrounded USKFetcher.
|
| USKInserter |
Insert a USK.
|
| USKManager |
Tracks the latest version of every known USK.
|
| USKProxyCompletionCallback |
Passes everything through, except that is updates the lastKnownGood on the USKManager,
and has some code to handle new URIs.
|
| USKRetriever |
Poll a USK, and when a new slot is found, fetch it.
|
| USKSparseProxyCallback |
Proxy class to only pass through latest-slot updates after an onRoundFinished().
|
| Enum | Description |
|---|---|
| USKDateHint.Type |
| Exception | Description |
|---|---|
| BinaryBlobFormatException | |
| BinaryBlobWriter.BinaryBlobAlreadyClosedException | |
| NoValidBlocksException | |
| PersistenceDisabledException | |
| TooManyFilesInsertException |
Thrown when there are too many files in a single folder (directory) for an insert.
|
Client layer core classes (implementation of actually fetching files etc).
for a description of the overall architecture of the client layer.
This package is mainly for classes that actually run high-level requests, inserts, site
inserts, etc. The major components here:
- @see ClientRequester The top level requests: A site insert, a fetch for a key on
Freenet (which may involve following redirects, unpacking containers, splitfiles, etc), an
insert of a file etc. E.g. @see ClientGetter
- @see ClientGetState The current stage in a request. E.g. fetch a block and follow the
metadata and redirects if necessary (@see SingleFileFetcher), or download a splitfile (@see
SplitFileFetcher).
- @see ClientPutState The current stage in an insert. E.g. insert a single block (@see
SingleBlockInserter), or a splitfile (@see SplitFileInserter).
- Code for actually choosing which request to start. ClientRequestScheduler is an interface
class, the actual request selection tree is on ClientRequestSelector. We keep a separate
structure (mostly Bloom filters) using KeyListeners to identify which block belongs to which
client, as we will often be offered blocks, or fetch them on behalf of other nodes. This is kept
by ClientRequestSchedulerCore for persistent requests and ClientRequestSchedulerNonPersistent
for transient requests.
- The cooldown queue: @see CooldownTracker. This is used to ensure that we don't keep on
selecting the same request repeatedly, while choosing requests efficiently.
,
for a closely related mechanism at the node level.
- USK-related code
- The healing queue
- Misc persistence-related code, @see ClientLayerPersister for the persistence architecture.
The main connections to other layers: Code which uses the client layer:
- @see freenet.client.HighLevelSimpleClient (a lightweight API used both internally and
by some plugins)
- @see freenet.clients.fcp The interface to external FCP clients
- Some code and plugins use the classes here directly.
Code which the client layer uses:
- @see freenet.client Support classes for MIME type handling, container handling, etc
- @see freenet.node.SendableRequest The actual implementation of sending requests
- @see freenet.support Especially @see freenet.support.RandomGrabArray and related classes
- @see freenet.client.events Events are sent to other layers (especially FCP)
- @see freenet.client.filter Content filtering code. Content filtering is implemented in the
client layer for various reasons.