Struct qiniu_http_client::Response

pub struct Response<B>(_);

HTTP 响应

Implementations

impl<B> Response<B>

pub fn into_body(self) -> B

转换为 HTTP 响应体

Examples found in repository

src/regions/endpoints_provider/bucket_domains_provider.rs (line 283)

    fn do_sync_query(&self) -> ApiResult<Endpoints> {
        let endpoints: Endpoints = self
            .queryer
            .http_client
            .get(&[ServiceName::Uc], &self.queryer.uc_endpoints)
            .path("/v2/domains")
            .authorization(Authorization::v2(&self.credential))
            .append_query_pair("tbl", self.bucket_name.as_str())
            .accept_json()
            .call()?
            .parse_json::<Vec<String>>()?
            .into_body()
            .into_iter()
            .map(Endpoint::from)
            .collect();
        Ok(endpoints)
    }

    #[cfg(feature = "async")]
    async fn do_async_query(&self) -> ApiResult<Endpoints> {
        let endpoints: Endpoints = self
            .queryer
            .http_client
            .async_get(&[ServiceName::Uc], &self.queryer.uc_endpoints)
            .path("/v2/domains")
            .authorization(Authorization::v2(&self.credential))
            .append_query_pair("tbl", self.bucket_name.as_str())
            .accept_json()
            .call()
            .await?
            .parse_json::<Vec<String>>()
            .await?
            .into_body()
            .into_iter()
            .map(Endpoint::from)
            .collect();
        Ok(endpoints)
    }

pub fn into_parts_and_body(self) -> (HttpResponseParts, B)

转换为 HTTP 响应信息和响应体

Examples found in repository

src/client/call/utils.rs (line 388)

    fn to_status_code_error(response: SyncResponse, retried: &RetriedStatsInfo) -> ApiResult<SyncResponse> {
        let status_code = response.status_code();
        let (parts, body) = response.parse_json::<ErrorResponseBody>()?.into_parts_and_body();
        Err(
            ResponseError::new_with_msg(ResponseErrorKind::StatusCodeError(status_code), body.into_error())
                .response_parts(&parts)
                .retried(retried),
        )
    }
}

fn check_x_req_id(response: &mut SyncResponse, retried: &RetriedStatsInfo) -> ApiResult<()> {
    if response.x_reqid().is_some() {
        Ok(())
    } else {
        Err(make_malicious_response(response.parts(), retried).read_response_body_sample(response.body_mut())?)
    }
}

#[cfg(feature = "async")]
async fn async_check_x_req_id(response: &mut AsyncResponse, retried: &RetriedStatsInfo) -> ApiResult<()> {
    if response.x_reqid().is_some() {
        Ok(())
    } else {
        Err(make_malicious_response(response.parts(), retried)
            .async_read_response_body_sample(response.body_mut())
            .await?)
    }
}

fn make_malicious_response(parts: &ResponseParts, retried: &RetriedStatsInfo) -> ResponseError {
    ResponseError::new_with_msg(
        ResponseErrorKind::MaliciousResponse,
        "cannot find X-ReqId header from response, might be malicious response",
    )
    .response_parts(parts)
    .retried(retried)
}

fn make_unexpected_status_code_error(parts: &ResponseParts, retried: &RetriedStatsInfo) -> ResponseError {
    ResponseError::new_with_msg(
        ResponseErrorKind::UnexpectedStatusCode(parts.status_code()),
        format!("status code {} is unexpected", parts.status_code()),
    )
    .response_parts(parts)
    .retried(retried)
}

#[cfg(feature = "async")]
mod async_utils {
    use super::{
        super::super::{AsyncResponse, InnerRequestParts},
        *,
    };
    use qiniu_http::AsyncRequest as AsyncHttpRequest;
    use std::future::Future;

    pub(in super::super) async fn sign_async_request(
        request: &mut AsyncHttpRequest<'_>,
        authorization: Option<&Authorization<'_>>,
        retried: &RetriedStatsInfo,
    ) -> Result<(), TryError> {
        if let Some(authorization) = authorization {
            authorization
                .async_sign(request)
                .await
                .map_err(|err| handle_sign_request_error(err, retried))?;
        }
        Ok(())
    }

