Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

chore: auto reconnect lsp (#20955)

ecmadao6fac45a5bb94
diff --git a/frontend/src/components/monaco/MonacoEditor.test.tsx b/frontend/src/components/monaco/MonacoEditor.test.tsx
index 1638480637..90b1767841 100644
--- a/frontend/src/components/monaco/MonacoEditor.test.tsx
+++ b/frontend/src/components/monaco/MonacoEditor.test.tsx
@@ -14,6 +14,7 @@ const mocks = vi.hoisted(() => {
timestamp: 1_714_000_000_000,
},
};
+ const connectionListeners = new Set<() => void>();
const model = {
uri: {
toString: () => "file:///test.sql",
@@ -24,6 +25,9 @@ const mocks = vi.hoisted(() => {
getAllDecorations: () => [],
};
const subscription = { dispose: vi.fn() };
+ const handlers = {
+ modelContent: undefined as (() => void) | undefined,
+ };
const editor = {
addAction: vi.fn(() => subscription),
createDecorationsCollection: vi.fn(() => ({ clear: vi.fn() })),
@@ -38,7 +42,10 @@ const mocks = vi.hoisted(() => {
onDidChangeCursorPosition: vi.fn(() => subscription),
onDidChangeCursorSelection: vi.fn(() => subscription),
onDidChangeModel: vi.fn(() => subscription),
- onDidChangeModelContent: vi.fn(() => subscription),
+ onDidChangeModelContent: vi.fn((handler: () => void) => {
+ handlers.modelContent = handler;
+ return subscription;
+ }),
onDidContentSizeChange: vi.fn(() => subscription),
setModel: vi.fn(),
setValue: vi.fn(),
@@ -46,7 +53,15 @@ const mocks = vi.hoisted(() => {
};
return {
connectionSnapshot,
+ connectionListeners,
+ currentWebSocket: undefined as
+ | {
+ addEventListener: ReturnType<typeof vi.fn>;
+ removeEventListener: ReturnType<typeof vi.fn>;
+ }
+ | undefined,
editor,
+ handlers,
model,
subscription,
};
@@ -122,11 +137,21 @@ vi.mock("./core", () => ({
}));
vi.mock("./lsp-client", () => ({
+ ensureLSPConnection: vi.fn(async () => ({})),
executeCommand: vi.fn(async () => undefined),
getConnectionStateSnapshot: vi.fn(() => mocks.connectionSnapshot),
- getConnectionWebSocket: vi.fn(() => undefined),
+ getConnectionWebSocket: vi.fn(() =>
+ mocks.currentWebSocket
+ ? Promise.resolve(mocks.currentWebSocket as unknown as WebSocket)
+ : undefined
+ ),
initializeLSPClient: vi.fn(async () => ({})),
- subscribeConnectionState: vi.fn(() => () => undefined),
+ subscribeConnectionState: vi.fn((listener: () => void) => {
+ mocks.connectionListeners.add(listener);
+ return () => {
+ mocks.connectionListeners.delete(listener);
+ };
+ }),
}));
vi.mock("./suggest-icons", () => ({
@@ -134,6 +159,9 @@ vi.mock("./suggest-icons", () => ({
}));
vi.mock("./text-model", () => ({
+ getUriByFilename: vi.fn(async (filename: string) => ({
+ toString: () => `file:///${filename}`,
+ })),
getOrCreateTextModel: vi.fn(async () => mocks.model),
restoreViewState: vi.fn(),
storeViewState: vi.fn(),
@@ -169,8 +197,39 @@ const renderIntoContainer = async (
beforeEach(() => {
vi.clearAllMocks();
+ mocks.connectionSnapshot = {
+ heartbeat: {
+ counter: 1,
+ timer: undefined,
+ timestamp: 1_714_000_000_000,
+ },
+ state: "ready",
+ };
+ mocks.connectionListeners.clear();
+ mocks.currentWebSocket = undefined;
+ mocks.handlers.modelContent = undefined;
+});
+
+const createWebSocket = () => ({
+ addEventListener: vi.fn(),
+ removeEventListener: vi.fn(),
});
+const setConnectionState = (state: typeof mocks.connectionSnapshot.state) => {
+ mocks.connectionSnapshot = {
+ ...mocks.connectionSnapshot,
+ state,
+ };
+};
+
+const notifyConnectionState = async () => {
+ act(() => {
+ mocks.connectionListeners.forEach((listener) => listener());
+ });
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ await new Promise((resolve) => setTimeout(resolve, 0));
+};
+
describe("MonacoEditor", () => {
test("keeps the legacy heartbeat interpolation text", () => {
const locale = JSON.parse(
@@ -222,4 +281,80 @@ describe("MonacoEditor", () => {
unmount();
});
+
+ test("rebinds statement-range listener when the LSP socket recovers", async () => {
+ const firstWebSocket = createWebSocket();
+ const recoveredWebSocket = createWebSocket();
+ mocks.currentWebSocket = firstWebSocket;
+
+ const { unmount } = await renderIntoContainer(
+ createElement(MonacoEditor, {
+ content: "select 1",
+ enableDecorations: true,
+ })
+ );
+
+ expect(firstWebSocket.addEventListener).toHaveBeenCalledWith(
+ "message",
+ expect.any(Function)
+ );
+
+ setConnectionState("closed");
+ await notifyConnectionState();
+ expect(firstWebSocket.removeEventListener).toHaveBeenCalledWith(
+ "message",
+ expect.any(Function)
+ );
+
+ mocks.currentWebSocket = recoveredWebSocket;
+ setConnectionState("ready");
+ await notifyConnectionState();
+
+ expect(recoveredWebSocket.addEventListener).toHaveBeenCalledWith(
+ "message",
+ expect.any(Function)
+ );
+
+ unmount();
+ });
+
+ test("resends LSP metadata when the connection recovers", async () => {
+ const { executeCommand } = await import("./lsp-client");
+ setConnectionState("closed");
+
+ const { unmount } = await renderIntoContainer(
+ createElement(MonacoEditor, {
+ autoCompleteContext: {
+ database: "instances/prod/databases/db",
+ instance: "instances/prod",
+ scene: "query",
+ schema: "public",
+ },
+ content: "select 1",
+ })
+ );
+
+ await new Promise((resolve) => setTimeout(resolve, 600));
+ expect(executeCommand).not.toHaveBeenCalled();
+
+ setConnectionState("ready");
+ await notifyConnectionState();
+ await new Promise((resolve) => setTimeout(resolve, 600));
+
+ expect(executeCommand).toHaveBeenCalledWith(
+ expect.anything(),
+ "setMetadata",
+ [
+ expect.objectContaining({
+ databaseName: "db",
+ documentUri: expect.stringContaining("file:///"),
+ instanceId: "instances/prod",
+ scene: "query",
+ schema: "public",
+ }),
+ ]
+ );
+
+ unmount();
+ });
});
diff --git a/frontend/src/components/monaco/MonacoEditor.tsx b/frontend/src/components/monaco/MonacoEditor.tsx
index 830e52850f..f4a37394a1 100644
--- a/frontend/src/components/monaco/MonacoEditor.tsx
+++ b/frontend/src/components/monaco/MonacoEditor.tsx
@@ -222,6 +222,8 @@ export function MonacoEditor({
getConnectionStateSnapshot,
getConnectionStateSnapshot
);
+ const connectionStateRef = useRef(connection.state);
+ connectionStateRef.current = connection.state;
const clampMeasuredHeight = (height: number): number => {
return Math.min(max, Math.max(min, height));
@@ -310,7 +312,6 @@ export function MonacoEditor({
let cursorSubscription: { dispose(): void } | null = null;
let formatAction: { dispose(): void } | null = null;
let suggestStyle: HTMLStyleElement | null = null;
- let messageHandler: ((event: MessageEvent) => void) | null = null;
const host = document.createElement("div");
host.className = "h-full w-full";
containerRef.current?.replaceChildren(host);
@@ -414,20 +415,6 @@ export function MonacoEditor({
suggestStyle = ensureSuggestOverrideStyle();
}
- if (shouldEnableLSP) {
- const wsPromise =
- getConnectionWebSocket() ??
- initializeLSPClient().then(() => getConnectionWebSocket());
- wsPromise?.then((ws) => {
- if (!ws || disposed) return;
- messageHandler = (message: MessageEvent) => {
- processStatementRangeMessage(message);
- emitSelectionSideEffects();
- };
- ws.addEventListener("message", messageHandler);
- });
- }
-
if (autoFocus) {
editor.focus();
}
@@ -450,12 +437,6 @@ export function MonacoEditor({
cursorSubscription?.dispose();
formatAction?.dispose();
suggestStyle?.remove();
- const wsPromise = getConnectionWebSocket();
- if (messageHandler) {
- wsPromise?.then((ws) =>
- ws.removeEventListener("message", messageHandler!)
- );
- }
// Clear ALL active-statement decorations on the (shared, persistent)
// model, not just this instance's tracked id, so teardown can't leave
// an orphan highlight behind for the next editor lifecycle.
@@ -501,6 +482,36 @@ export function MonacoEditor({
t,
]);
+ useEffect(() => {
+ if (!shouldEnableLSP || connection.state !== "ready") {
+ return;
+ }
+
+ let disposed = false;
+ let activeWebSocket: WebSocket | undefined;
+ const messageHandler = (message: MessageEvent) => {
+ processStatementRangeMessage(message);
+ emitSelectionSideEffects();
+ };
+ const wsPromise = getConnectionWebSocket();
+ void wsPromise?.then((ws) => {
+ if (!ws || disposed) return;
+ activeWebSocket = ws;
+ ws.addEventListener("message", messageHandler);
+ });
+
+ return () => {
+ disposed = true;
+ if (activeWebSocket) {
+ activeWebSocket.removeEventListener("message", messageHandler);
+ return;
+ }
+ void wsPromise?.then((ws) =>
+ ws?.removeEventListener("message", messageHandler)
+ );
+ };
+ }, [connection.state, shouldEnableLSP]);
+
useEffect(() => {
const editor = editorRef.current;
const model = modelRef.current ?? editor?.getModel();
@@ -597,7 +608,7 @@ export function MonacoEditor({
// a writable Monaco for plain text editing don't initialize the LSP
// client or send empty `setMetadata` traffic.
useEffect(() => {
- if (readOnly || !ready) return;
+ if (readOnly || !ready || connection.state !== "ready") return;
const ctx = autoCompleteContext;
if (!ctx) return;
const params: {
@@ -637,7 +648,13 @@ export function MonacoEditor({
return () => {
apply.cancel();
};
- }, [autoCompleteContext, readOnly, ready]);
+ }, [
+ autoCompleteContext,
+ connection.state,
+ generatedFilename,
+ readOnly,
+ ready,
+ ]);
const height = clampMeasuredHeight(contentHeight);
let connectionStateText = t(
diff --git a/frontend/src/components/monaco/lsp-client.test.ts b/frontend/src/components/monaco/lsp-client.test.ts
new file mode 100644
index 0000000000..446db99dd3
--- /dev/null
+++ b/frontend/src/components/monaco/lsp-client.test.ts
@@ -0,0 +1,408 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+ clients: [] as MockLanguageClient[],
+ errorNotification: vi.fn(),
+ initializeMonacoServices: vi.fn(async () => undefined),
+ refreshTokens: vi.fn(async () => undefined),
+ sleep: vi.fn(async () => undefined),
+ start: vi.fn(async () => undefined),
+}));
+
+class MockLanguageClient {
+ readonly clientOptions: {
+ errorHandler?: {
+ closed?: () => { action: number };
+ };
+ };
+ readonly onDidChangeState = vi.fn();
+ readonly sendRequest = vi.fn(async () => undefined);
+ readonly start = vi.fn(() => mocks.start());
+ readonly dispose = vi.fn();
+
+ constructor(
+ _id: string,
+ _name: string,
+ clientOptions: MockLanguageClient["clientOptions"]
+ ) {
+ this.clientOptions = clientOptions;
+ mocks.clients.push(this);
+ }
+}
+
+class MockWebSocket extends EventTarget {
+ static readonly CONNECTING = 0;
+ static readonly OPEN = 1;
+ static readonly CLOSING = 2;
+ static readonly CLOSED = 3;
+ static instances: MockWebSocket[] = [];
+
+ readonly close = vi.fn(() => {
+ this.readyState = 3;
+ this.dispatchClose();
+ });
+ readonly send = vi.fn();
+ readyState = 0;
+
+ constructor(readonly url: string) {
+ super();
+ MockWebSocket.instances.push(this);
+ }
+
+ open() {
+ this.readyState = MockWebSocket.OPEN;
+ this.dispatchEvent(new Event("open"));
+ }
+
+ closeBeforeOpen() {
+ this.readyState = 3;
+ this.dispatchClose();
+ }
+
+ private dispatchClose() {
+ const event = new Event("close") as CloseEvent;
+ Object.defineProperties(event, {
+ code: { value: 1006 },
+ reason: { value: "closed" },
+ });
+ this.dispatchEvent(event);
+ }
+}
+
+vi.mock("vscode-languageclient", () => ({
+ BaseLanguageClient: MockLanguageClient,
+ CloseAction: {
+ DoNotRestart: 1,
+ },
+ ErrorAction: {
+ Continue: 1,
+ },
+ State: {
+ Running: 2,
+ },
+}));
+
+vi.mock("vscode-ws-jsonrpc", () => ({
+ toSocket: (ws: WebSocket) => ws,
+ WebSocketMessageReader: class {
+ constructor(readonly _socket: WebSocket) {}
+ },
+ WebSocketMessageWriter: class {
+ constructor(readonly _socket: WebSocket) {}
+ },
+}));
+
+vi.mock("@/api/refreshToken", () => ({
+ refreshTokens: mocks.refreshTokens,
+}));
+
+vi.mock("@/utils", () => ({
+ sleep: mocks.sleep,
+}));
+
+vi.mock("./services", () => ({
+ initializeMonacoServices: mocks.initializeMonacoServices,
+}));
+
+vi.mock("./utils", () => ({
+ createUrl: (_host: string, path: string) =>
+ new URL(`ws://example.com${path}`),
+ errorNotification: mocks.errorNotification,
+ MAX_RETRIES: 5,
+ messages: {
+ disconnected: () => "WebSocket disconnected",
+ },
+ progressiveDelay: () => 0,
+ WEBSOCKET_HEARTBEAT_INTERVAL: 10_000,
+ WEBSOCKET_HEARTBEAT_TIMEOUT: 30_000,
+ WEBSOCKET_TIMEOUT: 5_000,
+}));
+
+const flushPromises = async () => {
+ await Promise.resolve();
+ await Promise.resolve();
+};
+
+const deferred = <T>() => {
+ let resolve!: (value: T | PromiseLike<T>) => void;
+ let reject!: (reason?: unknown) => void;
+ const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+ resolve = resolvePromise;
+ reject = rejectPromise;
+ });
+ return { promise, reject, resolve };
+};
+
+beforeEach(() => {
+ vi.useFakeTimers();
+ vi.resetModules();
+ vi.clearAllMocks();
+ mocks.start.mockReset();
+ mocks.start.mockResolvedValue(undefined);
+ mocks.clients.length = 0;
+ MockWebSocket.instances = [];
+ vi.stubGlobal("WebSocket", MockWebSocket);
+});
+
+afterEach(() => {
+ vi.unstubAllGlobals();
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+});
+
+describe("LSP client connection recovery", () => {
+ test("closes the WebSocket when heartbeat ping does not return", async () => {
+ const { initializeLSPClient } = await import("./lsp-client");
+
+ const initializing = initializeLSPClient();
+ await flushPromises();
+ const ws = MockWebSocket.instances[0];
+ ws.open();
+ await initializing;
+
+ const client = mocks.clients[0];
+ client.sendRequest.mockReturnValueOnce(new Promise(() => undefined));
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ expect(client.sendRequest).toHaveBeenCalledWith("$ping", {
+ state: {
+ counter: 1,
+ timestamp: expect.any(Number),
+ },
+ });
+
+ await vi.advanceTimersByTimeAsync(30_000);
+ expect(ws.close).toHaveBeenCalled();
+ });
+
+ test("ensureLSPConnection reconnects after the connection reaches closed state", async () => {
+ const {
+ ensureLSPConnection,
+ getConnectionStateSnapshot,
+ initializeLSPClient,
+ } = await import("./lsp-client");
+
+ const failedInitialConnection = initializeLSPClient().catch(
+ () => undefined
+ );
+ for (let i = 0; i < 5; i++) {
+ await flushPromises();
+ MockWebSocket.instances[i].closeBeforeOpen();
+ }
+ await failedInitialConnection;
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+
+ const reconnecting = ensureLSPConnection();
+ await flushPromises();
+ const ws = MockWebSocket.instances[5];
+ ws.open();
+ await reconnecting;
+
+ expect(mocks.refreshTokens).toHaveBeenCalled();
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+ });
+
+ test("marks the connection closed when reconnect cannot refresh tokens", async () => {
+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(
+ "./lsp-client"
+ );
+
+ const initializing = initializeLSPClient();
+ await flushPromises();
+ MockWebSocket.instances[0].open();
+ await initializing;
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+
+ mocks.refreshTokens.mockRejectedValueOnce(new Error("offline"));
+ mocks.clients[0].clientOptions.errorHandler?.closed?.();
+ await flushPromises();
+
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+ });
+
+ test("automatically retries a closed connection after reconnect fails", async () => {
+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(
+ "./lsp-client"
+ );
+
+ const initializing = initializeLSPClient();
+ await flushPromises();
+ MockWebSocket.instances[0].open();
+ await initializing;
+
+ mocks.refreshTokens.mockRejectedValueOnce(new Error("offline"));
+ mocks.clients[0].clientOptions.errorHandler?.closed?.();
+ await flushPromises();
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ await flushPromises();
+ MockWebSocket.instances[1].open();
+ await flushPromises();
+
+ expect(mocks.clients).toHaveLength(2);
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+ });
+
+ test("keeps retrying disconnected connections on the heartbeat interval until success", async () => {
+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(
+ "./lsp-client"
+ );
+
+ const initializing = initializeLSPClient();
+ await flushPromises();
+ MockWebSocket.instances[0].open();
+ await initializing;
+
+ mocks.refreshTokens
+ .mockRejectedValueOnce(new Error("offline"))
+ .mockRejectedValueOnce(new Error("still offline"));
+ mocks.clients[0].clientOptions.errorHandler?.closed?.();
+ await flushPromises();
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ await flushPromises();
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ await flushPromises();
+ MockWebSocket.instances[1].open();
+ await flushPromises();
+
+ expect(mocks.refreshTokens).toHaveBeenCalledTimes(3);
+ expect(mocks.clients).toHaveLength(2);
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+ });
+
+ test("shares one reconnect attempt across concurrent callers", async () => {
+ const {
+ ensureLSPConnection,
+ getConnectionStateSnapshot,
+ initializeLSPClient,
+ } = await import("./lsp-client");
+
+ const failedInitialConnection = initializeLSPClient().catch(
+ () => undefined
+ );
+ for (let i = 0; i < 5; i++) {
+ await flushPromises();
+ MockWebSocket.instances[i].closeBeforeOpen();
+ }
+ await failedInitialConnection;
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+
+ const refresh = deferred<undefined>();
+ mocks.refreshTokens.mockReturnValueOnce(refresh.promise);
+
+ const first = ensureLSPConnection();
+ const second = ensureLSPConnection();
+
+ expect(first).toBe(second);
+ expect(mocks.refreshTokens).toHaveBeenCalledTimes(1);
+
+ refresh.resolve(undefined);
+ await flushPromises();
+ await flushPromises();
+ MockWebSocket.instances[5].open();
+ await Promise.all([first, second]);
+
+ expect(mocks.clients).toHaveLength(1);
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+ });
+
+ test("queues another retry when the active reconnect socket closes during startup", async () => {
+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(
+ "./lsp-client"
+ );
+
+ const initializing = initializeLSPClient();
+ await flushPromises();
+ MockWebSocket.instances[0].open();
+ await initializing;
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+
+ const reconnectStart = deferred<undefined>();
+ mocks.start.mockReturnValueOnce(reconnectStart.promise);
+ mocks.clients[0].clientOptions.errorHandler?.closed?.();
+ await flushPromises();
+
+ const reconnectSocket = MockWebSocket.instances[1];
+ reconnectSocket.open();
+ await flushPromises();
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+
+ reconnectSocket.close();
+ mocks.clients[1].clientOptions.errorHandler?.closed?.();
+ reconnectStart.reject(new Error("connection dropped during startup"));
+ await flushPromises();
+
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ await flushPromises();
+ MockWebSocket.instances[2].open();
+ await flushPromises();
+
+ expect(mocks.clients).toHaveLength(3);
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+ });
+
+ test("closes the startup socket and disposes the failed client before retrying", async () => {
+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(
+ "./lsp-client"
+ );
+
+ mocks.start.mockRejectedValueOnce(new Error("initialize rejected"));
+
+ const initializing = initializeLSPClient().catch(() => undefined);
+ await flushPromises();
+ const ws = MockWebSocket.instances[0];
+ ws.open();
+ await flushPromises();
+ await initializing;
+
+ expect(ws.close).toHaveBeenCalled();
+ expect(mocks.clients[0].dispose).toHaveBeenCalled();
+ expect(getConnectionStateSnapshot().state).toBe("closed");
+
+ await vi.advanceTimersByTimeAsync(10_000);
+ await flushPromises();
+ MockWebSocket.instances[1].open();
+ await flushPromises();
+
+ expect(mocks.clients).toHaveLength(2);
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+ });
+
+ test("does not let a stale startup failure close a recovered client", async () => {
+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(
+ "./lsp-client"
+ );
+
+ const staleStart = deferred<undefined>();
+ mocks.start.mockReturnValueOnce(staleStart.promise);
+
+ const staleInitializing = initializeLSPClient().catch(() => undefined);
+ await flushPromises();
+ const staleSocket = MockWebSocket.instances[0];
+ staleSocket.open();
+ await flushPromises();
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+
+ staleSocket.close();
+ mocks.clients[0].clientOptions.errorHandler?.closed?.();
+ await flushPromises();
+ const recoveredSocket = MockWebSocket.instances[1];
+ recoveredSocket.open();
+ await flushPromises();
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+
+ staleStart.reject(new Error("stale initialize rejected"));
+ await staleInitializing;
+
+ expect(mocks.clients[1].dispose).not.toHaveBeenCalled();
+ expect(recoveredSocket.close).not.toHaveBeenCalled();
+ expect(getConnectionStateSnapshot().state).toBe("ready");
+ });
+});
diff --git a/frontend/src/components/monaco/lsp-client.ts b/frontend/src/components/monaco/lsp-client.ts
index 5eb3156aa4..fade8a6847 100644
--- a/frontend/src/components/monaco/lsp-client.ts
+++ b/frontend/src/components/monaco/lsp-client.ts
@@ -25,6 +25,7 @@ import {
messages,
progressiveDelay,
WEBSOCKET_HEARTBEAT_INTERVAL,
+ WEBSOCKET_HEARTBEAT_TIMEOUT,
WEBSOCKET_TIMEOUT,
} from "./utils";
@@ -41,6 +42,12 @@ export type ConnectionState = {
ws: Promise<WebSocket> | undefined;
};
+type LanguageClientConnection = {
+ client: MonacoLanguageClient;
+ ws: WebSocket;
+ wsPromise: Promise<WebSocket>;
+};
+
// Inline replacement for `monaco-languageclient`'s `MonacoLanguageClient`,
// which was a ~15-line subclass and the only thing we consumed from that
// package. All the LSP machinery lives in `vscode-languageclient`, whose
@@ -110,6 +117,8 @@ const state = {
client: undefined as MonacoLanguageClient | undefined,
clientInitialized: undefined as Promise<MonacoLanguageClient> | undefined,
};
+let reconnectHeartbeatTimer: ReturnType<typeof setTimeout> | undefined;
+let reconnectJob: Promise<MonacoLanguageClient> | undefined;
const setConnState = (patch: Partial<ConnectionState>) => {
Object.assign(conn, patch);
@@ -129,37 +138,81 @@ const setHeartbeat = (patch: Partial<ConnectionState["heartbeat"]>) => {
emit();
};
-const useHeartbeat = (ws: WebSocket) => {
+const clearHeartbeat = () => {
+ clearTimeout(conn.heartbeat.timer);
+ conn.heartbeat = {
+ timer: undefined,
+ counter: 0,
+ timestamp: 0,
+ };
+ emit();
+};
+
+const clearReconnectHeartbeat = () => {
+ clearTimeout(reconnectHeartbeatTimer);
+ reconnectHeartbeatTimer = undefined;
+};
+
+const scheduleReconnectHeartbeat = () => {
+ if (reconnectHeartbeatTimer || conn.state === "ready") {
+ return;
+ }
+ reconnectHeartbeatTimer = setTimeout(() => {
+ reconnectHeartbeatTimer = undefined;
+ void reconnect().catch(() => undefined);
+ }, WEBSOCKET_HEARTBEAT_INTERVAL);
+};
+
+const startHeartbeat = (client: MonacoLanguageClient, ws: WebSocket) => {
+ let active = true;
+ let heartbeatResponseTimer: ReturnType<typeof setTimeout> | undefined;
+
const cleanup = () => {
- clearTimeout(conn.heartbeat.timer);
- conn.heartbeat = {
- timer: undefined,
- counter: 0,
- timestamp: 0,
- };
- emit();
+ active = false;
+ clearTimeout(heartbeatResponseTimer);
+ clearHeartbeat();
};
ws.addEventListener("error", cleanup);
ws.addEventListener("close", cleanup);
const ping = () => {
+ clearTimeout(heartbeatResponseTimer);
+ const counter = conn.heartbeat.counter + 1;
+ const timestamp = Date.now();
setHeartbeat({
- counter: conn.heartbeat.counter + 1,
- timestamp: Date.now(),
+ counter,
+ timestamp,
});
- ws.send(
- JSON.stringify({
- jsonrpc: "2.0",
- method: "$ping",
- params: {
- state: omit(conn.heartbeat, "timer"),
- },
+
+ heartbeatResponseTimer = setTimeout(() => {
+ if (active && ws.readyState === WebSocket.OPEN) {
+ ws.close();
+ }
+ }, WEBSOCKET_HEARTBEAT_TIMEOUT);
+
+ void Promise.resolve(
+ client.sendRequest("$ping", {
+ state: omit(conn.heartbeat, "timer"),
})
- );
- setHeartbeat({
- timer: setTimeout(ping, WEBSOCKET_HEARTBEAT_INTERVAL),
- });
+ )
+ .then(() => {
+ if (!active) {
+ return;
+ }
+ clearTimeout(heartbeatResponseTimer);
+ heartbeatResponseTimer = undefined;
+ if (ws.readyState === WebSocket.OPEN) {
+ setHeartbeat({
+ timer: setTimeout(ping, WEBSOCKET_HEARTBEAT_INTERVAL),
+ });
+ }
+ })
+ .catch(() => {
+ if (active && ws.readyState === WebSocket.OPEN) {
+ ws.close();
+ }
+ });
};
ping();
@@ -214,8 +267,8 @@ const connectWebSocket = () => {
if (conn.state === "ready" || conn.state === "closed") {
return;
}
+ clearReconnectHeartbeat();
setConnState({ state: "ready", retries: 0 });
- useHeartbeat(ws);
resolve(ws);
});
@@ -231,15 +284,7 @@ const connectWebSocket = () => {
return promise;
};
-const reconnect = async () => {
- setConnState({
- ws: undefined,
- state: "initial",
- retries: 0,
- });
-
- await refreshTokens();
-
+const disposeClient = () => {
if (state.client) {
try {
state.client.dispose();
@@ -249,10 +294,44 @@ const reconnect = async () => {
state.client = undefined;
}
state.clientInitialized = undefined;
- await initializeLSPClient();
};
-const createLanguageClient = async (): Promise<MonacoLanguageClient> => {
+const reconnectRunner = async () => {
+ setConnState({
+ ws: undefined,
+ state: "initial",
+ retries: 0,
+ });
+
+ clearReconnectHeartbeat();
+ disposeClient();
+ try {
+ await refreshTokens();
+ } catch (err) {
+ setConnState({
+ ws: undefined,
+ state: "closed",
+ retries: 0,
+ });
+ scheduleReconnectHeartbeat();
+ throw err;
+ }
+
+ return initializeLSPClient();
+};
+
+const reconnect = () => {
+ if (reconnectJob) {
+ return reconnectJob;
+ }
+
+ reconnectJob = reconnectRunner().finally(() => {
+ reconnectJob = undefined;
+ });
+ return reconnectJob;
+};
+
+const createLanguageClient = async (): Promise<LanguageClientConnection> => {
// `vscode-languageclient` touches the `vscode` API at construction time,
// which requires `@codingame/monaco-vscode-api`'s `initialize()` to have
// completed before `new MonacoLanguageClient(...)`,
@@ -264,51 +343,57 @@ const createLanguageClient = async (): Promise<MonacoLanguageClient> => {
// caller to have initialized services first. Await it here so callers
// can fire-and-forget safely.
await initializeMonacoServices();
- const ws = await connectWebSocket();
+ const wsPromise = connectWebSocket();
+ const ws = await wsPromise;
const socket = toSocket(ws);
const reader = new WebSocketMessageReader(socket);
const writer = new WebSocketMessageWriter(socket);
- return new MonacoLanguageClient({
- name: "Bytebase Language Client",
- clientOptions: {
- documentSelector: ["sql", "javascript"],
- initializationOptions: {
- performanceMode: true,
- diagnosticDelay: 500,
- disableFeaturesWhileTyping: true,
- },
- middleware: {
- provideHover: throttle(async (document, position, token, next) => {
- return next(document, position, token);
- }, 300),
- provideCompletionItem: throttle(
- async (document, position, context, token, next) => {
- const triggerCharacters = [".", ",", "(", " "];
- if (
- context.triggerKind === 1 &&
- !triggerCharacters.includes(context.triggerCharacter || "")
- ) {
- return { items: [] };
- }
- return next(document, position, context, token);
+ return {
+ client: new MonacoLanguageClient({
+ name: "Bytebase Language Client",
+ clientOptions: {
+ documentSelector: ["sql", "javascript"],
+ initializationOptions: {
+ performanceMode: true,
+ diagnosticDelay: 500,
+ disableFeaturesWhileTyping: true,
+ },
+ middleware: {
+ provideHover: throttle(async (document, position, token, next) => {
+ return next(document, position, token);
+ }, 300),
+ provideCompletionItem: throttle(
+ async (document, position, context, token, next) => {
+ const triggerCharacters = [".", ",", "(", " "];
+ if (
+ context.triggerKind === 1 &&
+ !triggerCharacters.includes(context.triggerCharacter || "")
+ ) {
+ return { items: [] };
+ }
+ return next(document, position, context, token);
+ },
+ 200
+ ),
+ },
+ errorHandler: {
+ error: () => ({ action: ErrorAction.Continue }),
+ closed: () => {
+ reconnect().catch((err) => errorNotification(err));
+ return { action: CloseAction.DoNotRestart };
},
- 200
- ),
- },
- errorHandler: {
- error: () => ({ action: ErrorAction.Continue }),
- closed: () => {
- reconnect().catch((err) => errorNotification(err));
- return { action: CloseAction.DoNotRestart };
},
},
- },
- messageTransports: { reader, writer },
- });
+ messageTransports: { reader, writer },
+ }),
+ ws,
+ wsPromise,
+ };
};
const initializeRunner = async () => {
- const client = await createLanguageClient();
+ const { client, ws, wsPromise } = await createLanguageClient();
+ const isCurrentConnection = () => conn.ws === wsPromise;
client.onDidChangeState((event) => {
if (event.newState === State.Running) {
const { lastCommand } = conn;
@@ -318,13 +403,45 @@ const initializeRunner = async () => {
}
});
- try {
- await client.start();
- } catch (err) {
- errorNotification(err);
- }
+ await client.start().catch((err) => {
+ try {
+ client.dispose();
+ } catch {
+ // ignore
+ }
+ if (
+ ws.readyState !== WebSocket.CLOSING &&
+ ws.readyState !== WebSocket.CLOSED
+ ) {
+ ws.close();
+ }
+ if (isCurrentConnection()) {
+ setConnState({
+ ws: undefined,
+ state: "closed",
+ retries: 0,
+ });
+ scheduleReconnectHeartbeat();
+ }
+ throw err;
+ });
+ if (!isCurrentConnection()) {
+ try {
+ client.dispose();
+ } catch {
+ // ignore
+ }
+ if (
+ ws.readyState !== WebSocket.CLOSING &&
+ ws.readyState !== WebSocket.CLOSED
+ ) {
+ ws.close();
+ }
+ return client;
+ }
state.client = client;
+ startHeartbeat(client, ws);
return client;
};
@@ -332,11 +449,35 @@ export const initializeLSPClient = () => {
if (state.clientInitialized) {
return state.clientInitialized;
}
- const job = initializeRunner();
+ let job: Promise<MonacoLanguageClient>;
+ job = initializeRunner().catch((err) => {
+ if (state.clientInitialized === job) {
+ disposeClient();
+ if (conn.state !== "ready") {
+ setConnState({
+ ws: undefined,
+ state: "closed",
+ retries: 0,
+ });
+ scheduleReconnectHeartbeat();
+ }
+ }
+ throw err;
+ });
state.clientInitialized = job;
return job;
};
+export const ensureLSPConnection = () => {
+ if (conn.state === "ready" || conn.state === "reconnecting") {
+ return state.clientInitialized ?? initializeLSPClient();
+ }
+ if (conn.state === "initial" && conn.ws) {
+ return state.clientInitialized ?? initializeLSPClient();
+ }
+ return reconnect();
+};
+
export const executeCommand = async (
client: MonacoLanguageClient,
command: string,
diff --git a/frontend/src/components/monaco/utils.ts b/frontend/src/components/monaco/utils.ts
index b0b623e3c8..a158e4a2d0 100644
--- a/frontend/src/components/monaco/utils.ts
+++ b/frontend/src/components/monaco/utils.ts
@@ -13,6 +13,7 @@ export const RECONNECTION_DELAY = {
};
export const WEBSOCKET_TIMEOUT = 5000;
export const WEBSOCKET_HEARTBEAT_INTERVAL = 10 * 1000;
+export const WEBSOCKET_HEARTBEAT_TIMEOUT = 30 * 1000;
type MonacoMessages = {
title: string;