return nil
	}

	for _, disk := range driveMetrics.storageInfo.Disks {
		labels := []string{
			driveL, disk.DrivePath,
			poolIndexL, strconv.Itoa(disk.PoolIndex),
			setIndexL, strconv.Itoa(disk.SetIndex),
			driveIndexL, strconv.Itoa(disk.DiskIndex),
		}

		m.setDriveBasicMetrics(disk, labels)
		if dm, found := driveMetrics.ioStats[disk.DrivePath]; found {
			m.setDriveIOStatMetrics(dm, labels)
		}

        SuggestUtil.getAsList(123);
    }

    @Test
    public void testDeleteByQuery() {
        // Create test data
        client.prepareIndex().setIndex(TEST_INDEX).setId("1").setSource("field", "value1").execute().actionGet();
        client.prepareIndex().setIndex(TEST_INDEX).setId("2").setSource("field", "value2").execute().actionGet();
        client.admin().indices().prepareRefresh(TEST_INDEX).execute().actionGet();

					healOnce.Do(func() {
						globalMRFState.addPartialOp(PartialOperation{
							Bucket:     bucket,
							Object:     object,
							VersionID:  fi.VersionID,
							Queued:     time.Now(),
							SetIndex:   er.setIndex,
							PoolIndex:  er.poolIndex,
							BitrotScan: errors.Is(err, errFileCorrupt),
						})
					})
					// Healing is triggered and we have written
					// successfully the content to client for

            do {
                curReq.setResponse(curResp);

                final ServerMessageBlock nextReq = curReq.getAndx();
                if (nextReq == null) {
                    break;
                }
                final ServerMessageBlock nextResp = curResp.getAndx();
                nextReq.setResponse(nextReq);

		poolInfo, ok := poolsInfo[d.PoolIndex]
		if !ok {
			poolInfo = make(map[int]madmin.ErasureSetInfo)
		}
		erasureSet, ok := poolInfo[d.SetIndex]
		if !ok {
			erasureSet.ID = d.SetIndex
			cache := dataUsageCache{}
			if err := cache.load(ctx, z.serverPools[d.PoolIndex].sets[d.SetIndex], dataUsageCacheName); err == nil {
				dataUsageInfo := cache.dui(dataUsageRoot, nil)
				erasureSet.ObjectsCount = dataUsageInfo.ObjectsTotalCount

            this.andxCommand = (byte) andx.getCommand();
        }
    }

    /**
     * Gets the chained AndX command
     * @return the andx
     */
    public final ServerMessageBlock getAndx() {
        return this.andx;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#getNext()
     */
    @Override

	if !opts.Speedtest && len(versions) > 0 {
		globalMRFState.addPartialOp(PartialOperation{
			Bucket:    bucket,
			Object:    object,
			Queued:    time.Now(),
			Versions:  versions,
			SetIndex:  er.setIndex,
			PoolIndex: er.poolIndex,
		})
	}

	if !opts.Speedtest && len(versions) == 0 {
		// Check if there is any offline disk and add it to the MRF list
		for _, disk := range onlineDisks {

        try {
            final FessConfig fessConfig = ComponentUtil.getFessConfig();
            final UpdateRequestBuilder builder =
                    ComponentUtil.getSearchEngineClient().prepareUpdate().setIndex(fessConfig.getIndexDocumentUpdateIndex()).setId(id);
            builderLambda.accept(builder);
            final UpdateResponse response = builder.execute().actionGet(fessConfig.getIndexIndexTimeout());

			if ok {
				continue
			}
		}

		if disk.PoolIndex > -1 && disk.SetIndex > -1 {
			if disk.State == madmin.DriveStateOk {
				si := erasureSetUpCount[disk.PoolIndex][disk.SetIndex]
				si.online++
				if disk.Healing {
					si.healing++
					drivesHealing++
				}
				erasureSetUpCount[disk.PoolIndex][disk.SetIndex] = si
			}
		}
	}

	b := z.BackendInfo()

		opts.Error = fmt.Sprintf("unable to heal %d missing blocks on drives", b)
	}

	opts.Tags = map[string]string{
		"healObject": auditObjectOp{
			Name: opts.Object,
			Pool: er.poolIndex + 1,
			Set:  er.setIndex + 1,
		}.String(),
	}

	auditLogInternal(ctx, opts)
}

func objectErrToDriveState(reason error) string {
	switch {
	case reason == nil:
		return madmin.DriveStateOk