@theia/debug 1.18.0 → 1.21.0-next.12

package/src/browser/debug-session-connection.ts

@@ -19,13 +19,9 @@
 import { DebugProtocol } from 'vscode-debugprotocol';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { Event, Emitter, DisposableCollection, Disposable, MaybePromise } from '@theia/core';
-import { OutputChannel } from '@theia/output/lib/common/output-channel';
-import { IWebSocket } from '@theia/core/shared/vscode-ws-jsonrpc';
+import { OutputChannel } from '@theia/output/lib/browser/output-channel';
 
-export interface DebugExitEvent {
-    code?: number
-    reason?: string | Error
-}
+import { Channel } from '../common/debug-service';
 
 export type DebugRequestHandler = (request: DebugProtocol.Request) => MaybePromise<any>;
 
@@ -78,7 +74,7 @@ export interface DebugEventTypes {
     'breakpoint': DebugProtocol.BreakpointEvent
     'capabilities': DebugProtocol.CapabilitiesEvent
     'continued': DebugProtocol.ContinuedEvent
-    'exited': DebugExitEvent
+    'exited': DebugProtocol.ExitedEvent,
     'initialized': DebugProtocol.InitializedEvent
     'invalidated': DebugProtocol.InvalidatedEvent
     'loadedSource': DebugProtocol.LoadedSourceEvent
@@ -92,6 +88,15 @@ export interface DebugEventTypes {
     'terminated': DebugProtocol.TerminatedEvent
     'thread': DebugProtocol.ThreadEvent
 }
+
+export type DebugEventNames = keyof DebugEventTypes;
+
+export namespace DebugEventTypes {
+    export function isStandardEvent(evt: string): evt is DebugEventNames {
+        return standardDebugEvents.has(evt);
+    };
+}
+
 const standardDebugEvents = new Set<string>([
     'breakpoint',
     'capabilities',
@@ -115,14 +120,19 @@ export class DebugSessionConnection implements Disposable {
 
     private sequence = 1;
 
-    protected readonly pendingRequests = new Map<number, (response: DebugProtocol.Response) => void>();
-    protected readonly connection: Promise<IWebSocket>;
+    protected readonly pendingRequests = new Map<number, Deferred<DebugProtocol.Response>>();
+    protected readonly connectionPromise: Promise<Channel>;
 
     protected readonly requestHandlers = new Map<string, DebugRequestHandler>();
 
     protected readonly onDidCustomEventEmitter = new Emitter<DebugProtocol.Event>();
     readonly onDidCustomEvent: Event<DebugProtocol.Event> = this.onDidCustomEventEmitter.event;
 
+    protected readonly onDidCloseEmitter = new Emitter<void>();
+    readonly onDidClose: Event<void> = this.onDidCloseEmitter.event;
+
+    protected isClosed = false;
+
     protected readonly toDispose = new DisposableCollection(
         this.onDidCustomEventEmitter,
         Disposable.create(() => this.pendingRequests.clear()),
@@ -131,15 +141,16 @@ export class DebugSessionConnection implements Disposable {
 
     constructor(
         readonly sessionId: string,
-        protected readonly connectionFactory: (sessionId: string) => Promise<IWebSocket>,
+        connectionFactory: (sessionId: string) => Promise<Channel>,
         protected readonly traceOutputChannel: OutputChannel | undefined
     ) {
-        this.connection = this.createConnection();
+        this.connectionPromise = this.createConnection(connectionFactory);
     }
 
     get disposed(): boolean {
         return this.toDispose.disposed;
     }
+
     protected checkDisposed(): void {
         if (this.disposed) {
             throw new Error('the debug session connection is disposed, id: ' + this.sessionId);
@@ -150,23 +161,20 @@ export class DebugSessionConnection implements Disposable {
         this.toDispose.dispose();
     }
 
-    protected async createConnection(): Promise<IWebSocket> {
-        if (this.disposed) {
-            throw new Error('Connection has been already disposed.');
-        } else {
-            const connection = await this.connectionFactory(this.sessionId);
-            connection.onClose((code, reason) => {
-                connection.dispose();
-                this.fire('exited', { code, reason });
-            });
-            connection.onMessage(data => this.handleMessage(data));
-            return connection;
-        }
+    protected async createConnection(connectionFactory: (sessionId: string) => Promise<Channel>): Promise<Channel> {
+        const connection = await connectionFactory(this.sessionId);
+        connection.onClose(() => {
+            this.isClosed = true;
+            this.cancelPendingRequests();
+            this.onDidCloseEmitter.fire();
+        });
+        connection.onMessage(data => this.handleMessage(data));
+        return connection;
     }
 
     protected allThreadsContinued = true;
-    async sendRequest<K extends keyof DebugRequestTypes>(command: K, args: DebugRequestTypes[K][0]): Promise<DebugRequestTypes[K][1]> {
-        const result = await this.doSendRequest(command, args);
+    async sendRequest<K extends keyof DebugRequestTypes>(command: K, args: DebugRequestTypes[K][0], timeout?: number): Promise<DebugRequestTypes[K][1]> {
+        const result = await this.doSendRequest(command, args, timeout);
         if (command === 'next' || command === 'stepIn' ||
             command === 'stepOut' || command === 'stepBack' ||
             command === 'reverseContinue' || command === 'restartFrame') {
@@ -186,56 +194,69 @@ export class DebugSessionConnection implements Disposable {
     sendCustomRequest<T extends DebugProtocol.Response>(command: string, args?: any): Promise<T> {
         return this.doSendRequest<T>(command, args);
     }
-    protected async doSendRequest<K extends DebugProtocol.Response>(command: string, args?: any): Promise<K> {
+
+    protected cancelPendingRequests(): void {
+        this.pendingRequests.forEach((deferred, requestId) => {
+            deferred.reject(new Error(`Request ${requestId} cancelled on connection close`));
+        });
+    }
+
+    protected doSendRequest<K extends DebugProtocol.Response>(command: string, args?: any, timeout?: number): Promise<K> {
         const result = new Deferred<K>();
 
-        const request: DebugProtocol.Request = {
-            seq: this.sequence++,
-            type: 'request',
-            command: command,
-            arguments: args
-        };
+        if (this.isClosed) {
+            result.reject(new Error('Connection is closed'));
+        } else {
+            const request: DebugProtocol.Request = {
+                seq: this.sequence++,
+                type: 'request',
+                command: command,
+                arguments: args
+            };
 
-        const onDispose = this.toDispose.push(Disposable.create(() => {
-            const pendingRequest = this.pendingRequests.get(request.seq);
-            if (pendingRequest) {
-                pendingRequest({
-                    type: 'response',
-                    request_seq: request.seq,
-                    command: request.command,
-                    seq: 0,
-                    success: false,
-                    message: 'debug session is closed'
-                });
+            this.pendingRequests.set(request.seq, result);
+            if (timeout) {
+                const handle = setTimeout(() => {
+                    const pendingRequest = this.pendingRequests.get(request.seq);
+                    if (pendingRequest) {
+                        // request has not been handled
+                        this.pendingRequests.delete(request.seq);
+                        const error: DebugProtocol.Response = {
+                            type: 'response',
+                            seq: 0,
+                            request_seq: request.seq,
+                            success: false,
+                            command,
+                            message: `Request #${request.seq}: ${request.command} timed out`
+                        };
+                        pendingRequest.reject(error);
+                    }
+                }, timeout);
+                result.promise.finally(() => clearTimeout(handle));
             }
-        }));
-        this.pendingRequests.set(request.seq, (response: K) => {
-            onDispose.dispose();
-            if (!response.success) {
-                result.reject(response);
-            } else {
-                result.resolve(response);
-            }
-        });
-
-        await this.send(request);
+            this.send(request);
+        }
         return result.promise;
     }
 
     protected async send(message: DebugProtocol.ProtocolMessage): Promise<void> {
-        const connection = await this.connection;
+        const connection = await this.connectionPromise;
         const messageStr = JSON.stringify(message);
         if (this.traceOutputChannel) {
-            this.traceOutputChannel.appendLine(`${this.sessionId.substring(0, 8)} theia -> adapter: ${messageStr}`);
+            const now = new Date();
+            const dateStr = `${now.toLocaleString(undefined, { hour12: false })}.${now.getMilliseconds()}`;
+            this.traceOutputChannel.appendLine(`${this.sessionId.substring(0, 8)} ${dateStr} theia -> adapter: ${JSON.stringify(message, undefined, 4)}`);
         }
         connection.send(messageStr);
     }
 
     protected handleMessage(data: string): void {
+        const message: DebugProtocol.ProtocolMessage = JSON.parse(data);
         if (this.traceOutputChannel) {
-            this.traceOutputChannel.appendLine(`${this.sessionId.substring(0, 8)} theia <- adapter: ${data}`);
+            const now = new Date();
+            const dateStr = `${now.toLocaleString(undefined, { hour12: false })}.${now.getMilliseconds()}`;
+            this.traceOutputChannel.appendLine(`${this.sessionId.substring(0, 8)} ${dateStr} theia <- adapter: ${JSON.stringify(message, undefined, 4)}`);
         }
-        const message: DebugProtocol.ProtocolMessage = JSON.parse(data);
         if (message.type === 'request') {
             this.handleRequest(message as DebugProtocol.Request);
         } else if (message.type === 'response') {
@@ -246,10 +267,14 @@ export class DebugSessionConnection implements Disposable {
     }
 
     protected handleResponse(response: DebugProtocol.Response): void {
-        const callback = this.pendingRequests.get(response.request_seq);
-        if (callback) {
+        const pendingRequest = this.pendingRequests.get(response.request_seq);
+        if (pendingRequest) {
             this.pendingRequests.delete(response.request_seq);
-            callback(response);
+            if (!response.success) {
+                pendingRequest.reject(response);
+            } else {
+                pendingRequest.resolve(response);
+            }
         }
     }
 
@@ -280,36 +305,37 @@ export class DebugSessionConnection implements Disposable {
     }
 
     protected handleEvent(event: DebugProtocol.Event): void {
-        if ('event' in event) {
-            if (event.event === 'continued') {
-                this.allThreadsContinued = (<DebugProtocol.ContinuedEvent>event).body.allThreadsContinued === false ? false : true;
-            }
-            if (standardDebugEvents.has(event.event)) {
-                this.doFire(event.event, event);
-            } else {
-                this.onDidCustomEventEmitter.fire(event);
-            }
+        if (event.event === 'continued') {
+            this.allThreadsContinued = (<DebugProtocol.ContinuedEvent>event).body.allThreadsContinued === false ? false : true;
+        }
+        if (DebugEventTypes.isStandardEvent(event.event)) {
+            this.doFire(event.event, event);
         } else {
-            this.fire('exited', event);
+            this.onDidCustomEventEmitter.fire(event);
         }
     }
 
-    protected readonly emitters = new Map<string, Emitter<DebugProtocol.Event | DebugExitEvent>>();
+    protected readonly emitters = new Map<string, Emitter<DebugProtocol.Event>>();
     on<K extends keyof DebugEventTypes>(kind: K, listener: (e: DebugEventTypes[K]) => any): Disposable {
         return this.getEmitter(kind).event(listener);
     }
+
+    onEvent<K extends keyof DebugEventTypes>(kind: K): Event<DebugEventTypes[K]> {
+        return this.getEmitter(kind).event;
+    }
+
     protected fire<K extends keyof DebugEventTypes>(kind: K, e: DebugEventTypes[K]): void {
         this.doFire(kind, e);
     }
-    protected doFire(kind: string, e: DebugProtocol.Event | DebugExitEvent): void {
+    protected doFire<K extends keyof DebugEventTypes>(kind: K, e: DebugEventTypes[K]): void {
         this.getEmitter(kind).fire(e);
     }
-    protected getEmitter(kind: string): Emitter<DebugProtocol.Event | DebugExitEvent> {
+    protected getEmitter<K extends keyof DebugEventTypes>(kind: K): Emitter<DebugEventTypes[K]> {
         const emitter = this.emitters.get(kind) || this.newEmitter();
         this.emitters.set(kind, emitter);
-        return emitter;
+        return <Emitter<DebugEventTypes[K]>>emitter;
     }
-    protected newEmitter(): Emitter<DebugProtocol.Event | DebugExitEvent> {
+    protected newEmitter(): Emitter<DebugProtocol.Event> {
         const emitter = new Emitter();
         this.checkDisposed();
         this.toDispose.push(emitter);

package/src/browser/debug-session-contribution.ts

@@ -23,11 +23,10 @@ import { WebSocketConnectionProvider } from '@theia/core/lib/browser/messaging/w
 import { DebugSession } from './debug-session';
 import { BreakpointManager } from './breakpoint/breakpoint-manager';
 import { DebugSessionOptions } from './debug-session-options';
-import { OutputChannelManager, OutputChannel } from '@theia/output/lib/common/output-channel';
+import { OutputChannelManager, OutputChannel } from '@theia/output/lib/browser/output-channel';
 import { DebugPreferences } from './debug-preferences';
 import { DebugSessionConnection } from './debug-session-connection';
-import { IWebSocket } from '@theia/core/shared/vscode-ws-jsonrpc';
-import { DebugAdapterPath } from '../common/debug-service';
+import { Channel, DebugAdapterPath } from '../common/debug-service';
 import { ContributionProvider } from '@theia/core/lib/common/contribution-provider';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { DebugContribution } from './debug-contribution';
@@ -119,7 +118,7 @@ export class DefaultDebugSessionFactory implements DebugSessionFactory {
     get(sessionId: string, options: DebugSessionOptions, parentSession?: DebugSession): DebugSession {
         const connection = new DebugSessionConnection(
             sessionId,
-            () => new Promise<IWebSocket>(resolve =>
+            () => new Promise<Channel>(resolve =>
                 this.connectionProvider.openChannel(`${DebugAdapterPath}/${sessionId}`, channel => {
                     resolve(channel);
                 }, { reconnecting: false })

package/src/browser/debug-session-manager.ts

@@ -278,51 +278,73 @@ export class DebugSessionManager {
             const restart = event.body && event.body.restart;
             if (restart) {
                 // postDebugTask isn't run in case of auto restart as well as preLaunchTask
-                this.doRestart(session, restart);
+                this.doRestart(session, !!restart);
             } else {
-                session.terminate();
+                await session.disconnect(false, () => this.debug.terminateDebugSession(session.id));
                 await this.runTask(session.options.workspaceFolderUri, session.configuration.postDebugTask);
             }
         });
-        session.on('exited', () => this.destroy(session.id));
-        session.start().then(() => this.onDidStartDebugSessionEmitter.fire(session));
+
+        session.on('exited', async event => {
+            await session.disconnect(false, () => this.debug.terminateDebugSession(session.id));
+        });
+
+        session.onDispose(() => this.cleanup(session));
+        session.start().then(() => this.onDidStartDebugSessionEmitter.fire(session)).catch(e => {
+            session.stop(false, () => {
+                this.debug.terminateDebugSession(session.id);
+            });
+        });
         session.onDidCustomEvent(({ event, body }) =>
             this.onDidReceiveDebugSessionCustomEventEmitter.fire({ event, body, session })
         );
         return session;
     }
 
-    restart(): Promise<DebugSession | undefined>;
-    restart(session: DebugSession): Promise<DebugSession>;
-    async restart(session: DebugSession | undefined = this.currentSession): Promise<DebugSession | undefined> {
-        return session && this.doRestart(session);
+    protected cleanup(session: DebugSession): void {
+        if (this.remove(session.id)) {
+            this.onDidDestroyDebugSessionEmitter.fire(session);
+        }
     }
-    protected async doRestart(session: DebugSession, restart?: any): Promise<DebugSession | undefined> {
-        if (await session.restart()) {
+
+    protected async doRestart(session: DebugSession, isRestart: boolean): Promise<DebugSession | undefined> {
+        if (session.canRestart()) {
+            await session.restart();
             return session;
         }
-        await session.terminate(true);
         const { options, configuration } = session;
-        configuration.__restart = restart;
+        session.stop(isRestart, () => this.debug.terminateDebugSession(session.id));
+        configuration.__restart = isRestart;
         return this.start(options);
     }
 
-    async terminateSessions(): Promise<void> {
-        this.updateCurrentSession(undefined);
-        this.currentSession?.terminate();
+    async terminateSession(session?: DebugSession): Promise<void> {
+        if (!session) {
+            this.updateCurrentSession(this._currentSession);
+            session = this._currentSession;
+        }
+        if (session) {
+            session.stop(false, () => this.debug.terminateDebugSession(session!.id));
+        }
     }
 
-    async restartSessions(): Promise<void> {
-        this.updateCurrentSession(undefined);
-        this.currentSession?.restart();
+    async restartSession(session?: DebugSession): Promise<DebugSession | undefined> {
+        if (!session) {
+            this.updateCurrentSession(this._currentSession);
+            session = this._currentSession;
+        }
+        if (session) {
+            return this.doRestart(session, true);
+        }
     }
 
-    protected remove(sessionId: string): void {
-        this._sessions.delete(sessionId);
+    protected remove(sessionId: string): boolean {
+        const existed = this._sessions.delete(sessionId);
         const { currentSession } = this;
         if (currentSession && currentSession.id === sessionId) {
             this.updateCurrentSession(undefined);
         }
+        return existed;
     }
 
     getSession(sessionId: string): DebugSession | undefined {
@@ -334,7 +356,7 @@ export class DebugSessionManager {
     }
 
     protected _currentSession: DebugSession | undefined;
-    protected readonly toDisposeOnCurrentSession = new DisposableCollection();
+    protected readonly disposeOnCurrentSessionChanged = new DisposableCollection();
     get currentSession(): DebugSession | undefined {
         return this._currentSession;
     }
@@ -342,12 +364,12 @@ export class DebugSessionManager {
         if (this._currentSession === current) {
             return;
         }
-        this.toDisposeOnCurrentSession.dispose();
+        this.disposeOnCurrentSessionChanged.dispose();
         const previous = this.currentSession;
         this._currentSession = current;
         this.onDidChangeActiveDebugSessionEmitter.fire({ previous, current });
         if (current) {
-            this.toDisposeOnCurrentSession.push(current.onDidChange(() => {
+            this.disposeOnCurrentSessionChanged.push(current.onDidChange(() => {
                 if (this.currentFrame === this.topFrame) {
                     this.open();
                 }
@@ -403,30 +425,6 @@ export class DebugSessionManager {
         return currentThread && currentThread.topFrame;
     }
 
-    /**
-     * Destroy the debug session. If session identifier isn't provided then
-     * all active debug session will be destroyed.
-     * @param sessionId The session identifier
-     */
-    destroy(sessionId?: string): void {
-        if (sessionId) {
-            const session = this._sessions.get(sessionId);
-            if (session) {
-                this.doDestroy(session);
-            }
-        } else {
-            this._sessions.forEach(session => this.doDestroy(session));
-        }
-    }
-
-    private doDestroy(session: DebugSession): void {
-        this.debug.terminateDebugSession(session.id);
-
-        session.dispose();
-        this.remove(session.id);
-        this.onDidDestroyDebugSessionEmitter.fire(session);
-    }
-
     getFunctionBreakpoints(session: DebugSession | undefined = this.currentSession): DebugFunctionBreakpoint[] {
         if (session && session.state > DebugState.Initializing) {
             return session.getFunctionBreakpoints();

package/src/browser/debug-session.tsx

@@ -40,6 +40,7 @@ import { TerminalWidgetOptions, TerminalWidget } from '@theia/terminal/lib/brows
 import { DebugFunctionBreakpoint } from './model/debug-function-breakpoint';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { DebugContribution } from './debug-contribution';
+import { waitForEvent } from '@theia/core/lib/common/promise-util';
 
 export enum DebugState {
     Inactive,
@@ -63,9 +64,10 @@ export class DebugSession implements CompositeTreeElement {
     }
 
     protected readonly childSessions = new Map<string, DebugSession>();
-
     protected readonly toDispose = new DisposableCollection();
 
+    private isStopping: boolean = false;
+
     constructor(
         readonly id: string,
         readonly options: DebugSessionOptions,
@@ -80,6 +82,9 @@ export class DebugSession implements CompositeTreeElement {
         protected readonly debugContributionProvider: ContributionProvider<DebugContribution>
     ) {
         this.connection.onRequest('runInTerminal', (request: DebugProtocol.RunInTerminalRequest) => this.runInTerminal(request));
+        this.connection.onDidClose(() => {
+            this.toDispose.dispose();
+        });
         this.registerDebugContributions(options.configuration.type, this.connection);
 
         if (parentSession) {
@@ -88,6 +93,7 @@ export class DebugSession implements CompositeTreeElement {
                 this.parentSession?.childSessions?.delete(id);
             }));
         }
+        this.connection.onDidClose(() => this.toDispose.dispose());
         this.toDispose.pushAll([
             this.onDidChangeEmitter,
             this.onDidChangeBreakpointsEmitter,
@@ -96,19 +102,18 @@ export class DebugSession implements CompositeTreeElement {
                 this.doUpdateThreads([]);
             }),
             this.connection,
-            this.on('initialized', () => this.configure()),
-            this.on('breakpoint', ({ body }) => this.updateBreakpoint(body)),
-            this.on('continued', e => this.handleContinued(e)),
-            this.on('stopped', e => this.handleStopped(e)),
-            this.on('thread', e => this.handleThread(e)),
-            this.on('terminated', () => this.terminated = true),
-            this.on('capabilities', event => this.updateCapabilities(event.body.capabilities)),
+            this.connection.on('initialized', () => this.configure()),
+            this.connection.on('breakpoint', ({ body }) => this.updateBreakpoint(body)),
+            this.connection.on('continued', e => this.handleContinued(e)),
+            this.connection.on('stopped', e => this.handleStopped(e)),
+            this.connection.on('thread', e => this.handleThread(e)),
+            this.connection.on('capabilities', event => this.updateCapabilities(event.body.capabilities)),
             this.breakpoints.onDidChangeMarkers(uri => this.updateBreakpoints({ uri, sourceModified: true }))
         ]);
     }
 
-    dispose(): void {
-        this.toDispose.dispose();
+    get onDispose(): Event<void> {
+        return this.toDispose.onDispose;
     }
 
     get configuration(): DebugConfiguration {
@@ -278,8 +283,7 @@ export class DebugSession implements CompositeTreeElement {
         try {
             await this.sendRequest((this.configuration.request as keyof DebugRequestTypes), this.configuration);
         } catch (reason) {
-            this.fireExited(reason);
-            await this.messages.showMessage({
+            this.messages.showMessage({
                 type: MessageType.Error,
                 text: reason.message || 'Debug session initialization failed. See console for details.',
                 options: {
@@ -308,59 +312,48 @@ export class DebugSession implements CompositeTreeElement {
         await this.updateThreads(undefined);
     }
 
-    protected terminated = false;
-    async terminate(restart?: boolean): Promise<void> {
-        if (!this.terminated && this.capabilities.supportsTerminateRequest && this.configuration.request === 'launch') {
-            this.terminated = true;
-            await this.connection.sendRequest('terminate', { restart });
-            if (!await this.exited(1000)) {
-                await this.disconnect(restart);
-            }
-        } else {
-            await this.disconnect(restart);
-        }
+    canTerminate(): boolean {
+        return !!this.capabilities.supportsTerminateRequest;
     }
 
-    protected async disconnect(restart?: boolean): Promise<void> {
-        const TIMEOUT_MS = 1000;
-        Promise.race([
-            this.sendRequest('disconnect', { restart }),
-            new Promise(reject => setTimeout(reject, TIMEOUT_MS, new Error('TIMEOUT_ERR')))
-        ]).then(res => {
-            if (res instanceof Error) {
-                this.fireExited(res);
-            }
-        }).catch(() => this.fireExited());
+    canRestart(): boolean {
+        return !!this.capabilities.supportsRestartRequest;
     }
 
-    protected fireExited(reason?: Error): void {
-        try {
-            this.connection['fire']('exited', { reason });
-        } catch (e) {
-            console.error(e);
+    async restart(): Promise<void> {
+        if (this.canRestart()) {
+            await this.sendRequest('restart', {});
         }
     }
 
-    protected exited(timeout: number): Promise<boolean> {
-        return new Promise<boolean>(resolve => {
-            const listener = this.on('exited', () => {
-                listener.dispose();
-                resolve(true);
-            });
-            setTimeout(() => {
-                listener.dispose();
-                resolve(false);
-            }, timeout);
-        });
+    async stop(isRestart: boolean, callback: () => void): Promise<void> {
+        if (!this.isStopping) {
+            this.isStopping = true;
+            if (this.canTerminate()) {
+                const terminated = this.waitFor('terminated', 5000);
+                try {
+                    await this.connection.sendRequest('terminate', { restart: isRestart }, 5000);
+                    await terminated;
+                } catch (e) {
+                    console.error('Did not receive terminated event in time', e);
+                }
+            } else {
+                try {
+                    await this.sendRequest('disconnect', { restart: isRestart }, 5000);
+                } catch (e) {
+                    console.error('Error on disconnect', e);
+                }
+            }
+            callback();
+        }
     }
 
-    async restart(): Promise<boolean> {
-        if (this.capabilities.supportsRestartRequest) {
-            this.terminated = false;
-            await this.sendRequest('restart', {});
-            return true;
+    async disconnect(isRestart: boolean, callback: () => void): Promise<void> {
+        if (!this.isStopping) {
+            this.isStopping = true;
+            await this.sendRequest('disconnect', { restart: isRestart });
+            callback();
         }
-        return false;
     }
 
     async completions(text: string, column: number, line: number): Promise<DebugProtocol.CompletionItem[]> {
@@ -375,8 +368,8 @@ export class DebugSession implements CompositeTreeElement {
         return response.body;
     }
 
-    sendRequest<K extends keyof DebugRequestTypes>(command: K, args: DebugRequestTypes[K][0]): Promise<DebugRequestTypes[K][1]> {
-        return this.connection.sendRequest(command, args);
+    sendRequest<K extends keyof DebugRequestTypes>(command: K, args: DebugRequestTypes[K][0], timeout?: number): Promise<DebugRequestTypes[K][1]> {
+        return this.connection.sendRequest(command, args, timeout);
     }
 
     sendCustomRequest<T extends DebugProtocol.Response>(command: string, args?: any): Promise<T> {
@@ -387,6 +380,10 @@ export class DebugSession implements CompositeTreeElement {
         return this.connection.on(kind, listener);
     }
 
+    waitFor<K extends keyof DebugEventTypes>(kind: K, ms: number): Promise<void> {
+        return waitForEvent(this.connection.onEvent(kind), ms).then();
+    }
+
     get onDidCustomEvent(): Event<DebugProtocol.Event> {
         return this.connection.onDidCustomEvent;
     }