# go build -trimpath to build the binary.
	export GOOS=$os
	export GOARCH=$arch
	export MINIO_RELEASE=RELEASE
	LDFLAGS=$(go run buildscripts/gen-ldflags.go)
	go build -tags kqueue -trimpath --ldflags "${LDFLAGS}" -o ./minio-${arch}.${release}
	minisign -qQSm ./minio-${arch}.${release} -s "$CRED_DIR/minisign.key" <"$CRED_DIR/minisign-passphrase"

	sha256sum_str=$(sha256sum <./minio-${arch}.${release})

   *
   * @param queue the queue to be wrapped in a synchronized view
   * @return a synchronized view of the specified queue
   * @since 14.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Queue<E> synchronizedQueue(Queue<E> queue) {
    return Synchronized.queue(queue, null);
  }

  /**

   *
   * @param queue the queue to be wrapped in a synchronized view
   * @return a synchronized view of the specified queue
   * @since 14.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Queue<E> synchronizedQueue(Queue<E> queue) {
    return Synchronized.queue(queue, null);
  }

  /**

    /**
     * QueueHolder holds the waiting and crawling queues.
     */
    protected static class QueueHolder {
        /**
         * Constructs a new QueueHolder.
         */
        public QueueHolder() {
            // Default constructor
        }

        /**
         * The queue for URLs waiting to be crawled.
         */
        protected Queue<OpenSearchUrlQueue> waitingQueue = new ConcurrentLinkedQueue<>();

    assertEquals(1, Queues.newLinkedBlockingDeque(1).remainingCapacity());
    assertEquals(11, Queues.newLinkedBlockingDeque(11).remainingCapacity());
  }

  public void testNewLinkedBlockingQueueCapacity() {
    assertThrows(IllegalArgumentException.class, () -> Queues.newLinkedBlockingQueue(0));
    assertEquals(1, Queues.newLinkedBlockingQueue(1).remainingCapacity());

    dispatcher.maxRequests = 2
    client.newCall(newRequest("http://a/1")).enqueue(callback)
    client.newCall(newRequest("http://b/1")).enqueue(callback)
    client.newCall(newRequest("http://c/1")).enqueue(callback)
    client.newCall(newRequest("http://a/2")).enqueue(callback)
    client.newCall(newRequest("http://b/2")).enqueue(callback)

    val dispatcherQueueStartC1 = eventRecorder.removeUpToEvent<DispatcherQueueStart>()

            if ("https://example.com/page1".equals(queue.getUrl())) {
                foundPage1 = true;
                assertEquals("GET", queue.getMethod());
                assertEquals("https://example.com", queue.getParentUrl());
                assertEquals(Long.valueOf(123456789L), queue.getLastModified());
            } else if ("https://example.com/page2".equals(queue.getUrl())) {
                foundPage2 = true;

 * executor, it should be able to run [the configured maximum][maxRequests] number of calls
 * concurrently.
 */
class Dispatcher() {
  /**
   * The maximum number of requests to execute concurrently. Above this requests queue in memory,
   * waiting for the running calls to complete.
   *
   * If more than [maxRequests] requests are in flight when this is invoked, those requests will
   * remain in flight.
   */
  @get:Synchronized

  // instance for every unit test.
  MockWebServer server = new MockWebServer();

  // Schedule some responses.
  server.enqueue(new MockResponse.Builder()
      .body("hello, world!")
      .build());
  server.enqueue(new MockResponse.Builder()
      .body("sup, bra?")
      .build());
  server.enqueue(new MockResponse.Builder()
      .body("yo dog")
      .build());

  // Start the server.
  server.start();

    }

    /**
     * Adds a URL to the crawling queue.
     * @param url The URL to add.
     */
    public void addUrl(final String url) {
        try {
            urlQueueService.add(crawlerContext.sessionId, url);
            if (logger.isDebugEnabled()) {
                logger.debug("Added URL to queue: url={}, sessionId={}", url, crawlerContext.sessionId);
            }