👍 gracefully close service

- The Service is closed when The worker is terminated.
- The worker is teminated when The Service is closed.
- `denops.dispatch()` (but `service.dispatch()`) rejects with a service
  closed error if the service is closed before the plugin loaded.

Author: Milly

denops/@denops-private/service.ts

@@ -7,12 +7,14 @@ import type { CallbackId, Service as HostService } from "./host.ts";
 /**
  * Service manage plugins and is visible from the host (Vim/Neovim) through `invoke()` function.
  */
-export class Service implements HostService, Disposable {
+export class Service implements HostService, AsyncDisposable {
   #interruptController = new AbortController();
   #plugins = new Map<string, Plugin>();
   #waiters = new Map<string, PromiseWithResolvers<void>>();
   #meta: Meta;
   #host?: Host;
+  #closed = false;
+  #closedWaiter = Promise.withResolvers<void>();
 
   constructor(meta: Meta) {
     this.#meta = meta;
@@ -22,6 +24,7 @@ export class Service implements HostService, Disposable {
     let waiter = this.#waiters.get(name);
     if (!waiter) {
       waiter = Promise.withResolvers();
+      waiter.promise.catch(() => {});
       this.#waiters.set(name, waiter);
     }
     return waiter;
@@ -40,6 +43,9 @@ export class Service implements HostService, Disposable {
     script: string,
     suffix = "",
   ): Promise<void> {
+    if (this.#closed) {
+      throw new Error("Service closed");
+    }
     if (!this.#host) {
       throw new Error("No host is bound to the service");
     }
@@ -75,6 +81,9 @@ export class Service implements HostService, Disposable {
   }
 
   waitLoaded(name: string): Promise<void> {
+    if (this.#closed) {
+      return Promise.reject(new Error("Service closed"));
+    }
     return this.#getWaiter(name).promise;
   }
 
@@ -128,8 +137,27 @@ export class Service implements HostService, Disposable {
     }
   }
 
-  [Symbol.dispose](): void {
-    this.#plugins.clear();
+  close(): Promise<void> {
+    if (!this.#closed) {
+      this.#closed = true;
+      const error = new Error("Service closed");
+      for (const { reject } of this.#waiters.values()) {
+        reject(error);
+      }
+      this.#waiters.clear();
+      this.#plugins.clear();
+      this.#host = void 0;
+      this.#closedWaiter.resolve();
+    }
+    return this.waitClosed();
+  }
+
+  waitClosed(): Promise<void> {
+    return this.#closedWaiter.promise;
+  }
+
+  [Symbol.asyncDispose](): Promise<void> {
+    return this.close();
   }
 }
 

denops/@denops-private/service_test.ts

@@ -506,4 +506,79 @@ Deno.test("Service", async (t) => {
       assertThrows(() => signal.throwIfAborted(), "test");
     },
   );
+
+  const waitClosed = service.waitClosed();
+
+  const waitLoadedCalledBeforeClose = service.waitLoaded(
+    "whenclosedtestplugin",
+  );
+
+  await t.step(
+    "the result promise of waitClosed() become 'pending' when the service is not closed",
+    async () => {
+      assert(await promiseState(waitClosed), "pending");
+    },
+  );
+
+  await t.step(
+    "close() closes the service",
+    async () => {
+      await service.close();
+    },
+  );
+
+  await t.step(
+    "the result promise of waitClosed() become 'fulfilled' when the service is closed",
+    async () => {
+      assert(await promiseState(waitClosed), "fulfilled");
+    },
+  );
+
+  await t.step(
+    "the result promise of waitLoaded() become 'rejected' when the service is closed",
+    async () => {
+      assertEquals(await promiseState(waitLoadedCalledBeforeClose), "rejected");
+      await assertRejects(
+        () => waitLoadedCalledBeforeClose,
+        Error,
+        "Service closed",
+      );
+    },
+  );
+
+  await t.step(
+    "waitClosed() returns 'fulfilled' promise if the service is already closed",
+    async () => {
+      const actual = service.waitClosed();
+      assert(await promiseState(actual), "fulfilled");
+    },
+  );
+
+  await t.step(
+    "waitLoaded() returns 'rejected' promise if the service is already closed",
+    async () => {
+      await assertRejects(
+        () => service.waitLoaded("after-closed-test-plugin"),
+        Error,
+        "Service closed",
+      );
+    },
+  );
+
+  await t.step(
+    "load() rejects an error when the service is already closed",
+    async () => {
+      await assertRejects(
+        () => service.load("dummyValid", scriptValid),
+        Error,
+        "Service closed",
+      );
+    },
+  );
+
+  await t.step("[@@asyncDispose]() calls close()", async () => {
+    using service_close = stub(service, "close");
+    await service[Symbol.asyncDispose]();
+    assertSpyCalls(service_close, 1);
+  });
 });

denops/@denops-private/worker.ts

@@ -77,10 +77,11 @@ async function connectHost(): Promise<void> {
 
   // Start service
   using sigintTrap = asyncSignal("SIGINT");
-  using service = new Service(meta);
+  await using service = new Service(meta);
   await host.init(service);
   await host.call("execute", "doautocmd <nomodeline> User DenopsReady", "");
   await Promise.race([
+    service.waitClosed(),
     host.waitClosed(),
     sigintTrap,
   ]);

denops/@denops-private/worker_test.ts

@@ -9,6 +9,7 @@ import {
 import {
   assertSpyCalls,
   resolvesNext,
+  spy,
   stub,
 } from "jsr:@std/[email protected]/mock";
 import { delay } from "jsr:@std/[email protected]/delay";
@@ -17,6 +18,7 @@ import * as nvimCodec from "jsr:@lambdalisue/messagepack@^1.0.1";
 import { createFakeMeta } from "./testutil/mock.ts";
 import { Neovim } from "./host/nvim.ts";
 import { Vim } from "./host/vim.ts";
+import { Service } from "./service.ts";
 import { main } from "./worker.ts";
 
 const CONSOLE_PATCH_METHODS = [
@@ -125,6 +127,14 @@ for (const { host, mode } of matrix) {
       using _addEventListenerSpy = spyAddEventListener();
       using _denoCommandStub = stubDenoCommand();
       using deno_addSignalListener = stub(Deno, "addSignalListener");
+      using host_asyncDispose = spy(
+        (host === "vim" ? Vim : Neovim).prototype,
+        Symbol.asyncDispose,
+      );
+      using service_asyncDispose = spy(
+        Service.prototype,
+        Symbol.asyncDispose,
+      );
       using self_close = stub(globalThis, "close");
       const usePostMessageHistory = () => ({
         [Symbol.dispose]: () => messageStub.postMessage.resetHistory(),
@@ -353,15 +363,37 @@ for (const { host, mode } of matrix) {
         assertInstanceOf(signalHandler, Function);
       });
 
-      await t.step("closes worker when stream is closed", async () => {
-        assertSpyCalls(self_close, 0);
+      await t.step("before stream is closed", async (t) => {
+        await t.step("does not dispose service", () => {
+          assertSpyCalls(service_asyncDispose, 0);
+        });
 
-        // NOTE: Send `null` to close workerio stream.
-        messageStub.fakeHostMessage(null);
+        await t.step("does not dispose host", () => {
+          assertSpyCalls(host_asyncDispose, 0);
+        });
 
-        await delay(0);
-        assertSpyCalls(self_close, 1);
-        await mainPromise;
+        await t.step("does not close worker", () => {
+          assertSpyCalls(self_close, 0);
+        });
+      });
+
+      // NOTE: Send `null` to close workerio stream.
+      messageStub.fakeHostMessage(null);
+      await delay(0);
+
+      await t.step("after stream is closed", async (t) => {
+        await t.step("disposes service", () => {
+          assertSpyCalls(service_asyncDispose, 1);
+        });
+
+        await t.step("disposes host", () => {
+          assertSpyCalls(host_asyncDispose, 1);
+        });
+
+        await t.step("closes worker", async () => {
+          assertSpyCalls(self_close, 1);
+          await mainPromise;
+        });
       });
     });
 
@@ -397,6 +429,14 @@ for (const { host, mode } of matrix) {
       using _addEventListenerSpy = spyAddEventListener();
       using _denoCommandStub = stubDenoCommand();
       using deno_addSignalListener = stub(Deno, "addSignalListener");
+      using host_asyncDispose = spy(
+        (host === "vim" ? Vim : Neovim).prototype,
+        Symbol.asyncDispose,
+      );
+      using service_asyncDispose = spy(
+        Service.prototype,
+        Symbol.asyncDispose,
+      );
       using self_close = stub(globalThis, "close");
       const fakeMeta = { ...createFakeMeta(), host, mode };
 
@@ -441,6 +481,82 @@ for (const { host, mode } of matrix) {
         );
       });
 
+      await t.step("disposes service", () => {
+        assertSpyCalls(service_asyncDispose, 1);
+      });
+
+      await t.step("disposes host", () => {
+        assertSpyCalls(host_asyncDispose, 1);
+      });
+
+      await t.step("closes worker", async () => {
+        assertSpyCalls(self_close, 1);
+        await mainPromise;
+      });
+    });
+
+    await t.step("main() if service is closed", async (t) => {
+      using messageStub = stubMessage();
+      using _consoleStub = stubConsole();
+      using _addEventListenerSpy = spyAddEventListener();
+      using _denoCommandStub = stubDenoCommand();
+      using _deno_addSignalListener = stub(Deno, "addSignalListener");
+      using host_asyncDispose = spy(
+        (host === "vim" ? Vim : Neovim).prototype,
+        Symbol.asyncDispose,
+      );
+      using service_asyncDispose = spy(
+        Service.prototype,
+        Symbol.asyncDispose,
+      );
+      const service_waitClosed_waiter = Promise.withResolvers<void>();
+      using service_waitClosed = stub(
+        Service.prototype,
+        "waitClosed",
+        () => service_waitClosed_waiter.promise,
+      );
+      using self_close = stub(globalThis, "close");
+      const fakeMeta = { ...createFakeMeta(), host, mode };
+
+      const mainPromise = main();
+
+      if (host === "vim") {
+        // Initial message from the host.
+        messageStub.fakeHostMessage(vimCodec.encode([0, ["void"]]));
+        await delay(0);
+        // requests Meta data
+        messageStub.fakeHostMessage(vimCodec.encode([-1, [fakeMeta, ""]]));
+        await delay(0);
+        // doautocmd `User DenopsReady`
+        messageStub.fakeHostMessage(vimCodec.encode([-2, ["", ""]]));
+        await delay(0);
+      } else {
+        // Initial message from the host.
+        messageStub.fakeHostMessage(nvimCodec.encode([2, "void", []]));
+        await delay(0);
+        // requests Meta data
+        messageStub.fakeHostMessage(nvimCodec.encode([1, 0, null, fakeMeta]));
+        await delay(0);
+        // sets client info
+        messageStub.fakeHostMessage(nvimCodec.encode([1, 1, null, 0]));
+        await delay(0);
+        // doautocmd `User DenopsReady`
+        messageStub.fakeHostMessage(nvimCodec.encode([1, 2, null, ""]));
+        await delay(0);
+      }
+
+      assertSpyCalls(service_waitClosed, 1);
+      service_waitClosed_waiter.resolve();
+      await delay(0);
+
+      await t.step("disposes service", () => {
+        assertSpyCalls(service_asyncDispose, 1);
+      });
+
+      await t.step("disposes host", () => {
+        assertSpyCalls(host_asyncDispose, 1);
+      });
+
       await t.step("closes worker", async () => {
         assertSpyCalls(self_close, 1);
         await mainPromise;