Thread.currentThread().interrupt();
            }
        }

        // Clean up expired weak references
        cleanupExpiredReferences();

        // Release all leases
        releaseAll();

        // Clear file cache
        fileCache.clear();
    }

    /**
     * Clean up expired weak references from the file cache
     */
    private void cleanupExpiredReferences() {

        List<SmbTransportImpl> toClose = new ArrayList<>(this.connections);
        toClose.addAll(this.nonPooledConnections);

        // Clear the collections (thread-safe operations)
        this.connections.clear();
        this.nonPooledConnections.clear();
        this.activeConnections.set(0);

        // Close all connections outside of synchronization
        for (final SmbTransportImpl conn : toClose) {

                ipAttempts.size());
    }

    /**
     * Reset all rate limiting state
     */
    public void reset() {
        accountAttempts.clear();
        ipAttempts.clear();
        globalAttemptsInCurrentWindow.set(0);
        currentWindowStart.set(System.currentTimeMillis());
        totalAttemptsBlocked.set(0);
        totalAccountsLocked.set(0);

        }
    }

    /**
     * Clears all session contexts (for cleanup).
     */
    public void cleanup() {
        for (PreauthIntegrityContext context : sessionContexts.values()) {
            context.invalidate();
        }
        sessionContexts.clear();
        log.debug("Cleaned up all preauth integrity contexts");
    }

        return key;
    }

    /**
     * Clear all stored keys
     */
    public void clearAllKeys() {
        checkNotClosed();

        log.info("Clearing all stored keys");

        // Wipe all raw keys
        for (Map.Entry<String, byte[]> entry : rawKeys.entrySet()) {
            Arrays.fill(entry.getValue(), (byte) 0);
        }
        rawKeys.clear();

        // Destroy all secret keys

        // Clear the filter
        urlFilter.clear();

        // After clear, all URLs should match (no filters applied)
        assertTrue(urlFilter.match("https://example.com/page"));
        assertTrue(urlFilter.match("https://other.com/page"));
        assertTrue(urlFilter.match("https://any.com/image.jpg"));
    }

    /**
     * Test clear method without initialization
     */

        List<CompletableFuture<Void>> taskFutures = new ArrayList<>(asyncNotifyTasks.values());
        for (CompletableFuture<Void> task : taskFutures) {
            task.cancel(true);
        }
        asyncNotifyTasks.clear();

        // Unregister all active registrations
        List<CompletableFuture<Void>> unregisterFutures = new ArrayList<>();

        for (WitnessRegistration registration : registrations.values()) {

        }

        assertEquals(5, keyManager.getKeyCount(), "Should have 5 keys");

        keyManager.clearAllKeys();

        assertEquals(0, keyManager.getKeyCount(), "Should have no keys after clear");

        // Verify all keys are removed
        for (int i = 0; i < 5; i++) {
            assertFalse(keyManager.hasSessionKey("session-" + i), "Key should be removed");
        }
    }

    @Test

				sys.hMutex.Unlock()
			}
			hcTimer.Reset(defaultHealthCheckDuration)
		case <-ctx.Done():
			return
		}
	}
}

// periodically rebuild the healthCheck map from list of targets to clear
// out stale endpoints
func (sys *BucketTargetSys) reloadHealthCheckers(ctx context.Context) {
	m := make(map[string]epHealth)
	tgts := sys.ListTargets(ctx, "", "")
	sys.hMutex.Lock()
	for _, t := range tgts {

        return count;
    }

    /**
     * Clears a scroll context.
     *
     * @param scrollId The scroll ID to clear.
     */
    public void clearScroll(final String scrollId) {
        if (scrollId != null) {
            prepareClearScroll().addScrollId(scrollId)
                    .execute(ActionListener.wrap(res -> {}, e -> logger.warn("Failed to clear " + scrollId, e)));
        }
    }

    /**