jitar 0.1.0

package/src/server/utils/RuntimeConfigurationLoader.ts

@@ -0,0 +1,19 @@
+
+import { readFileSync } from 'fs';
+
+import RuntimeConfiguration from '../configuration/RuntimeConfiguration.js';
+
+import DataConverter from './DataConverter.js';
+
+export default class RuntimeConfigurationLoader
+{
+    static async load(filename: string): Promise<RuntimeConfiguration>
+    {
+        const plainContents = readFileSync(filename, 'utf-8');
+        const parsedContents = JSON.parse(plainContents);
+
+        const configuration = await DataConverter.convert<RuntimeConfiguration>(RuntimeConfiguration, parsedContents);
+
+        return configuration;
+    }
+}

package/src/server/utils/RuntimeConfigurator.ts

@@ -0,0 +1,207 @@
+
+import CacheBuilder from '../../runtime/caching/CacheBuilder.js';
+import Gateway from '../../runtime/Gateway.js';
+import LocalGateway from '../../runtime/LocalGateway.js';
+import LocalNode from '../../runtime/LocalNode.js';
+import LocalRepository from '../../runtime/LocalRepository.js';
+import Node from '../../runtime/Node.js';
+import NodeMonitor from '../../runtime/NodeMonitor.js';
+import Proxy from '../../runtime/Proxy.js';
+import RemoteGateway from '../../runtime/RemoteGateway.js';
+import RemoteNode from '../../runtime/RemoteNode.js';
+import RemoteRepository from '../../runtime/RemoteRepository.js';
+import Repository from '../../runtime/Repository.js';
+import Runtime from '../../runtime/Runtime.js';
+
+import LocalFileManager from './LocalFileManager.js';
+
+import RuntimeConfiguration from '../configuration/RuntimeConfiguration.js';
+import StandaloneConfiguration from '../configuration/StandaloneConfiguration.js';
+import RepositoryConfiguration from '../configuration/RepositoryConfiguration.js';
+import GatewayConfiguration from '../configuration/GatewayConfiguration.js';
+import NodeConfiguration from '../configuration/NodeConfiguration.js';
+import ProxyConfiguration from '../configuration/ProxyConfiguration.js';
+
+import RuntimeDefaults from '../definitions/RuntimeDefaults.js';
+
+import MissingConfigurationValue from '../errors/MissingConfigurationValue.js';
+import UnknownRuntimeMode from '../errors/UnknownRuntimeMode.js';
+
+export default class RuntimeConfigurator
+{
+    static async configure(configuration: RuntimeConfiguration): Promise<Runtime>
+    {
+        const url = configuration.url ?? RuntimeDefaults.URL;
+
+        if (configuration.standalone !== undefined) return this.#configureStandAlone(url, configuration.standalone);
+        if (configuration.repository !== undefined) return this.#configureRepository(url, configuration.repository);
+        if (configuration.gateway !== undefined) return this.#configureGateway(url, configuration.gateway);
+        if (configuration.node !== undefined) return this.#configureNode(url, configuration.node);
+        if (configuration.proxy !== undefined) return this.#configureProxy(url, configuration.proxy);
+
+        throw new UnknownRuntimeMode();
+    }
+
+    static async #configureStandAlone(url: string, configuration: StandaloneConfiguration): Promise<Proxy>
+    {
+        const sourceLocation = configuration.source ?? RuntimeDefaults.SOURCE;
+        const cacheLocation = configuration.cache ?? RuntimeDefaults.CACHE;
+
+        await this.#buildCache(sourceLocation, cacheLocation);
+
+        const segmentNames = configuration.segments === undefined
+            ? await this.#getSegmentNames(cacheLocation)
+            : configuration.segments;
+
+        const repository = await this.#buildRepository(url, cacheLocation);
+        const node = await this.#buildNode(url, segmentNames, repository);
+
+        return this.#buildProxy(url, repository, node);
+    }
+
+    static async #configureRepository(url: string, configuration: RepositoryConfiguration): Promise<LocalRepository>
+    {
+        const sourceLocation = configuration.source ?? RuntimeDefaults.SOURCE;
+        const cacheLocation = configuration.cache ?? RuntimeDefaults.CACHE;
+
+        await this.#buildCache(sourceLocation, cacheLocation);
+        return this.#buildRepository(url, cacheLocation);
+    }
+
+    static async #configureGateway(url: string, configuration: GatewayConfiguration): Promise<LocalGateway>
+    {
+        return this.#buildGateway(url, configuration.monitor);
+    }
+
+    static async #configureNode(url: string, configuration: NodeConfiguration): Promise<LocalNode>
+    {
+        const segmentNames = configuration.segments ?? [];
+
+        const repository = configuration.repository !== undefined
+            ? new RemoteRepository(configuration.repository)
+            : undefined;
+
+        const gateway = configuration.gateway !== undefined
+            ? new RemoteGateway(configuration.gateway)
+            : undefined;
+
+        return this.#buildNode(url, segmentNames, repository, gateway);
+    }
+
+    static async #configureProxy(url: string, configuration: ProxyConfiguration): Promise<Proxy>
+    {
+        if (configuration.repository === undefined)
+        {
+            throw new MissingConfigurationValue('proxy.repository');
+        }
+
+        const repository = new RemoteRepository(configuration.repository);
+
+        const gateway = configuration.gateway !== undefined
+            ? new RemoteGateway(configuration.gateway)
+            : undefined;
+
+        const node = configuration.node !== undefined
+            ? new RemoteNode(configuration.node, [])
+            : undefined;
+
+        const runner = gateway ?? node;
+
+        if (runner === undefined)
+        {
+            throw new MissingConfigurationValue('proxy.gateway or proxy.node');
+        }
+
+        return this.#buildProxy(url, repository, runner);
+    }
+
+    static async #buildCache(sourceLocation: string, cacheLocation: string): Promise<LocalFileManager>
+    {
+        const rootManager = new LocalFileManager('./');
+        await rootManager.remove(cacheLocation);
+        await rootManager.copy(sourceLocation, cacheLocation);
+
+        const sourceManager = new LocalFileManager(sourceLocation);
+        const cacheManager = new LocalFileManager(cacheLocation);
+
+        const segmentFiles = await rootManager.getSegmentFiles();
+        const moduleFiles = await sourceManager.getModuleFileNames();
+
+        const cacheBuilder = new CacheBuilder(sourceManager, cacheManager);
+        await cacheBuilder.build(segmentFiles, moduleFiles);
+
+        return cacheManager;
+    }
+
+    static async #getSegmentNames(cacheLocation: string): Promise<string[]>
+    {
+        const fileManager = new LocalFileManager(cacheLocation);
+        const segmentFilenames = await fileManager.getNodeSegmentFiles();
+
+        return segmentFilenames.map(filename => this.#extractSegmentName(filename));
+    }
+
+    static #extractSegmentName(filename: string): string
+    {
+        const name = filename.split('/').pop() ?? '';
+        const endIndex = name.indexOf('.segment');
+
+        return name.substring(0, endIndex);
+    }
+
+    static async #buildRepository(url: string | undefined, cacheLocation: string): Promise<LocalRepository>
+    {
+        const fileManager = new LocalFileManager(cacheLocation);
+        const repository = new LocalRepository(fileManager, url);
+
+        const segmentFilenames = await fileManager.getRepositorySegmentFiles();
+        const segmentNames = segmentFilenames.map(filename => this.#extractSegmentName(filename));
+
+        for (const name of segmentNames)
+        {
+            await repository.loadSegment(name);
+        }
+
+        return repository;
+    }
+
+    static async #buildGateway(url?: string, monitorInterval?: number): Promise<LocalGateway>
+    {
+        const gateway = new LocalGateway(url);
+        const monitor = new NodeMonitor(gateway, monitorInterval);
+
+        monitor.start();
+
+        return gateway;
+    }
+
+    static async #buildNode(url: string | undefined, segmentNames: string[], repository?: Repository, gateway?: Gateway): Promise<LocalNode>
+    {
+        const node = new LocalNode(url);
+
+        if (repository !== undefined)
+        {
+            await node.setRepository(repository, segmentNames);
+        }
+
+        for (const segmentName of segmentNames)
+        {
+            await node.loadSegment(segmentName);
+        }
+
+        // All segments have to be loaded before a node
+        // can be registered at the gateway
+
+        if (gateway !== undefined)
+        {
+            node.setGateway(gateway);
+        }
+
+        return node;
+    }
+
+    static async #buildProxy(url: string | undefined, repository: Repository, runner: Gateway | Node): Promise<Proxy>
+    {
+        return new Proxy(repository, runner, url);
+    }
+}

package/src/server/utils/ServerOptionsReader.ts

@@ -0,0 +1,17 @@
+
+import yargs from 'yargs';
+
+import ServerOptions from '../configuration/ServerOptions.js';
+
+import DataConverter from './DataConverter.js';
+
+export default class ServerOptionsReader
+{
+    static async read(): Promise<ServerOptions>
+    {
+        const args: object = yargs(process.argv).argv
+        const options = await DataConverter.convert<ServerOptions>(ServerOptions, args);
+
+        return options;
+    }
+}

package/src/server.ts

@@ -0,0 +1,16 @@
+
+import ModuleImporter from './runtime/types/ModuleImporter.js';
+import ModuleLoader from './runtime/utils/ModuleLoader.js';
+
+import JitarServer from './server/JitarServer.js';
+
+export async function startServer(moduleImporter: ModuleImporter): Promise<JitarServer>
+{
+    ModuleLoader.setImporter(moduleImporter);
+
+    const server = new JitarServer();
+
+    await server.start();
+
+    return server;
+}

package/test/_fixtures/core/Implementation.fixture.ts

@@ -0,0 +1,33 @@
+
+import * as AccessLevel from '../../../src/core/definitions/AccessLevel';
+import Implementation from '../../../src/core/Implementation';
+import Version from '../../../src/core/Version';
+import ReflectionHelper from '../../../src/core/reflection/ReflectionHelper';
+
+function getPrivate(): string
+{
+    return 'private';
+}
+
+function getPublic(): string
+{
+    return 'public';
+}
+
+function getParameters(mandatory: string, optional = 'default')
+{
+    return `${mandatory} ${optional}`;
+}
+
+const parameters = ReflectionHelper.getFunctionParameters(getParameters);
+
+const privateImplementation = new Implementation(Version.DEFAULT, AccessLevel.PRIVATE, [], getPrivate);
+const publicImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, [], getPublic);
+const parameterImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, parameters, getParameters);
+
+export
+{
+    privateImplementation,
+    publicImplementation,
+    parameterImplementation
+}

