reqwest-lb 0.1.2

The reqwest load balancer middleware
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

# reqwest-lb


A crate for [reqwest](https://crates.io/crates/reqwest) support load balancer, use
the [reqwest-middleware](https://crates.io/crates/reqwest-middleware).

## Overview


This crate provide a middleware `LoadBalancerMiddleware`, it implement `reqwest-middleware::Middleware`.

- ### dependencies

    ```toml
    [dependencies]
    reqwest = "0.12"
    reqwest-middleware = "0.3"
    reqwest-lb = "0.1"
    ```

- ### example

    ```rust
    use reqwest::{Client, Url};
    use reqwest_lb::LoadBalancerMiddleware;
    use reqwest_lb::SimpleLoadBalancer;
    use reqwest_lb::{LoadBalancerFactory, LoadBalancerPolicy};
    use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
  
    pub fn create<const N: usize>(
        ports: [u16; N],
        policy: LoadBalancerPolicy<Url>,
    ) -> ClientWithMiddleware {
        // create load balancer factory
        let mut factory = LoadBalancerFactory::default();
  
        // create url list
        let mut urls = Vec::with_capacity(N);
        for port in ports {
            urls.push(Url::parse(format!("http://127.0.0.1:{}", port).as_str()).unwrap());
        }
  
        // create load balancer
        let load_balancer = SimpleLoadBalancer::new(urls, policy);
  
        // register load balancer for the host: example-server
        factory.add("example-server", load_balancer);
  
        // create reqwest client
        let middleware = LoadBalancerMiddleware::new(factory);
        ClientBuilder::new(Client::builder().no_proxy().build().unwrap())
            .with(middleware)
            .build()
    }
  
    pub async fn run() {
        // use round robin policy
        let client = create([3001, 3002], LoadBalancerPolicy::RoundRobin);
        // http://127.0.0.1:3001
        let response = client.get("lb://example-server/").send().await.unwrap();
        // http://127.0.0.1:3002
        let response = client.get("lb://example-server/").send().await.unwrap();
    }
  
    ```

- ### load balancer policy

  - RoundRobin (default)
  - Random
  - First
  - Last
  - Weight

- ### discovery

  use `discovery` dynamic control the supplier elements, can send the elements change event `insert`,`remove` or
  `initialized` to the stream.

  ```rust
  
  use http::Extensions;
  use reqwest::Url;
  use reqwest_lb::discovery::Change;
  use reqwest_lb::supplier::discovery::DiscoverySupplier;
  use reqwest_lb::{LoadBalancer, LoadBalancerPolicy, SimpleLoadBalancer};
  
  #[tokio::test]
  async fn laod_balancer_discovery() {
      let ports = (0..10).map(|offset| 3000 + offset).collect::<Vec<_>>();
      let mut events = ports
          .iter()
          .map(|port| {
              Url::parse(&format!("http://127.0.0.1:{}", port)).map(|url| Change::Insert(*port, url))
          })
          .collect::<Vec<_>>();
      events.push(Ok(Change::Initialized));
  
      let discovery = futures::stream::iter(events);
      let supplier = DiscoverySupplier::new(discovery);
      let load_balancer = SimpleLoadBalancer::new(supplier, LoadBalancerPolicy::RoundRobin);
      let mut extensions = Extensions::new();
      for port in ports {
          let selected = load_balancer.choose(&mut extensions).await;
          assert_eq!(
              selected,
              Ok(Some(
                  Url::parse(&format!("http://127.0.0.1:{}", port)).unwrap()
              ))
          );
      }
  }
  
  ```  

## License


This project is licensed under the [Apache 2.0](./LICENSE)