zephyr-agent/dist/lib/edge-actions/ze-upload-assets.js

Zephyr plugin agent

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    zeUploadAssets: ()=>zeUploadAssets
});
const external_zephyr_edge_contract_namespaceObject = require("zephyr-edge-contract");
const get_missing_assets_js_namespaceObject = require("../edge-hash-list/get-missing-assets.js");
const get_application_hash_list_js_namespaceObject = require("../edge-requests/get-application-hash-list.js");
const upload_file_js_namespaceObject = require("../http/upload-file.js");
const index_js_namespaceObject = require("../logging/index.js");
const picocolor_js_namespaceObject = require("../logging/picocolor.js");
const MAX_MATCH_SIZE = 6;
const MAX_ENVIRONMENT_CONCURRENCY = 3;
async function zeUploadAssets(zephyr_engine, { missingAssets, assetsMap }) {
    const count = Object.keys(assetsMap).length;
    const logger = await zephyr_engine.logger;
    const appConfig = await zephyr_engine.application_configuration;
    const envs = appConfig.ENVIRONMENTS;
    if (null != envs) await (0, external_zephyr_edge_contract_namespaceObject.forEachLimit)(Object.entries(envs).filter(([_, envCfg])=>envCfg.edgeUrl !== appConfig.EDGE_URL).map(([env, envCfg])=>()=>zeUploadAssetsForEnv(env, envCfg, appConfig, assetsMap)), MAX_ENVIRONMENT_CONCURRENCY);
    if (0 === missingAssets.length) {
        logger({
            level: 'info',
            action: 'snapshot:assets:upload:empty',
            message: `No assets to upload, ${(0, picocolor_js_namespaceObject.white)('skipping')}...`
        });
        return true;
    }
    const start = Date.now();
    let totalSize = 0;
    await (0, external_zephyr_edge_contract_namespaceObject.forEachLimit)(missingAssets.map((asset)=>()=>upload_missing_asset(asset)), MAX_MATCH_SIZE);
    logger({
        level: 'info',
        action: 'snapshot:assets:upload:done',
        message: (0, picocolor_js_namespaceObject.white)(`(${(0, picocolor_js_namespaceObject.whiteBright)(missingAssets.length.toString())}/${(0, picocolor_js_namespaceObject.white)(count.toString())} assets uploaded in ${(0, picocolor_js_namespaceObject.whiteBright)((Date.now() - start).toString())}ms, ${(0, picocolor_js_namespaceObject.whiteBright)(totalSize.toFixed(2))}kb)`)
    });
    return true;
    async function upload_missing_asset(asset) {
        const start = Date.now();
        const assetWithBuffer = assetsMap[asset.hash];
        const assetSize = assetWithBuffer?.buffer?.length / 1024;
        await (0, upload_file_js_namespaceObject.uploadFile)({
            hash: asset.hash,
            asset: assetWithBuffer
        }, appConfig);
        const fileUploaded = Date.now() - start;
        totalSize += assetSize;
        index_js_namespaceObject.ze_log.upload(`file ${asset.path} uploaded in ${fileUploaded}ms (${assetSize.toFixed(2)}kb)`);
    }
    async function zeUploadAssetsForEnv(env, envCfg, appConfig, assetsMap) {
        const hash_set = await (0, get_application_hash_list_js_namespaceObject.getApplicationHashList)({
            application_uid: zephyr_engine.application_uid,
            edge_url: envCfg.edgeUrl
        });
        const missingAssets = (0, get_missing_assets_js_namespaceObject.get_missing_assets)({
            assetsMap,
            hash_set: {
                hash_set: new Set(hash_set.hashes)
            }
        });
        if (0 === missingAssets.length) return;
        let totalSize = 0;
        await (0, external_zephyr_edge_contract_namespaceObject.forEachLimit)(missingAssets.map((asset)=>async ()=>{
                index_js_namespaceObject.ze_log.upload(`Uploading file ${asset.path} to env: ${(0, picocolor_js_namespaceObject.whiteBright)(env)}`);
                const start = Date.now();
                const assetWithBuffer = assetsMap[asset.hash];
                const assetSize = assetWithBuffer?.buffer?.length / 1024;
                await (0, upload_file_js_namespaceObject.uploadFile)({
                    hash: asset.hash,
                    asset: assetWithBuffer
                }, {
                    ...appConfig,
                    EDGE_URL: envCfg.edgeUrl
                });
                const fileUploaded = Date.now() - start;
                totalSize += assetSize;
                index_js_namespaceObject.ze_log.upload(`file ${asset.path} uploaded in ${fileUploaded}ms (${assetSize.toFixed(2)}kb) for env: ${(0, picocolor_js_namespaceObject.whiteBright)(env)}`);
            }), MAX_MATCH_SIZE);
        index_js_namespaceObject.ze_log.upload(`Total size uploaded for env: ${(0, picocolor_js_namespaceObject.whiteBright)(env)}: ${totalSize.toFixed(2)}kb`);
    }
}
exports.zeUploadAssets = __webpack_exports__.zeUploadAssets;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "zeUploadAssets"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=ze-upload-assets.js.map