@hotmeshio/hotmesh 0.4.0 → 0.4.1

package/build/services/task/index.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskService = void 0;
+const enums_1 = require("../../modules/enums");
+const utils_1 = require("../../modules/utils");
+const pipe_1 = require("../pipe");
+const hotmesh_1 = require("../../types/hotmesh");
+const key_1 = require("../../modules/key");
+class TaskService {
+    constructor(store, logger) {
+        this.cleanupTimeout = null;
+        this.isScout = false;
+        this.errorCount = 0;
+        this.logger = logger;
+        this.store = store;
+    }
+    async processWebHooks(hookEventCallback) {
+        const workItemKey = await this.store.getActiveTaskQueue();
+        if (workItemKey) {
+            const [topic, sourceKey, scrub, ...sdata] = workItemKey.split(key_1.WEBSEP);
+            const data = JSON.parse(sdata.join(key_1.WEBSEP));
+            const destinationKey = `${sourceKey}:processed`;
+            const jobId = await this.store.processTaskQueue(sourceKey, destinationKey);
+            if (jobId) {
+                //todo: don't use 'id', make configurable using hook rule
+                await hookEventCallback(topic, { ...data, id: jobId });
+            }
+            else {
+                await this.store.deleteProcessedTaskQueue(workItemKey, sourceKey, destinationKey, scrub === 'true');
+            }
+            setImmediate(() => this.processWebHooks(hookEventCallback));
+        }
+    }
+    async enqueueWorkItems(keys) {
+        await this.store.addTaskQueues(keys);
+    }
+    async registerJobForCleanup(jobId, inSeconds = enums_1.HMSH_EXPIRE_DURATION, options) {
+        if (inSeconds > 0) {
+            await this.store.expireJob(jobId, inSeconds);
+            // const fromNow = Date.now() + inSeconds * 1000;
+            // const fidelityMS = HMSH_FIDELITY_SECONDS * 1000;
+            // const timeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
+            // await this.store.registerDependenciesForCleanup(jobId, timeSlot, options);
+        }
+    }
+    async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.HMSH_FIDELITY_SECONDS, dad, transaction) {
+        const fromNow = Date.now() + inSeconds * 1000;
+        const fidelityMS = enums_1.HMSH_FIDELITY_SECONDS * 1000;
+        const awakenTimeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
+        await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, dad, transaction);
+    }
+    /**
+     * Should this engine instance play the role of 'scout' on behalf
+     * of the entire quorum? The scout role is responsible for processing
+     * task lists on behalf of the collective.
+     */
+    async shouldScout() {
+        const wasScout = this.isScout;
+        const isScout = wasScout || (this.isScout = await this.store.reserveScoutRole('time'));
+        if (isScout) {
+            if (!wasScout) {
+                setTimeout(() => {
+                    this.isScout = false;
+                }, enums_1.HMSH_SCOUT_INTERVAL_SECONDS * 1000);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Callback handler that takes an item from a work list and
+     * processes according to its type
+     */
+    async processTimeHooks(timeEventCallback, listKey) {
+        if (await this.shouldScout()) {
+            try {
+                const workListTask = await this.store.getNextTask(listKey);
+                if (Array.isArray(workListTask)) {
+                    const [listKey, target, gId, activityId, type] = workListTask;
+                    if (type === 'child') {
+                        //continue; this child is listed here for convenience, but
+                        //  will be expired by an origin ancestor and is listed there
+                    }
+                    else if (type === 'delist') {
+                        //delist the signalKey (target)
+                        const key = this.store.mintKey(hotmesh_1.KeyType.SIGNALS, {
+                            appId: this.store.appId,
+                        });
+                        await this.store.delistSignalKey(key, target);
+                    }
+                    else {
+                        //awaken/expire/interrupt
+                        await timeEventCallback(target, gId, activityId, type);
+                    }
+                    await (0, utils_1.sleepFor)(0);
+                    this.errorCount = 0;
+                    this.processTimeHooks(timeEventCallback, listKey);
+                }
+                else if (workListTask) {
+                    //a worklist was just emptied; try again immediately
+                    await (0, utils_1.sleepFor)(0);
+                    this.errorCount = 0;
+                    this.processTimeHooks(timeEventCallback);
+                }
+                else {
+                    //no worklists exist; sleep before checking
+                    const sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_FIDELITY_SECONDS * 1000);
+                    this.cleanupTimeout = sleep.timerId;
+                    await sleep.promise;
+                    this.errorCount = 0;
+                    this.processTimeHooks(timeEventCallback);
+                }
+            }
+            catch (err) {
+                //most common reasons: deleted job not found; container stopping; test stopping
+                //less common: redis/cluster down; retry with fallback (5s max main reassignment)
+                this.logger.warn('task-process-timehooks-error', err);
+                await (0, utils_1.sleepFor)(1000 * this.errorCount++);
+                if (this.errorCount < 5) {
+                    this.processTimeHooks(timeEventCallback);
+                }
+            }
+        }
+        else {
+            //didn't get the scout role; try again in 'one-ish' minutes
+            const sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_SCOUT_INTERVAL_SECONDS * 1000 * 2 * Math.random());
+            this.cleanupTimeout = sleep.timerId;
+            await sleep.promise;
+            this.processTimeHooks(timeEventCallback);
+        }
+    }
+    cancelCleanup() {
+        if (this.cleanupTimeout !== undefined) {
+            clearTimeout(this.cleanupTimeout);
+            this.cleanupTimeout = undefined;
+        }
+    }
+    async getHookRule(topic) {
+        const rules = await this.store.getHookRules();
+        return rules?.[topic]?.[0];
+    }
+    async registerWebHook(topic, context, dad, expire, transaction) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            const mapExpression = hookRule.conditions.match[0].expected;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const jobId = context.metadata.jid;
+            const gId = context.metadata.gid;
+            const activityId = hookRule.to;
+            //composite keys are used to fully describe the task target
+            const compositeJobKey = [activityId, dad, gId, jobId].join(key_1.WEBSEP);
+            const hook = {
+                topic,
+                resolved,
+                jobId: compositeJobKey,
+                expire,
+            };
+            await this.store.setHookSignal(hook, transaction);
+            return jobId;
+        }
+        else {
+            throw new Error('signaler.registerWebHook:error: hook rule not found');
+        }
+    }
+    async processWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const hookSignalId = await this.store.getHookSignal(topic, resolved);
+            if (!hookSignalId) {
+                //messages can be double-processed; not an issue; return `undefined`
+                //users can also provide a bogus topic; not an issue; return `undefined`
+                return undefined;
+            }
+            //`aid` is part of composite key, but the hook `topic` is its public interface;
+            // this means that a new version of the graph can be deployed and the
+            // topic can be re-mapped to a different activity id. Outside callers
+            // can adhere to the unchanged contract (calling the same topic),
+            // while the internal system can be updated in real-time as necessary.
+            const [_aid, dad, gid, ...jid] = hookSignalId.split(key_1.WEBSEP);
+            return [jid.join(key_1.WEBSEP), hookRule.to, dad, gid];
+        }
+        else {
+            throw new Error('signal-not-found');
+        }
+    }
+    async deleteWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            return await this.store.deleteHookSignal(topic, resolved);
+        }
+        else {
+            throw new Error('signaler.process:error: hook rule not found');
+        }
+    }
+}
+exports.TaskService = TaskService;

