Add command to find and pause a PHP process.

Author: zobo

package.json

@@ -641,6 +641,11 @@
         "enablement": "!inDebugMode",
         "icon": "$(play)"
       },
+      {
+        "command": "extension.php-debug.pauseXdebugControlSocket",
+        "title": "Pause PHP process (Xdebug Control Socket)",
+        "category": "PHP Debug"
+      },
       {
         "command": "extension.php-debug.copyVarExport",
         "title": "Copy Value as var_export"

src/controlSocket.ts

@@ -1,6 +1,9 @@
 import * as xdebug from './xdebugConnection'
-import * as semver from 'semver'
 import * as net from 'net'
+import * as CP from 'child_process'
+import { promisify } from 'util'
+import { supportedEngine } from './xdebugUtils'
+import { DOMParser } from '@xmldom/xmldom'
 
 export class ControlSocket {
     /**
@@ -16,36 +19,36 @@ export class ControlSocket {
      * @returns Returns true if the current platform and xdebug version are supporting Xdebug control socket.
      */
     supportedInitPacket(initPacket: xdebug.InitPacket): boolean {
-        return (
-            this.supportedPlatform() &&
-            initPacket.engineName === 'Xdebug' &&
-            semver.valid(initPacket.engineVersion, { loose: true }) !== null &&
-            (semver.gte(initPacket.engineVersion, '3.5.0', { loose: true }) ||
-                initPacket.engineVersion.startsWith('3.5.0'))
-        )
+        return this.supportedPlatform() && supportedEngine(initPacket, '3.5.0')
     }
 
     /**
-     *
+     * Request the pause control socket command
      * @param ctrlSocket Control socket full path
      * @returns
      */
     async requestPause(ctrlSocket: string): Promise<void> {
-        let retval
+        await this.executeCtrlCmd(ctrlSocket, 'pause')
+    }
+
+    async requestPS(ctrlSocket: string): Promise<ControlPS> {
+        const xml = await this.executeCtrlCmd(ctrlSocket, 'ps')
+        const parser = new DOMParser()
+        const document = <unknown>parser.parseFromString(xml, 'application/xml')
+        return new ControlPS(<XMLDocument>document)
+    }
+
+    private async executeCtrlCmd(ctrlSocket: string, cmd: string): Promise<string> {
+        let rawCtrlSocket: string
         if (process.platform === 'linux') {
-            retval = await this.executeCtrlCmd(`\0${ctrlSocket}`, 'pause')
+            rawCtrlSocket = `\0${ctrlSocket}`
         } else if (process.platform === 'win32') {
-            retval = await this.executeCtrlCmd(`\\\\.\\pipe\\${ctrlSocket}`, 'pause')
+            rawCtrlSocket = `\\\\.\\pipe\\${ctrlSocket}`
         } else {
             throw new Error('Invalid platform for Xdebug control socket')
         }
-        retval
-        return
-    }
-
-    private async executeCtrlCmd(ctrlSocket: string, cmd: string): Promise<string> {
         return new Promise<string>((resolve, reject) => {
-            const s = net.createConnection(ctrlSocket, () => {
+            const s = net.createConnection(rawCtrlSocket, () => {
                 s.end(`${cmd}\0`)
             })
             s.setTimeout(3000)
@@ -69,4 +72,82 @@ export class ControlSocket {
             return
         })
     }
+
+    async listControlSockets(): Promise<XdebugRunningProcess[]> {
+        let retval:XdebugRunningProcess[]
+        if (process.platform === 'linux') {
+            // TODO
+            throw new Error('Invalid platform for Xdebug control socket')
+        } else if (process.platform === 'win32') {
+            retval = await this.listControlSocketsWin()
+        } else {
+            throw new Error('Invalid platform for Xdebug control socket')
+        }
+
+        const retval2 = Promise.all(
+            retval.map(async v => {
+                try {
+                    v.ps = await this.requestPS(v.ctrlSocket)
+                } catch {
+                    // ignore
+                }
+                return v
+            })
+        )
+        return retval2
+    }
+
+    private async listControlSocketsWin(): Promise<XdebugRunningProcess[]> {
+        const exec = promisify(CP.exec)
+        try {
+            const ret = await exec('cmd /C "dir \\\\.\\pipe\\\\xdebug-ctrl* /b"')
+            const lines = ret.stdout.split('\r\n')
+
+            const retval = lines
+                .filter(v => v.length != 0)
+                .map<XdebugRunningProcess>(v => <XdebugRunningProcess>{ ctrlSocket: v })
+
+            return retval
+
+        } catch (err) {
+            if (err instanceof Error && (<ExecError>err).stderr == 'File Not Found\r\n') {
+                return []
+            }
+            throw err
+        }
+    }
+}
+
+interface ExecError extends Error {
+    stderr: string
+}
+
+export interface XdebugRunningProcess {
+    readonly ctrlSocket: string
+    ps: ControlPS
+    // todo
+}
+
+export class ControlPS {
+    /** The file that was requested as a file:// URI */
+    fileUri: string
+    /** the version of Xdebug */
+    engineVersion: string
+    /** the name of the engine */
+    engineName: string
+    /** the internal PID */
+    pid: string
+    /** memory consumption */
+    memory: number
+    /**
+     * @param  {XMLDocument} document - An XML document to read from
+     */
+    constructor(document: XMLDocument) {
+        const documentElement = <Element>document.documentElement.firstChild
+        this.fileUri = documentElement.getElementsByTagName('fileuri').item(0)?.textContent ?? ''
+        this.engineVersion = documentElement.getElementsByTagName('engine').item(0)?.getAttribute('version') ?? ''
+        this.engineName = documentElement.getElementsByTagName('engine').item(0)?.textContent ?? ''
+        this.pid = documentElement.getElementsByTagName('pid').item(0)?.textContent ?? ''
+        this.memory = parseInt(documentElement.getElementsByTagName('memory').item(0)?.textContent ?? '0')
+    }
 }

src/extension.ts

@@ -4,6 +4,7 @@ import { EvaluateExtendedArguments, LaunchRequestArguments } from './phpDebug'
 import * as which from 'which'
 import * as path from 'path'
 import { DebugProtocol } from '@vscode/debugprotocol'
+import { ControlSocket } from './controlSocket'
 
 export function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(
@@ -197,4 +198,31 @@ export function activate(context: vscode.ExtensionContext) {
             }
         )
     )
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('extension.php-debug.pauseXdebugControlSocket', async () => {
+            // check compat
+            const controlSocket = new ControlSocket()
+            const sockets = await controlSocket.listControlSockets()
+
+            // loading indicator
+            if (sockets.length == 0) {
+                await vscode.window.showInformationMessage('No Xdebug control sockets found...')
+                return
+            }
+
+            const qpi = sockets.map<vscode.QuickPickItem>(
+                v =>
+                    <vscode.QuickPickItem>{
+                        label: v.ctrlSocket,
+                        description: v.ps ? `Mem: ${v.ps.memory}` : '',
+                        detail: v.ps ? v.ps.fileUri : '',
+                    }
+            )
+            const i = await vscode.window.showQuickPick(qpi, { canPickMany: false })
+            if (i) {
+                await controlSocket.requestPause(i.label)
+            }
+        })
+    )
 }