try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IOException("Interrupted waiting for send credit", e);
            }
        }
        
        if (!rdmaConnection.canSend()) {
            throw new IOException("Timeout waiting for RDMA send credit");
        }
    }
    

            executor.awaitTermination(executorTerminationTimeout, TimeUnit.SECONDS);
        } catch (final InterruptedException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Executor shutdown interrupted", e);
            }
        } finally {
            executor.shutdownNow();
        }

        synchronized (indexUpdateCallback) {
            if (!deleteUrlList.isEmpty()) {

 * in a few ways:
 *
 * <ul>
 *   <li>Each task may be associated with a different executor.
 *   <li>Tasks may be of type {@code AsyncCallable}.
 *   <li>Running tasks <i>cannot</i> be interrupted. (Note that {@code newSequentialExecutor} does
 *       not return {@code Future} objects, so it doesn't support interruption directly, either.

   * Returns a future that delegates to another but will finish early (via a {@link
   * TimeoutException} wrapped in an {@link ExecutionException}) if the specified duration expires.
   *
   * <p>The delegate future is interrupted and cancelled if it times out.
   *
   * @param delegate The future to delegate to.
   * @param time when to time out the future
   * @param scheduledExecutor The executor service to enforce the timeout.

     *
     * @param consumer Consumer function to configure the bulk request builder
     * @return true if all bulk operations were successful, false otherwise
     * @throws InterruptedRuntimeException if the operation is interrupted
     * @throws SearchEngineClientException if the bulk update fails
     */
    public boolean bulkUpdate(final Consumer<BulkRequestBuilder> consumer) {

            }
            wait() // Wait until we receive a WINDOW_UPDATE.
          }
        } catch (e: InterruptedException) {
          Thread.currentThread().interrupt() // Retain interrupted status.
          throw InterruptedIOException()
        }

        toWrite = minOf(byteCount, writeBytesMaximum - writeBytesTotal).toInt()
        toWrite = minOf(toWrite, writer.maxDataLength())

 *  Fix: Reverse suppression of connect exceptions. When both a call and its retry fail, we now
    throw the initial exception which is most likely to be actionable.
 *  Fix: Retain interrupted state when throwing `InterruptedIOException`. A single interrupt should
    now be sufficient to break out an in-flight OkHttp call.
 *  Fix: Don't drop a call to `EventListener.callEnd()` when the response body is consumed inside an

                    return this.treeHandle;

                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new SmbException("Connection retry interrupted", ie);
                } catch (CIFSException retryException) {
                    log.debug("Connection retry also failed", retryException);
                    throw e; // Throw original exception
                }

                        }
                        break;
                    } catch (final InterruptedException e) {
                        final InterruptedIOException ie = new InterruptedIOException("Interrupted while acquiring credits");
                        ie.initCause(e);
                        throw ie;
                    }
                } else {
                    // not enough credits available or too big, split

    Firefox’s ‘copy as cURL’ features.

 *  New: Support [JPMS]. We replaced our `Automatic-Module-Name` metadata with proper
    `module-info.java` files.

 *  Fix: Recover gracefully when worker threads are interrupted. When we introduced fast fallback in
    OkHttp 5.0, we started using background threads while connecting. Sadly that code didn't handle
    interruptions well. This is now fixed.