Class: GenServer

Analogous to cast, but makes the cast to the GenServer with name id on each node in nodes.

Makes a synchronous request against id with event event and event args data. If id is an object, it will be parsed into a GenServer id and a receiving node. If a callback is supplied, the response will be aggregated and returned on success as cb(null, res) or on error as cb(err). In either case, the response stream is returned, which can be used to pipe to other streams.

Makes an asynchronous request against id with event event and event args data. If id is an object, it will be parsed into a GenServer id and a receiving node.

Parses a fully memoized message stream into an object containing a key/value pair. If we fail to parse the job buffer (invalid JSON, etc), we just return an error and this GenServer will skip emitting an event. Otherwise, triggers user-defined logic for the parsed event.

Parses a message singleton into an object containing a key/value pair. If we fail to parse the job, we just return an error and this GenServer will skip emitting an event. Otherwise, triggers user-defined logic for the parsed event.

Acts as a getter/setter for the ID of this instance.

Returns whether this handler is in an idle state or not.

Acts as a getter/setter for the netkernel of this instance.

Analogous to call, but makes the call to the GenServer with name id on each node in nodes.

Pauses the GenServer's message processing. As a result, any messages routed from the network kernel to this GenServer will be missed until this.resume() is called.

Replies to the sending node for an event stream. Used when a triggered event contains synchronous logic, in which we need to respond to the calling node of this event.

Resumes the processing of message streams on this GenServer. Any messages missed in between pausing and now will result in failed message parsing (since all JSON contents are sent in one message).

Starts this GenServer. Use this to start processing messages. As a result of this function call, any message with an id equal to this server's id (or name, if provided) will be routed by the network kernel to this server. If called multiple times in a row, this function will throw, since name uniqueness is enforced by the network kernel. If no name is provided, the generated short id at construction-time will be used as the routing name.

Stops the processing of messages on this GenServer. As a result, any further messages sent to the network kernel will fail to route to this GenServer. Additionally, all current message streams will be discarded, and the current name will be regenerated to another short id.

Acts as a getter/setter for the internal message stream map of this instance.

Emitted when the number of active messages streams on this server is zero (or, if extending the GenServer class, when this.idle() returns true).

Emitted when the server has paused. On 'pause', if the server is started with name name, the network kernel will remove this server's event handler for name.

Emitted when the server has been resumed. Before 'resume' is emitted, the network kernel restarts the server's event handler for name, where name is the name of the server.

Emitted when the server has completely stopped executing handler logic on any user-defined events it's listening for.

Events defined by users for message handling.

Suppose we have a GenServer named server started with name name_goes_here. Any message stream routed to our node, both internal and external, with id set to name_goes_here will be gathered by serve into a map of streams. Each stream has a stream ID stream and a boolean flag done which indicates whether the stream has finished sending data. This stream ID is used as an index for stream memoization between concurrent requests.

// 'data' is the input data for this part of the stream
if (!this._streams.has(stream.stream)) {
  this._streams.set(stream.stream, {data: Buffer.from(""), ...});
}
let inner = this._streams.get(stream.stream);
inner.data = Buffer.concat([inner.data, data], ...);

Once sending has finished, the job is parsed using decodeJob into an event and message, under event and data respectively. From here, the server emits an event just like an EventEmitter with event and data.

// similar to this
if (stream.done === true) {
  let job = this.decodeJob(memo);
  serve.emit(job.event, job.data, from);
}

This is where our own event handling logic comes into play. Everything else is handled under the hood by this class.

Diagram of data flow for message streams:

Messages comes into node with id set to `name_goes_here` ---------------> this._parse
Message comes into node with `stream.done` set to true -----------------> this.decodeJob ---> this.emit(event, data,from) ---> this.on(event, handlerLogic...)

As for singleton message streams (a message stream with only one message, and done set to true), no memoization of streams into a stream map occurs. The data is parsed by decodeSingleton into an event and message, under event and data respectively. From here, the server emits an event just like an EventEmitter with event and data.

Diagram of data flow for message singletons:

Messages comes into node with id set to `name_goes_here` ---------------> this._parse ---> this.decodeSingleton ---> this.emit(event, data,from) ---> this.on(event, handlerLogic...)