@quenk/potoo 4.0.7 → 4.0.11

package/lib/actor/framework/resident.ts

@@ -1,90 +0,0 @@
-import { Err } from '@quenk/noni/lib/control/error';
-
-import { Runtime } from '../system/vm/runtime';
-import { Address } from '../address';
-import { Spawnable } from '../template';
-import { Api } from '../api';
-import { Message, Actor } from '../';
-import { TypeCase } from '.';
-
-/**
- * Resident is an actor that exists in the current runtime.
- */
-export interface Resident extends Api, Actor {}
-
-/**
- * AbstractResident is a base implementation of a Resident actor.
- */
-export abstract class AbstractResident implements Resident {
-    constructor(public runtime: Runtime) {}
-
-    self = this.runtime.self;
-
-    async notify(msg: Message) {
-        await this.runtime.notify(msg);
-    }
-
-    spawn(target: Spawnable) {
-        return this.runtime.spawn(target);
-    }
-
-    async tell<M>(addr: Address, msg: M) {
-        await this.runtime.tell(addr, msg);
-    }
-
-    async raise(err: Err) {
-        await this.runtime.raise(err);
-    }
-
-    async kill(addr: Address) {
-        await this.runtime.kill(addr);
-    }
-
-    async exit() {
-        await this.runtime.kill(this.self);
-    }
-
-    async start() {
-        return this.run();
-    }
-
-    async run() {}
-
-    async stop() {}
-
-    async receive<T>(cases: TypeCase<T>[] = []) {
-        return this.runtime.receive(cases);
-    }
-
-    watch<T>(task: () => Promise<T>) {
-        return this.runtime.watch(task);
-    }
-}
-
-/**
- * Mutable actors can change their behaviour after message processing.
- */
-export abstract class Mutable extends AbstractResident {}
-
-/**
- * Immutable is an actor whose behaviour does not change when a message is
- * received.
- *
- * For each message received, the same set of TypeCase classes are applied.
- * This class is useful for simple request/response style actors that do
- * not require much complicated logic.
- */
-export abstract class Immutable<T> extends AbstractResident {
-    /**
-     * selectors provides the list of TypeCase classes that will be applied to
-     * all incoming messages.
-     */
-    selectors(): TypeCase<T>[] {
-        return [];
-    }
-
-    async start() {
-        await this.run();
-        while (this.runtime.isValid()) await this.receive(this.selectors());
-    }
-}

package/lib/actor/index.ts

@@ -1,35 +0,0 @@
-import { Type } from '@quenk/noni/lib/data/type';
-
-/**
- * Message is any (ideally wire-safe) value that can be sent between actors.
- */
-export type Message = Type;
-
-/**
- * Actor is the main interface implemented by actors that are part of the system.
- */
-export interface Actor {
-    /**
-     * start the Actor.
-     *
-     * At this point resources have been allocated within the system for the
-     * actor and it can begin sending messages.
-     */
-    start(): Promise<void>;
-
-    /**
-     * notify is called when a message is received from another actor.
-     *
-     * Some actors may process the message immediately, others may store it to
-     * a mailbox for later.
-     */
-    notify(m: Message): Promise<void>;
-
-    /**
-     * stop the Actor.
-     *
-     * A this point resources for the actor have been removed from the system
-     * and any additional clean up needed can be done.
-     */
-    stop(): Promise<void>;
-}

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

