Rename WebSocketConnectionEventManager/Listener to MessageAvailabilityManager/Listener

service/src/main/java/org/whispersystems/textsecuregcm/WhisperServerService.java

@@ -199,7 +199,7 @@ import org.whispersystems.textsecuregcm.push.ProvisioningManager;
 import org.whispersystems.textsecuregcm.push.PushNotificationManager;
 import org.whispersystems.textsecuregcm.push.PushNotificationScheduler;
 import org.whispersystems.textsecuregcm.push.ReceiptSender;
-import org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager;
+import org.whispersystems.textsecuregcm.push.RedisMessageAvailabilityManager;
 import org.whispersystems.textsecuregcm.redis.ConnectionEventLogger;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisClient;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisClusterClient;
@@ -655,8 +655,8 @@ public class WhisperServerService extends Application<WhisperServerConfiguration
         apnSender, fcmSender, accountsManager, 0, 0);
     PushNotificationManager pushNotificationManager =
         new PushNotificationManager(accountsManager, apnSender, fcmSender, pushNotificationScheduler);
-    WebSocketConnectionEventManager webSocketConnectionEventManager =
-        new WebSocketConnectionEventManager(accountsManager, pushNotificationManager, messagesCluster, clientEventExecutor, asyncOperationQueueingExecutor);
+    RedisMessageAvailabilityManager redisMessageAvailabilityManager =
+        new RedisMessageAvailabilityManager(accountsManager, pushNotificationManager, messagesCluster, clientEventExecutor, asyncOperationQueueingExecutor);
     RateLimiters rateLimiters = RateLimiters.create(dynamicConfigurationManager, rateLimitersCluster);
     ProvisioningManager provisioningManager = new ProvisioningManager(pubsubClient);
     IssuedReceiptsManager issuedReceiptsManager = new IssuedReceiptsManager(
@@ -752,7 +752,7 @@ public class WhisperServerService extends Application<WhisperServerConfiguration
     environment.lifecycle().manage(pushNotificationScheduler);
     environment.lifecycle().manage(provisioningManager);
     environment.lifecycle().manage(disconnectionRequestManager);
-    environment.lifecycle().manage(webSocketConnectionEventManager);
+    environment.lifecycle().manage(redisMessageAvailabilityManager);
     environment.lifecycle().manage(currencyManager);
     environment.lifecycle().manage(registrationServiceClient);
     environment.lifecycle().manage(keyTransparencyServiceClient);
@@ -996,13 +996,13 @@ public class WhisperServerService extends Application<WhisperServerConfiguration
         config.idlePrimaryDeviceReminderConfiguration().minIdleDuration(), Clock.systemUTC()));
     webSocketEnvironment.setConnectListener(
         new AuthenticatedConnectListener(accountsManager, receiptSender, messagesManager, messageMetrics, pushNotificationManager,
-            pushNotificationScheduler, webSocketConnectionEventManager, disconnectionRequestManager, websocketScheduledExecutor,
+            pushNotificationScheduler, redisMessageAvailabilityManager, disconnectionRequestManager, websocketScheduledExecutor,
             messageDeliveryScheduler, clientReleaseManager, messageDeliveryLoopMonitor, experimentEnrollmentManager));
     webSocketEnvironment.jersey().register(new RateLimitByIpFilter(rateLimiters));
     webSocketEnvironment.jersey().register(new RequestStatisticsFilter(TrafficSource.WEBSOCKET));
     webSocketEnvironment.jersey().register(MultiRecipientMessageProvider.class);
     webSocketEnvironment.jersey().register(new MetricsApplicationEventListener(TrafficSource.WEBSOCKET, clientReleaseManager));
-    webSocketEnvironment.jersey().register(new KeepAliveController(webSocketConnectionEventManager));
+    webSocketEnvironment.jersey().register(new KeepAliveController(redisMessageAvailabilityManager));
     webSocketEnvironment.jersey().register(new TimestampResponseFilter());
 
     final List<SpamFilter> spamFilters = ServiceLoader.load(SpamFilter.class)
@@ -1145,7 +1145,7 @@ public class WhisperServerService extends Application<WhisperServerConfiguration
         webSocketEnvironment.getRequestLog(), Duration.ofMillis(60000));
     provisioningEnvironment.setConnectListener(new ProvisioningConnectListener(provisioningManager, provisioningWebsocketTimeoutExecutor, Duration.ofSeconds(90)));
     provisioningEnvironment.jersey().register(new MetricsApplicationEventListener(TrafficSource.WEBSOCKET, clientReleaseManager));
