and costs (collectively "Losses") arising from claims, lawsuits and other
legal actions brought by a third party against the Indemnified Contributor
to the extent caused by the acts or omissions of such Commercial Contributor
in connection with its distribution of the Program in a commercial product
offering. The obligations in this section do not apply to any claims or Losses

 * All components may use this storage to associate arbitrary data with a session.
 * <p>
 * Unlike a cache, this session data is not subject to purging. For this same reason, session data should also not be
 * abused as a cache (i.e. for storing values that can be re-calculated) to avoid memory exhaustion.
 * <p>
 * <strong>Note:</strong> Actual implementations must be thread-safe.
 *
 * @see Session#getData()
 * @since 4.0.0
 */

        when(nonPooledSpy.disconnect(false, false)).thenReturn(false); // Not in use

        // When: Close the pool
        boolean inUse = pool.close();

        // Then: Should report in-use and call disconnect on all
        assertTrue(inUse, "Should report connections in use");
        verify(pooledSpy).disconnect(false, false);
        verify(nonPooledSpy).disconnect(false, false);
    }

     *
     * @param crawlerContext the crawler context
     * @param urlQueue the URL queue containing the failed URL
     * @param errorName the name/type of the error
     * @param e the throwable that caused the failure
     * @return the stored FailureUrl entity
     */
    protected FailureUrl storeFailureUrl(final CrawlerContext crawlerContext, final UrlQueue<?> urlQueue, final String errorName,

              return;
            }
          }
          // Remove the interrupt bit before each task. The interrupt is for the "current task" when
          // it is sent, so subsequent tasks in the queue should not be caused to be interrupted
          // by a previous one in the queue being interrupted.
          interruptedDuringTask |= Thread.interrupted();
          try {
            task.run();

        });
        this.failoverStates = new ConcurrentHashMap<>();
    }

    /**
     * Handle channel failure
     *
     * @param failedChannel failed channel
     * @param error error that caused failure
     */
    public void handleFailure(ChannelInfo failedChannel, Exception error) {
        log.warn("Channel {} failed: {}", failedChannel.getChannelId(), error.getMessage());

        // Mark channel as failed

    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    assertThat(response2.body.string()).isEqualTo("A")

    // Confirm that the connection was reused.
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(1)
  }

  /**

            } catch (final CIFSException e) {
                throw new SmbException("Logon share connection failed", e);
            }
        }
    }

    boolean treeDisconnect(final boolean inError, final boolean inUse) {
        boolean wasInUse = false;
        try (SmbSessionImpl sess = getSession(); SmbTransportImpl transport = sess.getTransport()) {
            synchronized (transport) {

          // TODO: Fix tests not to call this directly and make it throw an error.
          return null;
        }
      };

  /**
   * Returns a builder for creating simple, fast escapers. A builder instance can be reused and each
   * escaper that is created will be a snapshot of the current builder state. Builders are not
   * thread safe.
   *
   * <p>The initial state of the builder is such that:
   *
   * <ul>

- Temporary credentials have a limited lifetime, there is no need to rotate them or explicitly revoke them. Expired temporary credentials cannot be reused.

## Identity Federation