@lakutata/docker 3.0.0-beta.0

package/dist/cjs/client/DockerConnection.js

@@ -0,0 +1,397 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerConnection = exports.DOCKER_MIN_API_VERSION = exports.DOCKER_API_VERSION = void 0;
+exports.compareAPIVersions = compareAPIVersions;
+exports.defaultConnectionOptions = defaultConnectionOptions;
+/*
+ * The connection to the Docker Engine API, rewritten from docker-modem (Copyright Pedro Dias, Apache License 2.0,
+ * see THIRD_PARTY_NOTICES.md), modified: the requests are promises, the API version is negotiated, and the requests
+ * streaming a body close their connection (see Request)
+ */
+const node_fs_1 = require("node:fs");
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = require("node:stream");
+const DockerRequestError_js_1 = require("./DockerRequestError.js");
+/**
+ * The newest API version this client is tested with (Docker 29.8): the one negotiated when the daemon supports it, so that
+ * a newer daemon answers as the tested one. An older daemon answers with its version: the fields a version does not have
+ * are missing or null
+ */
+exports.DOCKER_API_VERSION = '1.56';
+/**
+ * The oldest API version this client works with
+ */
+exports.DOCKER_MIN_API_VERSION = '1.41';
+/**
+ * Compare two API versions
+ * @param a
+ * @param b
+ */
+function compareAPIVersions(a, b) {
+    const [x, y] = [a, b].map((version) => version.replace(/^v/, '').split('.').map(Number));
+    return (x[0] - y[0]) || ((x[1] ?? 0) - (y[1] ?? 0));
+}
+/**
+ * The certificates of a CA file, split (a file may have several)
+ * @param file
+ */
+function splitCA(file) {
+    return (0, node_fs_1.readFileSync)(file, 'utf8').split(/(?<=-----END CERTIFICATE-----)\s*/).map((certificate) => certificate.trim()).filter(Boolean);
+}
+/**
+ * The connection options given by the environment (DOCKER_HOST, DOCKER_TLS_VERIFY, DOCKER_CERT_PATH,
+ * DOCKER_CLIENT_TIMEOUT), else the socket of the platform: the named pipe on Windows, the socket of the user (Docker
+ * Desktop) or /var/run/docker.sock
+ */
+function defaultConnectionOptions() {
+    const dockerHost = process.env.DOCKER_HOST;
+    if (!dockerHost) {
+        if ((0, node_os_1.platform)() === 'win32')
+            return { socketPath: '//./pipe/docker_engine' };
+        const userSocket = node_path_1.default.join((0, node_os_1.homedir)(), '.docker', 'run', 'docker.sock');
+        return { socketPath: (0, node_fs_1.existsSync)(userSocket) ? userSocket : '/var/run/docker.sock' };
+    }
+    if (dockerHost.startsWith('unix://'))
+        return { socketPath: dockerHost.slice(7) || '/var/run/docker.sock' };
+    if (dockerHost.startsWith('npipe://'))
+        return { socketPath: dockerHost.slice(8) || '//./pipe/docker_engine' };
+    let url;
+    try {
+        url = new URL(dockerHost.includes('//') ? dockerHost : `tcp://${dockerHost}`);
+    }
+    catch {
+        throw new Error('DOCKER_HOST should be something like tcp://localhost:2375');
+    }
+    const options = { host: url.hostname, port: url.port };
+    if (url.protocol === 'ssh:') {
+        options.protocol = 'ssh';
+        options.username = url.username || undefined;
+    }
+    else {
+        options.protocol = process.env.DOCKER_TLS_VERIFY === '1' || url.port === '2376' ? 'https' : 'http';
+    }
+    const certPath = process.env.DOCKER_CERT_PATH;
+    if (certPath) {
+        options.ca = splitCA(node_path_1.default.join(certPath, 'ca.pem'));
+        options.cert = (0, node_fs_1.readFileSync)(node_path_1.default.join(certPath, 'cert.pem'));
+        options.key = (0, node_fs_1.readFileSync)(node_path_1.default.join(certPath, 'key.pem'));
+    }
+    if (process.env.DOCKER_CLIENT_TIMEOUT)
+        options.timeout = Number.parseInt(process.env.DOCKER_CLIENT_TIMEOUT, 10);
+    return options;
+}
+/**
+ * The query string of the parameters of a request
+ * @param query
+ */
+function queryString(query = {}) {
+    const parameters = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            value.forEach((item) => parameters.append(key, String(item)));
+        }
+        else if (typeof value === 'object') {
+            parameters.append(key, JSON.stringify(value));
+        }
+        else {
+            parameters.append(key, String(value));
+        }
+    }
+    const text = parameters.toString();
+    return text ? `?${text}` : '';
+}
+/**
+ * Whether a body is a stream
+ * @param body
+ */
+function isStream(body) {
+    return !!body && typeof body.pipe === 'function';
+}
+/**
+ * The connection to a Docker daemon
+ */
+class DockerConnection {
+    #options;
+    #protocol;
+    /**
+     * The agent of the requests: the connections are kept alive
+     */
+    #agent;
+    /**
+     * The agent of the requests streaming their body: their connections are closed after them. Docker answers a build
+     * while it reads its context: on a kept alive connection, its HTTP server discards a part of the unread body when it
+     * answers, which corrupts the context ("unpigz: corrupted -- invalid deflate data")
+     */
+    #closingAgent;
+    /**
+     * The negotiated API version
+     */
+    #version;
+    #sshAgent;
+    constructor(options = {}) {
+        //The options given (a timeout, headers…) apply over the ones of the environment, the ones not given keep them
+        const given = Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+        this.#options = given.socketPath || given.host ? given : { ...defaultConnectionOptions(), ...given };
+        this.#protocol = this.#options.protocol ?? (this.#options.key && this.#options.cert && this.#options.ca ? 'https' : 'http');
+        if (this.#options.version)
+            this.#version = this.#options.version.replace(/^v/, '');
+        if (this.#protocol !== 'ssh') {
+            const module = this.#protocol === 'https' ? node_https_1.default : node_http_1.default;
+            this.#agent = new module.Agent({ keepAlive: true });
+            this.#closingAgent = new module.Agent({ keepAlive: false });
+        }
+    }
+    /**
+     * The API version of the requests, once negotiated
+     */
+    get version() {
+        return this.#version;
+    }
+    /**
+     * Negotiate the API version with the daemon: the newest one both support
+     */
+    async negotiate() {
+        if (this.#version)
+            return this.#version;
+        const version = await this.request({ method: 'GET', path: '/version', statusCodes: { 200: true, 500: 'server error' } });
+        const daemon = version.ApiVersion ?? exports.DOCKER_MIN_API_VERSION;
+        let negotiated = compareAPIVersions(daemon, exports.DOCKER_API_VERSION) < 0 ? daemon : exports.DOCKER_API_VERSION;
+        //The daemon no longer supports the version of the client
+        if (version.MinAPIVersion && compareAPIVersions(negotiated, version.MinAPIVersion) < 0)
+            negotiated = version.MinAPIVersion;
+        this.#version = negotiated;
+        return negotiated;
+    }
+    /**
+     * The agent of an SSH connection: the requests are sent to "docker system dial-stdio" (ssh2, an optional dependency)
+     */
+    sshAgent() {
+        return this.#sshAgent ??= (async () => {
+            let ssh2;
+            try {
+                //An optional dependency, loaded where it is installed
+                const ssh2Module = 'ssh2';
+                ssh2 = await Promise.resolve(`${ssh2Module}`).then(s => __importStar(require(s)));
+            }
+            catch {
+                throw new Error('The SSH connections to Docker need the package ssh2: npm install ssh2');
+            }
+            const Client = ssh2.Client ?? ssh2.default?.Client;
+            const agent = new node_http_1.default.Agent();
+            const options = this.#options;
+            agent.createConnection = ((_, callback) => {
+                const client = new Client();
+                const fail = (error) => {
+                    client.end();
+                    callback(error);
+                };
+                client.once('ready', () => {
+                    client.exec('docker system dial-stdio', (error, stream) => {
+                        if (error)
+                            return fail(error);
+                        callback(null, stream);
+                        stream.once('close', () => client.end());
+                    });
+                }).once('error', fail).connect({
+                    host: options.host,
+                    port: Number(options.port ?? 22),
+                    username: options.username,
+                    password: options.password,
+                    agent: options.sshAuthAgent ?? process.env.SSH_AUTH_SOCK
+                });
+            });
+            return agent;
+        })();
+    }
+    /**
+     * The options of a request
+     * @param request
+     * @param streamingBody
+     */
+    async requestOptions(request, streamingBody) {
+        const headers = { ...this.#options.headers, ...request.headers };
+        if (request.auth)
+            headers['X-Registry-Auth'] = Buffer.from(JSON.stringify(request.auth)).toString('base64url');
+        if (request.registryConfig)
+            headers['X-Registry-Config'] = Buffer.from(JSON.stringify(request.registryConfig)).toString('base64');
+        const versioned = this.#version ? `/v${this.#version}${request.path}` : request.path;
+        const options = {
+            method: request.method,
+            path: `${versioned}${queryString(request.query)}`,
+            headers: headers,
+            signal: request.signal,
+            timeout: this.#options.timeout
+        };
+        if (this.#protocol === 'ssh') {
+            options.agent = await this.sshAgent();
+            options.host = 'localhost';
+        }
+        else {
+            options.agent = streamingBody ? this.#closingAgent : this.#agent;
+            if (this.#options.socketPath) {
+                options.socketPath = this.#options.socketPath;
+            }
+            else {
+                options.host = this.#options.host;
+                options.port = this.#options.port;
+            }
+            if (this.#protocol === 'https')
+                Object.assign(options, { ca: this.#options.ca, cert: this.#options.cert, key: this.#options.key });
+        }
+        return options;
+    }
+    /**
+     * Send a request: the response, once its status is known
+     * @param request
+     * @param hijack upgrade the connection to a raw stream (the TTYs, the attached executions)
+     */
+    async send(request, hijack = false) {
+        const streamingBody = isStream(request.body);
+        const options = await this.requestOptions(request, streamingBody);
+        const headers = options.headers;
+        let payload;
+        if (request.body !== undefined && !streamingBody) {
+            payload = JSON.stringify(request.body);
+            headers['Content-Type'] = 'application/json';
+            headers['Content-Length'] = String(Buffer.byteLength(payload));
+        }
+        else if (streamingBody) {
+            headers['Content-Type'] = 'application/x-tar';
+        }
+        if (hijack) {
+            headers.Connection = 'Upgrade';
+            headers.Upgrade = 'tcp';
+        }
+        const module = this.#protocol === 'https' ? node_https_1.default : node_http_1.default;
+        return new Promise((resolve, reject) => {
+            const req = module.request(options);
+            req.once('error', reject);
+            req.once('timeout', () => req.destroy(new Error(`Timeout of ${this.#options.timeout} ms exceeded`)));
+            if (hijack) {
+                req.once('upgrade', (response, socket, head) => {
+                    if (head.length)
+                        socket.unshift(head);
+                    resolve({ response: response, socket: socket, request: req });
+                });
+            }
+            req.once('response', (response) => resolve({ response: response, request: req }));
+            if (streamingBody) {
+                const body = request.body;
+                //An error of the body (the packing of a build context) fails the request, instead of ending its stream
+                body.once('error', (error) => req.destroy(error));
+                body.pipe(req);
+            }
+            else {
+                req.end(payload);
+            }
+        });
+    }
+    /**
+     * The error of a failed response
+     * @param request
+     * @param response
+     */
+    async failure(request, response) {
+        const text = Buffer.concat(await response.toArray()).toString();
+        let json;
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            json = undefined;
+        }
+        const reason = typeof request.statusCodes[response.statusCode] === 'string' ? request.statusCodes[response.statusCode] : 'unexpected';
+        return new DockerRequestError_js_1.DockerRequestError(response.statusCode, reason, json?.message ?? text.trim(), json);
+    }
+    /**
+     * A request whose response is JSON (or nothing)
+     * @param request
+     */
+    async request(request) {
+        const { response } = await this.send(request);
+        if (request.statusCodes[response.statusCode] !== true)
+            throw await this.failure(request, response);
+        const text = Buffer.concat(await response.toArray()).toString();
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    /**
+     * A request whose response is a stream (the progress of a pull, the logs, an archive)
+     * @param request
+     */
+    async stream(request) {
+        const { response } = await this.send(request);
+        if (request.statusCodes[response.statusCode] !== true)
+            throw await this.failure(request, response);
+        return response;
+    }
+    /**
+     * A request upgraded to a raw stream, read and written (the TTYs, the attached executions)
+     * @param request
+     */
+    async hijack(request) {
+        const { response, socket } = await this.send(request, true);
+        if (socket)
+            return socket;
+        if (request.statusCodes[response.statusCode] !== true)
+            throw await this.failure(request, response);
+        //A daemon answering without upgrading: its response is the output, what is written is discarded
+        return node_stream_1.Duplex.from({ readable: response, writable: new node_stream_1.Writable({ write: (_chunk, _encoding, callback) => callback() }) });
+    }
+    /**
+     * Close the kept alive connections
+     */
+    close() {
+        this.#agent?.destroy();
+        this.#closingAgent?.destroy();
+        this.#sshAgent?.then((agent) => agent.destroy()).catch(() => undefined);
+    }
+}
+exports.DockerConnection = DockerConnection;

package/dist/cjs/client/DockerIgnore.d.ts

@@ -0,0 +1,44 @@
+type DockerIgnoreRule = {
+    pattern: string;
+    directories: string[];
+    negative: boolean;
+    expression?: RegExp;
+};
+/**
+ * The rules of a .dockerignore file: the files of a build context they exclude
+ */
+export declare class DockerIgnore {
+    #private;
+    protected readonly ignoreCase: boolean;
+    /**
+     * @param content the content of a .dockerignore file
+     * @param ignoreCase match the case-insensitively, as Docker does not (false by default)
+     */
+    constructor(content?: string, ignoreCase?: boolean);
+    /**
+     * Add the rules of a content
+     * @param content
+     */
+    add(content: string): this;
+    /**
+     * A rule of a line (moby/moby builder/dockerignore/dockerignore.go and pkg/fileutils/fileutils.go)
+     * @param line
+     */
+    protected rule(line: string): DockerIgnoreRule | undefined;
+    /**
+     * The regular expression of a rule (fileutils.go regexpMatch)
+     * @param rule
+     */
+    protected expression(rule: DockerIgnoreRule): RegExp;
+    /**
+     * Whether a file of the context is excluded by the rules (its path relative to the context, "/" separated)
+     * @param file
+     */
+    ignores(file: string): boolean;
+    /**
+     * Whether a file is excluded: the last rule matching it or one of its parent directories decides
+     * @param file
+     */
+    protected test(file: string): boolean;
+}
+export {};

package/dist/cjs/client/DockerIgnore.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerIgnore = void 0;
+/*
+ * The rules of the .dockerignore files, rewritten from @balena/dockerignore (Copyright 2020 Balena Ltd., Apache License
+ * 2.0, and Copyright 2018 Zeit, Inc., MIT License, see THIRD_PARTY_NOTICES.md), which follows the implementation of
+ * Docker (moby/moby builder/dockerignore and pkg/fileutils)
+ */
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * The separators of the paths of the platform: on Windows, "/" and "\" separate the paths and "\" does not escape
+ */
+const SEPARATOR = node_path_1.default.sep;
+/**
+ * filepath.Clean of Go
+ * @param file
+ */
+function cleanPath(file) {
+    return node_path_1.default.normalize(file).replace(SEPARATOR === '\\' ? /(?<=.)\\$/ : /(?<=.)\/$/, '');
+}
+/**
+ * filepath.ToSlash of Go
+ * @param file
+ */
+function toSlash(file) {
+    return SEPARATOR === '/' ? file : file.replace(/\\/g, '/');
+}
+/**
+ * filepath.FromSlash of Go
+ * @param file
+ */
+function fromSlash(file) {
+    return SEPARATOR === '/' ? file : file.replace(/\//g, SEPARATOR);
+}
+/**
+ * The rules of a .dockerignore file: the files of a build context they exclude
+ */
+class DockerIgnore {
+    #rules = [];
+    #cache = new Map();
+    /**
+     * @param content the content of a .dockerignore file
+     * @param ignoreCase match the case-insensitively, as Docker does not (false by default)
+     */
+    constructor(content = '', ignoreCase = false) {
+        this.ignoreCase = ignoreCase;
+        this.add(content);
+    }
+    /**
+     * Add the rules of a content
+     * @param content
+     */
+    add(content) {
+        for (const line of content.split(/\r?\n/)) {
+            if (!line.trim() || line.startsWith('#'))
+                continue;
+            const rule = this.rule(line.trim());
+            if (rule)
+                this.#rules.push(rule);
+        }
+        this.#cache.clear();
+        return this;
+    }
+    /**
+     * A rule of a line (moby/moby builder/dockerignore/dockerignore.go and pkg/fileutils/fileutils.go)
+     * @param line
+     */
+    rule(line) {
+        let pattern = line;
+        let negative = false;
+        if (pattern.startsWith('!')) {
+            negative = true;
+            pattern = pattern.substring(1).trim();
+        }
+        if (pattern.length > 0) {
+            pattern = toSlash(cleanPath(pattern));
+            if (pattern.length > 1 && pattern.startsWith('/'))
+                pattern = pattern.slice(1);
+        }
+        if (negative)
+            pattern = `!${pattern}`;
+        pattern = pattern.trim();
+        if (!pattern)
+            return undefined;
+        pattern = cleanPath(pattern);
+        if (pattern.startsWith('!')) {
+            if (pattern.length === 1)
+                return undefined;
+            negative = true;
+            pattern = pattern.substring(1);
+        }
+        else {
+            negative = false;
+        }
+        return { pattern: pattern, directories: pattern.split(SEPARATOR), negative: negative };
+    }
+    /**
+     * The regular expression of a rule (fileutils.go regexpMatch)
+     * @param rule
+     */
+    expression(rule) {
+        if (rule.expression)
+            return rule.expression;
+        const separator = SEPARATOR === '\\' ? '\\\\' : SEPARATOR;
+        let source = '^';
+        const pattern = rule.pattern;
+        for (let index = 0; index < pattern.length; index++) {
+            const character = pattern[index];
+            if (character === '*') {
+                if (pattern[index + 1] === '*') {
+                    index++;
+                    //"**/" is "**"
+                    if (pattern[index + 1] === SEPARATOR)
+                        index++;
+                    source += pattern[index + 1] === undefined ? '.*' : `(.*${separator})?`;
+                }
+                else {
+                    source += `[^${separator}]*`;
+                }
+            }
+            else if (character === '?') {
+                source += `[^${separator}]`;
+            }
+            else if (character === '.' || character === '$') {
+                source += `\\${character}`;
+            }
+            else if (character === '\\') {
+                if (SEPARATOR === '\\') {
+                    source += separator;
+                }
+                else if (pattern[index + 1] !== undefined) {
+                    source += `\\${pattern[++index]}`;
+                }
+                else {
+                    source += '\\';
+                }
+            }
+            else {
+                source += character;
+            }
+        }
+        return rule.expression = new RegExp(`${source}$`, this.ignoreCase ? 'i' : '');
+    }
+    /**
+     * Whether a file of the context is excluded by the rules (its path relative to the context, "/" separated)
+     * @param file
+     */
+    ignores(file) {
+        if (!file)
+            return true;
+        let ignored = this.#cache.get(file);
+        if (ignored === undefined)
+            this.#cache.set(file, ignored = this.test(file));
+        return ignored;
+    }
+    /**
+     * Whether a file is excluded: the last rule matching it or one of its parent directories decides
+     * @param file
+     */
+    test(file) {
+        const local = fromSlash(file);
+        const parent = cleanPath(node_path_1.default.dirname(local));
+        const parentDirectories = parent.split(SEPARATOR);
+        let matched = false;
+        for (const rule of this.#rules) {
+            let match = this.expression(rule).test(local);
+            if (!match && parent !== '.') {
+                if (rule.directories.includes('**')) {
+                    for (let index = rule.directories.filter((directory) => directory !== '**').length; index <= parentDirectories.length; index++) {
+                        match = match || this.expression(rule).test(parentDirectories.slice(0, index).join(SEPARATOR));
+                    }
+                }
+                else if (rule.directories.length <= parentDirectories.length) {
+                    match = this.expression(rule).test(parentDirectories.slice(0, rule.directories.length).join(SEPARATOR));
+                }
+            }
+            if (match)
+                matched = !rule.negative;
+        }
+        return matched;
+    }
+}
+exports.DockerIgnore = DockerIgnore;

package/dist/cjs/client/DockerRequestError.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A request to the Docker Engine API which failed: its message is the one of docker-modem, "(HTTP code 404) no such
+ * container - No such container: x", the status and the body of the response are given
+ */
+export declare class DockerRequestError extends Error {
+    readonly statusCode: number;
+    readonly reason: string;
+    readonly detail: string;
+    readonly json?: unknown | undefined;
+    /**
+     * @param statusCode the status of the response
+     * @param reason the meaning of the status for the request
+     * @param detail the message of the daemon
+     * @param json the body of the response
+     */
+    constructor(statusCode: number, reason: string, detail: string, json?: unknown | undefined);
+}

package/dist/cjs/client/DockerRequestError.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerRequestError = void 0;
+/**
+ * A request to the Docker Engine API which failed: its message is the one of docker-modem, "(HTTP code 404) no such
+ * container - No such container: x", the status and the body of the response are given
+ */
+class DockerRequestError extends Error {
+    /**
+     * @param statusCode the status of the response
+     * @param reason the meaning of the status for the request
+     * @param detail the message of the daemon
+     * @param json the body of the response
+     */
+    constructor(statusCode, reason, detail, json) {
+        super(`(HTTP code ${statusCode}) ${reason} - ${detail} `);
+        this.statusCode = statusCode;
+        this.reason = reason;
+        this.detail = detail;
+        this.json = json;
+        this.name = 'DockerRequestError';
+    }
+}
+exports.DockerRequestError = DockerRequestError;