package/test/_fixtures/core/Procedure.fixture.ts

@@ -0,0 +1,33 @@
+
+import Procedure from '../../../src/core/Procedure';
+import * as AccessLevel from '../../../src/core/definitions/AccessLevel';
+import Implementation from '../../../src/core/Implementation';
+import Version from '../../../src/core/Version';
+
+function v1_0_0(): string { return '1.0.0'; }
+function v1_0_5(): string { return '1.0.5'; }
+function v1_1_0(): string { return '1.1.0'; }
+
+const v100Implementation = new Implementation(new Version(1, 0, 0), AccessLevel.PRIVATE, [], v1_0_0);
+const v105Implementation = new Implementation(new Version(1, 0, 5), AccessLevel.PUBLIC, [], v1_0_5);
+const v110Implementation = new Implementation(new Version(1, 1, 0), AccessLevel.PUBLIC, [], v1_1_0);
+
+const rootProcedure = new Procedure('', 'myRootProcedure');
+rootProcedure.addImplementation(v100Implementation);
+rootProcedure.addImplementation(v105Implementation);
+rootProcedure.addImplementation(v110Implementation);
+
+const moduleProcedure = new Procedure('my/module', 'myModuleProcedure');
+moduleProcedure.addImplementation(v100Implementation);
+moduleProcedure.addImplementation(v105Implementation);
+moduleProcedure.addImplementation(v110Implementation);
+
+const privateProcedure = new Procedure('my/module', 'myPrivateProcedure');
+privateProcedure.addImplementation(v100Implementation);
+
+export
+{
+    rootProcedure,
+    moduleProcedure,
+    privateProcedure
+}

