2016-06-02 01:43:31 +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 (
|
|
|
|
"crypto/md5"
|
2016-10-03 00:51:49 +02:00
|
|
|
"crypto/sha256"
|
2016-05-21 05:48:47 +02:00
|
|
|
"encoding/hex"
|
2016-10-03 00:51:49 +02:00
|
|
|
"hash"
|
2016-05-21 05:48:47 +02:00
|
|
|
"io"
|
|
|
|
"path"
|
|
|
|
"strings"
|
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
|
2016-07-25 23:17:01 +02:00
|
|
|
"github.com/minio/minio/pkg/bpool"
|
2016-05-21 05:48:47 +02:00
|
|
|
"github.com/minio/minio/pkg/mimedb"
|
2016-07-04 01:58:21 +02:00
|
|
|
"github.com/minio/minio/pkg/objcache"
|
2016-05-21 05:48:47 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
/// Object Operations
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// GetObject - reads an object erasured coded across multiple
|
|
|
|
// disks. Supports additional parameters like offset and length
|
|
|
|
// which is synonymous with HTTP Range requests.
|
|
|
|
//
|
|
|
|
// startOffset indicates the location at which the client requested
|
|
|
|
// object to be read at. length indicates the total length of the
|
|
|
|
// object requested by client.
|
2016-05-29 00:13:15 +02:00
|
|
|
func (xl xlObjects) GetObject(bucket, object string, startOffset int64, length int64, writer io.Writer) error {
|
2016-05-21 05:48:47 +02:00
|
|
|
// Verify if bucket is valid.
|
|
|
|
if !IsValidBucketName(bucket) {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(BucketNameInvalid{Bucket: bucket})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
// Verify if object is valid.
|
|
|
|
if !IsValidObjectName(object) {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(ObjectNameInvalid{Bucket: bucket, Object: object})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-07-07 10:30:34 +02:00
|
|
|
// Start offset and length cannot be negative.
|
|
|
|
if startOffset < 0 || length < 0 {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(errUnexpected)
|
2016-07-07 10:30:34 +02:00
|
|
|
}
|
2016-07-08 16:46:49 +02:00
|
|
|
// Writer cannot be nil.
|
|
|
|
if writer == nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(errUnexpected)
|
2016-07-08 16:46:49 +02:00
|
|
|
}
|
2016-08-31 20:39:08 +02:00
|
|
|
|
2016-09-28 03:28:46 +02:00
|
|
|
// get a random ID for lock instrumentation.
|
2016-08-31 20:39:08 +02:00
|
|
|
opsID := getOpsID()
|
|
|
|
|
2016-05-25 10:33:39 +02:00
|
|
|
// Lock the object before reading.
|
2016-08-31 20:39:08 +02:00
|
|
|
nsMutex.RLock(bucket, object, opsID)
|
|
|
|
defer nsMutex.RUnlock(bucket, object, opsID)
|
2016-05-25 10:33:39 +02:00
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// Read metadata associated with the object from all disks.
|
2016-07-12 02:24:49 +02:00
|
|
|
metaArr, errs := readAllXLMetadata(xl.storageDisks, bucket, object)
|
2016-06-27 19:01:09 +02:00
|
|
|
// Do we have read quorum?
|
2016-07-13 09:29:48 +02:00
|
|
|
if !isDiskQuorum(errs, xl.readQuorum) {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(InsufficientReadQuorum{}, errs...)
|
2016-06-27 19:01:09 +02:00
|
|
|
}
|
2016-05-27 04:55:48 +02:00
|
|
|
|
2016-07-20 04:24:32 +02:00
|
|
|
if reducedErr := reduceErrs(errs, []error{
|
|
|
|
errDiskNotFound,
|
|
|
|
errFaultyDisk,
|
|
|
|
errDiskAccessDenied,
|
|
|
|
}); reducedErr != nil {
|
|
|
|
return toObjectErr(reducedErr, bucket, object)
|
2016-07-09 22:01:32 +02:00
|
|
|
}
|
|
|
|
|
2016-05-26 01:42:31 +02:00
|
|
|
// List all online disks.
|
2016-07-14 23:59:01 +02:00
|
|
|
onlineDisks, modTime := listOnlineDisks(xl.storageDisks, metaArr, errs)
|
2016-05-27 04:55:48 +02:00
|
|
|
|
2016-06-17 07:26:18 +02:00
|
|
|
// Pick latest valid metadata.
|
2016-07-25 07:49:27 +02:00
|
|
|
xlMeta := pickValidXLMeta(metaArr, modTime)
|
|
|
|
|
|
|
|
// Reorder online disks based on erasure distribution order.
|
2016-07-16 17:35:30 +02:00
|
|
|
onlineDisks = getOrderedDisks(xlMeta.Erasure.Distribution, onlineDisks)
|
2016-07-25 07:49:27 +02:00
|
|
|
|
|
|
|
// Reorder parts metadata based on erasure distribution order.
|
2016-07-16 17:35:30 +02:00
|
|
|
metaArr = getOrderedPartsMetadata(xlMeta.Erasure.Distribution, metaArr)
|
2016-05-26 01:42:31 +02:00
|
|
|
|
2016-07-08 16:46:49 +02:00
|
|
|
// Reply back invalid range if the input offset and length fall out of range.
|
|
|
|
if startOffset > xlMeta.Stat.Size || length > xlMeta.Stat.Size {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(InvalidRange{startOffset, length, xlMeta.Stat.Size})
|
2016-07-08 16:46:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Reply if we have inputs with offset and length.
|
|
|
|
if startOffset+length > xlMeta.Stat.Size {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(InvalidRange{startOffset, length, xlMeta.Stat.Size})
|
2016-07-08 16:46:49 +02:00
|
|
|
}
|
|
|
|
|
2016-06-19 22:35:26 +02:00
|
|
|
// Get start part index and offset.
|
2016-06-01 05:23:31 +02:00
|
|
|
partIndex, partOffset, err := xlMeta.ObjectToPartOffset(startOffset)
|
2016-05-21 05:48:47 +02:00
|
|
|
if err != nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(InvalidRange{startOffset, length, xlMeta.Stat.Size})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-06-01 05:23:31 +02:00
|
|
|
|
2016-06-19 22:35:26 +02:00
|
|
|
// Get last part index to read given length.
|
|
|
|
lastPartIndex, _, err := xlMeta.ObjectToPartOffset(startOffset + length - 1)
|
|
|
|
if err != nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(InvalidRange{startOffset, length, xlMeta.Stat.Size})
|
2016-06-19 22:35:26 +02:00
|
|
|
}
|
|
|
|
|
2016-07-04 01:58:21 +02:00
|
|
|
// Save the writer.
|
|
|
|
mw := writer
|
|
|
|
|
|
|
|
// Object cache enabled block.
|
2016-07-09 05:34:27 +02:00
|
|
|
if xlMeta.Stat.Size > 0 && xl.objCacheEnabled {
|
2016-07-04 01:58:21 +02:00
|
|
|
// Validate if we have previous cache.
|
2016-07-19 04:06:48 +02:00
|
|
|
var cachedBuffer io.ReadSeeker
|
2016-09-24 04:55:28 +02:00
|
|
|
cachedBuffer, err = xl.objCache.Open(path.Join(bucket, object), modTime)
|
2016-07-04 01:58:21 +02:00
|
|
|
if err == nil { // Cache hit.
|
|
|
|
// Advance the buffer to offset as if it was read.
|
|
|
|
if _, err = cachedBuffer.Seek(startOffset, 0); err != nil { // Seek to the offset.
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(err)
|
2016-07-04 01:58:21 +02:00
|
|
|
}
|
|
|
|
// Write the requested length.
|
|
|
|
if _, err = io.CopyN(writer, cachedBuffer, length); err != nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(err)
|
2016-07-04 01:58:21 +02:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
} // Cache miss.
|
|
|
|
// For unknown error, return and error out.
|
|
|
|
if err != objcache.ErrKeyNotFoundInCache {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(err)
|
2016-07-04 01:58:21 +02:00
|
|
|
} // Cache has not been found, fill the cache.
|
|
|
|
|
|
|
|
// Cache is only set if whole object is being read.
|
|
|
|
if startOffset == 0 && length == xlMeta.Stat.Size {
|
2016-07-05 10:04:50 +02:00
|
|
|
// Proceed to set the cache.
|
2016-07-06 10:29:49 +02:00
|
|
|
var newBuffer io.WriteCloser
|
2016-07-04 01:58:21 +02:00
|
|
|
// Create a new entry in memory of length.
|
|
|
|
newBuffer, err = xl.objCache.Create(path.Join(bucket, object), length)
|
2016-07-05 10:04:50 +02:00
|
|
|
if err == nil {
|
|
|
|
// Create a multi writer to write to both memory and client response.
|
|
|
|
mw = io.MultiWriter(newBuffer, writer)
|
2016-07-06 10:29:49 +02:00
|
|
|
defer newBuffer.Close()
|
2016-07-05 10:04:50 +02:00
|
|
|
}
|
2016-07-09 05:34:27 +02:00
|
|
|
// Ignore error if cache is full, proceed to write the object.
|
2016-07-05 10:04:50 +02:00
|
|
|
if err != nil && err != objcache.ErrCacheFull {
|
2016-07-09 05:34:27 +02:00
|
|
|
// For any other error return here.
|
2016-08-25 18:39:01 +02:00
|
|
|
return toObjectErr(traceError(err), bucket, object)
|
2016-07-04 01:58:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-19 22:35:26 +02:00
|
|
|
totalBytesRead := int64(0)
|
2016-07-25 23:17:01 +02:00
|
|
|
|
|
|
|
chunkSize := getChunkSize(xlMeta.Erasure.BlockSize, xlMeta.Erasure.DataBlocks)
|
|
|
|
pool := bpool.NewBytePool(chunkSize, len(onlineDisks))
|
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// Read from all parts.
|
2016-06-19 22:35:26 +02:00
|
|
|
for ; partIndex <= lastPartIndex; partIndex++ {
|
2016-06-21 23:34:11 +02:00
|
|
|
if length == totalBytesRead {
|
|
|
|
break
|
|
|
|
}
|
2016-06-01 05:23:31 +02:00
|
|
|
// Save the current part name and size.
|
|
|
|
partName := xlMeta.Parts[partIndex].Name
|
|
|
|
partSize := xlMeta.Parts[partIndex].Size
|
2016-06-22 18:05:03 +02:00
|
|
|
|
2016-06-21 23:34:11 +02:00
|
|
|
readSize := partSize - partOffset
|
2016-06-22 18:05:03 +02:00
|
|
|
// readSize should be adjusted so that we don't write more data than what was requested.
|
2016-06-21 23:34:11 +02:00
|
|
|
if readSize > (length - totalBytesRead) {
|
|
|
|
readSize = length - totalBytesRead
|
2016-06-19 22:35:26 +02:00
|
|
|
}
|
2016-06-01 05:23:31 +02:00
|
|
|
|
2016-07-16 17:35:30 +02:00
|
|
|
// Get the checksums of the current part.
|
|
|
|
checkSums := make([]string, len(onlineDisks))
|
2016-07-28 11:20:34 +02:00
|
|
|
var ckSumAlgo string
|
2016-07-25 07:49:27 +02:00
|
|
|
for index, disk := range onlineDisks {
|
|
|
|
// Disk is not found skip the checksum.
|
|
|
|
if disk == nil {
|
|
|
|
checkSums[index] = ""
|
|
|
|
continue
|
|
|
|
}
|
2016-07-28 11:20:34 +02:00
|
|
|
ckSumInfo, err := metaArr[index].Erasure.GetCheckSumInfo(partName)
|
2016-07-25 07:49:27 +02:00
|
|
|
if err != nil { // FIXME - relook at returning error here.
|
2016-07-16 17:35:30 +02:00
|
|
|
return toObjectErr(err, bucket, object)
|
|
|
|
}
|
2016-07-28 11:20:34 +02:00
|
|
|
checkSums[index] = ckSumInfo.Hash
|
|
|
|
// Set checksum algo only once, while it is possible to have
|
|
|
|
// different algos per block because of our `xl.json`.
|
|
|
|
// It is not a requirement, set this only once for all the disks.
|
|
|
|
if ckSumAlgo != "" {
|
|
|
|
ckSumAlgo = ckSumInfo.Algorithm
|
|
|
|
}
|
2016-07-16 17:35:30 +02:00
|
|
|
}
|
|
|
|
|
2016-07-28 11:20:34 +02:00
|
|
|
// Start erasure decoding and writing to the client.
|
|
|
|
n, err := erasureReadFile(mw, onlineDisks, bucket, pathJoin(object, partName), partOffset, readSize, partSize, xlMeta.Erasure.BlockSize, xlMeta.Erasure.DataBlocks, xlMeta.Erasure.ParityBlocks, checkSums, ckSumAlgo, pool)
|
2016-06-01 05:23:31 +02:00
|
|
|
if err != nil {
|
2016-07-09 05:34:27 +02:00
|
|
|
return toObjectErr(err, bucket, object)
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
|
|
|
|
2016-07-28 11:20:34 +02:00
|
|
|
// Track total bytes read from disk and written to the client.
|
2016-06-19 22:35:26 +02:00
|
|
|
totalBytesRead += n
|
2016-06-01 05:23:31 +02:00
|
|
|
|
2016-06-22 18:05:03 +02:00
|
|
|
// partOffset will be valid only for the first part, hence reset it to 0 for
|
|
|
|
// the remaining parts.
|
2016-06-01 05:23:31 +02:00
|
|
|
partOffset = 0
|
2016-06-02 01:43:31 +02:00
|
|
|
} // End of read all parts loop.
|
2016-06-01 05:23:31 +02:00
|
|
|
|
|
|
|
// Return success.
|
2016-05-29 00:13:15 +02:00
|
|
|
return nil
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-08-17 20:36:33 +02:00
|
|
|
// HealObject - heal the object.
|
|
|
|
// FIXME: If an object object was deleted and one disk was down, and later the disk comes back
|
|
|
|
// up again, heal on the object should delete it.
|
|
|
|
func (xl xlObjects) HealObject(bucket, object string) error {
|
|
|
|
// Verify if bucket is valid.
|
|
|
|
if !IsValidBucketName(bucket) {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(BucketNameInvalid{Bucket: bucket})
|
2016-08-17 20:36:33 +02:00
|
|
|
}
|
|
|
|
// Verify if object is valid.
|
|
|
|
if !IsValidObjectName(object) {
|
|
|
|
// FIXME: return Invalid prefix.
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(ObjectNameInvalid{Bucket: bucket, Object: object})
|
2016-08-17 20:36:33 +02:00
|
|
|
}
|
|
|
|
|
2016-09-28 03:28:46 +02:00
|
|
|
// get a random ID for lock instrumentation.
|
2016-08-31 20:39:08 +02:00
|
|
|
opsID := getOpsID()
|
|
|
|
|
2016-08-17 20:36:33 +02:00
|
|
|
// Lock the object before healing.
|
2016-08-31 20:39:08 +02:00
|
|
|
nsMutex.RLock(bucket, object, opsID)
|
|
|
|
defer nsMutex.RUnlock(bucket, object, opsID)
|
2016-08-17 20:36:33 +02:00
|
|
|
|
|
|
|
partsMetadata, errs := readAllXLMetadata(xl.storageDisks, bucket, object)
|
|
|
|
if err := reduceErrs(errs, nil); err != nil {
|
|
|
|
return toObjectErr(err, bucket, object)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !xlShouldHeal(partsMetadata, errs) {
|
|
|
|
// There is nothing to heal.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// List of disks having latest version of the object.
|
|
|
|
latestDisks, modTime := listOnlineDisks(xl.storageDisks, partsMetadata, errs)
|
|
|
|
// List of disks having outdated version of the object or missing object.
|
|
|
|
outDatedDisks := outDatedDisks(xl.storageDisks, partsMetadata, errs)
|
|
|
|
// Latest xlMetaV1 for reference.
|
|
|
|
latestMeta := pickValidXLMeta(partsMetadata, modTime)
|
|
|
|
|
|
|
|
for index, disk := range outDatedDisks {
|
|
|
|
// Before healing outdated disks, we need to remove xl.json
|
|
|
|
// and part files from "bucket/object/" so that
|
|
|
|
// rename(".minio.sys", "tmp/tmpuuid/", "bucket", "object/") succeeds.
|
|
|
|
if disk == nil {
|
|
|
|
// Not an outdated disk.
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if errs[index] != nil {
|
|
|
|
// If there was an error (most likely errFileNotFound)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// Outdated object with the same name exists that needs to be deleted.
|
|
|
|
outDatedMeta := partsMetadata[index]
|
|
|
|
// Delete all the parts.
|
|
|
|
for partIndex := 0; partIndex < len(outDatedMeta.Parts); partIndex++ {
|
|
|
|
err := disk.DeleteFile(bucket,
|
|
|
|
pathJoin(object, outDatedMeta.Parts[partIndex].Name))
|
|
|
|
if err != nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(err)
|
2016-08-17 20:36:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Delete xl.json file.
|
|
|
|
err := disk.DeleteFile(bucket, pathJoin(object, xlMetaJSONFile))
|
|
|
|
if err != nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(err)
|
2016-08-17 20:36:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reorder so that we have data disks first and parity disks next.
|
|
|
|
latestDisks = getOrderedDisks(latestMeta.Erasure.Distribution, latestDisks)
|
|
|
|
outDatedDisks = getOrderedDisks(latestMeta.Erasure.Distribution, outDatedDisks)
|
|
|
|
partsMetadata = getOrderedPartsMetadata(latestMeta.Erasure.Distribution, partsMetadata)
|
|
|
|
|
|
|
|
// We write at temporary location and then rename to fianal location.
|
|
|
|
tmpID := getUUID()
|
|
|
|
|
|
|
|
// Checksum of the part files. checkSumInfos[index] will contain checksums of all the part files
|
|
|
|
// in the outDatedDisks[index]
|
|
|
|
checkSumInfos := make([][]checkSumInfo, len(outDatedDisks))
|
|
|
|
|
|
|
|
// Heal each part. erasureHealFile() will write the healed part to
|
|
|
|
// .minio/tmp/uuid/ which needs to be renamed later to the final location.
|
|
|
|
for partIndex := 0; partIndex < len(latestMeta.Parts); partIndex++ {
|
|
|
|
partName := latestMeta.Parts[partIndex].Name
|
|
|
|
partSize := latestMeta.Parts[partIndex].Size
|
|
|
|
erasure := latestMeta.Erasure
|
|
|
|
sumInfo, err := latestMeta.Erasure.GetCheckSumInfo(partName)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// Heal the part file.
|
|
|
|
checkSums, err := erasureHealFile(latestDisks, outDatedDisks,
|
|
|
|
bucket, pathJoin(object, partName),
|
|
|
|
minioMetaBucket, pathJoin(tmpMetaPrefix, tmpID, partName),
|
|
|
|
partSize, erasure.BlockSize, erasure.DataBlocks, erasure.ParityBlocks, sumInfo.Algorithm)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for index, sum := range checkSums {
|
|
|
|
if outDatedDisks[index] == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
checkSumInfos[index] = append(checkSumInfos[index], checkSumInfo{partName, sumInfo.Algorithm, sum})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// xl.json should be written to all the healed disks.
|
|
|
|
for index, disk := range outDatedDisks {
|
|
|
|
if disk == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
partsMetadata[index] = latestMeta
|
|
|
|
partsMetadata[index].Erasure.Checksum = checkSumInfos[index]
|
|
|
|
}
|
|
|
|
err := writeUniqueXLMetadata(outDatedDisks, minioMetaBucket, pathJoin(tmpMetaPrefix, tmpID), partsMetadata, diskCount(outDatedDisks))
|
|
|
|
if err != nil {
|
|
|
|
return toObjectErr(err, bucket, object)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Rename from tmp location to the actual location.
|
|
|
|
for _, disk := range outDatedDisks {
|
|
|
|
if disk == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
err := disk.RenameFile(minioMetaBucket, retainSlash(pathJoin(tmpMetaPrefix, tmpID)), bucket, retainSlash(object))
|
|
|
|
if err != nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(err)
|
2016-08-17 20:36:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// GetObjectInfo - reads object metadata and replies back ObjectInfo.
|
2016-05-21 05:48:47 +02:00
|
|
|
func (xl xlObjects) GetObjectInfo(bucket, object string) (ObjectInfo, error) {
|
|
|
|
// Verify if bucket is valid.
|
|
|
|
if !IsValidBucketName(bucket) {
|
|
|
|
return ObjectInfo{}, BucketNameInvalid{Bucket: bucket}
|
|
|
|
}
|
|
|
|
// Verify if object is valid.
|
|
|
|
if !IsValidObjectName(object) {
|
|
|
|
return ObjectInfo{}, ObjectNameInvalid{Bucket: bucket, Object: object}
|
|
|
|
}
|
2016-08-31 20:39:08 +02:00
|
|
|
|
2016-09-28 03:28:46 +02:00
|
|
|
// get a random ID for lock instrumentation.
|
2016-08-31 20:39:08 +02:00
|
|
|
opsID := getOpsID()
|
|
|
|
|
|
|
|
nsMutex.RLock(bucket, object, opsID)
|
|
|
|
defer nsMutex.RUnlock(bucket, object, opsID)
|
2016-05-21 05:48:47 +02:00
|
|
|
info, err := xl.getObjectInfo(bucket, object)
|
|
|
|
if err != nil {
|
|
|
|
return ObjectInfo{}, toObjectErr(err, bucket, object)
|
|
|
|
}
|
|
|
|
return info, nil
|
|
|
|
}
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// getObjectInfo - wrapper for reading object metadata and constructs ObjectInfo.
|
2016-05-21 05:48:47 +02:00
|
|
|
func (xl xlObjects) getObjectInfo(bucket, object string) (objInfo ObjectInfo, err error) {
|
2016-09-09 07:38:18 +02:00
|
|
|
// returns xl meta map and stat info.
|
|
|
|
xlStat, xlMetaMap, err := xl.readXLMetaStat(bucket, object)
|
2016-05-25 10:33:39 +02:00
|
|
|
if err != nil {
|
|
|
|
// Return error.
|
|
|
|
return ObjectInfo{}, err
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-09-09 07:38:18 +02:00
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
objInfo = ObjectInfo{
|
|
|
|
IsDir: false,
|
|
|
|
Bucket: bucket,
|
|
|
|
Name: object,
|
2016-09-09 07:38:18 +02:00
|
|
|
Size: xlStat.Size,
|
|
|
|
ModTime: xlStat.ModTime,
|
|
|
|
MD5Sum: xlMetaMap["md5Sum"],
|
|
|
|
ContentType: xlMetaMap["content-type"],
|
|
|
|
ContentEncoding: xlMetaMap["content-encoding"],
|
|
|
|
UserDefined: xlMetaMap,
|
2016-06-02 01:43:31 +02:00
|
|
|
}
|
2016-05-25 10:33:39 +02:00
|
|
|
return objInfo, nil
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-07-20 04:24:32 +02:00
|
|
|
func undoRename(disks []StorageAPI, srcBucket, srcEntry, dstBucket, dstEntry string, isPart bool, errs []error) {
|
2016-06-17 20:57:51 +02:00
|
|
|
var wg = &sync.WaitGroup{}
|
|
|
|
// Undo rename object on disks where RenameFile succeeded.
|
2016-06-21 04:11:55 +02:00
|
|
|
|
|
|
|
// If srcEntry/dstEntry are objects then add a trailing slash to copy
|
|
|
|
// over all the parts inside the object directory
|
|
|
|
if !isPart {
|
|
|
|
srcEntry = retainSlash(srcEntry)
|
|
|
|
dstEntry = retainSlash(dstEntry)
|
|
|
|
}
|
2016-07-12 07:53:54 +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
|
|
|
|
}
|
2016-06-21 04:11:55 +02:00
|
|
|
_ = disk.RenameFile(dstBucket, dstEntry, srcBucket, srcEntry)
|
2016-06-17 20:57:51 +02:00
|
|
|
}(index, disk)
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
}
|
|
|
|
|
2016-06-21 04:11:55 +02:00
|
|
|
// rename - common function that renamePart and renameObject use to rename
|
|
|
|
// the respective underlying storage layer representations.
|
2016-07-20 04:24:32 +02:00
|
|
|
func rename(disks []StorageAPI, srcBucket, srcEntry, dstBucket, dstEntry string, isPart bool, quorum int) error {
|
2016-05-21 05:48:47 +02:00
|
|
|
// Initialize sync waitgroup.
|
|
|
|
var wg = &sync.WaitGroup{}
|
|
|
|
|
|
|
|
// Initialize list of errors.
|
2016-07-12 07:53:54 +02:00
|
|
|
var errs = make([]error, len(disks))
|
2016-05-21 05:48:47 +02:00
|
|
|
|
2016-06-21 04:11:55 +02:00
|
|
|
if !isPart {
|
|
|
|
dstEntry = retainSlash(dstEntry)
|
|
|
|
srcEntry = retainSlash(srcEntry)
|
|
|
|
}
|
|
|
|
|
2016-05-21 05:48:47 +02:00
|
|
|
// Rename file on all underlying storage disks.
|
2016-07-12 07:53:54 +02:00
|
|
|
for index, disk := range disks {
|
2016-06-03 01:34:15 +02:00
|
|
|
if disk == nil {
|
|
|
|
errs[index] = errDiskNotFound
|
|
|
|
continue
|
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
wg.Add(1)
|
|
|
|
go func(index int, disk StorageAPI) {
|
|
|
|
defer wg.Done()
|
2016-06-21 04:11:55 +02:00
|
|
|
err := disk.RenameFile(srcBucket, srcEntry, dstBucket, dstEntry)
|
2016-06-02 01:43:31 +02:00
|
|
|
if err != nil && err != errFileNotFound {
|
2016-08-25 18:39:01 +02:00
|
|
|
errs[index] = traceError(err)
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
}(index, disk)
|
|
|
|
}
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// Wait for all renames to finish.
|
2016-05-21 05:48:47 +02:00
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
// We can safely allow RenameFile errors up to len(xl.storageDisks) - xl.writeQuorum
|
|
|
|
// otherwise return failure. Cleanup successful renames.
|
2016-07-20 04:24:32 +02:00
|
|
|
if !isDiskQuorum(errs, quorum) {
|
2016-06-17 20:57:51 +02:00
|
|
|
// Undo all the partial rename operations.
|
2016-07-20 04:24:32 +02:00
|
|
|
undoRename(disks, srcBucket, srcEntry, dstBucket, dstEntry, isPart, errs)
|
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
|
|
|
// Return on first error, also undo any partially successful rename operations.
|
2016-07-20 04:24:32 +02:00
|
|
|
return reduceErrs(errs, []error{
|
|
|
|
errDiskNotFound,
|
|
|
|
errDiskAccessDenied,
|
|
|
|
errFaultyDisk,
|
|
|
|
})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-06-21 04:11:55 +02:00
|
|
|
// renamePart - renames a part of the source object to the destination
|
|
|
|
// across all disks in parallel. Additionally if we have errors and do
|
|
|
|
// not have a readQuorum partially renamed files are renamed back to
|
|
|
|
// its proper location.
|
2016-07-20 04:24:32 +02:00
|
|
|
func renamePart(disks []StorageAPI, srcBucket, srcPart, dstBucket, dstPart string, quorum int) error {
|
2016-06-21 04:11:55 +02:00
|
|
|
isPart := true
|
2016-07-20 04:24:32 +02:00
|
|
|
return rename(disks, srcBucket, srcPart, dstBucket, dstPart, isPart, quorum)
|
2016-06-21 04:11:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// renameObject - renames all source objects to destination object
|
|
|
|
// across all disks in parallel. Additionally if we have errors and do
|
|
|
|
// not have a readQuorum partially renamed files are renamed back to
|
|
|
|
// its proper location.
|
2016-07-20 04:24:32 +02:00
|
|
|
func renameObject(disks []StorageAPI, srcBucket, srcObject, dstBucket, dstObject string, quorum int) error {
|
2016-06-21 04:11:55 +02:00
|
|
|
isPart := false
|
2016-07-20 04:24:32 +02:00
|
|
|
return rename(disks, srcBucket, srcObject, dstBucket, dstObject, isPart, quorum)
|
2016-06-21 04:11:55 +02:00
|
|
|
}
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// PutObject - creates an object upon reading from the input stream
|
|
|
|
// until EOF, erasure codes the data across all disk and additionally
|
|
|
|
// writes `xl.json` which carries the necessary metadata for future
|
|
|
|
// object operations.
|
2016-10-03 00:51:49 +02:00
|
|
|
func (xl xlObjects) PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string, sha256sum string) (objInfo ObjectInfo, err error) {
|
2016-05-21 05:48:47 +02:00
|
|
|
// Verify if bucket is valid.
|
|
|
|
if !IsValidBucketName(bucket) {
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, traceError(BucketNameInvalid{Bucket: bucket})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
// Verify bucket exists.
|
|
|
|
if !xl.isBucketExist(bucket) {
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, traceError(BucketNotFound{Bucket: bucket})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
if !IsValidObjectName(object) {
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, traceError(ObjectNameInvalid{
|
2016-05-21 05:48:47 +02:00
|
|
|
Bucket: bucket,
|
|
|
|
Object: object,
|
2016-08-25 18:39:01 +02:00
|
|
|
})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
// No metadata is set, allocate a new one.
|
|
|
|
if metadata == nil {
|
|
|
|
metadata = make(map[string]string)
|
|
|
|
}
|
2016-08-17 22:26:08 +02:00
|
|
|
|
2016-05-29 09:42:09 +02:00
|
|
|
uniqueID := getUUID()
|
2016-06-28 06:42:33 +02:00
|
|
|
tempErasureObj := path.Join(tmpMetaPrefix, uniqueID, "part.1")
|
2016-06-29 11:28:46 +02:00
|
|
|
minioMetaTmpBucket := path.Join(minioMetaBucket, tmpMetaPrefix)
|
|
|
|
tempObj := uniqueID
|
2016-05-26 01:42:31 +02:00
|
|
|
|
2016-05-21 05:48:47 +02:00
|
|
|
// Initialize md5 writer.
|
|
|
|
md5Writer := md5.New()
|
|
|
|
|
2016-10-03 00:51:49 +02:00
|
|
|
writers := []io.Writer{md5Writer}
|
|
|
|
|
|
|
|
var sha256Writer hash.Hash
|
|
|
|
if sha256sum != "" {
|
|
|
|
sha256Writer = sha256.New()
|
|
|
|
writers = append(writers, sha256Writer)
|
|
|
|
}
|
|
|
|
|
2016-07-09 05:34:27 +02:00
|
|
|
// Proceed to set the cache.
|
|
|
|
var newBuffer io.WriteCloser
|
|
|
|
|
|
|
|
// If caching is enabled, proceed to set the cache.
|
|
|
|
if size > 0 && xl.objCacheEnabled {
|
|
|
|
// PutObject invalidates any previously cached object in memory.
|
|
|
|
xl.objCache.Delete(path.Join(bucket, object))
|
|
|
|
|
|
|
|
// Create a new entry in memory of size.
|
|
|
|
newBuffer, err = xl.objCache.Create(path.Join(bucket, object), size)
|
|
|
|
if err == nil {
|
|
|
|
// Create a multi writer to write to both memory and client response.
|
2016-10-03 00:51:49 +02:00
|
|
|
writers = append(writers, newBuffer)
|
2016-07-09 05:34:27 +02:00
|
|
|
}
|
|
|
|
// Ignore error if cache is full, proceed to write the object.
|
|
|
|
if err != nil && err != objcache.ErrCacheFull {
|
|
|
|
// For any other error return here.
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, toObjectErr(traceError(err), bucket, object)
|
2016-07-09 05:34:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-03 00:51:49 +02:00
|
|
|
mw := io.MultiWriter(writers...)
|
|
|
|
|
2016-07-01 23:33:28 +02:00
|
|
|
// Limit the reader to its provided size if specified.
|
2016-07-05 10:04:50 +02:00
|
|
|
var limitDataReader io.Reader
|
2016-07-01 23:33:28 +02:00
|
|
|
if size > 0 {
|
|
|
|
// This is done so that we can avoid erroneous clients sending
|
|
|
|
// more data than the set content size.
|
2016-07-05 10:04:50 +02:00
|
|
|
limitDataReader = io.LimitReader(data, size)
|
|
|
|
} else {
|
|
|
|
// else we read till EOF.
|
|
|
|
limitDataReader = data
|
|
|
|
}
|
2016-07-01 23:33:28 +02:00
|
|
|
|
2016-07-05 10:04:50 +02:00
|
|
|
// Tee reader combines incoming data stream and md5, data read from input stream is written to md5.
|
2016-07-09 05:34:27 +02:00
|
|
|
teeReader := io.TeeReader(limitDataReader, mw)
|
2016-06-02 01:43:31 +02:00
|
|
|
|
2016-07-13 20:56:25 +02:00
|
|
|
// Initialize xl meta.
|
|
|
|
xlMeta := newXLMetaV1(object, xl.dataBlocks, xl.parityBlocks)
|
|
|
|
|
2016-07-14 23:59:01 +02:00
|
|
|
onlineDisks := getOrderedDisks(xlMeta.Erasure.Distribution, xl.storageDisks)
|
2016-06-02 01:43:31 +02:00
|
|
|
|
2016-07-14 23:59:01 +02:00
|
|
|
// Erasure code data and write across all disks.
|
2016-07-28 11:20:34 +02:00
|
|
|
sizeWritten, checkSums, err := erasureCreateFile(onlineDisks, minioMetaBucket, tempErasureObj, teeReader, xlMeta.Erasure.BlockSize, xlMeta.Erasure.DataBlocks, xlMeta.Erasure.ParityBlocks, bitRotAlgo, xl.writeQuorum)
|
2016-06-02 01:43:31 +02:00
|
|
|
if err != nil {
|
2016-07-19 04:06:48 +02:00
|
|
|
// Create file failed, delete temporary object.
|
|
|
|
xl.deleteObject(minioMetaTmpBucket, tempObj)
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, toObjectErr(err, minioMetaBucket, tempErasureObj)
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-07-19 04:06:48 +02:00
|
|
|
// Should return IncompleteBody{} error when reader has fewer bytes
|
|
|
|
// than specified in request header.
|
|
|
|
if sizeWritten < size {
|
|
|
|
// Short write, delete temporary object.
|
|
|
|
xl.deleteObject(minioMetaTmpBucket, tempObj)
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, traceError(IncompleteBody{})
|
2016-07-19 04:06:48 +02:00
|
|
|
}
|
2016-07-01 23:33:28 +02:00
|
|
|
|
|
|
|
// For size == -1, perhaps client is sending in chunked encoding
|
|
|
|
// set the size as size that was actually written.
|
2016-06-03 02:09:47 +02:00
|
|
|
if size == -1 {
|
2016-07-01 23:33:28 +02:00
|
|
|
size = sizeWritten
|
2016-06-03 02:09:47 +02:00
|
|
|
}
|
2016-07-01 23:33:28 +02:00
|
|
|
|
2016-05-21 05:48:47 +02:00
|
|
|
// Save additional erasureMetadata.
|
|
|
|
modTime := time.Now().UTC()
|
|
|
|
|
|
|
|
newMD5Hex := hex.EncodeToString(md5Writer.Sum(nil))
|
|
|
|
// Update the md5sum if not set with the newly calculated one.
|
|
|
|
if len(metadata["md5Sum"]) == 0 {
|
|
|
|
metadata["md5Sum"] = newMD5Hex
|
|
|
|
}
|
2016-06-02 01:43:31 +02:00
|
|
|
|
2016-06-17 06:42:02 +02:00
|
|
|
// Guess content-type from the extension if possible.
|
2016-05-21 05:48:47 +02:00
|
|
|
if metadata["content-type"] == "" {
|
2016-08-17 22:26:08 +02:00
|
|
|
if objectExt := path.Ext(object); objectExt != "" {
|
2016-06-17 06:42:02 +02:00
|
|
|
if content, ok := mimedb.DB[strings.ToLower(strings.TrimPrefix(objectExt, "."))]; ok {
|
|
|
|
metadata["content-type"] = content.ContentType
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// md5Hex representation.
|
|
|
|
md5Hex := metadata["md5Sum"]
|
|
|
|
if md5Hex != "" {
|
|
|
|
if newMD5Hex != md5Hex {
|
2016-06-02 01:43:31 +02:00
|
|
|
// MD5 mismatch, delete the temporary object.
|
2016-06-29 11:28:46 +02:00
|
|
|
xl.deleteObject(minioMetaTmpBucket, tempObj)
|
2016-06-02 01:43:31 +02:00
|
|
|
// Returns md5 mismatch.
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, traceError(BadDigest{md5Hex, newMD5Hex})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-03 00:51:49 +02:00
|
|
|
if sha256sum != "" {
|
|
|
|
newSHA256sum := hex.EncodeToString(sha256Writer.Sum(nil))
|
|
|
|
if newSHA256sum != sha256sum {
|
|
|
|
// SHA256 mismatch, delete the temporary object.
|
|
|
|
xl.deleteObject(minioMetaBucket, tempObj)
|
|
|
|
return ObjectInfo{}, traceError(SHA256Mismatch{})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-28 03:28:46 +02:00
|
|
|
// get a random ID for lock instrumentation.
|
2016-10-03 00:51:49 +02:00
|
|
|
// generates random string on setting MINIO_DEBUG=lock, else returns empty string.
|
|
|
|
// used for instrumentation on locks.
|
2016-08-31 20:39:08 +02:00
|
|
|
opsID := getOpsID()
|
|
|
|
|
2016-07-13 20:56:25 +02:00
|
|
|
// Lock the object.
|
2016-08-31 20:39:08 +02:00
|
|
|
nsMutex.Lock(bucket, object, opsID)
|
|
|
|
defer nsMutex.Unlock(bucket, object, opsID)
|
2016-07-13 20:56:25 +02:00
|
|
|
|
2016-05-21 05:48:47 +02:00
|
|
|
// Check if an object is present as one of the parent dir.
|
2016-06-02 01:43:31 +02:00
|
|
|
// -- FIXME. (needs a new kind of lock).
|
2016-05-21 05:48:47 +02:00
|
|
|
if xl.parentDirIsObject(bucket, path.Dir(object)) {
|
2016-07-19 04:06:48 +02:00
|
|
|
// Parent (in the namespace) is an object, delete temporary object.
|
|
|
|
xl.deleteObject(minioMetaTmpBucket, tempObj)
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, toObjectErr(traceError(errFileAccessDenied), bucket, object)
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-05-29 09:42:09 +02:00
|
|
|
// Rename if an object already exists to temporary location.
|
|
|
|
newUniqueID := getUUID()
|
2016-06-20 15:18:47 +02:00
|
|
|
if xl.isObject(bucket, object) {
|
2016-07-27 20:57:08 +02:00
|
|
|
// NOTE: Do not use online disks slice here.
|
|
|
|
// The reason is that existing object should be purged
|
|
|
|
// regardless of `xl.json` status and rolled back in case of errors.
|
2016-07-20 04:24:32 +02:00
|
|
|
err = renameObject(xl.storageDisks, bucket, object, minioMetaTmpBucket, newUniqueID, xl.writeQuorum)
|
2016-06-20 15:18:47 +02:00
|
|
|
if err != nil {
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, toObjectErr(err, bucket, object)
|
2016-06-20 15:18:47 +02:00
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-05-27 04:55:48 +02:00
|
|
|
// Fill all the necessary metadata.
|
2016-05-21 05:48:47 +02:00
|
|
|
xlMeta.Meta = metadata
|
|
|
|
xlMeta.Stat.Size = size
|
|
|
|
xlMeta.Stat.ModTime = modTime
|
2016-07-13 00:20:31 +02:00
|
|
|
|
2016-06-01 05:23:31 +02:00
|
|
|
// Add the final part.
|
2016-06-28 06:42:33 +02:00
|
|
|
xlMeta.AddObjectPart(1, "part.1", newMD5Hex, xlMeta.Stat.Size)
|
2016-05-29 09:42:09 +02:00
|
|
|
|
2016-07-14 23:59:01 +02:00
|
|
|
partsMetadata := make([]xlMetaV1, len(xl.storageDisks))
|
2016-06-02 01:43:31 +02:00
|
|
|
// Update `xl.json` content on each disks.
|
2016-06-01 05:23:31 +02:00
|
|
|
for index := range partsMetadata {
|
|
|
|
partsMetadata[index] = xlMeta
|
2016-07-28 11:20:34 +02:00
|
|
|
partsMetadata[index].Erasure.AddCheckSumInfo(checkSumInfo{
|
|
|
|
Name: "part.1",
|
|
|
|
Hash: checkSums[index],
|
|
|
|
Algorithm: bitRotAlgo,
|
|
|
|
})
|
2016-06-01 05:23:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Write unique `xl.json` for each disk.
|
2016-07-20 04:24:32 +02:00
|
|
|
if err = writeUniqueXLMetadata(onlineDisks, minioMetaTmpBucket, tempObj, partsMetadata, xl.writeQuorum); err != nil {
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, toObjectErr(err, bucket, object)
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-05-29 09:42:09 +02:00
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// Rename the successfully written temporary object to final location.
|
2016-07-20 04:24:32 +02:00
|
|
|
err = renameObject(onlineDisks, minioMetaTmpBucket, tempObj, bucket, object, xl.writeQuorum)
|
2016-05-29 09:42:09 +02:00
|
|
|
if err != nil {
|
2016-09-02 21:18:35 +02:00
|
|
|
return ObjectInfo{}, toObjectErr(err, bucket, object)
|
2016-05-29 00:13:15 +02:00
|
|
|
}
|
2016-05-29 09:42:09 +02:00
|
|
|
|
|
|
|
// Delete the temporary object.
|
2016-06-29 11:28:46 +02:00
|
|
|
xl.deleteObject(minioMetaTmpBucket, newUniqueID)
|
2016-05-29 09:42:09 +02:00
|
|
|
|
2016-07-09 05:34:27 +02:00
|
|
|
// Once we have successfully renamed the object, Close the buffer which would
|
|
|
|
// save the object on cache.
|
|
|
|
if size > 0 && xl.objCacheEnabled && newBuffer != nil {
|
|
|
|
newBuffer.Close()
|
|
|
|
}
|
|
|
|
|
2016-09-02 21:18:35 +02:00
|
|
|
objInfo = ObjectInfo{
|
|
|
|
IsDir: false,
|
|
|
|
Bucket: bucket,
|
|
|
|
Name: object,
|
|
|
|
Size: xlMeta.Stat.Size,
|
|
|
|
ModTime: xlMeta.Stat.ModTime,
|
|
|
|
MD5Sum: xlMeta.Meta["md5Sum"],
|
|
|
|
ContentType: xlMeta.Meta["content-type"],
|
|
|
|
ContentEncoding: xlMeta.Meta["content-encoding"],
|
|
|
|
UserDefined: xlMeta.Meta,
|
|
|
|
}
|
|
|
|
return objInfo, nil
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// deleteObject - wrapper for delete object, deletes an object from
|
|
|
|
// all the disks in parallel, including `xl.json` associated with the
|
|
|
|
// object.
|
2016-05-21 05:48:47 +02:00
|
|
|
func (xl xlObjects) deleteObject(bucket, object string) error {
|
|
|
|
// Initialize sync waitgroup.
|
|
|
|
var wg = &sync.WaitGroup{}
|
|
|
|
|
|
|
|
// Initialize list of errors.
|
|
|
|
var dErrs = make([]error, len(xl.storageDisks))
|
|
|
|
|
|
|
|
for index, disk := range xl.storageDisks {
|
2016-06-03 01:34:15 +02:00
|
|
|
if disk == nil {
|
2016-08-25 18:39:01 +02:00
|
|
|
dErrs[index] = traceError(errDiskNotFound)
|
2016-06-03 01:34:15 +02:00
|
|
|
continue
|
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
wg.Add(1)
|
|
|
|
go func(index int, disk StorageAPI) {
|
|
|
|
defer wg.Done()
|
2016-05-25 23:32:49 +02:00
|
|
|
err := cleanupDir(disk, bucket, object)
|
2016-08-25 18:39:01 +02:00
|
|
|
if err != nil && errorCause(err) != errVolumeNotFound {
|
2016-05-25 23:32:49 +02:00
|
|
|
dErrs[index] = err
|
|
|
|
}
|
2016-05-21 05:48:47 +02:00
|
|
|
}(index, disk)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for all routines to finish.
|
|
|
|
wg.Wait()
|
|
|
|
|
2016-07-13 09:29:48 +02:00
|
|
|
// Do we have write quorum?
|
|
|
|
if !isDiskQuorum(dErrs, xl.writeQuorum) {
|
|
|
|
// Return errXLWriteQuorum if errors were more than allowed write quorum.
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(errXLWriteQuorum)
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-06-02 01:43:31 +02:00
|
|
|
// DeleteObject - deletes an object, this call doesn't necessary reply
|
|
|
|
// any error as it is not necessary for the handler to reply back a
|
|
|
|
// response to the client request.
|
2016-06-07 20:35:03 +02:00
|
|
|
func (xl xlObjects) DeleteObject(bucket, object string) (err error) {
|
2016-05-21 05:48:47 +02:00
|
|
|
// Verify if bucket is valid.
|
|
|
|
if !IsValidBucketName(bucket) {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(BucketNameInvalid{Bucket: bucket})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
|
|
|
if !IsValidObjectName(object) {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(ObjectNameInvalid{Bucket: bucket, Object: object})
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|
2016-08-31 20:39:08 +02:00
|
|
|
|
2016-09-28 03:28:46 +02:00
|
|
|
// get a random ID for lock instrumentation.
|
2016-08-31 20:39:08 +02:00
|
|
|
opsID := getOpsID()
|
|
|
|
|
|
|
|
nsMutex.Lock(bucket, object, opsID)
|
|
|
|
defer nsMutex.Unlock(bucket, object, opsID)
|
2016-06-07 20:35:03 +02:00
|
|
|
|
2016-06-17 20:57:51 +02:00
|
|
|
// Validate object exists.
|
2016-06-17 07:18:43 +02:00
|
|
|
if !xl.isObject(bucket, object) {
|
2016-08-25 18:39:01 +02:00
|
|
|
return traceError(ObjectNotFound{bucket, object})
|
2016-06-17 20:57:51 +02:00
|
|
|
} // else proceed to delete the object.
|
2016-06-17 07:18:43 +02:00
|
|
|
|
2016-06-17 20:57:51 +02:00
|
|
|
// Delete the object on all disks.
|
|
|
|
err = xl.deleteObject(bucket, object)
|
|
|
|
if err != nil {
|
|
|
|
return toObjectErr(err, bucket, object)
|
2016-06-07 20:35:03 +02:00
|
|
|
}
|
|
|
|
|
2016-07-06 19:25:42 +02:00
|
|
|
// Delete from the cache.
|
|
|
|
xl.objCache.Delete(pathJoin(bucket, object))
|
|
|
|
|
2016-06-17 20:57:51 +02:00
|
|
|
// Success.
|
|
|
|
return nil
|
2016-05-21 05:48:47 +02:00
|
|
|
}
|