@@ -1,43 +0,0 @@
-import { Maybe } from '@quenk/noni/lib/data/maybe';
-
-import { Address } from '../../../address';
-import { Template } from '../../../template';
-import { Thread } from '../thread';
-
-/**
- * Allocator is the interface the VM delegates storage of actor threads and
- * associated information to.
- */
-export interface Allocator {
-    /**
-     * getThread provides a Thread given an Address.
-     */
-    getThread(target: Address): Maybe<Thread>;
-
-    /**
-     * getThreads provides a list of Threads given a list of Addresses.
-     */
-    getThreads(targets: Address[]): Thread[];
-
-    /**
-     * getTemplate provides a Template given an Address.
-     */
-    getTemplate(address: Address): Maybe<Template>;
-
-    /**
-     * allocate a new thread from a Template.
-     */
-    allocate(parent: Thread, tmpl: Template): Promise<Address>;
-
-    /**
-     * reallocate resources for a Thread.
-     *
-     * This essentially means the Thread has been restarted.
-     */
-    reallocate(target: Thread): Promise<void>;
-
-    /**
-     * deallocate resources for a Thread.
-     */
-    deallocate(target: Thread): Promise<void>;
-}

package/lib/actor/system/vm/allocator/map.ts

@@ -1,256 +0,0 @@
-import * as errors from '../runtime/error';
-
-import { Maybe } from '@quenk/noni/lib/data/maybe';
-import { Future } from '@quenk/noni/lib/control/monad/future';
-import { distribute, empty } from '@quenk/noni/lib/data/array';
-import { evaluate, Lazy } from '@quenk/noni/lib/data/lazy';
-
-import { Address, isRestricted, make } from '../../../address';
-import {
-    SharedCreateTemplate,
-    SharedRunTemplate,
-    Template
-} from '../../../template';
-import {
-    EVENT_ACTOR_ALLOCATED,
-    EVENT_ACTOR_DEALLOCATED,
-    EVENT_ACTOR_STARTED,
-    EVENT_ACTOR_STOPPED
-} from '../event';
-import { ThreadFactory } from '../thread/factory';
-import { JSThread } from '../thread/shared/js';
-import { Thread } from '../thread';
-import { Actor } from '../../..';
-import { VM } from '..';
-import { Allocator } from './';
-
-const MAX_THREAD_KILL_PER_CYCLE = 25;
-
-/**
- * ActorTableEntry is the bookkeeping record for exactly one actor within the
- * system.
- */
-export interface ActorTableEntry {
-    /**
-     * address for the actor.
-     */
-    address: Address;
-
-    /**
-     * parent is the entry for the parent actor.
-     *
-     * No parent indicates the root actor.
-     */
-    parent: Maybe<ActorTableEntry>;
-
-    /**
-     * template used to create the actor.
-     */
-    template: Template;
-
-    /**
-     * actor instance for the entry.
-     */
-    actor: Actor;
-
-    /**
-     * thread for the entry.
-     */
-    thread: Thread;
-
-    /**
-     * children entries for the actor.
-     */
-    children: ActorTableEntry[];
-}
-
-/**
- * MapAllocator stores actor information in a map structure where each
- * entry points to its parent and children.
- */
-export class MapAllocator implements Allocator {
-    constructor(
-        public platform: Lazy<VM>,
-        public actors = new Map(),
-        public nextAID = 1
-    ) {}
-
-    /**
-     * getEntry provides the entry for an actor given its thread.
-     */
-    getEntry(thread: Thread): Maybe<ActorTableEntry> {
-        for (let entry of this.actors.values()) {
-            if (entry.thread === thread) return Maybe.of(entry);
-        }
-
-        return Maybe.nothing();
-    }
-
-    getThread(address: Address): Maybe<Thread> {
-        for (let entry of this.actors.values()) {
-            if (entry.address === address) return Maybe.of(entry.thread);
-        }
-
-        return Maybe.nothing();
-    }
-
-    getThreads(targets: Address[]): Thread[] {
-        let hits = [];
-        for (let entry of this.actors.values()) {
-            if (targets.includes(entry.address)) hits.push(entry.thread);
-        }
-        return hits;
-    }
-
-    getTemplate(address: Address): Maybe<Template> {
-        return Maybe.fromNullable(this.actors.get(address)).map(
-            (entry: ActorTableEntry) => entry.template
-        );
-    }
-
-    async allocate(parent: Thread, template: Template): Promise<Address> {
-        let platform = evaluate(this.platform);
-
-        let isRoot = parent === platform;
-
-        let parentCons = 'vm';
-
-        let mparentEntry = Maybe.nothing<ActorTableEntry>();
-
-        if (!isRoot) {
-            mparentEntry = this.getEntry(parent);
-
-            if (mparentEntry.isNothing())
-                return Future.raise(new errors.InvalidThreadErr(parent));
-
-            parentCons = mparentEntry
-                .get()
-                .actor.constructor.name.toLowerCase();
-        }
-
-        let aid = this.nextAID++;
-
-        let id = template.id ?? `instance::${parentCons}::aid::${aid}`;
-
-        if (isRestricted(<string>id))
-            return Future.raise(new errors.InvalidIdErr(id));
-
-        let address = make(parent.address, id);
-
-        if (this.actors.has(address))
-            return Future.raise(new errors.DuplicateAddressErr(address));
-
-        let thread = ThreadFactory.create(platform, address, template);
-
-        let actor = (<SharedCreateTemplate>template).create
-            ? (<SharedCreateTemplate>template).create(<JSThread>thread)
-            : thread;
-
-        let entry = {
-            address,
-            parent: mparentEntry,
-            thread,
-            template,
-            actor: actor ?? thread,
-            children: []
-        };
-
-        this.actors.set(address, entry);
-
-        mparentEntry.map(parentEntry => parentEntry.children.push(entry));
-
-        if (template.group) platform.groups.enroll(address, template.group);
-
-        platform.events.dispatchActorEvent(EVENT_ACTOR_ALLOCATED, address);
-
-        platform.runTask(thread, async () => {
-            platform.events.dispatchActorEvent(
-                EVENT_ACTOR_STARTED,
-                thread.address
-            );
-
-            await actor.start();
-
-            if ((<SharedRunTemplate>template).run) {
-                await (<SharedRunTemplate>template).run(<JSThread>thread);
-                await this.deallocate(thread);
-            }
-        });
-
-        return address;
-    }
-
-    async reallocate(target: Thread): Promise<void> {
-        let mentry = this.getEntry(target);
-
-        //TODO: dispatch event and ignore?
-        if (mentry.isNothing())
-            return Future.raise(new errors.InvalidThreadErr(target));
-
-        let entry = mentry.get();
-
-        await this.deallocate(entry.thread);
-
-        let mparent = entry.parent;
-
-        // TODO: dispatch event and ignore instead?
-        if (mparent.isNothing())
-            return Future.raise(new errors.UnknownAddressErr(target.address));
-
-        await this.allocate(mparent.get().thread, entry.template);
-    }
-
-    async deallocate(target: Thread): Promise<void> {
-        let mentry = this.getEntry(target);
-
-        if (mentry.isNothing()) return; //TODO: dispatch event
-
-        let entry = mentry.get();
-
-        // Remove the subtree from the system.
-        entry.parent.map(parent => {
-            parent.children = parent.children.filter(child => child !== entry);
-        });
-
-        let targets = [entry];
-
-        let pending = entry.children.slice();
-
-        while (!empty(pending)) {
-            let target = <ActorTableEntry>pending.shift();
-
-            pending = [...pending, ...target.children];
-
-            targets.unshift(target);
-        }
-
-        let platform = evaluate(this.platform);
-
-        await Future.batch(
-            distribute(
-                targets.map(target =>
-                    Future.do(async () => {
-                        await target.actor.stop();
-
-                        await target.thread.stop();
-
-                        platform.events.dispatchActorEvent(
-                            EVENT_ACTOR_STOPPED,
-                            target.address
-                        );
-
-                        platform.groups.unenroll(target.address);
-
-                        this.actors.delete(target.address);
-
-                        platform.events.dispatchActorEvent(
-                            EVENT_ACTOR_DEALLOCATED,
-                            target.address
-                        );
-                    })
-                ),
-                MAX_THREAD_KILL_PER_CYCLE
-            )
-        );
-    }
-}

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

