@theia/dev-container 1.49.0 → 1.50.0

package/src/electron-node/docker-container-service.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { ContributionProvider, URI } from '@theia/core';
+import { ContributionProvider, MaybePromise, URI } from '@theia/core';
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { WorkspaceServer } from '@theia/workspace/lib/common';
 import * as fs from '@theia/core/shared/fs-extra';
@@ -23,14 +23,29 @@ import { LastContainerInfo } from '../electron-common/remote-container-connectio
 import { DevContainerConfiguration } from './devcontainer-file';
 import { DevContainerFileService } from './dev-container-file-service';
 import { ContainerOutputProvider } from '../electron-common/container-output-provider';
+import { RemoteDockerContainerConnection } from './remote-container-connection-provider';
 
 export const ContainerCreationContribution = Symbol('ContainerCreationContributions');
 
 export interface ContainerCreationContribution {
-    handleContainerCreation(createOptions: Docker.ContainerCreateOptions,
+    handleContainerCreation?(createOptions: Docker.ContainerCreateOptions,
         containerConfig: DevContainerConfiguration,
         api: Docker,
-        outputProvider?: ContainerOutputProvider): Promise<void>;
+        outputProvider?: ContainerOutputProvider): MaybePromise<void>;
+
+    /**
+     * executed after creating and starting the container
+     */
+    handlePostCreate?(containerConfig: DevContainerConfiguration,
+        container: Docker.Container,
+        api: Docker,
+        outputProvider?: ContainerOutputProvider): MaybePromise<void>;
+
+    /**
+     * executed after a connection has been established with the container and theia has been setup
+     */
+    handlePostConnect?(containerConfig: DevContainerConfiguration, connection: RemoteDockerContainerConnection,
+        outputProvider?: ContainerOutputProvider): MaybePromise<void>;
 }
 
 @injectable()
@@ -70,6 +85,15 @@ export class DockerContainerService {
         return container;
     }
 
+    async postConnect(devcontainerFile: string, connection: RemoteDockerContainerConnection, outputProvider?: ContainerOutputProvider): Promise<void> {
+        const devcontainerConfig = await this.devContainerFileService.getConfiguration(devcontainerFile);
+
+        for (const containerCreateContrib of this.containerCreationContributions.getContributions()) {
+            await containerCreateContrib.handlePostConnect?.(devcontainerConfig, connection, outputProvider);
+        }
+
+    }
+
     protected async buildContainer(docker: Docker, devcontainerFile: string, workspace: URI, outputProvider?: ContainerOutputProvider): Promise<Docker.Container> {
         const devcontainerConfig = await this.devContainerFileService.getConfiguration(devcontainerFile);
 
@@ -92,33 +116,17 @@ export class DockerContainerService {
         };
 
         for (const containerCreateContrib of this.containerCreationContributions.getContributions()) {
-            await containerCreateContrib.handleContainerCreation(containerCreateOptions, devcontainerConfig, docker, outputProvider);
+            await containerCreateContrib.handleContainerCreation?.(containerCreateOptions, devcontainerConfig, docker, outputProvider);
         }
 
         // TODO add more config
         const container = await docker.createContainer(containerCreateOptions);
         await container.start();
 
-        return container;
-    }
-
-    protected getPortBindings(forwardPorts: (string | number)[]): { exposedPorts: {}, portBindings: {} } {
-        const res: { exposedPorts: { [key: string]: {} }, portBindings: { [key: string]: {} } } = { exposedPorts: {}, portBindings: {} };
-        for (const port of forwardPorts) {
-            let portKey: string;
-            let hostPort: string;
-            if (typeof port === 'string') {
-                const parts = port.split(':');
-                portKey = isNaN(+parts[0]) ? parts[0] : `${parts[0]}/tcp`;
-                hostPort = parts[1] ?? parts[0];
-            } else {
-                portKey = `${port}/tcp`;
-                hostPort = port.toString();
-            }
-            res.exposedPorts[portKey] = {};
-            res.portBindings[portKey] = [{ HostPort: hostPort }];
+        for (const containerCreateContrib of this.containerCreationContributions.getContributions()) {
+            await containerCreateContrib.handlePostCreate?.(devcontainerConfig, container, docker, outputProvider);
         }
 
-        return res;
+        return container;
     }
 }

