docs: public void deleteRemoteDurableRME(ConsumerDispatcherState subState)
                      throws SIDurableSubscriptionNotFoundException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc,
                          "deleteRemoteDurableRME",
                          new Object[] { subState });
  
          Object rcd = null;
  
          // Retreive the remote ME uuid from the ConsumerDispatcherState
          SIBUuid8 remoteMEUuid =
                          subState.getRemoteMEUuid();
  
          // Build the key for the consumerDispatchersDurable table
          String remSubName = null;
          if (remoteMEUuid != null)
          {
              remSubName =
                              _baseDestinationHandler.
                                              constructPseudoDurableDestName(remoteMEUuid.toString(),
                                                                             subState.getSubscriberID());
          }
  
          synchronized (_consumerDispatchersDurable)
          {
              if (remSubName != null)
              {
                  rcd = _consumerDispatchersDurable.get(remSubName);
              }
  
              if ((rcd != null) && (rcd instanceof RemoteConsumerDispatcher))
              {
                  // Mark the RCD to inicate that it is being deleted (and will have flush
                  // work scheduled against it)
                  ((RemoteConsumerDispatcher) rcd).setPendingDelete(true);
              }
              // Verify that the subscription exists.  If not, throw an error
              else
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(
                                 tc,
                                 "deleteRemoteDurableRME",
                                 "no such durable subcription");
  
                  throw new SIDurableSubscriptionNotFoundException(
                                  nls.getFormattedMessage(
                                                          "SUBSCRIPTION_DOESNT_EXIST_ERROR_CWSIP0072",
                                                          new Object[] {
                                                                        subState.getSubscriberID(),
                                                                        subState.getDurableHome() },
                                                          null));
              }
          }
  
          // Remove the RME side as if we were cleaning up the destination (which, in a sense, we are).
          // If necessary, delay the delete until the DME completes the flush.
          // Otherwise, we'll have problems if the DME missed the message and
          // we try to attach another consumer from the same RME.
          final String subName = remSubName;
          final AnycastInputHandler aih =
                          _pubSubRemoteSupport.getAIHByName(remSubName);
          final SIBUuid12 pseudoDestID = aih.getDestUuid();
  
          Runnable deleteAction = new Runnable()
          {
              @Override
              public void run()
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.entry(tc, "run");
  
                  try
                  {
                      // Actual delete happens here but we have to eat exceptions, yuck
                      LocalTransaction siTran =
                                      _baseDestinationHandler.
                                                      getTransactionManager().
                                                      createLocalTransaction(false);
  
                      boolean deleting =
                                      _pubSubRemoteSupport.
                                                      deleteRemoteDurableRME(subName, aih, siTran);
  
                      if (deleting)
                      {
                          _destinationManager.removePseudoDestination(pseudoDestID);
  
                          synchronized (_consumerDispatchersDurable)
                          {
                              // Remove the placeholder and signal anyone who happens to be
                              // waiting.
                              _consumerDispatchersDurable.remove(subName);
  
                              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                  SibTr.debug(tc, "Notifying all on " + _consumerDispatchersDurable);
                              _consumerDispatchersDurable.notifyAll();
                          }
                      }
  
                      siTran.commit();
                  } catch (Exception e)
                  {
                      // Have to FFDC, no other way to find out otherwise.
                      FFDCFilter.processException(
                                                  e,
                                                  "com.ibm.ws.sib.processor.impl.destination.PubSubRealization.run",
                                                  "1:3539:1.35.2.4",
                                                  this);
  
                      SibTr.error(
                                  tc,
                                  "INTERNAL_MESSAGING_ERROR_CWSIP0002",
                                  new Object[] {
                                                "com.ibm.ws.sib.processor.impl.destination.PubSubRealization",
                                                "1:3547:1.35.2.4",
                                                e });
  
                  }
  
                  // Test - see wait code below
                  synchronized (pseudoDestID)
                  {
                      pseudoDestID.notifyAll();
                  }
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "run");
              }
          };
  
          // Synchronize on a convenient object for delete
          // coordination below.
          synchronized (pseudoDestID)
          {
              synchronized (aih)
              {
                  if (!aih
                                  .testStreamStatus(
                                  AnycastInputHandler.AIStreamStatus.STREAM_NON_EXISTENT))
                  {
                      // Stream not yet flushed so have AIH call us when it's done
                      aih.addFlushedCallback(deleteAction);
                  }
                  else
                      // Stream must be flushed now so go ahead and run the delete action directly
                      deleteAction.run();
              }
          }
  
          // All done, return
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "deleteRemoteDurableRME");
      }