@@ -1,33 +0,0 @@
-import { LogSink } from './log';
-
-/**
- * PartialConf allows only some values to be specified in a Conf object
- * instead of all.
- */
-export interface PartialConf {
-    log?: Partial<Conf['log']>;
-}
-
-/**
- * Conf objects are used to create and configue various aspects of thhe VM.
- */
-export interface Conf {
-    /**
-     * log configures the logging system.
-     */
-    log: {
-        /**
-         * level sets the maximum log level that will be written.
-         *
-         * Defaults to info.
-         */
-        level: string;
-
-        /**
-         * sink is the destination logs will be written to.
-         *
-         * Defaults to the console object.
-         */
-        sink: LogSink;
-    };
-}

package/lib/actor/system/vm/event/dispatcher.ts

@@ -1,85 +0,0 @@
-import * as events from './';
-
-import { evaluate, Lazy } from '@quenk/noni/lib/data/lazy';
-
-import { LogWritable } from '../log/writer';
-import { Address } from '../../../address';
-import { Message } from '../../..';
-import { EventType, InternalEvent } from './';
-
-/**
- * Handler is the type of function that receives events.
- */
-export type Handler = (event: InternalEvent) => void;
-
-const eventMap = {
-    message: new Map([
-        [events.EVENT_MESSAGE_BOUNCE, events.MessageBounceEvent],
-        [events.EVENT_MESSGAE_SEND, events.MessageSendEvent]
-    ]),
-    actor: new Map([
-        [events.EVENT_ACTOR_ALLOCATED, events.ActorAllocatedEvent],
-        [events.EVENT_ACTOR_STARTED, events.ActorStartedEvent],
-        [events.EVENT_ACTOR_STOPPED, events.ActorStoppedEvent],
-        [events.EVENT_ACTOR_DEALLOCATED, events.ActorDeallocatedEvent]
-    ])
-};
-
-/**
- * EventDispatcher is an interface used by the internal VM components to
- * broadcast interesting events when they occur.
- *
- * This interface is not meant to be used for business logic in an application
- * but rather provides a way to inspect and troubleshoot the VM.  Event dispatch
- * is centralized here to make it clearer what events the system emits.
- *
- * This will also make it easier to disable some events when needed in the
- * future.
- *
- * @typeparam E type of event the dispatcher dispatches.
- */
-export class EventDispatcher {
-    constructor(
-        public log: Lazy<LogWritable>,
-        public handlers: Map<EventType, Handler[]> = new Map()
-    ) {}
-
-    /**
-     * addListener to the EventDispatcher.
-     */
-    addEventListener(type: EventType, handler: Handler) {
-        let handlers = this.handlers.get(type) || [];
-        handlers.push(handler);
-        this.handlers.set(type, handlers);
-    }
-
-    /**
-     * dispatchMessageEvent dispatches events related to message sending.
-     */
-    dispatchMessageEvent(
-        type: EventType,
-        from: Address,
-        to: Address,
-        message: Message
-    ) {
-        let Cons = eventMap.message.get(type);
-        if (Cons) this.dispatch(new Cons(from, to, message));
-    }
-
-    /**
-     * dispatchActorEvent dispatches events related to actor lifecycle.
-     */
-    dispatchActorEvent(type: EventType, actor: Address) {
-        let Cons = eventMap.actor.get(type);
-        if (Cons) this.dispatch(new Cons(actor));
-    }
-
-    /**
-     * dispatch is a generic function that when called will create and dispatch
-     * the event the EventDispatcher is responsible for.
-     */
-    dispatch(event: events.InternalEvent) {
-        evaluate(this.log).writeEvent(event);
-        for (let handler of this.handlers.get(event.type) || []) handler(event);
-    }
-}

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

