libeko 0.1.5

Create a command line interface binary with some common dependencies ((clap || docopt) and error_chain)
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
118

//! curl implementation for sending `Echo Event`
use curl::easy::{Easy, List};
use echo::event::Message;
use error::Result;
use serde_json;
use std::io::Read;
use {EchoEventClient, EchoSearchClient};

/// A curl based `Echo` client.
#[derive(Debug)]
pub struct Client {
    /// 'curl' easy API
    easy: Easy,
    /// `Echo` rest endpoint
    url: String,
}

impl Client {
    /// Create a new curl based event sender.
    pub fn new() -> Result<Self> {
        let mut list = List::new();
        list.append("Content-Type: application/json")?;
        list.append(&format!(
            "User-Agent: {}/{}",
            env!("CARGO_PKG_NAME"),
            env!("CARGO_PKG_VERSION")
        ))?;
        list.append("Expect: ")?;

        let mut easy = Easy::new();
        easy.post(true)?;
        easy.http_headers(list)?;

        Ok(Self {
            easy,
            url: Default::default(),
        })
    }

    /// Set the endpoint url.
    pub fn set_url(&mut self, url: &str) -> Result<&mut Self> {
        self.easy.url(url)?;
        Ok(self)
    }

    /// Set the verbose curl flag.
    pub fn set_verbose(&mut self, verbose: bool) -> Result<&mut Self> {
        self.easy.verbose(verbose)?;
        Ok(self)
    }

    /// Set the username (i.e. for Basic Authentication)
    pub fn set_username(&mut self, username: &str) -> Result<&mut Self> {
        self.easy.username(username)?;
        Ok(self)
    }

    /// Set the password (i.e. for Basic Authentication)
    pub fn set_password(&mut self, password: &str) -> Result<&mut Self> {
        self.easy.password(password)?;
        Ok(self)
    }
}

impl EchoEventClient for Client {
    fn send_event(&mut self, messages: &[Message]) -> Result<()> {
        let mut messages_vec = &serde_json::to_vec(&messages)?[..];
        self.easy.post_field_size(messages_vec.len() as u64)?;

        {
            let mut transfer = self.easy.transfer();
            transfer.read_function(|into| Ok(messages_vec.read(into).unwrap_or(0)))?;
            transfer.perform()?;
        }

        Ok(())
    }
}

impl EchoSearchClient for Client {
    fn search(&mut self, search: &str) -> Result<String> {
        let mut search_bytes = search.as_bytes();
        self.easy.post_field_size(search_bytes.len() as u64)?;

        let mut dst = Vec::new();

        {
            let mut transfer = self.easy.transfer();
            transfer.write_function(|data| {
                dst.extend_from_slice(data);
                Ok(data.len())
            })?;
            transfer.read_function(|into| Ok(search_bytes.read(into).unwrap_or(0)))?;
            transfer.perform()?;
        }

        Ok(String::from_utf8_lossy(&dst).to_string())
    }

    fn scroll(&mut self, scroll: &str) -> Result<String> {
        let mut scroll_bytes = scroll.as_bytes();
        self.easy.post_field_size(scroll_bytes.len() as u64)?;

        let mut dst = Vec::new();

        {
            let mut transfer = self.easy.transfer();
            transfer.write_function(|data| {
                dst.extend_from_slice(data);
                Ok(data.len())
            })?;
            transfer.read_function(|into| Ok(scroll_bytes.read(into).unwrap_or(0)))?;
            transfer.perform()?;
        }

        Ok(String::from_utf8_lossy(&dst).to_string())
    }
}