~gagbo/Rustpad

A fork of https://github.com/ekzhang/rustpad with remote code execution capabilities
~gagbo/public-inbox

New mailing list added

2 months ago
~gagbo/Rustpad

New ticket tracker added

2 months ago

#Derivative work notice

Most of the work has been done by ekzhang on github.

#Rustpad

Docker Pulls Docker Image Size builds.sr.ht status

Rustpad is an efficient and minimal open-source collaborative text editor based on the operational transformation algorithm. It lets users collaborate in real time while writing code in their browser. Rustpad is completely self-hosted and fits in a tiny Docker image, no database required.


pad.gagbo.net

The server is written in Rust using the warp web server framework and the operational-transform library. We use wasm-bindgen to compile text operation logic to WebAssembly code, which runs in the browser. The frontend is written in TypeScript using React and interfaces with Monaco, the text editor that powers VS Code.

Architecturally, client-side code communicates via WebSocket with a central server that stores in-memory data structures. This makes the editor very fast, allows us to avoid provisioning a database, and makes testing much easier. The tradeoff is that documents are transient and lost between server restarts, or after 24 hours of inactivity.

The server additionally holds an optional client to Piston, a safe and generic remote code execution engine to allow all users to run the code in the shared editor.

#Development setup

To run this application, you need to install Rust, wasm-pack, and Node.js. Then, build the WebAssembly portion of the app:

wasm-pack build --target web rustpad-wasm

When that is complete, you can install dependencies for the frontend React application:

npm install

Next, compile and run the backend web server:

cargo run

While the backend is running, open another shell and run the following command to start the frontend portion.

npm run dev

This command will open a browser window to http://localhost:3000, with hot reloading on changes.

#Testing

To run integration tests for the server, use the standard cargo test command. For the WebAssembly component, you can run tests in a headless browser with

wasm-pack test --chrome --headless rustpad-wasm

#Configuration

Although the default behavior of Rustpad is to store documents solely in memory and collect garbage after 24 hours of inactivity, this can be configured by setting the appropriate variables. The application server looks for the following environment variables on startup:

  • EXPIRY_DAYS: An integer corresponding to the number of days that inactive documents are kept in memory before being garbage collected by the server (default 1 day).
  • SQLITE_URI: A SQLite connection string used for persistence. If provided, Rustpad will snapshot document contents to a local file, which enables them to be retained between server restarts and after their in-memory data structures expire. (When deploying a Docker container, this should point to the path of a mounted volume.)
  • PISTON_URL: A location to the backend Piston instance to use for code evaluation. If the environment variable is not set, the application will not show the execution panel.
  • PORT: Which local port to listen for HTTP connections on (defaults to 3030).
  • RUST_LOG: Directives that control application logging, see the env_logger docs for more information.

#Deployment

Rustpad is distributed as a single 6 MB Docker image, which is built automatically from the Dockerfile in this repository. You can pull the latest version of this image from Docker Hub. It has multi-platform support for linux/amd64 and linux/arm64.

docker pull gagbo/rustpad:piston-latest

(You can also manually build this image with docker build -t rustpad . in the project root directory.) To run locally, execute the following command, then open http://localhost:3030 in your browser.

# This will use the public instance of Piston with all runtimes installed,
# but rate limited to 5 queries per second
docker run --rm -dp 3030:3030 -e PISTON_URL=https://emkc.org/api/v2/piston gagbo/rustpad:piston-latest

A demo version with a limited number of runtimes is available on pad.gagbo.net, deployed manually using the shipped docker-compose file as a base, on a self-managed small server.

#Piston integration

Using the basic docker-compose setup of Piston, you typically would have to use PISTON_URL=http://localhost:2000/api/v2 to have access to Piston execution panel in the application.

#In the media