fix(rabbitmq): honor tunnels and management endpoints

This commit is contained in:
t8y2 committed 2026-07-31 13:28:43 +08:00
1 parent dd913b5ab2
commit 9057b746a6
20 files changed
+398 -20

No files matched your search

+115
View File
@@ -2213,6 +2213,60 @@ impl AppState {
return Ok(mqc);
}
if mqc.system_kind == crate::mq::types::MqSystemKind::RabbitMq {
let transport_layers = self.resolved_transport_layers(config).await?;
let (amqp_host, amqp_port) = crate::mq::adapters::rabbitmq::primary_amqp_endpoint(&mqc)?;
let management_endpoint = crate::mq::adapters::rabbitmq::management_endpoint(&mqc)?;
let amqp_local_port = db::transport_layer_tunnel::start_transport_layers(
connection_id,
&transport_layers,
&amqp_host,
amqp_port,
&self.tunnels,
&self.proxy_tunnels,
&self.http_tunnels,
)
.await?;
let mut mqc = mqc.with_connect_override("127.0.0.1", amqp_local_port);
if let Some((management_host, management_port)) = management_endpoint {
let management_transport_id = rabbitmq_management_transport_id(connection_id);
let management_local_port = match db::transport_layer_tunnel::start_transport_layers(
&management_transport_id,
&transport_layers,
&management_host,
management_port,
&self.tunnels,
&self.proxy_tunnels,
&self.http_tunnels,
)
.await
{
Ok(port) => port,
Err(error) => {
db::transport_layer_tunnel::stop_transport_layers(
&management_transport_id,
transport_layers.len(),
&self.tunnels,
&self.proxy_tunnels,
&self.http_tunnels,
)
.await;
db::transport_layer_tunnel::stop_transport_layers(
connection_id,
transport_layers.len(),
&self.tunnels,
&self.proxy_tunnels,
&self.http_tunnels,
)
.await;
return Err(error);
}
};
mqc = mqc.with_management_connect_override("127.0.0.1", management_local_port);
}
return Ok(mqc);
}
let (host, port) = self.connection_host_port(connection_id, config).await?;
Ok(mqc.with_connect_override(&host, port))
}
@@ -3052,6 +3106,14 @@ impl AppState {
&self.http_tunnels,
)
.await;
db::transport_layer_tunnel::stop_transport_layers(
&rabbitmq_management_transport_id(connection_id),
layer_count,
&self.tunnels,
&self.proxy_tunnels,
&self.http_tunnels,
)
.await;
self.tunnels.stop_tunnel(connection_id).await;
self.proxy_tunnels.stop_tunnel(connection_id).await;
self.http_tunnels.stop_tunnel(connection_id).await;
@@ -3618,6 +3680,10 @@ fn rnacos_console_transport_id(connection_id: &str) -> String {
format!("{connection_id}:rnacos-console")
}
fn rabbitmq_management_transport_id(connection_id: &str) -> String {
format!("{connection_id}:rabbitmq-management")
}
fn parse_mq_admin_host_port(config: &ConnectionConfig) -> Option<(String, u16)> {
let value = config
.external_config
@@ -6122,6 +6188,55 @@ for line in sys.stdin:
let _ = std::fs::remove_dir_all(dir);
}
#[cfg(feature = "mq-admin")]
#[tokio::test]
async fn rabbitmq_transport_uses_separate_amqp_and_management_tunnels() {
let (state, dir) = test_app_state().await;
let mut config = mysql_config(None);
config.id = "proxied-rabbitmq".to_string();
config.db_type = DatabaseType::MessageQueue;
config.host = "rabbit.internal".to_string();
config.port = 5672;
config.external_config = Some(serde_json::json!({
"systemKind": "rabbitmq",
"adminUrl": "http://management.internal:15672/rmq",
"auth": { "kind": "none" },
"extra": {
"addresses": "rabbit.internal:5672",
"virtualHost": "/"
}
}));
config.transport_layers = vec![TransportLayerConfig::Proxy(ProxyTunnelConfig {
profile_id: String::new(),
id: "proxy".to_string(),
name: String::new(),
enabled: true,
proxy_type: ProxyType::Socks5,
host: "127.0.0.1".to_string(),
port: 65000,
username: String::new(),
password: String::new(),
test_target: None,
})];
let mqc = state.mq_admin_config_for_connection("proxied-rabbitmq", &config).await.unwrap();
let amqp_override = mqc.connect_override.expect("RabbitMQ AMQP tunnel override");
let management_override = mqc.management_connect_override.expect("RabbitMQ Management tunnel override");
assert_eq!(amqp_override.host, "127.0.0.1");
assert_eq!(management_override.host, "127.0.0.1");
assert_ne!(amqp_override.port, management_override.port);
assert_eq!(state.proxy_tunnels.local_port("proxied-rabbitmq:transport:0").await, Some(amqp_override.port));
assert_eq!(
state.proxy_tunnels.local_port("proxied-rabbitmq:rabbitmq-management:transport:0").await,
Some(management_override.port)
);
state.reset_connection_transport_for_config("proxied-rabbitmq", &config).await;
assert!(state.proxy_tunnels.local_port("proxied-rabbitmq:transport:0").await.is_none());
assert!(state.proxy_tunnels.local_port("proxied-rabbitmq:rabbitmq-management:transport:0").await.is_none());
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test]
async fn nacos_admin_config_allows_domain_server_addr_without_transport_override() {
let (state, dir) = test_app_state().await;
+1
View File
@@ -766,6 +766,7 @@ mod tests {
pinned_version: None,
token_signing: None,
connect_override: None,
management_connect_override: None,
extra,
}
}
@@ -1150,6 +1150,7 @@ mod tests {
pinned_version: Some("3.1".to_string()),
token_signing: None,
connect_override: None,
management_connect_override: None,
extra: serde_json::Value::Null,
})
.await
+106 -1
View File
@@ -861,7 +861,73 @@ fn extra_port(extra: &serde_json::Value) -> Result<u16, String> {
}
}
/// Build the connection params JSON from MqAdminConfig for the Java agent.
fn configured_management_port(cfg: &MqAdminConfig) -> Result<Option<u16>, String> {
let Some(value) = cfg.extra.get("properties").and_then(|value| value.get("management_port")) else {
return Ok(None);
};
let port = if let Some(port) = value.as_u64() {
u16::try_from(port).map_err(|_| format!("RabbitMQ management port {port} is out of range (1-65535)"))?
} else if let Some(port) = value.as_str() {
port.trim().parse::<u16>().map_err(|_| format!("invalid RabbitMQ management port '{port}'"))?
} else {
return Err("RabbitMQ management port must be a number or a numeric string".to_string());
};
if port == 0 {
return Err("RabbitMQ management port must be between 1 and 65535".to_string());
}
Ok(Some(port))
}
pub(crate) fn primary_amqp_endpoint(cfg: &MqAdminConfig) -> Result<(String, u16), String> {
let address_list = addresses(cfg);
let first = address_list
.split(',')
.map(str::trim)
.find(|address| !address.is_empty())
.ok_or("RabbitMQ addresses are empty")?;
let parsed = reqwest::Url::parse(&format!("amqp://{first}"))
.map_err(|error| format!("RabbitMQ address '{first}' is invalid: {error}"))?;
let host = parsed
.host_str()
.filter(|host| !host.is_empty())
.ok_or_else(|| format!("RabbitMQ address '{first}' has no host"))?;
Ok((host.to_string(), parsed.port().unwrap_or(extra_port(&cfg.extra)?)))
}
/// Resolve the independently configured RabbitMQ Management HTTP endpoint.
///
/// A blank admin URL is only safe to derive for RabbitMQ's default AMQP ports.
/// Custom AMQP listeners do not define the Management listener port, so callers
/// must not silently fall back to another broker's default port 15672/15671.
pub(crate) fn management_endpoint(cfg: &MqAdminConfig) -> Result<Option<(String, u16)>, String> {
if !cfg.admin_url.trim().is_empty() {
let parsed = reqwest::Url::parse(cfg.admin_url.trim())
.map_err(|error| format!("RabbitMQ Management API URL is invalid: {error}"))?;
let host = parsed
.host_str()
.filter(|host| !host.is_empty())
.ok_or("RabbitMQ Management API URL does not include a host")?;
let port = parsed.port_or_known_default().ok_or("RabbitMQ Management API URL does not include a port")?;
return Ok(Some((host.to_string(), port)));
}
let (host, amqp_port) = primary_amqp_endpoint(cfg)?;
if let Some(port) = configured_management_port(cfg)? {
return Ok(Some((host, port)));
}
let tls_enabled =
cfg.extra.get("properties").and_then(|properties| properties.as_object()).is_some_and(|properties| {
properties.get("ssl").and_then(|value| value.as_bool()).unwrap_or(false)
|| properties.get("tls").and_then(|value| value.as_bool()).unwrap_or(false)
});
let is_default_amqp_port = amqp_port == 5672 || (tls_enabled && amqp_port == 5671);
if !is_default_amqp_port {
return Ok(None);
}
Ok(Some((host, if tls_enabled { 15671 } else { 15672 })))
}
/// Build the connection params JSON from MqAdminConfig for the native agent.
/// Blank credentials are omitted so the agent falls back to its guest/guest
/// default instead of authenticating as `:`. A non-empty `admin_url` is
/// forwarded as `management_url`; otherwise the agent derives the management
@@ -894,6 +960,18 @@ fn build_connection_params(cfg: &MqAdminConfig) -> Result<serde_json::Value, Str
if !cfg.admin_url.trim().is_empty() {
params["management_url"] = serde_json::json!(cfg.admin_url);
}
if let Some(connect_override) = &cfg.connect_override {
params["connect_override"] = serde_json::json!({
"host": connect_override.host,
"port": connect_override.port,
});
}
if let Some(connect_override) = &cfg.management_connect_override {
params["management_connect_override"] = serde_json::json!({
"host": connect_override.host,
"port": connect_override.port,
});
}
Ok(params)
}
@@ -946,6 +1024,7 @@ mod tests {
pinned_version: None,
token_signing: None,
connect_override: None,
management_connect_override: None,
extra,
}
}
@@ -1046,10 +1125,36 @@ mod tests {
false,
);
cfg.admin_url = "http://rabbit.internal:15672/proxy".to_string();
cfg = cfg.with_connect_override("127.0.0.1", 45672).with_management_connect_override("127.0.0.1", 45673);
let params = build_connection_params(&cfg).expect("connection params");
assert_eq!(params.get("management_url").and_then(|v| v.as_str()), Some("http://rabbit.internal:15672/proxy"));
assert_eq!(params.pointer("/connect_override/host").and_then(|v| v.as_str()), Some("127.0.0.1"));
assert_eq!(params.pointer("/connect_override/port").and_then(|v| v.as_u64()), Some(45672));
assert_eq!(params.pointer("/management_connect_override/host").and_then(|v| v.as_str()), Some("127.0.0.1"));
assert_eq!(params.pointer("/management_connect_override/port").and_then(|v| v.as_u64()), Some(45673));
}
#[test]
fn management_endpoint_does_not_guess_for_custom_amqp_port() {
let custom = rabbitmq_config(serde_json::json!({ "addresses": "rabbit.internal:5673" }), MqAuth::None, false);
assert_eq!(primary_amqp_endpoint(&custom).unwrap(), ("rabbit.internal".to_string(), 5673));
assert_eq!(management_endpoint(&custom).unwrap(), None);
let configured = rabbitmq_config(
serde_json::json!({
"addresses": "rabbit.internal:5673",
"properties": { "management_port": 15673 }
}),
MqAuth::None,
false,
);
assert_eq!(management_endpoint(&configured).unwrap(), Some(("rabbit.internal".to_string(), 15673)));
let mut explicit = custom;
explicit.admin_url = "https://management.internal:8443/rmq".to_string();
assert_eq!(management_endpoint(&explicit).unwrap(), Some(("management.internal".to_string(), 8443)));
}
#[test]
@@ -966,6 +966,7 @@ mod tests {
pinned_version: None,
token_signing: None,
connect_override: None,
management_connect_override: None,
extra,
}
}
+15 -5
View File
@@ -10,12 +10,12 @@ use crate::models::connection::ConnectionConfig;
use crate::mq::auth::MqAuth;
use crate::mq::types::{MqSystemKind, MqTokenSigningConfig};
/// Runtime TCP endpoint override for MQ admin requests.
/// Runtime TCP endpoint override for an MQ transport.
///
/// The public admin URL remains unchanged so TLS hostname verification, SNI and
/// the HTTP Host header continue to target the broker name. The HTTP client uses
/// this endpoint only for the underlying TCP connection, e.g. after an SSH/proxy
/// tunnel has mapped the broker to a local port.
/// The logical broker endpoint remains unchanged so TLS hostname verification,
/// SNI and protocol-level host names continue to target the broker. The client
/// uses this endpoint only for the underlying TCP connection, e.g. after an
/// SSH/proxy tunnel has mapped the broker to a local port.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MqConnectOverride {
@@ -48,6 +48,11 @@ pub struct MqAdminConfig {
/// Runtime-only TCP endpoint override used by transport layers.
#[serde(skip)]
pub connect_override: Option<MqConnectOverride>,
/// Runtime-only TCP endpoint override for a secondary management endpoint.
/// RabbitMQ uses this in addition to the AMQP `connect_override` because
/// its Management HTTP API listens on an independently configured port.
#[serde(skip)]
pub management_connect_override: Option<MqConnectOverride>,
/// System-specific extension fields (e.g. Kafka bootstrap servers).
#[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
pub extra: serde_json::Value,
@@ -87,6 +92,11 @@ impl MqAdminConfig {
self.connect_override = Some(MqConnectOverride { host: host.to_string(), port });
self
}
pub fn with_management_connect_override(mut self, host: &str, port: u16) -> Self {
self.management_connect_override = Some(MqConnectOverride { host: host.to_string(), port });
self
}
}
pub fn admin_url_with_endpoint(admin_url: &str, host: &str, port: u16) -> Result<String, String> {