Retire the explicit "handle new message available" system in favor of implicit presence-on-insert values

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

@@ -654,8 +654,7 @@ public class WhisperServerService extends Application<WhisperServerConfiguration
 
     final AccountAuthenticator accountAuthenticator = new AccountAuthenticator(accountsManager);
 
-    final MessageSender messageSender =
-        new MessageSender(pubSubClientEventManager, messagesManager, pushNotificationManager);
+    final MessageSender messageSender = new MessageSender(messagesManager, pushNotificationManager);
     final ReceiptSender receiptSender = new ReceiptSender(accountsManager, messageSender, receiptSenderExecutor);
     final TurnTokenGenerator turnTokenGenerator = new TurnTokenGenerator(dynamicConfigurationManager,
         config.getTurnConfiguration().secret().value());

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

@@ -8,15 +8,10 @@ import static com.codahale.metrics.MetricRegistry.name;
 import static org.whispersystems.textsecuregcm.entities.MessageProtos.Envelope;
 
 import com.google.common.annotations.VisibleForTesting;
-import io.micrometer.core.instrument.Counter;
 import io.micrometer.core.instrument.Metrics;
-import org.whispersystems.textsecuregcm.identity.IdentityType;
-import org.whispersystems.textsecuregcm.metrics.MetricsUtil;
 import org.whispersystems.textsecuregcm.storage.Account;
 import org.whispersystems.textsecuregcm.storage.Device;
 import org.whispersystems.textsecuregcm.storage.MessagesManager;
