feat: launch.json option to limit the maximum parallel DBGp connections. (#673)

* launch.json option to limit the maximum parallel DBGp connections.

* Test with two connections.

* Changelog.

Author: zobo

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.21.0]
+
+- Support for maxConnections limiting how many parallel connections the debug adapter allows.
+
 ## [1.20.0]
 
 - Support no-folder debugging in (purple) VS Code.

README.md

@@ -76,6 +76,7 @@ More general information on debugging with VS Code can be found on https://code.
 - `pathMappings`: A list of server paths mapping to the local source paths on your machine, see "Remote Host Debugging" below
 - `log`: Whether to log all communication between VS Code and the adapter to the debug console. See _Troubleshooting_ further down.
 - `ignore`: An optional array of glob patterns that errors should be ignored from (for example `**/vendor/**/*.php`)
+- `maxConnections`: Accept only this number of parallel debugging sessions. Additional connections will be dropped and their execution will continue without debugging.
 - `xdebugSettings`: Allows you to override Xdebug's remote debugging settings to fine tuning Xdebug to your needs. For example, you can play with `max_children` and `max_depth` to change the max number of array and object children that are retrieved and the max depth in structures like arrays and objects. This can speed up the debugger on slow machines.
   For a full list of feature names that can be set please refer to the [Xdebug documentation](https://xdebug.org/docs-dbgp.php#feature-names).
   - `max_children`: max number of array or object children to initially retrieve

package.json

@@ -275,6 +275,11 @@
                 },
                 "description": "Overrides for Xdebug remote debugging settings. See https://xdebug.org/docs-dbgp.php#feature-names",
                 "default": {}
+              },
+              "maxConnections": {
+                "type": "number",
+                "description": "The maximum allowed parallel debugging sessions",
+                "default": 0
               }
             }
           }

src/dbgp.ts

@@ -121,6 +121,10 @@ export class DbgpConnection extends EventEmitter {
     /** closes the underlying socket */
     public close(): Promise<void> {
         return new Promise<void>((resolve, reject) => {
+            if (this._socket.destroyed) {
+                resolve()
+                return
+            }
             this._socket.once('close', resolve)
             this._socket.end()
         })

src/phpDebug.ts

@@ -88,6 +88,8 @@ export interface LaunchRequestArguments extends VSCodeDebugProtocol.LaunchReques
     env?: { [key: string]: string }
     /** If true launch the target in an external console. */
     externalConsole?: boolean
+    /** Maximum allowed parallel debugging sessions */
+    maxConnections?: number
 }
 
 class PhpDebugSession extends vscode.DebugSession {
@@ -288,21 +290,40 @@ class PhpDebugSession extends vscode.DebugSession {
                 server.on('connection', async (socket: net.Socket) => {
                     try {
                         // new Xdebug connection
+                        // first check if we have a limit on connections
+                        if (args.maxConnections ?? 0 > 0) {
+                            if (this._connections.size >= args.maxConnections!) {
+                                if (args.log) {
+                                    this.sendEvent(
+                                        new vscode.OutputEvent(
+                                            `new connection from ${socket.remoteAddress} - dropping due to max connection limit\n`
+                                        ),
+                                        true
+                                    )
+                                }
+                                socket.end()
+                                return
+                            }
+                        }
+
                         const connection = new xdebug.Connection(socket)
                         if (args.log) {
-                            this.sendEvent(new vscode.OutputEvent('new connection ' + connection.id + '\n'), true)
+                            this.sendEvent(
+                                new vscode.OutputEvent(
+                                    `new connection ${connection.id} from ${socket.remoteAddress}\n`
+                                ),
+                                true
+                            )
                         }
                         this._connections.set(connection.id, connection)
                         const disposeConnection = (error?: Error) => {
                             if (this._connections.has(connection.id)) {
                                 if (args.log) {
-                                    this.sendEvent(new vscode.OutputEvent('connection ' + connection.id + ' closed\n'))
+                                    this.sendEvent(new vscode.OutputEvent(`connection ${connection.id} closed\n`))
                                 }
                                 if (error) {
                                     this.sendEvent(
-                                        new vscode.OutputEvent(
-                                            'connection ' + connection.id + ': ' + error.message + '\n'
-                                        )
+                                        new vscode.OutputEvent(`connection ${connection.id}: ${error.message}\n`)
                                     )
                                 }
                                 this.sendEvent(new vscode.ContinuedEvent(connection.id, false))

src/test/adapter.ts

@@ -4,6 +4,7 @@ import * as path from 'path'
 import { DebugClient } from 'vscode-debugadapter-testsupport'
 import { DebugProtocol } from 'vscode-debugprotocol'
 import * as semver from 'semver'
+import * as net from 'net'
 chai.use(chaiAsPromised)
 const assert = chai.assert
 
@@ -686,4 +687,21 @@ describe('PHP Debug Adapter', () => {
             await client.assertOutput('stderr', 'stderr output 1\nstderr output 2')
         })
     })
+
+    describe('special adapter tests', () => {
+        it('max connections', async () => {
+            await Promise.all([client.launch({ maxConnections: 1, log: true }), client.configurationSequence()])
+
+            let s1 = net.createConnection({ port: 9003 })
+            await client.assertOutput('console', 'new connection 1 from ')
+            net.createConnection({ port: 9003 })
+            let o = await client.waitForEvent('output')
+            assert.match(
+                o.body!.output,
+                /^new connection from .* - dropping due to max connection limit/,
+                'Second connection does not generate proper error output'
+            )
+            s1.destroy()
+        })
+    })
 })

src/xdebugConnection.ts

@@ -784,6 +784,7 @@ export class Connection extends DbgpConnection {
                 }
             }
         })
+        this.on('close', () => this._initPromiseRejectFn(new Error('connection closed')))
     }
 
     /** Returns a promise that gets resolved once the init packet arrives */