fn write_revset_and_delta()

in rust-create-cascade/src/main.rs [576:625]

• 47 lines of code
• 6 McCabe index (conditional complexity)

fn write_revset_and_delta(
    output_delta_dir: &Path,
    output_revset_file: &Path,
    prev_revset_file: &Path,
    revoked_dir: &Path,
    known_dir: &Path,
    reason_set: ReasonSet,
    statsd_client: Option<&statsd::Client>,
) {
    let prev_revset: HashSet<Vec<u8>> = match std::fs::read(prev_revset_file)
        .as_deref()
        .map(bincode::deserialize)
    {
        Ok(Ok(prev_revset)) => prev_revset,
        _ => {
            warn!("Could not load previous revset. Stash file will be large.");
            Default::default()
        }
    };
    let mut revset: HashSet<Vec<u8>> = HashSet::new();

    for pair in list_issuer_file_pairs(revoked_dir, known_dir).iter() {
        if let (issuer, Some(revoked_file), known_file) = pair {
            let issuer_bytes = decode_issuer(issuer.to_str().expect("non-unicode issuer string"));
            let revoked_serials: HashMap<Serial, Reason> =
                RevokedSerialAndReasonIterator::new(revoked_file, reason_set).into();
            let known_revoked_serials = KnownSerialIterator::new(known_file)
                .filter_map(|(_expiry, serial)| revoked_serials.get_key_value(&serial));
            let mut per_issuer_delta_file = File::create(output_delta_dir.join(issuer))
                .expect("could not create per-issuer delta file");
            for (serial, reason) in known_revoked_serials {
                let serial_bytes = decode_serial(serial);
                let key = crlite_key(&issuer_bytes, &serial_bytes);
                if !prev_revset.contains(&key) {
                    writeln!(per_issuer_delta_file, "{:02x}{}", (*reason) as u8, serial)
                        .expect("Could not write delta entry");
                }
                revset.insert(key);
            }
        }
    }

    let revset_bytes = bincode::serialize(&revset).unwrap();
    info!("Revset is {} bytes", revset_bytes.len());
    std::fs::write(output_revset_file, &revset_bytes).expect("can't write revset file");

    if let Some(client) = statsd_client {
        client.gauge("revset_size", revset_bytes.len() as f64);
    }
}