update 2026-11-20 19:53

This commit is contained in:
nix
2026-11-20 19:53:02 +01:00
parent ef1e197ed8
commit 4696d75bc7
13 changed files with 1618 additions and 59 deletions
+138
View File
@@ -0,0 +1,138 @@
// État + logique métier. Tailles en octets.
const S = { devs: {}, order: [], pools: {}, sel: null };
const U = { B: 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4 };
const FS = ['ext4', 'btrfs', 'xfs', 'vfat', 'ntfs', 'zfs', 'swap'];
let seq = 0;
const uid = () => 'x' + (++seq) + Math.random().toString(36).slice(2, 6);
const unitOf = b => b >= U.T ? ['T', U.T] : b >= U.G ? ['G', U.G] : b >= U.M ? ['M', U.M] : ['K', U.K];
const num = (x, d) => String(+x.toFixed(d)).replace('.', ',');
const fmtIEC = b => { const [u, v] = unitOf(b); return num(b / v, 2) + ' ' + u + 'io'; };
const fmtLsblk = b => { const [u, v] = unitOf(b); return num(b / v, 1) + u; };
const sz = x => { // "463,2G" | 1234 | "1234" -> octets
if (typeof x === 'number') return x;
const m = String(x).match(/^([\d.,]+)\s*([BKMGT])?/i);
return m ? parseFloat(m[1].replace(',', '.')) * U[(m[2] || 'B').toUpperCase()] : 0;
};
const diskOf = d => d.kind === 'disk' ? d : d.kind === 'part' ? S.devs[d.parent] : null;
const free = d => d.size - d.children.reduce((a, c) => a + S.devs[c].size, 0);
function mk(o) {
const d = { id: uid(), fstype: '', label: '', used: null, mounts: [], children: [], rm: '0', ro: '0', ...o };
S.devs[d.id] = d;
return d;
}
const nextNvmeMinor = () => 1 + Math.max(-1, ...Object.values(S.devs).filter(d => d.majmin.startsWith('259:')).map(d => +d.majmin.split(':')[1]));
function addDisk(size, media) {
const names = Object.values(S.devs).filter(d => d.kind === 'disk').map(d => d.name);
let i = 0, name, majmin;
if (media === 'nvme') { while (names.includes(`nvme${i}n1`)) i++; name = `nvme${i}n1`; majmin = '259:' + nextNvmeMinor(); }
else { while (names.includes('sd' + String.fromCharCode(97 + i))) i++; name = 'sd' + String.fromCharCode(97 + i); majmin = '8:' + i * 16; }
const d = mk({ kind: 'disk', name, size, majmin, rm: media === 'sd' ? '0' : '0' });
S.order.push(d.id);
return d;
}
function addPart(disk, size, fstype) {
if (disk.pool) dissolvePool(disk.pool);
disk.fstype = ''; disk.mounts = []; // disque entier -> partitionné
const n = 1 + Math.max(0, ...disk.children.map(c => parseInt(S.devs[c].name.match(/(\d+)$/)[1])));
const nv = disk.name.startsWith('nvme');
const base = +disk.majmin.split(':')[1];
const p = mk({ kind: 'part', name: disk.name + (nv ? 'p' : '') + n, size, parent: disk.id, fstype,
majmin: nv ? '259:' + nextNvmeMinor() : '8:' + (base + n) });
disk.children.push(p.id);
return p;
}
function setFs(d, fstype, label) { d.fstype = fstype; d.label = label; d.mounts = []; d.used = null; }
function addMount(d, mp, subvol) {
if (!d.fstype || d.fstype === 'swap') return 'Formate d\'abord (hors swap).';
if (!mp.startsWith('/')) return 'Le point de montage doit commencer par /.';
if (Object.values(S.devs).some(x => x.mounts.some(m => m.mp === mp))) return `${mp} est déjà monté.`;
d.mounts.push({ mp, subvol });
return '';
}
const RAID_MIN = { 0: 2, 1: 2, 5: 3, 6: 4, 10: 4 };
const typeOf = d => d.kind === 'raid' ? 'raid' + d.level : d.kind;
const eligible = () => Object.values(S.devs).filter(d => (d.kind === 'part' || (d.kind === 'disk' && !d.children.length))
&& !d.mounts.length && d.fstype !== 'swap' && d.fstype !== 'linux_raid_member' && !d.pool);
function addRaid(ids, level) {
if (ids.length < RAID_MIN[level]) return `RAID ${level} : au moins ${RAID_MIN[level]} membres.`;
if (level === 10 && ids.length % 2) return 'RAID 10 : nombre pair de membres.';
const s = ids.map(i => S.devs[i].size), min = Math.min(...s), n = s.length;
const size = level === 0 ? s.reduce((a, b) => a + b, 0) : level === 1 ? min : level === 5 ? min * (n - 1) : level === 6 ? min * (n - 2) : min * n / 2;
const names = Object.values(S.devs).map(d => d.name); let i = 0;
while (names.includes('md' + i)) i++;
const r = mk({ kind: 'raid', name: 'md' + i, level, size, majmin: '9:' + i, members: ids });
ids.forEach(m => { S.devs[m].fstype = 'linux_raid_member'; });
S.sel = r.id;
return '';
}
const freeMembers = r => r.members.forEach(m => { const x = S.devs[m]; if (x && x.fstype === 'linux_raid_member') x.fstype = ''; });
function dropRaids(id) {
Object.values(S.devs).filter(r => r.kind === 'raid' && r.members.includes(id)).forEach(r => { freeMembers(r); delete S.devs[r.id]; });
}
// Pool btrfs multi-périphériques : pas de mdX, tous les membres sont "btrfs",
// le montage n'est affiché que sur le membre principal (comme lsblk).
const BTRFS_MIN = { single: 2, raid0: 2, raid1: 2, raid1c3: 3, raid10: 4, raid5: 2, raid6: 3 };
const host = d => d.pool ? S.devs[S.pools[d.pool].primary] : d;
function addPool(ids, profile, label) {
if (ids.length < BTRFS_MIN[profile]) return `btrfs ${profile} : au moins ${BTRFS_MIN[profile]} périphériques.`;
const s = ids.map(i => S.devs[i].size), sum = s.reduce((a, b) => a + b, 0), max = Math.max(...s);
const usable = { single: sum, raid0: sum, raid1: Math.min(sum / 2, sum - max), raid1c3: Math.min(sum / 3, (sum - max) / 2),
raid10: sum / 2, raid5: sum - max, raid6: sum - 2 * max }[profile];
const id = 'pool' + uid();
S.pools[id] = { id, profile, label, usable, members: ids, primary: ids[0] };
ids.forEach(i => { const d = S.devs[i]; d.fstype = 'btrfs'; d.pool = id; d.label = label; d.mounts = []; d.used = null; });
S.sel = ids[0];
return '';
}
function dissolvePool(pid) {
const p = S.pools[pid]; if (!p) return;
p.members.forEach(m => { const d = S.devs[m]; if (d) { d.fstype = ''; d.pool = null; d.label = ''; d.mounts = []; } });
delete S.pools[pid];
}
function dropPool(id) { const d = S.devs[id]; if (d && d.pool) dissolvePool(d.pool); }
function delDev(id) {
const d = S.devs[id]; if (!d) return;
if (d.kind === 'raid') freeMembers(d); else { dropRaids(id); dropPool(id); }
if (d.kind === 'disk') { d.children.forEach(c => { dropRaids(c); dropPool(c); delete S.devs[c]; }); S.order = S.order.filter(x => x !== id); }
else if (d.kind === 'part' && S.devs[d.parent]) S.devs[d.parent].children = S.devs[d.parent].children.filter(x => x !== id);
delete S.devs[id];
S.sel = null;
}
// Lignes de l'arbre lsblk (1 ligne par point de montage, comme le vrai lsblk)
// all=true : un pool btrfs affiche ses montages sur chaque membre (all=false : comme le vrai lsblk, membre principal seul)
const mountTexts = (d, all) => d.fstype === 'swap' ? ['[SWAP]'] : (all ? host(d) : d).mounts.map(m => m.mp);
function rows(all = true) {
const out = [];
const add = (d, name, pfx) => {
const m = mountTexts(d, all);
out.push({ d, name, mount: m[0] || '' });
m.slice(1).forEach(x => out.push({ d, name: pfx, mount: x, cont: true }));
};
const raids = (d, ind) => Object.values(S.devs).filter(r => r.kind === 'raid' && r.members.includes(d.id)).forEach(r => add(r, ind + '└─' + r.name, ''));
S.order.forEach(id => {
const d = S.devs[id]; add(d, d.name, ''); raids(d, '');
d.children.forEach((c, i) => {
const last = i === d.children.length - 1, p = S.devs[c];
add(p, (last ? '└─' : '├─') + p.name, last ? '' : '│'); raids(p, last ? ' ' : '│ ');
});
});
return out;
}
const save = () => { try { localStorage.setItem('lsblk-mgr', JSON.stringify({ devs: S.devs, order: S.order, pools: S.pools })); } catch (e) {} };
const load = () => { try { const j = JSON.parse(localStorage.getItem('lsblk-mgr')); if (j && j.devs) { S.devs = j.devs; S.order = j.order; S.pools = j.pools || {}; S.sel = S.order[0] || null; } } catch (e) {} };