@quenk/potoo 4.0.7 → 4.0.11

package/lib/actor/system/vm/script/info.ts

@@ -1,359 +0,0 @@
-import * as types from '../type';
-
-import { ForeignFun, TypeDescriptor } from '../type';
-import { Instruction } from '../op';
-
-/**
- * Info objects provide important information about named identifiers appearing
- * in the compiled source.
- */
-export interface Info {
-    /**
-     * type is the TypeInfo object of the indentifier.
-     */
-    type: TypeInfo;
-
-    /**
-     * name of the identifier as it appears in source text.
-     */
-    name: string;
-
-    /**
-     * descriptor
-     */
-    descriptor: TypeDescriptor;
-}
-
-/**
- * TypeInfo holds type information about a named identifier.
- *
- * In effect, it describes the constructor of a symbol and is itself a symbol.
- */
-export interface TypeInfo extends Info {
-    /**
-     * properties is an array of property info objects that describe the
-     * properties of objects created with this constructor.
-     */
-    properties: PropInfo[];
-}
-
-/**
- * ArrayTypeInfo is a TypeInfo for array types.
- *
- * This structure exists because arrays can be recursive and may need to
- * retain nested type information on their elements.
- */
-export interface ArrayTypeInfo extends TypeInfo {
-    /**
-     * elements indicates the type of the array's elements.
-     */
-    elements: TypeInfo;
-}
-
-/**
- * FunInfo maintains information about compiled functions.
- */
-export interface FunInfo extends Info {
-    /**
-     * argc is the argument count of the function.
-     */
-    argc: number;
-
-    /**
-     * code section.
-     */
-    code: Instruction[];
-
-    /**
-     * foreign indicates whether the function is implemented using a JS
-     * function.
-     * If so, the exec property must be provided.
-     */
-    foreign: boolean;
-}
-
-/**
- * ForeignFunInfo maintains information about foreigin functions.
- */
-export interface ForeignFunInfo extends FunInfo {
-    /**
-     * exec (foreign only).
-     */
-    exec: ForeignFun;
-}
-
-/**
- * PropInfo holds information about a property on an object.
- */
-export interface PropInfo {
-    /**
-     * name of the property.
-     */
-    name: string;
-
-    /**
-     * type information about the property.
-     */
-    type: TypeInfo;
-}
-
-/**
- * NewInfo
- */
-export abstract class NewInfo implements Info {
-    constructor(public name: string) {}
-
-    abstract type: TypeInfo;
-
-    abstract descriptor: number;
-}
-
-/**
- * VoidInfo
- */
-export class VoidInfo extends NewInfo {
-    type = voidType;
-
-    descriptor = types.TYPE_VOID;
-}
-
-/**
- * NewUInt8Info
- */
-export class NewUInt8Info extends NewInfo {
-    type = uint8Type;
-
-    descriptor = types.TYPE_UINT8;
-}
-
-/**
- * NewUInt16Info
- */
-export class NewUInt16Info extends NewInfo {
-    type = uint16Type;
-
-    descriptor = types.TYPE_UINT16;
-}
-
-/**
- * NewUInt32Info
- */
-export class NewUInt32Info extends NewInfo {
-    type = uint32Type;
-
-    descriptor = types.TYPE_UINT32;
-}
-
-/**
- * NewInt8Info
- */
-export class NewInt8Info extends NewInfo {
-    type = int8Type;
-
-    descriptor = types.TYPE_INT8;
-}
-
-/**
- * NewInt16Info
- */
-export class NewInt16Info extends NewInfo {
-    type = int16Type;
-
-    descriptor = types.TYPE_INT16;
-}
-
-/**
- * NewInt32Info
- */
-export class NewInt32Info extends NewInfo {
-    type = int32Type;
-
-    descriptor = types.TYPE_INT32;
-}
-
-/**
- * NewBooleanInfo
- */
-export class NewBooleanInfo extends NewInfo {
-    type = booleanType;
-
-    descriptor = types.TYPE_BOOLEAN;
-}
-
-/**
- * NewStringInfo
- */
-export class NewStringInfo extends NewInfo {
-    type = stringType;
-
-    descriptor = types.TYPE_STRING;
-}
-
-/**
- * NewObjectInfo
- */
-export class NewObjectInfo extends NewInfo {
-    type = objectType;
-
-    descriptor = types.TYPE_OBJECT;
-}
-
-/**
- * NewArrayInfo
- */
-export class NewArrayInfo extends NewInfo {
-    constructor(public name: string, public type: ArrayTypeInfo) {
-        super(name);
-    }
-
-    descriptor = types.TYPE_LIST;
-}
-
-/**
- * NewFunInfo
- */
-export class NewFunInfo extends NewInfo implements FunInfo {
-    constructor(
-        public name: string,
-        public argc: number,
-        public code: Instruction[]
-    ) {
-        super(name);
-    }
-
-    type = funType;
-
-    descriptor = types.TYPE_FUN;
-
-    foreign = false;
-}
-
-/**
- * NewForeignFunInfo
- */
-export class NewForeignFunInfo extends NewInfo implements FunInfo {
-    constructor(
-        public name: string,
-        public argc: number,
-        public exec: ForeignFun
-    ) {
-        super(name);
-    }
-
-    type = funType;
-
-    descriptor = types.TYPE_FUN;
-
-    foreign = true;
-
-    code = [];
-}
-
-/**
- * NewTypeInfo
- */
-export class NewTypeInfo extends NewInfo implements TypeInfo {
-    constructor(
-        public name: string,
-        public argc: number,
-        public properties: PropInfo[],
-        public descriptor = types.TYPE_OBJECT
-    ) {
-        super(name);
-    }
-
-    type = funType;
-
-    code = [];
-}
-
-/**
- * NewArrayTypeInfo
- */
-export class NewArrayTypeInfo extends NewInfo implements ArrayTypeInfo {
-    constructor(public name: string, public elements: TypeInfo) {
-        super(name);
-    }
-
-    type = funType;
-
-    argc = 0;
-
-    properties = [];
-
-    code = [];
-
-    descriptor = types.TYPE_LIST;
-}
-
-/**
- * NewPropInfo
- */
-export class NewPropInfo implements PropInfo {
-    constructor(public name: string, public type: TypeInfo) {}
-}
-
-/**
- * voidType constructor.
- */
-export const voidType = new NewTypeInfo('void', 0, [], types.TYPE_VOID);
-
-/**
- * int8Type constructor.
- */
-export const int8Type = new NewTypeInfo('int8', 1, [], types.TYPE_INT8);
-
-/**
- * int16Type constructor.
- */
-export const int16Type = new NewTypeInfo('int16', 1, [], types.TYPE_INT16);
-
-/**
- * int32type constructor.
- */
-export const int32Type = new NewTypeInfo('int32', 1, [], types.TYPE_INT32);
-
-/**
- * uint8Type constructor.
- */
-export const uint8Type = new NewTypeInfo('uint8', 1, [], types.TYPE_UINT8);
-
-/**
- * uint16Type constructor.
- */
-export const uint16Type = new NewTypeInfo('uint16', 1, [], types.TYPE_UINT16);
-
-/**
- * uint32type constructor.
- */
-export const uint32Type = new NewTypeInfo('uint32', 1, [], types.TYPE_UINT32);
-
-/**
- * booleanType constructor.
- */
-export const booleanType = new NewTypeInfo(
-    'boolean',
-    1,
-    [],
-    types.TYPE_BOOLEAN
-);
-
-/**
- * stringType constructor.
- */
-export const stringType = new NewTypeInfo('string', 1, [], types.TYPE_STRING);
-
-/**
- * arrayType constructor.
- */
-export const arrayType = new NewTypeInfo('array', 0, [], types.TYPE_LIST);
-
-/**
- * objectCons
- */
-export const objectType = new NewTypeInfo('object', 0, [], types.TYPE_OBJECT);
-
-/**
- * funType
- */
-export const funType = new NewTypeInfo('function', 0, [], types.TYPE_FUN);

