@theia/dev-container 1.48.0

package/src/electron-browser/container-connection-contribution.ts

@@ -0,0 +1,103 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { AbstractRemoteRegistryContribution, RemoteRegistry } from '@theia/remote/lib/electron-browser/remote-registry-contribution';
+import { LastContainerInfo, RemoteContainerConnectionProvider } from '../electron-common/remote-container-connection-provider';
+import { RemotePreferences } from '@theia/remote/lib/electron-browser/remote-preferences';
+import { WorkspaceStorageService } from '@theia/workspace/lib/browser/workspace-storage-service';
+import { Command, QuickInputService } from '@theia/core';
+import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
+import { ContainerOutputProvider } from './container-output-provider';
+
+export namespace RemoteContainerCommands {
+    export const REOPEN_IN_CONTAINER = Command.toLocalizedCommand({
+        id: 'dev-container:reopen-in-container',
+        label: 'Reopen in Container',
+        category: 'Dev Container'
+    }, 'theia/dev-container/connect');
+}
+
+const LAST_USED_CONTAINER = 'lastUsedContainer';
+@injectable()
+export class ContainerConnectionContribution extends AbstractRemoteRegistryContribution {
+
+    @inject(RemoteContainerConnectionProvider)
+    protected readonly connectionProvider: RemoteContainerConnectionProvider;
+
+    @inject(RemotePreferences)
+    protected readonly remotePreferences: RemotePreferences;
+
+    @inject(WorkspaceStorageService)
+    protected readonly workspaceStorageService: WorkspaceStorageService;
+
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
+    @inject(QuickInputService)
+    protected readonly quickInputService: QuickInputService;
+
+    @inject(ContainerOutputProvider)
+    protected readonly containerOutputProvider: ContainerOutputProvider;
+
+    registerRemoteCommands(registry: RemoteRegistry): void {
+        registry.registerCommand(RemoteContainerCommands.REOPEN_IN_CONTAINER, {
+            execute: () => this.openInContainer()
+        });
+    }
+
+    async openInContainer(): Promise<void> {
+        const devcontainerFile = await this.getOrSelectDevcontainerFile();
+        if (!devcontainerFile) {
+            return;
+        }
+        const lastContainerInfoKey = `${LAST_USED_CONTAINER}:${devcontainerFile}`;
+        const lastContainerInfo = await this.workspaceStorageService.getData<LastContainerInfo | undefined>(lastContainerInfoKey);
+
+        this.containerOutputProvider.openChannel();
+
+        const connectionResult = await this.connectionProvider.connectToContainer({
+            nodeDownloadTemplate: this.remotePreferences['remote.nodeDownloadTemplate'],
+            lastContainerInfo,
+            devcontainerFile
+        });
+
+        this.workspaceStorageService.setData<LastContainerInfo>(lastContainerInfoKey, {
+            id: connectionResult.containerId,
+            lastUsed: Date.now()
+        });
+
+        this.openRemote(connectionResult.port, false, connectionResult.workspacePath);
+    }
+
+    async getOrSelectDevcontainerFile(): Promise<string | undefined> {
+        const devcontainerFiles = await this.connectionProvider.getDevContainerFiles();
+
+        if (devcontainerFiles.length === 1) {
+            return devcontainerFiles[0].path;
+        }
+
+        return (await this.quickInputService.pick(devcontainerFiles.map(file => ({
+            type: 'item',
+            label: file.name,
+            description: file.path,
+            file: file.path,
+        })), {
+            title: 'Select a devcontainer.json file'
+        }))?.file;
+    }
+
+}

package/src/electron-browser/container-output-provider.ts

