@theia/dev-container 1.56.0 → 1.57.0-next.112

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

@@ -30,6 +30,7 @@ export function registerContainerCreationContributions(bind: interfaces.Bind): v
     bind(ContainerCreationContribution).to(MountsContribution).inSingletonScope();
     bind(ContainerCreationContribution).to(RemoteUserContribution).inSingletonScope();
     bind(ContainerCreationContribution).to(PostCreateCommandContribution).inSingletonScope();
+    bind(ContainerCreationContribution).to(ContainerEnvContribution).inSingletonScope();
 }
 
 @injectable()
@@ -37,11 +38,16 @@ 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) => {
+            const platform = process.platform;
+            const arch = process.arch;
+            const options = platform === 'darwin' && arch === 'arm64' ? { platform: 'amd64' } : {};
+            await new Promise<void>((res, rej) => api.pull(containerConfig.image, options, (err, stream) => {
                 if (err) {
                     rej(err);
+                } else if (stream === undefined) {
+                    rej('Stream is undefined');
                 } else {
-                    api.modem.followProgress(stream, (error, output) => error ?
+                    api.modem.followProgress(stream!, (error, output) => error ?
                         rej(error) :
                         res(), progress => outputprovider.onRemoteOutput(OutputHelper.parseProgress(progress)));
                 }
@@ -177,6 +183,20 @@ export class PostCreateCommandContribution implements ContainerCreationContribut
     }
 }
 
+@injectable()
+export class ContainerEnvContribution implements ContainerCreationContribution {
+    async handleContainerCreation(createOptions: Docker.ContainerCreateOptions, containerConfig: DevContainerConfiguration): Promise<void> {
+        if (containerConfig.containerEnv) {
+            if (createOptions.Env === undefined) {
+                createOptions.Env = [];
+            }
+            for (const [key, value] of Object.entries(containerConfig.containerEnv)) {
+                createOptions.Env.push(`${key}=${value}`);
+            }
+        }
+    }
+}
+
 export namespace OutputHelper {
     export interface Progress {
         id?: string;

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

@@ -19,7 +19,7 @@ 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';
 import * as Docker from 'dockerode';
-import { LastContainerInfo } from '../electron-common/remote-container-connection-provider';
+import { ContainerConnectionOptions } from '../electron-common/remote-container-connection-provider';
 import { DevContainerConfiguration } from './devcontainer-file';
 import { DevContainerFileService } from './dev-container-file-service';
 import { ContainerOutputProvider } from '../electron-common/container-output-provider';
@@ -60,15 +60,14 @@ export class DockerContainerService {
     @inject(DevContainerFileService)
     protected readonly devContainerFileService: DevContainerFileService;
 
-    async getOrCreateContainer(docker: Docker, devcontainerFile: string,
-        lastContainerInfo?: LastContainerInfo, outputProvider?: ContainerOutputProvider): Promise<Docker.Container> {
+    async getOrCreateContainer(docker: Docker, options: ContainerConnectionOptions, outputProvider?: ContainerOutputProvider): Promise<Docker.Container> {
         let container;
 
-        const workspace = new URI(await this.workspaceServer.getMostRecentlyUsedWorkspace());
+        const workspace = new URI(options.workspaceUri ?? await this.workspaceServer.getMostRecentlyUsedWorkspace());
 
-        if (lastContainerInfo && fs.statSync(devcontainerFile).mtimeMs < lastContainerInfo.lastUsed) {
+        if (options.lastContainerInfo && fs.statSync(options.devcontainerFile).mtimeMs < options.lastContainerInfo.lastUsed) {
             try {
-                container = docker.getContainer(lastContainerInfo.id);
+                container = docker.getContainer(options.lastContainerInfo.id);
                 if ((await container.inspect()).State.Running) {
                     await container.restart();
                 } else {
@@ -80,7 +79,7 @@ export class DockerContainerService {
             }
         }
         if (!container) {
-            container = await this.buildContainer(docker, devcontainerFile, workspace, outputProvider);
+            container = await this.buildContainer(docker, options.devcontainerFile, workspace, outputProvider);
         }
         return container;
     }

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

@@ -79,7 +79,7 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
             text: 'Creating container',
         });
         try {
-            const container = await this.containerService.getOrCreateContainer(dockerConnection, options.devcontainerFile, options.lastContainerInfo, this.outputProvider);
+            const container = await this.containerService.getOrCreateContainer(dockerConnection, options, this.outputProvider);
             const devContainerConfig = await this.devContainerFileService.getConfiguration(options.devcontainerFile);
 
             // create actual connection
@@ -121,8 +121,8 @@ export class DevContainerConnectionProvider implements RemoteContainerConnection
         }
     }
 
-    getDevContainerFiles(): Promise<DevContainerFile[]> {
-        return this.devContainerFileService.getAvailableFiles();
+    getDevContainerFiles(workspacePath: string): Promise<DevContainerFile[]> {
+        return this.devContainerFileService.getAvailableFiles(workspacePath);
     }
 
     async createContainerConnection(container: Docker.Container, docker: Docker, name?: string): Promise<RemoteDockerContainerConnection> {