}
        });
    }

    /**
     * Perform the actual reconnection logic.
     * This method should be overridden by subclasses to provide the actual
     * SMB reconnection implementation.
     *
     * @param info the handle information
     * @return true if reconnection was successful
     * @throws Exception if reconnection fails
     */

    /**
     * Check if this handle is currently reconnecting
     * @return true if reconnecting
     */
    public boolean isReconnecting() {
        return reconnecting;
    }

    /**
     * Set the reconnecting state
     * @param reconnecting the reconnecting state
     */
    public void setReconnecting(boolean reconnecting) {
        this.reconnecting = reconnecting;
    }

    /**

import java.nio.ByteBuffer;
import java.util.UUID;

/**
 * Handle GUID structure for SMB2/3 durable and persistent handles.
 * Provides a unique identifier for each handle that can be used
 * for reconnection after network failures or server reboots.
 *
 * According to MS-SMB2, the GUID is a 16-byte structure with little-endian
 * byte ordering for the individual components.
 */
public class HandleGuid implements Serializable {

 */
public class HandleReconnectorTest {

    @Mock
    private PersistentHandleManager mockManager;

    private HandleReconnector reconnector;
    private HandleInfo testHandle;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
        reconnector = new HandleReconnector(mockManager, 2, 50); // 2 retries, 50ms delay

        HandleGuid guid = new HandleGuid();

     *            the security mode flags for the session
     * @param capabilities
     *            the client capabilities
     * @param previousSessionid
     *            the previous session ID for reconnection (or 0 for new session)
     * @param token
     *            the security token for authentication
     */

		break
	}
}

var healSleeper = newDynamicSleeper(5, time.Second, false)

// healRoutine listens to new disks reconnection events and
// issues healing requests for queued objects belonging to the
// corresponding erasure set
func (m *mrfState) healRoutine(z *erasureServerPools) {
	for {
		select {
		case <-GlobalContext.Done():

 */
interface Connection {
  /** Returns the route used by this connection. */
  fun route(): Route

  /**
   * Returns the socket that this connection is using. Returns an
   * [SSL socket][javax.net.ssl.SSLSocket] if this connection is HTTPS. If this is an HTTP/2
   * connection the socket may be shared by multiple concurrent calls.
   */
  fun socket(): Socket

import java.io.Closeable
import java.io.IOException
import java.util.concurrent.LinkedBlockingDeque
import okhttp3.internal.concurrent.TaskFaker
import okhttp3.internal.connection.RealConnection
import okhttp3.internal.connection.RoutePlanner
import okhttp3.internal.connection.RoutePlanner.ConnectResult

class FakeRoutePlanner(
  val factory: TestValueFactory = TestValueFactory(),
  val taskFaker: TaskFaker = factory.taskFaker,

import okhttp3.internal.concurrent.withLock
import okhttp3.internal.connection.CallConnectionUser
import okhttp3.internal.connection.ConnectionListener
import okhttp3.internal.connection.FastFallbackExchangeFinder
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okhttp3.internal.connection.RealConnectionPool
import okhttp3.internal.connection.RealRoutePlanner
import okhttp3.internal.connection.RouteDatabase

  override fun connectionReleased(connection: Connection) {
    eventListener.connectionReleased(call, connection)
  }

  override fun connectionConnectionAcquired(connection: RealConnection) {
    connection.connectionListener.connectionAcquired(connection, call)
  }

  override fun connectionConnectionReleased(connection: RealConnection) {
    connection.connectionListener.connectionReleased(connection, call)
  }