Connected Devices: fix stream finish

src/devices.rs

@@ -222,6 +222,8 @@ enum WireMessage {
     PairResponse {
         accepted: bool,
         #[serde(default)]
+        pending: bool,
+        #[serde(default)]
         error: Option<String>,
         #[serde(default)]
         group_id: Option<String>,
@@ -387,7 +389,9 @@ impl DeviceSync {
             .ticket
             .parse()
             .map_err(|err| anyhow::anyhow!("malformed invite ticket: {err}"))?;
-        let peer = service.connect(ticket).await?;
+        let deadline = now_ms() + PAIRING_WAIT_MS;
+        loop {
+            let peer = service.connect(ticket.clone()).await?;
             let own_ticket = service.ticket().await?.to_string();
             let profile = self.own_profile(&own_ticket)?;
             let vector = self.vector()?;
@@ -397,8 +401,8 @@ impl DeviceSync {
             write_msg(
                 &mut stream,
                 &WireMessage::PairRequest {
-                invite_id: invite.invite_id,
+                    invite_id: invite.invite_id.clone(),
-                secret: invite.secret,
+                    secret: invite.secret.clone(),
                     profile,
                     vector,
                     ops,
@@ -407,7 +411,9 @@ impl DeviceSync {
             )
             .await?;
             finish_send(&mut stream).await?;
-        let response = read_msg(&mut stream).await?;
+            let response = read_msg(&mut stream)
+                .await
+                .context("pairing response was not received")?;
             match response {
                 WireMessage::PairResponse {
                     accepted: true,
@@ -427,9 +433,22 @@ impl DeviceSync {
                     self.apply_snapshot(snapshot)?;
                     self.apply_ops(ops)?;
                     self.note_peer_vector(&invite.device_id, &vector)?;
-                self.set_last_sync(Some(format!("paired with {}", short_id(&invite.device_id))))?;
+                    self.set_last_sync(Some(format!(
+                        "paired with {}",
+                        short_id(&invite.device_id)
+                    )))?;
                     self.gc_tombstones()?;
-                Ok(format!("connected device {}", short_id(&invite.device_id)))
+                    return Ok(format!("connected device {}", short_id(&invite.device_id)));
+                }
+                WireMessage::PairResponse {
+                    accepted: false,
+                    pending: true,
+                    ..
+                } => {
+                    if now_ms() >= deadline {
+                        anyhow::bail!("pairing timed out");
+                    }
+                    tokio::time::sleep(Duration::from_secs(1)).await;
                 }
                 WireMessage::PairResponse {
                     accepted: false,
@@ -439,6 +458,7 @@ impl DeviceSync {
                 _ => anyhow::bail!("unexpected pairing response"),
             }
         }
+    }
 
     pub fn answer_pairing(&self, request_id: &str, accept: bool) -> Result<()> {
         let conn = lock(&self.conn);
@@ -601,7 +621,10 @@ impl DeviceSync {
         )
         .await?;
         finish_send(&mut stream).await?;
-        match read_msg(&mut stream).await? {
+        match read_msg(&mut stream)
+            .await
+            .context("device sync response was not received")?
+        {
             WireMessage::SyncResponse {
                 accepted: true,
                 devices,
@@ -1600,6 +1623,7 @@ async fn handle_pair_request(
             &mut stream,
             &WireMessage::PairResponse {
                 accepted: false,
+                pending: false,
                 error: Some("invalid or expired invite".to_string()),
                 group_id: None,
                 profile: None,
@@ -1614,11 +1638,11 @@ async fn handle_pair_request(
         return Ok(());
     }
     profile.endpoint_id = stream.peer_id.to_string();
-    let request_id = format!("pair_{}", random_hex(8));
+    let request_id = pair_request_id(&invite_id, &profile.device_id);
-    {
+    let inserted = {
         let conn = lock(&sync.conn);
         conn.execute(
-            "INSERT INTO sync_pending_pairing
+            "INSERT OR IGNORE INTO sync_pending_pairing
                 (request_id, device_id, name, client_version, endpoint_id,
                  endpoint_ticket, invite_id, created_at_ms, status)
              VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'pending')",
@@ -1632,9 +1656,11 @@ async fn handle_pair_request(
                 invite_id,
                 now_ms(),
             ],
-        )?;
+        )?
-    }
+    };
-    if let Some(tx) = lock(&sync.event_tx).as_ref() {
+    if inserted > 0
+        && let Some(tx) = lock(&sync.event_tx).as_ref()
+    {
         let _ = tx.send(AppEvent::DevicePairingRequest(PendingPairing {
             request_id: request_id.clone(),
             device_id: profile.device_id.clone(),
@@ -1642,12 +1668,33 @@ async fn handle_pair_request(
             client_version: profile.client_version.clone(),
         }));
     }
-    let accepted = wait_pairing_answer(&sync, &request_id).await?;
+    match pairing_status(&sync, &request_id)?.as_deref() {
-    if !accepted {
+        Some("pending") => {
             write_msg(
                 &mut stream,
                 &WireMessage::PairResponse {
                     accepted: false,
+                    pending: true,
+                    error: Some("pairing pending".to_string()),
+                    group_id: None,
+                    profile: None,
+                    devices: Vec::new(),
+                    vector: BTreeMap::new(),
+                    ops: Vec::new(),
+                    snapshot: SyncSnapshot::default(),
+                },
+            )
+            .await?;
+            finish_send(&mut stream).await?;
+            return Ok(());
+        }
+        Some("accepted") => {}
+        _ => {
+            write_msg(
+                &mut stream,
+                &WireMessage::PairResponse {
+                    accepted: false,
+                    pending: false,
                     error: Some("pairing denied".to_string()),
                     group_id: None,
                     profile: None,
@@ -1661,6 +1708,7 @@ async fn handle_pair_request(
             finish_send(&mut stream).await?;
             return Ok(());
         }
+    }
 
     let own_ticket = service.ticket().await?.to_string();
     let own_profile = sync.own_profile(&own_ticket)?;
@@ -1685,6 +1733,7 @@ async fn handle_pair_request(
         &mut stream,
         &WireMessage::PairResponse {
             accepted: true,
+            pending: false,
             error: None,
             group_id: Some(identity.group_id),
             profile: Some(own_profile),
@@ -1780,25 +1829,20 @@ async fn handle_hello(
     Ok(())
 }
 
-async fn wait_pairing_answer(sync: &DeviceSync, request_id: &str) -> Result<bool> {
+fn pairing_status(sync: &DeviceSync, request_id: &str) -> Result<Option<String>> {
-    let deadline = now_ms() + PAIRING_WAIT_MS;
-    loop {
-        let status: Option<String> = {
     let conn = lock(&sync.conn);
-            conn.query_row(
+    Ok(conn
+        .query_row(
             "SELECT status FROM sync_pending_pairing WHERE request_id = ?1",
             [request_id],
             |row| row.get(0),
         )
-            .optional()?
+        .optional()?)
-        };
-        match status.as_deref() {
-            Some("accepted") => return Ok(true),
-            Some("denied") => return Ok(false),
-            _ if now_ms() > deadline => return Ok(false),
-            _ => tokio::time::sleep(Duration::from_millis(500)).await,
-        }
 }
+
+fn pair_request_id(invite_id: &str, device_id: &str) -> String {
+    let digest = blake3::hash(format!("{invite_id}:{device_id}").as_bytes());
+    format!("pair_{}", &digest.to_hex()[..16])
 }
 
 fn valid_invite(sync: &DeviceSync, invite_id: &str, secret: &str) -> Result<bool> {

src/federation/mod.rs

@@ -261,6 +261,10 @@ fn unix_time_ms() -> u64 {
         .unwrap_or(0)
 }
 
+fn personal_sync_network_name(group_id: &str) -> String {
+    format!("furumi-device-sync:{group_id}")
+}
+
 async fn dht_record_payload_bytes(data_dir: PathBuf, now_ms: u64) -> Result<u64> {
     tokio::task::spawn_blocking(move || -> Result<u64> {
         let path = data_dir.join("state.sqlite3");
@@ -346,7 +350,7 @@ impl Federation {
         if settings.enabled {
             self.start(settings.network_id.trim().to_string()).await?;
             self.spawn_sync_soon().await;
-        } else {
+        } else if !self.start_personal_sync_if_needed().await? {
             self.stop().await;
         }
         Ok(())
@@ -361,9 +365,23 @@ impl Federation {
             } else {
                 self.spawn_sync_soon().await;
             }
+        } else if let Err(err) = self.start_personal_sync_if_needed().await {
+            tracing::error!("device-sync autostart failed: {err:#}");
+            self.set_error(Some(format!("device sync autostart failed: {err}")));
         }
     }
 
+    async fn start_personal_sync_if_needed(self: &Arc<Self>) -> Result<bool> {
+        let status = self.devices.status();
+        if status.active_devices <= 1 {
+            return Ok(false);
+        }
+        let network_name = personal_sync_network_name(&status.group_id);
+        self.start_with_network_id(NetworkId::from_name(&network_name), "device-sync".into())
+            .await?;
+        Ok(true)
+    }
+
     /// Starts the DHT node. Idempotent per network name.
     async fn start(self: &Arc<Self>, network_name: String) -> Result<()> {
         self.start_with_network_id(NetworkId::from_name(&network_name), network_name)
@@ -908,7 +926,7 @@ impl Federation {
     pub async fn device_invite(self: &Arc<Self>) -> Result<String> {
         if self.running.lock().await.is_none() {
             let status = self.devices.status();
-            let network_name = format!("furumi-device-sync:{}", status.group_id);
+            let network_name = personal_sync_network_name(&status.group_id);
             self.start_with_network_id(NetworkId::from_name(&network_name), "device-sync".into())
                 .await?;
         }