tassello 0.4.0 → 0.6.0

package/dist/server/interfaces.js

@@ -0,0 +1,145 @@
+// The ROS interfaces (messages, services, actions) for the monitor widgets:
+// their definitions as ros2 interface show prints them, from the files of
+// their packages; their schemas and default values, from rclnodejs's code of
+// them; and the JSON of the pages made into their messages.
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import rclnodejs from 'rclnodejs';
+import { defaultMessage, expandDefinition, HEADER_TYPE, parseType, partTypes, toRosMessage, } from './message_format.js';
+import { missingCodeHint } from './message_code.js';
+import { errorMessage, packageShareDirectory } from './util.js';
+function load(type) {
+    let typeClass;
+    try {
+        typeClass = rclnodejs.require(type);
+    }
+    catch (e) {
+        throw new Error(missingCodeHint(errorMessage(e)));
+    }
+    if (!typeClass?.ROSMessageDef) {
+        throw new Error(`${type} is not a message type`);
+    }
+    return typeClass;
+}
+// A field's message type, pkg/<msg|srv|action>/Name: rclnodejs tells only
+// its package and name, which the parts of services and actions share
+function nestedType(pkg, name) {
+    const kinds = /_(Request|Response|Event)$/.test(name)
+        ? ['srv', 'msg', 'action']
+        : /_(Goal|Result|Feedback|FeedbackMessage|SendGoal_Request|SendGoal_Response|GetResult_Request|GetResult_Response)$/.test(name)
+            ? ['action', 'msg', 'srv']
+            : ['msg', 'action', 'srv'];
+    for (const kind of kinds) {
+        try {
+            if (rclnodejs.require(`${pkg}/${kind}/${name}`)?.ROSMessageDef) {
+                return `${pkg}/${kind}/${name}`;
+            }
+        }
+        catch {
+            // Not of this kind
+        }
+    }
+    return `${pkg}/msg/${name}`;
+}
+function plain(value) {
+    if (ArrayBuffer.isView(value)) {
+        return Array.from(value, (v) => (typeof v === 'bigint' ? Number(v) : v));
+    }
+    return typeof value === 'bigint' ? Number(value) : value;
+}
+export class Interfaces {
+    node;
+    schemas = new Map();
+    infos = new Map();
+    constructor(node) {
+        this.node = node;
+    }
+    // The schema of a message type, and of those it nests
+    schemasOf(type, into = {}) {
+        if (into[type]) {
+            return into;
+        }
+        const schema = this.schema(type);
+        into[type] = schema;
+        for (const field of schema.fields) {
+            if (!field.primitive) {
+                this.schemasOf(field.type, into);
+            }
+        }
+        return into;
+    }
+    // ros2 interface show, and the schemas and default values of its parts
+    info(type) {
+        const known = this.infos.get(type);
+        if (known) {
+            return known;
+        }
+        const { pkg, kind, name } = parseType(type);
+        const schemas = {};
+        const parts = partTypes(type).map((part) => {
+            this.schemasOf(part.type, schemas);
+            return { ...part, default: defaultMessage(part.type, schemas) };
+        });
+        const info = { type, kind, text: this.definition(pkg, kind, name), parts, schemas };
+        this.infos.set(type, info);
+        return info;
+    }
+    // The message of type the page's JSON describes (see toRosMessage)
+    message(type, value) {
+        return toRosMessage(value, type, this.schemasOf(type), () => this.now());
+    }
+    // Its messages begin with a std_msgs/msg/Header, whose stamp ros2 topic
+    // delay compares with their arrival
+    hasHeader(type) {
+        try {
+            const first = this.schema(type).fields[0];
+            return first?.name === 'header' && first.type === HEADER_TYPE;
+        }
+        catch {
+            return false;
+        }
+    }
+    // On the ROS clock: the simulation's with use_sim_time
+    now() {
+        const { seconds, nanoseconds } = this.node.getClock().now().secondsAndNanoseconds;
+        return { sec: Number(seconds), nanosec: Number(nanoseconds) };
+    }
+    schema(type) {
+        const known = this.schemas.get(type);
+        if (known) {
+            return known;
+        }
+        const { ROSMessageDef: def } = load(type);
+        const schema = {
+            fields: def.fields.map(({ name, type: t, default_value }) => ({
+                name,
+                type: t.isPrimitiveType ? t.type : nestedType(t.pkgName ?? '', t.type),
+                primitive: t.isPrimitiveType,
+                array: !t.isArray ? 'none' : t.isFixedSizeArray ? 'fixed' : t.isUpperBound ? 'bounded' : 'dynamic',
+                size: t.isArray && (t.isFixedSizeArray || t.isUpperBound) ? t.arraySize : null,
+                stringBound: t.stringUpperBound ?? null,
+                default: plain(default_value) ?? null,
+            })),
+            constants: def.constants.map(({ name, type: t, value }) => ({ name, type: t, value: plain(value) })),
+        };
+        this.schemas.set(type, schema);
+        return schema;
+    }
+    // Its file's text, expanded; null if not found
+    definition(pkg, kind, name) {
+        const text = readDefinition(pkg, kind, name);
+        return text === null ? null : expandDefinition(text, pkg, (p, n) => readDefinition(p, 'msg', n));
+    }
+}
+function readDefinition(pkg, kind, name) {
+    const share = packageShareDirectory(pkg);
+    if (!share) {
+        return null;
+    }
+    try {
+        return readFileSync(path.join(share, kind, `${name}.${kind}`), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/message_code.d.ts

@@ -0,0 +1,12 @@
+import { type Logger } from './util.ts';
+export interface MissingPackage {
+    name: string;
+    prefix: string;
+}
+export declare function expectedFiles(pkg: string, index: string, blocked?: (name: string) => boolean): string[];
+export declare function missingPackages(prefixes: string[], generatedRoot: string, blocklist?: {
+    pkgName?: string;
+    interfaceName?: string;
+}[]): Promise<MissingPackage[]>;
+export declare function missingCodeHint(message: string): string;
+export declare function makeMessageCode(logger: Logger): Promise<void>;

package/dist/server/message_code.js

@@ -0,0 +1,165 @@
+// rclnodejs's JavaScript code of the ROS interfaces, without which it cannot
+// use them: rclnodejs makes it when installed, for the packages sourced then.
+// Those sourced since (a robot's own installation, a workspace), or rebuilt
+// with new interfaces, are made here at start, before anything uses them: by
+// rclnodejs's own generator, as it makes them when installed, run on a prefix
+// of their own (their ament index entries, their share folders linked). Its
+// own fallback misses the interfaces of services and actions, and makes a
+// whole prefix's while the server waits.
+import { spawn } from 'node:child_process';
+import { existsSync, promises as fs } from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { errorMessage, tasselloRoot } from './util.js';
+// Where the ament index lists each package's interfaces
+const INDEX = path.join('share', 'ament_index', 'resource_index', 'rosidl_interfaces');
+const GENERATION_TIMEOUT_MS = 5 * 60_000;
+// The files rclnodejs makes of a package's interfaces, from its entry in the
+// ament index: msg/Pose.msg, msg/Pose.idl give <pkg>__msg__Pose.js. The
+// services' and actions' parts are made with them.
+export function expectedFiles(pkg, index, blocked = () => false) {
+    const files = new Set();
+    for (const line of index.split('\n')) {
+        const match = /^([\w-]+)\/(\w+)\.(msg|srv|action|idl)$/.exec(line.trim());
+        if (match && !blocked(match[2])) {
+            // msg-common: msg, as rclnodejs names them
+            files.add(`${pkg}__${match[1].split('-')[0]}__${match[2]}.js`);
+        }
+    }
+    return [...files];
+}
+// The packages of the prefixes whose code is not all made: the first of each
+// name, as the prefixes overlay those after them
+export async function missingPackages(prefixes, generatedRoot, blocklist = []) {
+    const seen = new Set();
+    const missing = [];
+    const filters = blocklist.map((f) => ({
+        pkg: f.pkgName ? new RegExp(f.pkgName) : null,
+        name: f.interfaceName ? new RegExp(f.interfaceName) : null,
+    }));
+    for (const prefix of prefixes) {
+        let packages;
+        try {
+            packages = await fs.readdir(path.join(prefix, INDEX));
+        }
+        catch {
+            continue;
+        }
+        for (const name of packages.sort()) {
+            if (seen.has(name)) {
+                continue;
+            }
+            seen.add(name);
+            const applying = filters.filter((f) => !f.pkg || f.pkg.test(name));
+            if (applying.some((f) => !f.name)) {
+                continue;
+            }
+            let index;
+            try {
+                index = await fs.readFile(path.join(prefix, INDEX, name), 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const expected = expectedFiles(name, index, (interfaceName) => applying.some((f) => f.name?.test(interfaceName)));
+            const made = new Set(await fs.readdir(path.join(generatedRoot, name)).catch(() => []));
+            if (expected.some((file) => !made.has(file))) {
+                missing.push({ name, prefix });
+            }
+        }
+    }
+    return missing;
+}
+// What to do when rclnodejs has no code of an interface, after its error
+export function missingCodeHint(message) {
+    return /message required does not exist/i.test(message)
+        ? `${message}. Tassello makes the code of the interfaces sourced when it starts: restart it with their workspace sourced, or run npx generate-ros-messages in ${tasselloRoot()}`
+        : message;
+}
+function rclnodejsRoot() {
+    return path.dirname(createRequire(import.meta.url).resolve('rclnodejs/package.json'));
+}
+// Runs rclnodejs's generator on the prefix: rejects with its error output if
+// it fails
+function generate(worker, prefix) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [worker], {
+            env: { ...process.env, WORKER_TARGET_PATH: prefix },
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.on('data', (data) => {
+            stderr = (stderr + data.toString()).slice(-2000);
+        });
+        const timer = setTimeout(() => child.kill('SIGKILL'), GENERATION_TIMEOUT_MS);
+        child.on('error', (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(stderr.trim() || (signal ? `killed by ${signal}` : `exit code ${code}`)));
+            }
+        });
+    });
+}
+// Makes the code of the packages sourced whose code is missing; says what it
+// did, or why it could not, and goes on: those packages stay unusable then
+export async function makeMessageCode(logger) {
+    const prefixes = (process.env.AMENT_PREFIX_PATH ?? '').split(path.delimiter).filter(Boolean);
+    let root;
+    try {
+        root = rclnodejsRoot();
+    }
+    catch (e) {
+        logger.warn(`Cannot find rclnodejs to check its code of the ROS interfaces: ${errorMessage(e)}`);
+        return;
+    }
+    const generatedRoot = path.join(root, 'generated');
+    let blocklist = [];
+    try {
+        blocklist = JSON.parse(await fs.readFile(path.join(root, 'rosidl_gen', 'blocklist.json'), 'utf8'));
+    }
+    catch {
+        // None
+    }
+    const missing = await missingPackages(prefixes, generatedRoot, blocklist);
+    if (missing.length === 0) {
+        return;
+    }
+    const names = missing.map((p) => p.name).join(', ');
+    const worker = path.join(root, 'rosidl_gen', 'generate_worker.cjs');
+    if (!existsSync(worker)) {
+        logger.warn(`rclnodejs has no code of the interfaces of ${names}: run npx generate-ros-messages in ${tasselloRoot()} with them sourced`);
+        return;
+    }
+    logger.info(`Making rclnodejs's code of the ROS interfaces it has not, of ${missing.length} package(s): ${names}`);
+    const started = Date.now();
+    const prefix = await fs.mkdtemp(path.join(os.tmpdir(), 'tassello-interfaces-'));
+    try {
+        await fs.mkdir(path.join(prefix, INDEX), { recursive: true });
+        for (const pkg of missing) {
+            await fs.copyFile(path.join(pkg.prefix, INDEX, pkg.name), path.join(prefix, INDEX, pkg.name));
+            await fs.symlink(path.join(pkg.prefix, 'share', pkg.name), path.join(prefix, 'share', pkg.name));
+        }
+        await generate(worker, prefix);
+    }
+    catch (e) {
+        logger.warn(`Could not make rclnodejs's code of the interfaces of ${names} (${errorMessage(e)}): run npx generate-ros-messages in ${tasselloRoot()} with them sourced, as a user who may write in ${generatedRoot}`);
+        return;
+    }
+    finally {
+        await fs.rm(prefix, { recursive: true, force: true });
+    }
+    const left = await missingPackages(missing.map((p) => p.prefix).filter((p, i, all) => all.indexOf(p) === i), generatedRoot, blocklist);
+    const still = left.filter((p) => missing.some((m) => m.name === p.name));
+    if (still.length > 0) {
+        logger.warn(`rclnodejs's code of some interfaces of ${still.map((p) => p.name).join(', ')} could not be made`);
+    }
+    logger.info(`Made in ${((Date.now() - started) / 1000).toFixed(1)} s`);
+}

package/dist/server/message_format.d.ts

@@ -0,0 +1,24 @@
+import type { InterfaceKind, MessageSchema } from '../shared/monitor.ts';
+export declare const TIME_TYPE = "builtin_interfaces/msg/Time";
+export declare const HEADER_TYPE = "std_msgs/msg/Header";
+export declare function isPrimitive(type: string): boolean;
+export declare function parseType(type: string): {
+    pkg: string;
+    kind: InterfaceKind;
+    name: string;
+};
+export declare function partTypes(type: string): {
+    name: string;
+    type: string;
+}[];
+export type DefinitionReader = (pkg: string, name: string) => string | null;
+export declare function nestedFieldType(line: string, pkg: string): [string, string] | null;
+export declare function expandDefinition(text: string, pkg: string, read: DefinitionReader, depth?: number): string;
+export declare function defaultMessage(type: string, schemas: Record<string, MessageSchema>): Record<string, unknown>;
+export interface RosTime {
+    sec: number;
+    nanosec: number;
+}
+export declare function toRosMessage(value: unknown, type: string, schemas: Record<string, MessageSchema>, now: () => RosTime, path?: string): Record<string, unknown>;
+export declare function fieldAt(message: unknown, path: string): unknown;
+export declare function echoJson(value: unknown, limit: number): unknown;