jitar 0.1.0

package/src/runtime/LocalRepository.ts

@@ -0,0 +1,157 @@
+
+import Module from '../core/types/Module.js';
+
+import FileManager from './interfaces/FileManager.js';
+import LocalNode from './LocalNode.js';
+import File from './models/File.js';
+import Repository from './Repository.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+
+import ClientNotFound from './errors/ClientNotFound.js';
+import InvalidClientId from './errors/InvalidClientId.js';
+import InvalidSegmentFile from './errors/InvalidSegmentFile.js';
+
+import { setRuntime } from '../hooks.js';
+
+let lastClientId = 0;
+
+const CLIENT_ID_PREFIX = 'CLIENT_';
+
+export default class LocalRepository extends Repository
+{
+    #fileManager: FileManager;
+    #segments: Map<string, string> = new Map();
+    #clients: Map<string, string[]> = new Map();
+
+    constructor(fileManager: FileManager, url?: string)
+    {
+        super(url);
+
+        this.#fileManager = fileManager;
+    }
+
+    async loadSegment(name: string): Promise<void>
+    {
+        const filename = `./${name}.segment.repository.js`;
+        const location = this.#fileManager.getAbsoluteLocation(filename);
+        const module = await ModuleLoader.load(location);
+        const files = module.files as string[];
+
+        if (files === undefined)
+        {
+            throw new InvalidSegmentFile(location);
+        }
+
+        this.registerSegment(name, files);
+    }
+
+    async registerSegment(name: string, files: string[]): Promise<void>
+    {
+        files.forEach((file: string) => this.#segments.set(file, name));
+    }
+
+    async registerClient(segmentFilenames: string[]): Promise<string>
+    {
+        const clientId = `${CLIENT_ID_PREFIX}${lastClientId++}`;
+
+        this.#clients.set(clientId, segmentFilenames);
+
+        return clientId;
+    }
+
+    async setRuntime(runtime: LocalNode): Promise<void>
+    {
+        setRuntime(runtime);
+    }
+
+    async loadAsset(filename: string): Promise<File>
+    {
+        return this.#fileManager.load(filename);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async getModuleLocation(clientId: string): Promise<string>
+    {
+        return this.#fileManager.getRootLocation();
+    }
+
+    async loadModule(clientId: string, filename: string): Promise<File>
+    {
+        this.#validateClientId(clientId);
+
+        const segmentFilename = this.#segments.get(filename);
+
+        if (segmentFilename === undefined)
+        {
+            return this.#getNodeModule(filename, false);
+        }
+
+        return this.#hasClientSegmentFile(clientId, segmentFilename)
+            ? this.#getNodeModule(filename, true)
+            : this.#getRemoteModule(filename);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async importModule(clientId: string, filename: string): Promise<Module>
+    {
+        // This function loads the original module file containing the
+        // original imports to prevent import issues while loading the
+        // module in the local repository.
+
+        const location = this.#fileManager.getAbsoluteLocation(filename);
+
+        return ModuleLoader.import(location);
+    }
+
+    #validateClientId(clientId: string): void
+    {
+        if (clientId.startsWith(CLIENT_ID_PREFIX) === false)
+        {
+            throw new InvalidClientId(clientId);
+        }
+
+        if (this.#clients.has(clientId) === false)
+        {
+            throw new ClientNotFound(clientId);
+        }
+    }
+
+    #hasClientSegmentFile(clientId: string, segmentFilename: string): boolean
+    {
+        const clientSegmentFiles = this.#clients.get(clientId);
+
+        if (clientSegmentFiles === undefined)
+        {
+            throw new ClientNotFound(clientId);
+        }
+
+        return clientSegmentFiles.some(clientSegmentFilename => segmentFilename.endsWith(clientSegmentFilename));
+    }
+
+    async #getNodeModule(filename: string, isSegmented: boolean): Promise<File>
+    {
+        // This function loads the node module file containing the rewritten
+        // imports to prevent import issues while loading the module from
+        // a remote repository.
+
+        if (isSegmented)
+        {
+            filename = filename.replace('.js', '.local.js');
+        }
+
+        const file = await this.loadAsset(filename);
+        const code = file.content.toString();
+
+        return new File(filename, 'application/javascript', code);
+    }
+
+    async #getRemoteModule(filename: string): Promise<File>
+    {
+        // This function loads the remote module file containing the rewritten
+        // implementation for each function to execute them on another node.
+
+        const remoteFilename = filename.replace('.js', '.remote.js');
+
+        return this.loadAsset(remoteFilename);
+    }
+}

package/src/runtime/Node.ts

@@ -0,0 +1,15 @@
+
+import Version from '../core/Version.js';
+
+import ProcedureContainer from './interfaces/ProcedureContainer.js';
+
+import Runtime from './Runtime.js';
+
+export default abstract class Node extends Runtime implements ProcedureContainer
+{
+    abstract getProcedureNames(): string[];
+
+    abstract hasProcedure(name: string): boolean;
+
+    abstract run(name: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/src/runtime/NodeBalancer.ts

@@ -0,0 +1,61 @@
+
+import Runner from '../core/interfaces/Runner.js';
+import Version from '../core/Version.js';
+
+import NoNodeAvailable from './errors/NoNodeAvailable.js';
+import Node from './Node.js';
+
+export default class NodeBalancer implements Runner
+{
+    #nodes: Node[] = [];
+    #currentIndex = 0;
+
+    addNode(node: Node): void
+    {
+        if (this.#nodes.includes(node))
+        {
+            return;
+        }
+
+        this.#nodes.push(node);
+    }
+
+    removeNode(node: Node): void
+    {
+        const index = this.#nodes.indexOf(node);
+
+        if (index === -1)
+        {
+            return;
+        }
+
+        this.#nodes.splice(index, 1);
+    }
+
+    getNextNode(): Node | undefined
+    {
+        if (this.#nodes.length === 0)
+        {
+            return;
+        }
+
+        if (this.#currentIndex >= this.#nodes.length)
+        {
+            this.#currentIndex = 0;
+        }
+
+        return this.#nodes[this.#currentIndex++];
+    }
+
+    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        const node = this.getNextNode();
+
+        if (node === undefined)
+        {
+            throw new NoNodeAvailable(fqn);
+        }
+
+        return node.run(fqn, version, args);
+    }
+}

package/src/runtime/NodeMonitor.ts

@@ -0,0 +1,63 @@
+
+import LocalGateway from './LocalGateway.js';
+import Node from './Node.js';
+
+const DEFAULT_FREQUENCY = 5000;
+
+export default class NodeMonitor
+{
+    #gateway: LocalGateway;
+    #frequency: number;
+    #interval: ReturnType<typeof setInterval> | null = null;
+
+    constructor(gateway: LocalGateway, frequency: number = DEFAULT_FREQUENCY)
+    {
+        this.#gateway = gateway;
+        this.#frequency = frequency;
+    }
+
+    start(): void
+    {
+        this.#interval = setInterval(async () => await this.#monitor(), this.#frequency);
+    }
+
+    stop(): void
+    {
+        if (this.#interval === null)
+        {
+            return;
+        }
+
+        clearInterval(this.#interval);
+    }
+
+    async #monitor(): Promise<void>
+    {
+        const nodes = this.#gateway.nodes;
+        const promises = nodes.map(async (node: Node) => await this.#monitorNode(node));
+
+        await Promise.all(promises);
+    }
+
+    async #monitorNode(node: Node): Promise<void>
+    {
+        const available = await this.#checkNodeAvailable(node);
+
+        if (available === false)
+        {
+            this.#gateway.removeNode(node);
+        }
+    }
+
+    async #checkNodeAvailable(node: Node): Promise<boolean>
+    {
+        try
+        {
+            return await node.isHealthy();
+        }
+        catch (error)
+        {
+            return false;
+        }
+    }
+}

package/src/runtime/Proxy.ts

@@ -0,0 +1,60 @@
+
+import Version from '../core/Version.js';
+
+import ProcedureContainer from './interfaces/ProcedureContainer.js';
+
+import Gateway from './Gateway.js';
+import File from './models/File.js';
+import Node from './Node.js';
+import Repository from './Repository.js';
+import Runtime from './Runtime.js';
+
+export default class Proxy extends Runtime implements ProcedureContainer
+{
+    #repository: Repository;
+    #runner: Gateway | Node;
+
+    constructor(repository: Repository, runner: Gateway | Node, url?: string)
+    {
+        super(url);
+
+        this.#repository = repository;
+        this.#runner = runner;
+    }
+
+    get repository() { return this.#repository; }
+
+    get runner() { return this.#runner; }
+
+    getProcedureNames(): string[] 
+    {
+        return this.#runner.getProcedureNames();
+    }
+
+    hasProcedure(fqn: string): boolean
+    {
+        const procedureNames = this.getProcedureNames();
+
+        return procedureNames.includes(fqn);
+    }
+
+    async loadAsset(filename: string): Promise<File>
+    {
+        return this.#repository.loadAsset(filename);
+    }
+
+    async registerClient(segmentFiles: string[]): Promise<string>
+    {
+        return this.#repository.registerClient(segmentFiles);
+    }
+
+    async loadModule(clientId: string, filename: string): Promise<File>
+    {
+        return this.#repository.loadModule(clientId, filename);
+    }
+
+    async run(name: string, version: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        return this.#runner.run(name, version, args);
+    }
+}

package/src/runtime/Remote.ts

@@ -0,0 +1,157 @@
+
+import Module from '../core/types/Module.js';
+import Version from '../core/Version.js';
+
+import File from './models/File.js';
+import Node from './Node.js';
+import ValueSerializer from './serialization/ValueSerializer.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+
+export default class Remote
+{
+    #url: string;
+    #useSerializer: boolean;
+
+    constructor(url: string, useSerializer: boolean)
+    {
+        this.#url = url;
+        this.#useSerializer = useSerializer;
+    }
+
+    async registerClient(segmentFiles: string[]): Promise<string>
+    {
+        const url = `${this.#url}/modules`;
+        const options =
+        {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(segmentFiles)
+        };
+
+        const response = await this.#callRemote(url, options, 200);
+        const clientId = await response.text();
+
+        return clientId;
+    }
+
+    async loadFile(filename: string): Promise<File>
+    {
+        const url = `${this.#url}/${filename}`;
+        const options = { method: 'GET' };
+
+        const response = await this.#callRemote(url, options, 200);
+        const type = response.headers.get('Content-Type') || 'application/octet-stream';
+        const content = await response.text();
+
+        return new File(filename, type, content);
+    }
+
+    async importFile(filename: string): Promise<Module>
+    {
+        const url = `${this.#url}/${filename}`;
+
+        return ModuleLoader.load(url);
+    }
+
+    async isHealthy(): Promise<boolean>
+    {
+        const url = `${this.#url}/health/status`;
+        const options = { method: 'GET' };
+
+        const response = await this.#callRemote(url, options, 200);
+        const healthy = await response.text();
+
+        return Boolean(healthy);
+    }
+
+    async getHealth(): Promise<Map<string, boolean>>
+    {
+        const url = `${this.#url}/health`;
+        const options = { method: 'GET' };
+
+        const response = await this.#callRemote(url, options, 200);
+        const health = await response.json();
+
+        return new Map(Object.entries(health));
+    }
+
+    async addNode(node: Node): Promise<void>
+    {
+        const url = `${this.#url}/nodes`;
+        const body =
+        {
+            url: node.url,
+            procedureNames: node.getProcedureNames()
+        }
+        const options =
+        {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        }
+
+        await this.#callRemote(url, options, 201);
+    }
+
+    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        const versionString = version.toString();
+        const argsObject = Object.fromEntries(args);
+
+        const url = `${this.#url}/rpc/${fqn}?version=${versionString}&serialize=true`;
+        const options =
+        {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: this.#createRequestBody(argsObject, this.#useSerializer)
+        };
+
+        const response = await this.#callRemote(url, options, 200);
+
+        return this.#createResponseResult(response, this.#useSerializer);
+    }
+
+    async #callRemote(url: string, options: object, expectedStatus: number): Promise<Response>
+    {
+        const response = await fetch(url, options);
+
+        if (response.status !== expectedStatus)
+        {
+            const error = await this.#createResponseResult(response, true);
+
+            throw error;
+        }
+
+        return response;
+    }
+
+    #createRequestBody(body: unknown, serialize: boolean): string
+    {
+        const data = serialize
+            ? ValueSerializer.serialize(body)
+            : body;
+
+        return JSON.stringify(data);
+    }
+
+    async #createResponseResult(response: Response, serialize: boolean): Promise<unknown>
+    {
+        const result = await this.#getResponseResult(response);
+
+        return serialize
+            ? ValueSerializer.deserialize(result)
+            : result;
+    }
+
+    async #getResponseResult(response: Response): Promise<unknown>
+    {
+        const contentType = response.headers.get('Content-Type');
+
+        if (contentType !== null && contentType.includes('json'))
+        {
+            return response.json();
+        }
+
+        return response.text();
+    }
+}

package/src/runtime/RemoteGateway.ts

@@ -0,0 +1,40 @@
+
+import NotImplemented from '../core/errors/NotImplemented.js';
+import Version from '../core/Version.js';
+
+import Gateway from './Gateway.js';
+import Node from './Node.js';
+import Remote from './Remote.js';
+
+export default class RemoteGateway extends Gateway
+{
+    #remote: Remote;
+
+    constructor(url: string)
+    {
+        super(url);
+
+        this.#remote = new Remote(url, true);
+    }
+
+    getProcedureNames(): string[]
+    {
+        throw new NotImplemented();
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hasProcedure(name: string): boolean
+    {
+        throw new NotImplemented();
+    }
+
+    async addNode(node: Node): Promise<void>
+    {
+        return this.#remote.addNode(node);
+    }
+
+    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        return this.#remote.run(fqn, version, args);
+    }
+}

package/src/runtime/RemoteNode.ts

@@ -0,0 +1,49 @@
+
+import Version from '../core/Version.js';
+
+import Node from './Node.js';
+import Remote from './Remote.js';
+
+export default class RemoteNode extends Node
+{
+    #remote: Remote;
+    #procedureNames: Set<string> = new Set();
+
+    constructor(url: string, procedureNames: string[])
+    {
+        super(url);
+
+        this.#remote = new Remote(url, false);
+        this.registerProcedures(procedureNames);
+    }
+
+    getProcedureNames(): string[]
+    {
+        return [...this.#procedureNames.values()];
+    }
+
+    registerProcedures(procedureNames: string[]): void
+    {
+        procedureNames.forEach(procedureName => this.#procedureNames.add(procedureName));
+    }
+
+    hasProcedure(name: string): boolean
+    {
+        return this.#procedureNames.has(name);
+    }
+
+    async isHealthy(): Promise<boolean>
+    {
+        return this.#remote.isHealthy();
+    }
+
+    async getHealth(): Promise<Map<string, boolean>>
+    {
+        return this.#remote.getHealth();
+    }
+
+    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        return this.#remote.run(fqn, version, args);
+    }
+}

package/src/runtime/RemoteRepository.ts

@@ -0,0 +1,60 @@
+
+import Module from '../core/types/Module.js';
+
+import InvalidJitarHooks from './errors/InvalidJitarHooks.js';
+import File from './models/File.js';
+import Remote from './Remote.js';
+import Repository from './Repository.js';
+import Runtime from './Runtime.js';
+import JitarHooks from './types/JitarHooks.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+
+export default class RemoteRepository extends Repository
+{
+    #remote: Remote;
+
+    constructor(url: string)
+    {
+        super(url);
+
+        this.#remote = new Remote(url, true);
+    }
+
+    async registerClient(segmentFiles: string[]): Promise<string>
+    {
+        return this.#remote.registerClient(segmentFiles);
+    }
+
+    async setRuntime(runtime: Runtime): Promise<void>
+    {
+        const jitar = await this.#remote.importFile('jitar/hooks.js') as JitarHooks;
+
+        if (jitar?.setRuntime === undefined || jitar?.setDependencyLoader === undefined)
+        {
+            throw new InvalidJitarHooks();
+        }
+
+        jitar.setRuntime(runtime);
+        jitar.setDependencyLoader(ModuleLoader.import);
+    }
+
+    async loadAsset(filename: string): Promise<File>
+    {
+        return this.#remote.loadFile(filename);
+    }
+
+    async getModuleLocation(clientId: string): Promise<string>
+    {
+        return `${this.url}/modules/${clientId}`;
+    }
+
+    async loadModule(clientId: string, filename: string): Promise<File>
+    {
+        return this.#remote.loadFile(`modules/${clientId}/${filename}`);
+    }
+
+    async importModule(clientId: string, filename: string): Promise<Module>
+    {
+        return this.#remote.importFile(`modules/${clientId}/${filename}`);
+    }
+}

package/src/runtime/Repository.ts

@@ -0,0 +1,20 @@
+
+import Module from '../core/types/Module.js';
+
+import File from './models/File.js';
+import Runtime from './Runtime.js';
+
+export default abstract class Repository extends Runtime
+{
+    abstract registerClient(segmentFiles: string[]): Promise<string>;
+
+    abstract setRuntime(runtime: Runtime): Promise<void>;
+
+    abstract loadAsset(filename: string): Promise<File>;
+
+    abstract getModuleLocation(clientId: string): Promise<string>;
+
+    abstract loadModule(clientId: string, filename: string): Promise<File>;
+
+    abstract importModule(clientId: string, filename: string): Promise<Module>;
+}