@cartesi/cli 1.5.0 → 2.0.0-alpha.1

package/dist/config.js

@@ -0,0 +1,378 @@
+import bytes from "bytes";
+import os from "os";
+import { extname } from "path";
+import { parse as parseToml } from "smol-toml";
+/**
+ * Typed Errors
+ */
+export class InvalidBuilderError extends Error {
+    constructor(builder) {
+        super(`Invalid builder: ${builder}`);
+        this.name = "InvalidBuilder";
+    }
+}
+export class InvalidDriveFormatError extends Error {
+    constructor(format) {
+        super(`Invalid drive format: ${format}`);
+        this.name = "InvalidDriveFormatError";
+    }
+}
+export class InvalidEmptyDriveFormatError extends Error {
+    constructor(format) {
+        super(`Invalid empty drive format: ${format}`);
+        this.name = "InvalidEmptyDriveFormatError";
+    }
+}
+export class InvalidStringValueError extends Error {
+    constructor(value) {
+        super(`Invalid string value: ${value}`);
+        this.name = "InvalidStringValueError";
+    }
+}
+export class InvalidBooleanValueError extends Error {
+    constructor(value) {
+        super(`Invalid boolean value: ${value}`);
+        this.name = "InvalidBooleanValueError";
+    }
+}
+export class InvalidNumberValueError extends Error {
+    constructor(value) {
+        super(`Invalid number value: ${value}`);
+        this.name = "InvalidNumberValueError";
+    }
+}
+export class InvalidBytesValueError extends Error {
+    constructor(value) {
+        super(`Invalid bytes value: ${value}`);
+        this.name = "InvalidBytesValueError";
+    }
+}
+export class RequiredFieldError extends Error {
+    constructor(key) {
+        super(`Missing required field: ${key}`);
+        this.name = "RequiredFieldError";
+    }
+}
+export class InvalidStringArrayError extends Error {
+    constructor() {
+        super(`Invalid string array`);
+        this.name = "InvalidStringArrayError";
+    }
+}
+/**
+ * Configuration for drives of a Cartesi Machine. A drive may already exist or be built by a builder
+ */
+const DEFAULT_FORMAT = "ext2";
+const DEFAULT_RAM = "128Mi";
+const DEFAULT_RAM_IMAGE_DOCKER = "/usr/share/cartesi-machine/images/linux.bin";
+const DEFAULT_RAM_IMAGE_LINUX = "/usr/share/cartesi-machine/images/linux.bin";
+const DEFAULT_RAM_IMAGE_MAC = "/opt/homebrew/share/cartesi-machine/images/linux.bin";
+export const DEFAULT_SDK = "cartesi/sdk:0.12.0-alpha.0";
+export const defaultRootDriveConfig = () => ({
+    builder: "docker",
+    context: ".",
+    dockerfile: "Dockerfile", // file on current working directory
+    extraSize: 0,
+    format: DEFAULT_FORMAT,
+    tags: [],
+});
+export const defaultRamImage = () => {
+    switch (os.platform()) {
+        case "darwin":
+            return DEFAULT_RAM_IMAGE_MAC;
+        default:
+            return DEFAULT_RAM_IMAGE_LINUX;
+    }
+};
+export const defaultMachineConfig = () => ({
+    assertRollingTemplate: undefined,
+    bootargs: [],
+    entrypoint: undefined,
+    finalHash: true,
+    interactive: undefined,
+    maxMCycle: undefined,
+    noRollup: undefined,
+    ramLength: DEFAULT_RAM,
+    ramImage: defaultRamImage(),
+    store: "image",
+    user: undefined,
+});
+export const defaultConfig = () => ({
+    drives: { root: defaultRootDriveConfig() },
+    machine: defaultMachineConfig(),
+    sdk: DEFAULT_SDK,
+});
+const parseBoolean = (value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    else if (typeof value === "boolean") {
+        return value;
+    }
+    throw new InvalidBooleanValueError(value);
+};
+const parseOptionalBoolean = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "boolean") {
+        return value;
+    }
+    throw new InvalidBooleanValueError(value);
+};
+const parseString = (value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseStringArray = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    else if (typeof value === "string") {
+        return [value];
+    }
+    else if (typeof value === "object" && Array.isArray(value)) {
+        return value.map((v) => {
+            if (typeof v === "string") {
+                return v;
+            }
+            throw new InvalidStringValueError(v);
+        });
+    }
+    throw new InvalidStringArrayError();
+};
+const parseRequiredString = (value, key) => {
+    if (value === undefined) {
+        throw new RequiredFieldError(key);
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseOptionalString = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseOptionalStringBoolean = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "string") {
+        return value;
+    }
+    else if (typeof value === "boolean") {
+        return value;
+    }
+    throw new InvalidStringValueError(value);
+};
+const parseOptionalNumber = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    else if (typeof value === "bigint") {
+        return value;
+    }
+    else if (typeof value === "number") {
+        return BigInt(value);
+    }
+    throw new InvalidNumberValueError(value);
+};
+const parseBytes = (value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    else if (typeof value === "bigint") {
+        return Number(value);
+    }
+    else if (typeof value === "number" || typeof value === "string") {
+        const output = bytes.parse(value);
+        if (output !== null) {
+            return output;
+        }
+    }
+    throw new InvalidBytesValueError(value);
+};
+const parseBuilder = (value) => {
+    if (value === undefined) {
+        return "docker";
+    }
+    else if (typeof value === "string") {
+        switch (value) {
+            case "directory":
+                return "directory";
+            case "docker":
+                return "docker";
+            case "empty":
+                return "empty";
+            case "none":
+                return "none";
+            case "tar":
+                return "tar";
+        }
+    }
+    throw new InvalidBuilderError(value);
+};
+const parseFormat = (value) => {
+    if (value === undefined) {
+        return DEFAULT_FORMAT;
+    }
+    else if (typeof value === "string") {
+        switch (value) {
+            case "ext2":
+                return "ext2";
+            case "sqfs":
+                return "sqfs";
+        }
+    }
+    throw new InvalidDriveFormatError(value);
+};
+const parseEmptyFormat = (value) => {
+    if (value === undefined) {
+        return DEFAULT_FORMAT;
+    }
+    else if (typeof value === "string") {
+        switch (value) {
+            case "ext2":
+                return "ext2";
+            case "raw":
+                return "raw";
+        }
+    }
+    throw new InvalidEmptyDriveFormatError(value);
+};
+const parseMachine = (value) => {
+    if (value === undefined) {
+        // default machine
+        return defaultMachineConfig();
+    }
+    if (typeof value !== "object") {
+        throw new Error(`Invalid machine configuration: ${value}`);
+    }
+    const toml = value;
+    return {
+        assertRollingTemplate: parseOptionalBoolean(toml["assert-rolling-template"]),
+        bootargs: parseStringArray(toml.bootargs),
+        finalHash: parseBoolean(toml["final-hash"], true),
+        interactive: undefined,
+        maxMCycle: parseOptionalNumber(toml["max-mcycle"]),
+        noRollup: parseBoolean(toml["no-rollup"], false),
+        ramLength: parseString(toml["ram-length"], DEFAULT_RAM),
+        ramImage: parseString(toml["ram-image"], defaultRamImage()),
+        store: "image",
+        user: parseOptionalString(toml.user),
+    };
+};
+export const getDriveFormat = (filename) => {
+    const extension = extname(filename);
+    switch (extension) {
+        case ".ext2":
+            return "ext2";
+        case ".sqfs":
+            return "sqfs";
+        default:
+            throw new InvalidDriveFormatError(extension);
+    }
+};
+const parseDrive = (drive) => {
+    const builder = parseBuilder(drive.builder);
+    switch (builder) {
+        case "directory": {
+            const { extraSize, format, mount, directory, shared, user } = drive;
+            return {
+                builder: "directory",
+                extraSize: parseBytes(extraSize, 0),
+                format: parseFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                directory: parseRequiredString(directory, "directory"),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+            };
+        }
+        case "docker": {
+            const { context, dockerfile, extraSize, format, image, mount, shared, tags, target, user, } = drive;
+            return {
+                builder: "docker",
+                image: parseOptionalString(image),
+                context: parseString(context, "."),
+                dockerfile: parseString(dockerfile, "Dockerfile"),
+                extraSize: parseBytes(extraSize, 0),
+                format: parseFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+                tags: parseStringArray(tags),
+                target: parseOptionalString(target),
+            };
+        }
+        case "empty": {
+            const { format, mount, size, shared, user } = drive;
+            return {
+                builder: "empty",
+                format: parseEmptyFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                size: parseBytes(size, 0),
+                user: parseOptionalString(user),
+            };
+        }
+        case "tar": {
+            const { extraSize, filename, format, mount, shared, user } = drive;
+            return {
+                builder: "tar",
+                extraSize: parseBytes(extraSize, 0),
+                filename: parseRequiredString(filename, "filename"),
+                format: parseFormat(format),
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+            };
+        }
+        case "none": {
+            const { shared, mount, user } = drive;
+            const filename = parseRequiredString(drive.filename, "filename");
+            const format = getDriveFormat(filename);
+            return {
+                builder: "none",
+                filename,
+                format,
+                mount: parseOptionalStringBoolean(mount),
+                shared: parseOptionalBoolean(shared),
+                user: parseOptionalString(user),
+            };
+        }
+    }
+};
+const parseDrives = (config) => {
+    // load drives from configuration
+    const drives = Object.entries(config ?? {}).reduce((acc, [name, drive]) => {
+        acc[name] = parseDrive(drive);
+        return acc;
+    }, {});
+    // check if there is a root drive
+    const hasRoot = drives.root !== undefined;
+    if (!hasRoot) {
+        // there is no root drive, add a default one
+        drives.root = defaultRootDriveConfig();
+    }
+    return drives;
+};
+export const parse = (str) => {
+    const toml = parseToml(str);
+    const config = {
+        drives: parseDrives(toml.drives),
+        machine: parseMachine(toml.machine),
+        sdk: parseString(toml.sdk, DEFAULT_SDK),
+    };
+    return config;
+};