Add new Docker SDK-based client

package.json

@@ -2652,6 +2652,7 @@
         "webpack-cli": "^3.3.12"
     },
     "dependencies": {
+        "@docker/sdk": "^0.1.7",
         "adal-node": "^0.2.1",
         "azure-arm-containerregistry": "^5.1.0",
         "azure-arm-website": "^5.7.0",

src/commands/containers/attachShellContainer.ts

@@ -5,6 +5,7 @@
 
 import * as vscode from 'vscode';
 import { IActionContext } from 'vscode-azureextensionui';
+import { DockerOSType } from '../../docker/Common';
 import { ext } from '../../extensionVariables';
 import { localize } from '../../localize';
 import { ContainerTreeItem } from '../../tree/containers/ContainerTreeItem';
@@ -20,7 +21,14 @@ export async function attachShellContainer(context: IActionContext, node?: Conta
         });
     }
 
-    let osType = await getDockerOSType(context);
+    let osType: DockerOSType;
+    try {
+        osType = await getDockerOSType(context);
+    } catch {
+        // Assume linux
+        osType = 'linux';
+    }
+
     context.telemetry.properties.dockerOSType = osType;
 
     let shellCommand: string;

src/docker/Containers.ts

@@ -12,6 +12,12 @@ export interface DockerPort {
     readonly Type?: string;
 }
 
+// Ports from inspect have a different shape entirely
+export interface InspectionPort {
+    readonly HostIp?: string;
+    readonly HostPort?: string;
+}
+
 export interface DockerContainer extends DockerObject {
     readonly State: string;
     readonly Status: string;
@@ -32,10 +38,7 @@ export interface DockerContainerInspection extends DockerObject {
     };
     readonly NetworkSettings?: {
         readonly Ports?: {
-            readonly [portAndProtocol: string]: {
-                readonly HostIp?: string;
-                readonly HostPort?: string;
-            }[];
+            readonly [portAndProtocol: string]: InspectionPort[];
         };
     };
 }

src/docker/DockerServeClient/DockerServeClient.ts

@@ -3,8 +3,11 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { Containers as ContainersClient } from '@docker/sdk';
+import { DeleteRequest, InspectRequest, InspectResponse, ListRequest, ListResponse } from '@docker/sdk/containers';
 import { CancellationToken } from 'vscode';
 import { IActionContext } from 'vscode-azureextensionui';
+import { localize } from '../../localize';
 import { DockerInfo, PruneResult } from '../Common';
 import { DockerContainer, DockerContainerInspection } from '../Containers';
 import { ContextChangeCancelClient } from '../ContextChangeCancelClient';
@@ -13,22 +16,57 @@ import { DockerImage, DockerImageInspection } from '../Images';
 import { DockerNetwork, DockerNetworkInspection, DriverType } from '../Networks';
 import { NotSupportedError } from '../NotSupportedError';
 import { DockerVolume, DockerVolumeInspection } from '../Volumes';
+import { containerPortsToInspectionPorts, containerToDockerContainer } from './DockerServeUtils';
+
+// 20 s timeout for all calls (enough time for any call, but short enough to be UX-reasonable)
+const dockerServeCallTimeout = 20 * 1000;
 
 export class DockerServeClient extends ContextChangeCancelClient implements DockerApiClient {
+    private readonly containersClient: ContainersClient;
+
+    public constructor() {
+        super();
+        this.containersClient = new ContainersClient();
+    }
+
+    public dispose(): void {
+        super.dispose();
+        void this.containersClient?.close();
+    }
+
     public async info(context: IActionContext, token?: CancellationToken): Promise<DockerInfo> {
         throw new NotSupportedError(context);
     }
 
     public async getContainers(context: IActionContext, token?: CancellationToken): Promise<DockerContainer[]> {
-        throw new NotSupportedError(context);
+        const response: ListResponse = await this.promisify(context, this.containersClient, this.containersClient.list, new ListRequest(), token);
+        const result = response.getContainersList();
+
+        return result.map(c => containerToDockerContainer(c.toObject()));
     }
 
-    // #region Not supported by the Docker SDK yet
     public async inspectContainer(context: IActionContext, ref: string, token?: CancellationToken): Promise<DockerContainerInspection> {
-        throw new NotSupportedError(context);
+        const request = new InspectRequest();
+        request.setId(ref);
+
+        const response: InspectResponse = await this.promisify(context, this.containersClient, this.containersClient.inspect, request, token);
+        const container = containerToDockerContainer(response.toObject().container);
+
+        if (!container) {
+            throw new Error(localize('vscode-docker.dockerServeClient.noContainer', 'No container with name \'{0}\' was found.', ref));
+        }
+
+        return {
+            ...container,
+            NetworkSettings: {
+                Ports: containerPortsToInspectionPorts(container),
+            },
+        };
     }
 
+    // #region Not supported by the Docker SDK yet
     public async getContainerLogs(context: IActionContext, ref: string, token?: CancellationToken): Promise<NodeJS.ReadableStream> {
+        // Supported by SDK, but used only for debugging which will not work in ACI, and complicated to implement
         throw new NotSupportedError(context);
     }
 
@@ -43,14 +81,19 @@ export class DockerServeClient extends ContextChangeCancelClient implements Dock
     public async restartContainer(context: IActionContext, ref: string, token?: CancellationToken): Promise<void> {
         throw new NotSupportedError(context);
     }
-    // #endregion Not supported by the Docker SDK yet
 
     public async stopContainer(context: IActionContext, ref: string, token?: CancellationToken): Promise<void> {
+        // Supported by SDK, but is not really the same thing; containers in ACI must stop/start as a group
         throw new NotSupportedError(context);
     }
+    // #endregion Not supported by the Docker SDK yet
 
     public async removeContainer(context: IActionContext, ref: string, token?: CancellationToken): Promise<void> {
-        throw new NotSupportedError(context);
+        const request = new DeleteRequest();
+        request.setId(ref);
+        request.setForce(true);
+
+        await this.promisify(context, this.containersClient, this.containersClient.delete, request, token)
     }
 
     // #region Not supported by the Docker SDK yet
@@ -110,4 +153,28 @@ export class DockerServeClient extends ContextChangeCancelClient implements Dock
         throw new NotSupportedError(context);
     }
     // #endregion Not supported by the Docker SDK yet