package/lib/actor/system/vm/strategy/error.ts

@@ -1,88 +0,0 @@
-import * as template from '../../../template';
-import * as errors from '../runtime/error';
-
-import { Err, toError } from '@quenk/noni/lib/control/err';
-
-import { ADDRESS_SYSTEM, getParent } from '../../../address';
-import { Thread } from '../thread';
-import { Allocator } from '../allocator';
-
-/**
- * ErrorStrategy is the interface used by threads to communicate errors that
- * have occurred within the system.
- *
- * Error handling is mostly dictated by the result of the template's trap
- * function however, when that function is not specified, the strategy determines
- * what to do.
- */
-export interface ErrorStrategy {
-    /**
-     * raise an error within the system.
-     *
-     * The error will be subject to the strategy's error handling algorithm.
-     */
-    raise(src: Thread, err: Err): Promise<void>;
-}
-
-/**
- * SupervisorErrorStrategy defaults to raising the error with the parent actor
- * if no trap function is specified.
- */
-export class SupervisorErrorStrategy implements ErrorStrategy {
-    constructor(public allocator: Allocator) {}
-
-    async raise(src: Thread, error: Err) {
-        let prevThread;
-
-        let err = error;
-
-        let currentThread = src;
-
-        let allocator = this.allocator;
-
-        while (true) {
-            if (prevThread) {
-                await allocator.deallocate(prevThread);
-                let mcurrentThread = allocator.getThread(
-                    getParent(prevThread.address)
-                );
-
-                //TODO: warn thread not found.
-                if (mcurrentThread.isNothing()) break;
-
-                currentThread = mcurrentThread.get();
-
-                err = new errors.ActorTerminatedErr(
-                    currentThread.address,
-                    src.address,
-                    error
-                );
-            }
-
-            let tmpl = allocator.getTemplate(currentThread.address).get();
-
-            let trap = tmpl.trap ?? defaultTrap;
-
-            let action = trap(err);
-
-            if (action === template.ACTION_IGNORE) {
-                //TODO: Should the thread be put back in the idle state?
-                return;
-            } else if (action === template.ACTION_RESTART) {
-                await allocator.reallocate(currentThread);
-                return;
-            } else if (action === template.ACTION_STOP) {
-                await allocator.deallocate(currentThread);
-                return;
-            } else if (currentThread.address === ADDRESS_SYSTEM) {
-                break;
-            }
-
-            prevThread = currentThread;
-        }
-
-        throw toError(err);
-    }
-}
-
-const defaultTrap = () => template.ACTION_RAISE;

