@quenk/potoo 4.0.7 → 4.0.11

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

@@ -1,151 +0,0 @@
-import { Err } from '@quenk/noni/lib/control/error';
-import { Future } from '@quenk/noni/lib/control/monad/future';
-import { empty } from '@quenk/noni/lib/data/array';
-import {
-    CaseFunction,
-    Default,
-    TypeCase
-} from '@quenk/noni/lib/control/match/case';
-import { identity } from '@quenk/noni/lib/data/function';
-
-import { Template } from '../../../../template';
-import { Address, ADDRESS_DISCARD } from '../../../../address';
-import { Task } from '../../scheduler';
-import { Message } from '../../../..';
-import { VM } from '../../';
-import { SharedThread, ThreadState } from '.';
-import { EVENT_ACTOR_RECEIVE, EVENT_MESSAGE_DROPPED } from '../../event';
-
-const defaultCases = [new Default(identity)];
-
-export const ERR_THREAD_INVALID = 'ERR_THREAD_INVALID';
-
-/**
- * JSThread is used by actors that run in the same event loop as the VM.
- */
-export class JSThread implements SharedThread {
-    constructor(
-        public vm: VM,
-        public address: Address,
-        public mailbox: Message[] = [],
-        public state: ThreadState = ThreadState.IDLE
-    ) {}
-
-    readonly self = this.address;
-
-    _assertValid() {
-        if (!this.isValid()) throw new Error(ERR_THREAD_INVALID);
-    }
-
-    isValid() {
-        return (
-            this.state !== ThreadState.INVALID &&
-            this.state !== ThreadState.ERROR
-        );
-    }
-
-    async start() {}
-
-    async notify(msg: Message) {
-        this._assertValid();
-
-        this.mailbox.push(msg);
-
-        if (this.state === ThreadState.MSG_WAIT) this.resume();
-
-        this.vm.scheduler.run();
-    }
-
-    async stop() {}
-
-    async watch<T>(task: () => Promise<T>) {
-        this._assertValid();
-        await Future.do(task).catch(err => this.raise(err));
-    }
-
-    async kill(address: Address): Promise<void> {
-        this._assertValid();
-        this.state = ThreadState.INVALID;
-        await this.vm.sendKillSignal(this, address);
-    }
-
-    die() {
-        // TODO: dispatch event
-        this.state = ThreadState.INVALID;
-        this.vm.scheduler.removeTasks(this);
-    }
-
-    /**
-     * resume marks the Thread as ready to run again.
-     */
-    resume() {
-        this._assertValid();
-        this.state = ThreadState.IDLE;
-    }
-
-    async raise(e: Err) {
-        this._assertValid();
-        this.state = ThreadState.ERROR;
-        await this.vm.errors.raise(this, e);
-    }
-
-    async spawn(tmpl: Template): Promise<Address> {
-        this._assertValid();
-        let result = await Future.fromCallback<Address>(cb => {
-            this.vm.scheduler.postTask(
-                new Task(this, cb, async () => {
-                    let address = await this.vm.allocator.allocate(this, tmpl);
-                    cb(null, address);
-                })
-            );
-        });
-        return result;
-    }
-
-    async tell(addr: Address, msg: Message): Promise<void> {
-        this._assertValid();
-        await Future.fromCallback(cb => {
-            this.vm.scheduler.postTask(
-                new Task(this, cb, async () => {
-                    await this.vm.sendMessage(this, addr, msg);
-                    cb(null);
-                })
-            );
-        });
-    }
-
-    async receive<T = Message>(cases: TypeCase<T>[] = []): Promise<T> {
-        this._assertValid();
-        let msg = await Future.fromCallback<T>(cb => {
-            this.vm.events.dispatchActorEvent(
-                EVENT_ACTOR_RECEIVE,
-                this.address
-            );
-            let matcher = new CaseFunction(empty(cases) ? defaultCases : cases);
-            let task = new Task(this, cb, async () => {
-                this._assertValid();
-                if (!empty(this.mailbox)) {
-                    let msg = this.mailbox.shift();
-                    if (matcher.test(msg)) {
-                        //XXX: Setting the state to idle here allows for
-                        // nested tasks.
-                        this.resume();
-                        let result = await matcher.apply(msg);
-                        return cb(null, result);
-                    }
-                    this.vm.events.dispatchMessageEvent(
-                        EVENT_MESSAGE_DROPPED,
-                        ADDRESS_DISCARD,
-                        this.address,
-                        msg
-                    );
-                }
-                this.state = ThreadState.MSG_WAIT;
-                this.vm.scheduler.postTask(task, true);
-            });
-
-            this.vm.scheduler.postTask(task);
-        });
-        return msg;
-    }
-}

