exasol 0.3.4

Exasol client library implemented in 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

#[cfg(feature = "flate2")]
use crate::error::RequestError;
#[cfg(feature = "flate2")]
use flate2::{read::ZlibDecoder, write::ZlibEncoder, Compression};
#[cfg(feature = "flate2")]
use std::io::Write;

use super::{ReqResult, Response};
use serde_json::Value;
use std::net::TcpStream;
use tungstenite::stream::MaybeTlsStream;
use tungstenite::{Message, WebSocket};

/// Represents a wrapped Websocket with possible Zlib compression enabled
pub enum MaybeCompressedWs {
    Plain(WebSocket<MaybeTlsStream<TcpStream>>),
    #[cfg(feature = "flate2")]
    Compressed(WebSocket<MaybeTlsStream<TcpStream>>),
}

impl MaybeCompressedWs {
    /// Consumes self to return a variant that might use compression
    #[allow(unreachable_code)]
    pub fn enable_compression(self, compression: bool) -> Self {
        if compression {
            #[cfg(feature = "flate2")]
            return match self {
                Self::Plain(ws) => Self::Compressed(ws),
                Self::Compressed(ws) => Self::Compressed(ws),
            };

            // Shouldn't ever reach this, but just in case:
            panic!("Compression enabled without flate2 feature!")
        } else {
            match self {
                Self::Plain(ws) => Self::Plain(ws),
                #[cfg(feature = "flate2")]
                Self::Compressed(ws) => Self::Plain(ws),
            }
        }
    }

    pub fn send(&mut self, payload: Value) -> ReqResult<()> {
        match self {
            MaybeCompressedWs::Plain(ws) => {
                ws.write_message(Message::Text(payload.to_string()))?;
                Ok(())
            }
            #[cfg(feature = "flate2")]
            MaybeCompressedWs::Compressed(ws) => {
                let mut enc = ZlibEncoder::new(Vec::new(), Compression::default());

                let message = enc
                    .write_all(payload.to_string().as_bytes())
                    .and(enc.finish())?;

                ws.write_message(Message::Binary(message))
                    .map_err(RequestError::WebsocketError)
            }
        }
    }

    pub fn recv(&mut self) -> ReqResult<Response> {
        match self {
            MaybeCompressedWs::Plain(ws) => loop {
                break match ws.read_message()? {
                    Message::Text(resp) => Ok(serde_json::from_str::<Response>(&resp)?),
                    Message::Binary(resp) => Ok(serde_json::from_slice::<Response>(&resp)?),
                    _ => continue,
                };
            },

            #[cfg(feature = "flate2")]
            MaybeCompressedWs::Compressed(ws) => loop {
                break match ws.read_message()? {
                    Message::Text(resp) => {
                        Ok(serde_json::from_reader(ZlibDecoder::new(resp.as_bytes()))?)
                    }
                    Message::Binary(resp) => {
                        Ok(serde_json::from_reader(ZlibDecoder::new(resp.as_slice()))?)
                    }
                    _ => continue,
                };
            },
        }
    }

    pub fn as_inner(&self) -> &WebSocket<MaybeTlsStream<TcpStream>> {
        match self {
            MaybeCompressedWs::Plain(ws) => ws,
            #[cfg(feature = "flate2")]
            MaybeCompressedWs::Compressed(ws) => ws,
        }
    }

    pub fn as_inner_mut(&mut self) -> &mut WebSocket<MaybeTlsStream<TcpStream>> {
        match self {
            MaybeCompressedWs::Plain(ws) => ws,
            #[cfg(feature = "flate2")]
            MaybeCompressedWs::Compressed(ws) => ws,
        }
    }
}