    pub(in super::super) async fn async_resolve(
        parts: &InnerRequestParts<'_>,
        domain_with_port: &DomainWithPort,
        extensions: &mut Extensions,
        retried: &RetriedStatsInfo,
    ) -> Result<Vec<IpAddrWithPort>, TryError> {
        let answers = with_resolve_domain(parts, domain_with_port.domain(), extensions, retried, || async {
            parts
                .http_client()
                .resolver()
                .async_resolve(
                    domain_with_port.domain(),
                    ResolveOptions::builder().retried(retried).build(),
                )
                .await
        });
        return Ok(answers
            .await?
            .into_ip_addrs()
            .iter()
            .map(|&ip| IpAddrWithPort::new(ip, domain_with_port.port()))
            .collect());

        async fn with_resolve_domain<F: FnOnce() -> Fu, Fu: Future<Output = ResolveResult>>(
            parts: &InnerRequestParts<'_>,
            domain: &str,
            extensions: &mut Extensions,
            retried: &RetriedStatsInfo,
            f: F,
        ) -> Result<ResolveAnswers, TryError> {
            call_to_resolve_domain_callbacks(parts, domain, extensions, retried)?;
            let answers = f()
                .await
                .map_err(|err| TryError::new(err, RetryDecision::TryNextServer.into()))?;
            call_domain_resolved_callbacks(parts, domain, &answers, extensions, retried)?;
            Ok(answers)
        }
    }

    pub(in super::super) async fn async_choose(
        parts: &InnerRequestParts<'_>,
        ips: &[IpAddrWithPort],
        extensions: &mut Extensions,
        retried: &RetriedStatsInfo,
    ) -> Result<Vec<IpAddrWithPort>, TryError> {
        call_to_choose_ips_callbacks(parts, ips, extensions, retried)?;
        let chosen_ips = parts
            .http_client()
            .chooser()
            .async_choose(ips, Default::default())
            .await
            .into_ip_addrs();
        call_ips_chosen_callbacks(parts, ips, &chosen_ips, extensions, retried)?;
        Ok(chosen_ips)
    }

