mirror of
https://github.com/fluencelabs/rust-libp2p
synced 2025-05-06 16:12:18 +00:00
73 lines
4.2 KiB
Markdown
73 lines
4.2 KiB
Markdown
## Description
|
|
|
|
The File Sharing example demonstrates a basic file sharing application built using **libp2p**.
|
|
This example showcases how to integrate **rust-libp2p** into a larger application while providing a simple file sharing functionality.
|
|
|
|
In this application, peers in the network can either act as file providers or file retrievers.
|
|
Providers advertise the files they have available on a Distributed Hash Table (DHT) using `libp2p-kad`.
|
|
Retrievers can locate and retrieve files by their names from any node in the network.
|
|
|
|
## How it Works
|
|
|
|
Let's understand the flow of the file sharing process:
|
|
|
|
- **File Providers**: Nodes A and B serve as file providers.
|
|
Each node offers a specific file: file FA for node A and file FB for node B.
|
|
To make their files available, they advertise themselves as providers on the DHT using `libp2p-kad`.
|
|
This enables other nodes in the network to discover and retrieve their files.
|
|
|
|
- **File Retrievers**: Node C acts as a file retriever.
|
|
It wants to retrieve either file FA or FB.
|
|
Using `libp2p-kad`, it can locate the providers for these files on the DHT without being directly connected to them.
|
|
Node C connects to the corresponding provider node and requests the file content using `libp2p-request-response`.
|
|
|
|
- **DHT and Network Connectivity**: The DHT (Distributed Hash Table) plays a crucial role in the file sharing process.
|
|
It allows nodes to store and discover information about file providers.
|
|
Nodes in the network are interconnected via the DHT, enabling efficient file discovery and retrieval.
|
|
|
|
## Architectural Properties
|
|
|
|
The File Sharing application has the following architectural properties:
|
|
|
|
- **Clean and Clonable Interface**: The application provides a clean and clonable async/await interface, allowing users to interact with the network layer seamlessly.
|
|
The `Client` module encapsulates the necessary functionality for network communication.
|
|
|
|
- **Efficient Network Handling**: The application operates with a single task that drives the network layer.
|
|
This design choice ensures efficient network communication without the need for locks or complex synchronization mechanisms.
|
|
|
|
## Usage
|
|
|
|
To set up a simple file sharing scenario with a provider and a retriever, follow these steps:
|
|
|
|
1. **Start a File Provider**: In one terminal, run the following command to start a file provider node:
|
|
```sh
|
|
cargo run -- --listen-address /ip4/127.0.0.1/tcp/40837 \
|
|
--secret-key-seed 1 \
|
|
provide \
|
|
--path <path-to-your-file> \
|
|
--name <name-for-others-to-find-your-file>
|
|
```
|
|
This command initiates a node that listens on the specified address and provides a file located at the specified path.
|
|
The file is identified by the provided name, which allows other nodes to discover and retrieve it.
|
|
|
|
2. **Start a File Retriever**: In another terminal, run the following command to start a file retriever node:
|
|
```sh
|
|
cargo run -- --peer /ip4/127.0.0.1/tcp/40837/p2p/12D3KooWPjceQrSwdWXPyLLeABRXmuqt69Rg3sBYbU1Nft9HyQ6X \
|
|
get \
|
|
--name <name-for-others-to-find-your-file>
|
|
```
|
|
This command initiates a node that connects to the specified peer (the provider) and requests the file with the given name.
|
|
|
|
Note: It is not necessary for the retriever node to be directly connected to the provider.
|
|
As long as both nodes are connected to any node in the same DHT network, the file can be successfully retrieved.
|
|
|
|
This File Sharing example demonstrates the fundamental concepts of building a file sharing application using **libp2p**.
|
|
By understanding the flow and architectural properties of this example, you can leverage the power of **libp2p** to integrate peer-to-peer networking capabilities into your own applications.
|
|
|
|
## Conclusion
|
|
|
|
The File Sharing example provides a practical implementation of a basic file sharing application using **libp2p**.
|
|
By leveraging the capabilities of **libp2p**, such as the DHT and network connectivity protocols, it demonstrates how peers can share files in a decentralized manner.
|
|
|
|
By exploring and understanding the file sharing process and architectural properties presented in this example, developers can gain insights into building their own file sharing applications using **libp2p**.
|