Furumi/furumi-tui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Connected Devices: fix stream finish

Browse Source
This commit is contained in:
Ultradesu
2026-07-24 01:24:18 +03:00
parent b47c271ec0
commit f85c806b43
2 changed files with 156 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/devices.rs
+136 -92
View File
@@ -222,6 +222,8 @@ enum WireMessage {
PairResponse { PairResponse {
accepted: bool, accepted: bool,
#[serde(default)] #[serde(default)]
pending: bool,
#[serde(default)]
error: Option<String>, error: Option<String>,
#[serde(default)] #[serde(default)]
group_id: Option<String>, group_id: Option<String>,
@@ -387,56 +389,74 @@ impl DeviceSync {
.ticket .ticket
.parse() .parse()
.map_err(|err| anyhow::anyhow!("malformed invite ticket: {err}"))?; .map_err(|err| anyhow::anyhow!("malformed invite ticket: {err}"))?;
let peer = service.connect(ticket).await?; let deadline = now_ms() + PAIRING_WAIT_MS;
let own_ticket = service.ticket().await?.to_string(); loop {
let profile = self.own_profile(&own_ticket)?; let peer = service.connect(ticket.clone()).await?;
let vector = self.vector()?; let own_ticket = service.ticket().await?.to_string();
let ops = self.ops_for_peer(&invite.device_id)?; let profile = self.own_profile(&own_ticket)?;
let snapshot = self.snapshot()?; let vector = self.vector()?;
let mut stream = service.open_stream(peer, SYNC_ALPN).await?; let ops = self.ops_for_peer(&invite.device_id)?;
write_msg( let snapshot = self.snapshot()?;
&mut stream, let mut stream = service.open_stream(peer, SYNC_ALPN).await?;
&WireMessage::PairRequest { write_msg(
invite_id: invite.invite_id, &mut stream,
secret: invite.secret, &WireMessage::PairRequest {
profile, invite_id: invite.invite_id.clone(),
vector, secret: invite.secret.clone(),
ops, profile,
snapshot, vector,
}, ops,
) snapshot,
.await?; },
finish_send(&mut stream).await?; )
let response = read_msg(&mut stream).await?; .await?;
match response { finish_send(&mut stream).await?;
WireMessage::PairResponse { let response = read_msg(&mut stream)
accepted: true, .await
group_id: Some(group_id), .context("pairing response was not received")?;
profile, match response {
devices, WireMessage::PairResponse {
vector, accepted: true,
ops, group_id: Some(group_id),
snapshot, profile,
.. devices,
} => { vector,
self.set_group_id(&group_id)?; ops,
if let Some(profile) = profile { snapshot,
self.apply_device_profile(&profile, false)?; ..
} => {
self.set_group_id(&group_id)?;
if let Some(profile) = profile {
self.apply_device_profile(&profile, false)?;
}
self.apply_device_profiles(&devices)?;
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.gc_tombstones()?;
return Ok(format!("connected device {}", short_id(&invite.device_id)));
} }
self.apply_device_profiles(&devices)?; WireMessage::PairResponse {
self.apply_snapshot(snapshot)?; accepted: false,
self.apply_ops(ops)?; pending: true,
self.note_peer_vector(&invite.device_id, &vector)?; ..
self.set_last_sync(Some(format!("paired with {}", short_id(&invite.device_id))))?; } => {
self.gc_tombstones()?; if now_ms() >= deadline {
Ok(format!("connected device {}", short_id(&invite.device_id))) anyhow::bail!("pairing timed out");
}
tokio::time::sleep(Duration::from_secs(1)).await;
}
WireMessage::PairResponse {
accepted: false,
error,
..
} => anyhow::bail!(error.unwrap_or_else(|| "pairing denied".to_string())),
_ => anyhow::bail!("unexpected pairing response"),
} }
WireMessage::PairResponse {
accepted: false,
error,
..
} => anyhow::bail!(error.unwrap_or_else(|| "pairing denied".to_string())),
_ => anyhow::bail!("unexpected pairing response"),
} }
} }
@@ -601,7 +621,10 @@ impl DeviceSync {
) )
.await?; .await?;
finish_send(&mut stream).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 { WireMessage::SyncResponse {
accepted: true, accepted: true,
devices, devices,
@@ -1600,6 +1623,7 @@ async fn handle_pair_request(
&mut stream, &mut stream,
&WireMessage::PairResponse { &WireMessage::PairResponse {
accepted: false, accepted: false,
pending: false,
error: Some("invalid or expired invite".to_string()), error: Some("invalid or expired invite".to_string()),
group_id: None, group_id: None,
profile: None, profile: None,
@@ -1614,11 +1638,11 @@ async fn handle_pair_request(
return Ok(()); return Ok(());
} }
profile.endpoint_id = stream.peer_id.to_string(); 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); let conn = lock(&sync.conn);
conn.execute( conn.execute(
"INSERT INTO sync_pending_pairing "INSERT OR IGNORE INTO sync_pending_pairing
(request_id, device_id, name, client_version, endpoint_id, (request_id, device_id, name, client_version, endpoint_id,
endpoint_ticket, invite_id, created_at_ms, status) endpoint_ticket, invite_id, created_at_ms, status)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'pending')", VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'pending')",
@@ -1632,9 +1656,11 @@ async fn handle_pair_request(
invite_id, invite_id,
now_ms(), 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 { let _ = tx.send(AppEvent::DevicePairingRequest(PendingPairing {
request_id: request_id.clone(), request_id: request_id.clone(),
device_id: profile.device_id.clone(), device_id: profile.device_id.clone(),
@@ -1642,24 +1668,46 @@ async fn handle_pair_request(
client_version: profile.client_version.clone(), 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( write_msg(
&mut stream, &mut stream,
&WireMessage::PairResponse { &WireMessage::PairResponse {
accepted: false, accepted: false,
error: Some("pairing denied".to_string()), pending: true,
group_id: None, error: Some("pairing pending".to_string()),
profile: None, group_id: None,
devices: Vec::new(), profile: None,
vector: BTreeMap::new(), devices: Vec::new(),
ops: Vec::new(), vector: BTreeMap::new(),
snapshot: SyncSnapshot::default(), ops: Vec::new(),
}, snapshot: SyncSnapshot::default(),
) },
.await?; )
finish_send(&mut stream).await?; .await?;
return Ok(()); 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,
devices: Vec::new(),
vector: BTreeMap::new(),
ops: Vec::new(),
snapshot: SyncSnapshot::default(),
},
)
.await?;
finish_send(&mut stream).await?;
return Ok(());
}
} }
let own_ticket = service.ticket().await?.to_string(); let own_ticket = service.ticket().await?.to_string();
@@ -1685,6 +1733,7 @@ async fn handle_pair_request(
&mut stream, &mut stream,
&WireMessage::PairResponse { &WireMessage::PairResponse {
accepted: true, accepted: true,
pending: false,
error: None, error: None,
group_id: Some(identity.group_id), group_id: Some(identity.group_id),
profile: Some(own_profile), profile: Some(own_profile),
@@ -1780,25 +1829,20 @@ async fn handle_hello(
Ok(()) 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; let conn = lock(&sync.conn);
loop { Ok(conn
let status: Option<String> = { .query_row(
let conn = lock(&sync.conn); "SELECT status FROM sync_pending_pairing WHERE request_id = ?1",
conn.query_row( [request_id],
"SELECT status FROM sync_pending_pairing WHERE request_id = ?1", |row| row.get(0),
[request_id], )
|row| row.get(0), .optional()?)
) }
.optional()?
}; fn pair_request_id(invite_id: &str, device_id: &str) -> String {
match status.as_deref() { let digest = blake3::hash(format!("{invite_id}:{device_id}").as_bytes());
Some("accepted") => return Ok(true), format!("pair_{}", &digest.to_hex()[..16])
Some("denied") => return Ok(false),
_ if now_ms() > deadline => return Ok(false),
_ => tokio::time::sleep(Duration::from_millis(500)).await,
}
}
} }
fn valid_invite(sync: &DeviceSync, invite_id: &str, secret: &str) -> Result<bool> { fn valid_invite(sync: &DeviceSync, invite_id: &str, secret: &str) -> Result<bool> {
src/federation/mod.rs
+20 -2
View File
@@ -261,6 +261,10 @@ fn unix_time_ms() -> u64 {
.unwrap_or(0) .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> { async fn dht_record_payload_bytes(data_dir: PathBuf, now_ms: u64) -> Result<u64> {
tokio::task::spawn_blocking(move || -> Result<u64> { tokio::task::spawn_blocking(move || -> Result<u64> {
let path = data_dir.join("state.sqlite3"); let path = data_dir.join("state.sqlite3");
@@ -346,7 +350,7 @@ impl Federation {
if settings.enabled { if settings.enabled {
self.start(settings.network_id.trim().to_string()).await?; self.start(settings.network_id.trim().to_string()).await?;
self.spawn_sync_soon().await; self.spawn_sync_soon().await;
} else { } else if !self.start_personal_sync_if_needed().await? {
self.stop().await; self.stop().await;
} }
Ok(()) Ok(())
@@ -361,9 +365,23 @@ impl Federation {
} else { } else {
self.spawn_sync_soon().await; 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. /// Starts the DHT node. Idempotent per network name.
async fn start(self: &Arc<Self>, network_name: String) -> Result<()> { async fn start(self: &Arc<Self>, network_name: String) -> Result<()> {
self.start_with_network_id(NetworkId::from_name(&network_name), network_name) 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> { pub async fn device_invite(self: &Arc<Self>) -> Result<String> {
if self.running.lock().await.is_none() { if self.running.lock().await.is_none() {
let status = self.devices.status(); 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()) self.start_with_network_id(NetworkId::from_name(&network_name), "device-sync".into())
.await?; .await?;
} }