barehttp 0.1.0

Blocking HTTP/1.1 client for no_std + alloc
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

//! Criterion: end-to-end HTTP over a local mock server (no internet).
#![allow(clippy::unwrap_used, clippy::expect_used)]

use criterion::{Criterion, criterion_group, criterion_main};
use std::hint::black_box;
use std::time::Duration;

#[path = "support.rs"]
mod support;

fn e2e_get(c: &mut Criterion) {
  let server = support::LoopbackServer::spawn(support::RESP_PLAIN.to_vec());
  let url = server.url();
  let client = support::bench_client();

  let mut group = c.benchmark_group("e2e_loopback");
  group.warm_up_time(Duration::from_millis(500));
  group.measurement_time(Duration::from_secs(3));
  group.sample_size(40);

  group.bench_function("get_plain", |b| {
    b.iter(|| {
      let resp = client.get(black_box(url.as_str())).call().unwrap();
      black_box(resp.status_code());
      black_box(resp.body().len());
    });
  });

  group.finish();
  drop(server);
}

fn e2e_chunked(c: &mut Criterion) {
  let server = support::LoopbackServer::spawn(support::RESP_CHUNKED.to_vec());
  let url = server.url();
  let client = support::bench_client();

  let mut group = c.benchmark_group("e2e_loopback_chunked");
  group.warm_up_time(Duration::from_millis(500));
  group.measurement_time(Duration::from_secs(3));
  group.sample_size(40);

  group.bench_function("get_chunked", |b| {
    b.iter(|| {
      let resp = client.get(black_box(url.as_str())).call().unwrap();
      black_box(resp.body());
    });
  });

  group.finish();
  drop(server);
}

#[cfg(feature = "gzip")]
fn e2e_gzip(c: &mut Criterion) {
  use flate2::Compression;
  use flate2::write::GzEncoder;
  use std::io::Write;

  let plain = b"gzipped-e2e-benchmark-body-0123456789";
  let mut enc = GzEncoder::new(Vec::new(), Compression::default());
  enc.write_all(plain).unwrap();
  let gz = enc.finish().unwrap();
  let mut msg = format!(
    "HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
    gz.len()
  )
  .into_bytes();
  msg.extend_from_slice(&gz);

  let server = support::LoopbackServer::spawn(msg);
  let url = server.url();
  let client = support::bench_client();

  let mut group = c.benchmark_group("e2e_loopback_gzip");
  group.warm_up_time(Duration::from_millis(500));
  group.measurement_time(Duration::from_secs(3));
  group.sample_size(30);

  group.bench_function("get_gzip_body", |b| {
    b.iter(|| {
      let resp = client.get(black_box(url.as_str())).call().unwrap();
      black_box(resp.body());
    });
  });

  group.finish();
  drop(server);
}

#[cfg(not(feature = "gzip"))]
fn e2e_gzip(_c: &mut Criterion) {}

criterion_group!(benches, e2e_get, e2e_chunked, e2e_gzip);
criterion_main!(benches);