Struct qiniu_isahc::TimeoutRequestExtension

source ·

pub struct TimeoutRequestExtension(_);

Expand description

请求超时时长扩展

Implementations§

source §

impl TimeoutRequestExtension

source

pub fn new(value: Duration) -> Self

创建扩展类型

source

pub fn get(&self) -> &Duration

获取扩展类型的值

Examples found in repository ?

src/client.rs (line 414)

fn add_extensions_to_isahc_request_builder(
    request: &RequestParts,
    ip_addr: Option<IpAddr>,
    mut isahc_request_builder: IsahcRequestBuilder,
) -> Result<IsahcRequestBuilder, ResponseError> {
    use super::extensions::*;

    isahc_request_builder = isahc_request_builder.metrics(true);

    if let Some(extension) = request.extensions().get::<TimeoutRequestExtension>() {
        isahc_request_builder = isahc_request_builder.timeout(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<ConnectTimeoutRequestExtension>() {
        isahc_request_builder = isahc_request_builder.connect_timeout(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<LowSpeedTimeoutRequestExtension>() {
        isahc_request_builder =
            isahc_request_builder.low_speed_timeout(extension.get().0.to_owned(), extension.get().1.to_owned());
    }

    if let Some(extension) = request.extensions().get::<VersionNegotiationRequestExtension>() {
        isahc_request_builder = isahc_request_builder.version_negotiation(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<RedirectPolicyRequestExtension>() {
        isahc_request_builder = isahc_request_builder.redirect_policy(extension.get().to_owned());
    }

    if request.extensions().get::<AutoRefererRequestExtension>().is_some() {
        isahc_request_builder = isahc_request_builder.auto_referer();
    }

    if let Some(extension) = request.extensions().get::<AutomaticDecompressionRequestExtension>() {
        isahc_request_builder = isahc_request_builder.automatic_decompression(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<TcpKeepaliveRequestExtension>() {
        isahc_request_builder = isahc_request_builder.tcp_keepalive(extension.get().to_owned());
    }

    if request.extensions().get::<TcpNodelayRequestExtension>().is_some() {
        isahc_request_builder = isahc_request_builder.tcp_nodelay();
    }

    if let Some(extension) = request.extensions().get::<NetworkInterfaceRequestExtension>() {
        isahc_request_builder = isahc_request_builder.interface(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<IpVersionRequestExtension>() {
        isahc_request_builder = isahc_request_builder.ip_version(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<DialRequestExtension>() {
        isahc_request_builder = isahc_request_builder.dial(extension.get().to_owned());
    } else if let Some(ip_addr) = ip_addr {
        isahc_request_builder = isahc_request_builder.dial(Dialer::ip_socket(SocketAddr::new(
            ip_addr,
            extract_port_for_uri(request.url())?,
        )));
    }

    if let Some(extension) = request.extensions().get::<ProxyRequestExtension>() {
        isahc_request_builder = isahc_request_builder.proxy(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<ProxyBlacklistRequestExtension>() {
        isahc_request_builder = isahc_request_builder.proxy_blacklist(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<ProxyAuthenticationRequestExtension>() {
        isahc_request_builder = isahc_request_builder.proxy_authentication(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<ProxyCredentialsRequestExtension>() {
        isahc_request_builder = isahc_request_builder.proxy_credentials(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<MaxUploadSpeedRequestExtension>() {
        isahc_request_builder = isahc_request_builder.max_upload_speed(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<MaxDownloadSpeedRequestExtension>() {
        isahc_request_builder = isahc_request_builder.max_download_speed(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<SslClientCertificateRequestExtension>() {
        isahc_request_builder = isahc_request_builder.ssl_client_certificate(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<SslCaCertificateRequestExtension>() {
        isahc_request_builder = isahc_request_builder.ssl_ca_certificate(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<SslCiphersRequestExtension>() {
        isahc_request_builder = isahc_request_builder.ssl_ciphers(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<SslOptionsRequestExtension>() {
        isahc_request_builder = isahc_request_builder.ssl_options(extension.get().to_owned());
    }

    if let Some(extension) = request.extensions().get::<TitleCaseHeadersRequestExtension>() {
        isahc_request_builder = isahc_request_builder.title_case_headers(extension.get().to_owned());
    }

    return Ok(isahc_request_builder);

    fn extract_port_for_uri(uri: &Uri) -> Result<u16, ResponseError> {
        const INVALID_URL: ResponseErrorKind = ResponseErrorKind::InvalidUrl;
        uri.port_u16().map(Ok).unwrap_or_else(|| {
            if let Some(scheme) = uri.scheme() {
                if scheme == &Scheme::HTTP {
                    Ok(80)
                } else if scheme == &Scheme::HTTPS {
                    Ok(443)
                } else {
                    Err(ResponseError::builder_with_msg(INVALID_URL, "unknown port for url").build())
                }
            } else {
                Err(ResponseError::builder_with_msg(INVALID_URL, "empty scheme for url").build())
            }
        })
    }
}