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

//! API Action process-check-result
//!
//! [Official Documentation](https://icinga.com/docs/icinga-2/latest/doc/12-icinga2-api/#process-check-result)

use serde::{Deserialize, Serialize};

use crate::serde::{
    deserialize_optional_icinga_timestamp, deserialize_optional_seconds_as_duration,
    serialize_optional_duration_as_seconds, serialize_optional_icinga_timestamp,
};
use crate::types::action::StatusResponse;
use crate::types::common::{command::IcingaCommandLine, performance_data::IcingaPerformanceData};
use crate::types::enums::object_type::IcingaObjectType;
use crate::types::filter::IcingaFilter;
use crate::types::query::ResultsWrapper;
use crate::types::rest::{RestApiEndpoint, RestApiResponse};

/// REST API Endpoint for the process-check-result call
#[derive(Debug, Clone, derive_builder::Builder, Serialize, Deserialize)]
#[builder(
    build_fn(error = "crate::error::Error", validate = "Self::validate"),
    derive(Debug)
)]
pub struct ProcessCheckResult {
    ///  For services: 0=OK, 1=WARNING, 2=CRITICAL, 3=UNKNOWN
    ///  For hosts: 0=UP, 1=DOWN
    pub exit_status: u64,
    /// the plugin output without the performance data
    pub plugin_output: String,
    /// the performance data
    #[builder(default)]
    pub performance_data: Option<Vec<IcingaPerformanceData>>,
    /// the check command
    #[builder(default)]
    pub check_command: Option<IcingaCommandLine>,
    /// usually the name of the command endpoint
    #[builder(default)]
    pub check_source: Option<String>,
    /// the start time of the check command execution
    #[serde(
        serialize_with = "serialize_optional_icinga_timestamp",
        deserialize_with = "deserialize_optional_icinga_timestamp"
    )]
    pub execution_start: Option<time::OffsetDateTime>,
    /// the end time of the check command execution
    #[serde(
        serialize_with = "serialize_optional_icinga_timestamp",
        deserialize_with = "deserialize_optional_icinga_timestamp"
    )]
    pub execution_end: Option<time::OffsetDateTime>,
    /// Time-to-live duration in seconds for this check result. The next expected check result is now + ttl where freshness checks are executed.
    #[serde(
        serialize_with = "serialize_optional_duration_as_seconds",
        deserialize_with = "deserialize_optional_seconds_as_duration"
    )]
    pub ttl: Option<time::Duration>,
    /// filter to target which host and/or service this check result applies to
    #[builder(default, setter(strip_option, into))]
    #[serde(flatten)]
    filter: Option<IcingaFilter>,
}

impl ProcessCheckResult {
    /// create a new builder for this endpoint
    ///
    /// this is usually the first step to calling this REST API endpoint
    #[must_use]
    pub fn builder() -> ProcessCheckResultBuilder {
        ProcessCheckResultBuilder::default()
    }
}

impl ProcessCheckResultBuilder {
    /// makes sure the filter object type is valid for this call (either Host or Service)
    ///
    /// # Errors
    ///
    /// this returns an error if the filter field object type is not Host or Service
    pub fn validate(&self) -> Result<(), crate::error::Error> {
        if let Some(Some(filter)) = &self.filter {
            if filter.object_type != IcingaObjectType::Host
                && filter.object_type != IcingaObjectType::Service
            {
                Err(crate::error::Error::FilterObjectTypeMismatch(
                    vec![IcingaObjectType::Host, IcingaObjectType::Service],
                    filter.object_type.to_owned(),
                ))
            } else {
                Ok(())
            }
        } else {
            Ok(())
        }
    }
}

impl RestApiEndpoint for ProcessCheckResult {
    type RequestBody = ProcessCheckResult;

    fn method(&self) -> Result<http::Method, crate::error::Error> {
        Ok(http::Method::POST)
    }

    fn url(&self, base_url: &url::Url) -> Result<url::Url, crate::error::Error> {
        base_url
            .join("v1/actions/process-check-result")
            .map_err(crate::error::Error::CouldNotParseUrlFragment)
    }

    fn request_body(
        &self,
    ) -> Result<Option<std::borrow::Cow<Self::RequestBody>>, crate::error::Error>
    where
        Self::RequestBody: Clone + serde::Serialize + std::fmt::Debug,
    {
        Ok(Some(std::borrow::Cow::Borrowed(self)))
    }
}

impl RestApiResponse<ProcessCheckResult> for ResultsWrapper<StatusResponse> {}