interfaceTxBytes  MetricName = "tx_bytes"
	interfaceTxErrors MetricName = "tx_errors"

	// cpu stats
	cpuUser       MetricName = "user"
	cpuSystem     MetricName = "system"
	cpuIOWait     MetricName = "iowait"
	cpuIdle       MetricName = "idle"
	cpuNice       MetricName = "nice"
	cpuSteal      MetricName = "steal"
	cpuLoad1      MetricName = "load1"
	cpuLoad5      MetricName = "load5"
	cpuLoad15     MetricName = "load15"

| `minio_node_cpu_avg_idle_max`        | CPU idle time (max).                       |
| `minio_node_cpu_avg_iowait`          | CPU ioWait time.                           |
| `minio_node_cpu_avg_iowait_avg`      | CPU ioWait time (avg).                     |
| `minio_node_cpu_avg_iowait_max`      | CPU ioWait time (max).                     |
| `minio_node_cpu_avg_nice`            | CPU nice time.                             |

	Mandatory         bool        `json:"mandatory"`
	Immediate         bool        `json:"immediate"`
	Durable           bool        `json:"durable"`
	Internal          bool        `json:"internal"`
	NoWait            bool        `json:"noWait"`
	AutoDeleted       bool        `json:"autoDeleted"`
	PublisherConfirms bool        `json:"publisherConfirms"`
	QueueDir          string      `json:"queueDir"`
	QueueLimit        uint64      `json:"queueLimit"`

						// proceed to heal nonetheless, since
						// this object might be dangling.
						entry, _ = entries.firstFound()
					}
					wait := noWait
					if f.weSleep() {
						// wait timer per object.
						wait = scannerSleeper.Timer(ctx)
					}
					defer wait()
					f.updateCurrentPath(entry.name)
					stopFn := globalScannerMetrics.log(scannerMetricHealAbandonedObject, f.root, entry.name)

    /*
     * An uninterruptible wait on a Condition requires different logic than an uninterruptible wait
     * on most other types: In cases in which we "should" receive both an interrupt and a
     * notification nearly simultaneously, we sometimes receive only an interrupt. Thus, when we're
     * interrupted, we can't just poll whether it's time to end the wait because our "end the wait"

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    startLatch.await(); // Wait for all threads to be ready

                    for (int i = 0; i < opsPerThread; i++) {
                        String share = "share" + (threadId % 3); // Use 3 different shares

                        // WAIT #1
                        barrier.await(1, SECONDS);

                        // WAIT #2
                        barrier.await(1, SECONDS);
                        assertTrue(executor.isShutdown());
                        assertFalse(executor.isTerminated());

                        // WAIT #3
                        barrier.await(1, SECONDS);
                        return null;

                        // WAIT #1
                        barrier.await(1, SECONDS);

                        // WAIT #2
                        barrier.await(1, SECONDS);
                        assertTrue(executor.isShutdown());
                        assertFalse(executor.isTerminated());

                        // WAIT #3
                        barrier.await(1, SECONDS);
                        return null;

            });

            longRunningThread.start();
            startLatch.await();

            // Check active requests
            assertEquals(1, cbWithTracking.getActiveRequests(), "Should have 1 active request");

            // Complete the operation
            holdLatch.countDown();
            completeLatch.await();
            longRunningThread.join();

                        startLatch.await();
                        response.received();
                        endLatch.countDown();
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                }).start();
            }

            startLatch.countDown();
            assertTrue(endLatch.await(1, TimeUnit.SECONDS));