Method compute_delta_from_scratch

atomic-remote/src/sync.rs:692–729

Compute delta when we have no cached state (first sync). Downloads the entire changelist from position 0 and builds the cache from scratch.

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

    /// Downloads the entire changelist from position 0 and builds the
    /// cache from scratch.
    async fn compute_delta_from_scratch(
        &mut self,
        view: &str,
        local_hashes: &HashSet<String>,
    ) -> RemoteResult<RemoteDelta> {
        debug!("sync: no cache, downloading full changelist");
        self.stats.from_scratch = true;

        let remote_entries = self.remote.get_changelist(view, 0).await?;
        self.stats.changelist_entries_fetched = remote_entries.len();

        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()));

            if !local_hashes.contains(&entry.hash) {
                to_download.push(node);
            }
        }

        // Seed the cache from the full changelist
        *self.cache = RemoteState::from_changelist(&remote_entries);

        Ok(RemoteDelta {
            to_download,
            ours_ge_dichotomy: Vec::new(),
            ours_ge_dichotomy_set: HashSet::new(),
            theirs_ge_dichotomy,
            theirs_ge_dichotomy_set,
            remote_unrecords: Vec::new(),
            divergence_point: 0,
        })
    }

    // Convenience: Pull and Push