@@ -1,143 +0,0 @@
-import { Address } from '../../../address';
-import { Message } from '../../..';
-import { LogLevelValue } from '../log';
-
-export const EVENT_MESSGAE_SEND = 'message-send';
-export const EVENT_MESSAGE_BOUNCE = 'message-bounce';
-export const EVENT_MESSAGE_DROPPED = 'message-dropped';
-export const EVENT_ACTOR_ALLOCATED = 'actor-allocated';
-export const EVENT_ACTOR_STARTED = 'actor-started';
-export const EVENT_ACTOR_STOPPED = 'actor-stopped';
-export const EVENT_ACTOR_DEALLOCATED = 'actor-deallocated';
-export const EVENT_ACTOR_RECEIVE = 'actor-receive';
-
-/**
- * EventType identifying an event that occurred.
- */
-export type EventType = string;
-
-/**
- * InternalEvent is the base class for all potoo events.
- */
-export interface InternalEvent {
-    /**
-     * type of event.
-     */
-    type: EventType;
-
-    /**
-     * level of the event.
-     *
-     * Used by the log writer to determine when to write the event.
-     */
-    level: LogLevelValue;
-
-    /**
-     * source of the event.
-     *
-     * All events are associated with either an actor or the system itself.
-     */
-    source: Address;
-}
-
-/**
- * VMEvent is the parent of all events that occur in the VM.
- */
-export abstract class VMEvent implements InternalEvent {
-    abstract type: EventType;
-
-    abstract level: LogLevelValue;
-
-    constructor(public source: Address) {}
-}
-
-/**
- * MessageEvent is the parent of events related to message sending.
- */
-export abstract class MessageEvent extends VMEvent {
-    constructor(
-        public from: Address,
-        public to: Address,
-        public message: Message
-    ) {
-        super(from);
-    }
-}
-
-/**
- * MessageSendEvent is triggered when an actor delivers a message to another
- * actor's thread.
- */
-export class MessageSendEvent extends MessageEvent {
-    type = EVENT_MESSGAE_SEND;
-
-    level = LogLevelValue.info;
-}
-
-/**
- * MessageBounceEvent is triggered when an actor attempts to deliver a message
- * to a thread that no longer exists.
- */
-export class MessageBounceEvent extends MessageEvent {
-    type = EVENT_MESSAGE_BOUNCE;
-
-    level = LogLevelValue.warn;
-}
-
-/**
- * MessageDropEvent is triggered when an actor refuses to process a message it
- * received.
- */
-export class MessageDropEvent extends MessageEvent {
-    type = EVENT_MESSAGE_DROPPED;
-
-    level = LogLevelValue.warn;
-}
-
-/**
- * ActorEvent are events related toe the lifecycle of an actor.
- */
-export abstract class ActorEvent extends VMEvent {
-    level = LogLevelValue.info;
-
-    constructor(public address: Address) {
-        super(address);
-    }
-}
-
-/**
- * ActorAllocatedEvent is triggered when an actor is allocated in the system.
- */
-export class ActorAllocatedEvent extends ActorEvent {
-    type = EVENT_ACTOR_ALLOCATED;
-}
-
-/**
- * ActorStartedEvent is triggered when an actor is about to be started by
- * the system.
- */
-export class ActorStartedEvent extends ActorEvent {
-    type = EVENT_ACTOR_STARTED;
-}
-
-/**
- * ActorStoppedEvent is triggered when an actor is stopped by the system.
- */
-export class ActorStoppedEvent extends ActorEvent {
-    type = EVENT_ACTOR_STOPPED;
-}
-
-/**
- * ActorDeallocatedEvent is triggered when an actor is deallocated from the
- * system.
- */
-export class ActorDeallocatedEvent extends ActorEvent {
-    type = EVENT_ACTOR_DEALLOCATED;
-}
-
-/**
- * ActorReceiveEvent is triggered when an actor attempts to receive a message.
- */
-export class ActorReceiveEvent extends ActorEvent {
-    type = EVENT_ACTOR_RECEIVE;
-}