routinator 0.15.1

An RPKI relying party software.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Error types used by multiple modules.
//!
//! There are two error types that are used widely within the Routinator
//! library.
//!
//! The most important is [`Failed`]. This error indicates that an
//! operation had to be canceled for some reason and callers can assume
//! that all diagnostic information has been logged and they need not do
//! anything further.
//!
//! Secondly, [`ExitError`] is used when the program should be terminated. It
//! provides enough information to determine the exit code of the program.

use log::error;


//------------ Failed --------------------------------------------------------

/// An operation has failed to complete.
///
/// This error types is used to indicate that an operation has failed,
/// diagnostic information has been printed or logged, and the caller can’t
/// really do anything to recover.
#[derive(Clone, Copy, Debug)]
pub struct Failed;

impl From<Fatal> for Failed {
    fn from(_: Fatal) -> Failed {
        Failed
    }
}


//------------ RunFailed -----------------------------------------------------

/// A validation run has failed to complete.
///
/// This error may be recoverable, which typically happens after some local
/// data corruption has been discovered and the offending was data removed. A
/// new validation run should then be started immediately to hopefully lead
/// to a success.
///
/// The error may also be fatal in which Routinator should just exit.
#[derive(Clone, Copy, Debug)]
pub struct RunFailed {
    /// Was the error fatal?
    fatal: bool,
}

impl RunFailed {
    /// Create a new fatal run failure.
    pub fn fatal() -> Self {
        RunFailed { fatal: true }
    }

    /// Create a new “retry” run failure.
    pub fn retry() -> Self {
        RunFailed { fatal: false }
    }

    /// Returns whether the error is fatal.
    pub fn is_fatal(self) -> bool {
        self.fatal
    }

    /// Returns whether the run should be retried.
    pub fn should_retry(self) -> bool {
        !self.fatal
    }
}

impl From<Fatal> for RunFailed {
    fn from(_: Fatal) -> Self {
        RunFailed::fatal()
    }
}

impl From<Failed> for RunFailed {
    fn from(_: Failed) -> Self {
        RunFailed::fatal()
    }
}


//------------ Fatal ---------------------------------------------------------

/// An operation has failed and continuing is pointless.
///
/// This error types is used to indicate that an operation has failed,
/// diagnostic information has been printed or logged, and continuing is
/// pointless or even dangerous.
#[derive(Clone, Copy, Debug)]
pub struct Fatal;

// XXX This shouldn’t be here.
impl From<Failed> for Fatal {
    fn from(_: Failed) -> Self {
        Self
    }
}


//------------ ExitError -----------------------------------------------------

/// An error happened that should lead to terminating the program.
#[derive(Clone, Copy, Debug)]
pub enum ExitError {
    /// Something has happened.
    ///
    /// This should be exit status 1.
    Generic,

    /// Incomplete update.
    ///
    /// This should be exit status 2.
    IncompleteUpdate,

    /// An object could not be validated.
    ///
    /// This should be exit status 3.
    Invalid,
}

impl From<Failed> for ExitError {
    fn from(_: Failed) -> ExitError {
        error!("Fatal error. Exiting.");
        ExitError::Generic
    }
}

impl From<RunFailed> for ExitError {
    fn from(_: RunFailed) -> ExitError {
        error!("Fatal error. Exiting.");
        ExitError::Generic
    }
}

impl From<Fatal> for ExitError {
    fn from(_: Fatal) -> ExitError {
        error!("Fatal error. Exiting.");
        ExitError::Generic
    }
}