docs: public void resolve(AIStreamKey key) throws SIResourceException
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
        SibTr.entry(tc, "resolve", key);
       
      RemoteQPConsumerKey ck = (RemoteQPConsumerKey)key.getRemoteDispatchableKey();
      ConsumableKey senderKey = ck.getConsumerPoint().getConsumerKey();
      
      boolean stillReady = false;
      boolean rckClosed = false;
  
      synchronized (_baseDestHandler.getReadyConsumerPointLock())
      {
        if (ck.isKeyReady())
        {
          stillReady = true; // is the consumer still ready
        }
        else if (senderKey.isKeyReady()) // If we are gathering then senderKey will be the GCK
        {
          // If we are here then the consumerKey that initiated the original request has been closed
          // but the containing gathering consumer key is still open so we want to do a request 
          // from a different rck
          rckClosed = true;
          stillReady = true; // is the consumer still ready
        }
        else 
        {
          // we update the prefetch info within the readyConsumerPointLock, since we want to avoid the
          // following ordered events: consumer is not ready -> this method releases the readyConsumerPointLock
          // -> consumer becomes ready and waiting but because there is an outstanding get, a get is not issued
          // -> this method decreases the outstanding gets by 1, resulting in a value of 0.
          // Now the consumer is waiting (possibly with infinite timeout), but no get has been issued.
          // So it can wait forever.
          // We use completedReceivedNoPrefetch() since we don't want this method to issue a get since
          // while we are holding the readyConsumerPointLock (as this lock is shared across all ConsumerPoints
          // and we don't want it to become a bottleneck)
          ck.completedReceivedNoPrefetch(key, false);
        }
      }
  
      if (!stillReady)
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
          SibTr.exit(tc, "resolve");
        // since the consumer is not ready, we don't care if get request was not satisfied
        return;
      }
  
      // must try to reissue the get if possible
      if (!rckClosed)
        ck.completedReceived(key, true); 
      else // original rck is closed but we have the gathering parent
      {
        // Cancel the original request state
        ck.completedReceived(key, false); 
        
        // reissue the request on another rck
        if (key.getOriginalTimeout() == SIMPConstants.INFINITE_TIMEOUT)
        {
          // Original consumerkey has been closed so reissue Get on the gathering consumerKey
          senderKey.waiting(key.getOriginalTimeout(), false);
        }
        else
        {
          // non-infinite timeout. see if there is enough time left to reissue get
          long currTime = System.currentTimeMillis();
          long expectedResponseTime = currTime + _aih.getRoundTripTime();
          long timeoutTime = key.getIssueTime() + key.getOriginalTimeout();
          if (expectedResponseTime < timeoutTime)
          {
            // Original consumerkey has been closed so reissue Get on the gathering consumerKey
            senderKey.waiting(timeoutTime - currTime, false);
          }
        }                
      }
        
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
        SibTr.exit(tc, "resolve");
    }