values.Set(peerRESTStorageClass, opts.storageClass)
	values.Set(peerRESTBucket, opts.bucketName)
	values.Set(peerRESTEnableSha256, strconv.FormatBool(opts.enableSha256))
	values.Set(peerRESTEnableMultipart, strconv.FormatBool(opts.enableMultipart))
	values.Set(peerRESTAccessKey, opts.creds.AccessKey)

	respBody, err := client.callWithContext(context.Background(), peerRESTMethodSpeedTest, values, nil, -1)

			storageRESTVolume:           volume,
			storageRESTFilePath:         path,
			storageRESTVersionID:        versionID,
			storageRESTInclFreeVersions: strconv.FormatBool(opts.InclFreeVersions),
			storageRESTHealing:          strconv.FormatBool(opts.Healing),
		}))
		if err != nil {
			return fi, toStorageErr(err)
		}
		return *resp, nil
	}

	values := make(url.Values)

	conn := client.gridConn()
	if conn == nil {
		return madmin.HealResultItem{}, nil
	}

	mss := grid.NewMSSWith(map[string]string{
		peerS3Bucket:        bucket,
		peerS3BucketDeleted: strconv.FormatBool(opts.Remove),
	})

	ctx, cancel := context.WithTimeout(ctx, globalDriveConfig.GetMaxTimeout())
	defer cancel()

	_, err := healBucketRPC.Call(ctx, conn, mss)

	// Initialize heal result info

		DeploymentType: r.Form.Get("deployment-type"),
	}
	result := objLayer.Health(ctx, opts)
	w.Header().Set(xhttp.MinIOWriteQuorum, strconv.Itoa(result.WriteQuorum))
	w.Header().Set(xhttp.MinIOStorageClassDefaults, strconv.FormatBool(result.UsingDefaults))
	// return how many drives are being healed if any
	if result.HealingDrives > 0 {
		w.Header().Set(xhttp.MinIOHealingDrives, strconv.Itoa(result.HealingDrives))
	}
	if !result.Healthy {

		authtype = "POST"
	}

	args := map[string][]string{
		"CurrentTime":      {currTime.Format(time.RFC3339)},
		"EpochTime":        {strconv.FormatInt(currTime.Unix(), 10)},
		"SecureTransport":  {strconv.FormatBool(r.TLS != nil)},
		"SourceIp":         {handlers.GetSourceIPRaw(r)},
		"UserAgent":        {r.UserAgent()},
		"Referer":          {r.Referer()},
		"principaltype":    {principalType},
		"userid":           {username},

		// If version is a deleted marker, set this header as well
		if objInfo.DeleteMarker && delete { // only returned during delete object
			w.Header()[xhttp.AmzDeleteMarker] = []string{strconv.FormatBool(objInfo.DeleteMarker)}
		}
	}

	if objInfo.Bucket != "" && objInfo.Name != "" {
		if lc, err := globalLifecycleSys.Get(objInfo.Bucket); err == nil && !delete {

		"profile=empty",
		"components.pilot.enabled=true",
		"revision=" + config.Revision,
		"values.revisionTags.[0]=" + config.Tag,
		"values.sidecarInjectorWebhook.enableNamespacesByDefault=" + strconv.FormatBool(opts.AutoInjectNamespaces),
		"values.istiodRemote.injectionURL=" + config.URL,
		"values.global.istioNamespace=" + config.IstioNamespace,
	}
	mfs, _, err := render.GenerateManifest(nil, flags, false, nil, nil)

		if objInfo.VersionID != "" && objInfo.DeleteMarker {
			w.Header()[xhttp.AmzVersionID] = []string{objInfo.VersionID}
			w.Header()[xhttp.AmzDeleteMarker] = []string{strconv.FormatBool(objInfo.DeleteMarker)}
		}
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// filter object lock metadata if permission does not permit

	}

	// TODO the defaults should be controlled by meshConfig/proxyConfig; if flags not given to the command proxyCOnfig takes precedence
	if dnsCapture {
		md["ISTIO_META_DNS_CAPTURE"] = strconv.FormatBool(dnsCapture)
	}
	if autoRegister {
		md["ISTIO_META_AUTO_REGISTER_GROUP"] = wg.Name
	}

	proxyConfig, err := protomarshal.ToJSONMap(meshConfig.DefaultConfig)
	if err != nil {
		return nil, err
	}

			if gr.ObjInfo.VersionID != "" && gr.ObjInfo.DeleteMarker {
				w.Header()[xhttp.AmzVersionID] = []string{gr.ObjInfo.VersionID}
				w.Header()[xhttp.AmzDeleteMarker] = []string{strconv.FormatBool(gr.ObjInfo.DeleteMarker)}
			}
		}
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}
	defer gr.Close()
	srcInfo := gr.ObjInfo

	actualPartSize, err := srcInfo.GetActualSize()