Struct qiniu_http_client::RequestBuilder

pub struct RequestBuilder<'r, B: 'r, E: 'r> { /* private fields */ }

请求构建器

通过 HttpClient::get， HttpClient::post 等方法创建请求构建器

Implementations

impl<'r, B: 'r, E: 'r> RequestBuilder<'r, B, E>

pub fn use_https(&mut self, use_https: bool) -> &mut Self

设置是否使用 HTTPS

pub fn version(&mut self, version: Version) -> &mut Self

设置 HTTP 协议版本

pub fn path(&mut self, path: impl Into<Cow<'r, str>>) -> &mut Self

设置 HTTP 请求路径

Examples found in repository

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

        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>()?,
            )
        }

        #[cfg(feature = "async")]
        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 291)

    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>()?,
        )
    }

    #[cfg(feature = "async")]
    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 277)

    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 headers(&mut self, headers: impl Into<Cow<'r, HeaderMap>>) -> &mut Self

设置 HTTP 请求头

pub fn set_header(
    &mut self,
    header_name: impl IntoHeaderName,
    header_value: impl Into<HeaderValue>
) -> &mut Self

添加 HTTP 请求头

pub fn accept_json(&mut self) -> &mut Self

设置 HTTP 响应预期为 JSON 类型

Examples found in repository

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

        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>()?,
            )
        }

        #[cfg(feature = "async")]
        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 294)

    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>()?,
        )
    }

    #[cfg(feature = "async")]
    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 280)

    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 accept_application_octet_stream(&mut self) -> &mut Self

设置 HTTP 响应预期为二进制流类型

pub fn query(&mut self, query: impl Into<Cow<'r, str>>) -> &mut Self

设置查询参数

pub fn query_pairs(
    &mut self,
    query_pairs: impl Into<Vec<QueryPair<'r>>>
) -> &mut Self

设置查询参数

pub fn append_query_pair(
    &mut self,
    query_pair_key: impl Into<QueryPairKey<'r>>,
    query_pair_value: impl Into<QueryPairValue<'r>>
) -> &mut Self

追加查询参数

Examples found in repository

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

    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>()?,
        )
    }

    #[cfg(feature = "async")]
    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 279)

    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 appended_user_agent(
    &mut self,
    user_agent: impl Into<UserAgent>
) -> &mut Self

追加 UserAgent

pub fn authorization(&mut self, authorization: Authorization<'r>) -> &mut Self

设置鉴权签名

Examples found in repository

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

        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>()?,
            )
        }

        #[cfg(feature = "async")]
        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/endpoints_provider/bucket_domains_provider.rs (line 278)

    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 idempotent(&mut self, idempotent: Idempotent) -> &mut Self

设置为幂等请求

pub fn extensions(&mut self, extensions: Extensions) -> &mut Self

设置扩展信息

pub fn add_extension<T: Send + Sync + 'static>(&mut self, val: T) -> &mut Self

添加扩展信息