@@ -0,0 +1,36 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, inject } from '@theia/core/shared/inversify';
+import { OutputChannel, OutputChannelManager } from '@theia/output/lib/browser/output-channel';
+
+@injectable()
+export class ContainerOutputProvider implements ContainerOutputProvider {
+
+    @inject(OutputChannelManager)
+    protected readonly outputChannelManager: OutputChannelManager;
+
+    protected currentChannel?: OutputChannel;
+
+    openChannel(): void {
+        this.currentChannel = this.outputChannelManager.getChannel('Container');
+        this.currentChannel.show();
+    };
+
+    onRemoteOutput(output: string): void {
+        this.currentChannel?.appendLine(output);
+    }
+}

package/src/electron-browser/dev-container-frontend-module.ts

@@ -0,0 +1,33 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+import { ContainerModule } from '@theia/core/shared/inversify';
+import { RemoteRegistryContribution } from '@theia/remote/lib/electron-browser/remote-registry-contribution';
+import { RemoteContainerConnectionProvider, RemoteContainerConnectionProviderPath } from '../electron-common/remote-container-connection-provider';
+import { ContainerConnectionContribution } from './container-connection-contribution';
+import { ServiceConnectionProvider } from '@theia/core/lib/browser/messaging/service-connection-provider';
+import { ContainerOutputProvider } from './container-output-provider';
+
+export default new ContainerModule(bind => {
+    bind(ContainerConnectionContribution).toSelf().inSingletonScope();
+    bind(RemoteRegistryContribution).toService(ContainerConnectionContribution);
+
+    bind(ContainerOutputProvider).toSelf().inSingletonScope();
+
+    bind(RemoteContainerConnectionProvider).toDynamicValue(ctx => {
+        const outputProvider = ctx.container.get(ContainerOutputProvider);
+        return ServiceConnectionProvider.createLocalProxy<RemoteContainerConnectionProvider>(ctx.container, RemoteContainerConnectionProviderPath, outputProvider);
+    }).inSingletonScope();
+});

package/src/electron-common/container-output-provider.ts

@@ -0,0 +1,19 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+export interface ContainerOutputProvider {
+    onRemoteOutput(output: string): void;
+}

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

@@ -0,0 +1,49 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+
+import { RpcServer } from '@theia/core';
+import { ContainerOutputProvider } from './container-output-provider';
+
+// *****************************************************************************
+export const RemoteContainerConnectionProviderPath = '/remote/container';
+
+export const RemoteContainerConnectionProvider = Symbol('RemoteContainerConnectionProvider');
+
+export interface ContainerConnectionOptions {
+    nodeDownloadTemplate?: string;
+    lastContainerInfo?: LastContainerInfo
+    devcontainerFile: string;
+}
+
+export interface LastContainerInfo {
+    id: string;
+    lastUsed: number;
+}
+
+export interface ContainerConnectionResult {
+    port: string;
+    workspacePath: string;
+    containerId: string;
+}
+
+export interface DevContainerFile {
+    name: string;
+    path: string;
+}
+
+export interface RemoteContainerConnectionProvider extends RpcServer<ContainerOutputProvider> {
+    connectToContainer(options: ContainerConnectionOptions): Promise<ContainerConnectionResult>;
+    getDevContainerFiles(): Promise<DevContainerFile[]>;
+}

package/src/electron-node/dev-container-backend-module.ts

