channelgroup: use qualifier options

Previously we relied on a new BaseRealtime instance with it's own
Channels object to separate usage of channels in the ChannelGroup from
independent external usage of those channels from the regular
client.channels.get() method. This led to various problems with shared
Auth state such as nonces in token requests which caused connections to
terminate and tests to fail.

A simpler solution is to avoid creating a new client instance and
instead share the Channel pool, but force the library to treat channels
used from the ChannelGroup independently (with their own attachment) by
setting dummy options in the qualifier, which is used as the key in the
channel map.

This implementation does not support channels in the channel group which
already have a qualifier. This is acceptable for the experimental
client-side simulation of the feature.

Author: mschristensen

src/common/lib/client/baserealtime.ts

@@ -36,14 +36,8 @@ class BaseRealtime extends BaseClient {
     this._decodeVcdiff = (modules.Vcdiff ?? (Platform.Vcdiff.supported && Platform.Vcdiff.bundledDecode)) || null;
     this.connection = new Connection(this, this.options);
     this._channels = new Channels(this);
-    // avoid using the same channel pool as that exposed via this.channels()
-    // to allow the channels to be used individually
     if (modules.ChannelGroups) {
-      // disable channel groups on the new base realtime instance to avoid recursion
-      const newModules = Object.assign({}, modules);
-      delete newModules['ChannelGroups'];
-      const newRealtime = new BaseRealtime(options, newModules);
-      this._channelGroups = new modules.ChannelGroups(newRealtime.channels);
+      this._channelGroups = new modules.ChannelGroups(this._channels);
     } else {
       this._channelGroups = null;
     }
@@ -249,14 +243,22 @@ class ChannelGroup {
   expression: RegExp;
   consumerGroup: ConsumerGroup;
 
-  constructor(readonly channels: Channels, filter: string, readonly options?: API.ChannelGroupOptions) {
+  constructor(readonly channels: Channels, readonly filter: string, readonly options?: API.ChannelGroupOptions) {
     this.subscriptions = new EventEmitter();
-    this.active = channels.get(options?.activeChannel || '$ably:active');
+    this.active = channels.get(this.safeChannelName(options?.activeChannel || '$ably:active'));
     this.consumerGroup = new ConsumerGroup(channels, options?.consumerGroup?.name);
     this.consumerGroup.on('membership', () => this.updateAssignedChannels());
     this.expression = new RegExp(filter); // eslint-disable-line security/detect-non-literal-regexp
   }
 
+  // Add dummy options to the channel name so that it is treated as an independent channel
+  // in the channel pool. This avoids any conflicts with external, independent use of individual
+  // channels that happen to also be included in a channel group.
+  private safeChannelName(name: string) {
+    // base64 encode to ensure only allowed characters are used in the qualifier
+    return `[?x-ably-channelgroup=${Utils.toBase64(this.filter)}]${name}`;
+  }
+
   async join() {
     await this.consumerGroup.join();
     await this.active.setOptions({ params: { rewind: '1' } });
@@ -332,7 +334,7 @@ class ChannelGroup {
         'ChannelGroups.subscribeChannel()',
         'setting up subscription to channel ' + channel
       );
-      this.subscribedChannels[channel] = this.channels.get(channel);
+      this.subscribedChannels[channel] = this.channels.get(this.safeChannelName(channel));
       this.subscribedChannels[channel].on(['detached', 'failed'], (event: ChannelStateChange) => {
         Logger.logAction(
           Logger.LOG_MAJOR,