release: v0.2.0 manifest DHT reannouncement, immediate post-publish replication, 5s connect timeouts, dual-transport bootstrap, comprehensive tracing

techartdev · techartdev · commit f6174e0001d7 · 2026-03-03T14:02:30.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,7 +11,7 @@ resolver = "2"
 [workspace.package]
 edition = "2024"
 license = "MPL-2.0"
-version = "0.1.0"
+version = "0.2.0"
 repository = "https://github.com/techartdev/scp2p"
 
 [workspace.dependencies]
diff --git a/app/package-lock.json b/app/package-lock.json
diff --git a/app/package.json b/app/package.json
@@ -1,7 +1,7 @@
 {
   "name": "scp2p-app",
   "private": true,
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -29,4 +29,4 @@
     "typescript": "^5.7.0",
     "vite": "^6.0.0"
   }
-}
+}
diff --git a/app/src-tauri/tauri.conf.json b/app/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/nicegui/nicegui/main/nicegui/static/tauri/schemas/tauri-conf-v2.json",
   "productName": "SCP2P",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "identifier": "com.scp2p.desktop",
   "build": {
     "frontendDist": "../dist",
diff --git a/crates/scp2p-cli/Cargo.toml b/crates/scp2p-cli/Cargo.toml
@@ -15,7 +15,7 @@ clap = { workspace = true, features = ["env"] }
 ed25519-dalek.workspace = true
 hex.workspace = true
 rand.workspace = true
-scp2p-core = { path = "../scp2p-core", version = "0.1.0" }
+scp2p-core = { path = "../scp2p-core", version = "0.2.0" }
 tokio.workspace = true
 inquire = "0.7"
 indicatif = "0.17"
diff --git a/crates/scp2p-core/src/api/node_dht.rs b/crates/scp2p-core/src/api/node_dht.rs
@@ -379,6 +379,10 @@ impl NodeHandle {
         transport: &T,
         seed_peers: &[PeerAddr],
     ) -> anyhow::Result<usize> {
+        // Re-populate ephemeral DHT with share heads + manifests for
+        // shares we have *published*, so they survive app restarts.
+        let _ = self.reannounce_published_share_data().await;
+
         // Refresh share heads for public subscriptions so they survive
         // after the original publisher goes offline.
         let _ = self.reannounce_subscribed_share_heads().await;
diff --git a/crates/scp2p-core/src/api/node_net.rs b/crates/scp2p-core/src/api/node_net.rs
@@ -1462,4 +1462,58 @@ impl NodeHandle {
         }
         Ok(refreshed)
     }
+
+    /// Re-populate the in-memory DHT with share heads **and** manifests for
+    /// shares we have *published*.  `reannounce_subscribed_share_heads` only
+    /// covers the subscriber side (iterates `subscriptions`); this covers the
+    /// publisher side so that data survives an app restart where the ephemeral
+    /// DHT is empty.
+    pub async fn reannounce_published_share_data(&self) -> anyhow::Result<usize> {
+        let now = super::helpers::now_unix_secs()?;
+        let mut state = self.state.write().await;
+        let mut refreshed = 0usize;
+
+        // Collect keys first to avoid borrow issues.
+        let heads: Vec<([u8; 32], crate::manifest::ShareHead)> = state
+            .published_share_heads
+            .iter()
+            .map(|(k, v)| (*k, v.clone()))
+            .collect();
+
+        for (share_id, head) in heads {
+            // 1. Re-announce the share head itself.
+            let head_key = share_head_key(&ShareId(share_id));
+            let head_bytes = match crate::cbor::to_vec(&head) {
+                Ok(b) => b,
+                Err(_) => continue,
+            };
+            state
+                .dht
+                .store(head_key, head_bytes, crate::dht::DEFAULT_TTL_SECS, now)?;
+            refreshed += 1;
+
+            // 2. Re-announce the manifest so subscribers behind NAT can
+            //    fetch it from the relay / DHT.
+            let manifest_id = head.latest_manifest_id;
+            if let Some(manifest) = state.manifest_cache.get(&manifest_id) {
+                let manifest_bytes = match crate::cbor::to_vec(manifest) {
+                    Ok(b) => b,
+                    Err(_) => continue,
+                };
+                state.dht.store(
+                    manifest_loc_key(&ManifestId(manifest_id)),
+                    manifest_bytes,
+                    crate::dht::DEFAULT_TTL_SECS,
+                    now,
+                )?;
+                refreshed += 1;
+            }
+        }
+
+        if refreshed > 0 {
+            debug!(refreshed, "reannounce_published_share_data: DHT entries restored");
+        }
+
+        Ok(refreshed)
+    }
 }