@@ -0,0 +1,47 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ContainerModule } from '@theia/core/shared/inversify';
+import { ConnectionContainerModule } from '@theia/core/lib/node/messaging/connection-container-module';
+import { DevContainerConnectionProvider } from './remote-container-connection-provider';
+import { RemoteContainerConnectionProvider, RemoteContainerConnectionProviderPath } from '../electron-common/remote-container-connection-provider';
+import { ContainerCreationContribution, DockerContainerService } from './docker-container-service';
+import { bindContributionProvider, ConnectionHandler, RpcConnectionHandler } from '@theia/core';
+import { registerContainerCreationContributions } from './devcontainer-contributions/main-container-creation-contributions';
+import { DevContainerFileService } from './dev-container-file-service';
+import { ContainerOutputProvider } from '../electron-common/container-output-provider';
+
+export const remoteConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService }) => {
+    bindContributionProvider(bind, ContainerCreationContribution);
+    registerContainerCreationContributions(bind);
+
+    bind(DevContainerConnectionProvider).toSelf().inSingletonScope();
+    bind(RemoteContainerConnectionProvider).toService(DevContainerConnectionProvider);
+    bind(ConnectionHandler).toDynamicValue(ctx =>
+        new RpcConnectionHandler<ContainerOutputProvider>(RemoteContainerConnectionProviderPath, client => {
+            const server = ctx.container.get<RemoteContainerConnectionProvider>(RemoteContainerConnectionProvider);
+            server.setClient(client);
+            client.onDidCloseConnection(() => server.dispose());
+            return server;
+        }));
+});
+
+export default new ContainerModule((bind, unbind, isBound, rebind) => {
+    bind(DockerContainerService).toSelf().inSingletonScope();
+    bind(ConnectionContainerModule).toConstantValue(remoteConnectionModule);
+
+    bind(DevContainerFileService).toSelf().inSingletonScope();
+});

package/src/electron-node/dev-container-file-service.ts

@@ -0,0 +1,72 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { WorkspaceServer } from '@theia/workspace/lib/common';
+import { DevContainerFile } from '../electron-common/remote-container-connection-provider';
+import { DevContainerConfiguration } from './devcontainer-file';
+import { parse } from 'jsonc-parser';
+import * as fs from '@theia/core/shared/fs-extra';
+import { Path, URI } from '@theia/core';
+
+@injectable()
+export class DevContainerFileService {
+
+    @inject(WorkspaceServer)
+    protected readonly workspaceServer: WorkspaceServer;
+
+    async getConfiguration(path: string): Promise<DevContainerConfiguration> {
+        const configuration: DevContainerConfiguration = parse(await fs.readFile(path, 'utf-8').catch(() => '0')) as DevContainerConfiguration;
+        if (!configuration) {
+            throw new Error(`devcontainer file ${path} could not be parsed`);
+        }
+
+        configuration.location = path;
+        return configuration;
+    }
+
+    async getAvailableFiles(): Promise<DevContainerFile[]> {
+        const workspace = await this.workspaceServer.getMostRecentlyUsedWorkspace();
+        if (!workspace) {
+            return [];
+        }
+
+        const devcontainerPath = new URI(workspace).path.join('.devcontainer').fsPath();
+
+        return (await this.searchForDevontainerJsonFiles(devcontainerPath, 1)).map(file => ({
+            name: parse(fs.readFileSync(file, 'utf-8')).name ?? 'devcontainer',
+            path: file
+        }));
+
+    }
+
+    protected async searchForDevontainerJsonFiles(directory: string, depth: number): Promise<string[]> {
+        if (depth < 0) {
+            return [];
+        }
+        const filesPaths = (await fs.readdir(directory)).map(file => new Path(directory).join(file).fsPath());
+
+        const devcontainerFiles = [];
+        for (const file of filesPaths) {
+            if (file.endsWith('devcontainer.json')) {
+                devcontainerFiles.push(file);
+            } else if ((await fs.stat(file)).isDirectory()) {
+                devcontainerFiles.push(...await this.searchForDevontainerJsonFiles(file, depth - 1));
+            }
+        }
+        return devcontainerFiles;
+    }
+}

package/src/electron-node/devcontainer-contributions/main-container-creation-contributions.ts

