HandleReconnector reconnector = new HandleReconnector(handleManager);
        try {
            SmbFile reconnected = reconnector.reconnectHandle(this, e).get(5, TimeUnit.SECONDS);
            // Update this file's state from reconnected file
            this.fileId = reconnected.fileId;
        } catch (Exception reconnectError) {
            log.error("Failed to reconnect durable handle", reconnectError);

        super(connection.getURL());
        this.connection = connection;
        requestProperties = new HashMap();
    }

    @Override
    public void connect() throws IOException {
        if (connected) {
            return;
        }
        connection.connect();
        connected = true;
    }

    private void handshake() throws IOException {
        if (handshakeComplete) {
            return;
        }

                }
            }
        }
        return null;
    }

    /**
     * Get the durable handle reconnect response if present
     * @return the durable handle reconnect response or null if not present
     */
    public jcifs.internal.smb2.persistent.DurableHandleReconnectResponse getDurableHandleReconnectResponse() {
        if (this.createContexts != null) {

        .execute(() -> {
            try {
                transport.disconnect();
                transport.connect();  // Reconnect
                log.info("Successfully reconnected after witness notification");
            } catch (Exception e) {
                log.error("Failed to reconnect after witness notification", e);
            }
        });
}

private void scheduleAddressChange(InetAddress newAddress) {

        this.setInstanceFollowRedirects(this.connection.getInstanceFollowRedirects());
    }

    @Override
    public void connect() throws IOException {
        if (this.connected) {
            return;
        }
        this.connection.connect();
        this.connected = true;
    }

    private void handshake() {
        if (this.handshakeComplete) {
            return;
        }

                    "DHnC", // Durable handle reconnect
                    "AlSi", // Allocation size
                    "MxAc", // Max access
                    "TWrp", // Timewarp
                    "QFid", // Query on disk ID
                    "RqLs", // Request lease
                    "DH2Q", // Durable handle request V2
                    "DH2C", // Durable handle reconnect V2
                    "ExtA", // Extended attributes

    }

    /**
     * Test that connect() calls connect() on the underlying connection.
     * @throws IOException
     */
    @Test
    void testConnect() throws Exception {
        // Act
        ntlmConnection.connect();

        // Assert
        verify(mockConnection).connect();
        // Connection should be established after connect
    }

    /**

            if (info != null && !info.isExpired()) {
                info.setReconnecting(true);
                info.updateAccessTime();
                log.debug("Found handle for reconnect: {}", path);
                return info;
            }
            return null;
        } finally {
            lock.readLock().unlock();
        }
    }

    /**

	return client.endpoint.String()
}

// IsOnline - returns whether client failed to connect or not.
func (client *storageRESTClient) IsOnline() bool {
	return client.restClient.IsOnline() || client.IsOnlineWS()
}

// IsOnlineWS - returns whether websocket client failed to connect or not.
func (client *storageRESTClient) IsOnlineWS() bool {
	return client.gridConn.State() == grid.StateConnected
}

     *
     * @return the registration timeout
     */
    long getWitnessRegistrationTimeout();

    /**
     * Gets the witness reconnect delay in milliseconds.
     *
     * @return the reconnect delay
     */
    long getWitnessReconnectDelay();

    /**
     * Gets whether witness service discovery is enabled.
     *
     * @return true if discovery is enabled