package/build/services/telemetry/index.d.ts

@@ -0,0 +1,52 @@
+import { ActivityMetadata, ActivityType, Consumes } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { StringAnyType, StringScalarType, StringStringType } from '../../types/serializer';
+import { StreamData, StreamRole } from '../../types/stream';
+import { Span, Context } from '../../types/telemetry';
+declare class TelemetryService {
+    span: Span;
+    jobSpan: Span;
+    config: ActivityType;
+    traceId: string | null;
+    spanId: string | null;
+    appId: string;
+    metadata: ActivityMetadata;
+    context: JobState;
+    leg: number;
+    constructor(appId: string, config?: ActivityType, metadata?: ActivityMetadata, context?: JobState);
+    /**
+     * too chatty for production; only output traces, jobs, triggers and workers
+     */
+    private shouldCreateSpan;
+    private static createNoopSpan;
+    getJobParentSpanId(): string | undefined;
+    getActivityParentSpanId(leg: number): string | undefined;
+    getTraceId(): string | undefined;
+    startJobSpan(): TelemetryService;
+    /**
+     * Traces an activity.
+     * @private
+     */
+    static traceActivity(appId: string, attributes: StringScalarType, activityId: string, traceId: string, spanId: string, index?: number): Promise<boolean>;
+    startActivitySpan(leg?: number): TelemetryService;
+    startStreamSpan(data: StreamData, role: StreamRole): TelemetryService;
+    startSpan(traceId: string, spanId: string, spanName: string, attributes: StringScalarType, bCreate?: boolean): Span;
+    mapActivityAttributes(): void;
+    setActivityAttributes(attributes: StringScalarType): void;
+    setStreamAttributes(attributes: StringScalarType): void;
+    setJobAttributes(attributes: StringScalarType): void;
+    endJobSpan(): void;
+    endActivitySpan(): void;
+    endStreamSpan(): void;
+    endSpan(span: Span): void;
+    getParentSpanContext(): undefined | Context;
+    getSpanAttrs(leg: number): StringAnyType;
+    getStreamSpanAttrs(input: StreamData): StringAnyType;
+    setTelemetryContext(span: Span, leg: number): void;
+    setActivityError(message: string): void;
+    setStreamError(message: string): void;
+    static addTargetTelemetryPaths(consumes: Consumes, config: ActivityType, metadata: ActivityMetadata, leg: number): void;
+    static bindJobTelemetryToState(state: StringStringType, config: ActivityType, context: JobState): void;
+    static bindActivityTelemetryToState(state: StringAnyType, config: ActivityType, metadata: ActivityMetadata, context: JobState, leg: number): void;
+}
+export { TelemetryService };

