Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

refactor: change/cleanup transport logic for different backens (ws, pyodide, static) (#7552)

Myles Scolnick3ba0e3d3df83
diff --git a/development_docs/pyodide.md b/development_docs/pyodide.md
index 333693ccf6..342fca9f7c 100644
--- a/development_docs/pyodide.md
+++ b/development_docs/pyodide.md
@@ -4,7 +4,7 @@
```bash
cd frontend
-PYODIDE=true pnpm dev
+PYODIDE=true VITE_WASM_MARIMO_PREBUILT_WHEEL=true pnpm dev
```
## Running the frontend against a local backend
@@ -16,5 +16,5 @@ hatch build
uv run pyodide/build_and_serve.py
# in another terminal
cd frontend
-PYODIDE=true VITE_MARIMO_VERSION=$(marimo --version) pnpm dev
+PYODIDE=true pnpm dev
```
diff --git a/frontend/src/core/edit-app.tsx b/frontend/src/core/edit-app.tsx
index 5a2549ced7..ac263e7780 100644
--- a/frontend/src/core/edit-app.tsx
+++ b/frontend/src/core/edit-app.tsx
@@ -35,7 +35,7 @@ import { useRequestClient } from "./network/requests";
import { useFilename } from "./saving/filename";
import { lastSavedNotebookAtom } from "./saving/state";
import { useJotaiEffect } from "./state/jotai";
-import { useMarimoWebSocket } from "./websocket/useMarimoWebSocket";
+import { useMarimoKernelConnection } from "./websocket/useMarimoKernelConnection";
interface AppProps {
/**
@@ -80,7 +80,7 @@ export const EditApp: React.FC<AppProps> = ({
};
}, []);
- const { connection } = useMarimoWebSocket({
+ const { connection } = useMarimoKernelConnection({
autoInstantiate: userConfig.runtime.auto_instantiate,
setCells: (cells, layout) => {
setCells(cells);
diff --git a/frontend/src/core/run-app.tsx b/frontend/src/core/run-app.tsx
index 3a0116a61e..c3538934c0 100644
--- a/frontend/src/core/run-app.tsx
+++ b/frontend/src/core/run-app.tsx
@@ -13,7 +13,7 @@ import { RuntimeState } from "./kernel/RuntimeState";
import { getSessionId } from "./kernel/session";
import { useRequestClient } from "./network/requests";
import { isAppConnecting } from "./websocket/connection-utils";
-import { useMarimoWebSocket } from "./websocket/useMarimoWebSocket";
+import { useMarimoKernelConnection } from "./websocket/useMarimoKernelConnection";
interface AppProps {
appConfig: AppConfig;
@@ -31,7 +31,7 @@ export const RunApp: React.FC<AppProps> = ({ appConfig }) => {
};
}, []);
- const { connection } = useMarimoWebSocket({
+ const { connection } = useMarimoKernelConnection({
autoInstantiate: true,
setCells: setCells,
sessionId: getSessionId(),
diff --git a/frontend/src/core/wasm/bridge.ts b/frontend/src/core/wasm/bridge.ts
index cfb2e392de..146d84ba82 100644
--- a/frontend/src/core/wasm/bridge.ts
+++ b/frontend/src/core/wasm/bridge.ts
@@ -29,7 +29,8 @@ import type {
Snippets,
} from "../network/types";
import { store } from "../state/jotai";
-import type { IReconnectingWebSocket } from "../websocket/types";
+import { BasicTransport } from "../websocket/transports/basic";
+import type { IConnectionTransport } from "../websocket/transports/transport";
import { PyodideRouter } from "./router";
import { getWorkerRPC } from "./rpc";
import { createShareableLink } from "./share";
@@ -55,7 +56,9 @@ export class PyodideBridge implements RunRequests, EditRequests {
private rpc!: ReturnType<typeof getWorkerRPC<WorkerSchema>>;
private saveRpc: SaveWorker | undefined;
private interruptBuffer?: Uint8Array;
- private messageConsumer: ((message: string) => void) | undefined;
+ private messageConsumer:
+ | ((message: MessageEvent<string>) => void)
+ | undefined;
public initialized = new Deferred<void>();
@@ -131,7 +134,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
this.initialized.reject(new Error(error));
});
this.rpc.addMessageListener("kernelMessage", ({ message }) => {
- this.messageConsumer?.(message);
+ this.messageConsumer?.(new MessageEvent("message", { data: message }));
});
}
@@ -184,7 +187,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
}
}
- consumeMessages(consumer: (message: string) => void) {
+ attachMessageConsumer(consumer: (message: MessageEvent<string>) => void) {
this.messageConsumer = consumer;
this.rpc.proxy.send.consumerReady({});
}
@@ -562,88 +565,8 @@ export class PyodideBridge implements RunRequests, EditRequests {
}
}
-export class PyodideWebsocket implements IReconnectingWebSocket {
- CONNECTING = WebSocket.CONNECTING;
- OPEN = WebSocket.OPEN;
- CLOSING = WebSocket.CLOSING;
- CLOSED = WebSocket.CLOSED;
- binaryType = "blob" as BinaryType;
- bufferedAmount = 0;
- extensions = "";
- protocol = "";
- url = "";
-
- onclose = null;
- onerror = null;
- onmessage = null;
- onopen = null;
-
- openSubscriptions = new Set<() => void>();
- closeSubscriptions = new Set<() => void>();
- messageSubscriptions = new Set<(event: MessageEvent) => void>();
- errorSubscriptions = new Set<(event: Event) => void>();
-
- private bridge: Pick<PyodideBridge, "consumeMessages">;
-
- constructor(bridge: Pick<PyodideBridge, "consumeMessages">) {
- this.bridge = bridge;
- }
-
- private consumeMessages() {
- this.bridge.consumeMessages((message) => {
- this.messageSubscriptions.forEach((callback) => {
- callback({ data: message } as MessageEvent);
- });
- });
- }
-
- addEventListener(type: unknown, callback: any, options?: unknown): void {
- switch (type) {
- case "open":
- this.openSubscriptions.add(callback);
- // Call open right away
- callback();
- break;
- case "close":
- this.closeSubscriptions.add(callback);
- break;
- case "message":
- this.messageSubscriptions.add(callback);
- // Don't start consuming messages until we have a message listener
- this.consumeMessages();
- break;
- case "error":
- this.errorSubscriptions.add(callback);
- break;
- }
- }
-
- removeEventListener(type: unknown, callback: any, options?: unknown): void {
- switch (type) {
- case "open":
- this.openSubscriptions.delete(callback);
- break;
- case "close":
- this.closeSubscriptions.delete(callback);
- break;
- case "message":
- this.messageSubscriptions.delete(callback);
- break;
- case "error":
- this.errorSubscriptions.delete(callback);
- break;
- }
- }
-
- dispatchEvent = throwNotImplemented;
- reconnect = throwNotImplemented;
- send = throwNotImplemented;
-
- readyState = WebSocket.OPEN;
- retryCount = 0;
- shouldReconnect = false;
-
- close() {
- return;
- }
+export function createPyodideConnection(): IConnectionTransport {
+ return BasicTransport.withProducerCallback((callback) => {
+ PyodideBridge.INSTANCE.attachMessageConsumer(callback);
+ });
}
diff --git a/frontend/src/core/wasm/worker/getMarimoWheel.ts b/frontend/src/core/wasm/worker/getMarimoWheel.ts
index 104363ce5c..a323884bad 100644
--- a/frontend/src/core/wasm/worker/getMarimoWheel.ts
+++ b/frontend/src/core/wasm/worker/getMarimoWheel.ts
@@ -1,10 +1,15 @@
/* Copyright 2024 Marimo. All rights reserved. */
export function getMarimoWheel(version: string) {
- if (import.meta.env.DEV && import.meta.env.VITE_MARIMO_VERSION) {
+ if (import.meta.env.DEV && import.meta.env.VITE_WASM_MARIMO_PREBUILT_WHEEL) {
+ return "marimo-base";
+ }
+
+ if (import.meta.env.DEV) {
return `http://localhost:8000/dist/marimo-${
import.meta.env.VITE_MARIMO_VERSION
}-py3-none-any.whl`;
}
+
return "marimo-base";
}
diff --git a/frontend/src/core/websocket/StaticWebsocket.ts b/frontend/src/core/websocket/StaticWebsocket.ts
deleted file mode 100644
index c838c3f26a..0000000000
--- a/frontend/src/core/websocket/StaticWebsocket.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Copyright 2024 Marimo. All rights reserved. */
-
-import { isIslands } from "@/core/islands/utils";
-import type { IReconnectingWebSocket } from "./types";
-
-export class StaticWebsocket implements IReconnectingWebSocket {
- CONNECTING = WebSocket.CONNECTING;
- OPEN = WebSocket.OPEN;
- CLOSING = WebSocket.CLOSING;
- CLOSED = WebSocket.CLOSED;
- binaryType = "blob" as BinaryType;
- bufferedAmount = 0;
- extensions = "";
- protocol = "";
- url = "";
-
- onclose = null;
- onerror = null;
- onmessage = null;
- onopen = null;
-
- addEventListener(
- type: string,
- callback: EventListener,
- _options?: unknown,
- ): void {
- // Normally this would be a no-op in a mock, but we simulate a synthetic "open" event
- // to mimic the WebSocket transitioning from CONNECTING to OPEN state.
- if (type === "open" && !isIslands()) {
- queueMicrotask(() => {
- callback(new Event("open"));
- });
- }
- }
-
- removeEventListener(
- type: unknown,
- callback: unknown,
- options?: unknown,
- ): void {
- // Noop
- }
- dispatchEvent(event: Event): boolean {
- // Noop
- return false;
- }
-
- readyState = WebSocket.OPEN;
- retryCount = 0;
- shouldReconnect = false;
-
- reconnect(code?: number | undefined, reason?: string | undefined): void {
- // Noop
- }
- send(data: string | ArrayBuffer | Blob | ArrayBufferView) {
- // Noop
- }
- close() {
- // Noop
- }
-}
diff --git a/frontend/src/core/websocket/transports/__tests__/basic.test.ts b/frontend/src/core/websocket/transports/__tests__/basic.test.ts
new file mode 100644
index 0000000000..f17ff5f3f6
--- /dev/null
+++ b/frontend/src/core/websocket/transports/__tests__/basic.test.ts
@@ -0,0 +1,275 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import { describe, expect, it, vi } from "vitest";
+import { BasicTransport } from "../basic";
+
+describe("BasicTransport", () => {
+ describe("close", () => {
+ it("should trigger close event", () => {
+ const transport = BasicTransport.empty();
+ const closeCallback = vi.fn();
+
+ transport.addEventListener("close", closeCallback);
+ transport.close();
+
+ expect(closeCallback).toHaveBeenCalledTimes(1);
+ expect(closeCallback).toHaveBeenCalledWith(expect.any(Event));
+ });
+ });
+
+ describe("reconnect", () => {
+ it("should trigger close and open events", async () => {
+ const transport = BasicTransport.empty();
+ const openCallback = vi.fn();
+ const closeCallback = vi.fn();
+
+ transport.addEventListener("open", openCallback);
+ transport.addEventListener("close", closeCallback);
+
+ // Clear the initial open callback
+ openCallback.mockClear();
+
+ transport.reconnect();
+
+ // Wait for connect to complete
+ await new Promise((resolve) => setTimeout(resolve, 10));
+
+ expect(closeCallback).toHaveBeenCalledTimes(1);
+ expect(openCallback).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe("send", () => {
+ it("should trigger message event with string data", async () => {
+ const transport = BasicTransport.empty();
+ const messageCallback = vi.fn();
+
+ transport.addEventListener("message", messageCallback);
+
+ transport.send("test message");
+
+ expect(messageCallback).toHaveBeenCalledTimes(1);
+ expect(messageCallback).toHaveBeenCalledWith(
+ expect.objectContaining({
+ data: "test message",
+ }),
+ );
+ });
+
+ it("should trigger message event with ArrayBuffer data", async () => {
+ const transport = BasicTransport.empty();
+ const messageCallback = vi.fn();
+
+ transport.addEventListener("message", messageCallback);
+
+ const buffer = new ArrayBuffer(8);
+ transport.send(buffer);
+
+ expect(messageCallback).toHaveBeenCalledTimes(1);
+ expect(messageCallback).toHaveBeenCalledWith(
+ expect.objectContaining({
+ data: buffer,
+ }),
+ );
+ });
+ });
+
+ describe("addEventListener", () => {
+ it("should add open event listener and call it immediately", () => {
+ const transport = BasicTransport.empty();
+ const callback = vi.fn();
+
+ transport.addEventListener("open", callback);
+
+ expect(callback).toHaveBeenCalledTimes(1);
+ expect(callback).toHaveBeenCalledWith(expect.any(Event));
+ });
+
+ it("should add message event listener and start producer", () => {
+ const producer = vi.fn();
+ const transport = BasicTransport.withProducerCallback(producer);
+ const callback = vi.fn();
+
+ transport.addEventListener("message", callback);
+
+ // Producer should be called once
+ expect(producer).toHaveBeenCalledTimes(1);
+ expect(producer).toHaveBeenCalledWith(expect.any(Function));
+ });
+ });
+
+ describe("removeEventListener", () => {
+ it("should remove event listener", async () => {
+ const transport = BasicTransport.empty();
+ const callback = vi.fn();
+
+ transport.addEventListener("message", callback);
+ transport.removeEventListener("message", callback);
+
+ transport.send("test");
+
+ expect(callback).not.toHaveBeenCalled();
+ });
+
+ it("should only remove the specific listener", () => {
+ const transport = BasicTransport.empty();
+ const callback1 = vi.fn();
+ const callback2 = vi.fn();
+
+ transport.addEventListener("close", callback1);
+ transport.addEventListener("close", callback2);
+
+ transport.removeEventListener("close", callback1);
+
+ transport.close();
+
+ expect(callback1).not.toHaveBeenCalled();
+ expect(callback2).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe("Producer functionality", () => {
+ it("should pass producer callback that triggers message events", () => {
+ let producerCallback: ((message: MessageEvent) => void) | undefined;
+ const producer = vi.fn((callback) => {
+ producerCallback = callback;
+ });
+ const transport = BasicTransport.withProducerCallback(producer);
+ const messageCallback = vi.fn();
+
+ transport.addEventListener("message", messageCallback);
+
+ expect(producerCallback).toBeDefined();
+
+ const testMessage = new MessageEvent("message", { data: "test" });
+ producerCallback?.(testMessage);
+
+ expect(messageCallback).toHaveBeenCalledWith(testMessage);
+ });
+
+ it("should handle multiple messages from producer", () => {
+ let producerCallback: ((message: MessageEvent) => void) | undefined;
+ const producer = vi.fn((callback) => {
+ producerCallback = callback;
+ });
+ const transport = BasicTransport.withProducerCallback(producer);
+ const messageCallback = vi.fn();
+
+ transport.addEventListener("message", messageCallback);
+
+ producerCallback?.(new MessageEvent("message", { data: "msg1" }));
+ producerCallback?.(new MessageEvent("message", { data: "msg2" }));
+ producerCallback?.(new MessageEvent("message", { data: "msg3" }));
+
+ expect(messageCallback).toHaveBeenCalledTimes(3);
+ expect(messageCallback).toHaveBeenNthCalledWith(
+ 1,
+ expect.objectContaining({ data: "msg1" }),
+ );
+ expect(messageCallback).toHaveBeenNthCalledWith(
+ 2,
+ expect.objectContaining({ data: "msg2" }),
+ );
+ expect(messageCallback).toHaveBeenNthCalledWith(
+ 3,
+ expect.objectContaining({ data: "msg3" }),
+ );
+ });
+
+ it("should not start producer if no message listener is added", () => {
+ const producer = vi.fn();
+ const transport = BasicTransport.withProducerCallback(producer);
+
+ transport.addEventListener("open", vi.fn());
+ transport.addEventListener("close", vi.fn());
+
+ expect(producer).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("Integration scenarios", () => {
+ it("should handle complete connection lifecycle", async () => {
+ const transport = BasicTransport.empty();
+ const openCallback = vi.fn();
+ const closeCallback = vi.fn();
+
+ transport.addEventListener("open", openCallback);
+ transport.addEventListener("close", closeCallback);
+
+ expect(openCallback).toHaveBeenCalledTimes(1);
+
+ transport.reconnect();
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ expect(openCallback).toHaveBeenCalledTimes(2);
+ expect(closeCallback).toHaveBeenCalledTimes(1);
+
+ transport.close();
+ expect(closeCallback).toHaveBeenCalledTimes(2);
+ });
+
+ it("should handle send and receive flow", async () => {
+ let producerCallback: ((message: MessageEvent) => void) | undefined;
+ const producer = vi.fn((callback) => {
+ producerCallback = callback;
+ });
+ const transport = BasicTransport.withProducerCallback(producer);
+ const messageCallback = vi.fn();
+
+ transport.addEventListener("message", messageCallback);
+
+ transport.send("outgoing");
+ expect(messageCallback).toHaveBeenCalledWith(
+ expect.objectContaining({ data: "outgoing" }),
+ );
+
+ messageCallback.mockClear();
+
+ producerCallback?.(new MessageEvent("message", { data: "incoming" }));
+ expect(messageCallback).toHaveBeenCalledWith(
+ expect.objectContaining({ data: "incoming" }),
+ );
+ });
+
+ it("should maintain separate event queues for different event types", async () => {
+ const transport = BasicTransport.empty();
+ const openCallback = vi.fn();
+ const closeCallback = vi.fn();
+ const messageCallback = vi.fn();
+
+ transport.addEventListener("open", openCallback);
+ transport.addEventListener("close", closeCallback);
+ transport.addEventListener("message", messageCallback);
+
+ openCallback.mockClear();
+
+ transport.reconnect();
+ await new Promise((resolve) => setTimeout(resolve, 10));
+ transport.send("test");
+ transport.close();
+
+ expect(openCallback).toHaveBeenCalledTimes(1);
+ expect(messageCallback).toHaveBeenCalledTimes(1);
+ expect(closeCallback).toHaveBeenCalledTimes(2);
+ });
+
+ it("should handle rapid reconnections", async () => {
+ const transport = BasicTransport.empty();
+ const openCallback = vi.fn();
+ const closeCallback = vi.fn();
+
+ transport.addEventListener("open", openCallback);
+ transport.addEventListener("close", closeCallback);
+
+ openCallback.mockClear();
+
+ transport.reconnect();
+ transport.reconnect();
+ transport.reconnect();
+
+ await new Promise((resolve) => setTimeout(resolve, 20));
+
+ expect(closeCallback).toHaveBeenCalledTimes(3);
+ expect(openCallback).toHaveBeenCalledTimes(3);
+ });
+ });
+});
diff --git a/frontend/src/core/websocket/transports/__tests__/transport.test.ts b/frontend/src/core/websocket/transports/__tests__/transport.test.ts
new file mode 100644
index 0000000000..c427d3800b
--- /dev/null
+++ b/frontend/src/core/websocket/transports/__tests__/transport.test.ts
@@ -0,0 +1,308 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import { describe, expect, it, vi } from "vitest";
+import { ConnectionSubscriptions } from "../transport";
+
+describe("ConnectionSubscriptions", () => {
+ describe("addSubscription", () => {
+ it("should add a subscription for an event", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback = vi.fn();
+
+ subscriptions.addSubscription("open", callback);
+
+ // Verify by notifying
+ subscriptions.notify("open", new Event("open") as Event);
+ expect(callback).toHaveBeenCalledTimes(1);
+ });
+
+ it("should add multiple subscriptions for the same event", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback1 = vi.fn();
+ const callback2 = vi.fn();
+ const callback3 = vi.fn();
+
+ subscriptions.addSubscription("message", callback1);
+ subscriptions.addSubscription("message", callback2);
+ subscriptions.addSubscription("message", callback3);
+
+ const messageEvent = new MessageEvent("message", { data: "test" });
+ subscriptions.notify("message", messageEvent);
+
+ expect(callback1).toHaveBeenCalledWith(messageEvent);
+ expect(callback2).toHaveBeenCalledWith(messageEvent);
+ expect(callback3).toHaveBeenCalledWith(messageEvent);
+ });
+
+ it("should add subscriptions for different event types", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const openCallback = vi.fn();
+ const closeCallback = vi.fn();
+ const messageCallback = vi.fn();
+
+ subscriptions.addSubscription("open", openCallback);
+ subscriptions.addSubscription("close", closeCallback);
+ subscriptions.addSubscription("message", messageCallback);
+
+ subscriptions.notify("open", new Event("open") as Event);
+ expect(openCallback).toHaveBeenCalledTimes(1);
+ expect(closeCallback).not.toHaveBeenCalled();
+ expect(messageCallback).not.toHaveBeenCalled();
+ });
+
+ it("should not add duplicate subscriptions for the same callback", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback = vi.fn();
+
+ subscriptions.addSubscription("close", callback);
+ subscriptions.addSubscription("close", callback);
+ subscriptions.addSubscription("close", callback);
+
+ subscriptions.notify("close", new Event("close") as Event);
+
+ // Set only stores unique callbacks, so should be called once
+ expect(callback).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe("removeSubscription", () => {
+ it("should remove a subscription", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback = vi.fn();
+
+ subscriptions.addSubscription("message", callback);
+ subscriptions.removeSubscription("message", callback);
+
+ const messageEvent = new MessageEvent("message", { data: "test" });
+ subscriptions.notify("message", messageEvent);
+
+ expect(callback).not.toHaveBeenCalled();
+ });
+
+ it("should only remove the specific callback", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback1 = vi.fn();
+ const callback2 = vi.fn();
+ const callback3 = vi.fn();
+
+ subscriptions.addSubscription("close", callback1);
+ subscriptions.addSubscription("close", callback2);
+ subscriptions.addSubscription("close", callback3);
+
+ subscriptions.removeSubscription("close", callback2);
+
+ subscriptions.notify("close", new Event("close") as Event);
+
+ expect(callback1).toHaveBeenCalledTimes(1);
+ expect(callback2).not.toHaveBeenCalled();
+ expect(callback3).toHaveBeenCalledTimes(1);
+ });
+
+ it("should handle removing subscription from non-existent event type", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback = vi.fn();
+
+ subscriptions.addSubscription("open", callback);
+
+ expect(() =>
+ subscriptions.removeSubscription("close", callback),
+ ).not.toThrow();
+
+ subscriptions.notify("open", new Event("open") as Event);
+ expect(callback).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe("notify", () => {
+ it("should notify all subscribed callbacks for an event", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback1 = vi.fn();
+ const callback2 = vi.fn();
+
+ subscriptions.addSubscription("open", callback1);
+ subscriptions.addSubscription("open", callback2);
+
+ const openEvent = new Event("open");
+ subscriptions.notify("open", openEvent as Event);
+
+ expect(callback1).toHaveBeenCalledWith(openEvent);
+ expect(callback2).toHaveBeenCalledWith(openEvent);
+ });
+
+ it("should pass the correct data to callbacks", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback = vi.fn();
+
+ subscriptions.addSubscription("message", callback);
+
+ const messageEvent = new MessageEvent("message", {
+ data: "test data",
+ });
+ subscriptions.notify("message", messageEvent);
+
+ expect(callback).toHaveBeenCalledWith(messageEvent);
+ expect(callback.mock.calls[0][0].data).toBe("test data");
+ });
+
+ it("should not notify callbacks for different event types", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const openCallback = vi.fn();
+ const closeCallback = vi.fn();
+
+ subscriptions.addSubscription("open", openCallback);
+ subscriptions.addSubscription("close", closeCallback);
+
+ subscriptions.notify("open", new Event("open") as Event);
+
+ expect(openCallback).toHaveBeenCalledTimes(1);
+ expect(closeCallback).not.toHaveBeenCalled();
+ });
+
+ it("should handle exceptions in callbacks without affecting other callbacks", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const throwingCallback = vi.fn(() => {
+ throw new Error("Callback error");
+ });
+ const normalCallback = vi.fn();
+
+ subscriptions.addSubscription("message", throwingCallback);
+ subscriptions.addSubscription("message", normalCallback);
+
+ const messageEvent = new MessageEvent("message", { data: "test" });
+
+ expect(() => subscriptions.notify("message", messageEvent)).toThrow(
+ "Callback error",
+ );
+
+ expect(throwingCallback).toHaveBeenCalledWith(messageEvent);
+ expect(normalCallback).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("Integration scenarios", () => {
+ it("should handle complete subscription lifecycle", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback = vi.fn();
+
+ subscriptions.addSubscription("open", callback);
+
+ subscriptions.notify("open", new Event("open") as Event);
+ expect(callback).toHaveBeenCalledTimes(1);
+
+ subscriptions.removeSubscription("open", callback);
+
+ subscriptions.notify("open", new Event("open") as Event);
+ expect(callback).toHaveBeenCalledTimes(1);
+ });
+
+ it("should handle multiple events with multiple callbacks", () => {
+ const subscriptions = new ConnectionSubscriptions();
+
+ const openCallback1 = vi.fn();
+ const openCallback2 = vi.fn();
+ const closeCallback1 = vi.fn();
+ const messageCallback = vi.fn();
+
+ subscriptions.addSubscription("open", openCallback1);
+ subscriptions.addSubscription("open", openCallback2);
+ subscriptions.addSubscription("close", closeCallback1);
+ subscriptions.addSubscription("message", messageCallback);
+
+ subscriptions.notify("open", new Event("open") as Event);
+ expect(openCallback1).toHaveBeenCalledTimes(1);
+ expect(openCallback2).toHaveBeenCalledTimes(1);
+ expect(closeCallback1).not.toHaveBeenCalled();
+ expect(messageCallback).not.toHaveBeenCalled();
+
+ const messageEvent = new MessageEvent("message", { data: "test" });
+ subscriptions.notify("message", messageEvent);
+ expect(openCallback1).toHaveBeenCalledTimes(1);
+ expect(openCallback2).toHaveBeenCalledTimes(1);
+ expect(closeCallback1).not.toHaveBeenCalled();
+ expect(messageCallback).toHaveBeenCalledTimes(1);
+ expect(messageCallback).toHaveBeenCalledWith(messageEvent);
+
+ subscriptions.notify("close", new Event("close") as Event);
+ expect(openCallback1).toHaveBeenCalledTimes(1);
+ expect(openCallback2).toHaveBeenCalledTimes(1);
+ expect(closeCallback1).toHaveBeenCalledTimes(1);
+ expect(messageCallback).toHaveBeenCalledTimes(1);
+ });
+
+ it("should handle add and remove operations interleaved", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback1 = vi.fn();
+ const callback2 = vi.fn();
+ const callback3 = vi.fn();
+
+ subscriptions.addSubscription("message", callback1);
+ subscriptions.addSubscription("message", callback2);
+
+ const msg1 = new MessageEvent("message", { data: "msg1" });
+ subscriptions.notify("message", msg1);
+
+ expect(callback1).toHaveBeenCalledWith(msg1);
+ expect(callback2).toHaveBeenCalledWith(msg1);
+ expect(callback3).not.toHaveBeenCalled();
+
+ subscriptions.removeSubscription("message", callback1);
+ subscriptions.addSubscription("message", callback3);
+
+ const msg2 = new MessageEvent("message", { data: "msg2" });
+ subscriptions.notify("message", msg2);
+
+ expect(callback1).toHaveBeenCalledTimes(1);
+ expect(callback2).toHaveBeenCalledWith(msg2);
+ expect(callback3).toHaveBeenCalledWith(msg2);
+ });
+
+ it("should maintain separate subscription lists per event type", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback = vi.fn();
+
+ subscriptions.addSubscription("open", callback);
+ subscriptions.addSubscription("close", callback);
+ subscriptions.addSubscription("message", callback);
+
+ subscriptions.removeSubscription("close", callback);
+
+ subscriptions.notify("open", new Event("open") as Event);
+ expect(callback).toHaveBeenCalledTimes(1);
+
+ subscriptions.notify(
+ "message",
+ new MessageEvent("message", { data: "test" }),
+ );
+ expect(callback).toHaveBeenCalledTimes(2);
+
+ subscriptions.notify("close", new Event("close") as Event);
+ expect(callback).toHaveBeenCalledTimes(2);
+ });
+ });
+
+ describe("Edge cases", () => {
+ it("should handle callback that modifies subscriptions", () => {
+ const subscriptions = new ConnectionSubscriptions();
+ const callback1 = vi.fn();
+ const callback2 = vi.fn(() => {
+ subscriptions.removeSubscription("message", callback1);
+ });
+
+ subscriptions.addSubscription("message", callback1);
+ subscriptions.addSubscription("message", callback2);
+
+ const messageEvent = new MessageEvent("message", { data: "test" });
+ subscriptions.notify("message", messageEvent);
+
+ expect(callback1).toHaveBeenCalledTimes(1);
+ expect(callback2).toHaveBeenCalledTimes(1);
+
+ callback1.mockClear();
+ callback2.mockClear();
+
+ subscriptions.notify("message", messageEvent);
+ expect(callback1).not.toHaveBeenCalled();
+ expect(callback2).toHaveBeenCalledTimes(1);
+ });
+ });
+});
diff --git a/frontend/src/core/websocket/transports/basic.ts b/frontend/src/core/websocket/transports/basic.ts
new file mode 100644
index 0000000000..ff12430f7c
--- /dev/null
+++ b/frontend/src/core/websocket/transports/basic.ts
@@ -0,0 +1,95 @@
+/* Copyright 2024 Marimo. All rights reserved. */
+
+import {
+ type ConnectionEvent,
+ ConnectionSubscriptions,
+ type ConnectionTransportCallback,
+ type IConnectionTransport,
+} from "./transport";
+
+type MessageProducer = (callback: (message: MessageEvent) => void) => void;
+
+export class BasicTransport implements IConnectionTransport {
+ private subscriptions = new ConnectionSubscriptions();
+ private producer?: MessageProducer;
+
+ static withProducerCallback(producer: MessageProducer): IConnectionTransport {
+ return new BasicTransport(producer);
+ }
+
+ static empty(): IConnectionTransport {
+ return new BasicTransport();
+ }
+
+ private constructor(producer?: MessageProducer) {
+ this.producer = producer;
+ }
+
+ private startProducer() {
+ if (this.producer) {
+ this.producer((message) => {
+ this.subscriptions.notify("message", message);
+ });
+ }
+ }
+
+ private connect(): Promise<void> {
+ return new Promise<void>((resolve) => setTimeout(resolve, 0)).then(() => {
+ this.subscriptions.notify("open", new Event("open"));
+ });
+ }
+
+ get readyState(): WebSocket["readyState"] {
+ return WebSocket.OPEN;
+ }
+
+ reconnect(code?: number | undefined, reason?: string | undefined): void {
+ this.close();
+ this.connect();
+ return;
+ }
+
+ close(): void {
+ this.subscriptions.notify("close", new Event("close"));
+ }
+
+ send(data: string | ArrayBuffer | Blob | ArrayBufferView): Promise<void> {
+ this.subscriptions.notify(
+ "message",
+ new MessageEvent("message", {
+ data,
+ }),
+ );
+ return Promise.resolve();
+ }
+
+ addEventListener<T extends ConnectionEvent>(
+ event: T,
+ callback: ConnectionTransportCallback<T>,
+ ): void {
+ this.subscriptions.addSubscription(
+ event,
+ callback as ConnectionTransportCallback<ConnectionEvent>,
+ );
+
+ // Call open right away
+ if (event === "open") {
+ (callback as ConnectionTransportCallback<"open">)(new Event("open"));
+ }
+
+ // Start the producer when we have one consumer
+ if (event === "message") {
+ this.startProducer();
+ }
+ }
+
+ removeEventListener<T extends ConnectionEvent>(
+ event: T,
+ callback: ConnectionTransportCallback<T>,
+ ): void {
+ this.subscriptions.removeSubscription(
+ event,
+ callback as ConnectionTransportCallback<ConnectionEvent>,
+ );
+ }
+}
diff --git a/frontend/src/core/websocket/transports/transport.ts b/frontend/src/core/websocket/transports/transport.ts
new file mode 100644
index 0000000000..908fedeb83
--- /dev/null
+++ b/frontend/src/core/websocket/transports/transport.ts
@@ -0,0 +1,62 @@
+export type ConnectionEvent = "open" | "close" | "message" | "error";
+
+export interface IConnectionTransportMap {
+ open: WebSocketEventMap["open"];
+ message: WebSocketEventMap["message"];
+ close: WebSocketEventMap["close"];
+ error: WebSocketEventMap["error"];
+}
+
+export type ConnectionTransportCallback<T extends ConnectionEvent> = (
+ data: IConnectionTransportMap[T],
+) => void;
+
+export interface IConnectionTransport {
+ reconnect(code?: number | undefined, reason?: string | undefined): void;
+ close(): void;
+ send(data: string | ArrayBuffer | Blob | ArrayBufferView): void;
+ addEventListener<T extends ConnectionEvent>(
+ event: T,
+ callback: ConnectionTransportCallback<T>,
+ ): void;
+ removeEventListener<T extends ConnectionEvent>(
+ event: T,
+ callback: ConnectionTransportCallback<T>,
+ ): void;
+ readyState: WebSocket["readyState"];
+}
+
+export class ConnectionSubscriptions {
+ private subscriptions = new Map<
+ ConnectionEvent,
+ Set<ConnectionTransportCallback<ConnectionEvent>>
+ >();
+
+ addSubscription(
+ event: ConnectionEvent,
+ callback: ConnectionTransportCallback<ConnectionEvent>,
+ ): void {
+ if (!this.subscriptions.has(event)) {
+ this.subscriptions.set(event, new Set());
+ }
+ this.subscriptions.get(event)?.add(callback);
+ }
+
+ removeSubscription(
+ event: ConnectionEvent,
+ callback: ConnectionTransportCallback<ConnectionEvent>,
+ ): void {
+ this.subscriptions
+ .get(event)
+ ?.delete(callback as ConnectionTransportCallback<ConnectionEvent>);
+ }
+
+ notify(
+ event: ConnectionEvent,
+ data: IConnectionTransportMap[ConnectionEvent],
+ ): void {
+ for (const callback of this.subscriptions.get(event) ?? []) {
+ callback(data);
+ }
+ }
+}
diff --git a/frontend/src/core/websocket/types.ts b/frontend/src/core/websocket/types.ts
index 6e7a086a4b..d09f44f6bc 100644
--- a/frontend/src/core/websocket/types.ts
+++ b/frontend/src/core/websocket/types.ts
@@ -1,7 +1,6 @@
/* Copyright 2024 Marimo. All rights reserved. */
-import type ReconnectingWebSocket from "partysocket/ws";
-
+// TODO: rename to ConnectionState
export const WebSocketState = {
CONNECTING: "CONNECTING",
OPEN: "OPEN",
@@ -41,9 +40,3 @@ export type ConnectionStatus =
| typeof WebSocketState.OPEN
| typeof WebSocketState.CLOSING;
};
-
-type PublicInterface<T> = {
- [P in keyof T]: T[P];
-};
-
-export type IReconnectingWebSocket = PublicInterface<ReconnectingWebSocket>;
diff --git a/frontend/src/core/websocket/useMarimoWebSocket.tsx b/frontend/src/core/websocket/useMarimoKernelConnection.tsx
similarity index 96%
rename from frontend/src/core/websocket/useMarimoWebSocket.tsx
rename to frontend/src/core/websocket/useMarimoKernelConnection.tsx
index 0d6dfc1ddb..86679dd7c1 100644
--- a/frontend/src/core/websocket/useMarimoWebSocket.tsx
+++ b/frontend/src/core/websocket/useMarimoKernelConnection.tsx
@@ -7,7 +7,7 @@ import { toast } from "@/components/ui/use-toast";
import { getNotebook, useCellActions } from "@/core/cells/cells";
import { AUTOCOMPLETER } from "@/core/codemirror/completion/Autocompleter";
import type { OperationMessage } from "@/core/kernel/messages";
-import { useWebSocket } from "@/core/websocket/useWebSocket";
+import { useConnectionTransport } from "@/core/websocket/useWebSocket";
import { renderHTML } from "@/plugins/core/RenderHTML";
import {
handleWidgetMessage,
@@ -58,12 +58,13 @@ import { SECRETS_REGISTRY } from "../secrets/request-registry";
import { isStaticNotebook } from "../static/static-state";
import { useVariablesActions } from "../variables/state";
import type { VariableName } from "../variables/types";
+import { isWasm } from "../wasm/utils";
import { WebSocketClosedReason, WebSocketState } from "./types";
/**
- * WebSocket that connects to the Marimo kernel and handles incoming messages.
+ * Creates a connection to the Marimo kernel and handles incoming messages.
*/
-export function useMarimoWebSocket(opts: {
+export function useMarimoKernelConnection(opts: {
sessionId: SessionId;
autoInstantiate: boolean;
setCells: (cells: CellData[], layout: LayoutState) => void;
@@ -296,7 +297,7 @@ export function useMarimoWebSocket(opts: {
}
};
- const ws = useWebSocket({
+ const ws = useConnectionTransport({
static: isStaticNotebook(),
/**
* Unique URL for this session.
@@ -317,7 +318,17 @@ export function useMarimoWebSocket(opts: {
setConnection({ state: WebSocketState.OPEN });
},
+ /**
+ * Wait to connect, in case the remote kernel still starting up.
+ */
waitToConnect: async () => {
+ if (isStaticNotebook()) {
+ return;
+ }
+ if (isWasm()) {
+ return;
+ }
+
if (runtimeManager.isSameOrigin) {
return;
}
@@ -325,7 +336,7 @@ export function useMarimoWebSocket(opts: {
},
/**
- * Message callback. Handle messages sent by the kernel.
+ * Handle messages sent by the kernel.
*/
onMessage: (e) => {
try {
diff --git a/frontend/src/core/websocket/useWebSocket.tsx b/frontend/src/core/websocket/useWebSocket.tsx
index 2f3fa1b802..8729d83a36 100644
--- a/frontend/src/core/websocket/useWebSocket.tsx
+++ b/frontend/src/core/websocket/useWebSocket.tsx
@@ -3,51 +3,57 @@
import ReconnectingWebSocket from "partysocket/ws";
import { useEffect, useState } from "react";
import { Logger } from "@/utils/Logger";
-import { isStaticNotebook } from "../static/static-state";
-import { PyodideBridge, PyodideWebsocket } from "../wasm/bridge";
+import { createPyodideConnection } from "../wasm/bridge";
import { isWasm } from "../wasm/utils";
-import { StaticWebsocket } from "./StaticWebsocket";
-import type { IReconnectingWebSocket } from "./types";
+import { BasicTransport } from "./transports/basic";
+import type { IConnectionTransport } from "./transports/transport";
-interface UseWebSocketOptions {
+interface UseConnectionTransportOptions {
url: () => string;
static: boolean;
- waitToConnect?: () => Promise<void>;
- onOpen?: (event: WebSocketEventMap["open"]) => void;
- onMessage?: (event: WebSocketEventMap["message"]) => void;
- onClose?: (event: WebSocketEventMap["close"]) => void;
- onError?: (event: WebSocketEventMap["error"]) => void;
+ waitToConnect: () => Promise<void>;
+ onOpen: (event: WebSocketEventMap["open"]) => void;
+ onMessage: (event: WebSocketEventMap["message"]) => void;
+ onClose: (event: WebSocketEventMap["close"]) => void;
+ onError: (event: WebSocketEventMap["error"]) => void;
+}
+
+function createConnectionTransport(
+ options: Pick<UseConnectionTransportOptions, "url" | "static">,
+): IConnectionTransport {
+ if (options.static) {
+ return BasicTransport.empty();
+ }
+ if (isWasm()) {
+ return createPyodideConnection();
+ }
+ // Create a connection transport using the ReconnectingWebSocket from partysocket
+ // This handles reconnecting when the connection is lost.
+ return new ReconnectingWebSocket(options.url(), undefined, {
+ // We don't want Infinity retries
+ maxRetries: 10,
+ debug: false,
+ startClosed: true,
+ // long timeout -- the server can become slow when many notebooks
+ // are open.
+ connectionTimeout: 10_000,
+ });
}
/**
- * A hook for creating a WebSocket connection with React.
- *
- * We use the WebSocket from partysocket, which is a wrapper around the native WebSocket API with reconnect logic.
+ * A hook for creating a connection transport with React.
*/
-export function useWebSocket(options: UseWebSocketOptions) {
- const { onOpen, onMessage, onClose, onError, waitToConnect, ...rest } =
- options;
+export function useConnectionTransport(options: UseConnectionTransportOptions) {
+ const { onOpen, onMessage, onClose, onError, waitToConnect } = options;
// eslint-disable-next-line react/hook-use-state
- const [ws] = useState<IReconnectingWebSocket>(() => {
- const socket: IReconnectingWebSocket = isWasm()
- ? new PyodideWebsocket(PyodideBridge.INSTANCE)
- : options.static
- ? new StaticWebsocket()
- : new ReconnectingWebSocket(rest.url, undefined, {
- // We don't want Infinity retries
- maxRetries: 10,
- debug: false,
- startClosed: true,
- // long timeout -- the server can become slow when many notebooks
- // are open.
- connectionTimeout: 10_000,
- });
+ const [transport] = useState<IConnectionTransport>(() => {
+ const socket = createConnectionTransport(options);
- onOpen && socket.addEventListener("open", onOpen);
- onClose && socket.addEventListener("close", onClose);
- onError && socket.addEventListener("error", onError);
- onMessage && socket.addEventListener("message", onMessage);
+ socket.addEventListener("open", onOpen);
+ socket.addEventListener("close", onClose);
+ socket.addEventListener("error", onError);
+ socket.addEventListener("message", onMessage);
return socket;
});
@@ -55,34 +61,27 @@ export function useWebSocket(options: UseWebSocketOptions) {
useEffect(() => {
// If it's closed, reconnect
// This starts closed, so we need to connect for the first time
- if (ws.readyState === WebSocket.CLOSED) {
- // Ignore waitToConnect for static and wasm notebooks
- if (waitToConnect && !isStaticNotebook() && !isWasm()) {
- waitToConnect()
- .then(() => {
- ws.reconnect();
- })
- .catch((error) => {
- Logger.error("Healthy connection never made", error);
- ws.close();
- });
- } else {
- ws.reconnect();
- }
+ if (transport.readyState === WebSocket.CLOSED) {
+ void waitToConnect()
+ .then(() => transport.reconnect())
+ .catch((error) => {
+ Logger.error("Healthy connection never made", error);
+ transport.close();
+ });
}
return () => {
Logger.warn(
- "useWebSocket is unmounting. This likely means there is a bug.",
+ "useConnectionTransport is unmounting. This likely means there is a bug.",
);
- ws.close();
- onOpen && ws.removeEventListener("open", onOpen);
- onClose && ws.removeEventListener("close", onClose);
- onError && ws.removeEventListener("error", onError);
- onMessage && ws.removeEventListener("message", onMessage);
+ transport.close();
+ transport.removeEventListener("open", onOpen);
+ transport.removeEventListener("close", onClose);
+ transport.removeEventListener("error", onError);
+ transport.removeEventListener("message", onMessage);
};
// eslint-disable-next-line react-hooks/exhaustive-deps
- }, [ws]);
+ }, [transport]);
- return ws;
+ return transport;
}
diff --git a/frontend/vite.config.mts b/frontend/vite.config.mts
index 176c1410bb..471bb55a85 100644
--- a/frontend/vite.config.mts
+++ b/frontend/vite.config.mts
@@ -1,5 +1,6 @@
/* Copyright 2024 Marimo. All rights reserved. */
+import { execSync } from "node:child_process";
import { codecovVitePlugin } from "@codecov/vite-plugin";
import react from "@vitejs/plugin-react";
import { JSDOM } from "jsdom";
@@ -44,6 +45,9 @@ const htmlDevPlugin = (): Plugin => {
}
if (isPyodide) {
+ const marimoVersion = execSync("uv run marimo --version")
+ .toString()
+ .trim();
const modeFromUrl = ctx.originalUrl?.includes("mode=read")
? "read"
: "edit";
@@ -56,7 +60,7 @@ const htmlDevPlugin = (): Plugin => {
mode: modeFromUrl,
// If VITE_MARIMO_VERSION is defined, pull the local version of marimo
// Otherwise, pull the latest version of marimo from PyPI
- version: process.env.VITE_MARIMO_VERSION ? "local" : "latest",
+ version: process.env.VITE_MARIMO_VERSION ?? marimoVersion,
config: {
// Add/remove user config here while developing
// runtime: {