tassello 0.2.0 → 0.3.0

package/dist/server/diagnostics_state.js

@@ -0,0 +1,146 @@
+// The robot's diagnostics as the server keeps them for the diagnostics widgets
+// (diagnostics.ts): the latest status of each name, stale once no longer
+// received, their latest changes of level, and what the pages have yet to get.
+// diagnostic_msgs/msg/DiagnosticStatus's levels
+const OK = 0;
+const STALE = 3;
+// A status not received for this long, nor for this many of its periods, is
+// stale: the aggregator's default timeout, and room for slower publishers
+// (diagnostic_updater publishes once a second by default)
+export const STALE_AFTER_MS = 5000;
+const STALE_PERIODS = 3;
+function text(value) {
+    return typeof value === 'string' ? value : '';
+}
+function count(value) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+}
+function keyValues(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((pair) => {
+        const fields = (pair ?? {});
+        return { key: text(fields.key), value: text(fields.value) };
+    });
+}
+function sameValues(a, b) {
+    return a.length === b.length && a.every((pair, i) => pair.key === b[i].key && pair.value === b[i].value);
+}
+// The level a status is at: STALE when stale, else as published
+export function levelOf(entry) {
+    return entry.stale ? STALE : entry.level;
+}
+export class DiagnosticsState {
+    capacity;
+    // By name
+    statuses = new Map();
+    // Oldest first, with up to an eighth of capacity more: dropped in chunks,
+    // not one by one
+    changes = [];
+    lastId = 0;
+    // The seq of the latest change, and of the latest taken in a batch
+    lastSeq = 0;
+    taken = 0;
+    // Changed since the last batch
+    dirty = new Set();
+    // Of the changes kept
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    // A diagnostic_msgs/msg/DiagnosticArray, from rclnodejs, received at now
+    add(raw, now) {
+        const { status } = (raw ?? {});
+        if (Array.isArray(status)) {
+            for (const fields of status) {
+                if (fields && typeof fields === 'object') {
+                    this.addStatus(fields, now);
+                }
+            }
+        }
+    }
+    // Marks stale the statuses no longer received
+    checkStale(now) {
+        for (const kept of this.statuses.values()) {
+            const { entry } = kept;
+            if (entry.stale || now - entry.updated <= Math.max(STALE_AFTER_MS, STALE_PERIODS * kept.period)) {
+                continue;
+            }
+            const before = levelOf(entry);
+            entry.stale = true;
+            this.dirty.add(kept);
+            if (before !== STALE) {
+                this.change(entry, now);
+            }
+        }
+    }
+    // All the statuses and changes kept: what a new page gets
+    snapshot() {
+        return {
+            statuses: [...this.statuses.values()].map((kept) => ({ ...kept.entry })),
+            changes: this.changes.slice(-this.capacity),
+        };
+    }
+    // The statuses changed and the changes since the last batch; null if none
+    takeBatch() {
+        const fresh = this.lastSeq - this.taken;
+        if (this.dirty.size === 0 && fresh === 0) {
+            return null;
+        }
+        const statuses = [...this.dirty].map((kept) => ({ ...kept.entry }));
+        this.dirty.clear();
+        this.taken = this.lastSeq;
+        const kept = Math.min(fresh, this.capacity);
+        return { statuses, changes: kept > 0 ? this.changes.slice(-kept) : [] };
+    }
+    addStatus(fields, now) {
+        const next = {
+            name: text(fields.name),
+            level: count(fields.level),
+            message: text(fields.message),
+            hardwareId: text(fields.hardware_id),
+            values: keyValues(fields.values),
+        };
+        const kept = this.statuses.get(next.name);
+        if (!kept) {
+            const entry = { id: ++this.lastId, ...next, stale: false, updated: now, since: now };
+            const added = { entry, period: 0 };
+            this.statuses.set(next.name, added);
+            this.dirty.add(added);
+            if (entry.level !== OK) {
+                this.change(entry, now);
+            }
+            return;
+        }
+        const { entry } = kept;
+        kept.period = now - entry.updated;
+        entry.updated = now;
+        if (!entry.stale &&
+            entry.level === next.level &&
+            entry.message === next.message &&
+            entry.hardwareId === next.hardwareId &&
+            sameValues(entry.values, next.values)) {
+            return;
+        }
+        const before = levelOf(entry);
+        Object.assign(entry, next, { stale: false });
+        this.dirty.add(kept);
+        if (levelOf(entry) !== before) {
+            this.change(entry, now);
+        }
+    }
+    change(entry, now) {
+        entry.since = now;
+        this.changes.push({
+            seq: ++this.lastSeq,
+            time: now,
+            status: entry.id,
+            level: levelOf(entry),
+            message: entry.message,
+        });
+        if (this.changes.length >= this.capacity + Math.ceil(this.capacity / 8)) {
+            this.changes.splice(0, this.changes.length - this.capacity);
+        }
+    }
+}

