2019-01-17 13:58:18 +01:00
|
|
|
/*
|
2019-04-09 20:39:42 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2019 MinIO, Inc.
|
2019-01-17 13:58:18 +01:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
package cmd
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
2020-09-04 18:45:06 +02:00
|
|
|
"context"
|
2019-01-17 13:58:18 +01:00
|
|
|
"encoding/hex"
|
2019-10-01 22:12:15 +02:00
|
|
|
"fmt"
|
2019-01-17 13:58:18 +01:00
|
|
|
"hash"
|
|
|
|
"io"
|
|
|
|
|
|
|
|
"github.com/minio/minio/cmd/logger"
|
2021-03-30 02:00:55 +02:00
|
|
|
"github.com/minio/minio/pkg/ioutil"
|
2019-01-17 13:58:18 +01:00
|
|
|
)
|
|
|
|
|
2020-04-01 21:14:00 +02:00
|
|
|
type errHashMismatch struct {
|
|
|
|
message string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err *errHashMismatch) Error() string {
|
|
|
|
return err.message
|
|
|
|
}
|
|
|
|
|
2019-01-17 13:58:18 +01:00
|
|
|
// Calculates bitrot in chunks and writes the hash into the stream.
|
|
|
|
type streamingBitrotWriter struct {
|
2021-03-30 02:00:55 +02:00
|
|
|
iow io.WriteCloser
|
|
|
|
closeWithErr func(err error) error
|
|
|
|
h hash.Hash
|
|
|
|
shardSize int64
|
|
|
|
canClose chan struct{} // Needed to avoid race explained in Close() call.
|
2019-01-17 13:58:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (b *streamingBitrotWriter) Write(p []byte) (int, error) {
|
|
|
|
if len(p) == 0 {
|
|
|
|
return 0, nil
|
|
|
|
}
|
|
|
|
b.h.Reset()
|
|
|
|
b.h.Write(p)
|
|
|
|
hashBytes := b.h.Sum(nil)
|
2019-05-02 06:46:00 +02:00
|
|
|
_, err := b.iow.Write(hashBytes)
|
|
|
|
if err != nil {
|
2019-01-17 13:58:18 +01:00
|
|
|
return 0, err
|
|
|
|
}
|
2019-05-02 06:46:00 +02:00
|
|
|
return b.iow.Write(p)
|
2019-01-17 13:58:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (b *streamingBitrotWriter) Close() error {
|
|
|
|
err := b.iow.Close()
|
|
|
|
// Wait for all data to be written before returning else it causes race conditions.
|
|
|
|
// Race condition is because of io.PipeWriter implementation. i.e consider the following
|
|
|
|
// sequent of operations:
|
|
|
|
// 1) pipe.Write()
|
|
|
|
// 2) pipe.Close()
|
|
|
|
// Now pipe.Close() can return before the data is read on the other end of the pipe and written to the disk
|
|
|
|
// Hence an immediate Read() on the file can return incorrect data.
|
2021-03-30 02:00:55 +02:00
|
|
|
if b.canClose != nil {
|
|
|
|
<-b.canClose
|
|
|
|
}
|
2019-01-17 13:58:18 +01:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2021-03-30 02:00:55 +02:00
|
|
|
// Returns streaming bitrot writer implementation.
|
|
|
|
func newStreamingBitrotWriterBuffer(w io.Writer, algo BitrotAlgorithm, shardSize int64) io.WriteCloser {
|
|
|
|
return &streamingBitrotWriter{iow: ioutil.NopCloser(w), h: algo.New(), shardSize: shardSize, canClose: nil}
|
|
|
|
}
|
|
|
|
|
2019-01-17 13:58:18 +01:00
|
|
|
// Returns streaming bitrot writer implementation.
|
2021-03-18 22:09:55 +01:00
|
|
|
func newStreamingBitrotWriter(disk StorageAPI, volume, filePath string, length int64, algo BitrotAlgorithm, shardSize int64, heal bool) io.Writer {
|
2019-01-17 13:58:18 +01:00
|
|
|
r, w := io.Pipe()
|
|
|
|
h := algo.New()
|
2021-03-18 22:09:55 +01:00
|
|
|
|
2021-03-30 02:00:55 +02:00
|
|
|
bw := &streamingBitrotWriter{iow: w, closeWithErr: w.CloseWithError, h: h, shardSize: shardSize, canClose: make(chan struct{})}
|
|
|
|
|
2019-01-17 13:58:18 +01:00
|
|
|
go func() {
|
2019-05-01 01:27:31 +02:00
|
|
|
totalFileSize := int64(-1) // For compressed objects length will be unknown (represented by length=-1)
|
|
|
|
if length != -1 {
|
|
|
|
bitrotSumsTotalSize := ceilFrac(length, shardSize) * int64(h.Size()) // Size used for storing bitrot checksums.
|
|
|
|
totalFileSize = bitrotSumsTotalSize + length
|
|
|
|
}
|
2021-03-18 22:09:55 +01:00
|
|
|
r.CloseWithError(disk.CreateFile(context.TODO(), volume, filePath, totalFileSize, r))
|
2019-01-17 13:58:18 +01:00
|
|
|
close(bw.canClose)
|
|
|
|
}()
|
|
|
|
return bw
|
|
|
|
}
|
|
|
|
|
|
|
|
// ReadAt() implementation which verifies the bitrot hash available as part of the stream.
|
|
|
|
type streamingBitrotReader struct {
|
|
|
|
disk StorageAPI
|
2021-01-08 04:27:31 +01:00
|
|
|
data []byte
|
2021-01-03 20:27:57 +01:00
|
|
|
rc io.Reader
|
2019-01-17 13:58:18 +01:00
|
|
|
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
|
|
|
|
}
|
2021-01-03 20:27:57 +01:00
|
|
|
if closer, ok := b.rc.(io.Closer); ok {
|
|
|
|
return closer.Close()
|
|
|
|
}
|
|
|
|
return nil
|
2019-01-17 13:58:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
func (b *streamingBitrotReader) ReadAt(buf []byte, offset int64) (int, error) {
|
|
|
|
var err error
|
|
|
|
if offset%b.shardSize != 0 {
|
|
|
|
// Offset should always be aligned to b.shardSize
|
2019-05-02 06:46:00 +02:00
|
|
|
// Can never happen unless there are programmer bugs
|
2019-01-17 13:58:18 +01:00
|
|
|
return 0, errUnexpected
|
|
|
|
}
|
|
|
|
if b.rc == nil {
|
|
|
|
// For the first ReadAt() call we need to open the stream for reading.
|
|
|
|
b.currOffset = offset
|
|
|
|
streamOffset := (offset/b.shardSize)*int64(b.h.Size()) + offset
|
2021-03-30 02:00:55 +02:00
|
|
|
if len(b.data) == 0 && b.tillOffset != streamOffset {
|
2021-01-08 04:27:31 +01:00
|
|
|
b.rc, err = b.disk.ReadFileStream(context.TODO(), b.volume, b.filePath, streamOffset, b.tillOffset-streamOffset)
|
|
|
|
} else {
|
|
|
|
b.rc = io.NewSectionReader(bytes.NewReader(b.data), streamOffset, b.tillOffset-streamOffset)
|
|
|
|
}
|
2021-01-05 03:51:52 +01:00
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
2019-01-17 13:58:18 +01:00
|
|
|
}
|
|
|
|
}
|
2021-01-03 20:27:57 +01:00
|
|
|
|
2019-01-17 13:58:18 +01:00
|
|
|
if offset != b.currOffset {
|
2019-05-02 06:46:00 +02:00
|
|
|
// Can never happen unless there are programmer bugs
|
2019-01-17 13:58:18 +01:00
|
|
|
return 0, errUnexpected
|
|
|
|
}
|
|
|
|
b.h.Reset()
|
|
|
|
_, err = io.ReadFull(b.rc, b.hashBytes)
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
_, err = io.ReadFull(b.rc, buf)
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
b.h.Write(buf)
|
|
|
|
|
2019-02-13 13:59:36 +01:00
|
|
|
if !bytes.Equal(b.h.Sum(nil), b.hashBytes) {
|
2021-01-27 19:21:14 +01:00
|
|
|
logger.LogIf(GlobalContext, fmt.Errorf("Disk: %s -> %s/%s - content hash does not match - expected %s, got %s",
|
|
|
|
b.disk, b.volume, b.filePath, hex.EncodeToString(b.hashBytes), hex.EncodeToString(b.h.Sum(nil))))
|
|
|
|
return 0, errFileCorrupt
|
2019-01-17 13:58:18 +01:00
|
|
|
}
|
|
|
|
b.currOffset += int64(len(buf))
|
|
|
|
return len(buf), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns streaming bitrot reader implementation.
|
2021-01-08 04:27:31 +01:00
|
|
|
func newStreamingBitrotReader(disk StorageAPI, data []byte, volume, filePath string, tillOffset int64, algo BitrotAlgorithm, shardSize int64) *streamingBitrotReader {
|
2019-01-17 13:58:18 +01:00
|
|
|
h := algo.New()
|
|
|
|
return &streamingBitrotReader{
|
2021-03-30 02:00:55 +02:00
|
|
|
disk: disk,
|
|
|
|
data: data,
|
|
|
|
volume: volume,
|
|
|
|
filePath: filePath,
|
|
|
|
tillOffset: ceilFrac(tillOffset, shardSize)*int64(h.Size()) + tillOffset,
|
|
|
|
h: h,
|
|
|
|
shardSize: shardSize,
|
|
|
|
hashBytes: make([]byte, h.Size()),
|
2019-01-17 13:58:18 +01:00
|
|
|
}
|
|
|
|
}
|