Method disconnectRequest2

src/gdb.ts:1461–1522

(
        response: DebugProtocol.DisconnectResponse | DebugProtocol.Response,
        args: DebugProtocol.DisconnectArguments)

    }

    protected disconnectRequest2(
        response: DebugProtocol.DisconnectResponse | DebugProtocol.Response,
        args: DebugProtocol.DisconnectArguments): Promise<void> {
        this.disconnectingPromise =  new Promise<void>(async (resolve) => {
            this.serverConsoleLog('Begin disconnectRequest');
            const doDisconnectProcessing = async () => {
                if (this.miLiveGdb) {
                    this.miLiveGdb.quit();
                    await new Promise((resolve) => setTimeout(resolve, 100));
                }
                await this.tryDeleteBreakpoints();
                this.disableSendStoppedEvents = false;
                this.attached = false;
                this.waitForServerExitAndRespond(response);     // Will wait asynchronously until the following actions are done
                if (args.terminateDebuggee || args.suspendDebuggee) {
                    // There is no such thing as terminate for us. Hopefully, the gdb-server will
                    // do the right thing and remain in halted state
                    this.miDebugger.stop();
                } else {
                    // If the gdb-server behaves like gdb (and us) expects it do, then the program
                    // should continue
                    this.miDebugger.detach();
                }
                resolve();
            };

            if (this.miDebugger) {
                this.disableSendStoppedEvents = true;
                if (!this.stopped) {
                    // Many ways things can fail. See issue #561
                    // exec-interrupt can fail because gdb is wedged and does not respond with proper status ever
                    // use a timeout and try to end session anyways.
                    let to = setTimeout(() => {
                        if (to) {
                            to = null;
                            this.handleMsg('log', 'GDB never responded to an interrupt request. Trying to end session anyways\n');
                            doDisconnectProcessing();
                        }
                    }, 2000);
                    this.miDebugger.once('generic-stopped', () => {
                        if (to) {
                            clearTimeout(to);
                            to = null;
                            doDisconnectProcessing();
                        }
                    });
                    try {
                        await this.miDebugger.sendCommand('exec-interrupt');
                    }
                    catch (e) {
                        // The timeout will take care of it...
                        this.handleMsg('log', `Could not interrupt program. Trying to end session anyways ${e}\n`);
                    }
                } else {
                    doDisconnectProcessing();
                }
            } else {
                resolve();