elefant-client 0.1.0

A pure rust implementation of a postgres client that is independent of the executor runtime
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

use crate::protocol::frame_reader::ByteSliceWriter;
use std::borrow::Cow;

#[derive(Debug, PartialEq, Eq)]
pub enum FrontendPMessage<'a> {
    SASLInitialResponse(SASLInitialResponse<'a>),
    SASLResponse(SASLResponse<'a>),
    GSSResponse(GSSResponse<'a>),
    PasswordMessage(PasswordMessage<'a>),
    Undecided(UndecidedFrontendPMessage<'a>),
}

#[derive(Debug, PartialEq, Eq)]
pub struct SASLInitialResponse<'a> {
    pub mechanism: Cow<'a, str>,
    pub data: Option<&'a [u8]>,
}

#[derive(Debug, PartialEq, Eq)]
pub struct SASLResponse<'a> {
    pub data: &'a [u8],
}

#[derive(Debug, PartialEq, Eq)]
pub struct GSSResponse<'a> {
    pub data: &'a [u8],
}

#[derive(Debug, PartialEq, Eq)]
pub struct PasswordMessage<'a> {
    pub password: Cow<'a, str>,
}

#[derive(Debug, PartialEq, Eq)]
pub struct UndecidedFrontendPMessage<'a> {
    pub data: &'a [u8],
}

impl FrontendPMessage<'_> {
    pub(crate) fn write_to(&self, destination: &mut ByteSliceWriter) {
        match self {
            FrontendPMessage::SASLInitialResponse(sasl) => {
                destination.write_u8(b'p');

                let length =
                    4 + sasl.mechanism.len() + 1 + 4 + sasl.data.map(|d| d.len()).unwrap_or(0);

                destination.write_i32(length as i32);
                destination.write_null_terminated_string(&sasl.mechanism);
                if let Some(data) = sasl.data {
                    destination.write_i32(data.len() as i32);
                    destination.write_bytes(data);
                } else {
                    destination.write_i32(-1);
                }
            }
            FrontendPMessage::SASLResponse(sasl) => {
                destination.write_u8(b'p');
                destination.write_i32(4 + sasl.data.len() as i32);
                destination.write_bytes(sasl.data);
            }
            FrontendPMessage::GSSResponse(gss) => {
                destination.write_u8(b'p');
                destination.write_i32(4 + gss.data.len() as i32);
                destination.write_bytes(gss.data);
            }
            FrontendPMessage::PasswordMessage(pw) => {
                destination.write_u8(b'p');
                destination.write_i32(4 + pw.password.len() as i32 + 1);
                destination.write_null_terminated_string(&pw.password);
            }
            FrontendPMessage::Undecided(undecided) => {
                destination.write_u8(b'p');
                destination.write_i32(4 + undecided.data.len() as i32);
                destination.write_bytes(undecided.data);
            }
        }
    }
}