balena-cli/build/utils/os.js

The official balena Command Line Interface

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getOsType = exports.isESR = void 0;
exports.downloadOSImage = downloadOSImage;
exports.getOsVersions = getOsVersions;
exports.formatOsVersion = formatOsVersion;
const lazy_1 = require("./lazy");
const errors_1 = require("../errors");
const isESR = (version) => {
    var _a;
    const match = version.match(/^v?(\d+)\.\d+\.\d+/);
    const major = parseInt((_a = match === null || match === void 0 ? void 0 : match[1]) !== null && _a !== void 0 ? _a : '', 10);
    return major >= 2018;
};
exports.isESR = isESR;
const getOsType = (version) => (0, exports.isESR)(version) ? 'esr' : 'default';
exports.getOsType = getOsType;
async function downloadOSImage(deviceType, outputPath, OSVersion, type) {
    console.info(`Getting device operating system for ${deviceType}`);
    if (!OSVersion) {
        console.warn('OS version not specified: using latest released version');
        OSVersion = 'latest';
    }
    OSVersion = await resolveOSVersion(deviceType, OSVersion);
    process.env.ZLIB_FLUSH = 'Z_NO_FLUSH';
    try {
        const { getStream } = await Promise.resolve().then(() => require('./image-manager'));
        const stream = await getStream(deviceType, OSVersion, {
            type,
        });
        const displayVersion = await new Promise((resolve, reject) => {
            stream.on('error', reject);
            stream.on('balena-image-manager:resolved-version', resolve);
        });
        const visuals = (0, lazy_1.getVisuals)();
        const bar = new visuals.Progress(`Downloading balenaOS version ${displayVersion}`);
        const spinner = new visuals.Spinner(`Downloading balenaOS version ${displayVersion} (size unknown)`);
        stream.on('progress', (state) => {
            if (state != null) {
                return bar.update(state);
            }
            spinner.start();
        });
        stream.on('end', () => {
            spinner.stop();
        });
        let output;
        if (stream.mime === 'application/zip') {
            const unzip = await Promise.resolve().then(() => require('node-unzip-2'));
            output = unzip.Extract({ path: outputPath });
        }
        else {
            const fs = await Promise.resolve().then(() => require('fs'));
            output = fs.createWriteStream(outputPath);
        }
        const { pipeline } = await Promise.resolve().then(() => require('node:stream/promises'));
        await pipeline(stream, output);
        console.info(`balenaOS image version ${displayVersion} downloaded successfully`);
        return outputPath;
    }
    catch (e) {
        const { getBalenaSdk } = await Promise.resolve().then(() => require('../utils/lazy'));
        const balenaSdk = getBalenaSdk();
        if (e instanceof balenaSdk.errors.OSImageNotFound) {
            if (type != null) {
                throw new errors_1.ExpectedError('The requested OS download type is unavailable for this device type and version.');
            }
        }
        throw e;
    }
}
async function resolveOSVersion(deviceType, version) {
    if (['menu', 'menu-esr'].includes(version)) {
        return await selectOSVersionFromMenu(deviceType, version === 'menu-esr', false);
    }
    const { normalizeOsVersion } = await Promise.resolve().then(() => require('./normalization'));
    version = normalizeOsVersion(version);
    return version;
}
async function selectOSVersionFromMenu(deviceType, esr, includeDraft) {
    var _a;
    const vs = await getOsVersions(deviceType, esr, includeDraft);
    const choices = vs.map((v) => ({
        value: v.raw_version,
        name: formatOsVersion(v),
    }));
    return (0, lazy_1.getCliForm)().ask({
        message: 'Select the OS version:',
        type: 'list',
        choices,
        default: (_a = vs[0]) === null || _a === void 0 ? void 0 : _a.raw_version,
    });
}
async function getOsVersions(deviceType, esr, includeDraft) {
    const sdk = (0, lazy_1.getBalenaSdk)();
    let slug = deviceType;
    let versions = await sdk.models.os.getAvailableOsVersions(slug, undefined, { includeDraft });
    if (!versions.length) {
        slug = (await sdk.models.deviceType.get(slug, { $select: 'slug' })).slug;
        if (slug !== deviceType) {
            versions = await sdk.models.os.getAvailableOsVersions(slug, undefined, {
                includeDraft,
            });
        }
    }
    versions = versions.filter((v) => v.osType === (esr ? 'esr' : 'default'));
    if (!versions.length) {
        const vType = esr ? 'ESR versions' : 'versions';
        throw new errors_1.ExpectedError(`Error: No balenaOS ${vType} found for device type '${deviceType}'.`);
    }
    return versions;
}
function formatOsVersion(osVersion) {
    return osVersion.line
        ? `v${osVersion.raw_version} (${osVersion.line})`
        : `v${osVersion.raw_version}`;
}
//# sourceMappingURL=os.js.map