// Initialize the pool meta, but set it to not save.
	// When z.Init below has loaded the poolmeta will be initialized,
	// and allowed to save.
	z.poolMeta = newPoolMeta(z, poolMeta{})
	z.poolMeta.dontSave = true

	bootstrapTrace("newSharedLock", func() {
		globalLeaderLock = newSharedLock(GlobalContext, z, "leader.lock")
	})

	// Start self healing after the object initialization

		return
	}

	const mapEntryOverhead = 200

	var (
		reader        io.Reader
		actualSize    int64 = -1
		fileName      string
		fanOutEntries = make([]minio.PutObjectFanOutEntry, 0, 100)
	)

	maxParts := 1000
	// Canonicalize the form values into http.Header.
	formValues := make(http.Header)
	var headerLen int64
	for {
		part, err := mp.NextRawPart()

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

package cmd

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *BucketReplicationStat) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--

func (z *allTierStats) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "ts"
	o = append(o, 0x81, 0xa2, 0x74, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.Tiers)))
	for za0001, za0002 := range z.Tiers {
		o = msgp.AppendString(o, za0001)
		// map header, size 3
		// string "ts"
		o = append(o, 0x83, 0xa2, 0x74, 0x73)
		o = msgp.AppendUint64(o, za0002.TotalSize)

	if z.ObjectV2 == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))
	if (zb0001Mask & 0x1) == 0 { // if not omitted
		// string "V2Obj"
		o = append(o, 0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
		if z.ObjectV2 == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 1
			// string "DDir"
			o = append(o, 0x81, 0xa4, 0x44, 0x44, 0x69, 0x72)

func (z *MRFReplicateEntries) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "e"
	o = append(o, 0x82, 0xa1, 0x65)
	o = msgp.AppendMapHeader(o, uint32(len(z.Entries)))
	for za0001, za0002 := range z.Entries {
		o = msgp.AppendString(o, za0001)
		// map header, size 3
		// string "b"
		o = append(o, 0x83, 0xa1, 0x62)
		o = msgp.AppendString(o, za0002.Bucket)

	// Get hashed payload.
	hashedPayload := req.Header.Get("x-amz-content-sha256")
	if hashedPayload == "" {
		return "", fmt.Errorf("Invalid hashed payload")
	}

	// Set x-amz-date.
	req.Header.Set("x-amz-date", currTime.Format(iso8601Format))

	// Get header map.
	headerMap := make(map[string][]string)
	for k, vv := range req.Header {
		// If request header key is not in ignored headers, then add it.

                }
                try (CurlResponse response = Curl.post(url)
                        .header("Authorization", "Bearer " + user.getAuthenticationResult().accessToken())
                        .header("Accept", "application/json")
                        .header("Content-type", "application/json")
                        .body("{\"securityEnabledOnly\":false}")
                        .execute()) {

}

// GetObjectNInfo - returns object info and an object
// Read(Closer). When err != nil, the returned reader is always nil.
func (er erasureObjects) GetObjectNInfo(ctx context.Context, bucket, object string, rs *HTTPRangeSpec, h http.Header, opts ObjectOptions) (gr *GetObjectReader, err error) {
	if !opts.NoAuditLog {
		auditObjectErasureSet(ctx, "GetObject", object, &er)
	}

    }
  }

  /**
   * On a concurrent computation that returns null, all threads should get an
   * InvalidCacheLoadException, with the loader only called once. The result should not be cached (a
   * later request should call the loader again).
   */
  private static void testConcurrentLoadingNull(CacheBuilder<Object, Object> builder)
      throws InterruptedException {

    int count = 10;