package/lib/actor/system/vm/type.ts

@@ -1,115 +0,0 @@
-/**
- * This module contains the type of objects used by the VM.
- *
- * The high byte of a stack instruction is used to indicate the type of value.
- * Therefore we can have a max of 255 types. In practice, far less is needed
- * and most non-primitive types should be an object.
- */
-import { Type } from '@quenk/noni/lib/data/type';
-
-import { PTObject } from './object';
-import { Thread } from './thread';
-
-export const BYTE_TYPE = 0xff000000;
-export const BYTE_INDEX = 0xffffff;
-
-export const TYPE_STEP = 0x1000000;
-
-export const TYPE_UINT8 = TYPE_STEP;
-export const TYPE_UINT16 = TYPE_STEP * 2;
-export const TYPE_UINT32 = TYPE_STEP * 3;
-export const TYPE_INT8 = TYPE_STEP * 4;
-export const TYPE_INT16 = TYPE_STEP * 5;
-export const TYPE_INT32 = TYPE_STEP * 6;
-export const TYPE_BOOLEAN = TYPE_STEP * 7;
-export const TYPE_STRING = TYPE_STEP * 8;
-export const TYPE_OBJECT = TYPE_STEP * 9;
-export const TYPE_LIST = TYPE_STEP * 10;
-export const TYPE_FUN = TYPE_STEP * 11;
-export const TYPE_CONS = TYPE_STEP * 12;
-export const TYPE_FOREIGN = TYPE_STEP * 13;
-export const TYPE_VOID = 0xf0000000;
-
-export const TYPE_MASK = 0xff000000;
-
-/**
- * TypeDescriptor
- */
-export type TypeDescriptor = number;
-
-/**
- * PTValue types.
- */
-export type PTValue = PTVoid | PTNumber | PTBoolean | PTString | PTObject;
-
-/**
- * PTNumber types.
- */
-export type PTNumber =
-    | PTInt8
-    | PTInt16
-    | PTInt32
-    | PTUInt8
-    | PTUInt16
-    | PTUInt32;
-
-/**
- * PTVoid is the absence of a value.
- */
-export type PTVoid = typeof TYPE_VOID;
-
-/**
- * PTInt8 is a signed 8bit integer.
- */
-export type PTInt8 = number;
-
-/**
- * PTInt16 is a signed 16bit integer.
- */
-export type PTInt16 = number;
-
-/**
- * PTInt32 is a signed 32bit integer.
- */
-export type PTInt32 = number;
-
-/**
- * PTUInt8 is an unsigned 8bit integer.
- */
-export type PTUInt8 = number;
-
-/**
- * PTUInt16 is an unsigned 16bit integer.
- */
-export type PTUInt16 = number;
-
-/**
- * PTUInt32 is an unsigned 32bit integer.
- */
-export type PTUInt32 = number;
-
-/**
- * PTBoolean is a boolean value.
- *
- * Zero=false, non-zero=true.
- */
-export type PTBoolean = number;
-
-/**
- * PTString
- */
-export type PTString = string;
-
-/**
- * ForeignFun type.
- *
- * To make the return value available to the VM, push a value onto the stack.
- */
-export type ForeignFun = (r: Thread, ...args: Type[]) => Type;
-
-/**
- * getType from a TypeDescriptor.
- *
- * The highest byte of the 32bit descriptor indicates its type.
- */
-export const getType = (d: TypeDescriptor): number => d & BYTE_TYPE;

package/lib/actor/template.ts