diff --git a/crates/scp2p-core/src/api/tests.rs b/crates/scp2p-core/src/api/tests.rs
@@ -147,13 +147,17 @@ async fn configured_bootstrap_peers_parse_from_runtime_config() {
         .configured_bootstrap_peers()
         .await
         .expect("configured peers");
-    assert_eq!(peers.len(), 1);
+    // Primary TCP peer + QUIC fallback
+    assert_eq!(peers.len(), 2);
     assert_eq!(
         peers[0].ip,
         "127.0.0.1".parse::<std::net::IpAddr>().expect("ip")
     );
     assert_eq!(peers[0].port, 7301);
     assert_eq!(peers[0].transport, crate::peer::TransportProtocol::Tcp);
+    // Alternate QUIC variant at port - 1
+    assert_eq!(peers[1].port, 7300);
+    assert_eq!(peers[1].transport, crate::peer::TransportProtocol::Quic);
 }
 
 #[tokio::test]
@@ -172,7 +176,8 @@ async fn configured_bootstrap_peers_with_transport_prefix() {
         .configured_bootstrap_peers()
         .await
         .expect("configured peers");
-    assert_eq!(peers.len(), 3);
+    // 3 explicit + 3 alternate-transport fallbacks
+    assert_eq!(peers.len(), 6);
     assert_eq!(peers[0].transport, crate::peer::TransportProtocol::Quic);
     assert_eq!(peers[0].port, 9000);
     assert_eq!(peers[1].transport, crate::peer::TransportProtocol::Tcp);
@@ -196,7 +201,8 @@ async fn configured_bootstrap_peers_parse_pubkey_suffix() {
         .configured_bootstrap_peers()
         .await
         .expect("configured peers");
-    assert_eq!(peers.len(), 2);
+    // 2 explicit + 2 alternate-transport fallbacks
+    assert_eq!(peers.len(), 4);
     assert_eq!(peers[0].pubkey_hint, Some([0xaa; 32]));
     assert_eq!(peers[0].port, 9500);
     // Entry without pubkey suffix should have None.
diff --git a/crates/scp2p-desktop/Cargo.toml b/crates/scp2p-desktop/Cargo.toml
@@ -12,6 +12,6 @@ hex.workspace = true
 rand.workspace = true
 serde.workspace = true
 ciborium.workspace = true
-scp2p-core = { path = "../scp2p-core", version = "0.1.0" }
+scp2p-core = { path = "../scp2p-core", version = "0.2.0" }
 tokio.workspace = true
 tracing.workspace = true
diff --git a/crates/scp2p-desktop/src/app_state.rs b/crates/scp2p-desktop/src/app_state.rs
@@ -22,7 +22,7 @@ use tokio::net::UdpSocket;
 use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
 use tokio::time::{self, Duration};
-use tracing::info;
+use tracing::{info, warn};
 
 use crate::dto::{
     CommunityBrowseView, CommunityParticipantView, CommunityView, CreateCommunityResult,
@@ -49,6 +49,10 @@ struct RuntimeState {
     dht_republish_task: Option<JoinHandle<()>>,
     subscription_sync_task: Option<JoinHandle<()>>,
     last_public_shares: Vec<PublicShareView>,
+    /// Transport used for DHT replication (same instance as background loops).
+    dht_transport: Option<Arc<dyn scp2p_core::RequestTransport>>,
+    /// Bootstrap peers used for DHT replication.
+    dht_bootstrap_peers: Vec<PeerAddr>,
 }
 
 const LAN_DISCOVERY_PORT: u16 = 46123;
@@ -188,10 +192,12 @@ impl DesktopAppState {
                 DHT_LOOP_INTERVAL,
             ));
             state.subscription_sync_task = Some(handle.clone().start_subscription_sync_loop(
-                transport,
-                bootstrap,
+                transport.clone(),
+                bootstrap.clone(),
                 DHT_LOOP_INTERVAL,
             ));
+            state.dht_transport = Some(transport);
+            state.dht_bootstrap_peers = bootstrap;
         }
 
         state.node = Some(handle);
@@ -711,6 +717,26 @@ impl DesktopAppState {
             .context("node is not running")
     }
 
+    /// Fire-and-forget: run one DHT republish cycle so newly published
+    /// share heads + manifests reach the relay immediately instead of
+    /// waiting for the next background interval.
+    async fn trigger_dht_republish(&self) {
+        let (node, transport, peers) = {
+            let state = self.inner.read().await;
+            match (&state.node, &state.dht_transport) {
+                (Some(n), Some(t)) => {
+                    (n.clone(), t.clone(), state.dht_bootstrap_peers.clone())
+                }
+                _ => return,
+            }
+        };
+        tokio::spawn(async move {
+            if let Err(e) = node.dht_republish_once(transport.as_ref(), &peers).await {
+                warn!(error = %e, "immediate DHT republish after publish failed");
+            }
+        });
+    }
+
     async fn sync_peer_targets(&self, node: &NodeHandle) -> anyhow::Result<Vec<PeerAddr>> {
         let mut peers = node.configured_bootstrap_peers().await?;
         for record in node.peer_records().await {
@@ -802,6 +828,11 @@ impl DesktopAppState {
             )
             .await?;
 
+        // Immediately replicate share head + manifest to DHT peers so
+        // subscribers can discover the share without waiting for the
+        // next background republish cycle.
+        self.trigger_dht_republish().await;
+
         Ok(PublishResultView {
             share_id_hex: hex::encode(share.share_id().0),
             share_pubkey_hex: hex::encode(share.verifying_key().to_bytes()),
@@ -858,6 +889,9 @@ impl DesktopAppState {
             )
             .await?;
 
+        // Immediately replicate share head + manifest to DHT peers.
+        self.trigger_dht_republish().await;
+
         Ok(PublishResultView {
             share_id_hex: hex::encode(share.share_id().0),
             share_pubkey_hex: hex::encode(share.verifying_key().to_bytes()),
diff --git a/crates/scp2p-relay/Cargo.toml b/crates/scp2p-relay/Cargo.toml
@@ -14,7 +14,7 @@ name = "scp2p-relay"
 path = "src/main.rs"
 
 [dependencies]
-scp2p-core     = { path = "../scp2p-core", version = "0.1.0" }
+scp2p-core     = { path = "../scp2p-core", version = "0.2.0" }
 
 anyhow         = { workspace = true }
 async-trait    = { workspace = true }
diff --git a/scripts/bump-version.ps1 b/scripts/bump-version.ps1
@@ -0,0 +1,98 @@
+#!/usr/bin/env pwsh
+<#
+.SYNOPSIS
+  Bump the SCP2P version across all configuration files.
+
+.DESCRIPTION
+  Updates the version string in every place it appears:
+    - Cargo.toml           (workspace.package.version)
+    - crates/*/Cargo.toml  (scp2p-core dependency version pin)
+    - app/src-tauri/tauri.conf.json
+    - app/package.json
+    - app/package-lock.json
+
+.PARAMETER Version
+  The new semver version string, e.g. "0.2.0".
+
+.EXAMPLE
+  .\scripts\bump-version.ps1 -Version 0.2.0
+#>
+param(
+    [Parameter(Mandatory)]
+    [ValidatePattern('^\d+\.\d+\.\d+(-[\w.]+)?$')]
+    [string]$Version
+)
+
+$ErrorActionPreference = 'Stop'
+$root = Split-Path -Parent $PSScriptRoot
+
+function Replace-InFile {
+    param([string]$Path, [string]$Pattern, [string]$Replacement)
+    if (-not (Test-Path $Path)) {
+        Write-Warning "  SKIP (not found): $Path"
+        return
+    }
+    $content = Get-Content $Path -Raw
+    $updated = $content -replace $Pattern, $Replacement
+    if ($content -eq $updated) {
+        Write-Host "  UNCHANGED: $Path"
+    } else {
+        Set-Content $Path -Value $updated -NoNewline
+        Write-Host "  UPDATED:   $Path"
+    }
+}
+
+Write-Host "`nBumping SCP2P version to $Version`n" -ForegroundColor Cyan
+
+# 1. Root Cargo.toml — workspace.package.version
+Write-Host "[Cargo workspace]"
+Replace-InFile "$root\Cargo.toml" `
+    '(?m)(^\[workspace\.package\][\s\S]*?^version\s*=\s*)"[^"]*"' `
+    "`${1}`"$Version`""
+
+# 2. scp2p-core dependency version pins in sibling crates
+Write-Host "[scp2p-core dep pins]"
+$cargoFiles = Get-ChildItem "$root\crates\*\Cargo.toml" -File
+foreach ($f in $cargoFiles) {
+    Replace-InFile $f.FullName `
+        '(scp2p-core\s*=\s*\{[^}]*version\s*=\s*)"[^"]*"' `
+        "`${1}`"$Version`""
+}
+
+# 3. Tauri config
+Write-Host "[Tauri config]"
+Replace-InFile "$root\app\src-tauri\tauri.conf.json" `
+    '("version"\s*:\s*)"[^"]*"' `
+    "`${1}`"$Version`""
+
+# 4. package.json — use regex to avoid PowerShell JSON reformatting
+Write-Host "[package.json]"
+$pkgPath = "$root\app\package.json"
+Replace-InFile $pkgPath `
+    '(?m)(^\s*"version"\s*:\s*)"[^"]*"' `
+    "`${1}`"$Version`""
+
+# 5. package-lock.json — too large for ConvertFrom-Json, use regex
+Write-Host "[package-lock.json]"
+$lockPath = "$root\app\package-lock.json"
+if (Test-Path $lockPath) {
+    # Update only the top-level "version" (line 3) and the root package
+    # entry "version" (within the first ~15 lines).  The lock file's
+    # nested dependency versions must NOT be touched.
+    $lines = Get-Content $lockPath
+    $updated = 0
+    for ($i = 0; $i -lt [Math]::Min($lines.Count, 15); $i++) {
+        if ($lines[$i] -match '^\s*"version"\s*:\s*"[^"]*"') {
+            $lines[$i] = $lines[$i] -replace '("version"\s*:\s*)"[^"]*"', "`${1}`"$Version`""
+            $updated++
+        }
+    }
+    if ($updated -gt 0) {
+        $lines | Set-Content $lockPath
+        Write-Host "  UPDATED:   $lockPath ($updated occurrences)"
+    } else {
+        Write-Host "  UNCHANGED: $lockPath"
+    }
+}
+
+Write-Host "`nDone. Run 'cargo build --workspace' to verify.`n" -ForegroundColor Green

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "scp2p-app",`
`3`	`3`	`"private": true,`
`4`		`- "version": "0.1.0",`
	`4`	`+ "version": "0.2.0",`
`5`	`5`	`"type": "module",`
`6`	`6`	`"scripts": {`
`7`	`7`	`"dev": "vite",`
`@@ -29,4 +29,4 @@`
`29`	`29`	`"typescript": "^5.7.0",`
`30`	`30`	`"vite": "^6.0.0"`
`31`	`31`	`}`
`32`		`-}`
	`32`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"$schema": "https://raw.githubusercontent.com/nicegui/nicegui/main/nicegui/static/tauri/schemas/tauri-conf-v2.json",`
`3`	`3`	`"productName": "SCP2P",`
`4`		`- "version": "0.1.0",`
	`4`	`+ "version": "0.2.0",`
`5`	`5`	`"identifier": "com.scp2p.desktop",`
`6`	`6`	`"build": {`
`7`	`7`	`"frontendDist": "../dist",`