@quenk/potoo 4.0.7 → 4.0.11

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

@@ -1,230 +0,0 @@
-import * as template from '../../template';
-import * as errors from './runtime/error';
-import * as events from './event';
-
-import { Err } from '@quenk/noni/lib/control/error';
-import { Future } from '@quenk/noni/lib/control/monad/future';
-import { diff, empty } from '@quenk/noni/lib/data/array';
-import { merge } from '@quenk/noni/lib/data/record';
-
-import { Address, ADDRESS_SYSTEM, isChild, isGroup } from '../../address';
-import { fromSpawnable } from '../../template';
-import { Actor, Message } from '../../';
-import { MapAllocator } from './allocator/map';
-import { ErrorStrategy, SupervisorErrorStrategy } from './strategy/error';
-import { Thread } from './thread';
-import { GroupMap } from './group';
-import { Scheduler } from './scheduler';
-import { RegistrySet } from './registry';
-import { Allocator } from './allocator';
-import { Api } from '../../api';
-import { LogWritable, LogWriter } from './log/writer';
-import { EventDispatcher } from './event/dispatcher';
-import { Conf, PartialConf } from './conf';
-import { toLogLevelValue } from './log';
-
-/**
- * VM is the interface for a virtual machine.
- *
- * It provides methods for manipulating the state of the actors of the system.
- * Some opcode handlers depend on this interface to do their work.
- */
-export interface VM extends Actor, Thread, Api {
-    /**
-     * allocator used to manage thread resources for an actor.
-     */
-    allocator: Allocator;
-
-    /**
-     * scheduler used for co-ordinating actor thread execution.
-     */
-    scheduler: Scheduler;
-
-    /**
-     * errors strategy used to handle errors that occur within the system.
-     */
-    errors: ErrorStrategy;
-
-    /**
-     * log service for the VM.
-     *
-     * Used to access the internal logging API.
-     */
-    log: LogWritable;
-
-    /**
-     * events service for the VM.
-     *
-     * Used to publish VM events to interested listeners.
-     */
-    events: EventDispatcher;
-
-    /**
-     * registry used to store internal VM objects.
-     */
-    registry: RegistrySet;
-
-    /**
-     * groups holds the mapping of group names to actor addresses.
-     */
-    groups: GroupMap;
-
-    /**
-     * sendMessage to the actor act the destination address.
-     *
-     * This is used by the threads to communicate.
-     */
-    sendMessage(from: Thread, to: Address, msg: Message): void;
-
-    /**
-     * sendKillSignal initiates the deallocation of the actor at the
-     * specified address.
-     *
-     * Actual deallocation only occurs if the source thread is allowed to.
-     */
-    sendKillSignal(src: Thread, target: Address): Promise<void>;
-
-    /**
-     * runTask allows an async function to be executed on behalf of a Thread.
-     *
-     * If the Promise rejects, the error is raised with the Thread.
-     */
-    runTask(thread: Thread, task: () => Promise<void>): Promise<void>;
-}
-
-/**
- * PVM (Potoo Virtual Machine) is a JavaScript implemented virtual machine that
- * functions as a message delivery system between target actors.
- *
- * Actors known to the VM are considered to be part of a system and may or may
- * not reside on the same process/worker/thread depending on the underlying
- * platform and individual actor implementations.
- */
-export class PVM implements VM {
-    constructor(
-        public allocator: Allocator = new MapAllocator(() => this),
-        public scheduler: Scheduler = new Scheduler(),
-        public errors: ErrorStrategy = new SupervisorErrorStrategy(allocator),
-        public log: LogWritable = new LogWriter(console),
-        public events = new EventDispatcher(log),
-        public registry = new RegistrySet(),
-        public groups: GroupMap = new GroupMap(),
-        public address = ADDRESS_SYSTEM,
-        public self = ADDRESS_SYSTEM
-    ) {}
-
-    /**
-     * create a new PVM instance using the provided configuration.
-     */
-    static create(conf: PartialConf = {}): PVM {
-        let config: Conf = {
-            log: merge({ level: 'info', sink: console }, conf.log ?? {})
-        };
-
-        let vm: PVM;
-
-        let allocator = new MapAllocator(() => vm);
-        let log = new LogWriter(
-            config.log.sink,
-            toLogLevelValue(config.log.level)
-        );
-
-        vm = new PVM(
-            allocator,
-            new Scheduler(),
-            new SupervisorErrorStrategy(allocator),
-            log,
-            new EventDispatcher(log),
-            new RegistrySet(),
-            new GroupMap()
-        );
-        return vm;
-    }
-
-    // Actor
-
-    async start() {}
-
-    //TODO: events.OnRootMessage.dispatch();
-    async notify() {}
-
-    //TODO: stop all actors?
-    async stop() {}
-
-    // Api
-
-    get vm() {
-        return this;
-    }
-
-    async spawn(tmpl: template.Spawnable): Promise<Address> {
-        return this.allocator.allocate(this, fromSpawnable(tmpl));
-    }
-
-    async tell(to: Address, msg: Message) {
-        this.sendMessage(this, to, msg);
-    }
-
-    async raise(err: Err) {
-        await this.errors.raise(this, err);
-    }
-
-    async kill(addr: Address) {
-        await this.sendKillSignal(this, addr);
-    }
-
-    async receive<T>() {
-        return <Promise<T>>Future.raise(new Error('Not implemented'));
-    }
-
-    // Platform
-
-    sendMessage(from: Thread, to: Address, msg: Message) {
-        let targets = isGroup(to) ? this.groups.getMembers(to) : [to];
-
-        let threads = this.allocator.getThreads(targets);
-
-        let missing = diff(
-            targets,
-            threads.map(t => t.address)
-        );
-
-        if (!empty(missing)) {
-            for (let address of missing)
-                this.events.dispatchMessageEvent(
-                    events.EVENT_MESSAGE_BOUNCE,
-                    from.address,
-                    address,
-                    msg
-                );
-        }
-
-        for (let thread of threads) {
-            this.events.dispatchMessageEvent(
-                events.EVENT_MESSGAE_SEND,
-                from.address,
-                to,
-                msg
-            );
-            thread.notify(msg).catch(err => thread.raise(err));
-        }
-    }
-
-    async sendKillSignal(src: Thread, target: Address): Promise<void> {
-        if (src.address !== target && !isChild(src.address, target)) {
-            return Future.raise(new errors.IllegalStopErr(src.address, target));
-        }
-
-        let mtargetThread = this.allocator.getThread(target);
-
-        if (mtargetThread.isNothing()) {
-            return;
-        }
-
-        await this.allocator.deallocate(mtargetThread.get());
-    }
-
-    runTask(thread: Thread, task: () => Promise<void>): Promise<void> {
-        return Future.do(task).catch(err => thread.raise(err));
-    }
-}

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