package/dist/server/disks.d.ts

@@ -0,0 +1,14 @@
+import type { FsDisk, FsSpace } from '../shared/file_manager.ts';
+export interface Mount {
+    device: string;
+    mount: string;
+    source: string;
+    type: string;
+    readOnly: boolean;
+}
+export declare function parseMountInfo(text: string): Mount[];
+export declare function storageMounts(mounts: Mount[]): Mount[];
+export declare function mountOf(file: string, mounts: Mount[]): Mount | null;
+export declare function readMounts(): Promise<Mount[]>;
+export declare function spaceOf(folder: string): Promise<FsSpace | null>;
+export declare function listDisks(): Promise<FsDisk[]>;

package/dist/server/disks.js

@@ -0,0 +1,152 @@
+// The robot's file systems, for the file manager: the mounts of
+// /proc/self/mountinfo that hold files (not proc, sysfs, cgroups, snaps...),
+// with their size and free space, and the one a path is on.
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+// File systems that hold no files of the robot's
+const PSEUDO = new Set([
+    'autofs',
+    'binfmt_misc',
+    'bpf',
+    'cgroup',
+    'cgroup2',
+    'configfs',
+    'debugfs',
+    'devpts',
+    'devtmpfs',
+    'efivarfs',
+    'fusectl',
+    'fuse.gvfsd-fuse',
+    'fuse.portal',
+    'fuse.snapfuse',
+    'hugetlbfs',
+    'mqueue',
+    'nsfs',
+    'proc',
+    'pstore',
+    'ramfs',
+    'rpc_pipefs',
+    'securityfs',
+    'selinuxfs',
+    'squashfs',
+    'sysfs',
+    'tracefs',
+]);
+// Mounts of the system's own, below these
+const HIDDEN_UNDER = ['/proc', '/sys', '/dev', '/run', '/snap', '/var/snap', '/var/lib/docker', '/boot/efi'];
+// statfs of a network share that went away hangs: given up after this
+const STATFS_TIMEOUT_MS = 2000;
+// The mount table changes rarely: read again after this
+const MOUNTS_TTL_MS = 10_000;
+// \040 for a space, as the kernel escapes them
+function unescape(field) {
+    return field.replace(/\\([0-7]{3})/g, (_, octal) => String.fromCharCode(parseInt(octal, 8)));
+}
+// The lines of /proc/self/mountinfo:
+//   36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
+export function parseMountInfo(text) {
+    const mounts = [];
+    for (const line of text.split('\n')) {
+        const fields = line.trim().split(' ');
+        const separator = fields.indexOf('-', 6);
+        if (fields.length < 10 || separator < 0 || separator + 2 >= fields.length) {
+            continue;
+        }
+        mounts.push({
+            device: fields[2],
+            mount: unescape(fields[4]),
+            source: unescape(fields[separator + 2]),
+            type: fields[separator + 1],
+            readOnly: fields[5].split(',').includes('ro'),
+        });
+    }
+    return mounts;
+}
+function under(file, folder) {
+    return file === folder || file.startsWith(folder.endsWith('/') ? folder : `${folder}/`);
+}
+// The mounts worth showing: not pseudo file systems, nor the system's own
+// (/run, /snap), nor RAM (but /tmp), each device once, at its shortest mount
+// point (others are bind mounts of it)
+export function storageMounts(mounts) {
+    const kept = new Map();
+    for (const mount of mounts) {
+        const media = under(mount.mount, '/run/media') || under(mount.mount, '/media');
+        if (PSEUDO.has(mount.type) ||
+            (mount.type === 'tmpfs' && mount.mount !== '/tmp') ||
+            // A container's root
+            (mount.type === 'overlay' && mount.mount !== '/') ||
+            (!media && HIDDEN_UNDER.some((folder) => under(mount.mount, folder)))) {
+            continue;
+        }
+        const known = kept.get(mount.device);
+        if (!known || mount.mount.length < known.mount.length) {
+            kept.set(mount.device, mount);
+        }
+    }
+    return [...kept.values()].sort((a, b) => a.mount.localeCompare(b.mount));
+}
+// The mount a path is on, of those given: the deepest that holds it
+export function mountOf(file, mounts) {
+    let found = null;
+    for (const mount of mounts) {
+        if (under(file, mount.mount) && (!found || mount.mount.length >= found.mount.length)) {
+            found = mount;
+        }
+    }
+    return found;
+}
+let cached = null;
+export function readMounts() {
+    if (!cached || Date.now() - cached.at > MOUNTS_TTL_MS) {
+        cached = {
+            at: Date.now(),
+            mounts: fs.readFile('/proc/self/mountinfo', 'utf8').then(parseMountInfo, () => []),
+        };
+    }
+    return cached.mounts;
+}
+async function statfs(folder) {
+    let timer;
+    const timeout = new Promise((resolve) => (timer = setTimeout(() => resolve(null), STATFS_TIMEOUT_MS)));
+    try {
+        return await Promise.race([fs.statfs(folder).catch(() => null), timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// Of the file system a folder is on; null if not known
+export async function spaceOf(folder) {
+    const [stats, mounts] = await Promise.all([statfs(folder), readMounts()]);
+    if (!stats) {
+        return null;
+    }
+    const real = await fs.realpath(folder).catch(() => folder);
+    return {
+        mount: mountOf(real, mounts)?.mount ?? path.parse(real).root,
+        total: stats.blocks * stats.bsize,
+        free: stats.bavail * stats.bsize,
+    };
+}
+// The robot's file systems, by mount point
+export async function listDisks() {
+    const mounts = storageMounts(await readMounts());
+    const disks = await Promise.all(mounts.map(async (mount) => {
+        const stats = await statfs(mount.mount);
+        if (!stats || stats.blocks === 0) {
+            return null;
+        }
+        return {
+            mount: mount.mount,
+            device: mount.source,
+            type: mount.type,
+            readOnly: mount.readOnly,
+            total: stats.blocks * stats.bsize,
+            used: (stats.blocks - stats.bfree) * stats.bsize,
+            free: stats.bavail * stats.bsize,
+            inodes: stats.files > 0 ? { total: stats.files, free: stats.ffree } : null,
+        };
+    }));
+    return disks.filter((disk) => disk !== null);
+}

package/dist/server/file_manager.d.ts

@@ -0,0 +1,25 @@
+import { type FsAnalysis, type FsConflict, type FsDetails, type FsListing, type FsPlaces, type FsResult, type FsSaved, type FsText } from '../shared/file_manager.ts';
+import { HttpError } from './panels.ts';
+export declare const collator: Intl.Collator;
+export declare function fsError(e: unknown, what: string): HttpError;
+export declare function resolvePath(input: unknown, home?: string): string;
+export declare function checkName(name: unknown): string;
+export declare function numberedName(name: string, n: number): string;
+export declare function listFolder(folder: string): Promise<FsListing>;
+export declare function entryDetails(file: string): Promise<FsDetails>;
+export declare function listPlaces(home?: string, prefixes?: string): FsPlaces;
+export declare function makeFolder(folder: string): Promise<FsResult>;
+export declare function makeFile(file: string): Promise<FsResult>;
+export declare function renameEntry(file: string, name: string, home?: string): Promise<FsResult>;
+export declare function transfer(op: 'move' | 'copy', sources: string[], to: string, conflict: FsConflict, home?: string): Promise<FsResult>;
+export declare function deleteEntries(files: string[], home?: string): Promise<FsResult>;
+export declare function changeMode(file: string, mode: unknown): Promise<FsResult>;
+export declare function readText(file: string, known?: string | null): Promise<FsText | null>;
+export declare function saveText(file: string, text: string, base: string | null, create: boolean): Promise<FsSaved>;
+export declare function uploadTarget(folder: string, name: string, conflict: FsConflict): Promise<string | null>;
+export declare function receiveFile(body: AsyncIterable<Buffer>, target: string, maxBytes: number): Promise<number>;
+export declare function archiveArguments(files: string[]): string[];
+export declare function analyzeFolder(root: string, limits?: {
+    ms: number;
+    entries: number;
+}): Promise<FsAnalysis>;