beam.com 0.1.0-rc.2 → 0.1.0-rc.3

package/runtime/browser.js

@@ -86,14 +86,15 @@ if (globalThis.caches && !caches.default) {
 
 // A request to the app. A Request of a page drops the headers Upgrade and
 // Sec-*, so the request is an object with the fields that worker.js reads,
-// and a Headers of its own.
+// and a Headers of its own. The body is a stream, as the body of a Request
+// (bridgeUpload of worker.js reads it in parts), with its size.
 function request(url, { method = 'GET', headers = {}, body = null } = {}) {
-  return {
-    url: url.href,
-    method,
-    headers: new Headers(headers),
-    arrayBuffer: () => new NativeResponse(body).arrayBuffer(),
-  };
+  const h = new Headers(headers);
+  if (body != null && !h.has('content-length')) {
+    const size = typeof body === 'string' ? new TextEncoder().encode(body).length : body.byteLength ?? body.size;
+    if (size !== undefined) h.set('content-length', String(size));
+  }
+  return { url: url.href, method, headers: h, body: body == null ? null : new NativeResponse(body).body };
 }
 
 // A reader of the bytes of the file of url (app-com.js): one range for each

package/runtime/cloudflare/durable.js

@@ -44,6 +44,7 @@ export class Beam extends DurableObject {
     super(ctx, env);
     this.vm = null;
     this.expires = undefined;
+    this.resetting = false;
   }
 
   // The VM starts at the first request: a path tenant gives its name there.
@@ -55,6 +56,10 @@ export class Beam extends DurableObject {
   }
 
   async fetch(request) {
+    if (this.resetting) {
+      return new Response('The app stopped. Try again.\n',
+        { status: 503, headers: { 'content-type': 'text/plain', 'retry-after': '1' } });
+    }
     if (this.env.BEAM_INSTANCES && this.env.BEAM_TENANTS === 'path') {
       this.expires ??= (await this.ctx.storage.get(EXPIRES)) ?? null;
       if (!this.expires || this.expires <= Date.now()) {
@@ -71,11 +76,36 @@ export class Beam extends DurableObject {
         vars.BEAM_TENANT_PATH = `/t/${tenant}`;
       }
       if (this.expires) vars.BEAM_INSTANCE_EXPIRES = String(Math.floor(this.expires / 1000));
-      this.vm = this.makeVm(vars, new URL(request.url).hostname);
+      const vm = this.vm = this.makeVm(vars, new URL(request.url).hostname);
+      vm.onDead = () => this.vmStopped(vm);
+      vm.ready.catch(() => this.vmStopped(vm));
     }
     return this.vm.fetch(request);
   }
 
+  // The VM stopped (erlang:halt, or a trap such as an allocation that
+  // failed), or its boot failed. Its open requests got 503. The memory of
+  // WebAssembly does not shrink, so the object resets after these answers:
+  // a new instance of the object, with a new VM, takes the next request.
+  vmStopped(vm) {
+    if (this.vm !== vm) return;
+    this.vm = null;
+    this.resetting = true;
+    setTimeout(() => this.reset('the VM stopped'), 100);
+  }
+
+  // A new instance of the object. When the host cannot abort the object,
+  // the next request starts a new VM in this instance: no request stays
+  // at 503.
+  reset(reason) {
+    try {
+      this.ctx.abort(reason);
+    } catch (e) {
+      console.log(`beam: the object did not reset (${e.message}): the next request starts a new VM`);
+      this.resetting = false;
+    }
+  }
+
   // An instance: its time limit (from the registry).
   async start(expires) {
     await this.ctx.storage.put(EXPIRES, expires);
@@ -92,7 +122,7 @@ export class Beam extends DurableObject {
   async expire() {
     this.expires = null;
     await this.ctx.storage.deleteAll();
-    if (this.vm) setTimeout(() => this.ctx.abort('the instance expired'), 0);
+    if (this.vm) setTimeout(() => this.reset('the instance expired'), 0);
   }
 
   // The registry (the object ".registry") admits a visitor: a ticket and a

package/runtime/cloudflare/index.js

@@ -27,7 +27,7 @@
 import { env as globalEnv } from 'cloudflare:workers';
 import { release, use } from './release.js';
 import { useSnapshot } from './snapshot.js';
-import plain, { snapshotHeader, staticResponse, Vm } from './worker.js';
+import plain, { parseSnapshot, staticResponse, Vm } from './worker.js';
 import front from './durable.js';
 
 export { Beam } from './durable.js';
@@ -62,7 +62,9 @@ export { Beam } from './durable.js';
 // --snapshot app.com, imported as a Data module, as app.com):
 // - a full one (--full): each new VM restores it in place of a boot. A
 //   stateless Worker restores its VM in the global scope, before the
-//   first request;
+//   first request. The global scope cannot inflate the pages of a
+//   snapshot in gzip (BEAMSNZ1), so such a snapshot restores in the first
+//   request;
 // - one at the boot point: a new VM restores it only when the store of
 //   snapshots has none (the first VM of a deploy), and then the VM makes
 //   its snapshot for the store, as with no snapshot of the build.
@@ -80,12 +82,21 @@ export function serve(app, { binding = 'BEAM', name, nifs = null, snapshot = nul
   // The VM of a stateless Worker, restored from a full snapshot in the
   // global scope.
   let vm = null;
-  const full = !!snapshot && !snapshotHeader(snapshot).boot_point;
+  const parsed = snapshot && parseSnapshot(snapshot);
+  const full = !!parsed && !parsed.boot_point && !parsed.packed;
   const ready = full && !globalEnv[binding] ? (async () => {
     vm = new Vm(globalEnv, { release: await release(), snapshot });
+    // A VM that stopped: the requests then go to the Worker of worker.js,
+    // which boots a VM of its own.
+    vm.onDead = () => { vm = null; };
     await vm.ready;
     if (globalEnv.BEAM_WARM) await vm.warm(globalEnv.BEAM_WARM);
-  })() : Promise.resolve();
+  })().catch((e) => {
+    // A VM that did not restore: the same, and the entry still loads
+    // (await beam.ready).
+    console.log(`beam: the snapshot of the build did not restore in the global scope (${e?.message ?? e}): each request boots a VM`);
+    vm = null;
+  }) : Promise.resolve();
   // The env of the front: the binding as BEAM, the name of the object, and
   // the static files of app.com (the front serves them, with no request
   // to the object).