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

use crate::*;


#[derive(Debug, Clone, Serialize, Deserialize)]
/// Page check structure
pub struct Page {
    /// Page URL
    pub url: String,

    /// Page expectations
    #[serde(default = "default_page_expectations")]
    pub expects: PageExpectations,

    /// Curl options
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<PageOptions>,
}


/// Provide own default page expectations if nothing defined in check input:
pub fn default_page_expectations() -> PageExpectations {
    vec![
        PageExpectation::ValidCode(CHECK_DEFAULT_SUCCESSFUL_HTTP_CODE),
        PageExpectation::ValidLength(CHECK_HTTP_MINIMUM_LENGHT),
        PageExpectation::ValidContent(CHECK_DEFAULT_CONTENT_EXPECTATION.to_string()),
    ]
}


/// Pages type
pub type Pages = Vec<Page>;


#[derive(Debug, Clone, Serialize, Deserialize)]
/// Page options - passed to Curl
pub struct PageOptions {
    /// HTTP headers
    #[serde(skip_serializing_if = "Option::is_none")]
    pub headers: Option<Vec<String>>,

    /// HTTP POST data (body)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub post_data: Option<Vec<String>>,

    /// HTTP cookies
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cookies: Option<Vec<String>>,

    /// HTTP follow 301/302 redirects
    #[serde(skip_serializing_if = "Option::is_none")]
    pub follow_redirects: Option<bool>,

    /// HTTP method used
    #[serde(skip_serializing_if = "Option::is_none")]
    pub method: Option<Method>,

    /// HTTP agent name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent: Option<String>,

    /// HTTP check timeout in seconds
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout: Option<u64>,

    /// HTTP connection timeout in seconds
    #[serde(skip_serializing_if = "Option::is_none")]
    pub connection_timeout: Option<u64>,

    /// HTTP connection timeout in seconds
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verbose: Option<bool>,

    /// TLS peer verification
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ssl_verify_peer: Option<bool>,

    /// TLS host verification
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ssl_verify_host: Option<bool>,
}


/// Implement JSON serialization on .to_string():
impl ToString for PageOptions {
    fn to_string(&self) -> String {
        serde_json::to_string(&self).unwrap_or_else(|_| {
            String::from("{\"status\": \"PageOptions serialization failure\"}")
        })
    }
}


impl Default for PageOptions {
    fn default() -> PageOptions {
        PageOptions {
            method: Some(Method::default()), // GET
            timeout: Some(CHECK_TIMEOUT),
            connection_timeout: Some(CHECK_CONNECTION_TIMEOUT),
            ssl_verify_peer: Some(true),
            ssl_verify_host: Some(true),
            follow_redirects: Some(true),

            agent: None,
            cookies: None,
            headers: None,
            post_data: None,
            verbose: None,
        }
    }
}


#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
/// HTTP methods allowed
pub enum Method {
    /// HTTP HEAD
    HEAD,

    /// HTTP PUT
    PUT,

    /// HTTP GET
    GET,

    /// HTTP POST
    POST,

    /// HTTP DELETE
    DELETE,
}


impl Default for Method {
    fn default() -> Method {
        Method::GET
    }
}