schema-registry-client 0.4.0

Serialize/deserialize data to/from Kafka using the Confluent Schema Registry
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

use serde::{Deserialize, Serialize};
use std::fmt;
use std::fmt::{Display, Formatter};

/// Rule : Rule
#[derive(Clone, Default, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct Rule {
    /// Rule name
    #[serde(rename = "name")]
    pub name: String,
    /// Rule doc
    #[serde(rename = "doc", skip_serializing_if = "Option::is_none")]
    pub doc: Option<String>,
    /// Rule kind
    #[serde(rename = "kind", skip_serializing_if = "Option::is_none")]
    pub kind: Option<Kind>,
    /// Rule mode
    #[serde(rename = "mode", skip_serializing_if = "Option::is_none")]
    pub mode: Option<Mode>,
    /// Rule type
    #[serde(rename = "type")]
    pub r#type: String,
    /// The tags to which this rule applies
    #[serde(rename = "tags", skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    /// Optional params for the rule
    #[serde(rename = "params", skip_serializing_if = "Option::is_none")]
    pub params: Option<std::collections::BTreeMap<String, String>>,
    /// Rule expression
    #[serde(rename = "expr", skip_serializing_if = "Option::is_none")]
    pub expr: Option<String>,
    /// Rule action on success
    #[serde(rename = "onSuccess", skip_serializing_if = "Option::is_none")]
    pub on_success: Option<String>,
    /// Rule action on failure
    #[serde(rename = "onFailure", skip_serializing_if = "Option::is_none")]
    pub on_failure: Option<String>,
    /// Whether the rule is disabled
    #[serde(rename = "disabled", skip_serializing_if = "Option::is_none")]
    pub disabled: Option<bool>,
}

impl Rule {
    /// Rule
    pub fn new(name: &str, r#type: &str) -> Rule {
        Rule {
            name: name.to_string(),
            doc: None,
            kind: None,
            mode: None,
            r#type: r#type.to_string(),
            tags: None,
            params: None,
            expr: None,
            on_success: None,
            on_failure: None,
            disabled: None,
        }
    }
}

impl Display for Rule {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "Rule {}", self.name)
    }
}

/// Rule kind
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Kind {
    #[serde(rename = "TRANSFORM")]
    Transform,
    #[serde(rename = "CONDITION")]
    Condition,
}

impl Default for Kind {
    fn default() -> Kind {
        Self::Transform
    }
}
/// Rule phase
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Phase {
    #[serde(rename = "MIGRATION")]
    Migration,
    #[serde(rename = "DOMAIN")]
    Domain,
    #[serde(rename = "ENCODING")]
    Encoding,
}

/// Rule mode
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum Mode {
    #[serde(rename = "UPGRADE")]
    Upgrade,
    #[serde(rename = "DOWNGRADE")]
    Downgrade,
    #[serde(rename = "UPDOWN")]
    UpDown,
    #[serde(rename = "WRITE")]
    Write,
    #[serde(rename = "READ")]
    Read,
    #[serde(rename = "WRITEREAD")]
    WriteRead,
}

impl Default for Mode {
    fn default() -> Mode {
        Self::WriteRead
    }
}