artifact-engine 1.2.0 → 1.3.0

package/Providers/webClientFactory.js

@@ -1,55 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebClientFactory = void 0;
-const fs = require("fs");
-const crypto = require("crypto");
-const webClient_1 = require("./webClient");
-class WebClientFactory {
-    static getClient(handlers, options) {
-        options = options || {};
-        options.keepAlive = true;
-        this.initializeProxy(options);
-        return new webClient_1.WebClient(handlers, options);
-    }
-    static initializeProxy(options) {
-        if (!options.proxy || !options.proxy.proxyUrl) {
-            if (global['_vsts_task_lib_proxy']) {
-                let proxyFromEnv = {
-                    proxyUrl: global['_vsts_task_lib_proxy_url'],
-                    proxyUsername: global['_vsts_task_lib_proxy_username'],
-                    proxyPassword: this._readTaskLibSecrets(global['_vsts_task_lib_proxy_password']),
-                    proxyBypassHosts: JSON.parse(global['_vsts_task_lib_proxy_bypass'] || "[]"),
-                };
-                options.proxy = proxyFromEnv;
-            }
-        }
-        if (!options.cert) {
-            if (global['_vsts_task_lib_cert']) {
-                let certFromEnv = {
-                    caFile: global['_vsts_task_lib_cert_ca'],
-                    certFile: global['_vsts_task_lib_cert_clientcert'],
-                    keyFile: global['_vsts_task_lib_cert_key'],
-                    passphrase: this._readTaskLibSecrets(global['_vsts_task_lib_cert_passphrase']),
-                };
-                options.cert = certFromEnv;
-            }
-        }
-        if (!options.ignoreSslError) {
-            options.ignoreSslError = !!global['_vsts_task_lib_skip_cert_validation'];
-        }
-    }
-    static _readTaskLibSecrets(lookupKey) {
-        if (lookupKey && lookupKey.indexOf(':') > 0) {
-            let lookupInfo = lookupKey.split(':', 2);
-            let keyFile = new Buffer(lookupInfo[0], 'base64').toString('utf8');
-            let encryptKey = new Buffer(fs.readFileSync(keyFile, 'utf8'), 'base64');
-            let encryptedContent = new Buffer(lookupInfo[1], 'base64').toString('utf8');
-            let decipher = crypto.createDecipher("aes-256-ctr", encryptKey);
-            let decryptedContent = decipher.update(encryptedContent, 'hex', 'utf8');
-            decryptedContent += decipher.final('utf8');
-            return decryptedContent;
-        }
-    }
-}
-exports.WebClientFactory = WebClientFactory;
-//# sourceMappingURL=webClientFactory.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const crypto = require("crypto");
+const webClient_1 = require("./webClient");
+class WebClientFactory {
+    static getClient(handlers, options) {
+        options = options || {};
+        options.keepAlive = true;
+        this.initializeProxy(options);
+        return new webClient_1.WebClient(handlers, options);
+    }
+    static initializeProxy(options) {
+        // try get proxy setting from environment variable set by azure-pipelines-task-lib if there is no proxy setting in the options
+        if (!options.proxy || !options.proxy.proxyUrl) {
+            if (global['_vsts_task_lib_proxy']) {
+                let proxyFromEnv = {
+                    proxyUrl: global['_vsts_task_lib_proxy_url'],
+                    proxyUsername: global['_vsts_task_lib_proxy_username'],
+                    proxyPassword: this._readTaskLibSecrets(global['_vsts_task_lib_proxy_password']),
+                    proxyBypassHosts: JSON.parse(global['_vsts_task_lib_proxy_bypass'] || "[]"),
+                };
+                options.proxy = proxyFromEnv;
+            }
+        }
+        // try get cert setting from environment variable set by azure-pipelines-task-lib if there is no cert setting in the options
+        if (!options.cert) {
+            if (global['_vsts_task_lib_cert']) {
+                let certFromEnv = {
+                    caFile: global['_vsts_task_lib_cert_ca'],
+                    certFile: global['_vsts_task_lib_cert_clientcert'],
+                    keyFile: global['_vsts_task_lib_cert_key'],
+                    passphrase: this._readTaskLibSecrets(global['_vsts_task_lib_cert_passphrase']),
+                };
+                options.cert = certFromEnv;
+            }
+        }
+        // try get ignore SSL error setting from environment variable set by azure-pipelines-task-lib if there is no ignore SSL error setting in the options
+        if (!options.ignoreSslError) {
+            options.ignoreSslError = !!global['_vsts_task_lib_skip_cert_validation'];
+        }
+    }
+    static _readTaskLibSecrets(lookupKey) {
+        // the lookupKey should has following format
+        // base64encoded<keyFilePath>:base64encoded<encryptedContent>
+        if (lookupKey && lookupKey.indexOf(':') > 0) {
+            let lookupInfo = lookupKey.split(':', 2);
+            // file contains encryption key
+            let keyFile = new Buffer(lookupInfo[0], 'base64').toString('utf8');
+            let encryptKey = new Buffer(fs.readFileSync(keyFile, 'utf8'), 'base64');
+            let encryptedContent = new Buffer(lookupInfo[1], 'base64').toString('utf8');
+            let decipher = crypto.createDecipher("aes-256-ctr", encryptKey);
+            let decryptedContent = decipher.update(encryptedContent, 'hex', 'utf8');
+            decryptedContent += decipher.final('utf8');
+            return decryptedContent;
+        }
+    }
+}
+exports.WebClientFactory = WebClientFactory;