    pub(in super::super) async fn async_judge(
        mut response: AsyncResponse,
        retried: &RetriedStatsInfo,
    ) -> ApiResult<AsyncResponse> {
        return match response.status_code().as_u16() {
            0..=199 | 300..=399 => Err(make_unexpected_status_code_error(response.parts(), retried)),
            200..=299 => {
                async_check_x_req_id(&mut response, retried).await?;
                Ok(response)
            }
            _ => to_status_code_error(response, retried).await,
        };

        async fn to_status_code_error(response: AsyncResponse, retried: &RetriedStatsInfo) -> ApiResult<AsyncResponse> {
            let status_code = response.status_code();
            let (parts, body) = response.parse_json::<ErrorResponseBody>().await?.into_parts_and_body();
            Err(
                ResponseError::new_with_msg(ResponseErrorKind::StatusCodeError(status_code), body.into_error())
                    .response_parts(&parts)
                    .retried(retried),
            )
        }

src/regions/regions_provider/bucket_regions_queryer.rs (line 319)

fn handle_response_body(response: Response<ResponseBody>) -> ApiResult<GotRegions> {
    let (parts, body) = response.into_parts_and_body();
    let hosts = body.into_hosts();
    let min_lifetime = hosts.iter().map(|host| host.lifetime()).min();
    let mut got_regions = hosts
        .into_iter()
        .map(|host| Region::try_from(host).map_err(|err| ResponseError::from_endpoint_parse_error(err, &parts)))
        .collect::<ApiResult<GotRegions>>()?;
    *got_regions.lifetime_mut() = min_lifetime;
    Ok(got_regions)
}

src/regions/regions_provider/all_regions_provider.rs (line 286)

    fn handle_response_body(response: Response<ResponseBody>) -> ApiResult<GotRegions> {
        let (parts, body) = response.into_parts_and_body();
        let hosts = body.into_hosts();
        let min_lifetime = hosts.iter().map(|host| host.lifetime()).min();
        let mut got_regions = hosts
            .into_iter()
            .map(|host| Region::try_from(host).map_err(|err| ResponseError::from_endpoint_parse_error(err, &parts)))
            .collect::<ApiResult<GotRegions>>()?;
        *got_regions.lifetime_mut() = min_lifetime;
        Ok(got_regions)
    }

pub fn from_parts_and_body(parts: HttpResponseParts, body: B) -> Self

根据 HTTP 响应信息和响应体创建 HTTP 响应

pub fn x_reqid(&self) -> Option<&HeaderValue>

获取 HTTP 响应的 X-ReqId 信息

Examples found in repository

src/client/call/utils.rs (line 398)

fn check_x_req_id(response: &mut SyncResponse, retried: &RetriedStatsInfo) -> ApiResult<()> {
    if response.x_reqid().is_some() {
        Ok(())
    } else {
        Err(make_malicious_response(response.parts(), retried).read_response_body_sample(response.body_mut())?)
    }
}

#[cfg(feature = "async")]
async fn async_check_x_req_id(response: &mut AsyncResponse, retried: &RetriedStatsInfo) -> ApiResult<()> {
    if response.x_reqid().is_some() {
        Ok(())
    } else {
        Err(make_malicious_response(response.parts(), retried)
            .async_read_response_body_sample(response.body_mut())
            .await?)
    }
}

pub fn x_log(&self) -> Option<&HeaderValue>

获取 HTTP 响应的 X-Log 信息

impl Response<SyncResponseBody>

pub fn parse_json<T: DeserializeOwned>(self) -> ApiResult<Response<T>>

解析 JSON 响应体

Examples found in repository

src/regions/regions_provider/all_regions_provider.rs (line 265)

        fn do_sync_query(&self) -> ApiResult<GotRegions> {
            handle_response_body(
                self.http_client
                    .get(&[ServiceName::Uc], &self.uc_endpoints)
                    .path("/regions")
                    .authorization(Authorization::v2(&self.credential_provider))
                    .accept_json()
                    .call()?
                    .parse_json::<ResponseBody>()?,
            )
        }

src/client/call/utils.rs (line 388)

    fn to_status_code_error(response: SyncResponse, retried: &RetriedStatsInfo) -> ApiResult<SyncResponse> {
        let status_code = response.status_code();
        let (parts, body) = response.parse_json::<ErrorResponseBody>()?.into_parts_and_body();
        Err(
            ResponseError::new_with_msg(ResponseErrorKind::StatusCodeError(status_code), body.into_error())
                .response_parts(&parts)
                .retried(retried),
        )
    }

src/regions/regions_provider/bucket_regions_queryer.rs (line 296)

    fn do_sync_query(&self) -> ApiResult<GotRegions> {
        handle_response_body(
            self.queryer
                .http_client
                .get(&[ServiceName::Uc, ServiceName::Api], &self.queryer.uc_endpoints)
                .path("/v4/query")
                .append_query_pair("ak", self.access_key.as_str())
                .append_query_pair("bucket", self.bucket_name.as_str())
                .accept_json()
                .call()?
                .parse_json::<ResponseBody>()?,
        )
    }

src/regions/endpoints_provider/bucket_domains_provider.rs (line 282)

    fn do_sync_query(&self) -> ApiResult<Endpoints> {
        let endpoints: Endpoints = self
            .queryer
            .http_client
            .get(&[ServiceName::Uc], &self.queryer.uc_endpoints)
            .path("/v2/domains")
            .authorization(Authorization::v2(&self.credential))
            .append_query_pair("tbl", self.bucket_name.as_str())
            .accept_json()
            .call()?
            .parse_json::<Vec<String>>()?
            .into_body()
            .into_iter()
            .map(Endpoint::from)
            .collect();
        Ok(endpoints)
    }

impl Response<AsyncResponseBody>

pub async fn parse_json<T: DeserializeOwned>(self) -> ApiResult<Response<T>>

异步解析 JSON 响应体

Examples found in repository

src/client/call/utils.rs (line 528)

        async fn to_status_code_error(response: AsyncResponse, retried: &RetriedStatsInfo) -> ApiResult<AsyncResponse> {
            let status_code = response.status_code();
            let (parts, body) = response.parse_json::<ErrorResponseBody>().await?.into_parts_and_body();
            Err(
                ResponseError::new_with_msg(ResponseErrorKind::StatusCodeError(status_code), body.into_error())
                    .response_parts(&parts)
                    .retried(retried),
            )
        }

src/regions/regions_provider/all_regions_provider.rs (line 279)

        async fn do_async_query(&self) -> ApiResult<GotRegions> {
            handle_response_body(
                self.http_client
                    .async_get(&[ServiceName::Uc], &self.uc_endpoints)
                    .path("/regions")
                    .authorization(Authorization::v2(&self.credential_provider))
                    .accept_json()
                    .call()
                    .await?
                    .parse_json::<ResponseBody>()
                    .await?,
            )
        }

src/regions/regions_provider/bucket_regions_queryer.rs (line 312)

    async fn do_async_query(&self) -> ApiResult<GotRegions> {
        handle_response_body(
            self.queryer
                .http_client
                .async_get(&[ServiceName::Uc, ServiceName::Api], &self.queryer.uc_endpoints)
                .path("/v4/query")
                .append_query_pair("ak", self.access_key.as_str())
                .append_query_pair("bucket", self.bucket_name.as_str())
                .accept_json()
                .call()
                .await?
                .parse_json::<ResponseBody>()
                .await?,
        )
    }

src/regions/endpoints_provider/bucket_domains_provider.rs (line 302)

    async fn do_async_query(&self) -> ApiResult<Endpoints> {
        let endpoints: Endpoints = self
            .queryer
            .http_client
            .async_get(&[ServiceName::Uc], &self.queryer.uc_endpoints)
            .path("/v2/domains")
            .authorization(Authorization::v2(&self.credential))
            .append_query_pair("tbl", self.bucket_name.as_str())
            .accept_json()
            .call()
            .await?
            .parse_json::<Vec<String>>()
            .await?
            .into_body()
            .into_iter()
            .map(Endpoint::from)
            .collect();
        Ok(endpoints)
    }

Methods from Deref<Target = HttpResponse<B>>

pub fn body(&self) -> &B

获取 HTTP 响应体

pub fn body_mut(&mut self) -> &mut B

获取 HTTP 响应体的可变引用

pub fn parts(&self) -> &ResponseParts

HTTP 响应信息

pub fn parts_mut(&mut self) -> &mut ResponseParts

获取 HTTP 响应信息的可变引用

Methods from Deref<Target = ResponseParts>

pub fn status_code(&self) -> StatusCode

获取 HTTP 状态码

pub fn status_code_mut(&mut self) -> &mut StatusCode

获取 HTTP 状态码 的可变引用

pub fn headers(&self) -> &HeaderMap<HeaderValue>

获取 HTTP Headers

pub fn headers_mut(&mut self) -> &mut HeaderMap<HeaderValue>

获取 HTTP Headers 的可变引用

pub fn version(&self) -> Version

获取 HTTP 版本

pub fn version_mut(&mut self) -> &mut Version

获取 HTTP 版本的可变引用

pub fn extensions(&self) -> &Extensions

获取 扩展信息

pub fn extensions_mut(&mut self) -> &mut Extensions

获取扩展信息的可变引用

pub fn header(&self, header_name: impl AsHeaderName) -> Option<&HeaderValue>

获取 HTTP 响应 Header

pub fn server_ip(&self) -> Option<IpAddr>

获取 HTTP 服务器 IP 地址

pub fn server_ip_mut(&mut self) -> &mut Option<IpAddr>

获取 HTTP 服务器 IP 地址的可变引用

pub fn server_port(&self) -> Option<NonZeroU16>

获取 HTTP 服务器端口号

pub fn server_port_mut(&mut self) -> &mut Option<NonZeroU16>

获取 HTTP 服务器端口号的可变引用

pub fn metrics(&self) -> Option<&Metrics>

获取 HTTP 响应的指标信息

pub fn metrics_mut(&mut self) -> &mut Option<Metrics>

获取 HTTP 响应的指标信息的可变引用

Trait Implementations

impl<B: Debug> Debug for Response<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Default> Default for Response<B>

fn default() -> Response<B>

Returns the “default value” for a type.

impl<B> Deref for Response<B>

type Target = Response<B>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<B> DerefMut for Response<B>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<B> From<Response<B>> for HttpResponse<B>

fn from(response: Response<B>) -> Self

Converts to this type from the input type.

impl<B> From<Response<B>> for Response<B>

fn from(response: HttpResponse<B>) -> Self

Converts to this type from the input type.