func (s *xlStorage) readMetadataWithDMTime(ctx context.Context, itemPath string) ([]byte, time.Time, error) {
	if contextCanceled(ctx) {
		return nil, time.Time{}, ctx.Err()
	}

	if err := checkPathLength(itemPath); err != nil {
		return nil, time.Time{}, err
	}

	f, err := OpenFile(itemPath, readMode, 0o666)
	if err != nil {
		return nil, time.Time{}, err
	}
	defer f.Close()
	stat, err := f.Stat()
	if err != nil {

- Fine grained filtering is available to pick relevant objects from source to copy from

MinIO batch jobs framework also provides

- Retrying a failed job automatically driven by user input
- Monitoring job progress in real-time
- Send notifications upon completion or failure to user configured target

Following YAML describes the structure of a replication job, each value is documented and self-describing.

```yaml
replicate:
  apiVersion: v1

	if !exists {
		return
	}

	var dur time.Duration
	if !bgSeq.lastHealActivity.IsZero() {
		dur = time.Since(bgSeq.lastHealActivity)
	}

	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(
			prometheus.BuildFQName(healMetricsNamespace, "time", "since_last_activity"),

        assertEquals(0x20, response.fileAttributes);
    }

    @Test
    void testSetLastWriteTime() {
        long time = System.currentTimeMillis();
        response.lastWriteTime = time;
        assertEquals(time, response.lastWriteTime);
    }

    @Test
    void testSetDataSize() {
        response.dataSize = 1024;
        assertEquals(1024, response.dataSize);
    }

            assertTrue(scheduler.containsKey("running"));
            isRunning = (Boolean) scheduler.get("running");

        }
        if (300 <= count) {
            logger.info("Time out: Crawler takes too much time");
            //TODO fail(); // Time Out
        }

        logger.info("Crawler terminated");
    }

    protected static String createWebConfig(final Map<String, Object> requestBody) {

	}

	// objProps represents properties that go beyond a single version
	type objProps struct {
		succModTime time.Time
		numVersions int
	}
	// Find the successor mod time and numVersions in quorum, otherwise leave the
	// candidate as found
	otherPropsMap := make(counterMap[objProps])
	var candidate FileInfo
	var found bool

            if (maxAge > 0) {
                try {
                    final long time = getCurrentTime() / 1000 - Long.parseLong(values[0]);
                    if (time > maxAge || time < 0) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("role info is expired: {} > {}", time, maxAge);
                        }
                        return;
                    }

		return errServerNotInitialized
	}

	started := tracker.Started
	if started.IsZero() || started.Equal(timeSentinel) {
		healingLogIf(ctx, fmt.Errorf("unexpected tracker healing start time found: %v", started))
		started = time.Time{}
	}

	// Final tracer update before quitting
	defer func() {
		tracker.setObject("")
		tracker.setBucket("")
		healingLogIf(ctx, tracker.update(ctx))
	}()

        };

        for (long[] times : timeValues) {
            // Given
            FileBasicInfo info = new FileBasicInfo(times[0], // create time
                    times[1], // last access time
                    times[2], // last write time
                    times[3], // change time
                    TEST_ATTRIBUTES);

            // When & Then
            assertEquals(times[0], info.getCreateTime());

		select {
		case <-ctx.Done():
			return ctx.Err()
		default:
			// Sleep and stagger to avoid blocked CPU and thundering
			// herd upon start up sequence.
			time.Sleep(25*time.Millisecond + time.Duration(rand.Int63n(int64(100*time.Millisecond))))
			retries++
			// after 20 retries start logging that servers are not reachable yet
			if retries >= 20 {