}
            return true;
        }

        // Check dynamically blocked IPs (Cache handles expiration automatically)
        final Boolean blocked = blockedIps.getIfPresent(ip);
        if (blocked != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("IP dynamically blocked: ip={}", ip);
            }
            return true;
        }

        return false;

        assertFalse("Path traversal should be blocked", result);
    }

    @Test
    public void test_isValidVirtualHostPath_pathTraversal_encoded() throws Exception {
        setupVirtualHostHelper("/site1", "/site2");

        Boolean result = invokeIsValidVirtualHostPath("/site1/../../../etc");
        assertFalse("Encoded path traversal should be blocked", result);
    }

    @Test

            this.mirroredRepositories = Collections.emptyList();
        }
    }

    @Override
    public boolean isBlocked() {
        return blocked;
    }

    @Override
    public void setBlocked(boolean blocked) {
        this.blocked = blocked;
    }

            logger.debug("Rate limit check: clientIp={}, path={}", clientIp, httpRequest.getRequestURI());
        }

        // Check if IP is blocked
        if (rateLimitHelper.isBlocked(clientIp)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Request blocked: clientIp={}", clientIp);
            }
            sendBlockedResponse(httpResponse);
            return;
        }

        // Check rate limit

    @Deprecated
    void setBlacklisted(boolean blackListed);

    /**
     * @return whether the repository is blocked
     * @since 3.8.1
     **/
    boolean isBlocked();

    /**
     * @param blocked block the repository?
     * @since 3.8.1
     **/
    void setBlocked(boolean blocked);

    //
    // New interface methods for the repository system.
    //
    /**
     *

            assertTrue(rateLimiter.checkAttempt("user" + i, ip));
            rateLimiter.recordFailure("user" + i, ip);
        }

        // Should be blocked
        assertFalse(rateLimiter.checkAttempt("user6", ip), "IP should be blocked");

        // Manually unblock
        assertTrue(rateLimiter.unblockIp(ip), "Manual unblock should succeed");

        // Should be allowed again

            this.mirroredRepositories = Collections.emptyList();
        }
    }

    @Override
    public boolean isBlocked() {
        return blocked;
    }

    @Override
    public void setBlocked(boolean blocked) {
        this.blocked = blocked;
    }

Returning any error will also cancel the stream remotely.

CAREFUL: When utilizing two-way communication, it is important to ensure that the remote handler is not blocked on a send.
If the remote handler is blocked on a send, and the client is trying to send without the remote receiving,
the operation would become deadlocked if the channels are full.

### Typed handlers

        final Path baseDir = tempFolder.getRoot().toPath();
        final Path traversalPath = baseDir.resolve("../../../etc/passwd");

        assertFalse("Path traversal should be blocked", FileUtil.isPathSafe(traversalPath, baseDir));
    }

    /**
     * Test isPathSafe with File objects
     *
     * @throws Exception
     */
    @Test

    // 1. the runner has been woken up
    // 2. the interrupter is stuck in the call the Thread.interrupt()

    // after some period of time the runner thread should become blocked on the task because it is
    // waiting for the slow interrupting thread to complete Thread.interrupt
    awaitBlockedOnInstanceOf(runner, InterruptibleTask.Blocker.class);