package/build/services/telemetry/index.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryService = void 0;
+const package_json_1 = __importDefault(require("../../package.json"));
+const mapper_1 = require("../mapper");
+const stream_1 = require("../../types/stream");
+const telemetry_1 = require("../../types/telemetry");
+const enums_1 = require("../../modules/enums");
+class TelemetryService {
+    constructor(appId, config, metadata, context) {
+        this.leg = 1;
+        this.appId = appId;
+        this.config = config;
+        this.metadata = metadata;
+        this.context = context;
+    }
+    /**
+     * too chatty for production; only output traces, jobs, triggers and workers
+     */
+    shouldCreateSpan() {
+        return (enums_1.HMSH_TELEMETRY === 'debug' ||
+            this.config?.type === 'trigger' ||
+            this.config?.type === 'worker');
+    }
+    static createNoopSpan(traceId, spanId) {
+        // A no-op span that returns the given spanContext and ignores all operations.
+        return {
+            spanContext() {
+                return {
+                    traceId,
+                    spanId,
+                    isRemote: true,
+                    traceFlags: 1,
+                };
+            },
+            addEvent(_name, _attributesOrStartTime, _startTime) {
+                return this;
+            },
+            setAttribute(_key, _value) {
+                return this;
+            },
+            setAttributes(_attributes) {
+                return this;
+            },
+            setStatus(_status) {
+                return this;
+            },
+            updateName(_name) {
+                return this;
+            },
+            end(_endTime) {
+                // no-op
+            },
+            isRecording() {
+                return false;
+            },
+            recordException(_exception, _time) {
+                // no-op
+            },
+        };
+    }
+    getJobParentSpanId() {
+        return this.context.metadata.spn;
+    }
+    getActivityParentSpanId(leg) {
+        if (leg === 1) {
+            return this.context[this.config.parent].output?.metadata?.l2s;
+        }
+        else {
+            return this.context['$self'].output?.metadata?.l1s;
+        }
+    }
+    getTraceId() {
+        return this.context.metadata.trc;
+    }
+    startJobSpan() {
+        const spanName = `JOB/${this.appId}/${this.config.subscribes}/1`;
+        const traceId = this.getTraceId();
+        const spanId = this.getJobParentSpanId();
+        const attributes = this.getSpanAttrs(1);
+        const span = this.startSpan(traceId, spanId, spanName, attributes);
+        this.jobSpan = span;
+        this.setTelemetryContext(span, 1);
+        return this;
+    }
+    /**
+     * Traces an activity.
+     * @private
+     */
+    static async traceActivity(appId, attributes, activityId, traceId, spanId, index = 0) {
+        const spanName = `TRACE/${appId}/${activityId}/${index}`;
+        const tracer = telemetry_1.trace.getTracer(package_json_1.default.name, package_json_1.default.version);
+        const restoredSpanContext = {
+            traceId,
+            spanId,
+            isRemote: true,
+            traceFlags: 1,
+        };
+        const parentContext = telemetry_1.trace.setSpanContext(telemetry_1.context.active(), restoredSpanContext);
+        return telemetry_1.context.with(parentContext, () => {
+            const span = tracer.startSpan(spanName, {
+                kind: telemetry_1.SpanKind.CLIENT,
+                attributes,
+            });
+            span.setAttributes(attributes);
+            span.end();
+            return true;
+        });
+    }
+    startActivitySpan(leg = this.leg) {
+        const spanName = `${this.config.type.toUpperCase()}/${this.appId}/${this.metadata.aid}/${leg}`;
+        const traceId = this.getTraceId();
+        const spanId = this.getActivityParentSpanId(leg);
+        const attributes = this.getSpanAttrs(leg);
+        const span = this.startSpan(traceId, spanId, spanName, attributes);
+        this.span = span;
+        this.setTelemetryContext(span, leg);
+        return this;
+    }
+    startStreamSpan(data, role) {
+        let type;
+        if (role === stream_1.StreamRole.SYSTEM) {
+            type = 'SYSTEM';
+        }
+        else if (role === stream_1.StreamRole.WORKER) {
+            type = 'EXECUTE';
+        }
+        else if (data.type === stream_1.StreamDataType.RESULT ||
+            data.type === stream_1.StreamDataType.RESPONSE) {
+            type = 'FANIN'; //re-entering engine router (from worker router)
+        }
+        else {
+            type = 'FANOUT'; //exiting engine router (to worker router)
+        }
+        // `EXECUTE` refers to the 'worker router' NOT the 'worker activity' run by the 'engine router'
+        // (Regardless, it's worker-related, so it matters and will be traced)
+        // `SYSTEM` refers to catastrophic errors, which are always traced
+        if (this.shouldCreateSpan() || type === 'EXECUTE' || type === 'SYSTEM') {
+            const topic = data.metadata.topic ? `/${data.metadata.topic}` : '';
+            const spanName = `${type}/${this.appId}/${data.metadata.aid}${topic}`;
+            const attributes = this.getStreamSpanAttrs(data);
+            this.span = this.startSpan(data.metadata.trc, data.metadata.spn, spanName, attributes, true);
+        }
+        else {
+            this.traceId = data.metadata.trc;
+            this.spanId = data.metadata.spn;
+            this.span = TelemetryService.createNoopSpan(data.metadata.trc, data.metadata.spn);
+        }
+        return this;
+    }
+    startSpan(traceId, spanId, spanName, attributes, bCreate = false) {
+        this.traceId = traceId;
+        this.spanId = spanId;
+        if (bCreate || this.shouldCreateSpan()) {
+            const tracer = telemetry_1.trace.getTracer(package_json_1.default.name, package_json_1.default.version);
+            const parentContext = this.getParentSpanContext();
+            const span = tracer.startSpan(spanName, { kind: telemetry_1.SpanKind.CLIENT, attributes, root: !parentContext }, parentContext);
+            return span;
+        }
+        return TelemetryService.createNoopSpan(traceId, spanId);
+    }
+    mapActivityAttributes() {
+        if (this.config.telemetry && this.span) {
+            const telemetryAtts = new mapper_1.MapperService(this.config.telemetry, this.context).mapRules();
+            const namespacedAtts = {
+                ...Object.keys(telemetryAtts).reduce((result, key) => {
+                    if (['string', 'boolean', 'number'].includes(typeof telemetryAtts[key])) {
+                        result[`app.activity.data.${key}`] = telemetryAtts[key];
+                    }
+                    return result;
+                }, {}),
+            };
+            this.span.setAttributes(namespacedAtts);
+        }
+    }
+    setActivityAttributes(attributes) {
+        this.span?.setAttributes(attributes);
+    }
+    setStreamAttributes(attributes) {
+        this.span?.setAttributes(attributes);
+    }
+    setJobAttributes(attributes) {
+        this.jobSpan?.setAttributes(attributes);
+    }
+    endJobSpan() {
+        this.endSpan(this.jobSpan);
+    }
+    endActivitySpan() {
+        this.endSpan(this.span);
+    }
+    endStreamSpan() {
+        this.endSpan(this.span);
+    }
+    endSpan(span) {
+        // For a no-op span, end() does nothing anyway
+        span && span.end();
+    }
+    getParentSpanContext() {
+        if (this.traceId && this.spanId) {
+            const restoredSpanContext = {
+                traceId: this.traceId,
+                spanId: this.spanId,
+                isRemote: true,
+                traceFlags: 1,
+            };
+            const parentContext = telemetry_1.trace.setSpanContext(telemetry_1.context.active(), restoredSpanContext);
+            return parentContext;
+        }
+    }
+    getSpanAttrs(leg) {
+        return {
+            ...Object.keys(this.context.metadata).reduce((result, key) => {
+                if (key !== 'trc') {
+                    result[`app.job.${key}`] = this.context.metadata[key];
+                }
+                return result;
+            }, {}),
+            ...Object.keys(this.metadata).reduce((result, key) => {
+                result[`app.activity.${key}`] = this.metadata[key];
+                return result;
+            }, {}),
+            'app.activity.leg': leg,
+        };
+    }
+    getStreamSpanAttrs(input) {
+        return {
+            ...Object.keys(input.metadata).reduce((result, key) => {
+                if (key !== 'trc' && key !== 'spn') {
+                    result[`app.stream.${key}`] = input.metadata[key];
+                }
+                return result;
+            }, {}),
+        };
+    }
+    setTelemetryContext(span, leg) {
+        // Even if span is no-op, we still set context so that callers remain unaware
+        if (!this.context.metadata.trc) {
+            this.context.metadata.trc = span.spanContext().traceId;
+        }
+        if (!this.context['$self'].output.metadata) {
+            this.context['$self'].output.metadata = {};
+        }
+        // Echo the parent's or the newly created span's spanId
+        // This ensures the caller sees a consistent chain
+        if (leg === 1) {
+            this.context['$self'].output.metadata.l1s = span.spanContext().spanId;
+        }
+        else {
+            this.context['$self'].output.metadata.l2s = span.spanContext().spanId;
+        }
+    }
+    setActivityError(message) {
+        this.span?.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
+    }
+    setStreamError(message) {
+        this.span?.setStatus({ code: telemetry_1.SpanStatusCode.ERROR, message });
+    }
+    static addTargetTelemetryPaths(consumes, config, metadata, leg) {
+        if (leg === 1) {
+            if (!(config.parent in consumes)) {
+                consumes[config.parent] = [];
+            }
+            consumes[config.parent].push(`${config.parent}/output/metadata/l2s`);
+        }
+        else {
+            if (!(metadata.aid in consumes)) {
+                consumes[metadata.aid] = [];
+            }
+            consumes[metadata.aid].push(`${metadata.aid}/output/metadata/l1s`);
+        }
+    }
+    static bindJobTelemetryToState(state, config, context) {
+        if (config.type === 'trigger') {
+            state['metadata/trc'] = context.metadata.trc;
+        }
+    }
+    static bindActivityTelemetryToState(state, config, metadata, context, leg) {
+        if (config.type === 'trigger') {
+            state[`${metadata.aid}/output/metadata/l1s`] =
+                context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] =
+                context['$self'].output.metadata.l2s;
+        }
+        else if (config.type === 'hook' && leg === 1) {
+            state[`${metadata.aid}/output/metadata/l1s`] =
+                context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] =
+                context['$self'].output.metadata.l1s;
+        }
+        else if (config.type === 'signal' && leg === 1) {
+            state[`${metadata.aid}/output/metadata/l1s`] =
+                context['$self'].output.metadata.l1s;
+            state[`${metadata.aid}/output/metadata/l2s`] =
+                context['$self'].output.metadata.l1s;
+        }
+        else {
+            const target = `l${leg}s`;
+            state[`${metadata.aid}/output/metadata/${target}`] =
+                context['$self'].output.metadata[target];
+        }
+    }
+}
+exports.TelemetryService = TelemetryService;

