humbird 0.1.4

humbird network communication core library,universal server function wrapper library
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

use tokio::{io::AsyncWriteExt, net::TcpStream};

use crate::protocol::http::{Request, Response};

/// proxy target host address list
pub static mut PROXY_TARGET: Vec<String> = vec![];

/// load balancing mode
#[derive(Debug, Clone)]
pub enum BalancingMode {
    /// weight mode
    WEIGHT,
    /// random mode
    RANDOM,
    /// polling mode
    POLLING,
}

/// network agent abstract structure
#[derive(Debug, Clone)]
pub struct Proxy {
    /// request abstract structure
    request: Request,
    /// Response abstract structure
    response: Response,
}

impl Proxy {
    /// load balancing
    pub async fn load_balancing(
        host: &str,
        port: &str,
        request: Request,
        mode: BalancingMode,
    ) -> Result<Self, String> {
        match mode {
            BalancingMode::WEIGHT => Proxy::to(host, port, request).await,
            BalancingMode::RANDOM => Proxy::to(host, port, request).await,
            BalancingMode::POLLING => Proxy::to(host, port, request).await,
            _ => Err("".to_string()),
        }
    }
    /// forward the request to a third-party server
    pub async fn to(host: &str, port: &str, request: Request) -> Result<Self, String> {
        let t = TcpStream::connect(format!("{}:{}", host, port))
            .await
            .unwrap();
        let (r, mut w) = t.into_split();
        let _ = w.write_all(&request.raw()).await;
        match Response::multi_thread_decode(r).await {
            Ok(response) => {
                return Ok(Proxy {
                    request: request,
                    response: response,
                });
            }
            Err(_) => {
                // TODO
                return Err("".to_string());
            }
        }
    }
}