@@ -0,0 +1,140 @@
+// *****************************************************************************
+// Copyright (C) 2024 Typefox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+import * as Docker from 'dockerode';
+import { injectable, interfaces } from '@theia/core/shared/inversify';
+import { ContainerCreationContribution } from '../docker-container-service';
+import { DevContainerConfiguration, DockerfileContainer, ImageContainer, NonComposeContainerBase } from '../devcontainer-file';
+import { Path } from '@theia/core';
+import { ContainerOutputProvider } from '../../electron-common/container-output-provider';
+
+export function registerContainerCreationContributions(bind: interfaces.Bind): void {
+    bind(ContainerCreationContribution).to(ImageFileContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(DockerFileContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(ForwardPortsContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(MountsContribution).inSingletonScope();
+}
+
+@injectable()
+export class ImageFileContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: ImageContainer,
+        api: Docker, outputprovider: ContainerOutputProvider): Promise<void> {
+        if (containerConfig.image) {
+            await new Promise<void>((res, rej) => api.pull(containerConfig.image, {}, (err, stream) => {
+                if (err) {
+                    rej(err);
+                } else {
+                    api.modem.followProgress(stream, (error, output) => error ?
+                        rej(error) :
+                        res(), progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress)));
+                }
+            }));
+            createOptions.Image = containerConfig.image;
+        }
+    }
+}
+
+@injectable()
+export class DockerFileContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DockerfileContainer,
+        api: Docker, outputprovider: ContainerOutputProvider): Promise<void> {
+        // check if dockerfile container
+        if (containerConfig.dockerFile || containerConfig.build?.dockerfile) {
+            const dockerfile = (containerConfig.dockerFile ?? containerConfig.build?.dockerfile) as string;
+            const buildStream = await api.buildImage({
+                context: containerConfig.context ?? new Path(containerConfig.location as string).dir.fsPath(),
+                src: [dockerfile],
+            } as Docker.ImageBuildContext, {
+                buildargs: containerConfig.build?.args
+            });
+            // TODO probably have some console windows showing the output of the build
+            const imageId = await new Promise<string>((res, rej) => api.modem.followProgress(buildStream, (err, outputs) => {
+                if (err) {
+                    rej(err);
+                } else {
+                    for (let i = outputs.length - 1; i >= 0; i--) {
+                        if (outputs[i].aux?.ID) {
+                            res(outputs[i].aux.ID);
+                            return;
+                        }
+                    }
+                }
+            }, progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress))));
+            createOptions.Image = imageId;
+        }
+    }
+}
+
+@injectable()
+export class ForwardPortsContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DevContainerConfiguration, api: Docker): Promise<void> {
+        if (!containerConfig.forwardPorts) {
+            return;
+        }
+
+        for (const port of containerConfig.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();
+            }
+            createOptions.ExposedPorts![portKey] = {};
+            createOptions.HostConfig!.PortBindings[portKey] = [{ HostPort: hostPort }];
+        }
+
+    }
+
+}
+
+@injectable()
+export class MountsContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DevContainerConfiguration, api: Docker): Promise<void> {
+        if (!containerConfig.mounts) {
+            return;
+        }
+
+        createOptions.HostConfig!.Mounts!.push(...(containerConfig as NonComposeContainerBase)?.mounts
+            ?.map(mount => typeof mount === 'string' ?
+                this.parseMountString(mount) :
+                { Source: mount.source, Target: mount.target, Type: mount.type ?? 'bind' }) ?? []);
+    }
+
+    parseMountString(mount: string): Docker.MountSettings {
+        const parts = mount.split(',');
+        return {
+            Source: parts.find(part => part.startsWith('source=') || part.startsWith('src='))?.split('=')[1]!,
+            Target: parts.find(part => part.startsWith('target=') || part.startsWith('dst='))?.split('=')[1]!,
+            Type: (parts.find(part => part.startsWith('type='))?.split('=')[1] ?? 'bind') as Docker.MountType
+        };
+    }
+}
+
+export namespace OutputHelper {
+    export interface Progress {
+        id?: string;
+        stream: string;
+        status?: string;
+        progress?: string;
+    }
+
+    export function parseProgress(progress: Progress): string {
+        return progress.stream ?? progress.progress ?? progress.status ?? '';
+    }
+}