| `minio_node_ilm_transition_active_tasks`                     | Number of active ILM transition tasks.                                                                     |

	}
}

func (z *erasureServerPools) decommissionInBackground(ctx context.Context, idx int) error {
	pool := z.serverPools[idx]
	z.poolMetaMutex.RLock()
	pending := z.poolMeta.PendingBuckets(idx)
	z.poolMetaMutex.RUnlock()

	for _, bucket := range pending {
		z.poolMetaMutex.RLock()
		isDecommissioned := z.poolMeta.isBucketDecommissioned(idx, bucket.String())
		z.poolMetaMutex.RUnlock()
		if isDecommissioned {

            assertTrue(latch.await(500, TimeUnit.MILLISECONDS));
            assertTrue(response.isReceived());
        }

        @Test
        @DisplayName("Should handle async pending status")
        void testReceivedAsyncPending() throws InterruptedException {
            response.setAsync(true);
            response.setStatusForTest(NtStatus.NT_STATUS_PENDING);

                throw new DictionaryException("Failed to write: " + line, e);
            }
        }

        /**
         * Commits the changes to the dictionary file.
         * If there is a pending new item, it is written to the file.
         *
         * @return The committed item, or null if no item was committed.
         * @throws DictionaryException if an I/O error occurs.
         */

        public String exception;
        /** Cluster health status */
        public String status;
        /** Number of in-flight fetch operations */
        public int numberOfInFlightFetch;
        /** Number of pending tasks */
        public int numberOfPendingTasks;
        /** Number of delayed unassigned shards */
        public int delayedUnassignedShards;
        /** Number of unassigned shards */

	ReplicateIncomingDelete = "replicate:incoming:delete"

	// ReplicateHeal - audit trail for healing of failed/pending replications
	ReplicateHeal = "replicate:heal"
	// ReplicateHealDelete - audit trail of healing of failed/pending delete replications.
	ReplicateHealDelete = "replicate:heal:delete"
)

var (
	globalReplicationPool  = once.NewSingleton[ReplicationPool]()

)

const (
	// TransitionComplete marks completed transition
	TransitionComplete = "complete"
	// TransitionPending - transition is yet to be attempted
	TransitionPending = "pending"
)

// Action represents a delete action or other transition
// actions that will be implemented later.
type Action int

//go:generate stringer -type Action $GOFILE

const (

// This call may not block for execution of ops enqueued concurrently with this
// call.
TF_CAPI_EXPORT extern void TFE_ExecutorWaitForAllPendingNodes(
    TFE_Executor*, TF_Status* status);

// When an error happens, any pending operations are discarded, and newly issued
// ops return an error. This call clears the error state and re-enables
// execution of newly issued ops.
//

	batchKeyRotateAPIVersion           = "v1"
	batchKeyRotateJobDefaultRetries    = 3
	batchKeyRotateJobDefaultRetryDelay = 25 * time.Millisecond
)

// Start the batch key rottion job, resumes if there was a pending job via "job.ID"
func (r *BatchJobKeyRotateV1) Start(ctx context.Context, api ObjectLayer, job BatchJobRequest) error {
	ri := &batchJobInfo{
		JobID:     job.ID,
		JobType:   string(job.Type()),

     * `CollectionFuture.values`). This might be a no-op: If this future completed during
     * handleAllCompleted(), they will already have been nulled out. But in the case of
     * whenAll*().call*(), this future may be pending until the callback runs -- or even longer in
     * the case of callAsync(), which waits for the callback's returned future to complete.
     */
    releaseResources(ALL_INPUT_FUTURES_PROCESSED);
  }

  /**