2016-05-21 05:48:47 +02:00
|
|
|
/*
|
|
|
|
* Minio Cloud Storage, (C) 2016 Minio, Inc.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2016-08-19 01:23:42 +02:00
|
|
|
package cmd
|
2016-05-21 05:48:47 +02:00
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"path"
|
|
|
|
"sort"
|
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
2016-05-25 02:48:58 +02:00
|
|
|
const (
|
2016-05-30 00:38:14 +02:00
|
|
|
// Erasure related constants.
|
2016-05-25 02:48:58 +02:00
|
|
|
erasureAlgorithmKlauspost = "klauspost/reedsolomon/vandermonde"
|
|
|
|
)
|
2016-05-21 05:48:47 +02:00
|
|
|
|
|
|
|
// objectPartInfo Info of each part kept in the multipart metadata
|
|
|
|
// file after CompleteMultipartUpload() is called.
|
|
|
|
type objectPartInfo struct {
|
2016-05-25 06:24:20 +02:00
|
|
|
Number int `json:"number"`
|
|
|
|
Name string `json:"name"`
|
|
|
|
ETag string `json:"etag"`
|
|
|
|
Size int64 `json:"size"`
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// byObjectPartNumber is a collection satisfying sort.Interface.
|
|
|
|
type byObjectPartNumber []objectPartInfo
|
2016-05-31 01:51:59 +02:00
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
func (t byObjectPartNumber) Len() int { return len(t) }
|
|
|
|
func (t byObjectPartNumber) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
|
|
|
|
func (t byObjectPartNumber) Less(i, j int) bool { return t[i].Number < t[j].Number }
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// checkSumInfo - carries checksums of individual scattered parts per disk.
|
2016-06-01 05:23:31 +02:00
|
|
|
type checkSumInfo struct {
|
|
|
|
Name string `json:"name"`
|
|
|
|
Algorithm string `json:"algorithm"`
|
|
|
|
Hash string `json:"hash"`
|
|
|
|
}
|
2016-05-31 01:51:59 +02:00
|
|
|
|
2016-07-28 11:20:34 +02:00
|
|
|
// Constant indicates current bit-rot algo used when creating objects.
|
|
|
|
const (
|
|
|
|
bitRotAlgo = "blake2b"
|
|
|
|
)
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// erasureInfo - carries erasure coding related information, block
|
|
|
|
// distribution and checksums.
|
|
|
|
type erasureInfo struct {
|
|
|
|
Algorithm string `json:"algorithm"`
|
|
|
|
DataBlocks int `json:"data"`
|
|
|
|
ParityBlocks int `json:"parity"`
|
|
|
|
BlockSize int64 `json:"blockSize"`
|
|
|
|
Index int `json:"index"`
|
|
|
|
Distribution []int `json:"distribution"`
|
|
|
|
Checksum []checkSumInfo `json:"checksum,omitempty"`
|
|
|
|
}
|
|
|
|
|
2016-07-28 11:20:34 +02:00
|
|
|
// AddCheckSum - add checksum of a part.
|
|
|
|
func (e *erasureInfo) AddCheckSumInfo(ckSumInfo checkSumInfo) {
|
|
|
|
for i, sum := range e.Checksum {
|
|
|
|
if sum.Name == ckSumInfo.Name {
|
|
|
|
e.Checksum[i] = ckSumInfo
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
e.Checksum = append(e.Checksum, ckSumInfo)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetCheckSumInfo - get checksum of a part.
|
2016-10-18 20:13:25 +02:00
|
|
|
func (e erasureInfo) GetCheckSumInfo(partName string) (ckSum checkSumInfo) {
|
2016-07-28 11:20:34 +02:00
|
|
|
// Return the checksum.
|
|
|
|
for _, sum := range e.Checksum {
|
|
|
|
if sum.Name == partName {
|
2016-10-18 20:13:25 +02:00
|
|
|
return sum
|
2016-07-28 11:20:34 +02:00
|
|
|
}
|
|
|
|
}
|
2016-10-18 20:13:25 +02:00
|
|
|
return checkSumInfo{Algorithm: bitRotAlgo}
|
2016-07-28 11:20:34 +02:00
|
|
|
}
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// statInfo - carries stat information of the object.
|
|
|
|
type statInfo struct {
|
|
|
|
Size int64 `json:"size"` // Size of the object `xl.json`.
|
|
|
|
ModTime time.Time `json:"modTime"` // ModTime of the object `xl.json`.
|
|
|
|
}
|
|
|
|
|
|
|
|
// A xlMetaV1 represents `xl.json` metadata header.
|
2016-05-21 05:48:47 +02:00
|
|
|
type xlMetaV1 struct {
|
2016-06-02 01:43:31 +02:00
|
|
|
Version string `json:"version"` // Version of the current `xl.json`.
|
|
|
|
Format string `json:"format"` // Format of the current `xl.json`.
|
|
|
|
Stat statInfo `json:"stat"` // Stat of the current object `xl.json`.
|
|
|
|
// Erasure coded info for the current object `xl.json`.
|
|
|
|
Erasure erasureInfo `json:"erasure"`
|
|
|
|
// Minio release tag for current object `xl.json`.
|
2016-05-21 05:48:47 +02:00
|
|
|
Minio struct {
|
|
|
|
Release string `json:"release"`
|
|
|
|
} `json:"minio"`
|
2016-06-02 01:43:31 +02:00
|
|
|
// Metadata map for current object `xl.json`.
|
2016-07-22 02:31:14 +02:00
|
|
|
Meta map[string]string `json:"meta,omitempty"`
|
2016-06-02 01:43:31 +02:00
|
|
|
// Captures all the individual object `xl.json`.
|
|
|
|
Parts []objectPartInfo `json:"parts,omitempty"`
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-07-09 00:28:09 +02:00
|
|
|
// newXLMetaV1 - initializes new xlMetaV1, adds version, allocates a fresh erasure info.
|
|
|
|
func newXLMetaV1(object string, dataBlocks, parityBlocks int) (xlMeta xlMetaV1) {
|
2016-05-31 01:51:59 +02:00
|
|
|
xlMeta = xlMetaV1{}
|
2016-06-29 11:10:40 +02:00
|
|
|
xlMeta.Version = "1.0.0"
|
2016-05-31 01:51:59 +02:00
|
|
|
xlMeta.Format = "xl"
|
2016-08-19 01:23:42 +02:00
|
|
|
xlMeta.Minio.Release = ReleaseTag
|
2016-06-02 01:43:31 +02:00
|
|
|
xlMeta.Erasure = erasureInfo{
|
|
|
|
Algorithm: erasureAlgorithmKlauspost,
|
|
|
|
DataBlocks: dataBlocks,
|
|
|
|
ParityBlocks: parityBlocks,
|
|
|
|
BlockSize: blockSizeV1,
|
2016-07-09 00:28:09 +02:00
|
|
|
Distribution: hashOrder(object, dataBlocks+parityBlocks),
|
2016-06-02 01:43:31 +02:00
|
|
|
}
|
2016-05-31 01:51:59 +02:00
|
|
|
return xlMeta
|
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// IsValid - tells if the format is sane by validating the version
|
|
|
|
// string and format style.
|
2016-06-01 05:23:31 +02:00
|
|
|
func (m xlMetaV1) IsValid() bool {
|
2016-06-29 11:10:40 +02:00
|
|
|
return m.Version == "1.0.0" && m.Format == "xl"
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
|
|
|
|
2016-09-09 07:38:18 +02:00
|
|
|
// objectPartIndex - returns the index of matching object part number.
|
|
|
|
func objectPartIndex(parts []objectPartInfo, partNumber int) int {
|
|
|
|
for i, part := range parts {
|
2016-05-26 12:15:01 +02:00
|
|
|
if partNumber == part.Number {
|
2016-08-16 16:57:14 +02:00
|
|
|
return i
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1
|
|
|
|
}
|
|
|
|
|
|
|
|
// AddObjectPart - add a new object part in order.
|
2016-05-26 12:15:01 +02:00
|
|
|
func (m *xlMetaV1) AddObjectPart(partNumber int, partName string, partETag string, partSize int64) {
|
2016-05-25 06:24:20 +02:00
|
|
|
partInfo := objectPartInfo{
|
2016-05-26 12:15:01 +02:00
|
|
|
Number: partNumber,
|
|
|
|
Name: partName,
|
|
|
|
ETag: partETag,
|
|
|
|
Size: partSize,
|
2016-05-25 06:24:20 +02:00
|
|
|
}
|
2016-05-26 12:15:01 +02:00
|
|
|
|
|
|
|
// Update part info if it already exists.
|
2016-05-25 06:24:20 +02:00
|
|
|
for i, part := range m.Parts {
|
2016-05-26 12:15:01 +02:00
|
|
|
if partNumber == part.Number {
|
2016-05-25 06:24:20 +02:00
|
|
|
m.Parts[i] = partInfo
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2016-05-26 12:15:01 +02:00
|
|
|
|
|
|
|
// Proceed to include new part info.
|
2016-05-25 06:24:20 +02:00
|
|
|
m.Parts = append(m.Parts, partInfo)
|
2016-05-26 12:15:01 +02:00
|
|
|
|
|
|
|
// Parts in xlMeta should be in sorted order by part number.
|
2016-06-01 05:23:31 +02:00
|
|
|
sort.Sort(byObjectPartNumber(m.Parts))
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// ObjectToPartOffset - translate offset of an object to offset of its individual part.
|
|
|
|
func (m xlMetaV1) ObjectToPartOffset(offset int64) (partIndex int, partOffset int64, err error) {
|
2016-07-11 02:12:22 +02:00
|
|
|
if offset == 0 {
|
|
|
|
// Special case - if offset is 0, then partIndex and partOffset are always 0.
|
|
|
|
return 0, 0, nil
|
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
partOffset = offset
|
2016-05-26 12:15:01 +02:00
|
|
|
// Seek until object offset maps to a particular part offset.
|
2016-05-21 05:48:47 +02:00
|
|
|
for i, part := range m.Parts {
|
2016-05-25 06:24:20 +02:00
|
|
|
partIndex = i
|
2016-05-26 12:15:01 +02:00
|
|
|
// Offset is smaller than size we have reached the proper part offset.
|
2016-05-21 05:48:47 +02:00
|
|
|
if partOffset < part.Size {
|
2016-05-25 06:24:20 +02:00
|
|
|
return partIndex, partOffset, nil
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-05-26 12:15:01 +02:00
|
|
|
// Continue to towards the next part.
|
2016-05-21 05:48:47 +02:00
|
|
|
partOffset -= part.Size
|
|
|
|
}
|
2016-05-26 12:15:01 +02:00
|
|
|
// Offset beyond the size of the object return InvalidRange.
|
2016-08-25 18:39:01 +02:00
|
|
|
return 0, 0, traceError(InvalidRange{})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// pickValidXLMeta - picks one valid xlMeta content and returns from a
|
|
|
|
// slice of xlmeta content. If no value is found this function panics
|
|
|
|
// and dies.
|
2016-07-14 23:59:01 +02:00
|
|
|
func pickValidXLMeta(metaArr []xlMetaV1, modTime time.Time) xlMetaV1 {
|
|
|
|
// Pick latest valid metadata.
|
|
|
|
for _, meta := range metaArr {
|
2016-10-18 20:13:25 +02:00
|
|
|
if meta.IsValid() && meta.Stat.ModTime.Equal(modTime) {
|
2016-07-14 23:59:01 +02:00
|
|
|
return meta
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
panic("Unable to look for valid XL metadata content")
|
|
|
|
}
|
|
|
|
|
2016-07-08 07:10:27 +02:00
|
|
|
// list of all errors that can be ignored in a metadata operation.
|
|
|
|
var objMetadataOpIgnoredErrs = []error{
|
|
|
|
errDiskNotFound,
|
|
|
|
errDiskAccessDenied,
|
|
|
|
errFaultyDisk,
|
|
|
|
errVolumeNotFound,
|
2016-07-11 09:15:37 +02:00
|
|
|
errFileAccessDenied,
|
2016-07-25 03:08:15 +02:00
|
|
|
errFileNotFound,
|
2016-07-08 07:10:27 +02:00
|
|
|
}
|
|
|
|
|
2016-09-09 07:38:18 +02:00
|
|
|
// readXLMetaParts - returns the XL Metadata Parts from xl.json of one of the disks picked at random.
|
|
|
|
func (xl xlObjects) readXLMetaParts(bucket, object string) (xlMetaParts []objectPartInfo, err error) {
|
|
|
|
for _, disk := range xl.getLoadBalancedDisks() {
|
|
|
|
if disk == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
xlMetaParts, err = readXLMetaParts(disk, bucket, object)
|
|
|
|
if err == nil {
|
|
|
|
return xlMetaParts, nil
|
|
|
|
}
|
|
|
|
// For any reason disk or bucket is not available continue
|
|
|
|
// and read from other disks.
|
|
|
|
if isErrIgnored(err, objMetadataOpIgnoredErrs) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
// Return error here.
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// readXLMetaStat - return xlMetaV1.Stat and xlMetaV1.Meta from one of the disks picked at random.
|
|
|
|
func (xl xlObjects) readXLMetaStat(bucket, object string) (xlStat statInfo, xlMeta map[string]string, err error) {
|
2016-07-21 09:27:08 +02:00
|
|
|
for _, disk := range xl.getLoadBalancedDisks() {
|
2016-06-03 01:34:15 +02:00
|
|
|
if disk == nil {
|
|
|
|
continue
|
|
|
|
}
|
2016-09-09 07:38:18 +02:00
|
|
|
// parses only xlMetaV1.Meta and xlMeta.Stat
|
|
|
|
xlStat, xlMeta, err = readXLMetaStat(disk, bucket, object)
|
2016-07-08 07:10:27 +02:00
|
|
|
if err == nil {
|
2016-09-09 07:38:18 +02:00
|
|
|
return xlStat, xlMeta, nil
|
2016-07-08 07:10:27 +02:00
|
|
|
}
|
|
|
|
// For any reason disk or bucket is not available continue
|
|
|
|
// and read from other disks.
|
|
|
|
if isErrIgnored(err, objMetadataOpIgnoredErrs) {
|
|
|
|
continue
|
2016-05-25 10:33:39 +02:00
|
|
|
}
|
2016-06-02 01:43:31 +02:00
|
|
|
break
|
2016-05-25 10:33:39 +02:00
|
|
|
}
|
2016-07-08 07:10:27 +02:00
|
|
|
// Return error here.
|
2016-09-09 07:38:18 +02:00
|
|
|
return statInfo{}, nil, err
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-06-03 01:34:15 +02:00
|
|
|
// deleteXLMetadata - deletes `xl.json` on a single disk.
|
|
|
|
func deleteXLMetdata(disk StorageAPI, bucket, prefix string) error {
|
|
|
|
jsonFile := path.Join(prefix, xlMetaJSONFile)
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(disk.DeleteFile(bucket, jsonFile))
|
2016-06-03 01:34:15 +02:00
|
|
|
}
|
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// writeXLMetadata - writes `xl.json` to a single disk.
|
|
|
|
func writeXLMetadata(disk StorageAPI, bucket, prefix string, xlMeta xlMetaV1) error {
|
|
|
|
jsonFile := path.Join(prefix, xlMetaJSONFile)
|
|
|
|
|
|
|
|
// Marshal json.
|
|
|
|
metadataBytes, err := json.Marshal(&xlMeta)
|
|
|
|
if err != nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(err)
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
|
|
|
// Persist marshalled data.
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(disk.AppendFile(bucket, jsonFile, metadataBytes))
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
|
|
|
|
2016-06-17 20:57:51 +02:00
|
|
|
// deleteAllXLMetadata - deletes all partially written `xl.json` depending on errs.
|
2016-07-12 02:24:49 +02:00
|
|
|
func deleteAllXLMetadata(disks []StorageAPI, bucket, prefix string, errs []error) {
|
2016-06-17 20:57:51 +02:00
|
|
|
var wg = &sync.WaitGroup{}
|
|
|
|
// Delete all the `xl.json` left over.
|
2016-07-12 02:24:49 +02:00
|
|
|
for index, disk := range disks {
|
2016-06-17 20:57:51 +02:00
|
|
|
if disk == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// Undo rename object in parallel.
|
|
|
|
wg.Add(1)
|
|
|
|
go func(index int, disk StorageAPI) {
|
|
|
|
defer wg.Done()
|
|
|
|
if errs[index] != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_ = deleteXLMetdata(disk, bucket, prefix)
|
|
|
|
}(index, disk)
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
}
|
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// writeUniqueXLMetadata - writes unique `xl.json` content for each disk in order.
|
2016-07-20 04:24:32 +02:00
|
|
|
func writeUniqueXLMetadata(disks []StorageAPI, bucket, prefix string, xlMetas []xlMetaV1, quorum int) error {
|
2016-06-01 05:23:31 +02:00
|
|
|
var wg = &sync.WaitGroup{}
|
2016-07-12 02:24:49 +02:00
|
|
|
var mErrs = make([]error, len(disks))
|
2016-06-01 05:23:31 +02:00
|
|
|
|
|
|
|
// Start writing `xl.json` to all disks in parallel.
|
2016-07-12 02:24:49 +02:00
|
|
|
for index, disk := range disks {
|
2016-06-03 01:34:15 +02:00
|
|
|
if disk == nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
mErrs[index] = traceError(errDiskNotFound)
|
2016-06-03 01:34:15 +02:00
|
|
|
continue
|
|
|
|
}
|
2016-06-01 05:23:31 +02:00
|
|
|
wg.Add(1)
|
|
|
|
// Write `xl.json` in a routine.
|
|
|
|
go func(index int, disk StorageAPI) {
|
|
|
|
defer wg.Done()
|
|
|
|
|
|
|
|
// Pick one xlMeta for a disk at index.
|
|
|
|
xlMetas[index].Erasure.Index = index + 1
|
|
|
|
|
|
|
|
// Write unique `xl.json` for a disk at index.
|
2016-06-03 07:49:27 +02:00
|
|
|
err := writeXLMetadata(disk, bucket, prefix, xlMetas[index])
|
|
|
|
if err != nil {
|
2016-06-01 05:23:31 +02:00
|
|
|
mErrs[index] = err
|
|
|
|
}
|
|
|
|
}(index, disk)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for all the routines.
|
|
|
|
wg.Wait()
|
|
|
|
|
2016-06-17 20:57:51 +02:00
|
|
|
// Do we have write quorum?.
|
2016-07-20 04:24:32 +02:00
|
|
|
if !isDiskQuorum(mErrs, quorum) {
|
2016-06-17 20:57:51 +02:00
|
|
|
// Delete all `xl.json` successfully renamed.
|
2016-07-12 02:24:49 +02:00
|
|
|
deleteAllXLMetadata(disks, bucket, prefix, mErrs)
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(errXLWriteQuorum)
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
2016-06-17 20:57:51 +02:00
|
|
|
|
2016-07-20 04:24:32 +02:00
|
|
|
return reduceErrs(mErrs, []error{
|
|
|
|
errDiskNotFound,
|
|
|
|
errFaultyDisk,
|
|
|
|
errDiskAccessDenied,
|
|
|
|
})
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
|
|
|
|
2016-06-03 01:34:15 +02:00
|
|
|
// writeSameXLMetadata - write `xl.json` on all disks in order.
|
2016-07-12 02:24:49 +02:00
|
|
|
func writeSameXLMetadata(disks []StorageAPI, bucket, prefix string, xlMeta xlMetaV1, writeQuorum, readQuorum int) error {
|
2016-05-26 12:15:01 +02:00
|
|
|
var wg = &sync.WaitGroup{}
|
2016-07-12 02:24:49 +02:00
|
|
|
var mErrs = make([]error, len(disks))
|
2016-05-26 12:15:01 +02:00
|
|
|
|
|
|
|
// Start writing `xl.json` to all disks in parallel.
|
2016-07-12 02:24:49 +02:00
|
|
|
for index, disk := range disks {
|
2016-06-03 01:34:15 +02:00
|
|
|
if disk == nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
mErrs[index] = traceError(errDiskNotFound)
|
2016-06-03 01:34:15 +02:00
|
|
|
continue
|
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
wg.Add(1)
|
2016-05-26 12:15:01 +02:00
|
|
|
// Write `xl.json` in a routine.
|
2016-05-21 05:48:47 +02:00
|
|
|
go func(index int, disk StorageAPI, metadata xlMetaV1) {
|
|
|
|
defer wg.Done()
|
|
|
|
|
2016-05-26 12:15:01 +02:00
|
|
|
// Save the disk order index.
|
2016-05-21 05:48:47 +02:00
|
|
|
metadata.Erasure.Index = index + 1
|
2016-05-26 12:15:01 +02:00
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// Write xl metadata.
|
2016-06-03 07:49:27 +02:00
|
|
|
err := writeXLMetadata(disk, bucket, prefix, metadata)
|
|
|
|
if err != nil {
|
2016-05-29 00:13:15 +02:00
|
|
|
mErrs[index] = err
|
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
}(index, disk, xlMeta)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for all the routines.
|
|
|
|
wg.Wait()
|
|
|
|
|
2016-06-17 20:57:51 +02:00
|
|
|
// Do we have write Quorum?.
|
2016-07-13 09:29:48 +02:00
|
|
|
if !isDiskQuorum(mErrs, writeQuorum) {
|
2016-06-17 20:57:51 +02:00
|
|
|
// Delete all `xl.json` successfully renamed.
|
2016-07-12 02:24:49 +02:00
|
|
|
deleteAllXLMetadata(disks, bucket, prefix, mErrs)
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(errXLWriteQuorum)
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-06-17 20:57:51 +02:00
|
|
|
|
2016-07-20 04:24:32 +02:00
|
|
|
return reduceErrs(mErrs, []error{
|
|
|
|
errDiskNotFound,
|
|
|
|
errFaultyDisk,
|
|
|
|
errDiskAccessDenied,
|
|
|
|
})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|