+
+    private async promisify<TRequest, TResponse>(
+        context: IActionContext,
+        thisArg: unknown,
+        clientCallback: (request: TRequest, callback: (err: unknown, response: TResponse) => void) => unknown,
+        request: TRequest,
+        token?: CancellationToken): Promise<TResponse> {
+
+        const callPromise: Promise<TResponse> = new Promise((resolve, reject) => {
+            try {
+                clientCallback.call(thisArg, request, (err, response) => {
+                    if (err) {
+                        reject(err);
+                    }
+
+                    resolve(response);
+                });
+            } catch (err) {
+                reject(err);
+            }
+        });
+
+        return this.withTimeoutAndCancellations(context, async () => callPromise, dockerServeCallTimeout, token);
+    }
 }

src/docker/DockerServeClient/DockerServeUtils.ts

@@ -0,0 +1,66 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Container } from '@docker/sdk/containers';
+import { DockerContainer, InspectionPort } from '../Containers';
+
+export function containerToDockerContainer(container: Container.AsObject): DockerContainer | undefined {
+    if (!container) {
+        return undefined;
+    }
+
+    const ports = container.portsList.map(p => {
+        return {
+            IP: p.hostIp,
+            PublicPort: p.hostPort,
+            PrivatePort: p.containerPort,
+            Type: p.protocol,
+        };
+    });
+
+    const labels: { [key: string]: string } = {};
+    container.labelsList.forEach(l => {
+        const [label, value] = l.split('=');
+        labels[label] = value;
+    });
+
+    return {
+        Id: container.id,
+        Image: container.image,
+        Name: container.id, // TODO ?
+        State: container.status,
+        Status: container.status,
+        ImageID: undefined, // TODO ?
+        CreatedTime: undefined, // TODO ?
+        Labels: labels, // TODO--not yet supported on ACI
+        Ports: ports,
+    };
+}
+
+export function containerPortsToInspectionPorts(container: DockerContainer): { [portAndProtocol: string]: InspectionPort[] } | undefined {
+    if (container?.Ports === undefined) {
+        return undefined;
+    }
+
+    const result: { [portAndProtocol: string]: InspectionPort[] } = {};
+
+    for (const port of container.Ports) {
+        // Get the key
+        const key = `${port.PrivatePort}/${port.Type}`;
+
+        // If there's no entries for this key yet, create an empty list
+        if (result[key] === undefined) {
+            result[key] = [];
+        }
+
+        // Add the value to the list
+        result[key].push({
+            HostIp: port.IP,
+            HostPort: port.PublicPort.toString(),
+        });
+    }
+
+    return result;
+}

src/docker/DockerodeApiClient/DockerodeApiClient.ts

@@ -15,10 +15,9 @@ import { DockerApiClient } from '../DockerApiClient';
 import { DockerImage, DockerImageInspection } from '../Images';
 import { DockerNetwork, DockerNetworkInspection, DriverType } from '../Networks';
 import { DockerVolume, DockerVolumeInspection } from '../Volumes';
-import { getContainerName, getFullTagFromDigest } from './DockerodeUtils';
-import { refreshDockerode } from './refreshDockerode';
+import { getContainerName, getFullTagFromDigest, refreshDockerode } from './DockerodeUtils';
 