package/lib/actor/system/vm/thread/factory.ts

@@ -1,29 +0,0 @@
-import { Address } from '../../../address';
-import {
-    isProcessTemplate,
-    ProcessTemplate,
-    Template
-} from '../../../template';
-import { VM } from '..';
-import { JSThread } from './shared/js';
-import { ProcessThread } from './process';
-
-/**
- * ThreadFactory creates Thread implementations based on the provided
- * TemplateType.
- */
-export class ThreadFactory {
-    /**
-     * create a new instance of a Thread for the given TemplateType.
-     */
-    static create(vm: VM, address: Address, template: Template) {
-        if (isProcessTemplate(template))
-            return ProcessThread.create(
-                vm,
-                address,
-                (<ProcessTemplate>template).script
-            );
-
-        return new JSThread(vm, address);
-    }
-}

package/lib/actor/system/vm/thread/index.ts

@@ -1,29 +0,0 @@
-import { Err } from '@quenk/noni/lib/control/err';
-
-import { Address } from '../../../address';
-import { Actor } from '../../..';
-
-export const ERR_THREAD_INVALID = 'ERR_THREAD_INVALID';
-
-/**
- * Thread serves as the execution context for a single actor.
- *
- * Coincidentally, Threads are themselves actors as far as the system is
- * concerned. This design allows any external code to simply allocate a Thread
- * and use it to communicate with the system without having to extend internal
- * classes or re-implement existing logic.
- *
- * Threads are of course, not actual OS threads but rather an abstract of the
- * VM used to make managing actors easier.
- */
-export interface Thread extends Actor {
-    /**
-     * address for the Thread (actor) within the system.
-     */
-    address: Address;
-
-    /**
-     * raise an error triggering the system's error handling machinery.
-     */
-    raise(e: Err): Promise<void>;
-}

package/lib/actor/system/vm/thread/process.ts

