bvandeusenandClaude Opus 5
0a7480cf9b
Android becomes a native Kotlin client over this same code (Scribe note 2730), so
the local store and sync engine stop being modules of the desktop app and become
`thoughtsync-core`, a crate with no UI framework in it at all.
This is a move, not a rewrite, and the measurement is why: every file in local/
and sync/ already carried ZERO Tauri references — 4,980 of 6,372 lines. The
coupling was 473 lines of command shim, which stays behind in the desktop crate
as src/commands/. Kept as git renames so history follows the files.
The desktop imports them under their old names (`use thoughtsync_core::{local,
sync}`) so every call site reads exactly as before. What moved is where they
live, not what they are.
Two things a workspace changes that are easy to miss, both caught before pushing:
[profile.release] now lives at the workspace ROOT. Cargo silently ignores
profiles declared by a non-root member — leaving it in the desktop crate would
have dropped lto/strip/opt-level from every release build with only a warning.
And a workspace shares ONE target dir, so the bundles moved from
desktop/src-tauri/target to target/. Thirteen references across publish-release,
debundle-graphics, verify.sh, package-prebuilt and the workflow now point there.
Pinning target-dir back would have been the smaller diff, but the Android lane
also produces Rust artifacts and they do not belong under desktop/.
Also retires the Tauri Android lane in the same push rather than leaving a path
that is being replaced: gen/android, android.yml and docs/android-dev.md are
gone, the mobile_entry_point attribute with them, and the lib drops to rlib —
staticlib/cdylib existed for Tauri mobile, and the .so Android loads will be
built from the core crate instead. Rule 22, no parallel path.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
78 lines
3.0 KiB
Rust
78 lines
3.0 KiB
Rust
//! The sync cycle (M10.7c).
|
|
//!
|
|
//! Deliberately the ONLY way the UI can sync. Push and pull are each usable on their
|
|
//! own inside this crate, but exposing them separately would let a caller pull
|
|
//! without pushing, which quietly overwrites unsent local edits.
|
|
|
|
use chrono::{SecondsFormat, Utc};
|
|
use serde::Serialize;
|
|
|
|
use super::blobs::BlobStore;
|
|
use super::pull;
|
|
use super::push;
|
|
use super::state;
|
|
use crate::local::Db;
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct SyncOutcome {
|
|
pub push: push::PushSummary,
|
|
pub pull: pull::PullSummary,
|
|
/// The state after the cycle, so the UI updates from one round-trip instead of
|
|
/// following every sync with a status call.
|
|
pub status: state::Status,
|
|
}
|
|
|
|
/// Push, then pull — in that order, always.
|
|
///
|
|
/// Pull writes the server's version straight over the local row, so anything not yet
|
|
/// sent would be lost to it. Pushing first is what puts the local edit in front of
|
|
/// the server's last-write-wins comparison, and it's the reason
|
|
/// `PullSummary::clobbered_dirty` should be zero on every healthy cycle.
|
|
///
|
|
/// A failed push aborts before the pull. Pulling anyway would take the exact rows we
|
|
/// just failed to save and overwrite them — turning a recoverable network error into
|
|
/// lost work.
|
|
pub async fn run_cycle(
|
|
db: &Db,
|
|
blobs: &BlobStore,
|
|
base_url: &str,
|
|
token: &str,
|
|
) -> Result<SyncOutcome, String> {
|
|
let push = push::run(db, base_url, token).await?;
|
|
let pull = pull::run(db, blobs, base_url, token).await?;
|
|
|
|
if pull.clobbered_dirty > 0 {
|
|
// Push ran first and reported success, so nothing should still have been
|
|
// dirty. Reaching here means something wrote to the store mid-cycle, or a
|
|
// change never got collected — worth a loud line either way.
|
|
log::warn!(
|
|
"sync cycle overwrote {} locally-edited note(s) despite pushing first",
|
|
pull.clobbered_dirty
|
|
);
|
|
}
|
|
|
|
// While we're already talking to this server, re-read what it says about itself.
|
|
// Today that's the trash-retention window the Trash view counts down against, and
|
|
// it can change under us whenever an admin edits the setting. Best-effort on
|
|
// purpose: a config blip must not fail a cycle whose actual work already
|
|
// succeeded, and the stored value simply stays as it was.
|
|
let retention = super::client::probe(base_url)
|
|
.await
|
|
.ok()
|
|
.and_then(|p| p.server.trash_retention_days);
|
|
|
|
let status = {
|
|
let conn = db.0.lock().map_err(|e| e.to_string())?;
|
|
if let Some(days) = retention {
|
|
state::set_server_retention(&conn, days as i64).map_err(|e| e.to_string())?;
|
|
}
|
|
// Stamped only here, after BOTH halves succeeded. A timestamp written after a
|
|
// partial cycle would tell the user they're up to date when they aren't.
|
|
let now = Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);
|
|
state::mark_synced(&conn, &now).map_err(|e| e.to_string())?;
|
|
state::status(&conn).map_err(|e| e.to_string())?
|
|
};
|
|
|
|
Ok(SyncOutcome { push, pull, status })
|
|
}
|