Struct Fud

pub struct Fud {

    pub node_data: Arc<RwLock<VerifiableNodeData>>,
    pub secret_key: Arc<RwLock<SecretKey>>,
    pub seeders_router: DhtRouterPtr<FudNode>,
    pub(crate) p2p: P2pPtr,
    pub(crate) geode: Geode,
    pub(crate) downloads_path: PathBuf,
    pub(crate) chunk_timeout: u64,
    pub pow: Arc<RwLock<FudPow>>,
    pub(crate) dht: Arc<Dht<FudNode>>,
    pub(crate) resources: Arc<RwLock<HashMap<Hash, Resource>>>,
    pub(crate) path_tree: Tree,
    pub(crate) file_selection_tree: Tree,
    pub(crate) scrap_tree: Tree,
    pub(crate) get_tx: Sender<(Hash, PathBuf, FileSelection)>,
    pub(crate) get_rx: Receiver<(Hash, PathBuf, FileSelection)>,
    pub(crate) put_tx: Sender<PathBuf>,
    pub(crate) put_rx: Receiver<PathBuf>,
    pub(crate) fetch_tasks: Arc<RwLock<HashMap<Hash, Arc<StoppableTask>>>>,
    pub(crate) put_tasks: Arc<RwLock<HashMap<PathBuf, Arc<StoppableTask>>>>,
    pub(crate) tasks: Arc<RwLock<HashMap<String, Arc<StoppableTask>>>>,
    pub(crate) event_publisher: PublisherPtr<FudEvent>,
    pub executor: ExecutorPtr,
}

Fields

node_data: Arc<RwLock<VerifiableNodeData>>

Our own VerifiableNodeData

secret_key: Arc<RwLock<SecretKey>>

Our secret key (the public key is in node_data)

seeders_router: DhtRouterPtr<FudNode>

Key -> Seeders

p2p: P2pPtr

Pointer to the P2P network instance

geode: Geode

The Geode instance

downloads_path: PathBuf

Default download directory

chunk_timeout: u64

Chunk transfer timeout in seconds

pow: Arc<RwLock<FudPow>>

The FudPow instance

dht: Arc<Dht<FudNode>>

The DHT instance

resources: Arc<RwLock<HashMap<Hash, Resource>>>

Resources (current status of all downloads/seeds)

path_tree: Tree

Sled tree containing “resource hash -> path on the filesystem”

file_selection_tree: Tree

Sled tree containing “resource hash -> file selection”. If the file selection is all files of the resource (or if the resource is not a directory), the resource does not store its file selection in the tree.

scrap_tree: Tree

Sled tree containing scraps which are chunks containing data the user did not want to save to files. They also contain data the user wanted otherwise we would not have downloaded the chunk at all. “chunk/scrap hash -> chunk content”

get_tx: Sender<(Hash, PathBuf, FileSelection)>

get_rx: Receiver<(Hash, PathBuf, FileSelection)>

put_tx: Sender<PathBuf>

put_rx: Receiver<PathBuf>

fetch_tasks: Arc<RwLock<HashMap<Hash, Arc<StoppableTask>>>>

Currently active downloading tasks (running the fud.fetch_resource() method)

put_tasks: Arc<RwLock<HashMap<PathBuf, Arc<StoppableTask>>>>

Currently active put tasks (running the fud.insert_resource() method)

tasks: Arc<RwLock<HashMap<String, Arc<StoppableTask>>>>

Currently active tasks (defined in tasks, started with the start_task macro)

event_publisher: PublisherPtr<FudEvent>

Used to send events to fud clients

executor: ExecutorPtr

Global multithreaded executor reference

Implementations

impl Fud

pub async fn new( settings: Args, p2p: P2pPtr, sled_db: &Db, event_publisher: PublisherPtr<FudEvent>, executor: ExecutorPtr, ) -> Result<Self>

pub async fn start_tasks(self: &Arc<Self>)

pub(crate) async fn init(&self) -> Result<()>

Bootstrap the DHT, verify our resources, add ourselves to seeders_router for the resources we already have, announce our files.

pub fn hash_to_path(&self, hash: &Hash) -> Result<Option<PathBuf>>

Get resource path from hash using the sled db

pub fn path_to_hash(&self, path: &Path) -> Result<Option<Hash>>

Get resource hash from path using the sled db

pub async fn verify_resources( &self, hashes: Option<Vec<Hash>>, ) -> Result<Vec<Resource>>

Verify if resources are complete and uncorrupted. If a resource is incomplete or corrupted, its status is changed to Incomplete. If a resource is complete, its status is changed to Seeding. Takes an optional list of resource hashes. If no hash is given (None), it verifies all resources. Returns the list of verified and uncorrupted/complete seeding resources.

pub(crate) async fn fetch_seeders( &self, nodes: &Vec<FudNode>, key: &Hash, ) -> HashSet<DhtRouterItem<FudNode>>

Query nodes to find the seeders for key

pub(crate) async fn fetch_chunks( &self, hash: &Hash, chunked: &mut ChunkedStorage, seeders: &HashSet<DhtRouterItem<FudNode>>, chunks: &HashSet<Hash>, ) -> Result<()>

