expStatus: replication.Pending,
	},
	{ // 3. replication status for one target - incorrect format
		name:      "replication status for one target",
		rs:        ReplicationState{ReplicationStatusInternal: "arn1=PENDING"},
		expStatus: replication.StatusType(""),
	},
	{ // 4. replication status for 3 targets, one of them failed
		name: "replication status for 3 targets - one failed",
		rs: ReplicationState{

package versioning

import (
	"encoding/xml"
	"io"
	"strings"

	"github.com/minio/pkg/v3/wildcard"
)

// State - enabled/disabled/suspended states
// for multifactor and status of versioning.
type State string

// Various supported states
const (
	Enabled State = "Enabled"
	// Disabled  State = "Disabled" only used by MFA Delete not supported yet.
	Suspended State = "Suspended"
)

var (

func (o *ObjectOptions) PutReplicationState() (r ReplicationState) {
	rstatus, ok := o.UserDefined[ReservedMetadataPrefixLower+ReplicationStatus]
	if !ok {
		return r
	}
	r.ReplicationStatusInternal = rstatus
	r.Targets = replicationStatusesMap(rstatus)
	return r
}

// SetEvalMetadataFn sets the metadata evaluation function

     */
    // GET /api/admin/stats
    @Execute
    public JsonResponse<ApiResult> index() {
        final HashMap<String, Object> stats = new HashMap<>();
        stats.put("jvm", getJvmObj());
        stats.put("os", getOsObj());
        stats.put("process", getProcessObj());
        stats.put("engine", getEngineObj());
        stats.put("fs", getFsObj());

    }

    /**
     * Represents the status of an API response.
     */
    public enum Status {
        /** Successful response status. */
        OK(0),
        /** Bad request status indicating client error. */
        BAD_REQUEST(1),
        /** System error status indicating server error. */
        SYSTEM_ERROR(2),
        /** Unauthorized status indicating authentication failure. */
        UNAUTHORIZED(3),

			return
		}
		switch msgp.UnsafeString(field) {
		case "Stats":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Stats")
				return
			}
			if z.Stats == nil {
				z.Stats = make(map[string]*BucketReplicationStat, zb0002)
			} else if len(z.Stats) > 0 {
				clear(z.Stats)
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string

    InputSerialization={
        'CSV': {
            "FileHeaderInfo": "USE",
        },
        'CompressionType': 'GZIP',
    },
    OutputSerialization={'CSV': {}},
)

for event in r['Payload']:
    if 'Records' in event:
        records = event['Records']['Payload'].decode('utf-8')
        print(records)
    elif 'Stats' in event:

			z.EndTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "EndTime")
				return
			}
		case "status":
			{
				var zb0002 uint8
				zb0002, err = dc.ReadUint8()
				if err != nil {
					err = msgp.WrapError(err, "Status")
					return
				}
				z.Status = rebalStatus(zb0002)
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return

        System.arraycopy(src, srcIndex + namesLength, this.macAddress, 0, 6);
        srcIndex += readNodeNameArray(src, srcIndex);
        this.stats = new byte[statsLength];
        System.arraycopy(src, srcIndex, this.stats, 0, statsLength);
        srcIndex += statsLength;
        return srcIndex - start;
    }

    private int readNodeNameArray(final byte[] src, int srcIndex) {

import (
	"errors"
	"fmt"
	"syscall"
)

// GetInfo returns total and free bytes available in a directory, e.g. `/`.
func GetInfo(path string, _ bool) (info Info, err error) {
	s := syscall.Statfs_t{}
	err = syscall.Statfs(path, &s)
	if err != nil {
		return Info{}, err
	}
	reservedBlocks := s.Bfree - uint64(s.Bavail)
	info = Info{
		Total:  uint64(s.Bsize) * (s.Blocks - reservedBlocks),
		Free:   uint64(s.Bsize) * uint64(s.Bavail),