bpi-rs 0.2.0

Bilibili API client library for 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

use tokio::time::Instant;

use reqwest::{Client, RequestBuilder};

use crate::{BpiError, BpiResult};

use super::{RequestMetadata, ResponseMetadata, TransportResponse};

/// Reqwest-backed transport placeholder used while endpoint modules are migrated.
#[derive(Debug, Clone)]
pub struct ReqwestTransport {
    client: Client,
}

impl ReqwestTransport {
    pub fn new(client: Client) -> Self {
        Self { client }
    }

    pub fn client(&self) -> &Client {
        &self.client
    }

    pub async fn send_request_builder(
        builder: RequestBuilder,
        endpoint: &str,
    ) -> BpiResult<TransportResponse> {
        let request_metadata = RequestMetadata::from_builder(&builder, endpoint);
        if let Some(metadata) = &request_metadata {
            tracing::info!(
                endpoint = metadata.endpoint.as_str(),
                method = %metadata.method,
                url = metadata.sanitized_url.as_str(),
                "sending Bilibili request"
            );
        } else {
            tracing::info!(endpoint, "sending Bilibili request");
        }

        let start = Instant::now();
        let response = builder.send().await.map_err(BpiError::from)?;
        let status = response.status();

        if !status.is_success() {
            tracing::error!(
                endpoint,
                status = status.as_u16(),
                "Bilibili request returned HTTP error"
            );
            return Err(BpiError::http(status.as_u16()));
        }

        let body = response.bytes().await.map_err(BpiError::from)?;
        let duration = start.elapsed();
        tracing::info!(
            endpoint,
            status = status.as_u16(),
            duration_ms = duration.as_millis(),
            "Bilibili request completed"
        );

        Ok(TransportResponse {
            metadata: ResponseMetadata {
                status: status.as_u16(),
                duration,
                api_code: None,
            },
            body,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn reqwest_transport_exposes_inner_client() {
        let client = Client::new();
        let transport = ReqwestTransport::new(client);

        let _ = transport.client();
    }
}