-// 20 s timeout for all calls (enough time for a possible Dockerode refresh + the call, but short enough to be UX-reasonable)
+// 20 s timeout for all calls (enough time for any call, but short enough to be UX-reasonable)
 const dockerodeCallTimeout = 20 * 1000;
 
 export class DockerodeApiClient extends ContextChangeCancelClient implements DockerApiClient {

src/docker/DockerodeApiClient/DockerodeUtils.ts

@@ -4,6 +4,15 @@
  *--------------------------------------------------------------------------------------------*/
 
 import Dockerode = require('dockerode');
+import { Socket } from 'net';
+import { CancellationTokenSource, workspace } from 'vscode';
+import { ext } from '../../extensionVariables';
+import { localize } from '../../localize';
+import { addDockerSettingsToEnv } from '../../utils/addDockerSettingsToEnv';
+import { cloneObject } from '../../utils/cloneObject';
+import { isWindows } from '../../utils/osUtils';
+import { TimeoutPromiseSource } from '../../utils/promiseUtils';
+import { DockerContext } from '../Contexts';
 
 export function getFullTagFromDigest(image: Dockerode.ImageInfo): string {
     let repo = '<none>';
@@ -28,3 +37,85 @@ export function getContainerName(containerInfo: Dockerode.ContainerInfo): string
 
     return canonicalName ?? names[0];
 }
+const SSH_URL_REGEX = /ssh:\/\//i;
+
+/**
+ * Dockerode parses and handles the well-known `DOCKER_*` environment variables, but it doesn't let us pass those values as-is to the constructor
+ * Thus we will temporarily update `process.env` and pass nothing to the constructor
+ */
+export function refreshDockerode(currentContext: DockerContext): Dockerode {
+    // If the docker.dockerodeOptions setting is present, use it only
+    const config = workspace.getConfiguration('docker');
+    const overrideDockerodeOptions = config.get('dockerodeOptions');
+    // eslint-disable-next-line @typescript-eslint/tslint/config
+    if (overrideDockerodeOptions && Object.keys(overrideDockerodeOptions).length > 0) {
+        return new Dockerode(<Dockerode.DockerOptions>overrideDockerodeOptions);
+    }
+
+    // Set up environment variables
+    const oldEnv = process.env;
+    const newEnv: NodeJS.ProcessEnv = cloneObject(process.env); // make a clone before we change anything
+
+    if (currentContext.Name === 'default') {
+        // If the current context is default, just make use of addDockerSettingsToEnv + the current environment
+        addDockerSettingsToEnv(newEnv, oldEnv);
+    } else {
+        // Otherwise get the host from the Docker context
+        newEnv.DOCKER_HOST = currentContext.DockerEndpoint;
+    }
+
+    // If host is an SSH URL, we need to configure / validate SSH_AUTH_SOCK for Dockerode
+    if (newEnv.DOCKER_HOST && SSH_URL_REGEX.test(newEnv.DOCKER_HOST)) {
+        if (!newEnv.SSH_AUTH_SOCK && isWindows()) {
+            // On Windows, we can use this one by default
+            newEnv.SSH_AUTH_SOCK = '\\\\.\\pipe\\openssh-ssh-agent';
+        }
+
+        // Don't wait
+        void validateSshAuthSock(newEnv.SSH_AUTH_SOCK).then((result) => {
+            if (!result) {
+                // Don't wait
+                void ext.ui.showWarningMessage(localize('vscode-docker.utils.dockerode.sshAgent', 'In order to use an SSH DOCKER_HOST, you must configure an ssh-agent.'), { learnMoreLink: 'https://aka.ms/AA7assy' });
+            }
+        });
+    }
+
+    try {
+        process.env = newEnv;
+        return new Dockerode();
+    } finally {
+        process.env = oldEnv;
+    }
+}
+
+async function validateSshAuthSock(authSock: string): Promise<boolean> {
+    if (!authSock) {
+        // On Mac and Linux, if SSH_AUTH_SOCK isn't set there's nothing we can do
+        // Running ssh-agent would yield a new agent that doesn't have the needed keys
+        return false;
+    }
+
+    const socket = new Socket();
+    const cts = new CancellationTokenSource();
+
+    const connectPromise = new Promise<boolean>(resolve => {
+        socket.on('error', (err) => {
+            cts.cancel();
+            resolve(false);
+        });
+
+        socket.on('connect', () => {
+            cts.cancel();
+            resolve(true);
+        });
+
+        socket.connect(authSock);
+    });
+
+    // Unfortunately Socket.setTimeout() does not actually work when attempting to establish a connection, so we need to race
+    return await Promise.race([connectPromise, new TimeoutPromiseSource(1000).promise])
+        .finally(() => {
+            socket.end();
+            cts.dispose();
+        });
+}