canic-host 0.111.0

Host-side App build and desired-state Fleet reconciliation library for Canic workspaces
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! Project filesystem publication failures into Host's existing I/O error boundaries.
//!
//! Retain the typed phase and cleanup cause. A visible publication is never an
//! ordinary create conflict, even when its final synchronization cause has that kind.

use ic_host_fs::durable::NamedWriteError;
use std::io;

/// Retain publication phase and cleanup evidence at Canic I/O boundaries.
#[must_use]
pub fn io_error(error: NamedWriteError<io::Error>) -> io::Error {
    let kind = match &error {
        NamedWriteError::BeforePublication { source, .. } => source.kind(),
        NamedWriteError::Producer { source, .. }
            if source.kind() != io::ErrorKind::AlreadyExists =>
        {
            source.kind()
        }
        NamedWriteError::Producer { .. } | NamedWriteError::AfterPublication { .. } => {
            io::ErrorKind::Other
        }
    };
    io::Error::new(kind, error)
}

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

    #[test]
    fn prepublication_conflict_retains_native_kind_and_cleanup_evidence() {
        let error = io_error(NamedWriteError::BeforePublication {
            source: io::ErrorKind::AlreadyExists.into(),
            cleanup_error: Some(io::ErrorKind::PermissionDenied.into()),
        });
        assert_eq!(error.kind(), io::ErrorKind::AlreadyExists);
        assert!(matches!(
            error.get_ref().unwrap().downcast_ref::<NamedWriteError<io::Error>>(),
            Some(NamedWriteError::BeforePublication { source, cleanup_error: Some(cleanup) })
                if source.kind() == io::ErrorKind::AlreadyExists
                    && cleanup.kind() == io::ErrorKind::PermissionDenied
        ));
    }

    #[test]
    fn producer_failure_cannot_be_treated_as_a_destination_conflict() {
        let error = io_error(NamedWriteError::Producer {
            source: io::ErrorKind::AlreadyExists.into(),
            cleanup_error: None,
        });
        assert_eq!(error.kind(), io::ErrorKind::Other);
        assert!(matches!(
            error.get_ref().unwrap().downcast_ref::<NamedWriteError<io::Error>>(),
            Some(NamedWriteError::Producer { source, cleanup_error: None })
                if source.kind() == io::ErrorKind::AlreadyExists
        ));
    }

    #[test]
    fn after_publication_failure_cannot_be_treated_as_a_create_conflict() {
        let error = io_error(NamedWriteError::AfterPublication {
            source: io::ErrorKind::AlreadyExists.into(),
        });
        assert_eq!(error.kind(), io::ErrorKind::Other);
        assert!(matches!(
            error.get_ref().unwrap().downcast_ref::<NamedWriteError<io::Error>>(),
            Some(NamedWriteError::AfterPublication { source })
                if source.kind() == io::ErrorKind::AlreadyExists
        ));
    }
}