package/test/_fixtures/core/Segment.fixture.ts

@@ -0,0 +1,36 @@
+
+import Procedure from '../../../src/core/Procedure';
+import * as AccessLevel from '../../../src/core/definitions/AccessLevel';
+import Implementation from '../../../src/core/Implementation';
+import Version from '../../../src/core/Version';
+import Segment from '../../../src/core/Segment';
+
+function getPrivate(): string { return 'private'; }
+function getPublic(): string { return 'public'; }
+function getModule(): string { return 'my/module'; }
+function throwError(): void { throw new Error('broken'); }
+
+const privateImplementation = new Implementation(Version.DEFAULT, AccessLevel.PRIVATE, [], getPrivate);
+const publicImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, [], getPublic);
+const moduleImplementation = new Implementation(Version.DEFAULT, AccessLevel.PRIVATE, [], getModule);
+const errorImplementation = new Implementation(Version.DEFAULT, AccessLevel.PRIVATE, [], throwError);
+
+const privateProcedure = new Procedure('', 'getPrivate');
+privateProcedure.addImplementation(privateImplementation);
+
+const publicProcedure = new Procedure('', 'getPublic');
+publicProcedure.addImplementation(publicImplementation);
+
+const moduleProcedure = new Procedure('my/module', 'getModule');
+moduleProcedure.addImplementation(moduleImplementation);
+
+const errorProcedure = new Procedure('', 'throwError');
+errorProcedure.addImplementation(errorImplementation);
+
+const segment = new Segment('my-segment');
+segment.addProcedure(privateProcedure);
+segment.addProcedure(publicProcedure);
+segment.addProcedure(moduleProcedure);
+segment.addProcedure(errorProcedure);
+
+export { segment }

