From ebe298921c77f4ae894e164b1e2233947078f18c Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Mon, 10 Jul 2023 00:21:58 +0300
Subject: [PATCH 1/2] dgram: socket add `asyncDispose`

---
 doc/api/dgram.md                           | 12 ++++++++++++
 lib/dgram.js                               | 10 +++++++++-
 test/parallel/test-dgram-async-dispose.mjs | 20 ++++++++++++++++++++
 3 files changed, 41 insertions(+), 1 deletion(-)
 create mode 100644 test/parallel/test-dgram-async-dispose.mjs

diff --git a/doc/api/dgram.md b/doc/api/dgram.md
index 88459727d299dc..aa5030d94bce01 100644
--- a/doc/api/dgram.md
+++ b/doc/api/dgram.md
@@ -372,6 +372,17 @@ added: v0.1.99
 Close the underlying socket and stop listening for data on it. If a callback is
 provided, it is added as a listener for the [`'close'`][] event.
 
+### `socket[Symbol.asyncDispose]()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Calls [`socket.close()`][] and returns a promise that fulfills when the
+socket has closed.
+
 ### `socket.connect(port[, address][, callback])`
 
 <!-- YAML
@@ -992,4 +1003,5 @@ and `udp6` sockets). The bound address and port can be retrieved using
 [`socket.address().address`]: #socketaddress
 [`socket.address().port`]: #socketaddress
 [`socket.bind()`]: #socketbindport-address-callback
+[`socket.close()`]: #socketclosecallback
 [byte length]: buffer.md#static-method-bufferbytelengthstring-encoding
diff --git a/lib/dgram.js b/lib/dgram.js
index 57975de9183f00..01b5886d72fa29 100644
--- a/lib/dgram.js
+++ b/lib/dgram.js
@@ -30,6 +30,7 @@ const {
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
   ReflectApply,
+  SymbolAsyncDispose,
   SymbolDispose,
 } = primordials;
 
@@ -59,7 +60,7 @@ const {
   validatePort,
 } = require('internal/validators');
 const { Buffer } = require('buffer');
-const { deprecate, guessHandleType } = require('internal/util');
+const { deprecate, guessHandleType, promisify } = require('internal/util');
 const { isArrayBufferView } = require('internal/util/types');
 const EventEmitter = require('events');
 const {
@@ -752,6 +753,13 @@ Socket.prototype.close = function(callback) {
   return this;
 };
 
+Socket.prototype[SymbolAsyncDispose] = async function() {
+  if (!this[kStateSymbol].handle) {
+    return;
+  }
+  return FunctionPrototypeCall(promisify(this.close), this);
+};
+
 
 function socketCloseNT(self) {
   self.emit('close');
diff --git a/test/parallel/test-dgram-async-dispose.mjs b/test/parallel/test-dgram-async-dispose.mjs
new file mode 100644
index 00000000000000..919bc832570025
--- /dev/null
+++ b/test/parallel/test-dgram-async-dispose.mjs
@@ -0,0 +1,20 @@
+import * as common from '../common/index.mjs';
+import assert from 'node:assert';
+import dgram from 'node:dgram';
+import { describe, it } from 'node:test';
+
+describe('dgram.Socket[Symbol.asyncDispose]()', () => {
+  it('should close the socket', async () => {
+    const server = dgram.createSocket({ type: 'udp4' });
+    server.on('close', common.mustCall());
+    await server[Symbol.asyncDispose]().then(common.mustCall());
+
+    assert.throws(() => server.address(), { code: 'ERR_SOCKET_DGRAM_NOT_RUNNING' });
+  });
+
+  it('should resolve even if the socket is already closed', async () => {
+    const server = dgram.createSocket({ type: 'udp4' });
+    await server[Symbol.asyncDispose]().then(common.mustCall());
+    await server[Symbol.asyncDispose]().then(common.mustCall(), common.mustNotCall());
+  });
+});

From 4792bdf0582db29fef8a302525a997816e7a88ce Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Mon, 10 Jul 2023 00:22:05 +0300
Subject: [PATCH 2/2] net: server add `asyncDispose`

---
 doc/api/net.md                                | 11 +++++++
 lib/net.js                                    | 11 ++++++-
 .../test-net-server-async-dispose.mjs         | 30 +++++++++++++++++++
 3 files changed, 51 insertions(+), 1 deletion(-)
 create mode 100644 test/parallel/test-net-server-async-dispose.mjs

diff --git a/doc/api/net.md b/doc/api/net.md
index 286e68d26aeda8..c8059d704052bc 100644
--- a/doc/api/net.md
+++ b/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
diff --git a/lib/net.js b/lib/net.js
index 194da673db5a22..7f9b1e5c084d8c 100644
--- a/lib/net.js
+++ b/lib/net.js
@@ -28,6 +28,7 @@ const {
   ArrayPrototypePush,
   Boolean,
   FunctionPrototypeBind,
+  FunctionPrototypeCall,
   MathMax,
   Number,
   NumberIsNaN,
@@ -35,6 +36,7 @@ const {
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
   Symbol,
+  SymbolAsyncDispose,
   SymbolDispose,
 } = primordials;
 
@@ -112,7 +114,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,
@@ -2243,6 +2245,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');
 
diff --git a/test/parallel/test-net-server-async-dispose.mjs b/test/parallel/test-net-server-async-dispose.mjs
new file mode 100644
index 00000000000000..08765e9c719ca9
--- /dev/null
+++ b/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);
+    }));
+  });
+});