@@ -1,73 +0,0 @@
-import { Type } from '@quenk/noni/lib/data/type';
-
-/**
- * LogLevel is a string indicating the maximum level of messages that should
- * be written to the log sink.
- */
-export type LogLevel = 'trace' | 'debug' | 'info' | 'notice' | 'warn' | 'error';
-
-/**
- * LogLevelValue is a numeric representation of a LogLevel.
- */
-export enum LogLevelValue {
-    trace = 8,
-    debug = 7,
-    info = 6,
-    notice = 5,
-    warn = 4,
-    error = 3
-}
-
-/**
- * LogSink is the interface expected of log message destinations.
- *
- * This is based on the JS console API and as a result `console` is a valid
- * LogSink.
- */
-export interface LogSink {
-    /**
-     * debug level.
-     */
-    debug(...e: Type[]): void;
-
-    /**
-     * info level.
-     */
-    info(...e: Type[]): void;
-
-    /**
-     * warn level.
-     */
-    warn(...e: Type[]): void;
-
-    /**
-     * error level.
-     */
-    error(...e: Type[]): void;
-
-    /**
-     * log level.
-     */
-    log(...e: Type[]): void;
-}
-
-const logLevelValueEntries = Object.entries(LogLevelValue);
-
-/**
- * toLogLevel converts a LogLevelValue to a LogLevel string.
- *
- * If the value is not valid '<void>' is returned.
- */
-export const toLogLevel = (level: LogLevelValue): LogLevel => {
-    let entry = logLevelValueEntries.find(([, v]) => v === level);
-    return <LogLevel>(entry ? entry[0] : '<void>');
-};
-
-/**
- * toLogLevelValue converts a LogLevel to a LogLevelValue.
- *
- * I the LogLevel is not valid LogLevelValue.info is returned.
- */
-export const toLogLevelValue = (level: LogLevel | string): LogLevelValue => {
-    return LogLevelValue[<LogLevel>level] ?? LogLevelValue.info;
-};

