diff --git a/.htaccess.bak b/.htaccess.bak deleted file mode 100644 index c1023a5..0000000 --- a/.htaccess.bak +++ /dev/null @@ -1,8 +0,0 @@ -# Allow access to everything -Require all granted - -# Allow overrides -Options +FollowSymLinks -Indexes - -# Default file -DirectoryIndex index.php diff --git a/autre/lsblk/index.html b/autre/lsblk/index.html new file mode 100644 index 0000000..175f1e3 --- /dev/null +++ b/autre/lsblk/index.html @@ -0,0 +1,667 @@ + + + + +lsblk --interactive + + + + + + +

$ lsblk --interactive

+

simulateur : disques, partitions, RAID logiciel, import lsblk — tout vit dans l'onglet, rien n'est persistant

+ +
+ +
+ +
+

Importer depuis lsblk

+

Colle une sortie lsblk réelle — disques, partitions, RAID (md) et points de montage sont reconstruits automatiquement. Le type de média (HDD/NVMe) est déduit du nom.

+ + +
+
+ +
+

Exporter

+

Génère l'état actuel au format lsblk (copiable/collable) ou en JSON complet (fidèle à 100%, pour reprendre une session).

+ + +
+ + +
+ + + +
+
+ +
+

Ajouter un disque

+
+
+ + +
+
+ + +
+
+
+
+ + + +
+
+ +
+

Partitionner un disque

+ + +
+
+
+ + +
+
+ + +
+
+
+ +
+
+ +
+

Assembler un RAID

+
+ + + +
+
+ +
+

Formater / monter

