}

        return needsRotation;
    }

    /**
     * Reset key rotation tracking after new keys are established
     */
    public void resetKeyRotationTracking() {
        bytesEncrypted.set(0);
        encryptionStartTime = System.currentTimeMillis();
        log.debug("Key rotation tracking reset");
    }

   * from the remote peer. Existing streams are not impacted. This is intended to permit an endpoint
   * to gracefully stop accepting new requests without harming previously established streams.
   */
  @Throws(IOException::class)
  fun shutdown(statusCode: ErrorCode) {
    writer.withLock {
      val lastGoodStreamId: Int
      withLock {
        if (isShutdown) {
          return

    duplex request bodies. Such interceptors should check `RequestBody.isDuplex()` and avoid
    accessing the request body when it is.

    Duplex calls require HTTP/2. If HTTP/1 is established instead the duplex call will fail. The
    most common use of duplex calls is [gRPC][grpc_http2].

 *  New: Prevent OkHttp from retransmitting a request body by overriding `RequestBody.isOneShot()`.

        channel1 = new ChannelInfo("channel1", mockTransport1, local, remote1);
        channel1.setState(ChannelState.ESTABLISHED);

        channel2 = new ChannelInfo("channel2", mockTransport2, local, remote2);
        channel2.setState(ChannelState.ESTABLISHED);
    }

    @Test
    void testSingleChannelSelection() {

// after the limit is reached blocks until some inflight nodes finishes.
// The effect is bounding the memory held by inflight TensorHandles that are
// referenced by the inflight nodes.
// A recommended value has not been established.
// A value of 0 removes the limit, which is the behavior of TensorFlow 2.11.
// When is_async is false, the value is ignored.
TF_CAPI_EXPORT extern TFE_Executor* TFE_NewExecutor(

            // Connection would be ensured through proper transport interface

            // Re-establish channel binding
            manager.performChannelBinding(channel);

            // Update channel with new transport
            channel.setTransport(newTransport);
            channel.setState(ChannelState.ESTABLISHED);

            // Clear failover state on success

			healthy := erasureSetUpCount[poolIdx][setIdx].online >= poolWriteQuorums[poolIdx]
			if !healthy && !opts.NoLogging {
				storageLogIf(logger.SetReqInfo(ctx, reqInfo),
					fmt.Errorf("Write quorum could not be established on pool: %d, set: %d, expected write quorum: %d, drives-online: %d",
						poolIdx, setIdx, poolWriteQuorums[poolIdx], erasureSetUpCount[poolIdx][setIdx].online), logger.FatalKind)
			}

        failedChannel = new ChannelInfo("failed-channel", mockTransport, localInterface, remoteInterface);
        failedChannel.setState(ChannelState.ESTABLISHED);

        when(mockChannelManager.getLoadBalancer()).thenReturn(mockLoadBalancer);
    }

    @Test
    void testHandleFailure() {
        IOException error = new IOException("Connection failed");

        ChannelInfo healthyChannel = new ChannelInfo("test-channel", mockTransport, localInterface, remoteInterface);
        healthyChannel.setState(ChannelState.ESTABLISHED);

        // Use reflection or package-private method to add channel for testing
        // For now, just test the empty case
        assertEquals(0, channelManager.getHealthyChannels().size());
    }

            }
            switch (this.sbuf[0] & 0xFF) {
            case SessionServicePacket.POSITIVE_SESSION_RESPONSE:
                if (log.isDebugEnabled()) {
                    log.debug("session established ok with " + this.address);
                }
                return;
            case SessionServicePacket.NEGATIVE_SESSION_RESPONSE:
                final int errorCode = this.in.read() & 0xFF;