Fetch chunks for chunked (file or directory) from seeders.

pub async fn fetch_metadata( &self, hash: &Hash, nodes: &Vec<FudNode>, path: &Path, ) -> Result<()>

Fetch a single resource metadata from nodes. If the resource is a file smaller than a single chunk then seeder can send the chunk directly, and we will create the file from it on path path.

1. Request seeders from those nodes
2. Request the metadata from the seeders
3. Insert metadata to geode using the reply

pub async fn get( &self, hash: &Hash, path: &Path, files: FileSelection, ) -> Result<()>

Start downloading a file or directory from the network to path. This creates a new task in fetch_tasks calling fetch_resource(). files is the list of files (relative paths) you want to download (if the resource is a directory), None means you want all files.

pub async fn get_metadata( &self, hash: &Hash, path: &Path, ) -> Result<(ChunkedStorage, Vec<FudNode>)>

Try to get the chunked file or directory from geode, if we don’t have it then it is fetched from the network using fetch_metadata().

pub async fn fetch_resource( &self, hash: &Hash, path: &Path, files: &FileSelection, ) -> Result<()>

Download a file or directory from the network to path. Called when get() creates a new fetch task.

pub(crate) async fn write_scraps( &self, chunked: &mut ChunkedStorage, chunk_hashes: &HashSet<Hash>, ) -> Result<()>

pub async fn verify_chunks( &self, resource: &Resource, chunked: &mut ChunkedStorage, ) -> Result<(u64, u64)>

Iterate over chunks and find which chunks are available locally, either in the filesystem (using geode::verify_chunks()) or in scraps. chunk_hashes is the list of chunk hashes we want to take into account, None means to take all chunks into account. Return the scraps in a HashMap, and the size in bytes of locally available data (downloaded and downloaded+targeted).

pub async fn put(&self, path: &Path) -> Result<()>

Add a resource from the file system.

pub async fn insert_resource(&self, path: &PathBuf) -> Result<()>

Insert a file or directory from the file system. Called when put() creates a new put task.

pub async fn remove(&self, hash: &Hash)

Removes:

• a resource
• its metadata in geode
• its path in the sled path tree
• its file selection in the sled file selection tree
• and any related scrap in the sled scrap tree,

then sends a ResourceRemoved fud event.

pub async fn stop(&self)

Stop all tasks.

Trait Implementations

impl DhtHandler<FudNode> for Fud

fn dht(&self) -> Arc<Dht<FudNode>>

fn node<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = FudNode> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get our own node

fn ping<'life0, 'async_trait>( &'life0 self, channel: ChannelPtr, ) -> Pin<Box<dyn Future<Output = Result<FudNode>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Send a DHT ping request

fn on_new_node<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 FudNode, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Triggered when we find a new node

fn fetch_nodes<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, node: &'life1 FudNode, key: &'life2 Hash, ) -> Pin<Box<dyn Future<Output = Result<Vec<FudNode>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Send FIND NODES request to a peer to get nodes close to key

fn announce<'life0, 'life1, 'life2, 'async_trait, M>( &'life0 self, key: &'life1 Hash, message: &'life2 M, router: Arc<RwLock<HashMap<Hash, HashSet<DhtRouterItem<N>>>>>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, N: 'async_trait, M: 'async_trait + Message, Self: 'async_trait,

Announce message for a key, and add ourselves to router

fn bootstrap<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Lookup our own node id to bootstrap our DHT

fn add_node<'life0, 'async_trait>( &'life0 self, node: N, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, N: 'async_trait, Self: 'async_trait,

Add a node in the correct bucket

fn update_node<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 N, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Move a node to the tail in its bucket, to show that it is the most recently seen in the bucket. If the node is not in a bucket it will be added using add_node

fn fetch_nodes_sp<'life0, 'life1, 'async_trait>( &'life0 self, semaphore: Arc<Semaphore>, node: N, key: &'life1 Hash, ) -> Pin<Box<dyn Future<Output = (N, Result<Vec<N>, Error>)> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, N: 'async_trait, Self: 'async_trait,

Wait to acquire a semaphore, then run self.fetch_nodes. This is meant to be used in lookup_nodes.

fn lookup_nodes<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 Hash, ) -> Pin<Box<dyn Future<Output = Result<Vec<N>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Find k nodes closest to a key

fn get_channel<'life0, 'life1, 'async_trait>( &'life0 self, node: &'life1 N, topic: Option<Hash>, ) -> Pin<Box<dyn Future<Output = Result<Arc<Channel>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Get a channel (existing or create a new one) to node about topic. Don’t forget to call cleanup_channel() once you are done with it.

fn cleanup_channel<'life0, 'async_trait>( &'life0 self, channel: Arc<Channel>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Decrement the channel usage count, if it becomes 0 then set the topic to None, so that this channel is available for another task

fn add_to_router<'life0, 'life1, 'async_trait>( &'life0 self, router: Arc<RwLock<HashMap<Hash, HashSet<DhtRouterItem<N>>>>>, key: &'life1 Hash, router_items: Vec<DhtRouterItem<N>>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, N: 'async_trait, Self: 'async_trait,

Add nodes as a provider for a key