net: server add asyncDispose

Author: atlowChemi

doc/api/net.md

@@ -357,6 +357,17 @@ The optional `callback` will be called once the `'close'` event occurs. Unlike
 that event, it will be called with an `Error` as its only argument if the server
 was not open when it was closed.
 
+### `server[Symbol.asyncDispose]()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Calls [`server.close()`][] and returns a promise that fulfills when the
+server has closed.
+
 ### `server.getConnections(callback)`
 
 <!-- YAML

lib/net.js

@@ -28,13 +28,15 @@ const {
   ArrayPrototypePush,
   Boolean,
   FunctionPrototypeBind,
+  FunctionPrototypeCall,
   MathMax,
   Number,
   NumberIsNaN,
   NumberParseInt,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
   Symbol,
+  SymbolAsyncDispose,
 } = primordials;
 
 const EventEmitter = require('events');
@@ -111,7 +113,7 @@ const {
 } = require('internal/errors');
 const { isUint8Array } = require('internal/util/types');
 const { queueMicrotask } = require('internal/process/task_queues');
-const { kEmptyObject, guessHandleType } = require('internal/util');
+const { kEmptyObject, guessHandleType, promisify } = require('internal/util');
 const {
   validateAbortSignal,
   validateBoolean,
@@ -2241,6 +2243,13 @@ Server.prototype.close = function(cb) {
   return this;
 };
 
+Server.prototype[SymbolAsyncDispose] = async function() {
+  if (!this._handle) {
+    return;
+  }
+  return FunctionPrototypeCall(promisify(this.close), this);
+};
+
 Server.prototype._emitCloseIfDrained = function() {
   debug('SERVER _emitCloseIfDrained');
 

test/parallel/test-net-server-async-dispose.mjs

@@ -0,0 +1,30 @@
+import * as common from '../common/index.mjs';
+import assert from 'node:assert';
+import net from 'node:net';
+import { describe, it } from 'node:test';
+
+describe('net.Server[Symbol.asyncDispose]()', () => {
+  it('should close the server', async () => {
+    const server = net.createServer();
+    const timeoutRef = setTimeout(common.mustNotCall(), 2 ** 31 - 1);
+
+    server.listen(0, common.mustCall(async () => {
+      await server[Symbol.asyncDispose]().then(common.mustCall());
+      assert.strictEqual(server.address(), null);
+      clearTimeout(timeoutRef);
+    }));
+
+    server.on('close', common.mustCall());
+  });
+
+  it('should resolve even if the server is already closed', async () => {
+    const server = net.createServer();
+    const timeoutRef = setTimeout(common.mustNotCall(), 2 ** 31 - 1);
+
+    server.listen(0, common.mustCall(async () => {
+      await server[Symbol.asyncDispose]().then(common.mustCall());
+      await server[Symbol.asyncDispose]().then(common.mustCall(), common.mustNotCall());
+      clearTimeout(timeoutRef);
+    }));
+  });
+});