fix(rocketmq): route tunneled traffic through SOCKS5

Closes #5742
This commit is contained in:
t8y2 committed 2026-08-11 03:16:08 +08:00
1 parent 2e9ed477a4
commit 5351fc5066
11 files changed
+883 -26

No files matched your search

+1
View File
@@ -803,6 +803,7 @@ mod tests {
token_signing: None,
connect_override: None,
management_connect_override: None,
socks_proxy: None,
query_timeout_secs: crate::mq::config::DEFAULT_MQ_QUERY_TIMEOUT_SECS,
connect_timeout_secs: crate::mq::config::DEFAULT_MQ_CONNECT_TIMEOUT_SECS,
extra,
@@ -1154,6 +1154,7 @@ mod tests {
token_signing: None,
connect_override: None,
management_connect_override: None,
socks_proxy: None,
query_timeout_secs: crate::mq::config::DEFAULT_MQ_QUERY_TIMEOUT_SECS,
connect_timeout_secs: crate::mq::config::DEFAULT_MQ_CONNECT_TIMEOUT_SECS,
extra: serde_json::Value::Null,
@@ -1029,6 +1029,7 @@ mod tests {
token_signing: None,
connect_override: None,
management_connect_override: None,
socks_proxy: None,
query_timeout_secs: crate::mq::config::DEFAULT_MQ_QUERY_TIMEOUT_SECS,
connect_timeout_secs: crate::mq::config::DEFAULT_MQ_CONNECT_TIMEOUT_SECS,
extra,
+154 -1
View File
@@ -842,6 +842,12 @@ fn build_connection_params(cfg: &MqAdminConfig) -> serde_json::Value {
"tls_skip_verify": cfg.tls_skip_verify,
"request_timeout_ms": cfg.request_timeout_ms(),
"connect_timeout_ms": cfg.connect_timeout_ms(),
"socks_proxy": cfg.socks_proxy.as_ref().map(|proxy| serde_json::json!({
"host": proxy.host,
"port": proxy.port,
"username": proxy.username,
"password": proxy.password,
})),
})
}
@@ -952,7 +958,90 @@ fn rocketmq_subscription_from_group(group: &serde_json::Value) -> SubscriptionIn
/// Fail fast on unreachable NameServer before paying for JVM agent startup.
/// Called outside the connect-timeout wall so the probe does not steal JVM budget.
pub(crate) async fn probe_namesrv_before_connect(cfg: &MqAdminConfig, budget: Duration) -> Result<(), String> {
probe_namesrv_tcp(&namesrv_addr(cfg), budget).await
if let Some(proxy) = &cfg.socks_proxy {
probe_namesrv_via_socks5(&namesrv_addr(cfg), proxy, budget).await
} else {
probe_namesrv_tcp(&namesrv_addr(cfg), budget).await
}
}
async fn probe_namesrv_via_socks5(
namesrv: &str,
proxy: &crate::mq::config::MqSocksProxy,
budget: Duration,
) -> Result<(), String> {
let targets: Vec<String> =
namesrv.split(';').map(str::trim).filter(|part| !part.is_empty()).map(str::to_string).collect();
if targets.is_empty() {
return Err("RocketMQ namesrv_addr is empty".to_string());
}
let deadline = tokio::time::Instant::now() + budget;
let per_attempt =
if targets.len() <= 1 { budget } else { (budget / targets.len() as u32).max(Duration::from_millis(500)) };
let mut last_error = String::new();
for target in targets {
let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
if remaining.is_zero() {
break;
}
let (host, port) = match parse_namesrv_target(&target) {
Ok(endpoint) => endpoint,
Err(error) => {
last_error = error;
continue;
}
};
let attempt = remaining.min(per_attempt);
match timeout(
attempt,
crate::db::proxy_tunnel::connect_via_socks5_proxy(
&proxy.host,
proxy.port,
&proxy.username,
&proxy.password,
&host,
port,
),
)
.await
{
Ok(Ok(_stream)) => return Ok(()),
Ok(Err(error)) => {
last_error = format!("Cannot reach RocketMQ NameServer {target} through SOCKS5 proxy: {error}");
}
Err(_) => {
last_error = format!(
"RocketMQ NameServer {target} connect through SOCKS5 proxy timed out after {}ms",
attempt.as_millis()
);
}
}
}
Err(if last_error.is_empty() {
format!("RocketMQ NameServer connect through SOCKS5 proxy timed out after {}s", budget.as_secs())
} else {
last_error
})
}
fn parse_namesrv_target(target: &str) -> Result<(String, u16), String> {
let target = target.trim();
let (host, port) = if let Some(rest) = target.strip_prefix('[') {
let (host, port) =
rest.split_once("]:").ok_or_else(|| format!("RocketMQ NameServer address '{target}' is invalid"))?;
(host, port)
} else {
target.rsplit_once(':').ok_or_else(|| format!("RocketMQ NameServer address '{target}' is invalid"))?
};
if host.trim().is_empty() {
return Err(format!("RocketMQ NameServer address '{target}' is invalid"));
}
let port = port
.trim()
.parse::<u16>()
.map_err(|_| format!("RocketMQ NameServer address '{target}' has an invalid port"))?;
Ok((host.trim().to_string(), port))
}
/// Probe NameServer addresses so connect fails before spawning the JVM agent.
@@ -1060,7 +1149,10 @@ fn peeked_message_from_agent_json(idx: usize, message: &serde_json::Value) -> Pe
mod tests {
use super::*;
use crate::mq::auth::MqAuth;
use crate::mq::config::MqSocksProxy;
use crate::mq::types::MqSystemKind;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
fn rocketmq_config(extra: serde_json::Value, auth: MqAuth) -> MqAdminConfig {
MqAdminConfig {
@@ -1072,6 +1164,7 @@ mod tests {
token_signing: None,
connect_override: None,
management_connect_override: None,
socks_proxy: None,
query_timeout_secs: crate::mq::config::DEFAULT_MQ_QUERY_TIMEOUT_SECS,
connect_timeout_secs: crate::mq::config::DEFAULT_MQ_CONNECT_TIMEOUT_SECS,
extra,
@@ -1084,6 +1177,41 @@ mod tests {
assert!(err.contains("empty"), "{err}");
}
#[tokio::test]
async fn probe_namesrv_uses_socks_proxy_for_logical_target() {
let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let proxy_port = listener.local_addr().unwrap().port();
let (target_tx, target_rx) = tokio::sync::oneshot::channel();
let proxy_task = tokio::spawn(async move {
let (mut stream, _) = listener.accept().await.unwrap();
let mut greeting = [0_u8; 3];
stream.read_exact(&mut greeting).await.unwrap();
assert_eq!(greeting, [0x05, 0x01, 0x00]);
stream.write_all(&[0x05, 0x00]).await.unwrap();
let mut request = [0_u8; 10];
stream.read_exact(&mut request).await.unwrap();
assert_eq!(&request[..4], &[0x05, 0x01, 0x00, 0x01]);
let host = std::net::Ipv4Addr::new(request[4], request[5], request[6], request[7]).to_string();
let port = u16::from_be_bytes([request[8], request[9]]);
let _ = target_tx.send((host, port));
stream.write_all(&[0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0]).await.unwrap();
});
let mut cfg = rocketmq_config(serde_json::json!({ "namesrvAddr": "172.19.191.166:9876" }), MqAuth::None);
cfg.socks_proxy = Some(MqSocksProxy {
host: "127.0.0.1".to_string(),
port: proxy_port,
username: String::new(),
password: String::new(),
});
probe_namesrv_before_connect(&cfg, Duration::from_secs(2)).await.unwrap();
assert_eq!(target_rx.await.unwrap(), ("172.19.191.166".to_string(), 9876));
proxy_task.await.unwrap();
}
#[test]
fn connection_params_map_namesrv_and_acl_credentials() {
let cfg = rocketmq_config(
@@ -1118,6 +1246,31 @@ mod tests {
assert_eq!(params.get("connect_timeout_ms").and_then(|v| v.as_u64()), Some(15_000));
}
#[test]
fn connection_params_include_runtime_socks_proxy() {
let mut cfg = rocketmq_config(serde_json::json!({ "namesrvAddr": "mq.internal:9876" }), MqAuth::None);
cfg.socks_proxy = Some(MqSocksProxy {
host: "127.0.0.1".to_string(),
port: 41080,
username: "proxy-user".to_string(),
password: "proxy-secret".to_string(),
});
let params = build_connection_params(&cfg);
assert_eq!(params.pointer("/socks_proxy/host").and_then(|v| v.as_str()), Some("127.0.0.1"));
assert_eq!(params.pointer("/socks_proxy/port").and_then(|v| v.as_u64()), Some(41080));
assert_eq!(params.pointer("/socks_proxy/username").and_then(|v| v.as_str()), Some("proxy-user"));
assert_eq!(params.pointer("/socks_proxy/password").and_then(|v| v.as_str()), Some("proxy-secret"));
}
#[test]
fn parse_namesrv_target_accepts_ipv4_domain_and_ipv6() {
assert_eq!(parse_namesrv_target("172.19.191.166:9876").unwrap(), ("172.19.191.166".to_string(), 9876));
assert_eq!(parse_namesrv_target("mq.internal:9876").unwrap(), ("mq.internal".to_string(), 9876));
assert_eq!(parse_namesrv_target("[2001:db8::1]:9876").unwrap(), ("2001:db8::1".to_string(), 9876));
}
#[test]
fn reset_cursor_params_preserve_timestamp_position() {
let topic = TopicRef {
+23
View File
@@ -30,6 +30,17 @@ pub struct MqConnectOverride {
pub port: u16,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MqSocksProxy {
pub host: String,
pub port: u16,
#[serde(default)]
pub username: String,
#[serde(default)]
pub password: String,
}
/// Configuration for an MQ admin connection, decoded from
/// `ConnectionConfig.external_config`.
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -60,6 +71,8 @@ pub struct MqAdminConfig {
/// its Management HTTP API listens on an independently configured port.
#[serde(skip)]
pub management_connect_override: Option<MqConnectOverride>,
#[serde(skip)]
pub socks_proxy: Option<MqSocksProxy>,
/// Runtime-only: from `ConnectionConfig.query_timeout_secs` (`0` = unlimited).
#[serde(skip)]
pub query_timeout_secs: u64,
@@ -141,6 +154,16 @@ impl MqAdminConfig {
self.management_connect_override = Some(MqConnectOverride { host: host.to_string(), port });
self
}
pub fn with_socks_proxy(mut self, host: &str, port: u16, username: &str, password: &str) -> Self {
self.socks_proxy = Some(MqSocksProxy {
host: host.to_string(),
port,
username: username.to_string(),
password: password.to_string(),
});
self
}
}
pub fn admin_url_with_endpoint(admin_url: &str, host: &str, port: u16) -> Result<String, String> {