-Configurable node server implementation for the [`p2panda`] network which can -be embedded inside your Rust program. +`aquadoggo` is a reference node implementation for [p2panda](https://p2panda.org). It is a intended as a tool for making the design and build of local-first, collaborative p2p applications as simple as possible, and hopefully even a little fun! -> The core p2panda [`specification`] is fully functional but still under review so -> please be prepared for breaking API changes until we reach v1.0. Currently no -> p2panda implementation has recieved a security audit. +`aquadoggo` can run both on your own device for local-first applications, or on a public server when acting as shared community infrastructure. Nodes like `aquadoggo` perform a number of tasks ranging from core p2panda data replication and validation, aiding the discovery and establishment of connections between edge peers, and exposing a developer friendly API used for building applications. -[`p2panda`]: https://p2panda.org -[`specification`]: https://p2panda.org/specification +> 📖 Read more about nodes in our [learn](https://p2panda.org/learn/networks) section
+> 🐬 Visit the main repo [README](https://github.com/p2panda/aquadoggo) for more general info ## Features @@ -59,15 +56,24 @@ be embedded inside your Rust program. - Verifies the consistency, format and signature of operations and rejects invalid ones. - Stores operations of the network in an SQL database of your choice (SQLite, PostgreSQL). - Materializes views on top of the known data. -- Answers filterable and paginated data queries via GraphQL. +- Answers filtered, sorted and paginated data queries via GraphQL. - Discovers other nodes in local network and internet. -- Replicates data with other nodes. +- Establishes peer-to-peer connections via UDP holepunching or via relays. +- Replicates data efficiently with other nodes. + +## Installation + +For using `aquadoggo` in your Rust project, you can add it as a dependency with the following command: + +```bash +cargo add aquadoggo +``` ## Example -Embed the node server in your Rust application or web container like [`Tauri`]: +Run the node directly next to the frontend you're building for full peer-to-peer applications. Check out our [Tauri](https://github.com/p2panda/tauri-example) example for writing a desktop app. -```rust +```rust,ignore use aquadoggo::{Configuration, Node}; use p2panda_rs::identity::KeyPair; @@ -76,17 +82,13 @@ let key_pair = KeyPair::new(); let node = Node::start(key_pair, config).await; ``` -[`Tauri`]: https://tauri.studio - -## Installation +### FFI bindings -With [`cargo-edit`](https://github.com/killercup/cargo-edit) installed run: +If you are not working with Rust you can create FFI bindings from the `aquadoggo` crate into your preferred programming language. Dealing with FFI bindings can be a bit cumbersome and we do not have much prepared for you (yet), but check out our [Meli](https://github.com/p2panda/meli/) Android project as an example on how we dealt with FFI bindings for Dart / Flutter. -```bash -$ cargo add aquadoggo -``` +### Command line application -[`cargo-edit`]: https://github.com/killercup/cargo-edit +Check out our [Releases](/releases) section where we publish binaries for Linux, RaspberryPi, MacOS and Windows. ## Development @@ -107,8 +109,9 @@ GNU Affero General Public License v3.0 [`AGPL-3.0-or-later`](LICENSE) ## Supported by
+
*This project has received funding from the European Union’s Horizon 2020
research and innovation programme within the framework of the NGI-POINTER
-Project funded under grant agreement No 871528*
+Project funded under grant agreement No 871528 and NGI-ASSURE No 957073*
diff --git a/aquadoggo/src/lib.rs b/aquadoggo/src/lib.rs
index 2c4eb447f..c7dc93919 100644
--- a/aquadoggo/src/lib.rs
+++ b/aquadoggo/src/lib.rs
@@ -1,38 +1,6 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
-//! # aquadoggo
-//!
-//! Configurable node server implementation for the [`p2panda`] network.
-//!
-//! [`p2panda`]: https://p2panda.org
-//!
-//! ## Features
-//!
-//! - Awaits signed operations from clients via GraphQL.
-//! - Verifies the consistency, format and signature of operations and rejects invalid ones.
-//! - Stores operations of the network in an SQL database of your choice (SQLite, PostgreSQL).
-//! - Materializes views on top of the known data.
-//! - Answers filterable and paginated data queries via GraphQL.
-//! - Discovers other nodes in local network and internet.
-//! - Replicates data with other nodes.
-//!
-//! ## Example
-//!
-//! Embed the node server in your Rust application or web container like [`Tauri`]:
-//!
-//! ```rust,no_run
-//! # #[tokio::main]
-//! # async fn main() {
-//! use aquadoggo::{Configuration, Node};
-//! use p2panda_rs::identity::KeyPair;
-//!
-//! let config = Configuration::default();
-//! let key_pair = KeyPair::new();
-//! let node = Node::start(key_pair, config).await;
-//! # }
-//! ```
-//!
-//! [`Tauri`]: https://tauri.studio
+#![doc = include_str!("../README.md")]
#![warn(
missing_debug_implementations,
missing_docs,
diff --git a/aquadoggo/src/network/peers/message.rs b/aquadoggo/src/network/peers/message.rs
index 6f1c98ea6..584ee2b0c 100644
--- a/aquadoggo/src/network/peers/message.rs
+++ b/aquadoggo/src/network/peers/message.rs
@@ -1,11 +1,19 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
+use p2panda_rs::entry::{EncodedEntry, LogId, SeqNum};
+use p2panda_rs::identity::PublicKey;
+use p2panda_rs::operation::EncodedOperation;
+use p2panda_rs::Validate;
+use serde::de::Visitor;
use serde::{Deserialize, Serialize};
-use crate::replication::{AnnouncementMessage, SyncMessage};
+use crate::replication::{
+ Announcement, AnnouncementMessage, Message, Mode, SchemaIdSet, SessionId, SyncMessage,
+ ANNOUNCE_TYPE, ENTRY_TYPE, HAVE_TYPE, SYNC_DONE_TYPE, SYNC_REQUEST_TYPE,
+};
/// p2panda protocol messages which can be sent over the wire.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(untagged)]
pub enum PeerMessage {
/// Announcement of peers about the schema ids they are interest in.
@@ -14,3 +22,242 @@ pub enum PeerMessage {
/// Replication status and data exchange.
SyncMessage(SyncMessage),
}
+
+impl<'de> Deserialize<'de> for PeerMessage {
+ fn deserializeaquadoggo CLI
-Node server with GraphQL API for the p2panda network. +
+ p2panda network node
+
+
++ +
+
+
++ + Releases + + | + + Contribute + + | + + Website + +
++ +Configurable node for the [`p2panda`] network, which runs as a command line +application on any computer, single-board or server. + +## Installation + +### Pre-compiled binaries + +Check out our [Releases](/releases) section where we publish binaries for +Linux, RaspberryPi, MacOS and Windows. + +### Compile it yourself + +For the following steps you need a +[Rust](https://www.rust-lang.org/learn/get-started) development environment on +your machine. + +```bash +# Download source code +git clone https://github.com/p2panda/aquadoggo.git +cd aquadoggo + +# Compile binary +cargo build --release + +# Copy binary into your path (example) +cp ./target/release/aquadoggo ~/.local/bin +``` + +## Examples + +```bash +# For experimental setups it is enough to just start the node! +aquadoggo + +# Enable logging +aquadoggo --log-level info + +# By default the config.toml is loaded from the same folder or from the XDG +# config directory, but you can also specify a custom path +aquadoggo -c ../config.toml + +# Turn your aquadoggo into a relay +aquadoggo --relay-mode + +# Check out the config.toml file for more options or consult the help menu. You +# might need it for more sophisticated setups +aquadoggo --help +``` + +## Usage + +`aquadoggo` is a powerful node implementation which can run in very different +setups during development and in production. It can be configured through a +[`config.toml`] file, environment variables and command line arguments, +depending on your needs. + +### Common setups + +#### Support only certain schemas + +> "I want to run a node which only replicates and serves data from a limited +> set of schemas. In this case it's schemas required by a mushroom sighting +> app." + +```toml +allow_schema_ids = [ + "mushroom_0020c3accb0b0c8822ecc0309190e23de5f7f6c82f660ce08023a1d74e055a3d7c4d", + "mushroom_finding_0020aaabb3edecb2e8b491b0c0cb6d7d175e4db0e9da6003b93de354feb9c52891d0" +] +``` + +#### Support all schemas but restrict allowed peers + +> "Me and my friends are running our own `p2panda` network supported by a +> couple of relay nodes, we trust each other and want to support all published +> data, but not allow anyone else to join the network." + +```toml +# I can do this by configuring `allow_schema_ids` to be a wildcard, meaning any +# schema are automatically supported! +allow_schema_ids = "*" + +# Add relay addresses to allow establishing connections over the internet +relay_addresses = [ + "203.0.113.12:2022", + "203.0.113.34:2022", +] + +# Enable discovery using mDNS (true by default) +mdns = true + +# Populate an allow list which will contain the peer ids of our friends +# (including the ones acting as relays) +allow_peer_ids = [ + "12D3KooWLxGKMgUtekXam9JsSjMa3b7M3rYEYUYUywdehHTRrLgU", + "12D3KooWP1ahRHeNp6s1M9qDJD2oyqRsYFeKLYjcjmFxrq6KM8xd", +] +``` + +#### Act as a relay node + +> "I want to deploy a relay which assists in connecting edge peers but doesn't +> persist any data itself." + +```toml +# I can do this by configuring `allow_schema_ids` an empty list, meaning this +# node does not support any schemas +allow_schema_ids = [] + +# Then set the relay flag so this node behaves as a relay for other nodes +relay_mode = true +``` + +#### Directly connect to known peers + +> "I want my node to connect to a list of known and accessible peers." + +```toml +# Allow all schemas +allow_schema_ids = "*" + +# Address of nodes with static IP addresses we can connect directly to +direct_node_addresses = [ + "192.0.2.78:2022", + "198.51.100.22:2022", + "192.0.2.211:2022", + "203.0.114.123:2022", +] +``` + +#### Persist node identity and database + +> "I want my node to persist it's identity and database on the filesystem and +> retreive them whenever it runs again." + +```toml +# Persist node private key at given location (using Linux XDG paths as an example) +private_key = "$HOME/.local/share/aquadoggo/private-key.txt" + +# Persist SQLite database at given location +database_url = "sqlite:$HOME/.local/share/aquadoggo/db.sqlite3" +``` + +### Configuration + +Check out the [`config.toml`] file for all configurations and documentation or +run `--help` to see all possible command line arguments. All values can also be +defined as environment variables, written in CAMEL_CASE (for example +`HTTP_PORT=3000`). + +``` +Usage: aquadoggo [OPTIONS] + +Options: + -c, --config
+
-*This project has received funding from the European Union’s Horizon 2020 research and innovation programme within the framework of the NGI-POINTER Project funded under grant agreement No 871528*
+*This project has received funding from the European Union’s Horizon 2020
+research and innovation programme within the framework of the NGI-POINTER
+Project funded under grant agreement No 871528 and NGI-ASSURE No 957073*
+
+[`config.toml`]: config.toml
+[`p2panda`]: https://p2panda.org
diff --git a/aquadoggo_cli/src/config.rs b/aquadoggo_cli/src/config.rs
index c8e999dff..6de928a19 100644
--- a/aquadoggo_cli/src/config.rs
+++ b/aquadoggo_cli/src/config.rs
@@ -67,8 +67,8 @@ pub fn load_config() -> Result<(ConfigFilePath, Configuration)> {
/// been set.
#[derive(Parser, Serialize, Debug)]
#[command(
- name = "aquadoggo Node",
- about = "Node server for the p2panda network",
+ name = "aquadoggo",
+ about = "Node for the p2panda network",
long_about = None,
version
)]
@@ -230,6 +230,17 @@ struct Cli {
)]
#[serde(skip_serializing_if = "Option::is_none")]
relay_mode: Option