@@ -1,170 +0,0 @@
-import { Path } from '@quenk/noni/lib/data/record/path';
-import { Err } from '@quenk/noni/lib/control/error';
-import { isFunction, isString } from '@quenk/noni/lib/data/type';
-
-import { Runtime } from './system/vm/runtime';
-import { Actor } from './';
-
-export const ACTION_RAISE = -0x1;
-export const ACTION_IGNORE = 0x0;
-export const ACTION_RESTART = 0x1;
-export const ACTION_STOP = 0x2;
-
-/**
- * TemplateType is the type of actor to create.
- */
-export type TemplateType = string;
-
-/**
- * TrapFunc is applied to unhandled errors raised by an actor.
- *
- * The result determines the action to take.
- */
-export type TrapFunc = (e: Err) => TrapAction;
-
-/**
- * TrapAction represents each one of the actions that can be taken after
- * an error has been trapped.
- *
- * These are:
- *
- * 1. Raise an error (to the actor's parent).
- * 2. Ignore the error (effectively continuing as though nothing happened).
- * 3. Restart the actor.
- * 4. Stop the actor and eject it from the system.
- */
-export type TrapAction = -0x1 | 0x0 | 0x1 | 0x2;
-
-/**
- * BaseTemplate holds the common properties for all templates.
- */
-export interface BaseTemplate {
-    /**
-     * type indicates the type of template and thus the type of thread that
-     * will be allocated for the actor.
-     *
-     * Defaults to 'shared' if not specified.
-     */
-    type?: TemplateType;
-
-    /**
-     * id of the actor used when constructing its address.
-     *
-     * Ids must be unique among the children of an actor but not necessary at
-     * the system level.
-     *
-     * If no id is supplied the system will generate one.
-     */
-    id?: string;
-
-    /**
-     * group assignment for the actor.
-     *
-     * Including an actor in a group allows for messages to be sent to one
-     * address but received by multiple actors.
-     */
-    group?: string | string[];
-
-    /**
-     * trap is called when unhandled errors are detected.
-     *
-     * The result of this function determines the next action to take.
-     */
-    trap?: TrapFunc;
-}
-
-/**
- * CreateFunc is a function that creates an actor given the handle the system
- * has generated.
- *
- * Use it when a class based actor implementation is preffered.
- */
-export type CreateFunc = (runtime: Runtime) => Actor;
-
-/**
- * RunFunc serves as the main function for function based actors.
- *
- * This should only ever be a function declared with the "async" keyword and
- * not just a function that returns a Promise.
- */
-export type RunFunc = (runtime: Runtime) => Promise<void>;
-
-/**
- * Template is an object that tells the system how to create an manage an
- * actor.
- *
- * Every actor in the system is created from an initial template that is reused
- * if the actor needs to be restarted. The type of template determines the
- * type of thread that will be allocated for the actor.
- */
-export type Template = SharedTemplate | ProcessTemplate;
-
-/**
- * SharedTemplate is used for resident actors that require a SharedThread to
- * be allocated.
- */
-export type SharedTemplate = SharedCreateTemplate | SharedRunTemplate;
-
-/**
- * SharedCreateTemplate is used for class based actors.
- */
-export interface SharedCreateTemplate extends BaseTemplate {
-    /**
-     * create an instance of the actor to be used within the system.
-     */
-    create: CreateFunc;
-}
-
-/**
- * SharedRunTemplate is used for function based actors.
- */
-export interface SharedRunTemplate extends BaseTemplate {
-    /**
-     * run is called to run a function based actor.
-     */
-    run: RunFunc;
-}
-
-/**
- * ProcessTemplate is used for creating child process actors.
- */
-export interface ProcessTemplate extends BaseTemplate {
-    /**
-     * script is the path to the script that will be executed in the child
-     * process.
-     */
-    script: Path;
-}
-
-/**
- * Spawnable allows a CreateFunc to be used in place of a Template.
- */
-export type Spawnable = Template | CreateFunc | RunFunc;
-
-const AsyncFunction = (async () => {}).constructor;
-
-const isAsyncFunction = (func: Function) => func.constructor === AsyncFunction;
-
-/**
- * isProcessTemplate test.
- */
-export const isProcessTemplate = (tmpl: Template): tmpl is ProcessTemplate =>
-    isString((<ProcessTemplate>tmpl).script);
-
-/**
- * fromSpawnable converts a Spawnable to a Template.
- *
- * If a function is supplied we assume a SharedTemplate is desired.
- *
- * NOTE: That this requires a runtime that has an AsyncFunction constructor
- * in global scope in order to work properly.
- */
-export const fromSpawnable = (tmpl: Spawnable): Template => {
-    if (isFunction(tmpl)) {
-        return isAsyncFunction(tmpl)
-            ? { run: <RunFunc>tmpl }
-            : { create: <CreateFunc>tmpl };
-    } else {
-        return tmpl;
-    }
-};

package/lib/tsconfig.json

@@ -1,22 +0,0 @@
-{
-    "compilerOptions": {
-        "baseUrl": "src",
-        "lib": ["es5", "ES2015", "DOM"],
-        "module": "commonjs",
-        "target": "ES2017",
-        "rootDir": ".",
-        "outDir": "../lib",
-        "moduleResolution": "node",
-        "allowUnreachableCode": true,
-        "noUnusedParameters": true,
-        "noUnusedLocals": true,
-        "skipLibCheck": true,
-        "noImplicitAny": true,
-        "sourceMap": true,
-        "declaration": true,
-        "strict": true,
-        "types": ["node"],
-        "typeRoots": ["../node_modules/@types"]
-    },
-    "exclude": ["node_modules"]
-}