etcd-rs 1.0.1

etcd client for rust
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

use crate::proto::etcdserverpb;
use crate::proto::etcdserverpb::watch_request::RequestUnion;
use crate::{Event, KeyRange, ResponseHeader};

#[derive(Debug)]
pub struct WatchCreateRequest {
    proto: crate::proto::etcdserverpb::WatchCreateRequest,
}

impl WatchCreateRequest {
    /// Creates a new WatchRequest which will subscribe events of the specified key.
    pub fn create(key_range: KeyRange) -> Self {
        Self {
            proto: etcdserverpb::WatchCreateRequest {
                key: key_range.key,
                range_end: key_range.range_end,
                start_revision: 0,
                progress_notify: false,
                filters: vec![], // TODO support filters
                prev_kv: false,
                fragment: false, // TODO support fragment
                watch_id: 0,     // TODO support watch_id
            },
        }
    }

    /// Sets the revision to watch from (inclusive). No start_revision is "now".
    pub fn start_revision(mut self, revision: i64) -> Self {
        self.proto.start_revision = revision;
        self
    }

    pub fn progress_notify(mut self) -> Self {
        self.proto.progress_notify = true;
        self
    }

    /// Sets previous key value.
    pub fn prev_kv(mut self) -> Self {
        self.proto.prev_kv = true;
        self
    }
}
impl Into<etcdserverpb::WatchCreateRequest> for WatchCreateRequest {
    fn into(self) -> etcdserverpb::WatchCreateRequest {
        self.proto
    }
}

impl Into<etcdserverpb::WatchRequest> for WatchCreateRequest {
    fn into(self) -> etcdserverpb::WatchRequest {
        etcdserverpb::WatchRequest {
            request_union: Some(RequestUnion::CreateRequest(self.into())),
        }
    }
}

impl From<KeyRange> for WatchCreateRequest {
    fn from(key_range: KeyRange) -> Self {
        Self::create(key_range)
    }
}

#[derive(Debug, Clone)]
pub struct WatchCancelRequest {
    proto: etcdserverpb::WatchCancelRequest,
}

impl WatchCancelRequest {
    /// Creates a new WatchRequest which will unsubscribe the specified watch.
    pub fn new(watch_id: i64) -> Self {
        Self {
            proto: etcdserverpb::WatchCancelRequest { watch_id },
        }
    }
}

impl From<i64> for WatchCancelRequest {
    fn from(watch_id: i64) -> Self {
        Self::new(watch_id)
    }
}

impl Into<etcdserverpb::WatchCancelRequest> for WatchCancelRequest {
    fn into(self) -> etcdserverpb::WatchCancelRequest {
        self.proto
    }
}

impl Into<etcdserverpb::WatchRequest> for WatchCancelRequest {
    fn into(self) -> etcdserverpb::WatchRequest {
        etcdserverpb::WatchRequest {
            request_union: Some(RequestUnion::CancelRequest(self.into())),
        }
    }
}

#[derive(Debug, Clone)]
pub struct WatchResponse {
    pub header: ResponseHeader,
    pub watch_id: i64,
    pub created: bool,
    pub canceled: bool,
    pub events: Vec<Event>,
}

impl From<etcdserverpb::WatchResponse> for WatchResponse {
    fn from(proto: etcdserverpb::WatchResponse) -> Self {
        Self {
            header: From::from(proto.header.expect("must fetch header")),
            watch_id: proto.watch_id,
            created: proto.created,
            canceled: proto.canceled,
            events: proto.events.into_iter().map(From::from).collect(),
        }
    }
}