self,
BroadcastFuture,
DEFAULT_ENCODE_SET,
+ PROXMOX_BACKUP_TCP_KEEPALIVE_TIME,
http::{
build_authority,
HttpsConnector,
httpc.enforce_http(false); // we want https...
httpc.set_connect_timeout(Some(std::time::Duration::new(10, 0)));
- let https = HttpsConnector::with_connector(httpc, ssl_connector_builder.build());
+ let https = HttpsConnector::with_connector(httpc, ssl_connector_builder.build(), PROXMOX_BACKUP_TCP_KEEPALIVE_TIME);
let client = Client::builder()
//.http2_initial_stream_window_size( (1 << 31) - 2)
use proxmox::sys::linux::socket::set_tcp_keepalive;
use proxmox_http::http::MaybeTlsStream;
-use crate::tools::PROXMOX_BACKUP_TCP_KEEPALIVE_TIME;
-
// Build a http::uri::Authority ("host:port"), use '[..]' around IPv6 addresses
pub(crate) fn build_authority(host: &str, port: u16) -> Result<Authority, Error> {
let bytes = host.as_bytes();
connector: HttpConnector,
ssl_connector: Arc<SslConnector>,
proxy: Option<ProxyConfig>,
+ tcp_keepalive: u32,
}
impl HttpsConnector {
- pub fn with_connector(mut connector: HttpConnector, ssl_connector: SslConnector) -> Self {
+ pub fn with_connector(mut connector: HttpConnector, ssl_connector: SslConnector, tcp_keepalive: u32) -> Self {
connector.enforce_http(false);
Self {
connector,
ssl_connector: Arc::new(ssl_connector),
proxy: None,
+ tcp_keepalive,
}
}
}
};
let port = dst.port_u16().unwrap_or(if is_https { 443 } else { 80 });
+ let keepalive = self.tcp_keepalive;
if let Some(ref proxy) = self.proxy {
.await
.map_err(|err| format_err!("error connecting to {} - {}", proxy_authority, err))?;
- let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), PROXMOX_BACKUP_TCP_KEEPALIVE_TIME);
+ let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), keepalive);
let mut connect_request = format!("CONNECT {0}:{1} HTTP/1.1\r\n", host, port);
if let Some(authorization) = authorization {
.await
.map_err(|err| format_err!("error connecting to {} - {}", proxy_authority, err))?;
- let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), PROXMOX_BACKUP_TCP_KEEPALIVE_TIME);
+ let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), keepalive);
Ok(MaybeTlsStream::Proxied(tcp_stream))
}.boxed()
.await
.map_err(|err| format_err!("error connecting to {} - {}", dst_str, err))?;
- let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), PROXMOX_BACKUP_TCP_KEEPALIVE_TIME);
+ let _ = set_tcp_keepalive(tcp_stream.as_raw_fd(), keepalive);
if is_https {
Self::secure_stream(tcp_stream, &ssl_connector, &host).await
use openssl::ssl::{SslConnector, SslMethod};
use futures::*;
+use crate::tools::PROXMOX_BACKUP_TCP_KEEPALIVE_TIME;
use crate::tools::http::{HttpsConnector, ProxyConfig};
/// Asyncrounous HTTP client implementation
}
let connector = HttpConnector::new();
- let mut https = HttpsConnector::with_connector(connector, ssl_connector);
+ let mut https = HttpsConnector::with_connector(connector, ssl_connector, PROXMOX_BACKUP_TCP_KEEPALIVE_TIME);
if let Some(proxy_config) = proxy_config {
https.set_proxy(proxy_config);
}