zookeeper-client 0.11.1

ZooKeeper async client
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

mod acl;
mod auth;
mod check;
mod connect;
mod consts;
mod data;
mod error_code;
mod multi;
mod op_code;
mod path;
mod reconfig;
mod reply_header;
mod request_header;
mod stat;

use bytes::BufMut;

pub use self::acl::{GetAclResponse, SetAclRequest};
pub use self::auth::AuthPacket;
pub use self::check::CheckVersionRequest;
pub use self::connect::{ConnectRequest, ConnectResponse};
pub use self::consts::{AddWatchMode, PredefinedXid};
pub use self::data::{
    CreateRequest,
    DeleteRequest,
    ExistsRequest,
    GetChildren2Response,
    GetChildrenRequest,
    GetRequest,
    PersistentWatchRequest,
    RemoveWatchesRequest,
    SetDataRequest,
    SetWatchesRequest,
    SyncRequest,
};
pub use self::error_code::ErrorCode;
pub use self::multi::{MultiHeader, MultiReadResponse, MultiWriteResponse};
pub use self::op_code::OpCode;
pub use self::reconfig::{EnsembleUpdate, ReconfigRequest};
pub use self::reply_header::ReplyHeader;
pub use self::request_header::RequestHeader;
pub use self::stat::Stat;
use super::record::{DynamicRecord, SerializableRecord};
use crate::record::Record;

pub trait RequestBuffer {
    fn write_request(&mut self, header: &RequestHeader, record: &dyn Record) -> usize;
    fn write_length_prefixed_record(&mut self, record: &dyn Record) -> usize;

    fn prepare_and_reserve(&mut self, n: usize);
    fn append_record(&mut self, record: &dyn Record);
    fn append_record2(&mut self, record1: &dyn Record, record2: &dyn Record);
    fn finish(&mut self);
}

#[allow(clippy::uninit_vec)]
impl RequestBuffer for Vec<u8> {
    fn write_request(&mut self, header: &RequestHeader, record: &dyn Record) -> usize {
        let i = self.len();
        self.reserve(4);
        unsafe { self.set_len(i + 4) };
        header.serialize(self);
        record.serialize(self);
        let len = self.len() - i - 4;
        let mut buf = &mut self[i..i + 4];
        buf.put_i32(len as i32);
        len + 4
    }

    fn write_length_prefixed_record(&mut self, record: &dyn Record) -> usize {
        let i = self.len();
        self.reserve(4);
        unsafe { self.set_len(i + 4) };
        record.serialize(self);
        let len = self.len() - i - 4;
        let mut buf = &mut self[i..i + 4];
        buf.put_i32(len as i32);
        len + 4
    }

    fn prepare_and_reserve(&mut self, n: usize) {
        self.reserve(n + 4);
        self.put_i32(0);
    }

    fn append_record(&mut self, record: &dyn Record) {
        self.reserve(record.serialized_len());
        record.serialize(self);
    }

    fn append_record2(&mut self, record1: &dyn Record, record2: &dyn Record) {
        self.reserve(record1.serialized_len() + record2.serialized_len());
        record1.serialize(self);
        record2.serialize(self);
    }

    fn finish(&mut self) {
        let n = (self.len() - 4) as i32;
        (&mut self[0..4]).put_i32(n);
    }
}

pub fn build_record_request(record: &dyn Record) -> Vec<u8> {
    let mut buf = Vec::with_capacity(record.serialized_len() + 4);
    buf.write_length_prefixed_record(record);
    buf
}

pub fn build_session_request(header: &RequestHeader, body: &dyn Record) -> Vec<u8> {
    let mut buf = Vec::with_capacity(header.serialized_len() + body.serialized_len() + 4);
    buf.write_request(header, body);
    buf
}