package/lib/actor/system/vm/log/writer.ts

@@ -1,96 +0,0 @@
-import * as events from '../event';
-
-import { isString, Type } from '@quenk/noni/lib/data/type';
-import { Record } from '@quenk/noni/lib/data/record';
-import { interpolate } from '@quenk/noni/lib/data/string';
-
-import { InternalEvent } from '../event';
-import { LogLevelValue, LogSink } from '.';
-
-/**
- * LogWritable is the interface used by the VM for logging.
- *
- * It provides convenience methods for writing various types of messages to the
- * log sink.
- */
-export interface LogWritable {
-    /**
-     * level is the current log level.
-     */
-    level: LogLevelValue;
-
-    /**
-     * sink is the destination logs will be written to.
-     */
-    sink: LogSink;
-
-    /**
-     * write a message to the log if the level is less than or equal to the
-     * current log level.
-     */
-    write(level: LogLevelValue, ...args: Type[]): void;
-
-    /**
-     * writeEvent writes an InternalEvent to the log.
-     *
-     * This uses internal logic to format a message for each event.
-     */
-    writeEvent<E extends InternalEvent>(event: E): void;
-}
-
-/**
- * LogTemplate used to format event log messages.
- */
-export type LogTemplates = Record<string>;
-
-const defaultTemplates: LogTemplates = {
-    [events.EVENT_MESSAGE_BOUNCE]: 'Message from {from} to {to} bounced!',
-
-    [events.EVENT_MESSGAE_SEND]:
-        'Message from {from} to {to} delivered successfully!'
-};
-
-/**
- * LogWriter provides an implementation of [[LogWritable]] for the VM.
- */
-export class LogWriter implements LogWritable {
-    constructor(
-        public sink: LogSink,
-        public level: LogLevelValue = LogLevelValue.error,
-        public templates: LogTemplates = defaultTemplates
-    ) {}
-
-    write(level: LogLevelValue, ...args: Type[]) {
-        if (level > this.level) return;
-
-        let { sink } = this;
-
-        switch (level) {
-            case LogLevelValue.debug:
-            case LogLevelValue.trace:
-                sink.debug(...args);
-                break;
-
-            case LogLevelValue.notice:
-            case LogLevelValue.warn:
-                sink.warn(...args);
-                break;
-
-            case LogLevelValue.error:
-                sink.error(...args);
-                break;
-
-            default:
-                sink.info(...args);
-                break;
-        }
-    }
-
-    writeEvent(evt: InternalEvent) {
-        let message = this.templates[evt.type] || evt;
-        this.write(
-            evt.level,
-            isString(message) ? interpolate(message, evt) : message
-        );
-    }
-}

package/lib/actor/system/vm/object/foreign.ts

@@ -1,10 +0,0 @@
-import { Type } from '@quenk/noni/lib/data/type';
-
-import { PTObject } from '.';
-
-/**
- * PTForeign contains an opaque value whose type is external to the VM.
- */
-export class PTForeign implements PTObject {
-    constructor(public value: Type) {}
-}

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