+ + + + + + + +
+
+ + +
+ +
+
+
+
linux — lsblk
+
+
+
+
+
+ ■disque + ■partition + ■RAID (mdX) + ■monté + ■swap +
+
+
+ +
+ + + + diff --git a/autre/lsblk/new/css/style.css b/autre/lsblk/new/css/style.css new file mode 100644 index 0000000..7d6b8c8 --- /dev/null +++ b/autre/lsblk/new/css/style.css @@ -0,0 +1,39 @@ +:root{--bg:#20212c;--panel:#282a36;--line:#44475a;--fg:#f8f8f2;--dim:#6272a4;--cyan:#8be9fd;--green:#50fa7b;--orange:#ffb86c;--purple:#bd93f9;--red:#ff5555;--yellow:#f1fa8c} +*{box-sizing:border-box} +body{margin:0;padding:24px;background:var(--bg);color:var(--fg);font:12.5px 'JetBrains Mono',ui-monospace,monospace} +h1{font-size:15px;font-weight:500;color:var(--dim);margin:0 0 4px}.prompt{color:var(--green)} +.sub{color:var(--dim);font-size:12px;margin:0 0 20px} +.layout{display:grid;grid-template-columns:340px 1fr;gap:20px;max-width:1400px;margin:auto;align-items:start} +@media(max-width:900px){.layout{grid-template-columns:1fr}} +.panel{background:var(--panel);border:1px solid var(--line);border-radius:8px;padding:14px;margin-bottom:14px} +h2{font-size:11px;text-transform:uppercase;letter-spacing:.08em;color:var(--purple);margin:0 0 8px} +.hint{font-size:10.5px;color:var(--dim);line-height:1.5;margin:0 0 8px}code{color:var(--cyan);word-break:break-all} +label{display:block;font-size:11px;color:var(--dim);margin:8px 0 4px} +input,select,textarea{width:100%;background:var(--bg);border:1px solid var(--line);color:var(--fg);font:inherit;padding:6px 8px;border-radius:5px} +textarea{min-height:80px;font-size:11px;resize:vertical} +.r2{display:grid;grid-template-columns:1fr 80px;gap:8px} +.chk{display:flex;gap:6px;align-items:center}.chk input{width:auto} +button{font:inherit;font-weight:500;border:0;border-radius:5px;padding:7px 10px;margin-top:10px;width:100%;cursor:pointer;background:var(--purple);color:#1a1b23} +button:hover{filter:brightness(1.1)} +button.ghost{background:none;border:1px solid var(--line);color:var(--dim)}button.ghost:hover{color:var(--red);border-color:var(--red)} +.err{color:var(--red);min-height:16px;margin:-6px 0 10px;font-size:11.5px} +.term{background:var(--panel);border:1px solid var(--line);border-radius:8px;overflow:hidden;margin-bottom:14px} +.term-bar{padding:10px 14px;background:#1c1d27;border-bottom:1px solid var(--line);color:var(--dim);font-size:11.5px} +.term-body{padding:12px 16px;overflow-x:auto} +.row{display:grid;grid-template-columns:200px 80px 36px 80px 36px 60px 1fr;line-height:2;white-space:pre;cursor:pointer;border-radius:4px;padding:0 6px} +.row:hover{background:var(--bg)}.row.sel{background:#3a3d52} +.row.head{color:var(--dim);font-weight:700;cursor:default}.row.head:hover{background:none} +.n-disk{color:var(--cyan)}.n-raid{color:var(--purple);font-weight:700}.mt{color:var(--green)}.sw{color:var(--yellow)}.dim{color:var(--dim)}.or{color:var(--orange)} +.info{margin-bottom:12px}.info b{color:var(--cyan)} +.gauge{display:flex;gap:2px;height:44px;border-radius:6px;overflow:hidden;border:1px solid var(--line);background:var(--bg)} +.seg{min-width:6px;display:flex;align-items:center;justify-content:center;color:#1a1b23;font-size:11px;overflow:hidden;cursor:pointer;opacity:.85} +.seg.on,.seg:hover{opacity:1;outline:2px solid var(--fg);outline-offset:-2px} +.seg.free{background:repeating-linear-gradient(45deg,#2c2e3d,#2c2e3d 6px,#34374a 6px,#34374a 12px);color:var(--dim);cursor:default} +.legend{display:flex;flex-wrap:wrap;gap:14px;margin:10px 0 14px;font-size:11px;color:var(--dim)} +.legend i,.dot{display:inline-block;width:10px;height:10px;border-radius:2px;margin-right:5px} +table{width:100%;border-collapse:collapse} +th{text-align:left;color:var(--dim);font-weight:500;padding:6px;border-bottom:1px solid var(--line)} +td{padding:6px;vertical-align:top;border-bottom:1px solid #31344a} +tr[data-act]{cursor:pointer}tr.sel{background:#3a3d52} +.mnt{display:flex;justify-content:space-between;align-items:center;padding:3px 0;color:var(--green)} +.mnt button{width:auto;margin:0;padding:0 6px;background:none;color:var(--dim)}.mnt button:hover{color:var(--red)} diff --git a/autre/lsblk/new/index.html b/autre/lsblk/new/index.html new file mode 100644 index 0000000..38e3031 --- /dev/null +++ b/autre/lsblk/new/index.html @@ -0,0 +1,76 @@ + + + + +lsblk --manager + + + + +

$ lsblk --manager

+

simulateur de disques/partitions — clique un disque ou une partition pour le détail. Sauvegarde auto dans le navigateur.

+ +
+ + +
+
lsblk
+

+

Détail du disque

+
+
+ + + + + + diff --git a/autre/lsblk/new/js/lsblk.js b/autre/lsblk/new/js/lsblk.js new file mode 100644 index 0000000..3ab961a --- /dev/null +++ b/autre/lsblk/new/js/lsblk.js @@ -0,0 +1,95 @@ +// Import (texte lsblk, JSON lsblk -J, JSON exporté par l'outil) et export. +// LVM / crypt / loop sont ignorés à l'import (RAID md géré). +const PFX = '[\\s│├└─|`\\-]*'; + +function addImported(d, list) { + list.forEach(x => { + if (x === '[SWAP]') d.fstype = 'swap'; + else { d.mounts.push({ mp: x, subvol: '' }); if (!d.fstype) d.fstype = '?'; } + }); +} + +// un mdX apparaît sous chacun de ses membres : on ne le crée qu'une fois +function raidFor(name, o, level, member) { + let r = Object.values(S.devs).find(x => x.kind === 'raid' && x.name === name); + const fresh = !r; + if (fresh) r = mk({ ...o, kind: 'raid', name, level, members: [] }); + if (!r.members.includes(member.id)) r.members.push(member.id); + member.fstype = 'linux_raid_member'; member.mounts = []; + return fresh ? r : null; +} + +function fromText(t) { + let disk = null, par = null, last = null; + const re = new RegExp('^' + PFX + '(\\S+)\\s+(\\d+:\\d+)\\s+(\\d)\\s+([\\d.,]+[BKMGT]?)\\s+(\\d)\\s+(\\S+)\\s*(.*)$', 'i'); + const cont = new RegExp('^' + PFX + '(\\/\\S*|\\[SWAP\\])\\s*$'); + t.split('\n').forEach(l => { + const m = l.replace(/\r$/, '').match(re); + if (m) { + const [, name, majmin, rm, size, ro, type, mt] = m; + const o = { name, majmin, rm, ro, size: sz(size) }, rl = type.match(/^raid(\d+)$/i); + last = null; + if (type === 'disk') { disk = mk({ ...o, kind: 'disk' }); S.order.push(disk.id); last = par = disk; } + else if (type === 'part' && disk) { last = par = mk({ ...o, kind: 'part', parent: disk.id }); disk.children.push(last.id); } + else if (rl && par) last = raidFor(name, o, +rl[1], par); + if (last && mt.trim()) addImported(last, [mt.trim()]); + } else if (last) { + const c = l.match(cont); + if (c) addImported(last, [c[1]]); + } + }); +} + +function fromJSON(j) { + const base = (b, kind) => { + const mp = (b.mountpoints || [b.mountpoint]).filter(Boolean); + const swap = mp.includes('[SWAP]'); + return { kind, name: b.name, majmin: b['maj:min'], size: sz(b.size), rm: +b.rm ? '1' : '0', ro: +b.ro ? '1' : '0', + uuid: b.uuid || '', fstype: swap ? 'swap' : (b.fstype || (mp.length ? '?' : '')), label: b.label || '', + used: b.fsused ? sz(b.fsused) : null, mounts: swap ? [] : mp.map(x => ({ mp: x, subvol: '' })) }; + }; + const raids = (b, m) => (b.children || []).forEach(c => { if (/^raid\d+$/i.test(c.type)) raidFor(c.name, base(c, 'raid'), +c.type.slice(4), m); }); + (j.blockdevices || []).forEach(b => { + if (b.type !== 'disk') return; + const d = mk(base(b, 'disk')); S.order.push(d.id); raids(b, d); + (b.children || []).forEach(c => { + if (c.type !== 'part') return; + const p = mk({ ...base(c, 'part'), parent: d.id }); d.children.push(p.id); raids(c, p); + }); + }); + groupPools(); +} + +// btrfs multi-device : mêmes UUID -> un pool (profil inconnu), montages regroupés sur le membre principal +function groupPools() { + const g = {}; + Object.values(S.devs).forEach(d => { if (d.fstype === 'btrfs' && d.uuid) (g[d.uuid] = g[d.uuid] || []).push(d); }); + Object.values(g).filter(a => a.length > 1).forEach(a => { + const id = 'pool' + uid(), prim = a.find(d => d.mounts.length) || a[0]; + S.pools[id] = { id, profile: '?', label: prim.label || '', usable: null, members: a.map(d => d.id), primary: prim.id }; + a.forEach(d => { d.pool = id; if (d !== prim) { prim.mounts.push(...d.mounts); d.mounts = []; } }); + }); +} + +function importAny(text) { + text = text.trim(); + if (!text) return 'Colle une sortie lsblk (texte ou JSON).'; + const bak = { devs: S.devs, order: S.order, pools: S.pools }; + S.devs = {}; S.order = []; S.pools = {}; + try { + if (text[0] === '{') { const j = JSON.parse(text); if (j.devs) { S.devs = j.devs; S.order = j.order; S.pools = j.pools || {}; } else fromJSON(j); } + else fromText(text); + if (!S.order.length) throw 0; + S.sel = S.order[0]; + return ''; + } catch (e) { S.devs = bak.devs; S.order = bak.order; S.pools = bak.pools; return 'Import impossible : format non reconnu.'; } +} + +function toText() { + const R = rows(false); if (!R.length) return ''; + const w = Math.max(4, ...R.map(r => r.name.length)) + 1; + const head = 'NAME'.padEnd(w) + 'MAJ:MIN'.padEnd(8) + 'RM'.padEnd(3) + 'SIZE'.padEnd(8) + 'RO'.padEnd(3) + 'TYPE'.padEnd(6) + 'MOUNTPOINTS'; + return [head, ...R.map(r => r.cont + ? r.name.padEnd(w + 28) + r.mount + : r.name.padEnd(w) + r.d.majmin.padEnd(8) + r.d.rm.padEnd(3) + fmtLsblk(r.d.size).padEnd(8) + r.d.ro.padEnd(3) + typeOf(r.d).padEnd(6) + r.mount)].join('\n'); +} diff --git a/autre/lsblk/new/js/model.js b/autre/lsblk/new/js/model.js new file mode 100644 index 0000000..150861b --- /dev/null +++ b/autre/lsblk/new/js/model.js @@ -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) {} }; diff --git a/autre/lsblk/new/js/ui.js b/autre/lsblk/new/js/ui.js new file mode 100644 index 0000000..81ef5df --- /dev/null +++ b/autre/lsblk/new/js/ui.js @@ -0,0 +1,119 @@ +const $ = id => document.getElementById(id); +const esc = s => String(s).replace(/[&<>"]/g, c => ({ '&': '&', '<': '<', '>': '>', '"': '"' }[c])); +const COL = { ext4: '#8be9fd', btrfs: '#bd93f9', xfs: '#ffb86c', vfat: '#ff79c6', ntfs: '#f1fa8c', zfs: '#50fa7b', swap: '#ff5555', '?': '#a0a4bd', linux_raid_member: '#c9a0ff', '': '#6272a4' }; +const fsLabel = f => f === '?' ? 'inconnu' : f === 'linux_raid_member' ? 'membre RAID' : f || 'non formaté'; +const colorOf = d => COL[d.fstype] || COL['?']; +const fsName = d => fsLabel(d.fstype); +const sel = () => S.devs[S.sel]; +let err = ''; + +const poolTag = p => p.pool && S.pools[p.pool] ? ` pool ${S.pools[p.pool].profile === '?' ? '' : S.pools[p.pool].profile + ' '}×${S.pools[p.pool].members.length}` : ''; +const mountHtml = p => p.fstype === 'swap' ? '[SWAP]' +: host(p).mounts.map(m => esc(m.mp) + (m.subvol ? ` (subvol=${esc(m.subvol)})` : '')).join('
'); + +function renderTree() { + const R = rows(); + $('tree').innerHTML = !R.length ? 'rien à afficher — ajoute un disque ou importe un lsblk' : + '
NAMEMAJ:MINRMSIZEROTYPEMOUNTPOINTS
' + + R.map(r => `
${esc(r.name)}` + + (r.cont ? ''.repeat(5) + : `${r.d.majmin}${r.d.rm}${fmtLsblk(r.d.size)}${r.d.ro}${typeOf(r.d)}`) + + `${esc(r.mount)}
`).join(''); +} + +function renderDetail() { + const d = sel(); + if (!d) { $('detail').innerHTML = 'clique un disque ou une partition'; return; } + if (d.kind === 'raid') { + $('detail').innerHTML = `
${esc(d.name)} · RAID ${d.level} · ${fmtIEC(d.size)} · ${d.majmin} · ${fsName(d)} · ${mountHtml(d)}
` + + '' + d.members.map(m => ``).join('') + '
MembreTaille
${esc(S.devs[m].name)}${fmtIEC(S.devs[m].size)}
'; + return; + } + const dk = diskOf(d), fr = free(dk); + const parts = dk.children.length ? dk.children.map(c => S.devs[c]) : (dk.fstype ? [dk] : []); + const pct = s => s / dk.size * 100; + const gauge = parts.map(p => `
${pct(p.size) > 7 ? esc(p.name) : ''}
`).join('') + + (fr > 0 ? `
${pct(fr) > 7 ? 'libre' : ''}
` : ''); + const fss = [...new Set(parts.map(p => p.fstype))]; + const legend = fss.map(f => `${fsLabel(f)}`).join('') + (fr > 0 ? 'non alloué' : ''); + $('detail').innerHTML = + `
${esc(dk.name)} · ${fmtIEC(dk.size)} · ${dk.majmin} · ${dk.children.length} partition(s) · ${fmtIEC(fr)} libre
` + + `
${gauge}
${legend}
` + + (parts.length ? '' + + parts.map(p => ``).join('') + '
PartitionFSMontagesÉtiquetteTailleUtilisé
${esc(p.name)}${fsName(p)}${poolTag(p)}${mountHtml(p)}${esc(p.label)}${fmtIEC(p.size)}${p.used != null ? fmtIEC(p.used) : '—'}
' : ''); +} + +function renderDevPanel() { + const d = sel(); + if (!d) { $('devPanel').innerHTML = '

Aucune sélection.

'; return; } + const pool = d.pool && S.pools[d.pool], h = host(d); + const canFs = !pool && !(d.kind === 'disk' && d.children.length); + $('devPanel').innerHTML = `
${esc(d.name)} · ${fmtIEC(d.size)} · ${fsName(d)}
` + + (pool ? `

Pool btrfs ${esc(pool.label || '(sans étiquette)')} · profil ${pool.profile === '?' ? 'inconnu' : pool.profile} · ${pool.members.length} périphériques${pool.usable != null ? ' · utilisable ≈ ' + fmtIEC(pool.usable) : ''}
Membres : ${pool.members.map(m => esc(S.devs[m].name)).join(', ')}
Montages portés par ${esc(h.name)}.

` : '') + + (canFs ? ` + ` : pool ? '' : '

Disque partitionné : sélectionne une partition pour la formater/monter.

') + + (h.fstype && h.fstype !== 'swap' ? `` + + h.mounts.map((m, i) => `
${esc(m.mp)}${m.subvol ? ` (subvol=${esc(m.subvol)})` : ''}
`).join('') + + `
` : '') + + ''; +} + +function render() { + save(); + const d = sel(), dk = d && diskOf(d); + $('pTarget').textContent = dk ? `sur ${dk.name} — libre : ${fmtIEC(free(dk))}` : 'sélectionne un disque ou une de ses partitions'; + $('err').textContent = err; + renderTree(); renderDetail(); renderDevPanel(); + const el = eligible(); + $('raidPool').innerHTML = el.length ? el.map(x => ``).join('') : '

aucun périphérique libre (non monté, hors RAID)

'; +} + +function download(name, text) { + const a = document.createElement('a'); + a.href = URL.createObjectURL(new Blob([text], { type: 'application/json' })); + a.download = name; a.click(); URL.revokeObjectURL(a.href); +} + +const ACT = { + sel: t => { S.sel = t.dataset.id; }, + addDisk: () => { + const v = +$('dSize').value, u = $('dUnit').value; + if (!(v > 0)) { err = 'Taille invalide.'; return; } + const mult = $('dDec').checked ? { K: 1e3, M: 1e6, G: 1e9, T: 1e12 }[u] : U[u]; + S.sel = addDisk(Math.round(v * mult), $('dMedia').value).id; + }, + addPart: () => { + const d = sel(), dk = d && diskOf(d); + if (!dk) { err = 'Sélectionne un disque.'; return; } + const b = Math.round(+$('pSize').value * U[$('pUnit').value]); + if (!(b > 0)) { err = 'Taille invalide.'; return; } + if (b > free(dk)) { err = `Espace insuffisant (libre : ${fmtIEC(free(dk))}).`; return; } + S.sel = addPart(dk, b, $('pFs').value).id; + }, + fmt: () => { const d = sel(); if (d && !d.children.length && !d.pool) setFs(d, $('fsSel').value, $('lblIn').value.trim()); }, + mount: () => { const d = sel(); if (d) err = addMount(host(d), $('mpIn').value.trim(), $('svIn').value.trim()); }, + umount: t => { const d = sel(); if (d) host(d).mounts.splice(+t.dataset.i, 1); }, + del: () => { const d = sel(); if (d && confirm(`Supprimer ${d.name}${d.children.length ? ' et ses partitions' : ''} ?`)) delDev(d.id); }, + raid: () => { + const ids = [...document.querySelectorAll('.rchk:checked')].map(c => c.value), [k, v] = $('rLevel').value.split(':'); + err = k === 'md' ? addRaid(ids, +v) : addPool(ids, v, $('rLabel').value.trim()); + }, + unpool: () => { const d = sel(); if (d && d.pool) dissolvePool(d.pool); }, + reset: () => { if (confirm('Tout réinitialiser ?')) { S.devs = {}; S.order = []; S.pools = {}; S.sel = null; } }, + imp: () => { if (!S.order.length || confirm('Remplacer la configuration actuelle ?')) err = importAny($('impTxt').value); }, + exTxt: () => { $('expTxt').value = toText(); }, + copy: () => { navigator.clipboard && navigator.clipboard.writeText($('expTxt').value); }, + exJson: () => download('lsblk-manager.json', JSON.stringify({ devs: S.devs, order: S.order, pools: S.pools }, null, 2)), +}; + +document.addEventListener('click', e => { + const t = e.target.closest('[data-act]'); if (!t) return; + err = ''; ACT[t.dataset.act](t); render(); +}); +$('impFile').addEventListener('change', e => { + const f = e.target.files[0]; if (!f) return; + f.text().then(txt => { if (!S.order.length || confirm('Remplacer la configuration actuelle ?')) { err = importAny(txt); } render(); e.target.value = ''; }); +}); + +$('pFs').innerHTML = ['', ...FS].map(f => ``).join(''); +load(); render(); diff --git a/data/api/mods-mc.php b/data/api/mods-mc.php index 76d8bb3..2f88991 100644 --- a/data/api/mods-mc.php +++ b/data/api/mods-mc.php @@ -1,7 +1,7 @@ '/srv/fabric-1.19.2', + 'Forge 1.20.1' => '/srv/forge-1.20.1', 'Forge 1.19.2' => '/srv/forge-1.19.2', ]; // ---------------------------------- diff --git a/graphs/index.html b/graphs/index.html new file mode 100644 index 0000000..054cb07 --- /dev/null +++ b/graphs/index.html @@ -0,0 +1,316 @@ + + + + + +Tanya : un glouton en chaîne pour l’ensemble indépendant + + + +
+
+

Tanya : un glouton en chaîne pour l’ensemble indépendant

+

Dans un graphe aléatoire, on cherche le plus de sommets possible sans qu’aucun soit relié à un autre. Tanya avance de proche en proche, bannit les sommets très connectés pour libérer leurs voisins, puis améliore son résultat par échanges. Voici un exemple, étape par étape.

+
+ +
+

Un exemple pas à pas sur 12 sommets

+
+ +
    +
  • en jeu (le petit nombre est son nombre de liaisons)
  • +
  • approuvé
  • +
  • banni
  • +
  • bloqué
  • +
  • sommet regardé
  • +
  • candidat
  • +
+

+
+ + + + +
+
+

Cette suite d’étapes vient d’une exécution réelle de l’algorithme (règles sûres et échanges désactivés pour garder l’exemple lisible). Les flèches du clavier font aussi avancer.

+
+ +
+

Le problème en bref

+
+
Graphe aléatoire G(n, c/n)
+
n sommets, chaque liaison étant présente avec probabilité c/n. Le nombre c est le degré moyen.
+
Ensemble indépendant
+
Un ensemble de sommets où aucun n’est relié à un autre de l’ensemble.
+
In et i
+
In est la taille maximale d’un ensemble indépendant. La proportion In / n tend vers une limite i, qui ne dépend que de c.
+
An
+
La taille de l’ensemble que trouve un algorithme. On a toujours An ≤ In, et on mesure la qualité par l’écart i − An / n.
+
Le seuil c = e ≈ 2,718
+
Pour c < e, les règles simples (prendre un sommet qui a 0 ou 1 liaison) suffisent à résoudre le graphe. Au-delà, les algorithmes simples restent en dessous de i.
+
+
+ +
+

L’algorithme en mots

+
+

Tanya lance plusieurs essais indépendants (20 par défaut) et garde le meilleur. Chaque essai a quatre temps.

+
    +
  1. Règles sûres, appliquées au début puis après chaque pas de la chaîne. Elles ne font jamais perdre l’optimum : +
      +
    • un sommet à 0 ou 1 liaison est pris (il entre dans la sélection, ses voisins sortent du jeu) ;
    • +
    • un sommet à 2 liaisons dont les deux voisins sont reliés (triangle) est pris ;
    • +
    • domination : si tous les voisins d’un sommet v sont aussi voisins d’un voisin u de v (v et u compris), on bannit u.
    • +
    +
  2. +
  3. La chaîne. +
      +
    1. On part d’un sommet v de degré maximal (égalités tranchées par numéro au premier essai, au hasard ensuite). Ses voisins sont les candidats, et v est le sommet à bannir.
    2. +
    3. Parmi les candidats, on garde w, celui qui a le moins de liaisons.
    4. +
    5. On bannit le sommet à bannir : il sort du jeu sans être choisi, et ses voisins perdent une liaison.
    6. +
    7. Si w a alors moins de 2 liaisons, il est approuvé : il entre dans la sélection et son éventuel voisin restant est bloqué. La chaîne repart des voisins encore en jeu de ce sommet bloqué, sans nouveau bannissement.
    8. +
    9. Sinon, w devient le sommet courant : ses voisins sont les nouveaux candidats et c’est lui qu’on bannira au pas suivant.
    10. +
    11. Sans candidat, on repart d’un autre sommet de degré maximal. Un sommet isolé est approuvé directement.
    12. +
    +
  4. +
  5. Reprise. Certains sommets bannis n’ont finalement aucun voisin choisi. On les ajoute, ce qui rend la sélection maximale.
  6. +
  7. Échanges (c’est ici que l’algorithme revient sur des choix) : +
      +
    • échange 1-2 : on retire un sommet choisi pour en ajouter deux libres, non reliés entre eux ;
    • +
    • échange 2-3 : un sommet non choisi touche exactement deux sommets choisis a et b. On retire a et b, et on ajoute trois sommets non reliés entre eux, pris parmi ceux qui ne touchaient que a ou b.
    • +
    + On répète jusqu’à ce qu’aucun échange ne marche. +
  8. +
+

Le résultat est toujours un ensemble indépendant valide et maximal. Pour c < e, les règles sûres vident à elles seules le graphe et l’algorithme atteint i. Pour c > e, il reste des sommets de degré au moins 2 : c’est le bannissement et les échanges qui travaillent.

+
+
+ +
+

Sur 100 sommets

+

Graphe aléatoire de 100 sommets et 267 liaisons (c = 5), premier essai. Tanya choisit 44 sommets, soit l’optimum exact. Min-degré en trouve 41.

+ Graphe de 100 sommets après TanyaSommets choisis par la chaîne, ajoutés ensuite, bannis ou bloqués, avec le premier trajet de la chaîne en orange.18756867818 + +
+

Le trait orange est le premier départ. Le sommet 18 a 11 liaisons : c’est le maximum, on le bannit. Son voisin 75 n’a plus qu’une liaison, il est approuvé et bloque 68. La chaîne repart des voisins de 68, bannit 67 puis 81, et approuve 8. Le sommet 67 est ensuite récupéré par la reprise, puisqu’il n’a plus de voisin choisi.

+

La chaîne ne se lance que 3 fois sur ce graphe, car les règles sûres font une grande partie du travail. Deux échanges 2-3 portent la sélection de 42 à 44 sommets.

+
+
+ +
+

Résultats à n = 1000 et c = 4

+

Trois graphes (graines 1, 2 et 3), chacun avec environ 2 000 liaisons et 97 à 99 % des sommets dans la même composante connexe. Les valeurs sont le nombre de sommets sélectionnés.

+
+ + +
MéthodeGraphe 1Graphe 2Graphe 3MoyenneAn / nTemps
min-degré461474468467,70,468< 0,01 s
hybride469477468471,30,471< 0,01 s
hybride + échanges 1-2469477470472,00,4720,01 s
Tanya (20 essais)469475470471,30,4710,55 s
exact (60 s, non terminé)471479470473,30,47360 s
ILS (5 s)471480473474,70,4755,01 s
+
+

L’exact (programmation linéaire en nombres entiers) a atteint sa limite de 60 secondes sur les trois graphes : son résultat est une borne basse de In, pas une valeur prouvée optimale. L’ILS, en 5 secondes, égale ou dépasse l’exact sur les trois graphes (il le dépasse sur deux). La meilleure valeur connue est donc celle de l’ILS, environ 0,475, et Tanya en est à environ 0,003.

+

Tanya passe devant min-degré et rejoint l’hybride en une demi-seconde, mais reste un peu sous l’ILS, qui défait des choix de façon répétée sur toute sa durée.

+
+

Ce que chaque étape apporte

+
+ + +
VersionGraphe 1Graphe 2Graphe 3MoyenneTemps
chaîne + règles sûres, sans reprise ni échanges413422409414,70,19 s
+ reprise des sommets libres456464460460,00,21 s
+ échanges 1-2 et 2-3 (1 essai)464475463467,30,02 s
20 essais469475472472,00,47 s
100 essais470478472473,32,26 s
+
+

La chaîne seule, sans reprise, est faible (environ 415). La reprise et les échanges font presque tout le reste. Passer de 20 à 100 essais ne gagne plus que 1,3 sommet en moyenne : les essais se ressemblent trop, il faut améliorer la construction plutôt que les répéter.

+

Tanya varie de 1 à 2 sommets selon la graine du hasard (les deux tableaux ont été tirés avec des graines différentes). Trois graphes seulement : ce sont des ordres de grandeur, pas une étude statistique.

+
+
+ +
+

Ce que l’on sait de i(c)

+
+

Pour c < e, on a une formule exacte avec la fonction W de Lambert (W eW = c) :

+
i(c) = (2·W(c) + W(c)²) / (2c)
+

Mesure avec la suppression de feuilles seule (règle « 0 ou 1 liaison »), à n = 100 000, qui est exacte dans ce régime :

+
+
+ + + + + + + +
cMesuréFormule
0,50,82770,8272
10,72930,7280
20,60940,6080
2,50,56810,5672
+
+

Proche de e (à c = 2,7), il reste à n fini un noyau de sommets que cette règle ne traite pas, et la mesure s’écarte un peu de la formule (0,5499 contre 0,5531).

+

Pour c > e, il n’y a pas de formule simple. Les algorithmes gloutons classiques atteignent environ n·ln(c)/c sommets, alors que le maximum est d’environ 2n·ln(c)/c pour c grand. Combler cet écart avec un algorithme rapide est le sujet ouvert.

+
+
+ +
+

Pistes d’amélioration

+
+

Ce sont des hypothèses, non testées à ce jour.

+
    +
  1. Repliement des sommets de degré 2. Si v a deux voisins u et w non reliés, on fusionne les trois en un seul sommet, et la solution gagne un sommet au dépliage. C’est la règle exacte la plus forte après « 0 ou 1 liaison ».
  2. +
  3. Échanges 1-1 sur plateau. Permuter un sommet choisi avec un voisin non choisi sans changer la taille, pour ouvrir de nouveaux échanges 1-2.
  4. +
  5. Meilleur arbitrage des égalités. Préférer, à degré égal, le voisin dont les voisins sont les plus connectés.
  6. +
  7. Départs plus variés. Choisir le sommet de départ au hasard parmi les sommets de degré presque maximal.
  8. +
+
+
+ + +
+ + + + diff --git a/graphs/tanya.txt b/graphs/tanya.txt new file mode 100644 index 0000000..b2212de --- /dev/null +++ b/graphs/tanya.txt @@ -0,0 +1,49 @@ +Stats chaîne vs exact (In) vs ILS +1000n 10c +essai 1 : +ILS (3s) : 315 (100%) +chaîne (300 essais) : 304 (96,5%) +exact (150s) : 269 (85,4%) + +essai 2 : +ILS (3s) : 317 (100%) +chaîne (300 essais) : 313 (98,7%) +exact (150s) : 276 (87,1%) + +essai 3 : +ILS (3s) : 318 (100%) +chaîne (300 essais) : 309 (97,2%) +exact (150s) : 266 (83,6%) + +essai 4 : +ILS (3s) : 320 (100%) +chaîne (300 essais) : 313 (97,8%) +exact (150s) : 267 (83,4%) + +1000n 15c +essai 1 : +ILS (3s) : 247 (100%) +chaîne (300 essais) : 238 (96,4%) +exact (150s) : 199 (80,6%) + +essai 2 : +ILS (3s) : 252 (100%) +chaîne (300 essais) : 245 (97,2%) +exact (150s) : 203 (80,6%) + +essai 3 : +ILS (3s) : 250 (100%) +chaîne (300 essais) : 239 (95,6%) +exact (150s) : 199 (79,6%) + +essai 4 : +ILS (3s) : 251 (100%) +chaîne (300 essais) : 245 (97,6%) +exact (150s) : 207 (82,5%) + +moyennes +Configuration ILS Chaîne Exact +1000n – 10c 317,5 309,75 269,5 +1000n – 15c 250 241,75 202 +10c (%) 100 % 97,55 % 84,88 % +15c (%) 100 % 96,70 % 80,83 % diff --git a/tests/index.html b/tests/index.html index 7ed99a8..28e4f7f 100644 --- a/tests/index.html +++ b/tests/index.html @@ -6,23 +6,47 @@ -
-
- Steam + + +

TEST TITRE

+
emerge --ask --getbinpkg --binpkg-respect-use=n --update --deep --newuse @world
+ +
+ +
+ +

TEST

+
+ TEST2 +
+ +
+ TEST2 +
+ +
+ TEST2 +
+ +
+ TEST2 +
+ +
+ +
+ +

TEST

+
+ TEST2 +
+
-
-
-
-
asd
-
asd
-
+ -
-
asd
-
asd
-
+ diff --git a/tests/script.js b/tests/script.js index 5e7c52a..6f49d42 100644 --- a/tests/script.js +++ b/tests/script.js @@ -1,14 +1 @@ -var couleurs = [ - "red", - "blue", - "gray", - "black", - "purple", - "pink", - "green" -]; - -if (true == true) { - var random = Math.floor(Math.random() * couleurs.length); - document.getElementById("rainbow").style.color = couleurs[random]; -} +console.log("Le site est pas fini hein") diff --git a/tests/style.css b/tests/style.css index 2424d0d..6341e95 100644 --- a/tests/style.css +++ b/tests/style.css @@ -4,39 +4,96 @@ html { font-family: 'Comfortaa', cursive; } -#DivG, #DivM, #DivD { - border: 2px solid rgb(95 97 110); - border-radius: 0.5em; - width: 300px; - height: 100px; - margin-right: 10px; - float: left; - text-align: center; - width: 600px; - align-content: center; +.large { + width: 80%; } -.DivLien { - border: 2px solid rgb(95 97 110); - border-radius: 0.5em; +body { + background: url(../data/fond/Pino.png) no-repeat center center fixed; +} + +.parent { + padding: 1rem; +} + +.grid-parent { + background: yellow; + display: grid; + grid-template-columns: 1fr 1fr; +} + +.child { + background: pink; + padding: 1rem; + margin: 0 auto; +} + +.divclic { + border-radius: 10px; + background: lightblue; + margin: 1% auto; width: 500px; height: 100px; - align-content: center; + text-align: center; + overflow-wrap: anywhere; + padding: 20px; + display: flex; + justify-content: center; + align-items: center; } +/* Alignement au centre et espacé des autre éléments */ + +.centre { + text-align: center; +} + +.pad { + padding: 20px; +} + +/* Animation multicolor */ + .mimicolor { - font-family: monospace; + font-family: Comfortaa; font-size: 3em; animation: color-change 1s infinite; } @keyframes color-change { - 0% { color: #cc0001; } - 16% { color: #fb940b; } - 32% { color: #ffff01; } - 48% { color: #01cc00; } - 64% { color: #03c0c6; } - 80% { color: #0000fe; } - 90% { color: #762ca7; } - 100% { color: #fe98bf; } + 0% { color: #ff0000; } + 10% { color: #ff5300; } + 20% { color: #ffa500; } + 30% { color: #ffd200; } + 40% { color: #ffff00; } + 50% { color: #80c000; } + 60% { color: #008000; } + 70% { color: #004080; } + 80% { color: #0000ff; } + 90% { color: #2600c1; } + 100% { color: #4b0082; } +} + +/* Apparence des LIENS */ + +a { + color: white; + background-color: black; + font-weight: bold; +} + +a:link { + text-decoration: none; +} + +a:visited { + text-decoration: none; +} + +a:hover { + text-decoration: none; +} + +a:active { + text-decoration: none; }