mirror of
https://github.com/minio/minio
synced 2024-07-20 09:57:03 +00:00
80ca120088
Each Put, List, Multipart operations heavily rely on making GetBucketInfo() call to verify if bucket exists or not on a regular basis. This has a large performance cost when there are tons of servers involved. We did optimize this part by vectorizing the bucket calls, however its not enough, beyond 100 nodes and this becomes fairly visible in terms of performance.
793 lines
23 KiB
Go
793 lines
23 KiB
Go
// Copyright (c) 2015-2021 MinIO, Inc.
|
|
//
|
|
// This file is part of MinIO Object Storage stack
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/minio/madmin-go/v3"
|
|
)
|
|
|
|
// Returns the latest updated FileInfo files and error in case of failure.
|
|
func getLatestFileInfo(ctx context.Context, partsMetadata []FileInfo, defaultParityCount int, errs []error) (FileInfo, error) {
|
|
// There should be at least half correct entries, if not return failure
|
|
expectedRQuorum := len(partsMetadata) / 2
|
|
if defaultParityCount == 0 {
|
|
// if parity count is '0', we expected all entries to be present.
|
|
expectedRQuorum = len(partsMetadata)
|
|
}
|
|
|
|
reducedErr := reduceReadQuorumErrs(ctx, errs, objectOpIgnoredErrs, expectedRQuorum)
|
|
if reducedErr != nil {
|
|
return FileInfo{}, reducedErr
|
|
}
|
|
|
|
// List all the file commit ids from parts metadata.
|
|
modTimes := listObjectModtimes(partsMetadata, errs)
|
|
|
|
// Count all latest updated FileInfo values
|
|
var count int
|
|
var latestFileInfo FileInfo
|
|
|
|
// Reduce list of UUIDs to a single common value - i.e. the last updated Time
|
|
modTime := commonTime(modTimes, expectedRQuorum)
|
|
|
|
if modTime.IsZero() || modTime.Equal(timeSentinel) {
|
|
return FileInfo{}, errErasureReadQuorum
|
|
}
|
|
|
|
// Iterate through all the modTimes and count the FileInfo(s) with latest time.
|
|
for index, t := range modTimes {
|
|
if partsMetadata[index].IsValid() && t.Equal(modTime) {
|
|
latestFileInfo = partsMetadata[index]
|
|
count++
|
|
}
|
|
}
|
|
|
|
if !latestFileInfo.IsValid() {
|
|
return FileInfo{}, errErasureReadQuorum
|
|
}
|
|
|
|
if count < latestFileInfo.Erasure.DataBlocks {
|
|
return FileInfo{}, errErasureReadQuorum
|
|
}
|
|
|
|
return latestFileInfo, nil
|
|
}
|
|
|
|
// validates functionality provided to find most common
|
|
// time occurrence from a list of time.
|
|
func TestCommonTime(t *testing.T) {
|
|
// List of test cases for common modTime.
|
|
testCases := []struct {
|
|
times []time.Time
|
|
time time.Time
|
|
quorum int
|
|
}{
|
|
{
|
|
// 1. Tests common times when slice has varying time elements.
|
|
[]time.Time{
|
|
time.Unix(0, 1).UTC(),
|
|
time.Unix(0, 2).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 2).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 1).UTC(),
|
|
},
|
|
time.Unix(0, 3).UTC(),
|
|
3,
|
|
},
|
|
{
|
|
// 2. Tests common time obtained when all elements are equal.
|
|
[]time.Time{
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
},
|
|
time.Unix(0, 3).UTC(),
|
|
4,
|
|
},
|
|
{
|
|
// 3. Tests common time obtained when elements have a mixture of
|
|
// sentinel values and don't have read quorum on any of the values.
|
|
[]time.Time{
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 2).UTC(),
|
|
time.Unix(0, 1).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
time.Unix(0, 4).UTC(),
|
|
time.Unix(0, 3).UTC(),
|
|
timeSentinel,
|
|
timeSentinel,
|
|
timeSentinel,
|
|
},
|
|
timeSentinel,
|
|
5,
|
|
},
|
|
}
|
|
|
|
// Tests all the testcases, and validates them against expected
|
|
// common modtime. Tests fail if modtime does not match.
|
|
for i, testCase := range testCases {
|
|
// Obtain a common mod time from modTimes slice.
|
|
ctime := commonTime(testCase.times, testCase.quorum)
|
|
if !testCase.time.Equal(ctime) {
|
|
t.Errorf("Test case %d, expect to pass but failed. Wanted modTime: %s, got modTime: %s\n", i+1, testCase.time, ctime)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestListOnlineDisks - checks if listOnlineDisks and outDatedDisks
|
|
// are consistent with each other.
|
|
func TestListOnlineDisks(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
obj, disks, err := prepareErasure16(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Prepare Erasure backend failed - %v", err)
|
|
}
|
|
setObjectLayer(obj)
|
|
defer obj.Shutdown(context.Background())
|
|
defer removeRoots(disks)
|
|
|
|
type tamperKind int
|
|
const (
|
|
noTamper tamperKind = iota
|
|
deletePart
|
|
corruptPart
|
|
)
|
|
|
|
timeSentinel := time.Unix(1, 0).UTC()
|
|
threeNanoSecs := time.Unix(3, 0).UTC()
|
|
fourNanoSecs := time.Unix(4, 0).UTC()
|
|
modTimesThreeNone := make([]time.Time, 16)
|
|
modTimesThreeFour := make([]time.Time, 16)
|
|
for i := 0; i < 16; i++ {
|
|
// Have 13 good xl.meta, 12 for default parity count = 4 (EC:4) and one
|
|
// to be tampered with.
|
|
if i > 12 {
|
|
modTimesThreeFour[i] = fourNanoSecs
|
|
modTimesThreeNone[i] = timeSentinel
|
|
continue
|
|
}
|
|
modTimesThreeFour[i] = threeNanoSecs
|
|
modTimesThreeNone[i] = threeNanoSecs
|
|
}
|
|
|
|
testCases := []struct {
|
|
modTimes []time.Time
|
|
expectedTime time.Time
|
|
errs []error
|
|
_tamperBackend tamperKind
|
|
}{
|
|
{
|
|
modTimes: modTimesThreeFour,
|
|
expectedTime: threeNanoSecs,
|
|
errs: []error{
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
},
|
|
_tamperBackend: noTamper,
|
|
},
|
|
{
|
|
modTimes: modTimesThreeNone,
|
|
expectedTime: threeNanoSecs,
|
|
errs: []error{
|
|
// Disks that have a valid xl.meta.
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
nil, nil, nil, nil, nil,
|
|
// Some disks can't access xl.meta.
|
|
errFileNotFound, errDiskAccessDenied, errDiskNotFound,
|
|
},
|
|
_tamperBackend: deletePart,
|
|
},
|
|
{
|
|
modTimes: modTimesThreeNone,
|
|
expectedTime: threeNanoSecs,
|
|
errs: []error{
|
|
// Disks that have a valid xl.meta.
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
nil, nil, nil, nil, nil,
|
|
// Some disks don't have xl.meta.
|
|
errDiskNotFound, errFileNotFound, errFileNotFound,
|
|
},
|
|
_tamperBackend: corruptPart,
|
|
},
|
|
}
|
|
|
|
bucket := "bucket"
|
|
err = obj.MakeBucket(ctx, "bucket", MakeBucketOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to make a bucket %v", err)
|
|
}
|
|
|
|
object := "object"
|
|
data := bytes.Repeat([]byte("a"), smallFileThreshold*16)
|
|
z := obj.(*erasureServerPools)
|
|
|
|
erasureDisks, err := z.GetDisks(0, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
for i, test := range testCases {
|
|
test := test
|
|
t.Run(fmt.Sprintf("case-%d", i), func(t *testing.T) {
|
|
_, err = obj.PutObject(ctx, bucket, object, mustGetPutObjReader(t, bytes.NewReader(data), int64(len(data)), "", ""), ObjectOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to putObject %v", err)
|
|
}
|
|
|
|
partsMetadata, errs := readAllFileInfo(ctx, erasureDisks, "", bucket, object, "", false, true)
|
|
fi, err := getLatestFileInfo(ctx, partsMetadata, z.serverPools[0].sets[0].defaultParityCount, errs)
|
|
if err != nil {
|
|
t.Fatalf("Failed to getLatestFileInfo %v", err)
|
|
}
|
|
|
|
for j := range partsMetadata {
|
|
if errs[j] != nil {
|
|
t.Fatalf("expected error to be nil: %s", errs[j])
|
|
}
|
|
partsMetadata[j].ModTime = test.modTimes[j]
|
|
}
|
|
|
|
tamperedIndex := -1
|
|
switch test._tamperBackend {
|
|
case deletePart:
|
|
for index, err := range test.errs {
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// Remove a part from a disk
|
|
// which has a valid xl.meta,
|
|
// and check if that disk
|
|
// appears in outDatedDisks.
|
|
tamperedIndex = index
|
|
dErr := erasureDisks[index].Delete(context.Background(), bucket, pathJoin(object, fi.DataDir, "part.1"), DeleteOptions{
|
|
Recursive: false,
|
|
Immediate: false,
|
|
})
|
|
if dErr != nil {
|
|
t.Fatalf("Failed to delete %s - %v", filepath.Join(object, "part.1"), dErr)
|
|
}
|
|
break
|
|
}
|
|
case corruptPart:
|
|
for index, err := range test.errs {
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// Corrupt a part from a disk
|
|
// which has a valid xl.meta,
|
|
// and check if that disk
|
|
// appears in outDatedDisks.
|
|
tamperedIndex = index
|
|
filePath := pathJoin(erasureDisks[index].String(), bucket, object, fi.DataDir, "part.1")
|
|
f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_SYNC, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to open %s: %s\n", filePath, err)
|
|
}
|
|
f.WriteString("oops") // Will cause bitrot error
|
|
f.Close()
|
|
break
|
|
}
|
|
|
|
}
|
|
|
|
rQuorum := len(errs) - z.serverPools[0].sets[0].defaultParityCount
|
|
onlineDisks, modTime, _ := listOnlineDisks(erasureDisks, partsMetadata, test.errs, rQuorum)
|
|
if !modTime.Equal(test.expectedTime) {
|
|
t.Fatalf("Expected modTime to be equal to %v but was found to be %v",
|
|
test.expectedTime, modTime)
|
|
}
|
|
availableDisks, newErrs, _ := disksWithAllParts(ctx, onlineDisks, partsMetadata,
|
|
test.errs, fi, bucket, object, madmin.HealDeepScan)
|
|
test.errs = newErrs
|
|
|
|
if test._tamperBackend != noTamper {
|
|
if tamperedIndex != -1 && availableDisks[tamperedIndex] != nil {
|
|
t.Fatalf("Drive (%v) with part.1 missing is not a drive with available data",
|
|
erasureDisks[tamperedIndex])
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestListOnlineDisksSmallObjects - checks if listOnlineDisks and outDatedDisks
|
|
// are consistent with each other.
|
|
func TestListOnlineDisksSmallObjects(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
obj, disks, err := prepareErasure16(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Prepare Erasure backend failed - %v", err)
|
|
}
|
|
setObjectLayer(obj)
|
|
defer obj.Shutdown(context.Background())
|
|
defer removeRoots(disks)
|
|
|
|
type tamperKind int
|
|
const (
|
|
noTamper tamperKind = iota
|
|
deletePart tamperKind = iota
|
|
corruptPart tamperKind = iota
|
|
)
|
|
timeSentinel := time.Unix(1, 0).UTC()
|
|
threeNanoSecs := time.Unix(3, 0).UTC()
|
|
fourNanoSecs := time.Unix(4, 0).UTC()
|
|
modTimesThreeNone := make([]time.Time, 16)
|
|
modTimesThreeFour := make([]time.Time, 16)
|
|
for i := 0; i < 16; i++ {
|
|
// Have 13 good xl.meta, 12 for default parity count = 4 (EC:4) and one
|
|
// to be tampered with.
|
|
if i > 12 {
|
|
modTimesThreeFour[i] = fourNanoSecs
|
|
modTimesThreeNone[i] = timeSentinel
|
|
continue
|
|
}
|
|
modTimesThreeFour[i] = threeNanoSecs
|
|
modTimesThreeNone[i] = threeNanoSecs
|
|
}
|
|
|
|
testCases := []struct {
|
|
modTimes []time.Time
|
|
expectedTime time.Time
|
|
errs []error
|
|
_tamperBackend tamperKind
|
|
}{
|
|
{
|
|
modTimes: modTimesThreeFour,
|
|
expectedTime: threeNanoSecs,
|
|
errs: []error{
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
},
|
|
_tamperBackend: noTamper,
|
|
},
|
|
{
|
|
modTimes: modTimesThreeNone,
|
|
expectedTime: threeNanoSecs,
|
|
errs: []error{
|
|
// Disks that have a valid xl.meta.
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
nil, nil, nil, nil, nil,
|
|
// Some disks can't access xl.meta.
|
|
errFileNotFound, errDiskAccessDenied, errDiskNotFound,
|
|
},
|
|
_tamperBackend: deletePart,
|
|
},
|
|
{
|
|
modTimes: modTimesThreeNone,
|
|
expectedTime: threeNanoSecs,
|
|
errs: []error{
|
|
// Disks that have a valid xl.meta.
|
|
nil, nil, nil, nil, nil, nil, nil, nil,
|
|
nil, nil, nil, nil, nil,
|
|
// Some disks don't have xl.meta.
|
|
errDiskNotFound, errFileNotFound, errFileNotFound,
|
|
},
|
|
_tamperBackend: corruptPart,
|
|
},
|
|
}
|
|
|
|
bucket := "bucket"
|
|
err = obj.MakeBucket(ctx, "bucket", MakeBucketOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to make a bucket %v", err)
|
|
}
|
|
|
|
object := "object"
|
|
data := bytes.Repeat([]byte("a"), smallFileThreshold/2)
|
|
z := obj.(*erasureServerPools)
|
|
|
|
erasureDisks, err := z.GetDisks(0, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
for i, test := range testCases {
|
|
test := test
|
|
t.Run(fmt.Sprintf("case-%d", i), func(t *testing.T) {
|
|
_, err := obj.PutObject(ctx, bucket, object,
|
|
mustGetPutObjReader(t, bytes.NewReader(data), int64(len(data)), "", ""), ObjectOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to putObject %v", err)
|
|
}
|
|
|
|
partsMetadata, errs := readAllFileInfo(ctx, erasureDisks, "", bucket, object, "", true, true)
|
|
fi, err := getLatestFileInfo(ctx, partsMetadata, z.serverPools[0].sets[0].defaultParityCount, errs)
|
|
if err != nil {
|
|
t.Fatalf("Failed to getLatestFileInfo %v", err)
|
|
}
|
|
|
|
for j := range partsMetadata {
|
|
if errs[j] != nil {
|
|
t.Fatalf("expected error to be nil: %s", errs[j])
|
|
}
|
|
partsMetadata[j].ModTime = test.modTimes[j]
|
|
}
|
|
|
|
if erasureDisks, err = writeUniqueFileInfo(ctx, erasureDisks, "", bucket, object, partsMetadata, diskCount(erasureDisks)); err != nil {
|
|
t.Fatal(ctx, err)
|
|
}
|
|
|
|
tamperedIndex := -1
|
|
switch test._tamperBackend {
|
|
case deletePart:
|
|
for index, err := range test.errs {
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// Remove a part from a disk
|
|
// which has a valid xl.meta,
|
|
// and check if that disk
|
|
// appears in outDatedDisks.
|
|
tamperedIndex = index
|
|
dErr := erasureDisks[index].Delete(context.Background(), bucket, pathJoin(object, xlStorageFormatFile), DeleteOptions{
|
|
Recursive: false,
|
|
Immediate: false,
|
|
})
|
|
if dErr != nil {
|
|
t.Fatalf("Failed to delete %s - %v", pathJoin(object, xlStorageFormatFile), dErr)
|
|
}
|
|
break
|
|
}
|
|
case corruptPart:
|
|
for index, err := range test.errs {
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// Corrupt a part from a disk
|
|
// which has a valid xl.meta,
|
|
// and check if that disk
|
|
// appears in outDatedDisks.
|
|
tamperedIndex = index
|
|
filePath := pathJoin(erasureDisks[index].String(), bucket, object, xlStorageFormatFile)
|
|
f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_SYNC, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to open %s: %s\n", filePath, err)
|
|
}
|
|
f.WriteString("oops") // Will cause bitrot error
|
|
f.Close()
|
|
break
|
|
}
|
|
|
|
}
|
|
|
|
rQuorum := len(errs) - z.serverPools[0].sets[0].defaultParityCount
|
|
onlineDisks, modTime, _ := listOnlineDisks(erasureDisks, partsMetadata, test.errs, rQuorum)
|
|
if !modTime.Equal(test.expectedTime) {
|
|
t.Fatalf("Expected modTime to be equal to %v but was found to be %v",
|
|
test.expectedTime, modTime)
|
|
}
|
|
|
|
availableDisks, newErrs, _ := disksWithAllParts(ctx, onlineDisks, partsMetadata,
|
|
test.errs, fi, bucket, object, madmin.HealDeepScan)
|
|
test.errs = newErrs
|
|
|
|
if test._tamperBackend != noTamper {
|
|
if tamperedIndex != -1 && availableDisks[tamperedIndex] != nil {
|
|
t.Fatalf("Drive (%v) with part.1 missing is not a drive with available data",
|
|
erasureDisks[tamperedIndex])
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDisksWithAllParts(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
obj, disks, err := prepareErasure16(ctx)
|
|
if err != nil {
|
|
t.Fatalf("Prepare Erasure backend failed - %v", err)
|
|
}
|
|
setObjectLayer(obj)
|
|
defer obj.Shutdown(context.Background())
|
|
defer removeRoots(disks)
|
|
|
|
bucket := "bucket"
|
|
object := "object"
|
|
// make data with more than one part
|
|
partCount := 3
|
|
data := bytes.Repeat([]byte("a"), 6*1024*1024*partCount)
|
|
z := obj.(*erasureServerPools)
|
|
s := z.serverPools[0].sets[0]
|
|
erasureDisks := s.getDisks()
|
|
err = obj.MakeBucket(ctx, "bucket", MakeBucketOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to make a bucket %v", err)
|
|
}
|
|
|
|
_, err = obj.PutObject(ctx, bucket, object, mustGetPutObjReader(t, bytes.NewReader(data), int64(len(data)), "", ""), ObjectOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to putObject %v", err)
|
|
}
|
|
|
|
_, errs := readAllFileInfo(ctx, erasureDisks, "", bucket, object, "", false, true)
|
|
readQuorum := len(erasureDisks) / 2
|
|
if reducedErr := reduceReadQuorumErrs(ctx, errs, objectOpIgnoredErrs, readQuorum); reducedErr != nil {
|
|
t.Fatalf("Failed to read xl meta data %v", reducedErr)
|
|
}
|
|
|
|
// Test 1: Test that all disks are returned without any failures with
|
|
// unmodified meta data
|
|
partsMetadata, errs := readAllFileInfo(ctx, erasureDisks, "", bucket, object, "", false, true)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read xl meta data %v", err)
|
|
}
|
|
|
|
fi, err := getLatestFileInfo(ctx, partsMetadata, s.defaultParityCount, errs)
|
|
if err != nil {
|
|
t.Fatalf("Failed to get quorum consistent fileInfo %v", err)
|
|
}
|
|
|
|
erasureDisks, _, _ = listOnlineDisks(erasureDisks, partsMetadata, errs, readQuorum)
|
|
|
|
filteredDisks, errs, _ := disksWithAllParts(ctx, erasureDisks, partsMetadata,
|
|
errs, fi, bucket, object, madmin.HealDeepScan)
|
|
|
|
if len(filteredDisks) != len(erasureDisks) {
|
|
t.Errorf("Unexpected number of drives: %d", len(filteredDisks))
|
|
}
|
|
|
|
for diskIndex, disk := range filteredDisks {
|
|
if errs[diskIndex] != nil {
|
|
t.Errorf("Unexpected error %s", errs[diskIndex])
|
|
}
|
|
|
|
if disk == nil {
|
|
t.Errorf("Drive erroneously filtered, driveIndex: %d", diskIndex)
|
|
}
|
|
}
|
|
|
|
// Test 2: Not synchronized modtime
|
|
partsMetadataBackup := partsMetadata[0]
|
|
partsMetadata[0].ModTime = partsMetadata[0].ModTime.Add(-1 * time.Hour)
|
|
|
|
errs = make([]error, len(erasureDisks))
|
|
filteredDisks, _, _ = disksWithAllParts(ctx, erasureDisks, partsMetadata,
|
|
errs, fi, bucket, object, madmin.HealDeepScan)
|
|
|
|
if len(filteredDisks) != len(erasureDisks) {
|
|
t.Errorf("Unexpected number of drives: %d", len(filteredDisks))
|
|
}
|
|
for diskIndex, disk := range filteredDisks {
|
|
if diskIndex == 0 && disk != nil {
|
|
t.Errorf("Drive not filtered as expected, drive: %d", diskIndex)
|
|
}
|
|
if diskIndex != 0 && disk == nil {
|
|
t.Errorf("Drive erroneously filtered, driveIndex: %d", diskIndex)
|
|
}
|
|
}
|
|
partsMetadata[0] = partsMetadataBackup // Revert before going to the next test
|
|
|
|
// Test 3: Not synchronized DataDir
|
|
partsMetadataBackup = partsMetadata[1]
|
|
partsMetadata[1].DataDir = "foo-random"
|
|
|
|
errs = make([]error, len(erasureDisks))
|
|
filteredDisks, _, _ = disksWithAllParts(ctx, erasureDisks, partsMetadata,
|
|
errs, fi, bucket, object, madmin.HealDeepScan)
|
|
|
|
if len(filteredDisks) != len(erasureDisks) {
|
|
t.Errorf("Unexpected number of drives: %d", len(filteredDisks))
|
|
}
|
|
for diskIndex, disk := range filteredDisks {
|
|
if diskIndex == 1 && disk != nil {
|
|
t.Errorf("Drive not filtered as expected, drive: %d", diskIndex)
|
|
}
|
|
if diskIndex != 1 && disk == nil {
|
|
t.Errorf("Drive erroneously filtered, driveIndex: %d", diskIndex)
|
|
}
|
|
}
|
|
partsMetadata[1] = partsMetadataBackup // Revert before going to the next test
|
|
|
|
// Test 4: key = disk index, value = part name with hash mismatch
|
|
diskFailures := make(map[int]string)
|
|
diskFailures[0] = "part.1"
|
|
diskFailures[3] = "part.1"
|
|
diskFailures[15] = "part.1"
|
|
|
|
for diskIndex, partName := range diskFailures {
|
|
for i := range partsMetadata[diskIndex].Parts {
|
|
if fmt.Sprintf("part.%d", i+1) == partName {
|
|
filePath := pathJoin(erasureDisks[diskIndex].String(), bucket, object, partsMetadata[diskIndex].DataDir, partName)
|
|
f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_SYNC, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to open %s: %s\n", filePath, err)
|
|
}
|
|
f.WriteString("oops") // Will cause bitrot error
|
|
f.Close()
|
|
}
|
|
}
|
|
}
|
|
|
|
errs = make([]error, len(erasureDisks))
|
|
filteredDisks, errs, _ = disksWithAllParts(ctx, erasureDisks, partsMetadata,
|
|
errs, fi, bucket, object, madmin.HealDeepScan)
|
|
|
|
if len(filteredDisks) != len(erasureDisks) {
|
|
t.Errorf("Unexpected number of drives: %d", len(filteredDisks))
|
|
}
|
|
|
|
for diskIndex, disk := range filteredDisks {
|
|
if _, ok := diskFailures[diskIndex]; ok {
|
|
if disk != nil {
|
|
t.Errorf("Drive not filtered as expected, drive: %d", diskIndex)
|
|
}
|
|
if errs[diskIndex] == nil {
|
|
t.Errorf("Expected error not received, driveIndex: %d", diskIndex)
|
|
}
|
|
} else {
|
|
if disk == nil {
|
|
t.Errorf("Drive erroneously filtered, driveIndex: %d", diskIndex)
|
|
}
|
|
if errs[diskIndex] != nil {
|
|
t.Errorf("Unexpected error, %s, driveIndex: %d", errs[diskIndex], diskIndex)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCommonParities(t *testing.T) {
|
|
// This test uses two FileInfo values that represent the same object but
|
|
// have different parities. They occur in equal number of drives, but only
|
|
// one has read quorum. commonParity should pick the parity corresponding to
|
|
// the FileInfo which has read quorum.
|
|
fi1 := FileInfo{
|
|
Volume: "mybucket",
|
|
Name: "myobject",
|
|
VersionID: "",
|
|
IsLatest: true,
|
|
Deleted: false,
|
|
ExpireRestored: false,
|
|
DataDir: "4a01d9dd-0c5e-4103-88f8-b307c57d212e",
|
|
XLV1: false,
|
|
ModTime: time.Date(2023, time.March, 15, 11, 18, 4, 989906961, time.UTC),
|
|
Size: 329289, Mode: 0x0, WrittenByVersion: 0x63c77756,
|
|
Metadata: map[string]string{
|
|
"content-type": "application/octet-stream", "etag": "f205307ef9f50594c4b86d9c246bee86", "x-minio-internal-erasure-upgraded": "5->6", "x-minio-internal-inline-data": "true",
|
|
},
|
|
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{
|
|
Algorithm: "ReedSolomon",
|
|
DataBlocks: 6,
|
|
ParityBlocks: 6,
|
|
BlockSize: 1048576,
|
|
Index: 1,
|
|
Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
|
|
Checksums: []ChecksumInfo{{PartNumber: 1, Algorithm: 0x3, Hash: []uint8{}}},
|
|
},
|
|
NumVersions: 1,
|
|
Idx: 0,
|
|
}
|
|
|
|
fi2 := FileInfo{
|
|
Volume: "mybucket",
|
|
Name: "myobject",
|
|
VersionID: "",
|
|
IsLatest: true,
|
|
Deleted: false,
|
|
DataDir: "6f5c106d-9d28-4c85-a7f4-eac56225876b",
|
|
ModTime: time.Date(2023, time.March, 15, 19, 57, 30, 492530160, time.UTC),
|
|
Size: 329289,
|
|
Mode: 0x0,
|
|
WrittenByVersion: 0x63c77756,
|
|
Metadata: map[string]string{"content-type": "application/octet-stream", "etag": "f205307ef9f50594c4b86d9c246bee86", "x-minio-internal-inline-data": "true"},
|
|
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{
|
|
Algorithm: "ReedSolomon",
|
|
DataBlocks: 7,
|
|
ParityBlocks: 5,
|
|
BlockSize: 1048576,
|
|
Index: 2,
|
|
Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
|
|
Checksums: []ChecksumInfo{
|
|
{PartNumber: 1, Algorithm: 0x3, Hash: []uint8{}},
|
|
},
|
|
},
|
|
NumVersions: 1,
|
|
Idx: 0,
|
|
}
|
|
|
|
fiDel := FileInfo{
|
|
Volume: "mybucket",
|
|
Name: "myobject",
|
|
VersionID: "",
|
|
IsLatest: true,
|
|
Deleted: true,
|
|
ModTime: time.Date(2023, time.March, 15, 19, 57, 30, 492530160, time.UTC),
|
|
Mode: 0x0,
|
|
WrittenByVersion: 0x63c77756,
|
|
NumVersions: 1,
|
|
Idx: 0,
|
|
}
|
|
|
|
tests := []struct {
|
|
fi1, fi2 FileInfo
|
|
}{
|
|
{
|
|
fi1: fi1,
|
|
fi2: fi2,
|
|
},
|
|
{
|
|
fi1: fi1,
|
|
fi2: fiDel,
|
|
},
|
|
}
|
|
for idx, test := range tests {
|
|
var metaArr []FileInfo
|
|
for i := 0; i < 12; i++ {
|
|
fi := test.fi1
|
|
if i%2 == 0 {
|
|
fi = test.fi2
|
|
}
|
|
metaArr = append(metaArr, fi)
|
|
}
|
|
|
|
parities := listObjectParities(metaArr, make([]error, len(metaArr)))
|
|
parity := commonParity(parities, 5)
|
|
var match int
|
|
for _, fi := range metaArr {
|
|
if fi.Erasure.ParityBlocks == parity {
|
|
match++
|
|
}
|
|
}
|
|
if match < len(metaArr)-parity {
|
|
t.Fatalf("Test %d: Expected %d drives with parity=%d, but got %d", idx, len(metaArr)-parity, parity, match)
|
|
}
|
|
}
|
|
}
|