-import org.whispersystems.textsecuregcm.util.Util;
-import java.util.concurrent.CompletableFuture;
 
 /**
  * A MessageSender sends Signal messages to destination devices. Messages may be "normal" user-to-user messages,
@@ -27,13 +22,10 @@ import java.util.concurrent.CompletableFuture;
  * for "online" delivery only and will not be delivered (and clients will not be notified) if the destination device
  * isn't actively connected to a Signal server.
  *
- * @see ClientPresenceManager
- * @see org.whispersystems.textsecuregcm.storage.MessageAvailabilityListener
  * @see ReceiptSender
  */
 public class MessageSender {
 
-  private final PubSubClientEventManager pubSubClientEventManager;
   private final MessagesManager messagesManager;
   private final PushNotificationManager pushNotificationManager;
 
@@ -45,52 +37,31 @@ public class MessageSender {
   private static final String STORY_TAG_NAME = "story";
   private static final String SEALED_SENDER_TAG_NAME = "sealedSender";
 
-  private static final Counter CLIENT_PRESENCE_ERROR =
-      Metrics.counter(MetricsUtil.name(MessageSender.class, "clientPresenceError"));
-
-  public MessageSender(final PubSubClientEventManager pubSubClientEventManager,
-      final MessagesManager messagesManager,
-      final PushNotificationManager pushNotificationManager) {
-
-    this.pubSubClientEventManager = pubSubClientEventManager;
+  public MessageSender(final MessagesManager messagesManager, final PushNotificationManager pushNotificationManager) {
     this.messagesManager = messagesManager;
     this.pushNotificationManager = pushNotificationManager;
   }
 
-  public CompletableFuture<Void> sendMessage(final Account account, final Device device, final Envelope message, final boolean online) {
-    messagesManager.insert(account.getUuid(),
+  public void sendMessage(final Account account, final Device device, final Envelope message, final boolean online) {
+    final boolean destinationPresent = messagesManager.insert(account.getUuid(),
         device.getId(),
         online ? message.toBuilder().setEphemeral(true).build() : message);
 
-    return pubSubClientEventManager.handleNewMessageAvailable(account.getIdentifier(IdentityType.ACI), device.getId())
-        .exceptionally(throwable -> {
-          // It's unlikely that the message insert (synchronous) would succeed and sending a "new message available"
-          // event would fail since both things happen in the same cluster, but just in case, we should "fail open" and
-          // act as if the client wasn't present if this happens. This is a conservative measure that biases toward
-          // sending more push notifications, though again, it shouldn't happen often.
-          CLIENT_PRESENCE_ERROR.increment();
-          return false;
-        })
-        .thenApply(clientPresent -> {
-          if (!clientPresent && !online) {
-            try {
-              pushNotificationManager.sendNewMessageNotification(account, device.getId(), message.getUrgent());
-            } catch (final NotPushRegisteredException ignored) {
-            }
-          }
+    if (!destinationPresent && !online) {
+      try {
+        pushNotificationManager.sendNewMessageNotification(account, device.getId(), message.getUrgent());
+      } catch (final NotPushRegisteredException ignored) {
+      }
+    }
 
-          return clientPresent;
-        })
-        .whenComplete((clientPresent, throwable) -> Metrics.counter(SEND_COUNTER_NAME,
-                CHANNEL_TAG_NAME, getDeliveryChannelName(device),
-                EPHEMERAL_TAG_NAME, String.valueOf(online),
-                CLIENT_ONLINE_TAG_NAME, String.valueOf(clientPresent),
-                URGENT_TAG_NAME, String.valueOf(message.getUrgent()),
-                STORY_TAG_NAME, String.valueOf(message.getStory()),
-                SEALED_SENDER_TAG_NAME, String.valueOf(!message.hasSourceServiceId()))
-            .increment())
-        .thenRun(Util.NOOP)
-        .toCompletableFuture();
+    Metrics.counter(SEND_COUNTER_NAME,
+            CHANNEL_TAG_NAME, getDeliveryChannelName(device),
+            EPHEMERAL_TAG_NAME, String.valueOf(online),
+            CLIENT_ONLINE_TAG_NAME, String.valueOf(destinationPresent),
+            URGENT_TAG_NAME, String.valueOf(message.getUrgent()),
+            STORY_TAG_NAME, String.valueOf(message.getStory()),
+            SEALED_SENDER_TAG_NAME, String.valueOf(!message.hasSourceServiceId()))
+        .increment();
   }
 
   @VisibleForTesting

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

@@ -68,11 +68,6 @@ public class PubSubClientEventManager extends RedisClusterPubSubAdapter<byte[],
 
   private final Map<AccountAndDeviceIdentifier, ClientEventListener> listenersByAccountAndDeviceIdentifier;
 
-  private static final byte[] NEW_MESSAGE_EVENT_BYTES = ClientEvent.newBuilder()
-      .setNewMessageAvailable(NewMessageAvailableEvent.getDefaultInstance())
-      .build()
-      .toByteArray();
-
   private static final byte[] DISCONNECT_REQUESTED_EVENT_BYTES = ClientEvent.newBuilder()
       .setDisconnectRequested(DisconnectRequested.getDefaultInstance())
       .build()
@@ -229,26 +224,6 @@ public class PubSubClientEventManager extends RedisClusterPubSubAdapter<byte[],
     });
   }
 
-  /**
-   * Publishes an event notifying a specific device that a new message is available for retrieval. This method indicates
-   * whether the target device is "present" (i.e. has an active listener). Callers may choose to take follow-up action
-   * (like sending a push notification) if the target device is not present.
-   *
-   * @param accountIdentifier the account identifier of the receiving device
-   * @param deviceId the ID of the receiving device within the target account
-   *
-   * @return a future that yields {@code true} if the target device had an active listener or {@code false} otherwise
-   */
-  public CompletionStage<Boolean> handleNewMessageAvailable(final UUID accountIdentifier, final byte deviceId) {
-    if (pubSubConnection == null) {
-      throw new IllegalStateException("Presence manager not started");
-    }
-
-    return pubSubConnection.withPubSubConnection(connection ->
-            connection.async().spublish(getClientEventChannel(accountIdentifier, deviceId), NEW_MESSAGE_EVENT_BYTES))
-        .thenApply(listeners -> listeners > 0);
-  }
-
   /**
    * Publishes an event notifying a specific device that messages have been persisted from short-term to long-term
    * storage.

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

@@ -211,13 +211,13 @@ public class MessagesCache {
     this.removeRecipientViewFromMrmDataScript = removeRecipientViewFromMrmDataScript;
   }
 
-  public void insert(final UUID messageGuid,
+  public boolean insert(final UUID messageGuid,
       final UUID destinationAccountIdentifier,
       final byte destinationDeviceId,
       final MessageProtos.Envelope message) {
 
     final MessageProtos.Envelope messageWithGuid = message.toBuilder().setServerGuid(messageGuid.toString()).build();
-    insertTimer.record(() -> insertScript.execute(destinationAccountIdentifier, destinationDeviceId, messageWithGuid));
+    return insertTimer.record(() -> insertScript.execute(destinationAccountIdentifier, destinationDeviceId, messageWithGuid));
   }
 
   public byte[] insertSharedMultiRecipientMessagePayload(

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

@@ -59,14 +59,16 @@ public class MessagesManager {
     this.messageDeletionExecutor = messageDeletionExecutor;
   }
 
-  public void insert(UUID destinationUuid, byte destinationDevice, Envelope message) {
+  public boolean insert(UUID destinationUuid, byte destinationDevice, Envelope message) {
     final UUID messageGuid = UUID.randomUUID();
 
-    messagesCache.insert(messageGuid, destinationUuid, destinationDevice, message);
+    final boolean destinationPresent = messagesCache.insert(messageGuid, destinationUuid, destinationDevice, message);
 
     if (message.hasSourceServiceId() && !destinationUuid.toString().equals(message.getSourceServiceId())) {
       reportMessageManager.store(message.getSourceServiceId(), messageGuid);
     }
+
+    return destinationPresent;
   }
 
   public CompletableFuture<Boolean> mayHavePersistedMessages(final UUID destinationUuid, final Device destinationDevice) {