pub fn on_uploading_progress(
    &mut self,
    callback: impl Fn(&dyn SimplifiedCallbackContext, TransferProgressInfo<'_>) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置上传进度回调函数

pub fn on_receive_response_status(
    &mut self,
    callback: impl Fn(&dyn SimplifiedCallbackContext, StatusCode) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置响应状态码回调函数

pub fn on_receive_response_header(
    &mut self,
    callback: impl Fn(&dyn SimplifiedCallbackContext, &HeaderName, &HeaderValue) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置响应 HTTP 头回调函数

pub fn on_to_resolve_domain(
    &mut self,
    callback: impl Fn(&mut dyn CallbackContext, &str) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置域名解析前回调函数

pub fn on_domain_resolved(
    &mut self,
    callback: impl Fn(&mut dyn CallbackContext, &str, &ResolveAnswers) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置域名解析成功回调函数

pub fn on_to_choose_ips(
    &mut self,
    callback: impl Fn(&mut dyn CallbackContext, &[IpAddrWithPort]) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置 IP 地址选择前回调函数

pub fn on_ips_chosen(
    &mut self,
    callback: impl Fn(&mut dyn CallbackContext, &[IpAddrWithPort], &[IpAddrWithPort]) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置 IP 地址选择成功回调函数

pub fn on_before_request_signed(
    &mut self,
    callback: impl Fn(&mut dyn ExtendedCallbackContext) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置 HTTP 请求签名前回调函数

pub fn on_after_request_signed(
    &mut self,
    callback: impl Fn(&mut dyn ExtendedCallbackContext) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置 HTTP 请求前回调函数

pub fn on_response(
    &mut self,
    callback: impl Fn(&mut dyn ExtendedCallbackContext, &ResponseParts) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置响应成功回调函数

pub fn on_error(
    &mut self,
    callback: impl Fn(&mut dyn ExtendedCallbackContext, &mut ResponseError) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置响应错误回调函数

pub fn on_before_backoff(
    &mut self,
    callback: impl Fn(&mut dyn ExtendedCallbackContext, Duration) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置退避前回调函数

pub fn on_after_backoff(
    &mut self,
    callback: impl Fn(&mut dyn ExtendedCallbackContext, Duration) -> AnyResult<()> + Send + Sync + 'r
) -> &mut Self

设置退避后回调函数

pub fn parts(&self) -> &RequestBuilderParts<'r>

获取 HTTP 请求构建器部分参数

pub fn parts_mut(&mut self) -> &mut RequestBuilderParts<'r>

获取 HTTP 请求构建器部分参数的可变引用

pub fn into_parts(self) -> RequestBuilderParts<'r>

转换为 HTTP 请求构建器部分参数

impl<'r, E: 'r> RequestBuilder<'r, RequestBody<'r>, E>

pub fn stream_as_body(
    &mut self,
    body: impl Read + Reset + Debug + Send + Sync + 'static,
    content_length: u64,
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为输入流

pub fn referenced_stream_as_body<T: Read + Reset + Debug + Send + Sync>(
    &mut self,
    body: &'r mut T,
    content_length: u64,
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为输入流的可变引用

pub fn bytes_as_body(
    &mut self,
    body: impl Into<Vec<u8>>,
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为内存数据

Examples found in repository

src/client/request/builder.rs (line 684)

    pub fn json(&mut self, body: impl Serialize) -> JsonResult<&mut Self> {
        Ok(self.bytes_as_body(serde_json::to_vec(&body)?, Some(APPLICATION_JSON)))
    }

    /// 设置 HTTP 请求体为表单对象
    #[inline]
    pub fn post_form<I, K, V>(&mut self, iter: I) -> &mut Self
    where
        I: IntoIterator,
        I::Item: Borrow<(K, Option<V>)>,
        K: AsRef<str>,
        V: AsRef<str>,
    {
        let mut form = form_urlencoded::Serializer::new(String::new());
        for pair in iter {
            let (k, v) = pair.borrow();
            if let Some(v) = v {
                form.append_pair(k.as_ref(), v.as_ref());
            } else {
                form.append_key_only(k.as_ref());
            }
        }
        self.bytes_as_body(form.finish().into_bytes(), Some(APPLICATION_WWW_FORM_URLENCODED))
    }

    /// 设置 HTTP 请求体为 Multipart 表单对象
    #[inline]
    pub fn multipart<'a>(&mut self, multipart: impl Into<SyncMultipart<'a>>) -> IoResult<&mut Self> {
        let mut buf = Vec::new();
        let multipart = multipart.into();
        let mime = ("multipart/form-data; boundary=".to_owned() + multipart.boundary())
            .parse()
            .unwrap();
        multipart.into_read().read_to_end(&mut buf)?;
        Ok(self.bytes_as_body(buf, Some(mime)))
    }

pub fn referenced_bytes_as_body(
    &mut self,
    body: &'r [u8],
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为内存数据的引用

pub fn json(&mut self, body: impl Serialize) -> JsonResult<&mut Self>

设置 HTTP 请求体为 JSON 对象

pub fn post_form<I, K, V>(&mut self, iter: I) -> &mut Selfwhere
    I: IntoIterator,
    I::Item: Borrow<(K, Option<V>)>,
    K: AsRef<str>,
    V: AsRef<str>,

设置 HTTP 请求体为表单对象

pub fn multipart<'a>(
    &mut self,
    multipart: impl Into<SyncMultipart<'a>>
) -> IoResult<&mut Self>

设置 HTTP 请求体为 Multipart 表单对象

impl<'r, E: EndpointsProvider + Clone + 'r> RequestBuilder<'r, RequestBody<'r>, E>

pub fn call(&mut self) -> ApiResult<SyncResponse>

阻塞发起 HTTP 请求

Examples found in repository

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

        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/regions/regions_provider/bucket_regions_queryer.rs (line 295)

    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 281)

    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<'r, E: 'r> RequestBuilder<'r, AsyncRequestBody<'r>, E>

pub fn stream_as_body(
    &mut self,
    body: impl AsyncRead + AsyncReset + Unpin + Debug + Send + Sync + 'static,
    content_length: u64,
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为异步输入流

pub fn referenced_stream_as_body<T: AsyncRead + AsyncReset + Unpin + Debug + Send + Sync>(
    &mut self,
    body: &'r mut T,
    content_length: u64,
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为异步输入流的可变引用

pub fn bytes_as_body(
    &mut self,
    body: impl Into<Vec<u8>>,
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为内存数据

Examples found in repository

src/client/request/builder.rs (line 793)

    pub fn json(&mut self, body: impl Serialize) -> JsonResult<&mut Self> {
        Ok(self.bytes_as_body(serde_json::to_vec(&body)?, Some(APPLICATION_JSON)))
    }

    /// 设置 HTTP 请求体为表单对象
    #[inline]
    pub fn post_form<I, K, V>(&mut self, iter: I) -> &mut Self
    where
        I: IntoIterator,
        I::Item: Borrow<(K, Option<V>)>,
        K: AsRef<str>,
        V: AsRef<str>,
    {
        let mut form = form_urlencoded::Serializer::new(String::new());
        for pair in iter {
            let (k, v) = pair.borrow();
            if let Some(v) = v {
                form.append_pair(k.as_ref(), v.as_ref());
            } else {
                form.append_key_only(k.as_ref());
            }
        }
        self.bytes_as_body(form.finish().into_bytes(), Some(APPLICATION_WWW_FORM_URLENCODED))
    }

    /// 设置 HTTP 请求体为 Multipart 表单对象
    #[inline]
    pub async fn multipart<'a>(
        &mut self,
        multipart: impl Into<AsyncMultipart<'a>>,
    ) -> IoResult<&mut RequestBuilder<'r, AsyncRequestBody<'r>, E>> {
        use futures::AsyncReadExt;

        let mut buf = Vec::new();
        let multipart = multipart.into();
        let mime = ("multipart/form-data; boundary=".to_owned() + multipart.boundary())
            .parse()
            .unwrap();
        multipart.into_async_read().read_to_end(&mut buf).await?;
        Ok(self.bytes_as_body(buf, Some(mime)))
    }

pub fn referenced_bytes_as_body(
    &mut self,
    body: &'r [u8],
    content_type: Option<Mime>
) -> &mut Self

设置 HTTP 请求体为内存数据的引用

pub fn json(&mut self, body: impl Serialize) -> JsonResult<&mut Self>

设置 HTTP 请求体为 JSON 对象

pub fn post_form<I, K, V>(&mut self, iter: I) -> &mut Selfwhere
    I: IntoIterator,
    I::Item: Borrow<(K, Option<V>)>,
    K: AsRef<str>,
    V: AsRef<str>,

设置 HTTP 请求体为表单对象

pub async fn multipart<'a>(
    &mut self,
    multipart: impl Into<AsyncMultipart<'a>>
) -> IoResult<&mut RequestBuilder<'r, AsyncRequestBody<'r>, E>>

设置 HTTP 请求体为 Multipart 表单对象

impl<'r, E: EndpointsProvider + Clone + 'r> RequestBuilder<'r, AsyncRequestBody<'r>, E>

pub async fn call(&mut self) -> ApiResult<AsyncResponse>

异步发起 HTTP 请求

Examples found in repository

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

        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 310)

    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 300)

    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)
    }

Trait Implementations

impl<'r, B: Debug + 'r, E: Debug + 'r> Debug for RequestBuilder<'r, B, E>

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

Formats the value using the given formatter.