package/test/_fixtures/core/SegmentBuilder.fixture.ts

@@ -0,0 +1,45 @@
+
+import SegmentModule from '../../../src/core/types/SegmentModule';
+
+function defaultFunction(): string
+{
+    return 'default';
+}
+
+function anotherFunction(a: string, b: string): string
+{
+    return a + b;
+}
+
+const segmentModule: SegmentModule =
+{
+    procedures:
+        [
+            {
+                module: '',
+                name: 'defaultFunction',
+                implementations:
+                    [
+                        {
+                            access: 'public',
+                            version: '0.0.0',
+                            executable: defaultFunction
+                        }
+                    ]
+            },
+            {
+                module: '',
+                name: 'anotherFunction',
+                implementations:
+                    [
+                        {
+                            access: 'public',
+                            version: '1.0.0',
+                            executable: anotherFunction
+                        }
+                    ]
+            }
+        ]
+}
+
+export { segmentModule }

package/test/_fixtures/core/Version.fixture.ts

@@ -0,0 +1,18 @@
+
+import Version from '../../../src/core/Version';
+
+const actualVersion = new Version(1, 2, 3);
+const equalVersion = new Version(1, 2, 3);
+const greaterVersion = new Version(10, 2, 3);
+const lesserVersion = new Version(1, 1, 3);
+const majorVersion = new Version(1, 0, 0);
+const majorMinorVersion = new Version(1, 2, 0);
+
+export {
+    actualVersion,
+    equalVersion,
+    greaterVersion,
+    lesserVersion,
+    majorVersion,
+    majorMinorVersion,
+}

package/test/_fixtures/core/reflection/ReflectionHelper.fixture.ts