package/Providers/webProvider.d.ts

@@ -1,22 +1,21 @@
-/// <reference types="node" />
-import * as stream from 'stream';
-import { ArtifactItem, IArtifactProvider } from '../Models';
-import { ArtifactItemStore } from '../Store/artifactItemStore';
-import { WebClient } from './webClient';
-import { IRequestHandler, IRequestOptions } from './typed-rest-client/Interfaces';
-export declare class WebProvider implements IArtifactProvider {
-    artifactItemStore: ArtifactItemStore;
-    constructor(rootItemsLocation: any, templateFile: string, variables: any, handler: IRequestHandler, requestOptions?: IRequestOptions);
-    getRootItems(): Promise<ArtifactItem[]>;
-    getArtifactItems(artifactItem: ArtifactItem): Promise<ArtifactItem[]>;
-    getArtifactItem(artifactItem: ArtifactItem): Promise<NodeJS.ReadableStream>;
-    putArtifactItem(item: ArtifactItem, readStream: stream.Readable): Promise<ArtifactItem>;
-    dispose(): void;
-    private getItems;
-    private getTemplateFilePath;
-    private extend;
-    private rootItemsLocation;
-    private templateFile;
-    private variables;
-    webClient: WebClient;
-}
+import * as stream from 'stream';
+import { ArtifactItem, IArtifactProvider } from '../Models';
+import { ArtifactItemStore } from '../Store/artifactItemStore';
+import { WebClient } from './webClient';
+import { IRequestHandler, IRequestOptions } from './typed-rest-client/Interfaces';
+export declare class WebProvider implements IArtifactProvider {
+    artifactItemStore: ArtifactItemStore;
+    constructor(rootItemsLocation: any, templateFile: string, variables: any, handler: IRequestHandler, requestOptions?: IRequestOptions);
+    getRootItems(): Promise<ArtifactItem[]>;
+    getArtifactItems(artifactItem: ArtifactItem): Promise<ArtifactItem[]>;
+    getArtifactItem(artifactItem: ArtifactItem): Promise<NodeJS.ReadableStream>;
+    putArtifactItem(item: ArtifactItem, readStream: stream.Readable): Promise<ArtifactItem>;
+    dispose(): void;
+    private getItems(itemsUrl, contentType);
+    private getTemplateFilePath();
+    private extend(target, source);
+    private rootItemsLocation;
+    private templateFile;
+    private variables;
+    webClient: WebClient;
+}

package/Providers/webProvider.js

