@nosana/node 1.0.0-rc

package/dist/NodeManager/provider/containerOrchestration/docker/index.js

@@ -0,0 +1,366 @@
+import os from 'os';
+import { DockerExtended } from './dockerExtended/index.js';
+import { createSeverObject } from './utils/createServerObject.js';
+import { checkDeprecationDeadline } from './utils/deadline.js';
+export class DockerContainerOrchestration {
+    constructor(server, gpu) {
+        this.name = 'docker';
+        this.gpu = 'all';
+        this.listeners = new Map();
+        this.gpu = gpu;
+        if (server.startsWith('http') || server.startsWith('ssh')) {
+            const { host, port, protocol } = createSeverObject(server);
+            this.host = host;
+            this.port = port;
+            this.protocol = protocol;
+            this.docker = new DockerExtended({
+                host: this.host,
+                port: this.port,
+                protocol: this.protocol,
+            });
+        }
+        else {
+            // Assume server is a socket path
+            this.protocol = 'socket';
+            if (server.startsWith('~')) {
+                server = server.replace('~', os.homedir());
+            }
+            this.host = server;
+            this.port = '';
+            this.docker = new DockerExtended({ socketPath: this.host });
+        }
+    }
+    async getContainerByName(name) {
+        const containers = await this.docker
+            .listContainers({ all: true })
+            .catch((_) => {
+            throw new Error('could not get containers');
+        });
+        const matchedContainer = containers.find((container) => container.Names.includes(`/${name}`));
+        if (!matchedContainer)
+            return undefined;
+        return this.docker.getContainer(matchedContainer.Id);
+    }
+    async getContainersByName(names) {
+        try {
+            const containers = await this.docker.listContainers({ all: true });
+            const matchedContainers = containers.filter((container) => names.some((name) => container.Names.includes(`/${name}`)));
+            if (matchedContainers.length > 0) {
+                const containerObjects = matchedContainers.map((containerInfo) => this.docker.getContainer(containerInfo.Id));
+                return containerObjects;
+            }
+            else {
+                return [];
+            }
+        }
+        catch (_) {
+            throw new Error('could not get containers');
+        }
+    }
+    getConnection() {
+        return this.docker;
+    }
+    async pullImage(image, authorisation, controller) {
+        try {
+            if (controller?.signal.aborted)
+                throw controller.signal.reason;
+            if (await this.docker.hasImage(image))
+                return;
+            await this.docker.promisePull(image, controller ?? new AbortController(), authorisation);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                error.eventType = 'image-pull-error';
+            }
+            throw error;
+        }
+    }
+    async hasImage(image) {
+        return await this.docker.hasImage(image);
+    }
+    async getImage(image) {
+        return this.docker.getImage(image);
+    }
+    async listImages() {
+        return this.docker.listImages();
+    }
+    async deleteImage(image, controller) {
+        if (await this.docker.hasImage(image)) {
+            await this.docker
+                .getImage(image)
+                .remove({ force: true, abortSignal: controller?.signal });
+        }
+    }
+    async createNetwork(name, controller) {
+        try {
+            if (await this.hasNetwork('NOSANA_GATEWAY'))
+                return;
+            await this.docker.createNetwork({
+                Name: 'NOSANA_GATEWAY',
+                IPAM: {
+                    Driver: 'bridge',
+                    Config: [{ Subnet: '192.168.101.0/24', Gateway: '192.168.101.1' }],
+                },
+                abortSignal: controller?.signal,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                error.eventType = 'resource-error';
+            }
+            throw error;
+        }
+    }
+    async hasNetwork(name) {
+        const networks = await this.docker.listNetworks();
+        return networks.some((network) => network.Name === name);
+    }
+    async deleteNetwork(name, controller) {
+        // await this.docker.getNetwork(name).remove({ abortSignal: controller?.signal });
+    }
+    async createVolume(name, controller) {
+        try {
+            return await this.docker.createVolume({ Name: name });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                error.eventType = 'resource-error';
+            }
+            throw error;
+        }
+    }
+    async hasVolume(name) {
+        try {
+            const volumes = await this.docker.listVolumes();
+            return volumes.Volumes.some((volume) => volume.Name === name);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async listVolumes() {
+        return (await this.docker.listVolumes()).Volumes;
+    }
+    async getVolume(name) {
+        return this.docker.getVolume(name);
+    }
+    async getRawVolume(name) {
+        return this.docker.getVolume(name);
+    }
+    async deleteVolume(name, controller) {
+        const volume = this.docker.getVolume(name);
+        try {
+            await volume.inspect(); // This will throw if the volume doesn't exist
+            await volume.remove({ force: true, abortSignal: controller?.signal });
+        }
+        catch (error) {
+            if (error.statusCode === 404) {
+                // Volume doesn't exist, nothing to delete
+                return;
+            }
+            throw error;
+        }
+    }
+    async healthy() {
+        if (this.protocol != 'socket') {
+            checkDeprecationDeadline();
+        }
+        try {
+            const info = await this.docker.info();
+            if (typeof info === 'object' && info !== null && info.ID) {
+                return { status: true };
+            }
+            return { status: false, error: new Error('invalid docker info') };
+        }
+        catch (error) {
+            return { status: false, error };
+        }
+    }
+    async getContainer(id) {
+        const container = this.docker.getContainer(id);
+        return container;
+    }
+    getProtocol() {
+        return this.protocol;
+    }
+    setupContainerAbortListener(containerId, controller) {
+        if (controller.signal.aborted) {
+            this.stopContainer(containerId);
+        }
+        const stopFunction = async () => {
+            await this.stopContainer(containerId);
+        };
+        controller.signal.addEventListener('abort', stopFunction);
+        const current = this.listeners.get(containerId) || [];
+        current.push(stopFunction);
+        this.listeners.set(containerId, current);
+    }
+    async runContainer(args, controller) {
+        try {
+            if (controller?.signal.aborted) {
+                throw controller.signal.reason;
+            }
+            const container = await this.docker.createContainer({
+                ...args,
+                abortSignal: controller?.signal,
+            });
+            await container.start();
+            if (controller) {
+                this.setupContainerAbortListener(container.id, controller);
+            }
+            return container;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                error.eventType = 'container-runtime-error';
+            }
+            throw error;
+        }
+    }
+    async runFlowContainer(image, args, controller) {
+        try {
+            if (controller?.signal.aborted) {
+                throw controller.signal.reason;
+            }
+            const container = await this.docker.createContainer({
+                ...mapRunContainerArgsToContainerCreateOpts(image, args, this.gpu),
+                abortSignal: controller?.signal,
+            });
+            await container.start();
+            if (controller) {
+                this.setupContainerAbortListener(container.id, controller);
+            }
+            return container;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                error.eventType = 'container-runtime-error';
+            }
+            throw error;
+        }
+    }
+    async stopContainer(id, controller) {
+        const listeners = this.listeners.get(id) || [];
+        if (controller) {
+            for (const l of listeners)
+                controller.signal.removeEventListener('abort', l);
+        }
+        const container = this.docker.getContainer(id);
+        try {
+            const info = await container.inspect();
+            if (info.State.Status !== 'exited')
+                await container.stop({ abortSignal: controller?.signal });
+        }
+        catch { }
+    }
+    async stopAndDeleteContainer(id, controller) {
+        const listeners = this.listeners.get(id) || [];
+        if (controller) {
+            for (const l of listeners)
+                controller.signal.removeEventListener('abort', l);
+        }
+        const container = await this.docker.getContainer(id);
+        try {
+            // Need to catch in case container is already stopped
+            await container.stop({ abortSignal: controller?.signal }).catch(() => { });
+            const info = await container.inspect();
+            await container.remove({
+                force: true,
+                v: true,
+                abortSignal: controller?.signal,
+            });
+            return info;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async isContainerExited(id) {
+        try {
+            const info = await this.docker.getContainer(id).inspect();
+            return info.State.Status === 'exited';
+        }
+        catch {
+            return true;
+        }
+    }
+    async doesContainerExist(id) {
+        try {
+            await this.docker.getContainer(id).inspect();
+            return true;
+        }
+        catch (e) {
+            if (e.statusCode === 404)
+                return false;
+            throw e;
+        }
+    }
+    async check() {
+        const { status, error } = await this.healthy();
+        if (!status) {
+            throw new Error(`error on container orchestration (docker or podman), error: ${error}`);
+        }
+        return `${this.protocol}://${this.host}:${this.port}`;
+    }
+}
+function mapRunContainerArgsToContainerCreateOpts(image, { name, cmd, gpu, volumes, env, work_dir, entrypoint, aliases, }, gpuOption) {
+    const devices = gpu
+        ? [
+            {
+                ...(gpuOption === 'all'
+                    ? { Count: -1 }
+                    : { device_ids: gpuOption.split(',') }),
+                Driver: 'nvidia',
+                Capabilities: [['gpu']],
+            },
+        ]
+        : [];
+    const dockerVolumes = [];
+    if (volumes && volumes.length > 0) {
+        for (let i = 0; i < volumes.length; i++) {
+            const volume = volumes[i];
+            dockerVolumes.push({
+                Target: volume.dest,
+                Source: volume.name,
+                Type: 'volume',
+                ReadOnly: volume.readonly || false,
+            });
+        }
+    }
+    const vars = [];
+    if (env) {
+        for (const [key, value] of Object.entries(env)) {
+            vars.push(`${key}=${value}`);
+        }
+    }
+    return {
+        name: name,
+        Hostname: '',
+        User: '',
+        AttachStdin: false,
+        AttachStdout: true,
+        AttachStderr: true,
+        Tty: false,
+        OpenStdin: false,
+        StdinOnce: false,
+        Env: vars,
+        Cmd: cmd,
+        Image: image,
+        WorkingDir: work_dir,
+        Entrypoint: entrypoint,
+        NetworkingConfig: {
+            EndpointsConfig: {
+                NOSANA_GATEWAY: aliases ? { Aliases: aliases } : {},
+            },
+        },
+        HostConfig: {
+            ExtraHosts: [
+                'host.docker.internal:8.8.8.8',
+                'host.containers.internal:8.8.8.8',
+            ],
+            Mounts: dockerVolumes,
+            NetworkMode: 'bridge',
+            DeviceRequests: devices,
+        },
+    };
+}

package/dist/NodeManager/provider/containerOrchestration/docker/utils/createServerObject.d.ts

@@ -0,0 +1,5 @@
+export declare function createSeverObject(server: string): {
+    host: string;
+    port: string;
+    protocol: 'https' | 'http' | 'ssh';
+};

package/dist/NodeManager/provider/containerOrchestration/docker/utils/createServerObject.js

@@ -0,0 +1,15 @@
+export function createSeverObject(server) {
+    const { hostname, port, protocol } = new URL(server.startsWith('http') || server.startsWith('ssh')
+        ? server
+        : `http://${server}`);
+    const formattedProtocol = protocol.replace(':', '');
+    if (!['https', 'http', 'ssh'].includes(formattedProtocol) &&
+        typeof protocol !== 'undefined') {
+        throw new Error(`Protocol ${protocol} not supported`);
+    }
+    return {
+        host: hostname,
+        port,
+        protocol: formattedProtocol,
+    };
+}

package/dist/NodeManager/provider/containerOrchestration/docker/utils/deadline.d.ts

@@ -0,0 +1 @@
+export declare function checkDeprecationDeadline(): void;

package/dist/NodeManager/provider/containerOrchestration/docker/utils/deadline.js

@@ -0,0 +1,15 @@
+import chalk from 'chalk';
+export function checkDeprecationDeadline() {
+    // 4pm CET today before the error starts showing
+    // Check if current time is after the deadline
+    const warning = new Date('2025-06-05T16:00:00+02:00'); // 05-06-2025 16:00 CET
+    const deadline = new Date('2025-06-07T15:00:00+02:00'); // 06-07-2025 15:00 CET
+    const now = new Date();
+    if (now > deadline) {
+        throw new Error('HTTP connections are no longer supported. Please use socket connection instead. Restart your host with `bash <(wget -qO- https://nosana.com/start.sh)`');
+    }
+    if (now > warning) {
+        console.error(chalk.red('WARNING: Using podman over HTTP is deprecated, use socket instead'));
+        console.error(chalk.red('Restart your host with `bash <(wget -qO- https://nosana.com/start.sh)` before 06-06-2025 15:00 CET'));
+    }
+}

package/dist/NodeManager/provider/containerOrchestration/docker/utils/repoTagsContainsImage.d.ts

@@ -0,0 +1 @@
+export declare function repoTagsContainsImage(image: string, repoTags: string[] | undefined): boolean;

package/dist/NodeManager/provider/containerOrchestration/docker/utils/repoTagsContainsImage.js

@@ -0,0 +1,13 @@
+export function repoTagsContainsImage(image, repoTags) {
+    if (!repoTags)
+        return false;
+    const imageWithTag = `${image}${!image.includes(':') ? ':latest' : ''}`;
+    const possible_options = [
+        imageWithTag,
+        `docker.io/${imageWithTag}`,
+        `docker.io/library/${imageWithTag}`,
+        `registry.hub.docker.com//${imageWithTag}`,
+        `registry.hub.docker.com/library/${imageWithTag}`,
+    ];
+    return repoTags.some((tag) => possible_options.includes(tag));
+}

package/dist/NodeManager/provider/containerOrchestration/interface.d.ts

@@ -0,0 +1,53 @@
+import { Container, ImageInfo, Image, Volume, VolumeCreateResponse, VolumeInspectInfo, ContainerCreateOptions, ContainerInspectInfo } from 'dockerode';
+import { DockerAuth, RestartPolicy } from '@nosana/sdk';
+import { ReturnedStatus } from '../types.js';
+export type RunContainerArgs = {
+    name?: string;
+    networks?: {
+        [key: string]: {};
+    };
+    cmd?: string[];
+    gpu?: boolean;
+    requires_network_mode?: boolean;
+    volumes?: Array<{
+        dest: string;
+        name: string;
+        readonly?: boolean;
+    }>;
+    env?: {
+        [key: string]: string;
+    };
+    work_dir?: string;
+    entrypoint?: string | string[];
+    restart_policy?: RestartPolicy;
+    aliases?: string[] | undefined;
+};
+export interface ContainerOrchestrationInterface {
+    getConnection(): any;
+    pullImage(image: string, auth?: DockerAuth, controller?: AbortController): Promise<void>;
+    hasImage(image: string): Promise<boolean>;
+    getImage(image: string): Promise<Image>;
+    listImages(): Promise<ImageInfo[]>;
+    deleteImage(image: string, controller?: AbortController): Promise<void>;
+    createNetwork(name: string, controller?: AbortController): Promise<void>;
+    hasNetwork(name: string): Promise<boolean>;
+    deleteNetwork(name: string, controller?: AbortController): Promise<void>;
+    createVolume(name?: string, controller?: AbortController): Promise<VolumeCreateResponse>;
+    getVolume(name: string): Promise<Volume>;
+    hasVolume(name: string): Promise<boolean>;
+    getRawVolume(name: string): Promise<Volume>;
+    listVolumes(): Promise<VolumeInspectInfo[]>;
+    deleteVolume(name: string, controller?: AbortController): Promise<void>;
+    getContainerByName(name: string): Promise<Container | undefined>;
+    getContainersByName(names: string[]): Promise<Container[]>;
+    getContainer(id: string): Promise<Container>;
+    runContainer(args: ContainerCreateOptions, controller?: AbortController): Promise<Container>;
+    runFlowContainer(image: string, args: RunContainerArgs, controller?: AbortController): Promise<Container>;
+    stopContainer(id: string, controller?: AbortController): Promise<void>;
+    stopAndDeleteContainer(id: string, controller?: AbortController): Promise<ContainerInspectInfo | undefined>;
+    isContainerExited(id: string): Promise<boolean>;
+    doesContainerExist(id: string): Promise<boolean>;
+    healthy(): Promise<ReturnedStatus>;
+    check(): Promise<string>;
+    getProtocol(): string;
+}

package/dist/NodeManager/provider/containerOrchestration/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/NodeManager/provider/containerOrchestration/podman/index.d.ts

@@ -0,0 +1,11 @@
+import { Container } from 'dockerode';
+import { DockerContainerOrchestration } from '../docker/index.js';
+import { RunContainerArgs } from '../interface.js';
+import { RequestInit, Response } from 'undici';
+export declare class PodmanContainerOrchestration extends DockerContainerOrchestration {
+    private api;
+    name: string;
+    constructor(server: string, gpu: string);
+    libPodAPICall(path: string, options: RequestInit): Promise<Response>;
+    runFlowContainer(image: string, args: RunContainerArgs, controller?: AbortController): Promise<Container>;
+}

package/dist/NodeManager/provider/containerOrchestration/podman/index.js

@@ -0,0 +1,69 @@
+import { DockerContainerOrchestration } from '../docker/index.js';
+import { createPodmanRunOptions } from './utils/createPodmanRunOptions.js';
+import { fetch, Agent } from 'undici';
+export class PodmanContainerOrchestration extends DockerContainerOrchestration {
+    constructor(server, gpu) {
+        super(server, gpu);
+        this.name = 'podman';
+        if (this.protocol === 'socket') {
+            this.api = `http://localhost/v4.5.0/libpod`;
+        }
+        else {
+            this.api = `${this.protocol}://${this.host}:${this.port}/v4.5.0/libpod`;
+        }
+    }
+    async libPodAPICall(path, options) {
+        if (this.protocol === 'socket') {
+            options.dispatcher = new Agent({
+                connect: {
+                    socketPath: this.host,
+                },
+            });
+        }
+        return fetch(`${this.api}${path}`, options);
+    }
+    async runFlowContainer(image, args, controller) {
+        try {
+            let error;
+            // Incase of error, retry 3 times
+            for (let i = 0; i < 3; i++) {
+                // Sleep between retries to try and let podman image copying finalise
+                await new Promise((res) => setTimeout(res, 3000 * i));
+                const create = await this.libPodAPICall(`/containers/create`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(createPodmanRunOptions(image, args, this.gpu)),
+                });
+                if (create.status === 201) {
+                    const createResult = await create.json();
+                    const start = await this.libPodAPICall(`/containers/${createResult.Id}/start`, {
+                        method: 'POST',
+                    });
+                    if (start.status === 204) {
+                        const container = this.docker.getContainer(createResult.Id);
+                        if (controller) {
+                            this.setupContainerAbortListener(container.id, controller);
+                        }
+                        return container;
+                    }
+                    else {
+                        throw new Error('Cannot start container: ' +
+                            (await start.json()).message);
+                    }
+                }
+                error = await create.json();
+                if (error.message !== `${image}: image not known`)
+                    break;
+            }
+            throw error;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                error.eventType = 'container-runtime-error';
+            }
+            throw error;
+        }
+    }
+}

