// Add a transient bucket.
	// Start saver when object layer is ready.
	go func() {
		objAPI := newObjectLayerFn()
		for objAPI == nil {
			time.Sleep(time.Second)
			objAPI = newObjectLayerFn()
		}

		t := time.NewTicker(time.Minute)
		defer t.Stop()

		var exit bool
		for !exit {
			select {
			case <-t.C:
			case <-GlobalContext.Done():
				exit = true
			}
			m.mu.RLock()

    /**
     * Gets the file creation time.
     *
     * @return the creation time in milliseconds since epoch
     */
    long createTime();

    /**
     * Gets the last modified time.
     *
     * @return the last modified time in milliseconds since epoch
     */
    long lastModified();

    /**
     * Gets the last access time.
     *

pkg crypto/x509, type RevocationList struct, NextUpdate time.Time
pkg crypto/x509, type RevocationList struct, Number *big.Int
pkg crypto/x509, type RevocationList struct, RevokedCertificates []pkix.RevokedCertificate
pkg crypto/x509, type RevocationList struct, SignatureAlgorithm SignatureAlgorithm
pkg crypto/x509, type RevocationList struct, ThisUpdate time.Time
pkg database/sql, method (*DB) SetConnMaxIdleTime(time.Duration)

   * returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the
   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.

        // Verify that the central time zone is returned
        assertNotNull(result);
        assertEquals(FessUserTimeZoneProcessProvider.centralTimeZone, result);
        assertEquals(TimeZone.getDefault(), result);
    }

    // Test getRequestedTimeZone() with different default time zone
    public void test_getRequestedTimeZone_withDifferentDefaultTimeZone() {
        // Store original time zone

	avg := rl.UploadHistogram.GetAvgData()
	for k, v := range avg {
		// Convert nanoseconds to milliseconds
		ret[sizeTagToString(k)] = uint64(v.avg() / time.Millisecond)
	}
	return
}

// Update replication upload latency with a new value
func (rl *ReplicationLatency) update(size int64, duration time.Duration) {
	rl.UploadHistogram.Add(size, duration)
}

// ReplicationLastMinute has last minute replication counters

//
//msgp:tuple VolInfo
type VolInfo struct {
	// Name of the volume.
	Name string

	// Date and time when the volume was created.
	Created time.Time

	// total VolInfo counts
	count int

	// Date and time when the volume was deleted, if Deleted
	Deleted time.Time
}

// FilesInfo represent a list of files, additionally
// indicates if the list is last.
//
//msgp:tuple FileInfo

    }

    /**
     * @param time
     * @return
     */
    private long convertTime(final long time) {
        return time + this.serverTimeZoneOffset;
    }

    @Override
    public long getLastWriteTime() {
        return convertTime(this.lastWriteTime);
    }

    @Override
    public long getLastAccessTime() {
        // Fake access time
        return convertTime(this.lastWriteTime);
    }

	pluginAuthnServiceLastSuccSecondsMD      = NewCounterMD(pluginAuthnServiceLastSuccSeconds, "When plugin authentication is configured, returns time (in seconds) since the last successful request to the service")

	// difference between newer and current release.
	t := time.Time{}
	newerThan := humanize.RelTime(t, t.Add(older), "before the latest release", "")

	if globalServerCtxt.JSON {
		return fmt.Sprintf("You are running an older version of MinIO released %s, update: %s", newerThan, downloadURL)
	}

	// Return the nicely colored and formatted update message.