go func() {
			timer := time.NewTicker(10 * time.Second)
			defer timer.Stop()
			defaultKey := env.Get(EnvKESDefaultKey, "")
			for {
				select {
				case <-ctx.Done():
					return
				case <-timer.C:
					client.DescribeKey(ctx, defaultKey)
				}
			}
		}()

		return &KMS{
			Type:       MinKES,
			DefaultKey: env.Get(EnvKESDefaultKey, ""),
			conn: &kesConn{

func lockMaintenance(ctx context.Context) {
	if !globalIsDistErasure {
		return
	}

	// Initialize a new ticker with 1 minute between each ticks.
	lkTimer := time.NewTimer(lockMaintenanceInterval)
	// Stop the timer upon returning.
	defer lkTimer.Stop()

	for {
		// Verifies every minute for locks held more than 2 minutes.
		select {
		case <-ctx.Done():
			return
		case <-lkTimer.C:

}

// Load config from backend
func Load(configFile string, data interface{}) (quick.Config, error) {
	return quick.LoadConfig(configFile, globalEtcdClient, data)
}

func readConfigWithoutMigrate(ctx context.Context, objAPI ObjectLayer) (config.Config, error) {
	// Construct path to config.json for the given bucket.
	configFile := path.Join(minioConfigPrefix, minioConfigFile)

	configFiles := []string{
		getConfigFile(),

import (
	"context"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	xioutil "github.com/minio/minio/internal/ioutil"
)

const (
	retryInterval = 3 * time.Second
)

type logger = func(ctx context.Context, err error, id string, errKind ...interface{})

// ErrNotConnected - indicates that the target connection is not active.
var ErrNotConnected = errors.New("not connected to target server/service")

	sysCPUSystemMD    = NewGaugeMD(sysCPUSystem, "CPU system time")
	sysCPUUserMD      = NewGaugeMD(sysCPUUser, "CPU user time")
)

// loadCPUMetrics - `MetricsLoaderFn` for system CPU metrics.
func loadCPUMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	cpuMetrics, _ := c.cpuMetrics.Get()

	if cpuMetrics.LoadStat != nil {
		m.Set(sysCPULoad, cpuMetrics.LoadStat.Load1)

	if _, ok := tx.ConnPool.(*gorm.PreparedStmtDB); !ok {
		t.Fatalf("should assign PreparedStatement Manager back to database when using PrepareStmt mode")
	}

	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()
	txCtx := tx.WithContext(ctx)

	user := *GetUser("prepared_stmt", Config{})

	txCtx.Create(&user)

	var result1 User
	if err := txCtx.Find(&result1, user.ID).Error; err != nil {

MinIO places new objects in server pools based on proportionate free space, per pool. Following pseudo code demonstrates this behavior.

```go
func getAvailablePoolIdx(ctx context.Context) int {
        serverPools := z.getServerPoolsAvailableSpace(ctx)
        total := serverPools.TotalAvailable()
        // choose when we reach this many
        choose := rand.Uint64() % total
        atTotal := uint64(0)

     */
    @AfterClass
    public static void closeContexts () throws CIFSException {
        for ( Entry<String, CIFSContext> ctx : CONTEXT_CACHE.entrySet() ) {
            if ( ctx.getValue().close() ) {
                log.error("Context was still in use " + ctx.getKey());
            }
        }
    }


    static CIFSContext getCachedContext ( String context, Properties props ) throws CIFSException {

 *
 * `numerical_grad` is the pointer to the AbstractTensorHandle* which will
 * hold the numerical gradient data at the end of the function.
 */
absl::Status CalcNumericalGrad(AbstractContext* ctx, Model forward,
                               absl::Span<AbstractTensorHandle* const> inputs,
                               int input_index, bool use_function,
                               AbstractTensorHandle** numerical_grad);

// return an error, the returned loader will return that error.
func JoinLoaders(loaders ...MetricsLoaderFn) MetricsLoaderFn {
	return func(ctx context.Context, m MetricValues, c *metricsCache) error {
		for _, loader := range loaders {
			if err := loader(ctx, m, c); err != nil {
				return err
			}
		}
		return nil
	}
}

// BucketMetricsLoaderFn - represents a function to load metrics from the