@@ -1,4 +0,0 @@
-/**
- * PTObject is the base interface for all objects in the PT library.
- */
-export interface PTObject {}

package/lib/actor/system/vm/object/list.ts

@@ -1,8 +0,0 @@
-import { PTObject } from '.';
-
-/**
- * PTList is the interface of objects stored in the object pool.
- *
- * TODO: Make useable by the VM.
- */
-export class PTList implements PTObject {}

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

@@ -1,126 +0,0 @@
-import { Frame } from '../frame';
-import { Template } from '../../../template';
-import { Operand } from '.';
-import { JSThread } from '../thread/shared/js';
-
-/**
- * alloc allocates resources for a new child actor.
- *
- * TOS must be an instance of PTTemplate or an error will be raised.
- * The address of the new actor is pushed onto the stack.
- *
- * Stack:
- * <template> -> <address>
- */
-export const alloc = (thread: JSThread, frame: Frame, _: Operand) => {
-    let eTemp = frame.popObject();
-
-    if (eTemp.isLeft()) return thread.raise(eTemp.takeLeft());
-
-    let tmpl = eTemp.takeRight();
-
-    //TODO: if(!isTemplateLike(tmpl)) return thread.raise(new Error('alloc: Cannot allocate non-template!'));
-
-    //TODO: this is async
-    thread.spawn(<Template>tmpl);
-
-    /*
-    if (eresult.isLeft()) {
-        thread.raise(eresult.takeLeft());
-    } else {
-        frame.push(thread.vm.registry.addString(eresult.takeRight()));
-    }*/
-};
-
-/**
- * self puts the address of the current actor on to the stack.
- * TODO: make self an automatic variable
- */
-export const self = (_: JSThread, f: Frame, __: Operand) => {
-    f.pushSelf();
-};
-
-/**
- * send a message to another actor.
- *
- * Stack:
- * <message>,<address> -> <uint8>
- */
-export const send = (r: JSThread, f: Frame, _: Operand) => {
-    let eMsg = f.popValue();
-
-    if (eMsg.isLeft()) return r.raise(eMsg.takeLeft());
-
-    let eAddr = f.popString();
-
-    if (eAddr.isLeft()) return r.raise(eAddr.takeLeft());
-
-    r.vm.sendMessage(r, eAddr.takeRight(), eMsg.takeRight());
-};
-
-/**
- * recv schedules a receiver function for the next available message.
- *
- * Currently only supports foreign functions.
- * Will invoke the actor's notify() method if there are pending
- * messages.
- *
- * Stack:
- * <function> ->
- */
-export const recv = (r: JSThread, f: Frame, _: Operand) => {
-    let einfo = f.popFunction();
-
-    if (einfo.isLeft()) return r.raise(einfo.takeLeft());
-
-    // r.watch(r.receive());
-};
-
-/**
- * recvcount pushes the total count of pending receives to the top of the stack.
- *
- * Stack:
- *  -> <uint32>
- */
-export const recvcount = (_r: JSThread, _f: Frame, _: Operand) => {
-    //f.push(r.context.receivers.length);
-};
-
-/**
- * mailcount pushes the number of messages in the actor's mailbox onto the top
- * of the stack.
- *
- * Stack:
- *  -> <uint32>
- */
-export const mailcount = (r: JSThread, f: Frame, _: Operand) => {
-    f.push(r.mailbox.length);
-};
-
-/**
- * maildq pushes the earliest message in the mailbox (if any).
- *
- * Stack:
- *
- *  -> <message>?
- */
-export const maildq = (_: JSThread, f: Frame, __: Operand) => {
-    f.pushMessage();
-};
-
-/**
- * stop an actor in the system.
- *
- * The actor will be removed.
- *
- * Stack:
- *
- * <address> ->
- */
-export const stop = (r: JSThread, f: Frame, _: Operand) => {
-    let eaddr = f.popString();
-
-    if (eaddr.isLeft()) return r.raise(eaddr.takeLeft());
-
-    // r.watch(r.kill(eaddr.takeRight()));
-};