2016-06-01 19:43:31 -04:00
/ *
2017-03-18 14:28:41 -04:00
* Minio Cloud Storage , ( C ) 2016 , 2017 Minio , Inc .
2016-06-01 19:43:31 -04: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 .
* /
2016-08-18 19:23:42 -04:00
package cmd
2016-05-20 23:48:47 -04:00
import (
"encoding/hex"
"io"
"path"
2017-01-30 18:44:42 -05:00
"strconv"
2016-05-20 23:48:47 -04:00
"strings"
"sync"
2016-07-25 17:17:01 -04:00
"github.com/minio/minio/pkg/bpool"
2016-05-20 23:48:47 -04:00
"github.com/minio/minio/pkg/mimedb"
2016-07-03 19:58:21 -04:00
"github.com/minio/minio/pkg/objcache"
2016-05-20 23:48:47 -04:00
)
2016-11-20 19:57:12 -05:00
// list all errors which can be ignored in object operations.
2017-02-01 14:16:17 -05:00
var objectOpIgnoredErrs = append ( baseIgnoredErrs , errDiskAccessDenied )
2016-11-20 19:57:12 -05:00
2017-03-07 17:48:56 -05:00
// prepareFile hints the bottom layer to optimize the creation of a new object
func ( xl xlObjects ) prepareFile ( bucket , object string , size int64 , onlineDisks [ ] StorageAPI , blockSize int64 , dataBlocks int ) error {
pErrs := make ( [ ] error , len ( onlineDisks ) )
// Calculate the real size of the part in one disk.
actualSize := xl . sizeOnDisk ( size , blockSize , dataBlocks )
// Prepare object creation in a all disks
for index , disk := range onlineDisks {
if disk != nil {
if err := disk . PrepareFile ( bucket , object , actualSize ) ; err != nil {
// Save error to reduce it later
pErrs [ index ] = err
// Ignore later access to disk which generated the error
onlineDisks [ index ] = nil
}
}
}
return reduceWriteQuorumErrs ( pErrs , objectOpIgnoredErrs , xl . writeQuorum )
}
2016-05-20 23:48:47 -04:00
/// Object Operations
2016-12-26 19:29:26 -05:00
// CopyObject - copy object source object to destination object.
// if source object and destination object are same we only
// update metadata.
2017-06-21 22:53:09 -04:00
func ( xl xlObjects ) CopyObject ( srcBucket , srcObject , dstBucket , dstObject string , metadata map [ string ] string ) ( oi ObjectInfo , e error ) {
2016-12-26 19:29:26 -05:00
// Read metadata associated with the object from all disks.
metaArr , errs := readAllXLMetadata ( xl . storageDisks , srcBucket , srcObject )
if reducedErr := reduceReadQuorumErrs ( errs , objectOpIgnoredErrs , xl . readQuorum ) ; reducedErr != nil {
2017-06-21 22:53:09 -04:00
return oi , toObjectErr ( reducedErr , srcBucket , srcObject )
2016-12-26 19:29:26 -05:00
}
// List all online disks.
onlineDisks , modTime := listOnlineDisks ( xl . storageDisks , metaArr , errs )
// Pick latest valid metadata.
xlMeta , err := pickValidXLMeta ( metaArr , modTime )
if err != nil {
2017-06-21 22:53:09 -04:00
return oi , toObjectErr ( err , srcBucket , srcObject )
2016-12-26 19:29:26 -05:00
}
// Reorder online disks based on erasure distribution order.
2017-02-24 12:20:40 -05:00
onlineDisks = shuffleDisks ( onlineDisks , xlMeta . Erasure . Distribution )
2016-12-26 19:29:26 -05:00
// Length of the file to read.
length := xlMeta . Stat . Size
// Check if this request is only metadata update.
2017-02-18 16:41:59 -05:00
cpMetadataOnly := isStringEqual ( pathJoin ( srcBucket , srcObject ) , pathJoin ( dstBucket , dstObject ) )
2016-12-26 19:29:26 -05:00
if cpMetadataOnly {
xlMeta . Meta = metadata
partsMetadata := make ( [ ] xlMetaV1 , len ( xl . storageDisks ) )
// Update `xl.json` content on each disks.
for index := range partsMetadata {
partsMetadata [ index ] = xlMeta
}
tempObj := mustGetUUID ( )
// Write unique `xl.json` for each disk.
2017-06-14 20:14:27 -04:00
if onlineDisks , err = writeUniqueXLMetadata ( onlineDisks , minioMetaTmpBucket , tempObj , partsMetadata , xl . writeQuorum ) ; err != nil {
2017-06-21 22:53:09 -04:00
return oi , toObjectErr ( err , srcBucket , srcObject )
2016-12-26 19:29:26 -05:00
}
// Rename atomically `xl.json` from tmp location to destination for each disk.
2017-08-23 20:58:52 -04:00
if _ , err = renameXLMetadata ( onlineDisks , minioMetaTmpBucket , tempObj , srcBucket , srcObject , xl . writeQuorum ) ; err != nil {
2017-06-21 22:53:09 -04:00
return oi , toObjectErr ( err , srcBucket , srcObject )
2016-12-26 19:29:26 -05:00
}
2017-05-14 15:05:51 -04:00
return xlMeta . ToObjectInfo ( srcBucket , srcObject ) , nil
2016-12-26 19:29:26 -05:00
}
// Initialize pipe.
pipeReader , pipeWriter := io . Pipe ( )
go func ( ) {
2017-02-24 12:20:40 -05:00
var startOffset int64 // Read the whole file.
2016-12-26 19:29:26 -05:00
if gerr := xl . GetObject ( srcBucket , srcObject , startOffset , length , pipeWriter ) ; gerr != nil {
errorIf ( gerr , "Unable to read %s of the object `%s/%s`." , srcBucket , srcObject )
pipeWriter . CloseWithError ( toObjectErr ( gerr , srcBucket , srcObject ) )
return
}
pipeWriter . Close ( ) // Close writer explicitly signalling we wrote all data.
} ( )
2017-09-19 15:40:27 -04:00
objInfo , err := xl . PutObject ( dstBucket , dstObject , NewHashReader ( pipeReader , length , metadata [ "etag" ] , "" ) , metadata )
2016-12-26 19:29:26 -05:00
if err != nil {
2017-06-21 22:53:09 -04:00
return oi , toObjectErr ( err , dstBucket , dstObject )
2016-12-26 19:29:26 -05:00
}
// Explicitly close the reader.
pipeReader . Close ( )
return objInfo , nil
}
2016-06-01 19:43:31 -04:00
// GetObject - reads an object erasured coded across multiple
// disks. Supports additional parameters like offset and length
2016-12-26 19:29:26 -05:00
// which are synonymous with HTTP Range requests.
2016-06-01 19:43:31 -04:00
//
2016-12-26 19:29:26 -05:00
// startOffset indicates the starting read location of the object.
// length indicates the total length of the object.
2016-05-28 18:13:15 -04:00
func ( xl xlObjects ) GetObject ( bucket , object string , startOffset int64 , length int64 , writer io . Writer ) error {
2016-12-02 02:15:17 -05:00
if err := checkGetObjArgs ( bucket , object ) ; err != nil {
return err
2016-05-20 23:48:47 -04:00
}
2016-12-21 14:29:32 -05:00
// Start offset cannot be negative.
if startOffset < 0 {
2016-08-25 12:39:01 -04:00
return traceError ( errUnexpected )
2016-07-07 04:30:34 -04:00
}
2016-12-21 14:29:32 -05:00
2016-07-08 10:46:49 -04:00
// Writer cannot be nil.
if writer == nil {
2016-08-25 12:39:01 -04:00
return traceError ( errUnexpected )
2016-07-08 10:46:49 -04:00
}
2016-08-31 14:39:08 -04:00
2016-05-31 23:23:31 -04:00
// Read metadata associated with the object from all disks.
2016-07-11 20:24:49 -04:00
metaArr , errs := readAllXLMetadata ( xl . storageDisks , bucket , object )
2016-11-21 04:47:26 -05:00
if reducedErr := reduceReadQuorumErrs ( errs , objectOpIgnoredErrs , xl . readQuorum ) ; reducedErr != nil {
2016-07-19 22:24:32 -04:00
return toObjectErr ( reducedErr , bucket , object )
2016-07-09 16:01:32 -04:00
}
2016-05-25 19:42:31 -04:00
// List all online disks.
2016-07-14 17:59:01 -04:00
onlineDisks , modTime := listOnlineDisks ( xl . storageDisks , metaArr , errs )
2016-05-26 22:55:48 -04:00
2016-06-17 01:26:18 -04:00
// Pick latest valid metadata.
2016-11-20 23:56:44 -05:00
xlMeta , err := pickValidXLMeta ( metaArr , modTime )
if err != nil {
return err
}
2016-07-25 01:49:27 -04:00
// Reorder online disks based on erasure distribution order.
2017-02-24 12:20:40 -05:00
onlineDisks = shuffleDisks ( onlineDisks , xlMeta . Erasure . Distribution )
2016-07-25 01:49:27 -04:00
// Reorder parts metadata based on erasure distribution order.
2017-02-24 12:20:40 -05:00
metaArr = shufflePartsMetadata ( metaArr , xlMeta . Erasure . Distribution )
2016-05-25 19:42:31 -04:00
2016-12-21 14:29:32 -05:00
// For negative length read everything.
if length < 0 {
length = xlMeta . Stat . Size - startOffset
2016-07-08 10:46:49 -04:00
}
2016-12-21 14:29:32 -05:00
// Reply back invalid range if the input offset and length fall out of range.
if startOffset > xlMeta . Stat . Size || startOffset + length > xlMeta . Stat . Size {
2016-08-25 12:39:01 -04:00
return traceError ( InvalidRange { startOffset , length , xlMeta . Stat . Size } )
2016-07-08 10:46:49 -04:00
}
2016-06-19 16:35:26 -04:00
// Get start part index and offset.
2016-05-31 23:23:31 -04:00
partIndex , partOffset , err := xlMeta . ObjectToPartOffset ( startOffset )
2016-05-20 23:48:47 -04:00
if err != nil {
2016-08-25 12:39:01 -04:00
return traceError ( InvalidRange { startOffset , length , xlMeta . Stat . Size } )
2016-05-20 23:48:47 -04:00
}
2016-05-31 23:23:31 -04:00
2017-01-27 13:51:02 -05:00
// Calculate endOffset according to length
endOffset := startOffset
if length > 0 {
endOffset += length - 1
}
2016-06-19 16:35:26 -04:00
// Get last part index to read given length.
2017-01-27 13:51:02 -05:00
lastPartIndex , _ , err := xlMeta . ObjectToPartOffset ( endOffset )
2016-06-19 16:35:26 -04:00
if err != nil {
2016-08-25 12:39:01 -04:00
return traceError ( InvalidRange { startOffset , length , xlMeta . Stat . Size } )
2016-06-19 16:35:26 -04:00
}
2016-07-03 19:58:21 -04:00
// Save the writer.
mw := writer
// Object cache enabled block.
2016-07-08 23:34:27 -04:00
if xlMeta . Stat . Size > 0 && xl . objCacheEnabled {
2016-07-03 19:58:21 -04:00
// Validate if we have previous cache.
2017-02-11 20:17:58 -05:00
var cachedBuffer io . ReaderAt
2016-09-23 22:55:28 -04:00
cachedBuffer , err = xl . objCache . Open ( path . Join ( bucket , object ) , modTime )
2017-02-11 20:17:58 -05:00
if err == nil { // Cache hit
// Create a new section reader, starting at an offset with length.
reader := io . NewSectionReader ( cachedBuffer , startOffset , length )
// Copy the data out.
if _ , err = io . Copy ( writer , reader ) ; err != nil {
2016-08-25 12:39:01 -04:00
return traceError ( err )
2016-07-03 19:58:21 -04:00
}
2017-02-11 20:17:58 -05:00
// Success.
2016-07-03 19:58:21 -04:00
return nil
2017-02-11 20:17:58 -05:00
2016-07-03 19:58:21 -04:00
} // Cache miss.
2017-02-11 20:17:58 -05:00
2016-07-03 19:58:21 -04:00
// For unknown error, return and error out.
if err != objcache . ErrKeyNotFoundInCache {
2016-08-25 12:39:01 -04:00
return traceError ( err )
2016-07-03 19:58:21 -04: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 04:04:50 -04:00
// Proceed to set the cache.
2016-07-06 04:29:49 -04:00
var newBuffer io . WriteCloser
2016-07-03 19:58:21 -04:00
// Create a new entry in memory of length.
newBuffer , err = xl . objCache . Create ( path . Join ( bucket , object ) , length )
2016-07-05 04:04:50 -04:00
if err == nil {
// Create a multi writer to write to both memory and client response.
mw = io . MultiWriter ( newBuffer , writer )
2016-07-06 04:29:49 -04:00
defer newBuffer . Close ( )
2016-07-05 04:04:50 -04:00
}
2016-07-08 23:34:27 -04:00
// Ignore error if cache is full, proceed to write the object.
2016-07-05 04:04:50 -04:00
if err != nil && err != objcache . ErrCacheFull {
2016-07-08 23:34:27 -04:00
// For any other error return here.
2016-08-25 12:39:01 -04:00
return toObjectErr ( traceError ( err ) , bucket , object )
2016-07-03 19:58:21 -04:00
}
}
}
2017-02-24 12:20:40 -05:00
var totalBytesRead int64
2016-07-25 17:17:01 -04:00
chunkSize := getChunkSize ( xlMeta . Erasure . BlockSize , xlMeta . Erasure . DataBlocks )
pool := bpool . NewBytePool ( chunkSize , len ( onlineDisks ) )
2017-08-14 21:08:42 -04:00
storage , err := NewErasureStorage ( onlineDisks , xlMeta . Erasure . DataBlocks , xlMeta . Erasure . ParityBlocks )
if err != nil {
return toObjectErr ( err , bucket , object )
}
checksums := make ( [ ] [ ] byte , len ( storage . disks ) )
2016-06-19 16:35:26 -04:00
for ; partIndex <= lastPartIndex ; partIndex ++ {
2016-06-21 17:34:11 -04:00
if length == totalBytesRead {
break
}
2016-05-31 23:23:31 -04:00
// Save the current part name and size.
partName := xlMeta . Parts [ partIndex ] . Name
partSize := xlMeta . Parts [ partIndex ] . Size
2016-06-22 12:05:03 -04:00
2016-06-21 17:34:11 -04:00
readSize := partSize - partOffset
2016-06-22 12:05:03 -04:00
// readSize should be adjusted so that we don't write more data than what was requested.
2016-06-21 17:34:11 -04:00
if readSize > ( length - totalBytesRead ) {
readSize = length - totalBytesRead
2016-06-19 16:35:26 -04:00
}
2016-05-31 23:23:31 -04:00
2016-07-16 11:35:30 -04:00
// Get the checksums of the current part.
2017-08-14 21:08:42 -04:00
var algorithm BitrotAlgorithm
for index , disk := range storage . disks {
if disk == OfflineDisk {
2016-07-25 01:49:27 -04:00
continue
}
2017-08-14 21:08:42 -04:00
checksumInfo := metaArr [ index ] . Erasure . GetChecksumInfo ( partName )
algorithm = checksumInfo . Algorithm
checksums [ index ] = checksumInfo . Hash
2016-07-16 11:35:30 -04:00
}
2017-08-14 21:08:42 -04:00
file , err := storage . ReadFile ( mw , bucket , pathJoin ( object , partName ) , partOffset , readSize , partSize , checksums , algorithm , xlMeta . Erasure . BlockSize , pool )
2016-05-31 23:23:31 -04:00
if err != nil {
2016-10-18 16:09:26 -04:00
errorIf ( err , "Unable to read %s of the object `%s/%s`." , partName , bucket , object )
2016-07-08 23:34:27 -04:00
return toObjectErr ( err , bucket , object )
2016-05-31 23:23:31 -04:00
}
2016-07-28 05:20:34 -04:00
// Track total bytes read from disk and written to the client.
2017-08-14 21:08:42 -04:00
totalBytesRead += file . Size
2016-05-31 23:23:31 -04:00
2016-06-22 12:05:03 -04:00
// partOffset will be valid only for the first part, hence reset it to 0 for
// the remaining parts.
2016-05-31 23:23:31 -04:00
partOffset = 0
2016-06-01 19:43:31 -04:00
} // End of read all parts loop.
2016-05-31 23:23:31 -04:00
// Return success.
2016-05-28 18:13:15 -04:00
return nil
2016-05-20 23:48:47 -04:00
}
2016-06-01 19:43:31 -04:00
// GetObjectInfo - reads object metadata and replies back ObjectInfo.
2017-06-21 22:53:09 -04:00
func ( xl xlObjects ) GetObjectInfo ( bucket , object string ) ( oi ObjectInfo , e error ) {
2016-12-02 02:15:17 -05:00
if err := checkGetObjArgs ( bucket , object ) ; err != nil {
2017-06-21 22:53:09 -04:00
return oi , err
2016-05-20 23:48:47 -04:00
}
2016-08-31 14:39:08 -04:00
2016-05-20 23:48:47 -04:00
info , err := xl . getObjectInfo ( bucket , object )
if err != nil {
2017-06-21 22:53:09 -04:00
return oi , toObjectErr ( err , bucket , object )
2016-05-20 23:48:47 -04:00
}
return info , nil
}
2016-06-01 19:43:31 -04:00
// getObjectInfo - wrapper for reading object metadata and constructs ObjectInfo.
2016-05-20 23:48:47 -04:00
func ( xl xlObjects ) getObjectInfo ( bucket , object string ) ( objInfo ObjectInfo , err error ) {
2017-05-14 15:05:51 -04:00
// Extracts xlStat and xlMetaMap.
2016-09-09 01:38:18 -04:00
xlStat , xlMetaMap , err := xl . readXLMetaStat ( bucket , object )
2016-05-25 04:33:39 -04:00
if err != nil {
return ObjectInfo { } , err
2016-05-20 23:48:47 -04:00
}
2016-09-09 01:38:18 -04:00
2016-06-01 19:43:31 -04:00
objInfo = ObjectInfo {
IsDir : false ,
Bucket : bucket ,
Name : object ,
2016-09-09 01:38:18 -04:00
Size : xlStat . Size ,
ModTime : xlStat . ModTime ,
ContentType : xlMetaMap [ "content-type" ] ,
ContentEncoding : xlMetaMap [ "content-encoding" ] ,
2016-06-01 19:43:31 -04:00
}
2016-10-17 11:41:33 -04:00
2017-05-14 15:05:51 -04:00
// Extract etag.
objInfo . ETag = extractETag ( xlMetaMap )
// etag/md5Sum has already been extracted. We need to
// remove to avoid it from appearing as part of
// response headers. e.g, X-Minio-* or X-Amz-*.
objInfo . UserDefined = cleanMetaETag ( xlMetaMap )
2016-10-17 11:41:33 -04:00
2017-05-14 15:05:51 -04:00
// Success.
2016-05-25 04:33:39 -04:00
return objInfo , nil
2016-05-20 23:48:47 -04:00
}
2016-12-26 19:29:26 -05:00
func undoRename ( disks [ ] StorageAPI , srcBucket , srcEntry , dstBucket , dstEntry string , isDir bool , errs [ ] error ) {
2016-06-17 14:57:51 -04:00
var wg = & sync . WaitGroup { }
// Undo rename object on disks where RenameFile succeeded.
2016-06-20 22:11:55 -04:00
// If srcEntry/dstEntry are objects then add a trailing slash to copy
// over all the parts inside the object directory
2016-12-26 19:29:26 -05:00
if isDir {
2016-06-20 22:11:55 -04:00
srcEntry = retainSlash ( srcEntry )
dstEntry = retainSlash ( dstEntry )
}
2016-07-12 01:53:54 -04:00
for index , disk := range disks {
2016-06-17 14:57:51 -04: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-20 22:11:55 -04:00
_ = disk . RenameFile ( dstBucket , dstEntry , srcBucket , srcEntry )
2016-06-17 14:57:51 -04:00
} ( index , disk )
}
wg . Wait ( )
}
2016-06-20 22:11:55 -04:00
// rename - common function that renamePart and renameObject use to rename
// the respective underlying storage layer representations.
2017-06-14 20:14:27 -04:00
func rename ( disks [ ] StorageAPI , srcBucket , srcEntry , dstBucket , dstEntry string , isDir bool , quorum int ) ( [ ] StorageAPI , error ) {
2016-05-20 23:48:47 -04:00
// Initialize sync waitgroup.
var wg = & sync . WaitGroup { }
// Initialize list of errors.
2016-07-12 01:53:54 -04:00
var errs = make ( [ ] error , len ( disks ) )
2016-05-20 23:48:47 -04:00
2016-12-26 19:29:26 -05:00
if isDir {
2016-06-20 22:11:55 -04:00
dstEntry = retainSlash ( dstEntry )
srcEntry = retainSlash ( srcEntry )
}
2016-05-20 23:48:47 -04:00
// Rename file on all underlying storage disks.
2016-07-12 01:53:54 -04:00
for index , disk := range disks {
2016-06-02 19:34:15 -04:00
if disk == nil {
errs [ index ] = errDiskNotFound
continue
}
2016-05-20 23:48:47 -04:00
wg . Add ( 1 )
go func ( index int , disk StorageAPI ) {
defer wg . Done ( )
2016-06-20 22:11:55 -04:00
err := disk . RenameFile ( srcBucket , srcEntry , dstBucket , dstEntry )
2016-06-01 19:43:31 -04:00
if err != nil && err != errFileNotFound {
2016-08-25 12:39:01 -04:00
errs [ index ] = traceError ( err )
2016-05-20 23:48:47 -04:00
}
} ( index , disk )
}
2016-06-01 19:43:31 -04:00
// Wait for all renames to finish.
2016-05-20 23:48:47 -04:00
wg . Wait ( )
// We can safely allow RenameFile errors up to len(xl.storageDisks) - xl.writeQuorum
// otherwise return failure. Cleanup successful renames.
2017-02-01 14:16:17 -05:00
err := reduceWriteQuorumErrs ( errs , objectOpIgnoredErrs , quorum )
if errorCause ( err ) == errXLWriteQuorum {
2016-06-17 14:57:51 -04:00
// Undo all the partial rename operations.
2016-12-26 19:29:26 -05:00
undoRename ( disks , srcBucket , srcEntry , dstBucket , dstEntry , isDir , errs )
2016-05-20 23:48:47 -04:00
}
2017-06-14 20:14:27 -04:00
return evalDisks ( disks , errs ) , err
2016-05-20 23:48:47 -04:00
}
2016-06-20 22:11:55 -04: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.
2017-06-14 20:14:27 -04:00
func renamePart ( disks [ ] StorageAPI , srcBucket , srcPart , dstBucket , dstPart string , quorum int ) ( [ ] StorageAPI , error ) {
2016-12-26 19:29:26 -05:00
isDir := false
return rename ( disks , srcBucket , srcPart , dstBucket , dstPart , isDir , quorum )
2016-06-20 22:11:55 -04: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.
2017-06-14 20:14:27 -04:00
func renameObject ( disks [ ] StorageAPI , srcBucket , srcObject , dstBucket , dstObject string , quorum int ) ( [ ] StorageAPI , error ) {
2016-12-26 19:29:26 -05:00
isDir := true
return rename ( disks , srcBucket , srcObject , dstBucket , dstObject , isDir , quorum )
2016-06-20 22:11:55 -04:00
}
2016-06-01 19:43:31 -04: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.
2017-09-19 15:40:27 -04:00
func ( xl xlObjects ) PutObject ( bucket string , object string , data * HashReader , metadata map [ string ] string ) ( objInfo ObjectInfo , err error ) {
2017-01-20 19:33:01 -05:00
// This is a special case with size as '0' and object ends with
// a slash separator, we treat it like a valid operation and
// return success.
2017-09-19 15:40:27 -04:00
if isObjectDir ( object , data . Size ( ) ) {
2017-02-21 22:43:44 -05:00
// Check if an object is present as one of the parent dir.
// -- FIXME. (needs a new kind of lock).
2017-05-09 17:32:24 -04:00
// -- FIXME (this also causes performance issue when disks are down).
2017-02-21 22:43:44 -05:00
if xl . parentDirIsObject ( bucket , path . Dir ( object ) ) {
return ObjectInfo { } , toObjectErr ( traceError ( errFileAccessDenied ) , bucket , object )
}
2017-09-19 15:40:27 -04:00
return dirObjectInfo ( bucket , object , data . Size ( ) , metadata ) , nil
2017-01-20 19:33:01 -05:00
}
2017-02-21 22:43:44 -05:00
// Validate put object input args.
2016-12-02 02:15:17 -05:00
if err = checkPutObjectArgs ( bucket , object , xl ) ; err != nil {
return ObjectInfo { } , err
2016-05-20 23:48:47 -04:00
}
2017-02-21 22:43:44 -05:00
// Check if an object is present as one of the parent dir.
// -- FIXME. (needs a new kind of lock).
2017-05-09 17:32:24 -04:00
// -- FIXME (this also causes performance issue when disks are down).
2017-02-21 22:43:44 -05:00
if xl . parentDirIsObject ( bucket , path . Dir ( object ) ) {
return ObjectInfo { } , toObjectErr ( traceError ( errFileAccessDenied ) , bucket , object )
}
2016-05-20 23:48:47 -04:00
// No metadata is set, allocate a new one.
if metadata == nil {
metadata = make ( map [ string ] string )
}
2016-08-17 16:26:08 -04:00
2016-11-22 19:52:37 -05:00
uniqueID := mustGetUUID ( )
2016-06-29 05:28:46 -04:00
tempObj := uniqueID
2016-05-25 19:42:31 -04:00
2017-09-19 15:40:27 -04:00
// Limit the reader to its provided size if specified.
var reader io . Reader = data
2016-10-02 18:51:49 -04:00
2016-07-08 23:34:27 -04:00
// Proceed to set the cache.
var newBuffer io . WriteCloser
// If caching is enabled, proceed to set the cache.
2017-09-19 15:40:27 -04:00
if data . Size ( ) > 0 && xl . objCacheEnabled {
2016-07-08 23:34:27 -04:00
// PutObject invalidates any previously cached object in memory.
xl . objCache . Delete ( path . Join ( bucket , object ) )
// Create a new entry in memory of size.
2017-09-19 15:40:27 -04:00
newBuffer , err = xl . objCache . Create ( path . Join ( bucket , object ) , data . Size ( ) )
2016-07-08 23:34:27 -04: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 15:18:35 -04:00
return ObjectInfo { } , toObjectErr ( traceError ( err ) , bucket , object )
2016-07-08 23:34:27 -04:00
}
2017-09-19 15:40:27 -04:00
reader = io . TeeReader ( data , newBuffer )
2016-07-08 23:34:27 -04:00
}
2017-01-30 18:44:42 -05:00
// Initialize parts metadata
partsMetadata := make ( [ ] xlMetaV1 , len ( xl . storageDisks ) )
2016-07-13 14:56:25 -04:00
xlMeta := newXLMetaV1 ( object , xl . dataBlocks , xl . parityBlocks )
2017-01-30 18:44:42 -05:00
// Initialize xl meta.
for index := range partsMetadata {
partsMetadata [ index ] = xlMeta
}
// Order disks according to erasure distribution
2017-02-24 12:20:40 -05:00
onlineDisks := shuffleDisks ( xl . storageDisks , partsMetadata [ 0 ] . Erasure . Distribution )
2016-06-01 19:43:31 -04:00
2017-01-16 20:05:00 -05:00
// Delete temporary object in the event of failure.
// If PutObject succeeded there would be no temporary
// object to delete.
2016-10-20 01:52:03 -04:00
defer xl . deleteObject ( minioMetaTmpBucket , tempObj )
2017-01-30 18:44:42 -05:00
// Total size of the written object
2017-02-24 12:20:40 -05:00
var sizeWritten int64
2017-01-30 18:44:42 -05:00
2017-08-14 21:08:42 -04:00
storage , err := NewErasureStorage ( onlineDisks , xlMeta . Erasure . DataBlocks , xlMeta . Erasure . ParityBlocks )
if err != nil {
return ObjectInfo { } , toObjectErr ( err , bucket , object )
}
buffer := make ( [ ] byte , partsMetadata [ 0 ] . Erasure . BlockSize , 2 * partsMetadata [ 0 ] . Erasure . BlockSize ) // alloc additional space for parity blocks created while erasure coding
2017-01-30 18:44:42 -05:00
// Read data and split into parts - similar to multipart mechanism
for partIdx := 1 ; ; partIdx ++ {
// Compute part name
partName := "part." + strconv . Itoa ( partIdx )
// Compute the path of current part
2017-02-21 22:43:44 -05:00
tempErasureObj := pathJoin ( uniqueID , partName )
2017-01-30 18:44:42 -05:00
// Calculate the size of the current part, if size is unknown, curPartSize wil be unknown too.
// allowEmptyPart will always be true if this is the first part and false otherwise.
2017-01-31 18:34:49 -05:00
var curPartSize int64
2017-09-19 15:40:27 -04:00
curPartSize , err = getPartSizeFromIdx ( data . Size ( ) , globalPutPartSize , partIdx )
2017-01-31 18:34:49 -05:00
if err != nil {
return ObjectInfo { } , toObjectErr ( err , bucket , object )
}
2017-01-30 18:44:42 -05:00
2017-02-24 12:20:40 -05:00
// Hint the filesystem to pre-allocate one continuous large block.
// This is only an optimization.
2017-01-30 18:44:42 -05:00
if curPartSize > 0 {
2017-08-14 21:08:42 -04:00
pErr := xl . prepareFile ( minioMetaTmpBucket , tempErasureObj , curPartSize , storage . disks , xlMeta . Erasure . BlockSize , xlMeta . Erasure . DataBlocks )
2017-03-07 17:48:56 -05:00
if pErr != nil {
return ObjectInfo { } , toObjectErr ( pErr , bucket , object )
2016-10-29 15:44:44 -04:00
}
}
2017-09-19 15:40:27 -04:00
file , erasureErr := storage . CreateFile ( io . LimitReader ( reader , globalPutPartSize ) , minioMetaTmpBucket , tempErasureObj , buffer , DefaultBitrotAlgorithm , xl . writeQuorum )
2017-01-30 18:44:42 -05:00
if erasureErr != nil {
return ObjectInfo { } , toObjectErr ( erasureErr , minioMetaTmpBucket , tempErasureObj )
}
// Should return IncompleteBody{} error when reader has fewer bytes
// than specified in request header.
2017-08-18 14:45:16 -04:00
if file . Size < curPartSize {
2017-01-30 18:44:42 -05:00
return ObjectInfo { } , traceError ( IncompleteBody { } )
}
// Update the total written size
2017-08-14 21:08:42 -04:00
sizeWritten += file . Size
// allowEmpty creating empty earsure file only when this is the first part. This flag is useful
// when size == -1 because in this case, we are not able to predict how many parts we will have.
allowEmpty := partIdx == 1
if file . Size > 0 || allowEmpty {
for i := range partsMetadata {
partsMetadata [ i ] . AddObjectPart ( partIdx , partName , "" , file . Size )
partsMetadata [ i ] . Erasure . AddChecksumInfo ( ChecksumInfo { partName , file . Algorithm , file . Checksums [ i ] } )
2017-01-30 18:44:42 -05:00
}
}
// If we didn't write anything or we know that the next part doesn't have any
// data to write, we should quit this loop immediately
2017-08-14 21:08:42 -04:00
if file . Size == 0 {
2017-01-31 18:34:49 -05:00
break
}
// Check part size for the next index.
var partSize int64
2017-09-19 15:40:27 -04:00
partSize , err = getPartSizeFromIdx ( data . Size ( ) , globalPutPartSize , partIdx + 1 )
2017-01-31 18:34:49 -05:00
if err != nil {
return ObjectInfo { } , toObjectErr ( err , bucket , object )
}
if partSize == 0 {
2017-01-30 18:44:42 -05:00
break
}
2016-07-18 22:06:48 -04:00
}
2016-07-01 17:33:28 -04:00
2017-09-19 15:40:27 -04:00
if size := data . Size ( ) ; size > 0 && sizeWritten < data . Size ( ) {
return ObjectInfo { } , traceError ( IncompleteBody { } )
2016-06-02 20:09:47 -04:00
}
2016-07-01 17:33:28 -04:00
2016-05-20 23:48:47 -04:00
// Save additional erasureMetadata.
2017-03-18 14:28:41 -04:00
modTime := UTCNow ( )
2016-05-20 23:48:47 -04:00
2017-09-19 15:40:27 -04:00
if err = data . Verify ( ) ; err != nil {
return ObjectInfo { } , toObjectErr ( err , bucket , object )
2016-05-20 23:48:47 -04:00
}
2017-09-19 15:40:27 -04:00
metadata [ "etag" ] = hex . EncodeToString ( data . MD5 ( ) )
2016-06-01 19:43:31 -04:00
2016-06-17 00:42:02 -04:00
// Guess content-type from the extension if possible.
2016-05-20 23:48:47 -04:00
if metadata [ "content-type" ] == "" {
2016-08-17 16:26:08 -04:00
if objectExt := path . Ext ( object ) ; objectExt != "" {
2016-06-17 00:42:02 -04:00
if content , ok := mimedb . DB [ strings . ToLower ( strings . TrimPrefix ( objectExt , "." ) ) ] ; ok {
metadata [ "content-type" ] = content . ContentType
2016-05-20 23:48:47 -04:00
}
}
}
2016-06-20 09:18:47 -04:00
if xl . isObject ( bucket , object ) {
2017-02-21 22:43:44 -05:00
// Rename if an object already exists to temporary location.
newUniqueID := mustGetUUID ( )
// Delete successfully renamed object.
2016-10-20 01:52:03 -04:00
defer xl . deleteObject ( minioMetaTmpBucket , newUniqueID )
2016-07-27 14:57:08 -04: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.
2017-06-14 20:14:27 -04:00
_ , err = renameObject ( xl . storageDisks , bucket , object , minioMetaTmpBucket , newUniqueID , xl . writeQuorum )
2016-06-20 09:18:47 -04:00
if err != nil {
2016-09-02 15:18:35 -04:00
return ObjectInfo { } , toObjectErr ( err , bucket , object )
2016-06-20 09:18:47 -04:00
}
2016-05-20 23:48:47 -04:00
}
2016-05-26 22:55:48 -04:00
// Fill all the necessary metadata.
2016-06-01 19:43:31 -04:00
// Update `xl.json` content on each disks.
2016-05-31 23:23:31 -04:00
for index := range partsMetadata {
2017-01-30 18:44:42 -05:00
partsMetadata [ index ] . Meta = metadata
2017-09-19 15:40:27 -04:00
partsMetadata [ index ] . Stat . Size = sizeWritten
2017-01-30 18:44:42 -05:00
partsMetadata [ index ] . Stat . ModTime = modTime
2016-05-31 23:23:31 -04:00
}
// Write unique `xl.json` for each disk.
2017-06-14 20:14:27 -04:00
if onlineDisks , err = writeUniqueXLMetadata ( onlineDisks , minioMetaTmpBucket , tempObj , partsMetadata , xl . writeQuorum ) ; err != nil {
2016-09-02 15:18:35 -04:00
return ObjectInfo { } , toObjectErr ( err , bucket , object )
2016-05-20 23:48:47 -04:00
}
2016-05-29 03:42:09 -04:00
2016-06-01 19:43:31 -04:00
// Rename the successfully written temporary object to final location.
2017-08-23 20:58:52 -04:00
if _ , err = renameObject ( onlineDisks , minioMetaTmpBucket , tempObj , bucket , object , xl . writeQuorum ) ; err != nil {
2016-09-02 15:18:35 -04:00
return ObjectInfo { } , toObjectErr ( err , bucket , object )
2016-05-28 18:13:15 -04:00
}
2016-05-29 03:42:09 -04:00
2016-07-08 23:34:27 -04:00
// Once we have successfully renamed the object, Close the buffer which would
// save the object on cache.
2017-09-19 15:40:27 -04:00
if sizeWritten > 0 && xl . objCacheEnabled && newBuffer != nil {
2016-07-08 23:34:27 -04:00
newBuffer . Close ( )
}
2017-01-30 18:44:42 -05:00
// Object info is the same in all disks, so we can pick the first meta
// of the first disk
xlMeta = partsMetadata [ 0 ]
2016-09-02 15:18:35 -04:00
objInfo = ObjectInfo {
IsDir : false ,
Bucket : bucket ,
Name : object ,
Size : xlMeta . Stat . Size ,
ModTime : xlMeta . Stat . ModTime ,
2017-05-14 15:05:51 -04:00
ETag : xlMeta . Meta [ "etag" ] ,
2016-09-02 15:18:35 -04:00
ContentType : xlMeta . Meta [ "content-type" ] ,
ContentEncoding : xlMeta . Meta [ "content-encoding" ] ,
UserDefined : xlMeta . Meta ,
}
2017-01-16 22:23:43 -05:00
// Success, return object info.
2016-09-02 15:18:35 -04:00
return objInfo , nil
2016-05-20 23:48:47 -04:00
}
2016-06-01 19:43:31 -04:00
// deleteObject - wrapper for delete object, deletes an object from
// all the disks in parallel, including `xl.json` associated with the
// object.
2016-05-20 23:48:47 -04: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-02 19:34:15 -04:00
if disk == nil {
2016-08-25 12:39:01 -04:00
dErrs [ index ] = traceError ( errDiskNotFound )
2016-06-02 19:34:15 -04:00
continue
}
2016-05-20 23:48:47 -04:00
wg . Add ( 1 )
go func ( index int , disk StorageAPI ) {
defer wg . Done ( )
2016-05-25 17:32:49 -04:00
err := cleanupDir ( disk , bucket , object )
2016-08-25 12:39:01 -04:00
if err != nil && errorCause ( err ) != errVolumeNotFound {
2016-05-25 17:32:49 -04:00
dErrs [ index ] = err
}
2016-05-20 23:48:47 -04:00
} ( index , disk )
}
// Wait for all routines to finish.
wg . Wait ( )
2017-02-01 14:16:17 -05:00
return reduceWriteQuorumErrs ( dErrs , objectOpIgnoredErrs , xl . writeQuorum )
2016-05-20 23:48:47 -04:00
}
2016-06-01 19:43:31 -04: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 14:35:03 -04:00
func ( xl xlObjects ) DeleteObject ( bucket , object string ) ( err error ) {
2016-12-02 02:15:17 -05:00
if err = checkDelObjArgs ( bucket , object ) ; err != nil {
return err
2016-05-20 23:48:47 -04:00
}
2016-08-31 14:39:08 -04:00
2016-06-17 14:57:51 -04:00
// Validate object exists.
2016-06-17 01:18:43 -04:00
if ! xl . isObject ( bucket , object ) {
2016-08-25 12:39:01 -04:00
return traceError ( ObjectNotFound { bucket , object } )
2016-06-17 14:57:51 -04:00
} // else proceed to delete the object.
2016-06-17 01:18:43 -04:00
2016-06-17 14:57:51 -04:00
// Delete the object on all disks.
err = xl . deleteObject ( bucket , object )
if err != nil {
return toObjectErr ( err , bucket , object )
2016-06-07 14:35:03 -04:00
}
2016-12-08 23:35:07 -05:00
if xl . objCacheEnabled {
// Delete from the cache.
xl . objCache . Delete ( pathJoin ( bucket , object ) )
}
2016-07-06 13:25:42 -04:00
2016-06-17 14:57:51 -04:00
// Success.
return nil
2016-05-20 23:48:47 -04:00
}