Fix build

lib/provision.js

@@ -0,0 +1,166 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const httpm = __importStar(require("typed-rest-client/HttpClient"));
+const unzip = __importStar(require("unzipper"));
+const core = __importStar(require("@actions/core"));
+const io = __importStar(require("@actions/io"));
+const toolCache = __importStar(require("@actions/tool-cache"));
+const gradlew = __importStar(require("./gradlew"));
+const httpc = new httpm.HttpClient("eskatos/gradle-command-action");
+const gradleVersionsBaseUrl = "https://services.gradle.org/versions";
+function gradleVersion(gradleVersion) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (gradleVersion) {
+            case "current":
+                return gradleCurrent();
+            case "rc":
+                return gradleReleaseCandidate();
+            case "nightly":
+                return gradleNightly();
+            case "release-nightly":
+                return gradleReleaseNightly();
+            default:
+                return gradle(gradleVersion);
+        }
+    });
+}
+exports.gradleVersion = gradleVersion;
+function gradleCurrent() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = yield gradleVersionDeclaration(`${gradleVersionsBaseUrl}/current`);
+        return provisionGradle(json.version, json.downloadUrl);
+    });
+}
+function gradleReleaseCandidate() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = yield gradleVersionDeclaration(`${gradleVersionsBaseUrl}/release-candidate`);
+        if (json) {
+            return provisionGradle(json.version, json.downloadUrl);
+        }
+        return gradleCurrent();
+    });
+}
+function gradleNightly() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = yield gradleVersionDeclaration(`${gradleVersionsBaseUrl}/nightly`);
+        return provisionGradle(json.version, json.downloadUrl);
+    });
+}
+function gradleReleaseNightly() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = yield gradleVersionDeclaration(`${gradleVersionsBaseUrl}/release-nightly`);
+        return provisionGradle(json.version, json.downloadUrl);
+    });
+}
+function gradle(version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const declaration = yield findGradleVersionDeclaration(version);
+        if (!declaration) {
+            throw new Error(`Gradle version ${version} does not exists`);
+        }
+        return provisionGradle(declaration.version, declaration.downloadUrl);
+    });
+}
+function gradleVersionDeclaration(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = yield httpGetJson(url);
+        return (json.version && json.version.length > 0) ? json : undefined;
+    });
+}
+function findGradleVersionDeclaration(version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const json = yield httpGetJson(`${gradleVersionsBaseUrl}/all`);
+        const found = json.find((entry) => {
+            return entry.version === version;
+        });
+        return found ? found : undefined;
+    });
+}
+function provisionGradle(version, url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cachedInstall = toolCache.find("gradle", version);
+        if (cachedInstall.length > 0) {
+            const cachedExecutable = executableFrom(cachedInstall);
+            core.info(`Provisioned Gradle executable ${cachedExecutable}`);
+            return cachedExecutable;
+        }
+        const home = process.env["HOME"] || "";
+        const tmpdir = path.join(home, "gradle-provision-tmpdir");
+        const downloadsDir = path.join(tmpdir, "downloads");
+        const installsDir = path.join(tmpdir, "installs");
+        yield io.mkdirP(downloadsDir);
+        yield io.mkdirP(installsDir);
+        core.info(`Downloading ${url}`);
+        const downloadPath = path.join(downloadsDir, `gradle-${version}-bin.zip`);
+        yield httpDownload(url, downloadPath);
+        core.info(`Downloaded at ${downloadPath}, size ${fs.statSync(downloadPath).size}`);
+        yield extractZip(downloadPath, installsDir);
+        const installDir = path.join(installsDir, `gradle-${version}`);
+        core.info(`Extracted in ${installDir}`);
+        const executable = executableFrom(installDir);
+        fs.chmodSync(executable, "755");
+        core.info(`Provisioned Gradle executable ${executable}`);
+        toolCache.cacheDir(installDir, "gradle", version);
+        return executable;
+    });
+}
+function executableFrom(installDir) {
+    return path.join(installDir, "bin", `${gradlew.installScriptFilename()}`);
+}
+function httpGetJson(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield httpc.get(url);
+        const body = yield response.readBody();
+        return JSON.parse(body);
+    });
+}
+function httpDownload(url, path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve, reject) {
+            const writeStream = fs.createWriteStream(path);
+            httpc.get(url).then(response => {
+                response.message.pipe(writeStream)
+                    .on("close", () => {
+                    resolve();
+                })
+                    .on("error", err => {
+                    reject(err);
+                });
+            }).catch(reason => {
+                reject(reason);
+            });
+        });
+    });
+}
+function extractZip(zip, destination) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise(function (resolve, reject) {
+            fs.createReadStream(zip)
+                .pipe(unzip.Extract({ "path": destination }))
+                .on("close", () => {
+                resolve();
+            })
+                .on("error", err => {
+                reject(err);
+            });
+        });
+    });
+}