/** Runnable is not running and not queued for execution */
    IDLE,
    /** Runnable is not running, but is being queued for execution */
    QUEUING,
    /** runnable has been submitted but has not yet begun execution */
    QUEUED,
    RUNNING,
  }

  /** Underlying executor that all submitted Runnable objects are run on. */
  private final Executor executor;

  @GuardedBy("queue")

| `minio_cluster_replication_last_minute_queued_count`       | Total number of objects queued for replication in the last full minute                                   |
| `minio_cluster_replication_last_minute_queued_bytes`       | Total number of bytes queued for replication in the last full minute                                     |

	// Total number of replica received
	ReplicaCount int64 `json:"replicaCount"`
	// Queued operations
	Queued InQueueMetric `json:"queued"`
	// Proxy stats
	Proxied ProxyMetric `json:"proxied"`
	// replication metrics summary for each site replication peer
	Metrics map[string]SRMetric `json:"replMetrics"`
	// uptime of node being queried for site replication metrics
	Uptime int64 `json:"uptime"`

// but not written in all disks (having quorum)
type partialOperation struct {
	bucket              string
	object              string
	versionID           string
	versions            []byte
	setIndex, poolIndex int
	queued              time.Time
	scanMode            madmin.HealScanMode
}

// mrfState sncapsulates all the information
// related to the global background MRF.
type mrfState struct {
	opCh chan partialOperation
}

    ready.await()
    assertThat(dispatcher.runningCallsCount()).isEqualTo(2)
    assertThat(dispatcher.queuedCallsCount()).isEqualTo(0)
    assertThat(dispatcher.runningCalls())
      .containsExactlyInAnyOrder(a1, a2)
    assertThat(dispatcher.queuedCalls()).isEmpty()

    // Cancel some calls. That doesn't impact running or queued.
    a2.cancel()
    a3.cancel()

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();
    assertEquals("One event dispatch task should be queued.", 1, tasks.size());

    tasks.get(0).run();

    assertEquals("One event should be delivered.", 1, events.size());
    assertEquals("Correct string should be delivered.", EVENT, events.get(0));
  }

  /**

    /**
     * Used to update and read the latestTaskQueue field. Set to null once the runnable has been run
     * or queued.
     */
    @CheckForNull ExecutionSequencer sequencer;

    /**
     * Executor the task was set to run on. Set to null when the task has been queued, run, or
     * cancelled.
     */
    @CheckForNull Executor delegate;

    /**

          "expr": "sum by (server) (minio_cluster_replication_average_queued_bytes{job=\"$scrape_jobs\"})",
          "interval": "1m",
          "intervalFactor": 2,
          "legendFormat": "{{server}}",
          "refId": "A"
        }
      ],
      "thresholds": [],
      "timeRegions": [],
      "title": "Avg. Queued Size",
      "tooltip": {
        "shared": true,
        "sort": 0,

const (
	_ TargetType = iota
	TargetConsole
	TargetHTTP
	TargetKafka
)

// TargetStats contains statistics for a target.
type TargetStats struct {
	// QueueLength is the queue length if any messages are queued.
	QueueLength int

	// TotalMessages is the total number of messages sent in the lifetime of the target
	TotalMessages int64

	// FailedMessages should log message count that failed to send.

      logger.info("served $requestLine")
      return MockResponse(code = HttpURLConnection.HTTP_NOT_FOUND)
    }

    if (failFastResponse != null && responseQueue.peek() == null) {
      // Fail fast if there's no response queued up.
      return failFastResponse!!
    }

    val result = responseQueue.take()

    // If take() returned because we're shutting down, then enqueue another dead letter so that any