docs: private void executeOneRevoctionStatusCheck(
        SFPair<Certificate, Certificate> pairIssuerSubject, long currentTimeSecond,
        String peerHost)
    throws IOException, CertificateException
    {
      OCSPReq req = createRequest(pairIssuerSubject);
      CertID cid = req.getRequestList()[0].getCertID().toASN1Primitive();
      OcspResponseCacheKey keyOcspResponse = new OcspResponseCacheKey(
          cid.getIssuerNameHash().getEncoded(),
          cid.getIssuerKeyHash().getEncoded(),
          cid.getSerialNumber().getValue());
      String hostSpecSSD = null;
  
      long sleepTime = INITIAL_SLEEPING_TIME_IN_MILLISECONDS;
      DecorrelatedJitterBackoff backoff = new DecorrelatedJitterBackoff(
          sleepTime, MAX_SLEEPING_TIME_IN_MILLISECONDS);
      CertificateException error = null;
      boolean success = false;
      for (int retry = 0; retry < MAX_RETRY_COUNTER; ++retry)
      {
        /**
         * Look for Host Specific SSD in SSD Cache
         */
        if (ssdManager.getSSDSupportStatus())
        {
          boolean retval = false;
          SFPair<Long, String> resp = OCSP_RESPONSE_CACHE.get(ssdManager.getWildCardCertId());
          if ((hostSpecSSD = ssdManager.getSSDFromCache()) != null)
          {
            try
            {
              retval = this.processOCSPBypassSSD(hostSpecSSD, keyOcspResponse, peerHost);
              if (retval)
              {
                success = true;
                break;
              }
              else
              {
                /* remove invalid entry from SSD Cache */
                ssdManager.clearSSDCache();
              }
            }
            catch (Throwable ex)
            {
              LOGGER.info("Unable to process Host Specific OCSP Response. Removing" +
                          "it from the SSD Cache");
              ssdManager.clearSSDCache();
            }
          }
          else if (resp.right != null)
          {
            /**
             * Process WildCard SSD if present
             */
            if (this.processOCSPBypassSSD(resp.right, ssdManager.getWildCardCertId(), "*"))
            {
              success = true;
              break;
            }
            else
            {
              /**
               * Delete WildCard from cache
               */
              LOGGER.info("Found invalid wildcard SSD in cache, removing.");
              OCSP_RESPONSE_CACHE.remove(ssdManager.getWildCardCertId());
            }
          }
        }
        SFPair<Long, String> value0 = OCSP_RESPONSE_CACHE.get(keyOcspResponse);
        OCSPResp ocspResp;
        try
        {
          if (value0 == null)
          {
            LOGGER.debug("not hit cache.");
            ocspResp = fetchOcspResponse(pairIssuerSubject, req,
                                         encodeCacheKey(keyOcspResponse), peerHost);
  
            OCSP_RESPONSE_CACHE.put(
                keyOcspResponse, SFPair.of(currentTimeSecond,
                                           ocspResponseToB64(ocspResp)));
            WAS_CACHE_UPDATED = true;
            value0 = SFPair.of(currentTimeSecond,
                               ocspResponseToB64(ocspResp));
          }
  
          LOGGER.debug("validating. {}",
                       CertificateIDToString(req.getRequestList()[0].getCertID()));
          try
          {
            validateRevocationStatusMain(pairIssuerSubject, value0.right);
            success = true;
            break;
          }
          catch (Throwable ex)
          {
            if (ssdManager.getSSDSupportStatus())
            {
              /**
               *  Failed processing OCSP response
               *  Try processing cache value as SSD
               */
              if (this.processOCSPBypassSSD(value0.right, keyOcspResponse, peerHost))
              {
                success = true;
                break;
              }
              else
              {
                throw ex;
              }
            }
            else
            {
              throw ex;
            }
          }
        }
        catch (CertificateException ex)
        {
          if (OCSP_RESPONSE_CACHE.containsKey(keyOcspResponse))
          {
            LOGGER.debug("deleting the invalid OCSP cache.");
            OCSP_RESPONSE_CACHE.remove(keyOcspResponse);
            WAS_CACHE_UPDATED = true;
          }
          error = ex;
          LOGGER.debug("Retrying {}/{} after sleeping {}(ms)",
                       retry + 1, MAX_RETRY_COUNTER, sleepTime);
          try
          {
            Thread.sleep(sleepTime);
            sleepTime = backoff.nextSleepTime(sleepTime);
          }
          catch (InterruptedException ex0)
          { // nop
          }
        }
      }
      if (!success)
      {
        // still not success, raise an error.
        throw error;
      }
    }