// Block the IP
        for (int i = 1; i <= 5; i++) {
            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");

    }

    /**
     * Manually unblock an IP
     *
     * @param sourceIp the IP to unblock
     * @return true if IP was unblocked, false if not found
     */
    public boolean unblockIp(String sourceIp) {
        IpAttempts ip = ipAttempts.get(sourceIp);
        if (ip != null) {
            ip.reset();
            log.info("Manually unblocked IP: {}", sourceIp);
            return true;
        }

  fun assertNoMoreTasks() {
    taskRunner.assertLockNotHeld()

    taskRunner.withLock {
      assertThat(activeThreads).isEqualTo(0)
    }
  }

  /** Unblock a waiting task thread. Used by the test thread only. */
  fun interruptCoordinatorThread() {
    taskRunner.assertLockNotHeld()
    require(currentTask == TestThreadSerialTask)

		return
	}
	if m.acked || m.outBlock == nil {
		return
	}
	available := cap(m.outBlock)
	for range available {
		m.outBlock <- struct{}{}
	}
	m.acked = true
}

func (m *muxClient) unblockSend(seq uint32) {
	if !m.checkSeq(seq) {
		return
	}
	select {
	case m.outBlock <- struct{}{}:
	default:
		gridLogIf(m.ctx, errors.New("output unblocked overflow"))
	}
}

		if !ok || mid == nil {
			resp(true)
			return
		}
		mid.respMu.Lock()
		resp(mid.closed)
		mid.respMu.Unlock()
	case debugBlockInboundMessages:
		c.connMu.Lock()
		a, _ := args[0].(chan struct{})
		block := (<-chan struct{})(a)
		c.blockMessages.Store(&block)
		c.connMu.Unlock()
	}
}

// wsWriter writes websocket messages.
type wsWriter struct {
	tmp [ws.MaxHeaderSize]byte
}

    connection.setReadTimeout(500)
    try {
      connection.getResponseCode()
      fail<Any>()
    } catch (expected: SocketTimeoutException) {
    }

    // Shutting down the server should unblock the dispatcher.
    server.shutdown()
  }

  @Test
  fun requestUrlReconstructed() {
    server.enqueue(MockResponse().setBody("hello world"))
    val url = server.url("/a/deep/path?key=foo%20bar").toUrl()

    connection.readTimeout = 500
    assertFailsWith<SocketTimeoutException> {
      connection.responseCode
    }

    // Closing the server should unblock the dispatcher.
    server.close()
  }

  @Test
  fun requestUrlReconstructed() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("hello world")
        .build(),

	// Caller may use this as an indication to call again.
	return !checkFailedUnlocks(*locks, tolerance)
}

// Unlock unlocks the write lock.
//
// It is a run-time error if dm is not locked on entry to Unlock.
func (dm *DRWMutex) Unlock(ctx context.Context) {
	dm.m.Lock()
	dm.cancelRefresh()
	dm.m.Unlock()

	restClnts, owner := dm.clnt.GetLockers()
	// create temp array on stack
	locks := make([]string, len(restClnts))

	sys.aMutex.Lock()
	defer sys.aMutex.Unlock()
	if v, ok := sys.arnErrsMap[arn]; !ok {
		sys.arnErrsMap[arn] = arnErrs{
			updateInProgress: true,
			count:            v.count + 1,
			bucket:           bucket,
		}
	}
}

func (sys *BucketTargetSys) markRefreshDone(bucket, arn string) {
	sys.aMutex.Lock()
	defer sys.aMutex.Unlock()
	if v, ok := sys.arnErrsMap[arn]; ok {

		globalHTTPStats.incS3RequestsIncoming()

		if r.Header.Get(globalObjectPerfUserMetadata) == "" {
			if val := globalServiceFreeze.Load(); val != nil {
				if unlock, ok := val.(chan struct{}); ok && unlock != nil {
					// Wait until unfrozen.
					select {
					case <-unlock:
					case <-r.Context().Done():
						// if client canceled we don't need to wait here forever.
						return
					}
				}
			}
		}