fn populate()

in content-addressed-cache/src/synchronizer.rs [156:231]
71 lines of code
2 McCabe index (conditional complexity)

    fn populate(&self, keyset_id: &KeysetID, dest_cache: &dyn Cache) -> Result<PopulateResult> {
        let commit = self
            .repo
            .find_reference(&tag_fmt(&self.namespace, keyset_id))
            .context("Resolving reference")?;
        let kv_tree = commit.peel_to_tree().context("Resolving tree")?;

        let mut entry_count = 0;
        let mut new_entry_count = 0;
        let mut failed_entry_count = 0;
        for tree_entry in kv_tree.iter() {
            entry_count += 1;

            let object = match tree_entry.to_object(&self.repo) {
                Ok(object) => object,
                Err(_) => {
                    warn!(
                        "Could not find object for tree entry {:X?}",
                        tree_entry.name_bytes()
                    );
                    continue;
                }
            };
            let name = match tree_entry.name() {
                Some(name) => name,
                None => {
                    warn!("{:X?} not utf-8", tree_entry.name_bytes());
                    continue;
                }
            };
            let CompositeKey { kind, key } = match CompositeKey::from_str(name) {
                Ok(key) => key,
                Err(_) => {
                    warn!("Tree entry {} is not a composite_key", name);
                    continue;
                }
            };
            let blob = match object.as_blob() {
                Some(blob) => blob,
                None => {
                    warn!(?object, "Tree entry was not a blob");
                    continue;
                }
            };

            match dest_cache.get(kind, key) {
                Ok(Some(_)) => {
                    // Already present, do nothing.
                    continue;
                }
                Ok(None) => {
                    // Insert below.
                }
                Err(e) => {
                    // Insert below.
                    warn!(?kind, ?key, ?e, "Failed to get key from cache");
                }
            }

            match dest_cache.put(kind, key, blob.content()) {
                Ok(()) => {
                    new_entry_count += 1;
                }
                Err(e) => {
                    failed_entry_count += 1;
                    warn!(?object, ?e, "Failed to insert key into Cache");
                }
            }
        }

        Ok(PopulateResult {
            entry_count,
            new_entry_count,
            failed_entry_count,
        })
    }