@xcanwin/manyoyo 7.0.5 → 7.0.7

package/lib/capacity.js

@@ -0,0 +1,92 @@
+'use strict';
+
+// 新容器主要复用镜像的只读层（overlayfs），没有历史容器数据可参考时，
+// 按这个偏保守的写层体积假设估算——避免刚起步就把估算数拉得虚高
+const DEFAULT_FALLBACK_CONTAINER_BYTES = 100 * 1024 * 1024;
+
+function toPositiveNumber(value) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+function estimateContainerCapacity(options = {}) {
+    const runCommand = typeof options.runCommand === 'function'
+        ? options.runCommand
+        : () => { throw new Error('未配置命令执行器'); };
+    const statfs = typeof options.statfs === 'function'
+        ? options.statfs
+        : () => { throw new Error('未配置磁盘空间检测器'); };
+
+    const runtimeCommand = options.runtimeCommand || 'docker';
+    const imageRef = `${options.imageName || ''}:${options.imageVersion || ''}`;
+    const containerNames = Array.isArray(options.containerNames) ? options.containerNames : [];
+    const diskPath = options.diskPath || '';
+    const notes = [];
+
+    let imageSizeBytes = 0;
+    try {
+        const raw = runCommand(runtimeCommand, ['image', 'inspect', imageRef, '--format', '{{.Size}}']);
+        imageSizeBytes = toPositiveNumber(String(raw).trim().split('\n')[0]);
+    } catch (error) {
+        notes.push(`镜像 ${imageRef} 尚未在本地构建/拉取，暂无法读取体积。`);
+    }
+
+    let averageWritableBytes = 0;
+    let sampledCount = 0;
+    if (containerNames.length > 0) {
+        try {
+            const raw = runCommand(runtimeCommand, ['inspect', '--size', '--format', '{{.SizeRw}}', ...containerNames]);
+            const sizes = String(raw)
+                .split('\n')
+                .map(line => toPositiveNumber(line.trim()))
+                .filter(size => size > 0);
+            if (sizes.length > 0) {
+                averageWritableBytes = sizes.reduce((sum, size) => sum + size, 0) / sizes.length;
+                sampledCount = sizes.length;
+            }
+        } catch (error) {
+            notes.push('无法读取现有容器的可写层体积，改用保守默认值估算。');
+        }
+    }
+
+    const perContainerEstimateBytes = averageWritableBytes > 0 ? averageWritableBytes : DEFAULT_FALLBACK_CONTAINER_BYTES;
+    if (sampledCount === 0) {
+        notes.push(`当前没有可参考的历史容器数据，按 ${Math.round(DEFAULT_FALLBACK_CONTAINER_BYTES / (1024 * 1024))}MB / 容器的保守假设估算。`);
+    }
+
+    let availableBytes = 0;
+    try {
+        const stat = statfs(diskPath);
+        availableBytes = toPositiveNumber(stat.bavail) * toPositiveNumber(stat.bsize);
+    } catch (error) {
+        notes.push('无法读取宿主机磁盘剩余空间。');
+    }
+
+    const estimatedAdditionalContainers = perContainerEstimateBytes > 0 && availableBytes > 0
+        ? Math.max(0, Math.floor(availableBytes / perContainerEstimateBytes))
+        : null;
+
+    notes.push('新容器主要复用镜像的只读层，磁盘增量主要来自容器自身的可写层；这里按现有容器可写层的平均值估算，实际会随使用情况波动，仅供参考。');
+
+    return {
+        runtimeCommand,
+        image: {
+            reference: imageRef,
+            sizeBytes: imageSizeBytes || null
+        },
+        container: {
+            averageWritableBytes: Math.round(perContainerEstimateBytes),
+            sampledCount
+        },
+        disk: {
+            path: diskPath,
+            availableBytes: availableBytes || null
+        },
+        estimatedAdditionalContainers,
+        notes
+    };
+}
+
+module.exports = {
+    estimateContainerCapacity
+};

package/lib/json5-text-edit.js

@@ -231,8 +231,69 @@ function applyTextReplacements(text, replacements) {
         .reduce((result, item) => `${result.slice(0, item.start)}${item.text}${result.slice(item.end)}`, text);
 }
 
+function formatPropertyKey(key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+
+// 永远只在对象的 '{' 后面插入，不管这个对象原来是空的还是已经有属性——
+// 不用去判断"是不是最后一个属性、要不要补逗号"，语法上总是安全的
+function insertObjectProperty(text, objectStartIndex, key, valueText) {
+    const prefix = `\n    ${formatPropertyKey(key)}: `;
+    const insertion = `${prefix}${valueText},`;
+    const insertPos = objectStartIndex + 1;
+    const nextText = `${text.slice(0, insertPos)}${insertion}${text.slice(insertPos)}`;
+    return { text: nextText, valueStart: insertPos + prefix.length };
+}
+
+// findValueRangeByPath 的"读+建"版本：路径上缺失的中间对象会被逐级创建，
+// 最终这个 key 已存在就原地替换值，不存在就插入新属性；已有内容/注释不受影响。
+// 路径中间遇到"已存在但不是对象"的值会直接抛错，不做任何改动（避免静默吞掉用户数据）。
+function upsertValueByPath(text, pathParts, valueText) {
+    if (!Array.isArray(pathParts) || pathParts.length === 0) {
+        throw new Error('path 不能为空');
+    }
+
+    let objectStart = findRootObjectStart(text);
+    if (objectStart === -1) {
+        throw new Error('未找到根对象');
+    }
+
+    let currentText = text;
+    let currentObjectStart = objectStart;
+
+    for (let i = 0; i < pathParts.length; i += 1) {
+        const key = pathParts[i];
+        const isLast = i === pathParts.length - 1;
+        const existingRange = findObjectPropertyValueRange(currentText, currentObjectStart, key);
+
+        if (existingRange) {
+            if (isLast) {
+                return applyTextReplacements(currentText, [
+                    { start: existingRange.start, end: existingRange.end, text: valueText }
+                ]);
+            }
+            const nextObjectStart = skipTrivia(currentText, existingRange.start);
+            if (currentText[nextObjectStart] !== '{') {
+                throw new Error(`路径 ${pathParts.slice(0, i + 1).join('.')} 已存在且不是对象，无法继续`);
+            }
+            currentObjectStart = nextObjectStart;
+            continue;
+        }
+
+        const inserted = insertObjectProperty(currentText, currentObjectStart, key, isLast ? valueText : '{}');
+        currentText = inserted.text;
+        if (isLast) {
+            return currentText;
+        }
+        currentObjectStart = inserted.valueStart;
+    }
+
+    return currentText;
+}
+
 module.exports = {
     findTopLevelPropertyValueRange,
     findValueRangeByPath,
-    applyTextReplacements
+    applyTextReplacements,
+    upsertValueByPath
 };