package/dist/NodeManager/provider/containerOrchestration/podman/utils/createPodmanRunOptions.d.ts

@@ -0,0 +1,103 @@
+import type { RunContainerArgs } from '../../interface.js';
+/**
+ * Takes image and args and return podman run options
+ * @param image
+ * @param args
+ * @param gpu
+ * @returns
+ */
+export declare function createPodmanRunOptions(image: string, args: RunContainerArgs, gpuOption: string): {
+    hostadd: string[];
+    netns: {
+        nsmode: string;
+    };
+    Networks: {
+        NOSANA_GATEWAY: {
+            aliases: string[];
+        } | {
+            aliases?: undefined;
+        };
+    };
+    create_working_dir: boolean;
+    cgroups_mode: string;
+    work_dir: string | undefined;
+    restart_policy: "" | "no" | "unless-stopped" | "on-failure";
+    env: {
+        [key: string]: string;
+    } | undefined;
+    devices: {
+        path: string;
+    }[];
+    entrypoint?: string[] | undefined;
+    image: string;
+    name: string | undefined;
+    command: string[] | undefined;
+    volumes: {
+        dest: string;
+        name: string;
+        Options: string[];
+    }[] | undefined;
+} | {
+    hostadd: string[];
+    netns: {
+        nsmode: string;
+    };
+    Networks: {
+        NOSANA_GATEWAY: {
+            aliases: string[];
+        } | {
+            aliases?: undefined;
+        };
+    };
+    create_working_dir: boolean;
+    cgroups_mode: string;
+    work_dir: string | undefined;
+    restart_tries?: number | undefined;
+    restart_policy: "on-failure";
+    env: {
+        [key: string]: string;
+    } | undefined;
+    devices: {
+        path: string;
+    }[];
+    entrypoint?: string[] | undefined;
+    image: string;
+    name: string | undefined;
+    command: string[] | undefined;
+    volumes: {
+        dest: string;
+        name: string;
+        Options: string[];
+    }[] | undefined;
+} | {
+    hostadd: string[];
+    netns: {
+        nsmode: string;
+    };
+    Networks: {
+        NOSANA_GATEWAY: {
+            aliases: string[];
+        } | {
+            aliases?: undefined;
+        };
+    };
+    create_working_dir: boolean;
+    cgroups_mode: string;
+    work_dir: string | undefined;
+    restart_policy?: undefined;
+    env: {
+        [key: string]: string;
+    } | undefined;
+    devices: {
+        path: string;
+    }[];
+    entrypoint?: string[] | undefined;
+    image: string;
+    name: string | undefined;
+    command: string[] | undefined;
+    volumes: {
+        dest: string;
+        name: string;
+        Options: string[];
+    }[] | undefined;
+};