// This allows another goroutine to close the reader.
	pr.mu.Lock()
	defer pr.mu.Unlock()
	if pr.rc == nil {
		return 0, io.EOF
	}
	return pr.rc.Read(p)
}

func (pr *syncReadCloser) Close() error {
	pr.mu.Lock()
	defer pr.mu.Unlock()
	if pr.rc != nil {
		err := pr.rc.Close()
		pr.rc = nil
		return err
	}
	return nil

	disk       StorageAPI
	data       []byte
	rc         io.Reader
	volume     string
	filePath   string
	tillOffset int64
	currOffset int64
	h          hash.Hash
	shardSize  int64
	hashBytes  []byte
}

func (b *streamingBitrotReader) Close() error {
	if b.rc == nil {
		return nil
	}
	if closer, ok := b.rc.(io.Closer); ok {
		// drain the body for connection reuse at network layer.

	if pr.closer != nil {
		pr.closer.Close()
	}
	return pr.rc.Close()
}

func (pr *progressReader) Stats() (bytesScanned, bytesProcessed int64) {
	if pr == nil {
		return 0, 0
	}
	return pr.scannedReader.BytesRead(), pr.processedReader.BytesRead()
}

func newProgressReader(rc io.ReadCloser, compType CompressionType) (*progressReader, error) {
	if rc == nil {

			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return
		}
		defer gr.Close()
		rc, err = file.Open(gr)
		if err != nil {
			writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
			return
		}
	} else {
		rc = io.NopCloser(bytes.NewReader([]byte{}))
	}

	defer rc.Close()

	if err = setObjectHeaders(w, fileObjInfo, nil, opts); err != nil {

							return
						}
					case "o":
						za0002.Object, err = dc.ReadString()
						if err != nil {
							err = msgp.WrapError(err, "Entries", za0001, "Object")
							return
						}
					case "rc":
						za0002.RetryCount, err = dc.ReadInt()
						if err != nil {
							err = msgp.WrapError(err, "Entries", za0001, "RetryCount")
							return
						}
					default:
						err = dc.Skip()

		DisableContentSha256: true,
	})
	return err
}

// GetFile implements ftpDriver
func (driver *ftpDriver) GetFile(ctx *ftp.Context, objPath string, offset int64) (n int64, rc io.ReadCloser, err error) {
	stopFn := globalFtpMetrics.log(ctx, objPath)
	defer stopFn(err)

	bucket, object := path2BucketObject(objPath)
	if bucket == "" {
		return 0, nil, errors.New("bucket name cannot be empty")

		if header.ModTime.UnixNano() <= 0 {
			header.ModTime = time.Now()
		}

		// Sync upload.
		rc := disconnectReader{r: tarReader}
		if err := putObject(&rc, header.FileInfo(), name); err != nil {
			rc.Close()
			if o.ignoreErrs {
				s3LogIf(ctx, err)
				continue
			}
			return err
		}
		rc.Close()
	}

}

type replicationAllStats struct {
	Targets      map[string]replicationStats `msg:"t,omitempty"`
	ReplicaSize  uint64                      `msg:"r,omitempty"`
	ReplicaCount uint64                      `msg:"rc,omitempty"`
}

//msgp:tuple replicationAllStatsV1
type replicationAllStatsV1 struct {
	Targets      map[string]replicationStats
	ReplicaSize  uint64 `msg:"ReplicaSize,omitempty"`

github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=

type MRFReplicateEntry struct {
	Bucket     string `json:"bucket" msg:"b"`
	Object     string `json:"object" msg:"o"`
	versionID  string `json:"-"`
	RetryCount int    `json:"retryCount" msg:"rc"`
	sz         int64  `json:"-"`
}

// MRFReplicateEntries has the map of MRF entries to save to disk
type MRFReplicateEntries struct {
	Entries map[string]MRFReplicateEntry `json:"entries" msg:"e"`