nosignal/nosignal-shell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

systemusage: optimized storage aggregation and improved device filtering (#1261)

Browse source 
* refactor: Optimized storage aggregation

+ The storage aggregation logic doesn't account more complex storage
setups and relied too much on risky string parsing to guess where
partitions are. For example, in my case, I had a LUKS-encrypted drive
which lives inside a "crypt," because it couldn't match the type (it
only matched "disk" and "part"), it did not include my entire drive at
all. Also, Linux devices names aren't always predictable (take mapper
devices or complex NVMe paths), so if the RegEx doesn't match the name
of those devices, the data just dissapears.

I decided to go for a JSON approach making the code shorter and safer.

Everything should work about the same.

* systemusage: More intuitive filtering for storage devices

+ Removes "useless" drives from being show on the storage dashboard
+ Prioritizes the root disk to be shown first

* refactor: formatted code properly
This commit is contained in:
Kalagmitan 2026-03-15 14:49:37 +08:00 • committed by GitHub
parent bffe29e6b7
commit dd2d7dceab
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 58 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

129
services/SystemUsage.qml
View file

@ -138,91 +138,78 @@ Singleton {
Process { Process {
id: storage id: storage
// Get physical disks with aggregated usage from their partitions // Get physical disks with aggregated usage from their partitions
// lsblk outputs: NAME SIZE TYPE FSUSED FSSIZE in bytes // -J triggers JSON output. -b triggers bytes.
command: ["lsblk", "-b", "-o", "NAME,SIZE,TYPE,FSUSED,FSSIZE", "-P"] command: ["lsblk", "-J", "-b", "-o", "NAME,SIZE,TYPE,FSUSED,FSSIZE,MOUNTPOINT"]
stdout: StdioCollector { stdout: StdioCollector {
onStreamFinished: { onStreamFinished: {
const diskMap = {}; // Map disk name -> { name, totalSize, used, fsTotal } const data = JSON.parse(text);
const lines = text.trim().split("\n"); const diskList = [];
const seenDevices = new Set();
for (const line of lines) { // Helper to recursively sum usage from children (partitions, crypt, lvm)
if (line.trim() === "") const aggregateUsage = dev => {
continue; let used = 0;
let size = 0;
let isRoot = dev.mountpoint === "/" || (dev.mountpoints && dev.mountpoints.includes("/"));
// Parse KEY="VALUE" format if (!seenDevices.has(dev.name)) {
const nameMatch = line.match(/NAME="([^"]+)"/); // lsblk returns null for empty/unformatted partitions, which parses to 0 here
const sizeMatch = line.match(/SIZE="([^"]+)"/); used = parseInt(dev.fsused) || 0;
const typeMatch = line.match(/TYPE="([^"]+)"/); size = parseInt(dev.fssize) || 0;
const fsusedMatch = line.match(/FSUSED="([^"]*)"/); seenDevices.add(dev.name);
const fssizeMatch = line.match(/FSSIZE="([^"]*)"/); }
if (!nameMatch || !typeMatch) if (dev.children) {
continue; for (const child of dev.children) {
const stats = aggregateUsage(child);
used += stats.used;
size += stats.size;
if (stats.isRoot)
isRoot = true;
}
}
return {
used,
size,
isRoot
};
};
const name = nameMatch[1]; for (const dev of data.blockdevices) {
const type = typeMatch[1]; // Only process physical disks at the top level
const size = parseInt(sizeMatch?.[1] || "0", 10); if (dev.type === "disk" && !dev.name.startsWith("zram")) {
const fsused = parseInt(fsusedMatch?.[1] || "0", 10); const stats = aggregateUsage(dev);
const fssize = parseInt(fssizeMatch?.[1] || "0", 10);
if (type === "disk") { if (stats.size === 0) {
// Skip zram (swap) devices
if (name.startsWith("zram"))
continue; continue;
// Initialize disk entry
if (!diskMap[name]) {
diskMap[name] = {
name: name,
totalSize: size,
used: 0,
fsTotal: 0
};
} }
} else if (type === "part") {
// Find parent disk (remove trailing numbers/p+numbers)
let parentDisk = name.replace(/p?\d+$/, "");
// For nvme devices like nvme0n1p1, parent is nvme0n1
if (name.match(/nvme\d+n\d+p\d+/))
parentDisk = name.replace(/p\d+$/, "");
// Aggregate partition usage to parent disk const total = stats.size;
if (diskMap[parentDisk]) { const used = stats.used;
diskMap[parentDisk].used += fsused;
diskMap[parentDisk].fsTotal += fssize; diskList.push({
} mount: dev.name,
used: used / 1024 // KiB
,
total: total / 1024 // KiB
,
free: (total - used) / 1024,
perc: total > 0 ? used / total : 0,
hasRoot: stats.isRoot
});
} }
} }
// Convert map to sorted array // Sort by putting the disk with root first, then sort the rest alphabetically
const diskList = []; root.disks = diskList.sort((a, b) => {
let totalUsed = 0; if (a.hasRoot && !b.hasRoot)
let totalSize = 0; return -1;
if (!a.hasRoot && b.hasRoot)
for (const diskName of Object.keys(diskMap).sort()) { return 1;
const disk = diskMap[diskName]; return a.mount.localeCompare(b.mount);
// Use filesystem total if available, otherwise use disk size });
const total = disk.fsTotal > 0 ? disk.fsTotal : disk.totalSize;
const used = disk.used;
const perc = total > 0 ? used / total : 0;
// Convert bytes to KiB for consistency with formatKib
diskList.push({
mount: disk.name // Using 'mount' property for compatibility
,
used: used / 1024,
total: total / 1024,
free: (total - used) / 1024,
perc: perc
});
totalUsed += used;
totalSize += total;
}
root.disks = diskList;
} }
} }
} }