closerErr error
}

// NewObjectReadSeekCloser creates a new ObjectReadSeekCloser.
func NewObjectReadSeekCloser(segmentReader ObjectSegmentReaderFn, actualSize int64) *ObjectReadSeekCloser {
	return &ObjectReadSeekCloser{
		segmentReader: segmentReader,
		size:          actualSize,
		offset:        0,
		reader:        nil,
	}
}

// Seek call to implement io.Seeker

	oi := gr.ObjInfo

	defer func() {
		gr.Close()
		auditLogRebalance(ctx, "RebalanceCopyData", oi.Bucket, oi.Name, oi.VersionID, err)
	}()

	actualSize, err := oi.GetActualSize()
	if err != nil {
		return err
	}

	if oi.isMultipart() {
		res, err := z.NewMultipartUpload(ctx, bucket, oi.Name, ObjectOptions{
			VersionID:    oi.VersionID,

		},
		Parts: []ObjectPartInfo{
			{
				ETag:       "",
				Number:     1,
				Size:       329289,
				ActualSize: 329289,
				ModTime:    time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC),
				Index:      []uint8(nil),
				Checksums:  map[string]string(nil),
			},
		},
		Erasure: ErasureInfo{

	for _, partInfo := range objInfo.Parts {
		if isSSEC {
			hr, err = hash.NewReader(ctx, io.LimitReader(r, partInfo.Size), partInfo.Size, "", "", partInfo.ActualSize)
		} else {
			hr, err = hash.NewReader(ctx, io.LimitReader(r, partInfo.ActualSize), partInfo.ActualSize, "", "", partInfo.ActualSize)
		}
		if err != nil {
			return err
		}

		cHeader := http.Header{}
		cHeader.Add(xhttp.MinIOSourceReplicationRequest, "true")

	objInfo := gr.ObjInfo

	defer func() {
		gr.Close()
		auditLogDecom(ctx, "DecomCopyData", objInfo.Bucket, objInfo.Name, objInfo.VersionID, err)
	}()

	actualSize, err := objInfo.GetActualSize()
	if err != nil {
		return err
	}

	if objInfo.isMultipart() {
		res, err := z.NewMultipartUpload(ctx, bucket, objInfo.Name, ObjectOptions{
			VersionID:    objInfo.VersionID,

	rstate.ReplicateDecisionStr = dsc.String()
	asz, _ := oi.GetActualSize()

	r := ReplicateObjectInfo{
		Name:                       oi.Name,
		Size:                       oi.Size,
		ActualSize:                 asz,
		Bucket:                     oi.Bucket,
		VersionID:                  oi.VersionID,
		ETag:                       oi.ETag,
		ModTime:                    oi.ModTime,

		}

		erasureInfo := latestMeta.Erasure
		for partIndex := 0; partIndex < len(latestMeta.Parts); partIndex++ {
			partSize := latestMeta.Parts[partIndex].Size
			partActualSize := latestMeta.Parts[partIndex].ActualSize
			partModTime := latestMeta.Parts[partIndex].ModTime
			partNumber := latestMeta.Parts[partIndex].Number
			partIdx := latestMeta.Parts[partIndex].Index
			partChecksums := latestMeta.Parts[partIndex].Checksums

		for i := range fi.Parts {
			fi.Parts[i].Number = j.PartNumbers[i]
			fi.Parts[i].Size = j.PartSizes[i]
			if len(j.PartETags) == len(fi.Parts) {
				fi.Parts[i].ETag = j.PartETags[i]
			}
			fi.Parts[i].ActualSize = j.PartActualSizes[i]
			if len(j.PartIndices) == len(fi.Parts) {
				fi.Parts[i].Index = j.PartIndices[i]
			}
		}
	}

	// fi.Erasure.Checksums - is left empty since we do not have any

	// create xlStorage test setup
	xlStorage, _, err := newXLStorageTestSetup(t)
	if err != nil {
		t.Fatalf("Unable to cfgreate xlStorage test setup, %s", err)
	}

		if attemptInline {
			inlineBlock := globalStorageClass.InlineBlock()
			if inlineBlock <= 0 {
				inlineBlock = 128 * humanize.KiByte
			}

			canInline := fi.ShardFileSize(fi.Parts[0].ActualSize) <= inlineBlock
			if canInline {
				dataPath := pathJoin(volumeDir, path, fi.DataDir, fmt.Sprintf("part.%d", fi.Parts[0].Number))
				fi.Data, err = s.readAllData(ctx, volume, volumeDir, dataPath)
				if err != nil {