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

use crate::proto::etcdserverpb;
use crate::KeyValue;
use crate::ResponseHeader;

/// Request for putting key-value.
pub struct PutRequest {
    proto: etcdserverpb::PutRequest,
}

impl PutRequest {
    /// Creates a new PutRequest for saving the specified key-value.
    pub fn new<K, V>(key: K, value: V) -> Self
    where
        K: Into<Vec<u8>>,
        V: Into<Vec<u8>>,
    {
        Self {
            proto: etcdserverpb::PutRequest {
                key: key.into(),
                value: value.into(),
                lease: 0,
                prev_kv: false,
                ignore_value: false,
                ignore_lease: false,
            },
        }
    }

    /// Sets the lease ID to associate with the key in the key-value store.
    /// A lease value of 0 indicates no lease.
    pub fn set_lease(&mut self, lease: u64) {
        self.proto.lease = lease as i64;
    }

    /// When set, responds with the key-value pair data before the update from this Put request.
    pub fn set_prev_kv(&mut self, prev_kv: bool) {
        self.proto.prev_kv = prev_kv;
    }

    /// When set, update the key without changing its current value. Returns an error if the key does not exist.
    pub fn set_ignore_value(&mut self, ignore_value: bool) {
        self.proto.ignore_value = ignore_value;
    }

    /// When set, update the key without changing its current lease. Returns an error if the key does not exist.
    pub fn set_ignore_lease(&mut self, ignore_lease: bool) {
        self.proto.ignore_lease = ignore_lease;
    }
}

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

/// Response for putting key-value.
#[derive(Debug)]
pub struct PutResponse {
    proto: etcdserverpb::PutResponse,
}

impl PutResponse {
    /// Takes the header out of response, leaving a `None` in its place.
    pub fn take_header(&mut self) -> Option<ResponseHeader> {
        match self.proto.header.take() {
            Some(header) => Some(From::from(header)),
            _ => None,
        }
    }

    /// Takes the previous key-value pair out of response, leaving a `None` in its place.
    pub fn take_prev_kv(&mut self) -> Option<KeyValue> {
        match self.proto.prev_kv.take() {
            Some(kv) => Some(From::from(kv)),
            _ => None,
        }
    }
}

impl From<etcdserverpb::PutResponse> for PutResponse {
    fn from(resp: etcdserverpb::PutResponse) -> Self {
        Self { proto: resp }
    }
}