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

Zephyr plugin agent

import "node:module";
import { forEachLimit } from "zephyr-edge-contract";
import { get_missing_assets } from "../edge-hash-list/get-missing-assets.mjs";
import { getApplicationHashList } from "../edge-requests/get-application-hash-list.mjs";
import { uploadFile } from "../http/upload-file.mjs";
import { ze_log } from "../logging/index.mjs";
import { white, whiteBright } from "../logging/picocolor.mjs";
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 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, ${white('skipping')}...`
        });
        return true;
    }
    const start = Date.now();
    let totalSize = 0;
    await forEachLimit(missingAssets.map((asset)=>()=>upload_missing_asset(asset)), MAX_MATCH_SIZE);
    logger({
        level: 'info',
        action: 'snapshot:assets:upload:done',
        message: white(`(${whiteBright(missingAssets.length.toString())}/${white(count.toString())} assets uploaded in ${whiteBright((Date.now() - start).toString())}ms, ${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 uploadFile({
            hash: asset.hash,
            asset: assetWithBuffer
        }, appConfig);
        const fileUploaded = Date.now() - start;
        totalSize += assetSize;
        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 getApplicationHashList({
            application_uid: zephyr_engine.application_uid,
            edge_url: envCfg.edgeUrl
        });
        const missingAssets = get_missing_assets({
            assetsMap,
            hash_set: {
                hash_set: new Set(hash_set.hashes)
            }
        });
        if (0 === missingAssets.length) return;
        let totalSize = 0;
        await forEachLimit(missingAssets.map((asset)=>async ()=>{
                ze_log.upload(`Uploading file ${asset.path} to env: ${whiteBright(env)}`);
                const start = Date.now();
                const assetWithBuffer = assetsMap[asset.hash];
                const assetSize = assetWithBuffer?.buffer?.length / 1024;
                await uploadFile({
                    hash: asset.hash,
                    asset: assetWithBuffer
                }, {
                    ...appConfig,
                    EDGE_URL: envCfg.edgeUrl
                });
                const fileUploaded = Date.now() - start;
                totalSize += assetSize;
                ze_log.upload(`file ${asset.path} uploaded in ${fileUploaded}ms (${assetSize.toFixed(2)}kb) for env: ${whiteBright(env)}`);
            }), MAX_MATCH_SIZE);
        ze_log.upload(`Total size uploaded for env: ${whiteBright(env)}: ${totalSize.toFixed(2)}kb`);
    }
}
export { zeUploadAssets };

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