@@ -0,0 +1,56 @@
+
+class Human {}
+
+class Person extends Human
+{
+    id: number;
+    #firstName: string; // No getter and setter
+    #lastName: string; // No getter and setter
+    #age: number; // No setter
+    #state: string; // No getter
+
+    constructor(id: number, firstName: string, lastName: string, age: number)
+    {
+        super();
+
+        this.id = id;
+        this.#firstName = firstName;
+        this.#lastName = lastName;
+        this.#age = age;
+        this.#state = 'Ottawa';
+    }
+
+    get fullName() { return `${this.#firstName} ${this.#lastName}`; }
+
+    get age() { return this.#age; }
+
+    set state(state: string) { this.#state = state; }
+
+    toString(): string
+    {
+        return `${this.fullName} is ${this.#age} years old and lives in ${this.#state}`;
+    }
+}
+
+class User extends Person {}
+
+const johnDoe = new Person(1, 'John', 'Doe', 42);
+
+function requiredArgedFunction(a: string, b: Person, c: number): string
+{
+    return a + b + c;
+}
+
+function optionalArgedFunction(a: string, b = new Person(1, 'Jane', 'Doe', 42), c = 0): string
+{
+    return a + b + c;
+}
+
+export
+{
+    Person,
+    User,
+    johnDoe,
+    requiredArgedFunction,
+    optionalArgedFunction
+};

package/test/_fixtures/runtime/LocalGateway.fixture.ts

@@ -0,0 +1,24 @@
+
+import LocalNode from '../../../src/runtime/LocalNode';
+import LocalGateway from '../../../src/runtime/LocalGateway';
+
+import { setRuntime } from '../../../src/hooks';
+
+import { firstSegment, secondSegment } from './segments';
+
+const API_URL = 'http://localhost:80';
+
+const gateway = new LocalGateway(API_URL);
+
+const firstNode = new LocalNode();
+firstNode.addSegment(firstSegment);
+firstNode.setGateway(gateway);
+
+const secondNode = new LocalNode();
+secondNode.addSegment(secondSegment);
+secondNode.setGateway(gateway);
+
+// All test cases have to start from this node
+setRuntime(firstNode);
+
+export { API_URL, gateway }

package/test/_fixtures/runtime/LocalNode.fixture.ts

@@ -0,0 +1,16 @@
+
+import LocalNode from '../../../src/runtime/LocalNode';
+
+import { setRuntime } from '../../../src/hooks';
+
+import { firstSegment, secondSegment } from './segments';
+
+const API_URL = 'http://localhost:80';
+
+const node = new LocalNode(API_URL);
+node.addSegment(firstSegment);
+node.addSegment(secondSegment);
+
+setRuntime(node);
+
+export { API_URL, node }

package/test/_fixtures/runtime/LocalRepository.fixture.ts

@@ -0,0 +1,73 @@
+
+import FileLoader from '../../../src/runtime/interfaces/FileManager';
+import LocalRepository from '../../../src/runtime/LocalRepository';
+import File from '../../../src/runtime/models/File';
+
+class TestFileManager implements FileLoader
+{
+    getRootLocation(): string
+    {
+        return '';
+    }
+
+    getAbsoluteLocation(filename: string): string
+    {
+        return filename;
+    }
+
+    getRelativeLocation(filename: string): string 
+    {
+        return filename;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async getType(filename: string): Promise<string>
+    {
+        return 'application/javascript';
+    }
+
+    async getContent(filename: string): Promise<Buffer | string>
+    {
+        switch (filename)
+        {
+            case 'fourthPrivateTask.js':
+                return Buffer.from('fourthPrivateTask()');
+
+            case 'firstPublicTask.local.js':
+                return Buffer.from('firstPublicTask()');
+
+            case 'secondPublicTask.remote.js':
+                return Buffer.from('runProcedure()');
+        }
+
+        return Buffer.from('');
+    }
+
+    async load(filename: string): Promise<File>
+    {
+        const type = await this.getType(filename);
+        const content = await this.getContent(filename);
+
+        return new File(filename, type, content);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async store(filename: string, content: string): Promise<void>
+    {
+        // Do nothing
+    }
+}
+
+const fileManager = new TestFileManager();
+const repository = new LocalRepository(fileManager);
+const client = { id: '' };
+
+repository.registerSegment('first', ['firstPrivateTask.js', 'firstPublicTask.js', 'thirdPublicTask.js']);
+repository.registerSegment('second', ['secondPrivateTask.js', 'secondPublicTask.js', 'fourthPublicTask.js']);
+repository.registerClient(['first']).then(clientId => client.id = clientId);
+
+const UNSEGMENTED_FILE = 'fourthPrivateTask.js';
+const LOCAL_FILE = 'firstPublicTask.js';
+const REMOTE_FILE = 'secondPublicTask.js';
+
+export { repository, client, UNSEGMENTED_FILE, LOCAL_FILE, REMOTE_FILE }

package/test/_fixtures/runtime/NodeBalancer.fixture.ts

@@ -0,0 +1,19 @@
+
+import LocalNode from '../../../src/runtime/LocalNode';
+import NodeBalancer from '../../../src/runtime/NodeBalancer';
+
+const firstNode = new LocalNode();
+const secondNode = new LocalNode();
+
+const balancer = new NodeBalancer();
+balancer.addNode(firstNode);
+balancer.addNode(secondNode);
+
+const emptyBalancer = new NodeBalancer();
+
+export {
+    balancer,
+    emptyBalancer,
+    firstNode,
+    secondNode
+}

package/test/_fixtures/runtime/NodeMonitor.fixture.ts

@@ -0,0 +1,34 @@
+
+import LocalNode from '../../../src/runtime/LocalNode';
+import LocalGateway from '../../../src/runtime/LocalGateway';
+import NodeMonitor from '../../../src/runtime/NodeMonitor';
+import HealthCheck from '../../../src/runtime/interfaces/HealthCheck';
+
+class HealthyCheck implements HealthCheck
+{
+    async isHealthy(): Promise<boolean> { return true; }
+}
+
+class UnhealthyCheck implements HealthCheck
+{
+    async isHealthy(): Promise<boolean> { return false; }
+}
+
+const goodNode = new LocalNode();
+goodNode.addHealthCheck('good', new HealthyCheck());
+
+const badNode = new LocalNode();
+badNode.addHealthCheck('bad', new UnhealthyCheck());
+
+const gateway = new LocalGateway('http://localhost:80');
+gateway.addNode(goodNode);
+gateway.addNode(badNode);
+
+const monitor = new NodeMonitor(gateway, 100);
+
+export {
+    goodNode,
+    badNode,
+    gateway,
+    monitor
+}

package/test/_fixtures/runtime/RemoteNode.fixture.ts

@@ -0,0 +1,8 @@
+
+import RemoteNode from '../../../src/runtime/RemoteNode';
+
+const API_URL = 'http://localhost:80';
+
+const node = new RemoteNode(API_URL, ['FirstProcedure', 'SecondProcedure']);
+
+export { API_URL, node }