外付けHDDの「繋ぎっぱなし」が一番危ない？
会社と家庭を守る「3-2-1-1-0バックアップ」実践ガイド

#![forbid(unsafe_code)]
use std::collections::HashSet;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MediaType {
    InternalNvme,
    ExternalUsbHdd,
    ZfsImmutablePool,
    OffsiteObjectStorage,
}

#[derive(Debug, Clone)]
pub struct BackupCopyMeta {
    pub copy_id: &'static str,
    pub media_type: MediaType,
    pub site_code: &'static str,
    pub is_offline_or_immutable: bool,
    pub last_restore_verified_unix: u64,
    pub last_restore_error_count: u32,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Rule32110Report {
    pub total_copies: usize,
    pub distinct_media: usize,
    pub distinct_sites: usize,
    pub immutable_copies: usize,
    pub restore_errors: u32,
    pub is_compliant: bool,
}

pub fn evaluate_32110_compliance(copies: &[BackupCopyMeta], now_unix: u64, max_verify_age_sec: u64) -> Rule32110Report {
    let total_copies = copies.len();
    let distinct_media: HashSet<MediaType> = copies.iter().map(|c| c.media_type).collect();
    let distinct_sites: HashSet<&str> = copies.iter().map(|c| c.site_code).collect();

    let immutable_copies = copies
        .iter()
        .filter(|c| c.is_offline_or_immutable)
        .count();

    let mut restore_errors = 0u32;
    for c in copies {
        restore_errors = restore_errors.saturating_add(c.last_restore_error_count);
        if now_unix.saturating_sub(c.last_restore_verified_unix) > max_verify_age_sec {
            restore_errors = restore_errors.saturating_add(1);
        }
    }

    let is_compliant = total_copies >= 3
        && distinct_media.len() >= 2
        && distinct_sites.len() >= 2
        && immutable_copies >= 1
        && restore_errors == 0;

    Rule32110Report {
        total_copies,
        distinct_media: distinct_media.len(),
        distinct_sites: distinct_sites.len(),
        immutable_copies,
        restore_errors,
        is_compliant,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_32110_rule_passes_only_with_immutable_and_zero_errors() {
        let now = 1_710_000_000;
        let copies = vec![
            BackupCopyMeta {
                copy_id: "prod-nvme",
                media_type: MediaType::InternalNvme,
                site_code: "osaka-hq",
                is_offline_or_immutable: false,
                last_restore_verified_unix: now - 3600,
                last_restore_error_count: 0,
            },
            BackupCopyMeta {
                copy_id: "usb-offline-week-a",
                media_type: MediaType::ExternalUsbHdd,
                site_code: "osaka-hq",
                is_offline_or_immutable: true,
                last_restore_verified_unix: now - 86_400,
                last_restore_error_count: 0,
            },
            BackupCopyMeta {
                copy_id: "remote-zfs-vault",
                media_type: MediaType::ZfsImmutablePool,
                site_code: "tokyo-dr",
                is_offline_or_immutable: true,
                last_restore_verified_unix: now - 7200,
                last_restore_error_count: 0,
            },
        ];
        let rep = evaluate_32110_compliance(&copies, now, 30 * 86_400);
        assert!(rep.is_compliant);
        assert_eq!(rep.immutable_copies, 2);
    }
}