spop 0.11.0

Library for parsing HAProxy SPOP (Stream Processing Offload Protocol)
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

use crate::{
    SpopFrame,
    frame::{FramePayload, FrameType, Metadata},
    types::TypedData,
};
use std::{borrow::Cow, collections::HashMap, convert::TryFrom};

/// Frame HAPROXY-DISCONNECT
///
/// <https://github.com/haproxy/haproxy/blob/master/doc/SPOE.txt#L956>
///
/// ```text
/// 3.2.8. Frame: HAPROXY-DISCONNECT
/// ---------------------------------
///
/// If an error occurs, at anytime, from the HAProxy side, a HAPROXY-DISCONNECT
/// frame is sent with information describing the error. HAProxy will wait an
/// AGENT-DISCONNECT frame in reply. All other frames will be ignored. The agent
/// must then close the socket.
///
/// The payload of this frame is a KV-LIST. STREAM-ID and FRAME-ID are must be set
/// 0.
///
/// Following items are mandatory in the KV-LIST:
///
///   * "status-code"    <UINT32>
///
///     This is the code corresponding to the error.
///
///   * "message"    <STRING>
///
///     This is a textual message describing the error.
/// ```
#[derive(Debug)]
pub struct HaproxyDisconnect {
    pub status_code: u32,
    pub message: String,
}

impl HaproxyDisconnect {
    #[must_use]
    pub fn to_kv_list(&self) -> HashMap<String, TypedData> {
        let mut map = HashMap::new();

        map.insert(
            "status-code".to_string(),
            TypedData::UInt32(self.status_code),
        );

        map.insert(
            "message".to_string(),
            TypedData::String(self.message.clone()),
        );

        map
    }
}

#[derive(Debug)]
pub struct HaproxyDisconnectFrame {
    pub metadata: Metadata,
    pub payload: HaproxyDisconnect,
}

impl SpopFrame for HaproxyDisconnectFrame {
    fn frame_type(&self) -> &FrameType {
        &FrameType::HaproxyDisconnect
    }

    fn metadata(&self) -> Cow<'_, Metadata> {
        Cow::Borrowed(&self.metadata)
    }

    fn payload(&self) -> FramePayload<'_> {
        FramePayload::KVList(self.payload.to_kv_list())
    }
}

impl TryFrom<FramePayload<'_>> for HaproxyDisconnect {
    type Error = String;

    fn try_from(payload: FramePayload) -> Result<Self, Self::Error> {
        // Ensure that the payload is a KVList
        if let FramePayload::KVList(kv_list) = payload {
            let status_code = kv_list
                .get("status-code")
                .and_then(|v| match v {
                    TypedData::UInt32(val) => Some(*val),
                    _ => None,
                })
                .ok_or_else(|| "Missing or invalid status_code".to_string())?;

            let message = kv_list
                .get("message")
                .and_then(|v| match v {
                    TypedData::String(val) => Some(val.clone()),
                    _ => None,
                })
                .ok_or_else(|| "Missing message".to_string())?;

            Ok(Self {
                status_code,
                message,
            })
        } else {
            Err("Invalid FramePayload type, expected KVList.".to_string())
        }
    }
}