hs := madmin.HealOpts{
		// Remove objects that do not have read-quorum
		Remove: healDeleteDangling,
	}

	return &healSequence{
		startTime:   UTCNow(),
		clientToken: bgHealingUUID,
		// run-background heal with reserved bucket
		bucket:   minioReservedBucket,
		settings: hs,
		currentStatus: healSequenceStatus{
			Summary:      healNotStartedStatus,

            final CrawlerClient client) {
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final long startTime = systemHelper.getCurrentTimeAsLong();
        final CrawlerStatsHelper crawlerStatsHelper = ComponentUtil.getCrawlerStatsHelper();

        configProps.put(ConfigurationProperties.USER_AGENT, getUserAgent());
        configProps.put(ConfigurationProperties.INTERACTIVE, request.isInteractiveMode());
        configProps.put("maven.startTime", request.getStartTime());
        configProps.put(Constants.MAVEN_START_INSTANT, request.getStartInstant());

        sessionBuilder.setOffline(request.isOffline());

			}
			b, err := json.Marshal(madmin.HealStartSuccess{
				ClientToken:   clientToken,
				ClientAddress: nh.clientAddress,
				StartTime:     nh.startTime,
			})
			if err != nil {
				writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
				return
			}
			// Client token not specified but a heal sequence exists on a path,

            if (logger.isDebugEnabled()) {
                logger.debug("[scheduleParentGroupLookup] Async task started for user: {}", user.getName());
            }
            final long startTime = System.currentTimeMillis();
            try {
                final List<String> updatedGroups = new ArrayList<>(initialGroups);
                final List<String> updatedRoles = new ArrayList<>(initialRoles);

			internalLogOnceIf(ctx, err, string(nodeMetricNamespace))
			return metrics
		}

		openFDs, _ := p.FileDescriptorsLen()
		l, _ := p.Limits()
		io, _ := p.IO()
		stat, _ := p.Stat()
		startTime, _ := stat.StartTime()

		metrics = make([]MetricV2, 0, 20)

		if openFDs > 0 {
			metrics = append(metrics,
				MetricV2{
					Description: getMinioFDOpenMD(),
					Value:       float64(openFDs),

     */
    protected void waitForYellowStatus(final FessConfig fessConfig) {
        Exception cause = null;
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final long startTime = systemHelper.getCurrentTimeAsLong();
        for (int i = 0; i < maxEsStatusRetry; i++) {
            try {
                final ClusterHealthResponse response = client.admin()
                        .cluster()

		if populatedUploadIDs.Contains(uploadID) {
			continue
		}
		// If present, use time stored in ID.
		startTime := time.Now()
		if split := strings.Split(uploadID, "x"); len(split) == 2 {
			t, err := strconv.ParseInt(split[1], 10, 64)
			if err == nil {
				startTime = time.Unix(0, t)
			}
		}
		uploads = append(uploads, MultipartInfo{
			Bucket:    bucket,
			Object:    object,

func (r *BatchJobKeyRotateV1) Start(ctx context.Context, api ObjectLayer, job BatchJobRequest) error {
	ri := &batchJobInfo{
		JobID:     job.ID,
		JobType:   string(job.Type()),
		StartTime: job.Started,
	}
	if err := ri.loadOrInit(ctx, api, job); err != nil {
		return err
	}
	if ri.Complete {
		return nil
	}

	globalBatchJobsMetrics.save(job.ID, ri)
	lastObject := ri.Object

            return true;
        }
        final long startTime = getCurrentTimeAsLong();
        final String threadName = Thread.currentThread().getName();
        try {
            waitingThreadNames.add(threadName);
            while (current >= percent) {
                if (timeoutInMillis > 0 && getCurrentTimeAsLong() - startTime > timeoutInMillis) {
                    if (logger.isInfoEnabled()) {