package/src/electron-node/remote-container-connection-provider.ts

@@ -56,6 +56,9 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
     @inject(DevContainerFileService)
     protected readonly devContainerFileService: DevContainerFileService;
 
+    @inject(RemoteConnectionService)
+    protected readonly remoteService: RemoteConnectionService;
+
     protected outputProvider: ContainerOutputProvider | undefined;
 
     setClient(client: ContainerOutputProvider): void {
@@ -77,12 +80,13 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
         });
         try {
             const container = await this.containerService.getOrCreateContainer(dockerConnection, options.devcontainerFile, options.lastContainerInfo, this.outputProvider);
+            const devContainerConfig = await this.devContainerFileService.getConfiguration(options.devcontainerFile);
 
             // create actual connection
             const report: RemoteStatusReport = message => progress.report({ message });
             report('Connecting to remote system...');
 
-            const remote = await this.createContainerConnection(container, dockerConnection);
+            const remote = await this.createContainerConnection(container, dockerConnection, devContainerConfig.name);
             const result = await this.remoteSetup.setup({
                 connection: remote,
                 report,
@@ -100,6 +104,9 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
             });
             const localPort = (server.address() as net.AddressInfo).port;
             remote.localPort = localPort;
+
+            await this.containerService.postConnect(options.devcontainerFile, remote, this.outputProvider);
+
             return {
                 containerId: container.id,
                 workspacePath: (await container.inspect()).Mounts[0].Destination,
@@ -118,16 +125,24 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
         return this.devContainerFileService.getAvailableFiles();
     }
 
-    async createContainerConnection(container: Docker.Container, docker: Docker): Promise<RemoteDockerContainerConnection> {
+    async createContainerConnection(container: Docker.Container, docker: Docker, name?: string): Promise<RemoteDockerContainerConnection> {
         return Promise.resolve(new RemoteDockerContainerConnection({
             id: generateUuid(),
-            name: 'dev-container',
-            type: 'container',
+            name: name ?? 'dev-container',
+            type: 'Dev Container',
             docker,
             container,
         }));
     }
 
+    async getCurrentContainerInfo(port: number): Promise<Docker.ContainerInspectInfo | undefined> {
+        const connection = this.remoteConnectionService.getConnectionFromPort(port);
+        if (!connection || !(connection instanceof RemoteDockerContainerConnection)) {
+            return undefined;
+        }
+        return connection.container.inspect();
+    }
+
     dispose(): void {
 
     }
@@ -167,8 +182,6 @@ export class RemoteDockerContainerConnection implements RemoteConnection {
     docker: Docker;
     container: Docker.Container;
 
-    containerInfo: Docker.ContainerInspectInfo | undefined;
-
     remoteSetupResult: RemoteSetupResult;
 
     protected activeTerminalSession: ContainerTerminalSession | undefined;
@@ -180,10 +193,13 @@ export class RemoteDockerContainerConnection implements RemoteConnection {
         this.id = options.id;
         this.type = options.type;
         this.name = options.name;
-        this.onDidDisconnect(() => this.dispose());
 
         this.docker = options.docker;
         this.container = options.container;
+
+        this.docker.getEvents({ filters: { container: [this.container.id], event: ['stop'] } }).then(stream => {
+            stream.on('data', () => this.onDidDisconnectEmitter.fire());
+        });
     }
 
     async forwardOut(socket: Socket, port?: number): Promise<void> {
@@ -287,8 +303,9 @@ export class RemoteDockerContainerConnection implements RemoteConnection {
         return deferred.promise;
     }
 
-    dispose(): void {
-        this.container.stop();
+    async dispose(): Promise<void> {
+        // cant use dockerrode here since this needs to happen on one tick
+        exec(`docker stop ${this.container.id}`);
     }
 
 }