Merge pull request #1676 from jumpserver/pr@dev@feat_change_mariadb_protocol

fix: use MySQL protocol for MariaDB client connections

Author: Aaron3S

electron/src/apps/local-app-launcher.ts

@@ -258,6 +258,8 @@ export class LocalApplicationLauncher {
       throw new Error("local client payload is missing required connection fields");
     }
     const application = await this.resolveApplication(payload);
+    // Preserve MariaDB application preferences, but use the MySQL driver on Magnus's shared port.
+    if (payload.protocol === "mariadb") payload.protocol = "mysql";
     if (application.launch_type === "file") {
       if (!payload.file?.content) throw new Error("local client payload is missing connection file content");
       electronLog.info(`launch ${payload.protocol} connection file via ${application.display_name || "file handler"}`);

electron/tests/application-config.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -281,6 +281,74 @@ test("launches RDP connection files without endpoint fields", async () => {
   assert.deepEqual(launchedPayload, payload);
 });
 
+for (const [platform, plugin, expected] of [
+  ["macos", "dbeaver", "driver=mysql"],
+  ["linux", "dbeaver", "driver=mysql"],
+  ["windows", "dbeaver", "driver=mysql"],
+  ["windows", "navicat17", "navicat://conn.mysql?"],
+  ["macos", "terminal-db", "mysql -u token-id"],
+  ["linux", "terminal-db", "mysql -u token-id"],
+  ["demo", "tablepro-uploadable", "mysql"]
+]) {
+  test(`${platform}/${plugin} uses MySQL for MariaDB without changing application selection`, async () => {
+    const directory = platform === "demo" ? plugin : `${platform}.${plugin}`;
+    const config = JSON.parse(
+      await readFile(path.join(projectRoot, "plugins", platform, directory, "connect.json"), "utf8")
+    );
+    const application = {
+      name: plugin,
+      protocol: ["mariadb", "mysql"],
+      is_set: true,
+      // Only the MariaDB preference is enabled; normalization must happen after selection.
+      enabled_protocols: ["mariadb"],
+      match_first: ["mariadb"],
+      launch_type: config.launch.type,
+      launch_driver: config.launch.driver,
+      arg_format: config.launch.template,
+      protocol_templates: config.launch.protocol_templates
+    };
+    const launcher = new LocalApplicationLauncher(
+      { isPackaged: false },
+      projectRoot,
+      { getConfig: async () => ({ databases: [application] }) },
+      null
+    );
+    const payload = {
+      protocol: "mariadb",
+      name: "测试数据库",
+      endpoint: { host: "gateway.example.com", port: 5525 },
+      token: { id: "token-id", value: "secret", protocol: "mariadb" },
+      asset: { info: { db_name: "app" } }
+    };
+    let launches = 0;
+    const checkArgs = async (selected, args) => {
+      assert.equal(selected, application);
+      assert.ok(args.includes(expected), args);
+      assert.ok(args.includes("gateway.example.com"), args);
+      assert.ok(args.includes("5525"), args);
+      assert.ok(!args.includes("mariadb"), args);
+      launches++;
+    };
+    launcher.launchExecutable = checkArgs;
+    launcher.launchTerminal = checkArgs;
+    launcher.launchScript = async (selected, received, values) => {
+      assert.equal(selected, application);
+      assert.deepEqual(received, { ...payload, protocol: "mysql", ...(received.client ? { client: plugin } : {}) });
+      assert.equal(values.protocol, "mysql");
+      assert.equal(values.dbeaver_protocol, "mysql");
+      assert.equal(values.dbname, "app");
+      launches++;
+    };
+    for (const client of [undefined, plugin]) {
+      const url = `jms2://${Buffer.from(JSON.stringify({ ...payload, client })).toString("base64")}`;
+      await launcher.launch(url);
+    }
+    assert.equal(launches, 2);
+    assert.equal(payload.protocol, "mariadb");
+    assert.deepEqual(application.enabled_protocols, ["mariadb"]);
+  });
+}
+
 test("normalizes duplicate and hidden system font families", () => {
   assert.deepEqual(systemFontInternals.normalizeFamilies(["Menlo", " .Hidden ", "Menlo", "SF Mono", ""]), [
     "Menlo",

ui/composables/useAssetAction.test.ts

@@ -280,6 +280,59 @@ describe("opening assets in local applications", () => {
     expect(mocks.setConnectionTokenReusable).not.toHaveBeenCalled();
   });
 
+  it.each([false, true])("launches MariaDB with client-only compatibility on desktop=%s", async (desktop) => {
+    vi.stubGlobal("isDesktopRuntime", () => desktop);
+    const dbMethod = { value: "db_client", type: "native", component: "magnus", disabled: false };
+    vi.stubGlobal("useConnectMethods", () => ({
+      fetchConnectMethods: async () => ({ mariadb: [dbMethod] }),
+      getMethodsForProtocol: async () => [dbMethod]
+    }));
+    const dbPayload = {
+      ...payload,
+      protocol: "mariadb",
+      name: "测试数据库",
+      endpoint: { host: "gateway.example.com", port: 5525 },
+      asset: { info: { db_name: "app" } },
+      token: { ...payload.token, protocol: "mariadb" }
+    };
+    const url = `jms2://${btoa(String.fromCharCode(...new TextEncoder().encode(JSON.stringify(dbPayload))))}`;
+    mocks.getLocalClientUrl.mockResolvedValue({ url });
+    mocks.createToken.mockResolvedValue(dbPayload.token);
+
+    const { ready, failed } = await connect("db_client", "mariadb");
+
+    expect(failed).not.toHaveBeenCalled();
+    expect(mocks.createToken).toHaveBeenCalledWith(
+      expect.objectContaining({ protocol: "mariadb", connect_method: "db_client" }),
+      expect.anything()
+    );
+    expect(ready.mock.calls[0]?.[0].token.protocol).toBe("mariadb");
+    const launchedUrl = desktop ? mocks.invoke.mock.calls[0]?.[1].url : mocks.assign.mock.calls[0]?.[0];
+    const launchedPayload = JSON.parse(
+      new TextDecoder().decode(Uint8Array.from(atob(launchedUrl.slice(7)), (character) => character.charCodeAt(0)))
+    );
+    expect(launchedPayload).toEqual({
+      ...dbPayload,
+      // Desktop resolves the user's MariaDB application first, then normalizes the driver in the launcher.
+      protocol: desktop ? "mariadb" : "mysql"
+    });
+  });
+
+  it("preserves an applet's RDP launch protocol for a MariaDB asset", async () => {
+    const applet = { value: "dbeaver", type: "applet", component: "razor", disabled: false };
+    vi.stubGlobal("useConnectMethods", () => ({
+      fetchConnectMethods: async () => ({ mariadb: [applet] }),
+      getMethodsForProtocol: async () => [applet]
+    }));
+    const url = `jms2://${btoa(JSON.stringify({ ...payload, name: "database", protocol: "rdp" }))}`;
+    mocks.getLocalClientUrl.mockResolvedValue({ url });
+
+    const { failed } = await connect("dbeaver", "mariadb");
+
+    expect(failed).not.toHaveBeenCalled();
+    expect(mocks.assign).toHaveBeenCalledExactlyOnceWith(url);
+  });
+
   describe("RDP file downloads", () => {
     const content = "full address:s:rdp.example\r\nusername:s:用户\r\n";
     const rdpMethod = { ...method, value: "mstsc", component: "razor" };

ui/composables/useAssetAction.ts

@@ -110,15 +110,23 @@ function resolveConnectionErrorDescription(error: unknown, translate: (key: stri
   return typeof data.detail === "string" && data.detail ? data.detail : error.message || `HTTP ${error.status}`;
 }
 
-const withLocalClientName = (url: string, clientName?: string) => {
-  if (!clientName || !url.startsWith("jms2://")) return url;
+const withLocalClientOptions = (
+  url: string,
+  { clientName, mysqlForMariaDB }: { clientName?: string; mysqlForMariaDB?: boolean }
+) => {
+  if ((!clientName && !mysqlForMariaDB) || !url.startsWith("jms2://")) return url;
 
   try {
     const decoded = Uint8Array.from(atob(url.slice("jms2://".length)), (character) => character.charCodeAt(0));
     const parsed: unknown = JSON.parse(new TextDecoder().decode(decoded));
     if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") return url;
 
-    const payload = { ...(parsed as Record<string, unknown>), client: clientName };
+    const payload = { ...(parsed as Record<string, unknown>) };
+    const useMySQL = mysqlForMariaDB && payload.protocol === "mariadb";
+    if (!clientName && !useMySQL) return url;
+    if (clientName) payload.client = clientName;
+    // Only change the client driver, never the Core token or an applet's RDP protocol.
+    if (useMySQL) payload.protocol = "mysql";
     const encoded = new TextEncoder().encode(JSON.stringify(payload));
     return `jms2://${btoa(String.fromCharCode(...encoded))}`;
   } catch {
@@ -601,12 +609,12 @@ export const useAssetAction = () => {
         };
         if (isDesktopRuntime()) {
           await desktopInvoke("pull_up", {
-            url: withLocalClientName(localClientUrl, nativeApp.clientName)
+            url: withLocalClientOptions(localClientUrl, { clientName: nativeApp.clientName })
           });
           meta?.onSessionReady?.(payload);
         } else {
           meta?.onSessionReady?.(payload);
-          window.location.assign(localClientUrl);
+          window.location.assign(withLocalClientOptions(localClientUrl, { mysqlForMariaDB: true }));
         }
         return;
       }

ui/shared/connectors/GuideSessionSurface.vue

@@ -4,7 +4,7 @@ import type { TokenResponse } from "~/types";
 
 import { writeText } from "clipboard-polyfill";
 import { getPublicSettings, getUserProfile, setConnectionTokenReusable } from "~/composables/useApiRequest";
-import { getGuideConnectCommand } from "./guideCommand";
+import { getGuideClientProtocol, getGuideConnectCommand } from "./guideCommand";
 import { getDirectSshCommand } from "./sshGuide";
 import {
   applyConnectionTokenReuse,
@@ -41,6 +41,7 @@ const reusable = ref(false);
 const reusableUpdating = ref(false);
 
 const protocol = computed(() => (token.value?.protocol || props.tab.protocol || "").toLowerCase());
+const clientProtocol = computed(() => getGuideClientProtocol(protocol.value));
 const showReusable = computed(() => shouldShowConnectionTokenReuse(connectionTokenReusable.value, token.value?.id));
 const showDatabaseHelp = computed(() => isDatabaseGuideProtocol(protocol.value));
 const host = computed(() => String(endpoint.value.host || ""));
@@ -81,7 +82,7 @@ const rows = computed(() => {
     ...(databaseProtocols.has(protocol.value)
       ? [{ name: "database", label: t("ConnectionGuide.Database"), value: database.value }]
       : []),
-    { name: "protocol", label: t("ConnectionGuide.Protocol"), value: protocol.value },
+    { name: "protocol", label: t("ConnectionGuide.Protocol"), value: clientProtocol.value },
     { name: "date_expired", label: t("ConnectionGuide.ExpireTime"), value: token.value.date_expired }
   ];
 
@@ -218,7 +219,7 @@ onMounted(async () => {
                 <h2 class="truncate text-base font-semibold text-[var(--app-fg)]">
                   {{ t("ConnectionGuide.Title") }}
                 </h2>
-                <UBadge :label="protocol.toUpperCase()" color="neutral" variant="outline" size="sm" />
+                <UBadge :label="clientProtocol.toUpperCase()" color="neutral" variant="outline" size="sm" />
               </div>
               <p class="mt-0.5 truncate text-xs text-[var(--app-muted)]">
                 {{ assetName }}

ui/shared/connectors/guideCommand.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { getGuideConnectCommand } from "./guideCommand";
+import { getGuideClientProtocol, getGuideConnectCommand } from "./guideCommand";
 
 const database = {
   id: "token-id",
@@ -9,7 +9,29 @@ const database = {
   database: "app"
 };
 
+describe("connection guide client protocol", () => {
+  it.each(["mariadb", "MariaDB", " MARIADB "])("presents %s as mysql", (protocol) => {
+    expect(getGuideClientProtocol(protocol)).toBe("mysql");
+  });
+
+  it.each(["mysql", "postgresql", "redis", "oracle", "sqlserver", "mongodb", "ssh", "vnc", "", "unknown"])(
+    "preserves other protocols (%s)",
+    (protocol) => {
+      expect(getGuideClientProtocol(protocol)).toBe(protocol);
+    }
+  );
+});
+
 describe("connection guide CLI", () => {
+  it.each(["mariadb", "MariaDB", " MARIADB "])(
+    "uses the MySQL client for %s without changing connection details",
+    (protocol) => {
+      const connection = { ...database, protocol, port: "5525" };
+      expect(getGuideConnectCommand(connection)).toBe("mysql -u token-id -ps3cret -h gateway.example.com -P 5525 app");
+      expect(connection.protocol).toBe(protocol);
+    }
+  );
+
   it("matches the v4 MongoDB client URI including auth and load-balancer flags", () => {
     expect(
       getGuideConnectCommand({

ui/shared/connectors/guideCommand.ts

@@ -1,3 +1,9 @@
+// Client-facing only: retain the original asset/token protocol for backend routing.
+export function getGuideClientProtocol(protocol: string) {
+  const normalized = protocol.trim().toLowerCase();
+  return normalized === "mariadb" ? "mysql" : normalized;
+}
+
 export function getGuideConnectCommand(input: {
   protocol: string;
   id: string;
@@ -9,13 +15,12 @@ export function getGuideConnectCommand(input: {
 }) {
   const { protocol, id, secret, host, port, database } = input;
 
-  switch (protocol) {
+  switch (getGuideClientProtocol(protocol)) {
     case "ssh":
       return `ssh JMS-${id}@${host}${port === "22" ? "" : ` -p ${port}`}`;
     case "vnc":
       return `vncviewer -UserName=${id} ${host}:${port || "5900"}`;
     case "mysql":
-    case "mariadb":
       return `mysql -u ${id} -p${secret} -h ${host} -P ${port} ${database}`;
     case "postgresql":
       return `psql "user=${id} password=${secret} host=${host} dbname=${database} port=${port}"`;