feat(mq): implement Apache Pulsar message queue admin

* feat(mq): implement Apache Pulsar message queue admin

- Add complete MQ admin adapter layer with version detection
  * Pulsar adapter with multi-version API support
  * OAuth2 token caching and authentication
  * JWT token signing for Pulsar clients
  * Transport layer (SSH/Proxy) integration

- Implement comprehensive admin operations
  * Tenant, namespace, topic management
  * Subscription and consumer/producer monitoring
  * Rate limits, backlog quotas, retention policies
  * Permissions and role-based access control
  * Raw admin API for advanced operations

- Add desktop UI components
  * MQ admin console with tabbed interface
  * Tenant, namespace, topic panels
  * Subscription management and cursor operations
  * Monitoring panel with stats visualization
  * Policy configuration UI

- Add web routes for MQ admin operations
- Add secret store support for MQ auth credentials
- Add comprehensive test coverage

* fix: del local test files

* fix(mq): mark message queue as unsupported mcpMode in driver manifest

MQ admin connections do not use the MCP query bridge - they use a
separate REST admin API. Mark mcpMode as 'unsupported' to align with
the test expectations and reflect the actual architecture.

Fixes CI test: driver-manifest.test.ts

* fix(mq): fix TypeScript errors in MQ components

- Fix typo in SubscriptionsPanel.vue: messagformatError(e)Id -> message.messageId
- Use formatError() helper in RawApiPanel.vue instead of accessing e?.message
- Fix undefined 'tab' reference in ConnectionTree.vue: use config.db_type instead

Fixes frontend CI TypeScript check errors.

* fix(mcp): add 'mq' to MCP server connection type description

The MCP server's connection type description must include all database
types from the driver manifest. Add 'mq' to the list to fix the test:
'add connection database type description includes every manifest database type'

Fixes: packages/mcp-server/tests/driver-manifest.test.ts

* fix(mq): add missing ConnectionConfig fields for Rust compilation

- Add gbase_server and keepalive_interval_secs fields to all ConnectionConfig
  test constructors in mq/config.rs, mq/service.rs, and storage.rs
- Import uses_bare_mysql_pool in connection.rs tests module

Fixes compilation errors from upstream ConnectionConfig changes.

* chore(ui): simplify Pulsar icon to logo-only version

Remove text from Pulsar icon (127x30 -> 35x30), keeping only
the wave logo symbol for a cleaner, more consistent appearance
with other database icons.

* fix(mq): return removed pools from drain_connection_pools

---------

Co-authored-by: t8y2 <1156263951@qq.com>
This commit is contained in:
miracleandt8y2 authored and GitHub committed 2026-06-16 21:57:17 +08:00
1 parent 8339d23df5
commit 2a59d3143e
83 files changed
+15979 -37

No files matched your search