-    provisioningEnvironment.jersey().register(new KeepAliveController(webSocketConnectionEventManager));
+    provisioningEnvironment.jersey().register(new KeepAliveController(redisMessageAvailabilityManager));
     provisioningEnvironment.jersey().register(new TimestampResponseFilter());
 
     registerExceptionMappers(environment, webSocketEnvironment, provisioningEnvironment);

service/src/main/java/org/whispersystems/textsecuregcm/controllers/KeepAliveController.java

@@ -22,7 +22,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.whispersystems.textsecuregcm.auth.AuthenticatedDevice;
 import org.whispersystems.textsecuregcm.metrics.UserAgentTagUtil;
-import org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager;
+import org.whispersystems.textsecuregcm.push.RedisMessageAvailabilityManager;
 import org.whispersystems.websocket.session.WebSocketSession;
 import org.whispersystems.websocket.session.WebSocketSessionContext;
 
@@ -33,14 +33,14 @@ public class KeepAliveController {
 
   private final Logger logger = LoggerFactory.getLogger(KeepAliveController.class);
 
-  private final WebSocketConnectionEventManager webSocketConnectionEventManager;
+  private final RedisMessageAvailabilityManager redisMessageAvailabilityManager;
 
   private static final String CLOSED_CONNECTION_AGE_DISTRIBUTION_NAME = name(KeepAliveController.class,
       "closedConnectionAge");
 
 
-  public KeepAliveController(final WebSocketConnectionEventManager webSocketConnectionEventManager) {
-    this.webSocketConnectionEventManager = webSocketConnectionEventManager;
+  public KeepAliveController(final RedisMessageAvailabilityManager redisMessageAvailabilityManager) {
+    this.redisMessageAvailabilityManager = redisMessageAvailabilityManager;
   }
 
   @GET
@@ -48,7 +48,7 @@ public class KeepAliveController {
       @WebSocketSession WebSocketSessionContext context) {
 
     maybeAuth.ifPresent(auth -> {
-      if (!webSocketConnectionEventManager.isLocallyPresent(auth.accountIdentifier(), auth.deviceId())) {
+      if (!redisMessageAvailabilityManager.isLocallyPresent(auth.accountIdentifier(), auth.deviceId())) {
 
         final Duration age = Duration.between(context.getClient().getCreated(), Instant.now());
 

service/src/main/java/org/whispersystems/textsecuregcm/push/MessageAvailabilityListener.java

@@ -5,11 +5,15 @@
 
 package org.whispersystems.textsecuregcm.push;
 
+import java.util.UUID;
+
 /**
- * A WebSocket connection event listener handles message availability and presence events related to a client's open
- * WebSocket connection. Handler methods are run on dedicated threads and may safely perform blocking operations.
+ * A message availability listener handles message availability and presence events related to a client's open message
+ * stream. Handler methods are run on dedicated threads and may safely perform blocking operations.
+ * 
+ * @see RedisMessageAvailabilityManager#handleClientConnected(UUID, byte, MessageAvailabilityListener)
  */
-public interface WebSocketConnectionEventListener {
+public interface MessageAvailabilityListener {
 
   /**
    * Indicates that a new message is available in the connected client's message queue.

service/src/main/java/org/whispersystems/textsecuregcm/push/RedisMessageAvailabilityManager.java

@@ -39,22 +39,22 @@ import org.whispersystems.textsecuregcm.util.UUIDUtil;
 import org.whispersystems.textsecuregcm.util.Util;
 
 /**
- * The WebSocket connection event manager distributes events related to client presence and message availability to
+ * The Redis message availability manager distributes events related to client presence and message availability to
  * registered listeners. In the current Signal server implementation, clients generally interact with the service by
  * opening a dual-purpose WebSocket. The WebSocket serves as both a delivery mechanism for messages and as a channel
  * for the client to issue API requests to the server. Clients are considered "present" if they have an open WebSocket
- * connection and are therefore likely to receive messages as soon as they're delivered to the server. WebSocket
- * connection managers make a best effort to ensure that clients have at most one active message delivery channel at
- * a time.
+ * connection and are therefore likely to receive messages as soon as they're delivered to the server. Redis message
+ * availability managers ensure that clients have at most one active message delivery channel at a time on a
+ * best-effort basis.
  *
- * @implNote The WebSocket connection event manager uses the Redis 7 sharded pub/sub system to distribute events. This
+ * @implNote The Redis message availability manager uses the Redis 7 sharded pub/sub system to distribute events. This
  * system makes a best effort to ensure that a given client has only a single open connection across the fleet of
  * servers, but cannot guarantee at-most-one behavior.
  *
- * @see WebSocketConnectionEventListener
+ * @see MessageAvailabilityListener
  * @see org.whispersystems.textsecuregcm.storage.MessagesManager#insert(UUID, Map)
  */
-public class WebSocketConnectionEventManager extends RedisClusterPubSubAdapter<byte[], byte[]> implements Managed {
+public class RedisMessageAvailabilityManager extends RedisClusterPubSubAdapter<byte[], byte[]> implements Managed {
 
   private final AccountsManager accountsManager;
   private final PushNotificationManager pushNotificationManager;
@@ -68,7 +68,7 @@ public class WebSocketConnectionEventManager extends RedisClusterPubSubAdapter<b
   @Nullable
   private FaultTolerantPubSubClusterConnection<byte[], byte[]> pubSubConnection;
 
-  private final Map<AccountAndDeviceIdentifier, WebSocketConnectionEventListener> listenersByAccountAndDeviceIdentifier;
+  private final Map<AccountAndDeviceIdentifier, MessageAvailabilityListener> listenersByAccountAndDeviceIdentifier;
 
   private final UUID serverId = UUID.randomUUID();
 
@@ -80,31 +80,31 @@ public class WebSocketConnectionEventManager extends RedisClusterPubSubAdapter<b
       .toByteArray();
 
   private static final Counter PUBLISH_CLIENT_CONNECTION_EVENT_ERROR_COUNTER =
-      Metrics.counter(MetricsUtil.name(WebSocketConnectionEventManager.class, "publishClientConnectionEventError"));
+      Metrics.counter(MetricsUtil.name(RedisMessageAvailabilityManager.class, "publishClientConnectionEventError"));
 
   private static final Counter UNSUBSCRIBE_ERROR_COUNTER =
-      Metrics.counter(MetricsUtil.name(WebSocketConnectionEventManager.class, "unsubscribeError"));
+      Metrics.counter(MetricsUtil.name(RedisMessageAvailabilityManager.class, "unsubscribeError"));
 
   private static final Counter PUB_SUB_EVENT_WITHOUT_LISTENER_COUNTER =
-      Metrics.counter(MetricsUtil.name(WebSocketConnectionEventManager.class, "pubSubEventWithoutListener"));
+      Metrics.counter(MetricsUtil.name(RedisMessageAvailabilityManager.class, "pubSubEventWithoutListener"));
 
   private static final Counter MESSAGE_AVAILABLE_WITHOUT_LISTENER_COUNTER =
-      Metrics.counter(MetricsUtil.name(WebSocketConnectionEventManager.class, "messageAvailableWithoutListener"));
+      Metrics.counter(MetricsUtil.name(RedisMessageAvailabilityManager.class, "messageAvailableWithoutListener"));
 
   private static final String LISTENER_GAUGE_NAME =
-      MetricsUtil.name(WebSocketConnectionEventManager.class, "listeners");
+      MetricsUtil.name(RedisMessageAvailabilityManager.class, "listeners");
 
-  private static final Logger logger = LoggerFactory.getLogger(WebSocketConnectionEventManager.class);
+  private static final Logger logger = LoggerFactory.getLogger(RedisMessageAvailabilityManager.class);
 
   @VisibleForTesting
   record AccountAndDeviceIdentifier(UUID accountIdentifier, byte deviceId) {
   }
 
-  public WebSocketConnectionEventManager(final AccountsManager accountsManager,
-      final PushNotificationManager pushNotificationManager,
-      final FaultTolerantRedisClusterClient clusterClient,
-      final Executor listenerEventExecutor,
-      final Executor asyncOperationQueueingExecutor) {
+  public RedisMessageAvailabilityManager(final AccountsManager accountsManager,
+                                         final PushNotificationManager pushNotificationManager,
+                                         final FaultTolerantRedisClusterClient clusterClient,
+                                         final Executor listenerEventExecutor,
+                                         final Executor asyncOperationQueueingExecutor) {
 
     this.accountsManager = accountsManager;
     this.pushNotificationManager = pushNotificationManager;
@@ -140,7 +140,7 @@ public class WebSocketConnectionEventManager extends RedisClusterPubSubAdapter<b
   /**
    * Marks the given device as "present" for message delivery and registers a listener for new messages and conflicting
    * connections. If the given device already has a presence registered with this manager, that presence is displaced
-   * immediately and the listener's {@link WebSocketConnectionEventListener#handleConflictingMessageReader()} method is called.
+   * immediately and the listener's {@link MessageAvailabilityListener#handleConflictingMessageReader()} method is called.
    *
    * @param accountIdentifier the account identifier for the newly-connected device
    * @param deviceId the ID of the newly-connected device within the given account
@@ -151,13 +151,13 @@ public class WebSocketConnectionEventManager extends RedisClusterPubSubAdapter<b
    * pub/sub subscription could not be established, in which case callers should close the client's connection to the
    * server
    */
-  public CompletionStage<Void> handleClientConnected(final UUID accountIdentifier, final byte deviceId, final WebSocketConnectionEventListener listener) {
+  public CompletionStage<Void> handleClientConnected(final UUID accountIdentifier, final byte deviceId, final MessageAvailabilityListener listener) {
     if (pubSubConnection == null) {
       throw new IllegalStateException("WebSocket connection event manager not started");
     }
 
     final byte[] eventChannel = getClientEventChannel(accountIdentifier, deviceId);
-    final AtomicReference<WebSocketConnectionEventListener> displacedListener = new AtomicReference<>();
+    final AtomicReference<MessageAvailabilityListener> displacedListener = new AtomicReference<>();
     final AtomicReference<CompletionStage<Void>> subscribeFuture = new AtomicReference<>();
 
     // Note that we're relying on some specific implementation details of `ConcurrentHashMap#compute(...)`. In
@@ -315,7 +315,7 @@ public class WebSocketConnectionEventManager extends RedisClusterPubSubAdapter<b
 
     final AccountAndDeviceIdentifier accountAndDeviceIdentifier = parseClientEventChannel(shardChannel);
 
-    @Nullable final WebSocketConnectionEventListener listener =
+    @Nullable final MessageAvailabilityListener listener =
         listenersByAccountAndDeviceIdentifier.get(accountAndDeviceIdentifier);
 
     if (listener != null) {

service/src/main/java/org/whispersystems/textsecuregcm/storage/MessagesCacheInsertScript.java

@@ -16,7 +16,7 @@ import java.util.concurrent.CompletableFuture;
 import org.whispersystems.textsecuregcm.entities.MessageProtos;
 import org.whispersystems.textsecuregcm.push.ClientEvent;
 import org.whispersystems.textsecuregcm.push.NewMessageAvailableEvent;
-import org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager;
+import org.whispersystems.textsecuregcm.push.RedisMessageAvailabilityManager;
 import org.whispersystems.textsecuregcm.redis.ClusterLuaScript;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisClusterClient;
 
@@ -53,7 +53,7 @@ class MessagesCacheInsertScript {
         MessagesCache.getMessageQueueKey(destinationUuid, destinationDevice), // queueKey
         MessagesCache.getMessageQueueMetadataKey(destinationUuid, destinationDevice), // queueMetadataKey
         MessagesCache.getQueueIndexKey(destinationUuid, destinationDevice), // queueTotalIndexKey
-        WebSocketConnectionEventManager.getClientEventChannel(destinationUuid, destinationDevice) // eventChannelKey
+        RedisMessageAvailabilityManager.getClientEventChannel(destinationUuid, destinationDevice) // eventChannelKey
     );
 
     final List<byte[]> args = new ArrayList<>(Arrays.asList(

service/src/main/java/org/whispersystems/textsecuregcm/storage/MessagesCacheUnlockQueueScript.java

@@ -8,7 +8,7 @@ package org.whispersystems.textsecuregcm.storage;
 import io.lettuce.core.ScriptOutputType;
 import org.whispersystems.textsecuregcm.push.ClientEvent;
 import org.whispersystems.textsecuregcm.push.MessagesPersistedEvent;
-import org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager;
+import org.whispersystems.textsecuregcm.push.RedisMessageAvailabilityManager;
 import org.whispersystems.textsecuregcm.redis.ClusterLuaScript;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisClusterClient;
 import java.io.IOException;
@@ -35,7 +35,7 @@ class MessagesCacheUnlockQueueScript {
   void execute(final UUID accountIdentifier, final byte deviceId) {
     final List<byte[]> keys = List.of(
         MessagesCache.getPersistInProgressKey(accountIdentifier, deviceId), // persistInProgressKey
-        WebSocketConnectionEventManager.getClientEventChannel(accountIdentifier, deviceId) // eventChannelKey
+        RedisMessageAvailabilityManager.getClientEventChannel(accountIdentifier, deviceId) // eventChannelKey
     );
 
     unlockQueueScript.executeBinary(keys, MESSAGES_PERSISTED_EVENT_ARGS);

service/src/main/java/org/whispersystems/textsecuregcm/storage/MessagesManager.java

@@ -33,6 +33,7 @@ import org.whispersystems.textsecuregcm.entities.MessageProtos.Envelope;
 import org.whispersystems.textsecuregcm.identity.IdentityType;
 import org.whispersystems.textsecuregcm.identity.ServiceIdentifier;
 import org.whispersystems.textsecuregcm.metrics.MetricsUtil;
+import org.whispersystems.textsecuregcm.push.RedisMessageAvailabilityManager;
 import org.whispersystems.textsecuregcm.util.Pair;
 import reactor.core.observability.micrometer.Micrometer;
 import reactor.core.publisher.Flux;
@@ -82,7 +83,7 @@ public class MessagesManager {
    *
    * @return a map of device IDs to a device's presence state (i.e. if the device has an active event listener)
    *
-   * @see org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager
+   * @see RedisMessageAvailabilityManager
    */
   public Map<Byte, Boolean> insert(final UUID accountIdentifier, final Map<Byte, Envelope> messagesByDeviceId) {
     return insertAsync(accountIdentifier, messagesByDeviceId).join();
@@ -127,7 +128,7 @@ public class MessagesManager {
    * @return a map of accounts to maps of device IDs to a device's presence state (i.e. if the device has an active
    * event listener)
    *
-   * @see org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager
+   * @see RedisMessageAvailabilityManager
    */
   public CompletableFuture<Map<Account, Map<Byte, Boolean>>> insertMultiRecipientMessage(
       final SealedSenderMultiRecipientMessage multiRecipientMessage,

service/src/main/java/org/whispersystems/textsecuregcm/websocket/AuthenticatedConnectListener.java

@@ -19,7 +19,7 @@ import org.whispersystems.textsecuregcm.identity.IdentityType;
 import org.whispersystems.textsecuregcm.limits.MessageDeliveryLoopMonitor;
 import org.whispersystems.textsecuregcm.metrics.MessageMetrics;
 import org.whispersystems.textsecuregcm.metrics.OpenWebSocketCounter;
-import org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager;
+import org.whispersystems.textsecuregcm.push.RedisMessageAvailabilityManager;
 import org.whispersystems.textsecuregcm.push.PushNotificationManager;
 import org.whispersystems.textsecuregcm.push.PushNotificationScheduler;
 import org.whispersystems.textsecuregcm.push.ReceiptSender;
@@ -49,7 +49,7 @@ public class AuthenticatedConnectListener implements WebSocketConnectListener {
   private final MessageMetrics messageMetrics;
   private final PushNotificationManager pushNotificationManager;
   private final PushNotificationScheduler pushNotificationScheduler;
-  private final WebSocketConnectionEventManager webSocketConnectionEventManager;
+  private final RedisMessageAvailabilityManager redisMessageAvailabilityManager;
   private final DisconnectionRequestManager disconnectionRequestManager;
   private final ScheduledExecutorService scheduledExecutorService;
   private final Scheduler messageDeliveryScheduler;
@@ -67,7 +67,7 @@ public class AuthenticatedConnectListener implements WebSocketConnectListener {
       final MessageMetrics messageMetrics,
       final PushNotificationManager pushNotificationManager,
       final PushNotificationScheduler pushNotificationScheduler,
-      final WebSocketConnectionEventManager webSocketConnectionEventManager,
+      final RedisMessageAvailabilityManager redisMessageAvailabilityManager,
       final DisconnectionRequestManager disconnectionRequestManager,
       final ScheduledExecutorService scheduledExecutorService,
       final Scheduler messageDeliveryScheduler,
@@ -81,7 +81,7 @@ public class AuthenticatedConnectListener implements WebSocketConnectListener {
     this.messageMetrics = messageMetrics;
     this.pushNotificationManager = pushNotificationManager;
     this.pushNotificationScheduler = pushNotificationScheduler;
-    this.webSocketConnectionEventManager = webSocketConnectionEventManager;
+    this.redisMessageAvailabilityManager = redisMessageAvailabilityManager;
     this.disconnectionRequestManager = disconnectionRequestManager;
     this.scheduledExecutorService = scheduledExecutorService;
     this.messageDeliveryScheduler = messageDeliveryScheduler;
@@ -145,7 +145,7 @@ public class AuthenticatedConnectListener implements WebSocketConnectListener {
         // receive push notifications for inbound messages. We should do this first because, at this point, the
         // connection has already closed and attempts to actually deliver a message via the connection will not succeed.
         // It's preferable to start sending push notifications as soon as possible.
-        webSocketConnectionEventManager.handleClientDisconnected(auth.accountIdentifier(), auth.deviceId());
+        redisMessageAvailabilityManager.handleClientDisconnected(auth.accountIdentifier(), auth.deviceId());
 
         // Finally, stop trying to deliver messages and send a push notification if the connection is aware of any
         // undelivered messages.
@@ -161,7 +161,7 @@ public class AuthenticatedConnectListener implements WebSocketConnectListener {
 
         // Finally, we register this client's presence, which suppresses push notifications. We do this last because
         // receiving extra push notifications is generally preferable to missing out on a push notification.
-        webSocketConnectionEventManager.handleClientConnected(auth.accountIdentifier(), auth.deviceId(), connection);
+        redisMessageAvailabilityManager.handleClientConnected(auth.accountIdentifier(), auth.deviceId(), connection);
       } catch (final Exception e) {
         log.warn("Failed to initialize websocket", e);
         context.getClient().close(1011, "Unexpected error initializing connection");

service/src/main/java/org/whispersystems/textsecuregcm/websocket/WebSocketConnection.java

@@ -51,7 +51,7 @@ import org.whispersystems.textsecuregcm.metrics.UserAgentTagUtil;
 import org.whispersystems.textsecuregcm.push.PushNotificationManager;
 import org.whispersystems.textsecuregcm.push.PushNotificationScheduler;
 import org.whispersystems.textsecuregcm.push.ReceiptSender;
-import org.whispersystems.textsecuregcm.push.WebSocketConnectionEventListener;
+import org.whispersystems.textsecuregcm.push.MessageAvailabilityListener;
 import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.ClientReleaseManager;
 import org.whispersystems.textsecuregcm.storage.Device;
@@ -66,7 +66,7 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Scheduler;
 
-public class WebSocketConnection implements WebSocketConnectionEventListener, DisconnectionRequestListener {
+public class WebSocketConnection implements MessageAvailabilityListener, DisconnectionRequestListener {
 
   private static final DistributionSummary messageTime = Metrics.summary(
       name(MessageController.class, "messageDeliveryDuration"));

service/src/main/java/org/whispersystems/textsecuregcm/workers/CommandDependencies.java

@@ -43,7 +43,7 @@ import org.whispersystems.textsecuregcm.push.APNSender;
 import org.whispersystems.textsecuregcm.push.FcmSender;
 import org.whispersystems.textsecuregcm.push.PushNotificationManager;
 import org.whispersystems.textsecuregcm.push.PushNotificationScheduler;
-import org.whispersystems.textsecuregcm.push.WebSocketConnectionEventManager;
+import org.whispersystems.textsecuregcm.push.RedisMessageAvailabilityManager;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisClient;
 import org.whispersystems.textsecuregcm.redis.FaultTolerantRedisClusterClient;
 import org.whispersystems.textsecuregcm.securestorage.SecureStorageClient;
@@ -319,15 +319,15 @@ record CommandDependencies(
             configuration.getDynamoDbTables().getPushNotificationExperimentSamples().getTableName(),
             Clock.systemUTC());
 
-    WebSocketConnectionEventManager webSocketConnectionEventManager =
-        new WebSocketConnectionEventManager(accountsManager, pushNotificationManager, messagesCluster, clientEventExecutor, asyncOperationQueueingExecutor);
+    RedisMessageAvailabilityManager redisMessageAvailabilityManager =
+        new RedisMessageAvailabilityManager(accountsManager, pushNotificationManager, messagesCluster, clientEventExecutor, asyncOperationQueueingExecutor);
 
     final DynamoDbRecoveryManager dynamoDbRecoveryManager =
         new DynamoDbRecoveryManager(accounts, phoneNumberIdentifiers);
 
     environment.lifecycle().manage(apnSender);
     environment.lifecycle().manage(disconnectionRequestManager);
-    environment.lifecycle().manage(webSocketConnectionEventManager);
+    environment.lifecycle().manage(redisMessageAvailabilityManager);
     environment.lifecycle().manage(new ManagedAwsCrt());
 
     return new CommandDependencies(