public async downloadAndInstall(versionInfo: VersionInfo, downloadUrl: string): Promise<void> {
if (!versionInfo || !versionInfo.getVersion() || !downloadUrl || !url.parse(downloadUrl)) {
throw tl.loc("VersionCanNotBeDownloadedFromUrl", versionInfo, downloadUrl);
}
let version = versionInfo.getVersion();
try {
try {
var downloadPath = await toolLib.downloadTool(downloadUrl)
}
catch (ex) {
throw tl.loc("CouldNotDownload", downloadUrl, ex);
}
// Extract
console.log(tl.loc("ExtractingPackage", downloadPath));
try {
var extPath = tl.osType().match(/^Win/) ? await toolLib.extractZip(downloadPath) : await toolLib.extractTar(downloadPath);
}
catch (ex) {
throw tl.loc("FailedWhileExtractingPacakge", ex);
}
// Copy folders
tl.debug(tl.loc("CopyingFoldersIntoPath", this.installationPath));
var allRootLevelEnteriesInDir: string[] = tl.ls("", [extPath]).map(name => path.join(extPath, name));
var directoriesTobeCopied: string[] = allRootLevelEnteriesInDir.filter(path => fs.lstatSync(path).isDirectory());
directoriesTobeCopied.forEach((directoryPath) => {
tl.cp(directoryPath, this.installationPath, "-rf", false);
});
// Copy files
try {
if (this.packageType == utils.Constants.sdk && this.isLatestInstalledVersion(version)) {
tl.debug(tl.loc("CopyingFilesIntoPath", this.installationPath));
var filesToBeCopied = allRootLevelEnteriesInDir.filter(path => !fs.lstatSync(path).isDirectory());
filesToBeCopied.forEach((filePath) => {
tl.cp(filePath, this.installationPath, "-f", false);
});
}
}
catch (ex) {
tl.warning(tl.loc("FailedToCopyTopLevelFiles", this.installationPath, ex));
}
// Cache tool
this.createInstallationCompleteFile(versionInfo);
console.log(tl.loc("SuccessfullyInstalled", this.packageType, version));
}
catch (ex) {
throw tl.loc("FailedWhileInstallingVersionAtPath", version, this.installationPath, ex);
}
}
async function acquireGo(version: string): Promise<string> {
//
// Download - a tool installer intimately knows how to get the tool (and construct urls)
//
let fileName: string = getFileName(version);
let downloadUrl: string = getDownloadUrl(fileName);
let downloadPath: string = null;
try {
downloadPath = await toolLib.downloadTool(downloadUrl);
} catch (error) {
tl.debug(error);
// cannot localized the string here because to localize we need to set the resource file.
// which can be set only once. vsts-task-tool-lib/tool, is already setting it to different file.
// So left with no option but to hardcode the string. Other tasks are doing the same.
throw (util.format("Failed to download version %s. Please verify that the version is valid and resolve any other issues. %s", version, error));
}
//make sure agent version is latest then 2.115.0
tl.assertAgent('2.115.0');
//
// Extract
//
let extPath: string;
extPath = tl.getVariable('Agent.TempDirectory');
if (!extPath) {
throw new Error("Expected Agent.TempDirectory to be set");
}
if (osPlat == 'win32') {
extPath = await toolLib.extractZip(downloadPath);
}
else {
extPath = await toolLib.extractTar(downloadPath);
}
//
// Install into the local tool cache - node extracts with a root folder that matches the fileName downloaded
//
let toolRoot = path.join(extPath, "go");
version = fixVersion(version);
return await toolLib.cacheDir(toolRoot, 'go', version);
}
async function acquireDotNetCore(packageType: string, version: string): Promise<string> {
let downloadUrls = getDownloadUrls(packageType, version);
let downloadPath: string;
try {
// try primary url
if (!!downloadUrls[0]) {
console.log(taskLib.loc("DownloadingPrimaryUrl", downloadUrls[0]));
downloadPath = await toolLib.downloadTool(downloadUrls[0]);
}
} catch (error1) {
console.log(taskLib.loc("PrimaryUrlDownloadFailed", error1));
try {
// try secondary url
if (!!downloadUrls[1]) {
console.log(taskLib.loc("DownloadingSecondaryUrl", downloadUrls[1]));
downloadPath = await toolLib.downloadTool(downloadUrls[1]);
}
} catch (error2) {
console.log(taskLib.loc("LegacyUrlDownloadFailed", error2));
throw taskLib.loc("DownloadFailed", packageType, version);
}
}
// extract
let extPath: string;
console.log(taskLib.loc("ExtractingPackage", downloadPath));
if (taskLib.osType().match(/^Win/)) {
extPath = await toolLib.extractZip(downloadPath);
}
else {
extPath = await toolLib.extractTar(downloadPath);
}
// cache tool
let cachedToolName = getCachedToolName(packageType);
console.log(taskLib.loc("CachingTool"));
let cachedDir = await toolLib.cacheDir(extPath, cachedToolName, version);
console.log(taskLib.loc("SuccessfullyInstalled", packageType, version));
return cachedDir;
}
export async function downloadHelm(version?: string): Promise<string> {
if (!version) version = await getStableHelmVersion();
var cachedToolpath = toolLib.findLocalTool(helmToolName, version);
if (!cachedToolpath) {
try {
var helmDownloadPath = await toolLib.downloadTool(getHelmDownloadURL(version), helmToolName + "-" + version + "-" + uuidV4() + ".zip");
} catch (exception) {
throw new Error(tl.loc("HelmDownloadFailed", getHelmDownloadURL(version), exception));
}
var unzipedHelmPath = await toolLib.extractZip(helmDownloadPath);
cachedToolpath = await toolLib.cacheDir(unzipedHelmPath, helmToolName, version);
}
var helmpath = findHelm(cachedToolpath);
if (!helmpath) {
throw new Error(tl.loc("HelmNotFoundInFolder", cachedToolpath))
}
fs.chmodSync(helmpath, "777");
return helmpath;
}