+542 -1
View File
@@ -6,9 +6,13 @@ use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::ai::{AiChatMessage, AiConfig, AiConversation};
use crate::connection_secrets::{
MQ_AUTH_API_KEY_VALUE_KEY, MQ_AUTH_CLIENT_SECRET_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_SECRET_PREFIX,
MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, MQ_TOKEN_SIGNING_SECRET_PREFIX,
};
use crate::db::sqlite::{connect_path_create_if_missing, SqliteHandle};
use crate::history::{HistoryEntry, MAX_HISTORY};
use crate::models::connection::{ConnectionConfig, TransportLayerConfig};
use crate::models::connection::{ConnectionConfig, DatabaseType, TransportLayerConfig};
use crate::saved_sql::{SavedSqlFile, SavedSqlFolder, SavedSqlLibrary};
const SSH_TUNNEL_SECRET_PREFIX: &str = "ssh_tunnels.";
@@ -136,6 +140,22 @@ const SCHEMA_STATEMENTS: &[&str] = &[
byte_size INTEGER NOT NULL DEFAULT 0,
updated_at TEXT NOT NULL
)",
"CREATE TABLE IF NOT EXISTS mq_token_records (
id TEXT PRIMARY KEY,
connection_id TEXT NOT NULL,
subject TEXT NOT NULL,
algorithm TEXT NOT NULL,
token_fingerprint TEXT NOT NULL,
scope_json TEXT,
actions_json TEXT NOT NULL DEFAULT '[]',
expires_at TEXT,
created_at TEXT NOT NULL,
note TEXT NOT NULL DEFAULT ''
)",
"CREATE INDEX IF NOT EXISTS idx_mq_token_records_connection_subject
ON mq_token_records (connection_id, subject, created_at DESC)",
"CREATE INDEX IF NOT EXISTS idx_mq_token_records_fingerprint
ON mq_token_records (token_fingerprint)",
"CREATE TABLE IF NOT EXISTS saved_sql_folders (
id TEXT PRIMARY KEY,
connection_id TEXT NOT NULL,
@@ -302,6 +322,32 @@ fn scrub_transport_layer_secrets(config: &mut ConnectionConfig) {
}
}
fn scrub_mq_auth_secrets(config: &mut ConnectionConfig) {
if config.db_type != DatabaseType::MessageQueue {
return;
}
let Some(auth) = mq_auth_object_mut(config.external_config.as_mut()) else {
return;
};
match mq_auth_kind(auth) {
Some("token") => scrub_json_secret(auth, "token"),
Some("basic") => scrub_json_secret(auth, "password"),
Some(kind) if is_api_key_auth_kind(kind) => scrub_json_secret(auth, "value"),
Some("oauth2") => scrub_json_secret(auth, "clientSecret"),
_ => {}
}
}
fn scrub_mq_token_signing_secret(config: &mut ConnectionConfig) {
if config.db_type != DatabaseType::MessageQueue {
return;
}
let Some(signing) = mq_token_signing_object_mut(config.external_config.as_mut()) else {
return;
};
scrub_json_secret(signing, "key");
}
fn delete_secret_prefix_in_tx(
tx: &rusqlite::Transaction<'_>,
connection_id: &str,
@@ -736,6 +782,8 @@ impl Storage {
scrub_transport_layer_secrets(&mut sanitized);
sanitized.redis_sentinel_password = String::new();
sanitized.connection_string = None;
scrub_mq_auth_secrets(&mut sanitized);
scrub_mq_token_signing_secret(&mut sanitized);
let json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;
tx.execute("INSERT INTO connections (id, config_json) VALUES (?1, ?2)", params![config_id, json])
@@ -770,6 +818,8 @@ impl Storage {
scrub_transport_layer_secrets(&mut sanitized);
sanitized.redis_sentinel_password = String::new();
sanitized.connection_string = None;
scrub_mq_auth_secrets(&mut sanitized);
scrub_mq_token_signing_secret(&mut sanitized);
let json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;
tx.execute("INSERT INTO connections (id, config_json) VALUES (?1, ?2)", params![config_id, json])
@@ -817,6 +867,8 @@ impl Storage {
)
.map_err(|e| e.to_string())?;
}
persist_mq_auth_secrets_in_tx(&tx, &config)?;
persist_mq_token_signing_secret_in_tx(&tx, &config)?;
}
if configs.is_empty() {
@@ -895,10 +947,73 @@ impl Storage {
}
config.redis_sentinel_password = self.get_secret(&id, "redis_sentinel_password").await?.unwrap_or_default();
config.connection_string = self.get_secret(&id, "connection_string").await?;
let needs_mq_auth_rewrite = self.hydrate_mq_auth_secrets(&id, &mut config).await?;
let needs_mq_token_signing_rewrite = self.hydrate_mq_token_signing_secret(&id, &mut config).await?;
let needs_mq_secret_rewrite = needs_mq_auth_rewrite || needs_mq_token_signing_rewrite;
if needs_mq_secret_rewrite {
let mut sanitized = config.clone().canonicalized();
scrub_mq_auth_secrets(&mut sanitized);
scrub_mq_token_signing_secret(&mut sanitized);
let sanitized_json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;
let update_id = id.clone();
self.with_conn(move |conn| {
conn.execute(
"UPDATE connections SET config_json = ?1 WHERE id = ?2",
params![sanitized_json, update_id],
)
.map(|_| ())
.map_err(|e| e.to_string())
})
.await?;
}
configs.push(config.canonicalized());
}
Ok(configs)
}
async fn hydrate_mq_auth_secrets(
&self,
connection_id: &str,
config: &mut ConnectionConfig,
) -> Result<bool, String> {
if config.db_type != DatabaseType::MessageQueue {
return Ok(false);
}
let Some(auth) = mq_auth_object_mut(config.external_config.as_mut()) else {
return Ok(false);
};
let needs_rewrite = match mq_auth_kind(auth) {
Some("token") => hydrate_mq_json_secret(self, connection_id, MQ_AUTH_TOKEN_KEY, auth, "token").await?,
Some("basic") => {
hydrate_mq_json_secret(self, connection_id, MQ_AUTH_PASSWORD_KEY, auth, "password").await?
}
Some(kind) if is_api_key_auth_kind(kind) => {
hydrate_mq_json_secret(self, connection_id, MQ_AUTH_API_KEY_VALUE_KEY, auth, "value").await?
}
Some("oauth2") => {
hydrate_mq_json_secret(self, connection_id, MQ_AUTH_CLIENT_SECRET_KEY, auth, "clientSecret").await?
}
_ => false,
};
Ok(needs_rewrite)
}
async fn hydrate_mq_token_signing_secret(
&self,
connection_id: &str,
config: &mut ConnectionConfig,
) -> Result<bool, String> {
if config.db_type != DatabaseType::MessageQueue {
return Ok(false);
}
let Some(signing) = mq_token_signing_object_mut(config.external_config.as_mut()) else {
return Ok(false);
};
hydrate_mq_json_secret(self, connection_id, MQ_TOKEN_SIGNING_KEY, signing, "key").await
}
}
// Saved SQL
@@ -1166,6 +1281,76 @@ impl Storage {
}
}
// MQ token records
#[cfg(feature = "mq-admin")]
impl Storage {
pub async fn save_mq_token_record(&self, record: &crate::mq::MqTokenRecord) -> Result<(), String> {
let record = record.clone();
self.with_conn(move |conn| {
let scope_json = record
.scope
.as_ref()
.map(serde_json::to_string)
.transpose()
.map_err(|e| e.to_string())?;
let actions_json = serde_json::to_string(&record.actions).map_err(|e| e.to_string())?;
conn.execute(
"INSERT OR REPLACE INTO mq_token_records \
(id, connection_id, subject, algorithm, token_fingerprint, scope_json, actions_json, expires_at, created_at, note) \
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
params![
record.id,
record.connection_id,
record.subject,
record.algorithm.as_str(),
record.token_fingerprint,
scope_json,
actions_json,
record.expires_at,
record.created_at,
record.note
],
)
.map(|_| ())
.map_err(|e| e.to_string())
})
.await
}
pub async fn load_mq_token_records(
&self,
connection_id: &str,
subject: Option<&str>,
) -> Result<Vec<crate::mq::MqTokenRecord>, String> {
let connection_id = connection_id.to_string();
let subject = subject.map(str::to_string);
self.with_conn(move |conn| {
let sql = if subject.is_some() {
"SELECT id, connection_id, subject, algorithm, token_fingerprint, scope_json, actions_json, expires_at, created_at, note \
FROM mq_token_records WHERE connection_id = ?1 AND subject = ?2 ORDER BY created_at DESC"
} else {
"SELECT id, connection_id, subject, algorithm, token_fingerprint, scope_json, actions_json, expires_at, created_at, note \
FROM mq_token_records WHERE connection_id = ?1 ORDER BY created_at DESC"
};
let mut stmt = conn.prepare(sql).map_err(|e| e.to_string())?;
let rows = if let Some(subject) = subject {
stmt.query_map(params![connection_id, subject], mq_token_record_from_row)
.map_err(|e| e.to_string())?
.collect::<Result<Vec<_>, _>>()
.map_err(|e| e.to_string())?
} else {
stmt.query_map(params![connection_id], mq_token_record_from_row)
.map_err(|e| e.to_string())?
.collect::<Result<Vec<_>, _>>()
.map_err(|e| e.to_string())?
};
Ok(rows)
})
.await
}
}
// Layout
impl Storage {
@@ -1480,6 +1665,163 @@ fn persist_secret_in_tx(
Ok(())
}
fn persist_mq_auth_secrets_in_tx(tx: &rusqlite::Transaction<'_>, config: &ConnectionConfig) -> Result<(), String> {
if config.db_type != DatabaseType::MessageQueue {
delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?;
return Ok(());
}
let Some(auth) = mq_auth_object(config.external_config.as_ref()) else {
delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?;
return Ok(());
};
match mq_auth_kind(auth) {
Some("none") => delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?,
Some("token") => replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_TOKEN_KEY, auth, "token")?,
Some("basic") => replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_PASSWORD_KEY, auth, "password")?,
Some(kind) if is_api_key_auth_kind(kind) => {
replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_API_KEY_VALUE_KEY, auth, "value")?
}
Some("oauth2") => {
replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_CLIENT_SECRET_KEY, auth, "clientSecret")?
}
_ => delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?,
}
Ok(())
}
fn replace_mq_auth_secret_in_tx(
tx: &rusqlite::Transaction<'_>,
connection_id: &str,
key: &str,
auth: &serde_json::Map<String, serde_json::Value>,
field: &str,
) -> Result<(), String> {
let current = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty());
let existing = if current.is_none() { get_secret_in_tx(tx, connection_id, key)? } else { None };
delete_secret_prefix_in_tx(tx, connection_id, MQ_AUTH_SECRET_PREFIX)?;
match current {
Some(secret) => persist_secret_in_tx(tx, connection_id, key, secret),
None => match existing {
Some(secret) => persist_secret_in_tx(tx, connection_id, key, &secret),
None => Ok(()),
},
}
}
fn get_secret_in_tx(tx: &rusqlite::Transaction<'_>, connection_id: &str, key: &str) -> Result<Option<String>, String> {
tx.query_row(
"SELECT secret FROM connection_secrets WHERE connection_id = ?1 AND key = ?2",
params![connection_id, key],
|row| row.get(0),
)
.optional()
.map_err(|e| e.to_string())
}
fn persist_mq_token_signing_secret_in_tx(
tx: &rusqlite::Transaction<'_>,
config: &ConnectionConfig,
) -> Result<(), String> {
if config.db_type != DatabaseType::MessageQueue {
delete_secret_prefix_in_tx(tx, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;
return Ok(());
}
let Some(signing) = mq_token_signing_object(config.external_config.as_ref()) else {
delete_secret_prefix_in_tx(tx, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;
return Ok(());
};
persist_json_secret_if_present_in_tx(tx, &config.id, MQ_TOKEN_SIGNING_KEY, signing, "key")
}
fn persist_json_secret_if_present_in_tx(
tx: &rusqlite::Transaction<'_>,
connection_id: &str,
key: &str,
auth: &serde_json::Map<String, serde_json::Value>,
field: &str,
) -> Result<(), String> {
if let Some(secret) = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty()) {
persist_secret_in_tx(tx, connection_id, key, secret)?;
}
Ok(())
}
async fn hydrate_mq_json_secret(
storage: &Storage,
connection_id: &str,
key: &str,
auth: &mut serde_json::Map<String, serde_json::Value>,
field: &str,
) -> Result<bool, String> {
if let Some(secret) = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty()) {
storage.set_secret(connection_id, key, secret).await?;
Ok(true)
} else if let Some(secret) = storage.get_secret(connection_id, key).await? {
auth.insert(field.to_string(), serde_json::Value::String(secret));
Ok(false)
} else {
Ok(false)
}
}
fn scrub_json_secret(auth: &mut serde_json::Map<String, serde_json::Value>, field: &str) {
if auth.contains_key(field) {
auth.insert(field.to_string(), serde_json::Value::String(String::new()));
}
}
fn mq_auth_kind(auth: &serde_json::Map<String, serde_json::Value>) -> Option<&str> {
auth.get("kind").and_then(serde_json::Value::as_str)
}
fn mq_auth_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {
value?.get("auth")?.as_object()
}
fn mq_auth_object_mut(
value: Option<&mut serde_json::Value>,
) -> Option<&mut serde_json::Map<String, serde_json::Value>> {
value?.get_mut("auth")?.as_object_mut()
}
fn mq_token_signing_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {
value?.get("tokenSigning")?.as_object()
}
fn mq_token_signing_object_mut(
value: Option<&mut serde_json::Value>,
) -> Option<&mut serde_json::Map<String, serde_json::Value>> {
value?.get_mut("tokenSigning")?.as_object_mut()
}
fn is_api_key_auth_kind(kind: &str) -> bool {
matches!(kind, "apiKey" | "api_key" | "apikey")
}
#[cfg(feature = "mq-admin")]
fn mq_token_record_from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<crate::mq::MqTokenRecord> {
let algorithm: String = row.get(3)?;
let scope_json: Option<String> = row.get(5)?;
let actions_json: String = row.get(6)?;
Ok(crate::mq::MqTokenRecord {
id: row.get(0)?,
connection_id: row.get(1)?,
subject: row.get(2)?,
algorithm: serde_json::from_value(serde_json::Value::String(algorithm)).map_err(map_from_sql_err)?,
token_fingerprint: row.get(4)?,
scope: scope_json.as_deref().map(serde_json::from_str).transpose().map_err(map_from_sql_err)?,
actions: serde_json::from_str(&actions_json).map_err(map_from_sql_err)?,
expires_at: row.get(7)?,
created_at: row.get(8)?,
note: row.get(9)?,
})
}
fn map_from_sql_err(err: serde_json::Error) -> rusqlite::Error {
rusqlite::Error::FromSqlConversionFailure(0, rusqlite::types::Type::Text, Box::new(err))
}
@@ -1487,6 +1829,8 @@ fn map_from_sql_err(err: serde_json::Error) -> rusqlite::Error {
#[cfg(test)]
mod tests {
use super::{DesktopIconTheme, DesktopSettings, Storage};
use crate::connection_secrets::{MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY};
use crate::models::connection::{ConnectionConfig, DatabaseType};
use std::time::{SystemTime, UNIX_EPOCH};
fn temp_db_path(name: &str) -> std::path::PathBuf {
@@ -1494,6 +1838,203 @@ mod tests {
std::env::temp_dir().join(format!("dbx-storage-{name}-{}-{stamp}.db", std::process::id()))
}
fn mq_connection(id: &str, token: &str) -> ConnectionConfig {
ConnectionConfig {
id: id.to_string(),
name: "Pulsar".to_string(),
db_type: DatabaseType::MessageQueue,
driver_profile: Some("pulsar".to_string()),
driver_label: Some("Apache Pulsar".to_string()),
url_params: None,
host: "127.0.0.1".to_string(),
port: 8080,
username: String::new(),
password: String::new(),
database: None,
visible_databases: None,
attached_databases: Vec::new(),
color: None,
transport_layers: Vec::new(),
connect_timeout_secs: 30,
query_timeout_secs: 300,
idle_timeout_secs: 600,
keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
ssl: false,
ca_cert_path: String::new(),
client_cert_path: String::new(),
client_key_path: String::new(),
sysdba: false,
oracle_connection_type: None,
connection_string: None,
redis_connection_mode: None,
redis_sentinel_master: String::new(),
redis_sentinel_nodes: String::new(),
redis_sentinel_username: String::new(),
redis_sentinel_password: String::new(),
redis_sentinel_tls: false,
redis_cluster_nodes: String::new(),
redis_key_separator: ":".to_string(),
etcd_endpoints: String::new(),
gbase_server: String::new(),
external_config: Some(serde_json::json!({
"systemKind": "pulsar",
"adminUrl": "http://127.0.0.1:8080",
"auth": {
"kind": "token",
"token": token
}
})),
jdbc_driver_class: None,
jdbc_driver_paths: Vec::new(),
one_time: false,
read_only: false,
}
}
async fn raw_connection_json(storage: &Storage, id: &str) -> String {
let id = id.to_string();
storage
.with_conn(move |conn| {
conn.query_row("SELECT config_json FROM connections WHERE id = ?1", [id], |row| row.get::<_, String>(0))
.map_err(|e| e.to_string())
})
.await
.unwrap()
}
async fn insert_raw_connection(storage: &Storage, config: &ConnectionConfig) {
let id = config.id.clone();
let json = serde_json::to_string(config).unwrap();
storage
.with_conn(move |conn| {
conn.execute("INSERT INTO connections (id, config_json) VALUES (?1, ?2)", rusqlite::params![id, json])
.map(|_| ())
.map_err(|e| e.to_string())
})
.await
.unwrap();
}
fn mq_token(config: &ConnectionConfig) -> Option<&str> {
config.external_config.as_ref()?.get("auth")?.get("token")?.as_str()
}
fn mq_token_signing_key(config: &ConnectionConfig) -> Option<&str> {
config.external_config.as_ref()?.get("tokenSigning")?.get("key")?.as_str()
}
#[tokio::test]
async fn save_connections_moves_mq_auth_token_to_secret_table_and_restores_it() {
let path = temp_db_path("mq-token-secrets");
let storage = Storage::open(&path).await.unwrap();
storage.save_connections(&[mq_connection("pulsar", "mq-token-secret")]).await.unwrap();
let raw_json = raw_connection_json(&storage, "pulsar").await;
assert!(!raw_json.contains("mq-token-secret"));
let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
assert_eq!(mq_token(&persisted), Some(""));
assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap().as_deref(), Some("mq-token-secret"));
let loaded = storage.load_connections().await.unwrap();
assert_eq!(loaded.len(), 1);
assert_eq!(mq_token(&loaded[0]), Some("mq-token-secret"));
}
#[tokio::test]
async fn metadata_save_scrubs_mq_auth_token_and_preserves_existing_secret() {
let path = temp_db_path("mq-token-metadata");
let storage = Storage::open(&path).await.unwrap();
let original = mq_connection("pulsar", "existing-token");
storage.save_connections(&[original.clone()]).await.unwrap();
let mut metadata = original;
metadata.name = "Pulsar renamed".to_string();
if let Some(auth) = metadata.external_config.as_mut().and_then(|value| value.get_mut("auth")) {
auth["token"] = serde_json::Value::String("new-token-that-should-not-persist".to_string());
}
storage.save_connection_metadata_preserving_secrets(&[metadata]).await.unwrap();
let raw_json = raw_connection_json(&storage, "pulsar").await;
assert!(!raw_json.contains("existing-token"));
assert!(!raw_json.contains("new-token-that-should-not-persist"));
assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap().as_deref(), Some("existing-token"));
let loaded = storage.load_connections().await.unwrap();
assert_eq!(loaded[0].name, "Pulsar renamed");
assert_eq!(mq_token(&loaded[0]), Some("existing-token"));
}
#[tokio::test]
async fn load_connections_migrates_legacy_mq_auth_token_out_of_config_json() {
let path = temp_db_path("mq-token-legacy-migration");
let storage = Storage::open(&path).await.unwrap();
insert_raw_connection(&storage, &mq_connection("pulsar", "legacy-token")).await;
let loaded = storage.load_connections().await.unwrap();
assert_eq!(mq_token(&loaded[0]), Some("legacy-token"));
assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap().as_deref(), Some("legacy-token"));
let raw_json = raw_connection_json(&storage, "pulsar").await;
assert!(!raw_json.contains("legacy-token"));
let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
assert_eq!(mq_token(&persisted), Some(""));
}
#[tokio::test]
async fn save_connections_deletes_stale_mq_auth_secrets_when_kind_changes() {
let path = temp_db_path("mq-auth-kind-change");
let storage = Storage::open(&path).await.unwrap();
storage.save_connections(&[mq_connection("pulsar", "old-token")]).await.unwrap();
let mut config = mq_connection("pulsar", "");
config.external_config = Some(serde_json::json!({
"systemKind": "pulsar",
"adminUrl": "http://127.0.0.1:8080",
"auth": {
"kind": "basic",
"username": "admin",
"password": "basic-secret"
}
}));
storage.save_connections(&[config]).await.unwrap();
assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap(), None);
assert_eq!(storage.get_secret("pulsar", MQ_AUTH_PASSWORD_KEY).await.unwrap().as_deref(), Some("basic-secret"));
}
#[tokio::test]
async fn save_connections_moves_mq_token_signing_key_to_secret_table_and_restores_it() {
let path = temp_db_path("mq-token-signing-secret");
let storage = Storage::open(&path).await.unwrap();
let mut config = mq_connection("pulsar", "");
config.external_config = Some(serde_json::json!({
"systemKind": "pulsar",
"adminUrl": "http://127.0.0.1:8080",
"auth": { "kind": "none" },
"tokenSigning": {
"algorithm": "hs256",
"key": "broker-signing-secret"
}
}));
storage.save_connections(&[config]).await.unwrap();
let raw_json = raw_connection_json(&storage, "pulsar").await;
assert!(!raw_json.contains("broker-signing-secret"));
let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
assert_eq!(mq_token_signing_key(&persisted), Some(""));
assert_eq!(
storage.get_secret("pulsar", MQ_TOKEN_SIGNING_KEY).await.unwrap().as_deref(),
Some("broker-signing-secret")
);
let loaded = storage.load_connections().await.unwrap();
assert_eq!(mq_token_signing_key(&loaded[0]), Some("broker-signing-secret"));
}
#[tokio::test]
async fn desktop_settings_default_to_background_enabled() {
let path = temp_db_path("desktop-settings-default");