Method compute_delta

atomic-remote/src/sync.rs:614–686

Compute the full `RemoteDelta` for a given view. This is the main entry point for sync operations. It: 1. Runs the dichotomy algorithm to find the divergence point 2. Downloads the remote's changelist from the divergence point 3. Compares "ours" (cached) vs "theirs" (actual) after divergence 4. Identifies changes to download, unrecords, and unknowns 5. Updates the local cache # Arguments `view

(
        &mut self,
        view: &str,
        local_hashes: &HashSet<String>,
    )

    /// * `local_hashes` - Set of change hashes present in the local repository.
    ///   Used to determine which remote changes need to be downloaded.
    pub async fn compute_delta(
        &mut self,
        view: &str,
        local_hashes: &HashSet<String>,
    ) -> RemoteResult<RemoteDelta> {
        // Handle from-scratch sync (no cache)
        if self.cache.is_empty() {
            return self.compute_delta_from_scratch(view, local_hashes).await;
        }

        // Find divergence point
        let divergence = self.dichotomy_changelist(view).await?;
        self.stats.divergence_point = divergence;

        // Collect our cached entries at or after divergence
        let ours_ge_dichotomy: Vec<(u64, Node)> = self
            .cache
            .entries_from(divergence)
            .into_iter()
            .map(|(seq, node)| (seq, node.clone()))
            .collect();

        let ours_ge_dichotomy_set: HashSet<Node> = ours_ge_dichotomy
            .iter()
            .map(|(_, node)| node.clone())
            .collect();

        // Download the remote's changelist from the divergence point
        let remote_entries = self.remote.get_changelist(view, divergence).await?;
        self.stats.changelist_entries_fetched = remote_entries.len();

        // Build "theirs" sets
        let mut theirs_ge_dichotomy = Vec::new();
        let mut theirs_ge_dichotomy_set = HashSet::new();
        let mut to_download = Vec::new();

        for entry in &remote_entries {
            let node = entry.to_node();
            theirs_ge_dichotomy_set.insert(node.clone());
            theirs_ge_dichotomy.push((entry.sequence, node.clone()));

            // Need to download if we don't have it locally
            if !local_hashes.contains(&entry.hash) {
                to_download.push(node);
            }
        }

        // Compute remote unrecords: entries in our cache that are no longer
        // on the remote. These are changes that were unrecorded remotely.
        let remote_unrecords: Vec<(u64, Node)> = ours_ge_dichotomy
            .iter()
            .filter(|(_, node)| !theirs_ge_dichotomy_set.contains(node))
            .cloned()
            .collect();

        if !remote_unrecords.is_empty() {
            debug!("sync: {} remote unrecords detected", remote_unrecords.len());
        }