From 2d7c2bca4bb5e017bb7c98e2588df969f48cf492 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beno=C3=AEt=20CORTIER?= Date: Thu, 26 Jun 2025 19:55:24 +0900 Subject: [PATCH] build: update ngrok --- devolutions-gateway/Cargo.toml | 2 +- devolutions-gateway/src/ngrok.rs | 71 +++++++++++++++++--------------- 2 files changed, 38 insertions(+), 35 deletions(-) diff --git a/devolutions-gateway/Cargo.toml b/devolutions-gateway/Cargo.toml index 472b97f75..c1cedfa72 100644 --- a/devolutions-gateway/Cargo.toml +++ b/devolutions-gateway/Cargo.toml @@ -81,7 +81,7 @@ reqwest = { version = "0.12", default-features = false, features = ["rustls-tls- futures = "0.3" async-trait = "0.1" tower = { version = "0.5", features = ["timeout"] } -ngrok = "0.13" +ngrok = { version = "0.15", default-features = false, features = ["ring"] } # HTTP hyper = "1.4" diff --git a/devolutions-gateway/src/ngrok.rs b/devolutions-gateway/src/ngrok.rs index d1d9cccbf..98e671756 100644 --- a/devolutions-gateway/src/ngrok.rs +++ b/devolutions-gateway/src/ngrok.rs @@ -5,7 +5,8 @@ use async_trait::async_trait; use devolutions_gateway_task::{ChildTask, ShutdownSignal, Task}; use futures::TryStreamExt as _; use ngrok::config::{HttpTunnelBuilder, TcpTunnelBuilder, TunnelBuilder as _}; -use ngrok::tunnel::UrlTunnel as _; +use ngrok::conn::ConnInfo as _; +use ngrok::tunnel::EndpointInfo as _; use tracing::Instrument as _; use crate::config::dto::{NgrokConf, NgrokTunnelConf}; @@ -19,22 +20,28 @@ pub struct NgrokSession { impl NgrokSession { pub async fn connect(conf: &NgrokConf) -> anyhow::Result { - let mut builder = ngrok::Session::builder().authtoken(&conf.auth_token); + let mut builder = ngrok::Session::builder(); + + builder.authtoken(&conf.auth_token); if let Some(heartbeat_interval) = conf.heartbeat_interval { - builder = builder.heartbeat_interval(Duration::from_secs(heartbeat_interval)); + builder + .heartbeat_interval(Duration::from_secs(heartbeat_interval)) + .context("set heartbeat interval")?; } if let Some(heartbeat_tolerance) = conf.heartbeat_tolerance { - builder = builder.heartbeat_tolerance(Duration::from_secs(heartbeat_tolerance)); + builder + .heartbeat_tolerance(Duration::from_secs(heartbeat_tolerance)) + .context("set heartbeat tolerence")?; } if let Some(metadata) = &conf.metadata { - builder = builder.metadata(metadata); + builder.metadata(metadata); } if let Some(server_addr) = &conf.server_addr { - builder = builder.server_addr(server_addr); + builder.server_addr(server_addr).context("set server address")?; } info!("Connecting to ngrok service"); @@ -53,23 +60,23 @@ impl NgrokSession { match conf { NgrokTunnelConf::Tcp(tcp_conf) => { - let mut builder = self.inner.tcp_endpoint().remote_addr(&tcp_conf.remote_addr); + let mut builder = self.inner.tcp_endpoint(); + + builder.remote_addr(&tcp_conf.remote_addr); if let Some(metadata) = &tcp_conf.metadata { - builder = builder.metadata(metadata); + builder.metadata(metadata); } let before_cidrs = builder.clone(); - builder = tcp_conf - .allow_cidrs - .iter() - .fold(builder, |builder, cidr| builder.allow_cidr(cidr)); + tcp_conf.allow_cidrs.iter().for_each(|cidr| { + builder.allow_cidr(cidr); + }); - builder = tcp_conf - .deny_cidrs - .iter() - .fold(builder, |builder, cidr| builder.deny_cidr(cidr)); + tcp_conf.deny_cidrs.iter().for_each(|cidr| { + builder.deny_cidr(cidr); + }); // HACK: Find the subscription plan. This uses ngrok-rs internal API, so it’s not great. // Ideally, we could use the `Session` to find out about the subscription plan without dirty tricks. @@ -102,35 +109,31 @@ impl NgrokSession { } } NgrokTunnelConf::Http(http_conf) => { - let mut builder = self - .inner - .http_endpoint() - .domain(&http_conf.domain) - .scheme(Scheme::HTTPS); + let mut builder = self.inner.http_endpoint(); + + builder.domain(&http_conf.domain).scheme(Scheme::HTTPS); if let Some(metadata) = &http_conf.metadata { - builder = builder.metadata(metadata); + builder.metadata(metadata); } if let Some(circuit_breaker) = http_conf.circuit_breaker { - builder = builder.circuit_breaker(circuit_breaker); + builder.circuit_breaker(circuit_breaker); } if matches!(http_conf.compression, Some(true)) { - builder = builder.compression(); + builder.compression(); } let before_cidrs = builder.clone(); - builder = http_conf - .allow_cidrs - .iter() - .fold(builder, |builder, cidr| builder.allow_cidr(cidr)); + http_conf.allow_cidrs.iter().for_each(|cidr| { + builder.allow_cidr(cidr); + }); - builder = http_conf - .deny_cidrs - .iter() - .fold(builder, |builder, cidr| builder.deny_cidr(cidr)); + http_conf.deny_cidrs.iter().for_each(|cidr| { + builder.deny_cidr(cidr); + }); // HACK: Find the subscription plan. This uses ngrok-rs internal API, so it’s not great. // Ideally, we could use the `Session` to find out about the subscription plan without dirty tricks. @@ -184,7 +187,7 @@ impl NgrokTunnel { let hostname = state.conf_handle.get_conf().hostname.clone(); match self.inner { - NgrokTunnelInner::Tcp(builder) => { + NgrokTunnelInner::Tcp(mut builder) => { // Start tunnel with a TCP edge let tunnel = builder .forwards_to(hostname) @@ -196,7 +199,7 @@ impl NgrokTunnel { run_tcp_tunnel(tunnel, state).await; } - NgrokTunnelInner::Http(builder) => { + NgrokTunnelInner::Http(mut builder) => { // Start tunnel with an HTTP edge let tunnel = builder .forwards_to(hostname)