feat(runtime,serverless): add V8 heap snapshots (#591)

* feat(runtime): use v8 snapshot for runtime code

* feat: run all tests with and without snapshot

* chore: add changesets

* fix(serverless): add back thread isolate

* feat: build serverless before running runtime tests

.changeset/early-wombats-ring.md

@@ -0,0 +1,6 @@
+---
+'@lagon/runtime': patch
+'@lagon/js-runtime': patch
+---
+
+Split sync and async bindings into LagonSync/LagonAsync

.changeset/healthy-rice-fly.md

@@ -0,0 +1,6 @@
+---
+'@lagon/runtime': patch
+'@lagon/serverless': patch
+---
+
+Add option to load V8 heap snapshot

.gitignore

@@ -15,3 +15,4 @@ storybook-static/
 .DS_Store
 .env
 tsconfig.tsbuildinfo
+snapshot.bin

crates/runtime/Cargo.toml

@@ -14,3 +14,7 @@ lagon-runtime-http = { path = "../runtime_http" }
 lagon-runtime-isolate = { path = "../runtime_isolate" }
 log = { version = "0.4.17", features = ["std", "kv_unstable", "kv_unstable_serde"] }
 serial_test = "1.0.0"
+
+[features]
+default = []
+ignore-snapshot = ["lagon-runtime-isolate/ignore-snapshot"]

crates/runtime/package.json

@@ -5,7 +5,7 @@
   "private": true,
   "scripts": {
     "build": "cargo build",
-    "test": "cargo test",
+    "test": "cargo test && cargo test --features ignore-snapshot",
     "lint": "cargo clippy -- -Dwarnings --no-deps"
   }
 }

crates/runtime/tests/crypto.rs

@@ -14,14 +14,17 @@ fn setup() {
 #[tokio::test]
 async fn crypto_random_uuid() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export function handler() {
     const uuid = crypto.randomUUID();
     const secondUuid = crypto.randomUUID();
     return new Response(`${typeof uuid} ${uuid.length} ${uuid === secondUuid}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -34,14 +37,17 @@ async fn crypto_random_uuid() {
 #[tokio::test]
 async fn crypto_get_random_values() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export function handler() {
     const typedArray = new Uint8Array([0, 8, 2]);
     const result = crypto.getRandomValues(typedArray);
     return new Response(`${result == typedArray} ${typedArray.length} ${result.length}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -54,13 +60,16 @@ async fn crypto_get_random_values() {
 #[tokio::test]
 async fn crypto_get_random_values_throw_not_typedarray() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export function handler() {
     const result = crypto.getRandomValues(true);
     return new Response(`${result == typedArray} ${typedArray.length} ${result.length}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -76,8 +85,9 @@ async fn crypto_get_random_values_throw_not_typedarray() {
 #[tokio::test]
 async fn crypto_key_value() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const { keyValue } = await crypto.subtle.importKey(
         'raw',
         new TextEncoder().encode('secret'),
@@ -88,8 +98,10 @@ async fn crypto_key_value() {
 
     return new Response(`${typeof keyValue} ${keyValue.length}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -102,8 +114,9 @@ async fn crypto_key_value() {
 #[tokio::test]
 async fn crypto_unique_key_value() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const { keyValue: first } = await crypto.subtle.importKey(
         'raw',
         new TextEncoder().encode('secret'),
@@ -121,8 +134,10 @@ async fn crypto_unique_key_value() {
 
     return new Response(first == second);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -135,8 +150,9 @@ async fn crypto_unique_key_value() {
 #[tokio::test]
 async fn crypto_sign() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const key = await crypto.subtle.importKey(
         'raw',
         new TextEncoder().encode('secret'),
@@ -151,8 +167,10 @@ async fn crypto_sign() {
 
     return new Response(`${signed instanceof Uint8Array} ${signed.length}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -165,8 +183,9 @@ async fn crypto_sign() {
 #[tokio::test]
 async fn crypto_verify() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const key = await crypto.subtle.importKey(
         'raw',
         new TextEncoder().encode('secret'),
@@ -185,8 +204,10 @@ async fn crypto_verify() {
 
     return new Response(verified);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -199,14 +220,17 @@ async fn crypto_verify() {
 #[tokio::test]
 async fn crypto_digest_sha1() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const digest = await crypto.subtle.digest('SHA-1', new TextEncoder().encode('hello, world'));
 
     return new Response(`${digest.length} ${digest}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -221,14 +245,17 @@ async fn crypto_digest_sha1() {
 #[tokio::test]
 async fn crypto_digest_string() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode('hello, world'));
 
     return new Response(`${digest.length} ${digest}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -248,7 +275,7 @@ async fn crypto_digest_object() {
     return new Response(`${digest.length} ${digest}`);
 }"
         .into(),
-    ));
+    ).snapshot_blob(include_bytes!("../../serverless/snapshot.bin")));
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -261,8 +288,9 @@ async fn crypto_digest_object() {
 #[tokio::test]
 async fn crypto_encrypt() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const key = await crypto.subtle.importKey(
         'raw',
         new TextEncoder().encode('secret'),
@@ -280,8 +308,10 @@ async fn crypto_encrypt() {
 
     return new Response(`${ciphertext instanceof Uint8Array} ${ciphertext.length}`);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -294,8 +324,9 @@ async fn crypto_encrypt() {
 #[tokio::test]
 async fn crypto_decrypt() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export async function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export async function handler() {
     const key = await crypto.subtle.importKey(
         'raw',
         new TextEncoder().encode('secret'),
@@ -319,8 +350,10 @@ async fn crypto_decrypt() {
 
     return new Response(text);
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 

crates/runtime/tests/disallow_codegen.rs

@@ -14,13 +14,16 @@ fn setup() {
 #[tokio::test]
 async fn disallow_eval() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export function handler() {
     const result = eval('1 + 1')
     return new Response(result)
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;
 
@@ -35,13 +38,16 @@ async fn disallow_eval() {
 #[tokio::test]
 async fn disallow_function() {
     setup();
-    let mut isolate = Isolate::new(IsolateOptions::new(
-        "export function handler() {
+    let mut isolate = Isolate::new(
+        IsolateOptions::new(
+            "export function handler() {
     const result = new Function('return 1 + 1')
     return new Response(result())
 }"
-        .into(),
-    ));
+            .into(),
+        )
+        .snapshot_blob(include_bytes!("../../serverless/snapshot.bin")),
+    );
     let (tx, rx) = flume::unbounded();
     isolate.run(Request::default(), tx).await;