@@ -1,116 +1,120 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebProvider = void 0;
-const fs = require("fs");
-const path = require("path");
-const zlib = require("zlib");
-const Models_1 = require("../Models");
-const logger_1 = require("../Engine/logger");
-const webClientFactory_1 = require("./webClientFactory");
-var handlebars = require('handlebars');
-var tl = require('azure-pipelines-task-lib/task');
-class WebProvider {
-    constructor(rootItemsLocation, templateFile, variables, handler, requestOptions) {
-        this.rootItemsLocation = rootItemsLocation;
-        this.templateFile = templateFile;
-        this.webClient = webClientFactory_1.WebClientFactory.getClient([handler], requestOptions);
-        this.variables = variables;
-    }
-    getRootItems() {
-        var rootItem = new Models_1.ArtifactItem();
-        rootItem.metadata = { downloadUrl: this.rootItemsLocation };
-        rootItem.path = '';
-        rootItem.itemType = Models_1.ItemType.Folder;
-        return Promise.resolve([rootItem]);
-    }
-    getArtifactItems(artifactItem) {
-        var itemsUrl = artifactItem.metadata["downloadUrl"];
-        var contentType = artifactItem.contentType;
-        return this.getItems(itemsUrl, contentType);
-    }
-    getArtifactItem(artifactItem) {
-        var promise = new Promise((resolve, reject) => {
-            if (!artifactItem.metadata || !artifactItem.metadata['downloadUrl']) {
-                reject("No downloadUrl available to download the item.");
-            }
-            var downloadSize = 0;
-            var contentType = artifactItem.contentType;
-            var itemUrl = artifactItem.metadata['downloadUrl'];
-            itemUrl = itemUrl.replace(/([^:]\/)\/+/g, "$1");
-            this.webClient.get(itemUrl, contentType ? { 'Accept': contentType } : undefined).then((res) => {
-                res.message.on('data', (chunk) => {
-                    downloadSize += chunk.length;
-                });
-                res.message.on('end', () => {
-                    this.artifactItemStore.updateDownloadSize(artifactItem, downloadSize);
-                });
-                res.message.on('error', (error) => {
-                    reject(error);
-                });
-                if (res.message.headers['content-encoding'] === 'gzip') {
-                    try {
-                        resolve(res.message.pipe(zlib.createUnzip()));
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                }
-                else {
-                    resolve(res.message);
-                }
-            }, (reason) => {
-                reject(reason);
-            });
-        });
-        return promise;
-    }
-    putArtifactItem(item, readStream) {
-        throw new Error("Not implemented");
-    }
-    dispose() {
-        this.webClient.dispose();
-    }
-    getItems(itemsUrl, contentType) {
-        var promise = new Promise((resolve, reject) => {
-            itemsUrl = itemsUrl.replace(/([^:]\/)\/+/g, "$1");
-            this.webClient.get(itemsUrl, contentType ? { 'Accept': contentType } : { 'Accept': 'application/json' }).then((res) => {
-                res.readBody().then((body) => {
-                    fs.readFile(this.getTemplateFilePath(), 'utf8', (err, templateFileContent) => {
-                        if (err) {
-                            logger_1.Logger.logMessage(err ? JSON.stringify(err) : "");
-                            reject(err);
-                        }
-                        try {
-                            var template = handlebars.compile(templateFileContent);
-                            var response = JSON.parse(body);
-                            var context = this.extend(response, this.variables);
-                            var result = template(context);
-                            var items = JSON.parse(result);
-                            resolve(items);
-                        }
-                        catch (error) {
-                            logger_1.Logger.logMessage(tl.loc("FailedToParseResponse", body, error));
-                            reject(error);
-                        }
-                    });
-                }, (err) => {
-                    reject(err);
-                });
-            }, (err) => {
-                reject(err);
-            });
-        });
-        return promise;
-    }
-    getTemplateFilePath() {
-        return path.isAbsolute(this.templateFile) ? this.templateFile : path.join(__dirname, this.templateFile);
-    }
-    extend(target, source) {
-        for (var prop in source) {
-            target[prop] = source[prop];
-        }
-        return target;
-    }
-}
-exports.WebProvider = WebProvider;
-//# sourceMappingURL=webProvider.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const zlib = require("zlib");
+const Models_1 = require("../Models");
+const logger_1 = require("../Engine/logger");
+const webClientFactory_1 = require("./webClientFactory");
+var handlebars = require('handlebars');
+var tl = require('azure-pipelines-task-lib/task');
+class WebProvider {
+    constructor(rootItemsLocation, templateFile, variables, handler, requestOptions) {
+        this.rootItemsLocation = rootItemsLocation;
+        this.templateFile = templateFile;
+        this.webClient = webClientFactory_1.WebClientFactory.getClient([handler], requestOptions);
+        this.variables = variables;
+    }
+    getRootItems() {
+        var rootItem = new Models_1.ArtifactItem();
+        rootItem.metadata = { downloadUrl: this.rootItemsLocation };
+        rootItem.path = '';
+        rootItem.itemType = Models_1.ItemType.Folder;
+        return Promise.resolve([rootItem]);
+    }
+    getArtifactItems(artifactItem) {
+        var itemsUrl = artifactItem.metadata["downloadUrl"];
+        var contentType = artifactItem.contentType;
+        return this.getItems(itemsUrl, contentType);
+    }
+    getArtifactItem(artifactItem) {
+        var promise = new Promise((resolve, reject) => {
+            if (!artifactItem.metadata || !artifactItem.metadata['downloadUrl']) {
+                reject("No downloadUrl available to download the item.");
+            }
+            var downloadSize = 0;
+            var contentType = artifactItem.contentType;
+            var itemUrl = artifactItem.metadata['downloadUrl'];
+            var zipStream = null;
+            itemUrl = itemUrl.replace(/([^:]\/)\/+/g, "$1");
+            this.webClient.get(itemUrl, contentType ? { 'Accept': contentType } : undefined).then((res) => {
+                res.message.on('data', (chunk) => {
+                    downloadSize += chunk.length;
+                });
+                res.message.on('end', () => {
+                    this.artifactItemStore.updateDownloadSize(artifactItem, downloadSize);
+                });
+                res.message.on('error', (error) => {
+                    if (zipStream) {
+                        zipStream.destroy(error);
+                        logger_1.Logger.logMessage(error);
+                    }
+                    reject(error);
+                });
+                if (res.message.headers['content-encoding'] === 'gzip') {
+                    try {
+                        zipStream = zlib.createUnzip();
+                        resolve(res.message.pipe(zipStream));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }
+                else {
+                    resolve(res.message);
+                }
+            }, (reason) => {
+                reject(reason);
+            });
+        });
+        return promise;
+    }
+    putArtifactItem(item, readStream) {
+        throw new Error("Not implemented");
+    }
+    dispose() {
+        this.webClient.dispose();
+    }
+    getItems(itemsUrl, contentType) {
+        var promise = new Promise((resolve, reject) => {
+            itemsUrl = itemsUrl.replace(/([^:]\/)\/+/g, "$1");
+            this.webClient.get(itemsUrl, contentType ? { 'Accept': contentType } : { 'Accept': 'application/json' }).then((res) => {
+                res.readBody().then((body) => {
+                    fs.readFile(this.getTemplateFilePath(), 'utf8', (err, templateFileContent) => {
+                        if (err) {
+                            logger_1.Logger.logMessage(err ? JSON.stringify(err) : "");
+                            reject(err);
+                        }
+                        try {
+                            var template = handlebars.compile(templateFileContent);
+                            var response = JSON.parse(body);
+                            var context = this.extend(response, this.variables);
+                            var result = template(context);
+                            var items = JSON.parse(result);
+                            resolve(items);
+                        }
+                        catch (error) {
+                            logger_1.Logger.logMessage(tl.loc("FailedToParseResponse", body, error));
+                            reject(error);
+                        }
+                    });
+                }, (err) => {
+                    reject(err);
+                });
+            }, (err) => {
+                reject(err);
+            });
+        });
+        return promise;
+    }
+    getTemplateFilePath() {
+        return path.isAbsolute(this.templateFile) ? this.templateFile : path.join(__dirname, this.templateFile);
+    }
+    extend(target, source) {
+        for (var prop in source) {
+            target[prop] = source[prop];
+        }
+        return target;
+    }
+}
+exports.WebProvider = WebProvider;

package/Providers/zipProvider.d.ts

@@ -1,16 +1,15 @@
-/// <reference types="node" />
-import { ArtifactItemStore } from '../Store/artifactItemStore';
-import { ArtifactItem, IArtifactProvider } from '../Models';
-import { WebClient } from './webClient';
-import { IRequestHandler, IRequestOptions } from './typed-rest-client/Interfaces';
-export declare class ZipProvider implements IArtifactProvider {
-    artifactItemStore: ArtifactItemStore;
-    constructor(zipLocation: any, handler: IRequestHandler, requestOptions?: IRequestOptions);
-    getRootItems(): Promise<ArtifactItem[]>;
-    getArtifactItems(artifactItem: ArtifactItem): Promise<ArtifactItem[]>;
-    getArtifactItem(artifactItem: ArtifactItem): Promise<NodeJS.ReadableStream>;
-    putArtifactItem(artifactItem: ArtifactItem, stream: NodeJS.ReadableStream): Promise<ArtifactItem>;
-    dispose(): void;
-    private zipLocation;
-    webClient: WebClient;
-}
+import { ArtifactItemStore } from '../Store/artifactItemStore';
+import { ArtifactItem, IArtifactProvider } from '../Models';
+import { WebClient } from './webClient';
+import { IRequestHandler, IRequestOptions } from './typed-rest-client/Interfaces';
+export declare class ZipProvider implements IArtifactProvider {
+    artifactItemStore: ArtifactItemStore;
+    constructor(zipLocation: any, handler: IRequestHandler, requestOptions?: IRequestOptions);
+    getRootItems(): Promise<ArtifactItem[]>;
+    getArtifactItems(artifactItem: ArtifactItem): Promise<ArtifactItem[]>;
+    getArtifactItem(artifactItem: ArtifactItem): Promise<NodeJS.ReadableStream>;
+    putArtifactItem(artifactItem: ArtifactItem, stream: NodeJS.ReadableStream): Promise<ArtifactItem>;
+    dispose(): void;
+    private zipLocation;
+    webClient: WebClient;
+}

package/Providers/zipProvider.js

@@ -1,55 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZipProvider = void 0;
-const Models_1 = require("../Models");
-const factory = require("./webClientFactory");
-class ZipProvider {
-    constructor(zipLocation, handler, requestOptions) {
-        this.zipLocation = zipLocation;
-        this.webClient = factory.WebClientFactory.getClient([handler], requestOptions);
-    }
-    getRootItems() {
-        var rootItem = new Models_1.ArtifactItem();
-        rootItem.metadata = { downloadUrl: this.zipLocation };
-        rootItem.path = '';
-        rootItem.itemType = Models_1.ItemType.File;
-        return Promise.resolve([rootItem]);
-    }
-    getArtifactItems(artifactItem) {
-        return null;
-    }
-    getArtifactItem(artifactItem) {
-        var promise = new Promise((resolve, reject) => {
-            if (!artifactItem.metadata || !artifactItem.metadata['downloadUrl']) {
-                reject("No downloadUrl available to download the item.");
-            }
-            var downloadSize = 0;
-            var itemUrl = artifactItem.metadata['downloadUrl'];
-            itemUrl = itemUrl.replace(/([^:]\/)\/+/g, "$1");
-            this.webClient.get(itemUrl).then((res) => {
-                res.message.on('data', (chunk) => {
-                    if (chunk) {
-                        downloadSize += chunk.length;
-                    }
-                });
-                res.message.on('end', () => {
-                    this.artifactItemStore.updateDownloadSize(artifactItem, downloadSize);
-                });
-                res.message.on('error', (error) => {
-                    reject(error);
-                });
-                resolve(res.message);
-            }, (reason) => {
-                reject(reason);
-            });
-        });
-        return promise;
-    }
-    putArtifactItem(artifactItem, stream) {
-        return null;
-    }
-    dispose() {
-    }
-}
-exports.ZipProvider = ZipProvider;
-//# sourceMappingURL=zipProvider.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Models_1 = require("../Models");
+const factory = require("./webClientFactory");
+class ZipProvider {
+    constructor(zipLocation, handler, requestOptions) {
+        this.zipLocation = zipLocation;
+        this.webClient = factory.WebClientFactory.getClient([handler], requestOptions);
+    }
+    getRootItems() {
+        var rootItem = new Models_1.ArtifactItem();
+        rootItem.metadata = { downloadUrl: this.zipLocation };
+        rootItem.path = '';
+        rootItem.itemType = Models_1.ItemType.File;
+        return Promise.resolve([rootItem]);
+    }
+    getArtifactItems(artifactItem) {
+        return null;
+    }
+    getArtifactItem(artifactItem) {
+        var promise = new Promise((resolve, reject) => {
+            if (!artifactItem.metadata || !artifactItem.metadata['downloadUrl']) {
+                reject("No downloadUrl available to download the item.");
+            }
+            var downloadSize = 0;
+            var itemUrl = artifactItem.metadata['downloadUrl'];
+            itemUrl = itemUrl.replace(/([^:]\/)\/+/g, "$1");
+            this.webClient.get(itemUrl).then((res) => {
+                res.message.on('data', (chunk) => {
+                    if (chunk) {
+                        downloadSize += chunk.length;
+                    }
+                });
+                res.message.on('end', () => {
+                    this.artifactItemStore.updateDownloadSize(artifactItem, downloadSize);
+                });
+                res.message.on('error', (error) => {
+                    reject(error);
+                });
+                resolve(res.message);
+            }, (reason) => {
+                reject(reason);
+            });
+        });
+        return promise;
+    }
+    putArtifactItem(artifactItem, stream) {
+        return null;
+    }
+    dispose() {
+    }
+}
+exports.ZipProvider = ZipProvider;

package/Store/artifactItemStore.d.ts

@@ -1,18 +1,18 @@
-import * as models from "../Models";
-export declare class ArtifactItemStore {
-    _downloadTickets: models.ArtifactDownloadTicket[];
-    _hasDownloadFailed: boolean;
-    addItem(item: models.ArtifactItem): void;
-    addItems(items: models.ArtifactItem[]): void;
-    getTickets(): models.ArtifactDownloadTicket[];
-    itemsPendingProcessing(): boolean;
-    getNextItemToProcess(): models.ArtifactItem;
-    updateState(item: models.ArtifactItem, state: models.TicketState): void;
-    getRootLocation(): string;
-    increaseRetryCount(item: models.ArtifactItem): void;
-    updateDownloadSize(item: models.ArtifactItem, downloadSizeInBytes: number): void;
-    updateFileSize(item: models.ArtifactItem, fileSizeInBytes: number): void;
-    size(): number;
-    flush(): void;
-    hasDownloadFailed(): boolean;
-}
+import * as models from "../Models";
+export declare class ArtifactItemStore {
+    _downloadTickets: models.ArtifactDownloadTicket[];
+    _hasDownloadFailed: boolean;
+    addItem(item: models.ArtifactItem): void;
+    addItems(items: models.ArtifactItem[]): void;
+    getTickets(): models.ArtifactDownloadTicket[];
+    itemsPendingProcessing(): boolean;
+    getNextItemToProcess(): models.ArtifactItem;
+    updateState(item: models.ArtifactItem, state: models.TicketState): void;
+    getRootLocation(): string;
+    increaseRetryCount(item: models.ArtifactItem): void;
+    updateDownloadSize(item: models.ArtifactItem, downloadSizeInBytes: number): void;
+    updateFileSize(item: models.ArtifactItem, fileSizeInBytes: number): void;
+    size(): number;
+    flush(): void;
+    hasDownloadFailed(): boolean;
+}