package/build/services/worker/index.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import { ILogger } from '../logger';
+import { Router } from '../router';
+import { StoreService } from '../store';
+import { StreamService } from '../stream';
+import { SubService } from '../sub';
+import { HotMeshConfig, HotMeshWorker } from '../../types/hotmesh';
+import { ProviderClient, ProviderTransaction } from '../../types/provider';
+import { RollCallMessage, SubscriptionCallback } from '../../types/quorum';
+import { StreamData, StreamDataResponse } from '../../types/stream';
+declare class WorkerService {
+    namespace: string;
+    appId: string;
+    guid: string;
+    topic: string;
+    config: HotMeshConfig;
+    callback: (streamData: StreamData) => Promise<StreamDataResponse | void>;
+    store: StoreService<ProviderClient, ProviderTransaction> | null;
+    stream: StreamService<ProviderClient, ProviderTransaction> | null;
+    subscribe: SubService<ProviderClient> | null;
+    router: Router<typeof this.stream> | null;
+    logger: ILogger;
+    reporting: boolean;
+    inited: string;
+    rollCallInterval: NodeJS.Timeout;
+    /**
+     * @private
+     */
+    constructor();
+    /**
+     * @private
+     */
+    static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, logger: ILogger): Promise<WorkerService[]>;
+    /**
+     * @private
+     */
+    verifyWorkerFields(worker: HotMeshWorker): void;
+    /**
+     * @private
+     */
+    initStoreChannel(service: WorkerService, store: ProviderClient): Promise<void>;
+    /**
+     * @private
+     */
+    initSubChannel(service: WorkerService, sub: ProviderClient, store: ProviderClient): Promise<void>;
+    /**
+     * @private
+     */
+    initStreamChannel(service: WorkerService, stream: ProviderClient, store: ProviderClient): Promise<void>;
+    /**
+     * @private
+     */
+    initRouter(worker: HotMeshWorker, logger: ILogger): Promise<Router<StreamService<ProviderClient, ProviderTransaction>>>;
+    /**
+     * @private
+     */
+    subscriptionHandler(): SubscriptionCallback;
+    /**
+     * A quorum-wide command to broadcaset system details.
+     *
+     */
+    doRollCall(message: RollCallMessage): Promise<void>;
+    cancelRollCall(): void;
+    /**
+     * @private
+     */
+    stop(): void;
+    /**
+     * @private
+     */
+    sayPong(appId: string, guid: string, originator?: string, details?: boolean, signature?: boolean): Promise<void>;
+    /**
+     * @private
+     */
+    throttle(delayInMillis: number): Promise<void>;
+}
+export { WorkerService };