lib: make diagnostics_channel async iterable

lib/diagnostics_channel.js

@@ -3,10 +3,14 @@
 const {
  ArrayPrototypeIndexOf,
  ArrayPrototypePush,
+ ArrayPrototypeShift,
  ArrayPrototypeSplice,
  ObjectCreate,
  ObjectGetPrototypeOf,
  ObjectSetPrototypeOf,
+ Promise,
+ PromiseResolve,
+ SymbolAsyncIterator,
  SymbolHasInstance,
  WeakRefPrototypeGet
 } = primordials;
@@ -21,8 +25,72 @@ const { triggerUncaughtException } = internalBinding('errors');
 
 const { WeakReference } = internalBinding('util');
 
+class AsyncIterableChannel {
+ constructor(channel) {
+ this.channel = channel;
+ this.events = [];
+ this.waiting = [];
+
+ this.subscriber = (message) => {
+ const resolve = ArrayPrototypeShift(this.waiting);
+ if (resolve) {
+ return resolve({
+ value: message,
+ done: false
+ });
+ }
+
+ ArrayPrototypePush(this.events, message);
+ };
+
+ channel.subscribe(this.subscriber);
+ }
+
+ [SymbolAsyncIterator]() {
+ return this;
+ }
+
+ return() {
+ const data = { done: true };
+ this.done = true;
+
+ this.channel.unsubscribe(this.subscriber);
+
+ for (let i = 0; i < this.waiting.length; i++) {
+ const resolve = this.waiting[i];
+ resolve(data);
+ }
+
+ return PromiseResolve(data);
+ }
+
+ next() {
+ const event = ArrayPrototypeShift(this.events);
+ if (event) {
+ return PromiseResolve({
+ value: event,
+ done: false
+ });
+ }
+
+ if (this.done) {
+ return PromiseResolve({
+ done: true
+ });
+ }
+
+ return new Promise((resolve) => {
+ ArrayPrototypePush(this.waiting, resolve);
+ });
+ }
+}
+
 // TODO(qard): should there be a C++ channel interface?
 class ActiveChannel {
+ [SymbolAsyncIterator]() {
+ return new AsyncIterableChannel(this);
+ }
+
  subscribe(subscription) {
  if (typeof subscription !== 'function') {
  throw new ERR_INVALID_ARG_TYPE('subscription', ['function'],
@@ -71,7 +139,11 @@ class Channel {
  static [SymbolHasInstance](instance) {
  const prototype = ObjectGetPrototypeOf(instance);
  return prototype === Channel.prototype ||
- prototype === ActiveChannel.prototype;
+ prototype === ActiveChannel.prototype;
+ }
+
+ [SymbolAsyncIterator]() {
+ return new AsyncIterableChannel(this);
  }
 
  subscribe(subscription) {

test/parallel/test-diagnostics-channel-async-iterable.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+const assert = require('assert');
+
+const input = {
+ foo: 'bar'
+};
+
+const channel = dc.channel('test');
+
+const done = common.mustCall();
+
+async function main() {
+ for await (const message of channel) {
+ assert.strictEqual(channel.hasSubscribers, true);
+ assert.strictEqual(message, input);
+ break;
+ }
+
+ // Make sure the subscription is cleaned up when breaking the loop!
+ assert.strictEqual(channel.hasSubscribers, false);
+ done();
+}
+
+main();
+
+setTimeout(common.mustCall(() => {
+ channel.publish(input);
+}), 1);