@@ -1,134 +0,0 @@
-import { resolve } from 'path';
-import { ChildProcess, fork } from 'child_process';
-
-import { Err } from '@quenk/noni/lib/control/err';
-import { Path } from '@quenk/noni/lib/data/record/path';
-import { Any, test } from '@quenk/noni/lib/data/type';
-
-import { Address } from '../../../address';
-import { Message } from '../../..';
-import { VM } from '../';
-import { Thread } from '.';
-
-export const CTRL_MSG_RAISE = 9;
-export const CTRL_MSG_SEND = 1;
-export const CTRL_MSG_DROP = 3;
-
-const shapes = {
-    raise: {
-        code: CTRL_MSG_RAISE,
-
-        src: String,
-
-        dest: String,
-
-        message: String,
-
-        stack: String
-    },
-
-    send: {
-        to: String,
-
-        from: String,
-
-        message: Any
-    },
-
-    drop: {
-        code: CTRL_MSG_DROP,
-
-        from: String,
-
-        to: String,
-
-        message: Any
-    }
-};
-
-/**
- * ProcessThread is used for actors created via ChildProcess instances.
- *
- * The child process script is treated as a single actor as far as the VM is
- * concerned.
- */
-export class ProcessThread implements Thread {
-    constructor(
-        public vm: VM,
-        public process: ChildProcess,
-        public address: Address
-    ) {}
-
-    /**
-     * create a new ProcessThread instance using the provided script path for
-     * the ChildProcess creation.
-     *
-     * The child process will have access to the following environment variables:
-     *
-     * 1. POTOO_ACTOR_ADDRESS   The full address of the actor in the parent VM.
-     */
-    static create(vm: VM, address: Address, script: Path): ProcessThread {
-        let cp = fork(resolve(script), {
-            env: { POTOO_ACTOR_ADDRESS: address }
-        });
-
-        let thread = new ProcessThread(vm, cp, address);
-
-        return thread;
-    }
-
-    async notify(msg: Message) {
-        this.process.send(msg);
-    }
-
-    async raise(err: Err) {
-        await this.vm.errors.raise(this, err);
-    }
-
-    /**
-     * start the ProcessThread.
-     *
-     * The following event handlers are installed on the child process:
-     *
-     * 1. "error"   - will raise through the error handling machinery.
-     * 2. "message  - will forward messages in the correct format from the child
-     *                process to other actors in the system.
-     * 3. "exit"    - will signal to the VM to kill this actor.
-     */
-    async start() {
-        let { vm, address } = this;
-
-        let cp = this.process;
-
-        cp.on('error', (err: Error) => this.raise(err));
-
-        if (cp.stderr)
-            cp.stderr.on('data', data => console.error(`${address}: ${data}`));
-
-        if (cp.stdout)
-            cp.stdout.on('data', data => console.log(`${address}: ${data}`));
-
-        cp.on('message', async (m: Message) => {
-            if (test(shapes.raise, m)) {
-                let { message, stack } = m;
-                let err = new Error(message);
-
-                err.stack = stack;
-                this.raise(err);
-            } else if (test(shapes.send, m)) {
-                let { to, message } = m;
-                await vm.sendMessage(this, to, message);
-            } else {
-                //TODO: Publish drop event.
-            }
-        });
-
-        cp.on('exit', () => {
-            vm.sendKillSignal(this, address);
-        });
-    }
-
-    async stop() {
-        this.process.kill();
-    }
-}

package/lib/actor/system/vm/thread/shared/index.ts

@@ -1,50 +0,0 @@
-import { Err } from '@quenk/noni/lib/control/error';
-
-import { Thread } from '../';
-
-export const THREAD_STATE_IDLE = 0;
-export const THREAD_STATE_RUN = 1;
-export const THREAD_STATE_MSG_WAIT = 2;
-export const THREAD_STATE_ASYNC_WAIT = 3;
-export const THREAD_STATE_ERROR = 4;
-export const THREAD_STATE_INVALID = 5;
-
-/**
- * ThreadState is a number corresponding to one of the THREAD_STATE_X constants.
- */
-export enum ThreadState {
-    IDLE = THREAD_STATE_IDLE,
-    RUNNING = THREAD_STATE_RUN,
-    MSG_WAIT = THREAD_STATE_MSG_WAIT,
-    ASYNC_WAIT = THREAD_STATE_ASYNC_WAIT,
-    ERROR = THREAD_STATE_ERROR,
-    INVALID = THREAD_STATE_INVALID
-}
-
-export const ERR_THREAD_INVALID = 'ERR_THREAD_INVALID';
-
-/**
- * SharedThread is one that shares the JavaScript event loop with other threads.
- *
- * Due to the design of JavaScript engines, only one of these threads can
- * actively execute at a time meaning the actors have to share execution time
- * via the Scheduler.
- */
-export interface SharedThread extends Thread {
-    /**
-     * state of the Thread.
-     *
-     * Used by the scheduler to determine execution order.
-     */
-    state: ThreadState;
-
-    /**
-     * raise an error triggering the system's error handling machinery.
-     */
-    raise(e: Err): Promise<void>;
-
-    /**
-     * resume marks the Thread as ready to run again.
-     */
-    resume(): void;
-}