2016-04-30 02:52:17 +02:00
|
|
|
/*
|
2019-04-17 18:52:08 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2016-2019 MinIO, Inc.
|
2016-04-30 02:52:17 +02: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-19 01:23:42 +02:00
|
|
|
package cmd
|
2016-04-30 02:52:17 +02:00
|
|
|
|
2016-05-25 10:33:39 +02:00
|
|
|
import (
|
2018-03-15 21:27:16 +01:00
|
|
|
"context"
|
2018-01-30 03:43:13 +01:00
|
|
|
"path"
|
2016-05-25 10:33:39 +02:00
|
|
|
"sync"
|
2016-11-23 03:18:22 +01:00
|
|
|
|
2019-07-05 23:06:12 +02:00
|
|
|
"strings"
|
|
|
|
|
2016-11-23 03:18:22 +01:00
|
|
|
humanize "github.com/dustin/go-humanize"
|
2018-04-06 00:04:40 +02:00
|
|
|
"github.com/minio/minio/cmd/logger"
|
2016-05-25 10:33:39 +02:00
|
|
|
)
|
2016-04-30 02:52:17 +02:00
|
|
|
|
2016-05-30 00:38:14 +02:00
|
|
|
const (
|
|
|
|
// Block size used for all internal operations version 1.
|
2016-11-23 03:18:22 +01:00
|
|
|
blockSizeV1 = 10 * humanize.MiByte
|
2016-06-25 12:03:27 +02:00
|
|
|
|
|
|
|
// Staging buffer read size for all internal operations version 1.
|
2016-11-23 03:18:22 +01:00
|
|
|
readSizeV1 = 1 * humanize.MiByte
|
2016-07-22 02:31:14 +02:00
|
|
|
|
|
|
|
// Buckets meta prefix.
|
|
|
|
bucketMetaPrefix = "buckets"
|
2017-04-11 04:51:23 +02:00
|
|
|
|
2017-05-14 21:05:51 +02:00
|
|
|
// ETag (hex encoded md5sum) of empty string.
|
|
|
|
emptyETag = "d41d8cd98f00b204e9800998ecf8427e"
|
2016-05-30 00:38:14 +02:00
|
|
|
)
|
|
|
|
|
2016-10-10 08:03:10 +02:00
|
|
|
// Global object layer mutex, used for safely updating object layer.
|
2020-05-04 07:35:40 +02:00
|
|
|
var globalObjLayerMutex sync.RWMutex
|
2016-10-10 08:03:10 +02:00
|
|
|
|
2019-10-31 07:39:09 +01:00
|
|
|
// Global object layer, only accessed by globalObjectAPI.
|
2016-10-10 08:03:10 +02:00
|
|
|
var globalObjectAPI ObjectLayer
|
|
|
|
|
2018-03-28 23:14:06 +02:00
|
|
|
//Global cacheObjects, only accessed by newCacheObjectsFn().
|
|
|
|
var globalCacheObjectAPI CacheObjectLayer
|
|
|
|
|
2017-01-21 01:33:01 +01:00
|
|
|
// Checks if the object is a directory, this logic uses
|
2019-08-06 21:08:58 +02:00
|
|
|
// if size == 0 and object ends with SlashSeparator then
|
2017-01-21 01:33:01 +01:00
|
|
|
// returns true.
|
|
|
|
func isObjectDir(object string, size int64) bool {
|
2019-12-06 08:16:06 +01:00
|
|
|
return HasSuffix(object, SlashSeparator) && size == 0
|
2017-01-21 01:33:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Converts just bucket, object metadata into ObjectInfo datatype.
|
|
|
|
func dirObjectInfo(bucket, object string, size int64, metadata map[string]string) ObjectInfo {
|
|
|
|
// 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-05-14 21:05:51 +02:00
|
|
|
etag := metadata["etag"]
|
|
|
|
delete(metadata, "etag")
|
|
|
|
if etag == "" {
|
|
|
|
etag = emptyETag
|
2017-04-11 04:51:23 +02:00
|
|
|
}
|
|
|
|
|
2017-01-21 01:33:01 +01:00
|
|
|
return ObjectInfo{
|
|
|
|
Bucket: bucket,
|
|
|
|
Name: object,
|
2017-03-18 19:28:41 +01:00
|
|
|
ModTime: UTCNow(),
|
2017-01-21 01:33:01 +01:00
|
|
|
ContentType: "application/octet-stream",
|
|
|
|
IsDir: true,
|
|
|
|
Size: size,
|
2017-05-14 21:05:51 +02:00
|
|
|
ETag: etag,
|
2017-01-21 01:33:01 +01:00
|
|
|
UserDefined: metadata,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-06 00:04:40 +02:00
|
|
|
func deleteBucketMetadata(ctx context.Context, bucket string, objAPI ObjectLayer) {
|
2018-02-13 03:34:30 +01:00
|
|
|
// Delete bucket access policy, if present - ignore any errors.
|
2018-04-25 00:53:30 +02:00
|
|
|
removePolicyConfig(ctx, objAPI, bucket)
|
2018-02-13 03:34:30 +01:00
|
|
|
|
|
|
|
// Delete notification config, if present - ignore any errors.
|
2020-05-08 22:44:44 +02:00
|
|
|
logger.LogIf(ctx, removeNotificationConfig(ctx, objAPI, bucket))
|
|
|
|
|
|
|
|
// Delete bucket meta config, if present - ignore any errors.
|
|
|
|
logger.LogIf(ctx, removeBucketMeta(ctx, objAPI, bucket))
|
2018-02-13 03:34:30 +01:00
|
|
|
}
|
|
|
|
|
2016-06-02 10:49:46 +02:00
|
|
|
// Depending on the disk type network or local, initialize storage API.
|
2017-04-12 00:44:27 +02:00
|
|
|
func newStorageAPI(endpoint Endpoint) (storage StorageAPI, err error) {
|
|
|
|
if endpoint.IsLocal {
|
2019-10-25 19:37:53 +02:00
|
|
|
storage, err := newPosix(endpoint.Path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &posixDiskIDCheck{storage: storage}, nil
|
2016-06-02 10:49:46 +02:00
|
|
|
}
|
2017-04-12 00:44:27 +02:00
|
|
|
|
2019-11-13 21:17:45 +01:00
|
|
|
return newStorageRESTClient(endpoint), nil
|
2016-06-02 10:49:46 +02:00
|
|
|
}
|
|
|
|
|
2016-05-08 19:15:34 +02:00
|
|
|
// Cleanup a directory recursively.
|
2018-04-06 00:04:40 +02:00
|
|
|
func cleanupDir(ctx context.Context, storage StorageAPI, volume, dirPath string) error {
|
2016-05-08 19:15:34 +02:00
|
|
|
var delFunc func(string) error
|
|
|
|
// Function to delete entries recursively.
|
|
|
|
delFunc = func(entryPath string) error {
|
2019-12-06 08:16:06 +01:00
|
|
|
if !HasSuffix(entryPath, SlashSeparator) {
|
2016-07-12 10:01:47 +02:00
|
|
|
// Delete the file entry.
|
2018-04-06 00:04:40 +02:00
|
|
|
err := storage.DeleteFile(volume, entryPath)
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2016-05-08 19:15:34 +02:00
|
|
|
}
|
2016-07-12 10:01:47 +02:00
|
|
|
|
2016-05-08 19:15:34 +02:00
|
|
|
// If it's a directory, list and call delFunc() for each entry.
|
2019-04-23 23:54:28 +02:00
|
|
|
entries, err := storage.ListDir(volume, entryPath, -1, "")
|
2016-07-12 10:01:47 +02:00
|
|
|
// If entryPath prefix never existed, safe to ignore.
|
|
|
|
if err == errFileNotFound {
|
|
|
|
return nil
|
|
|
|
} else if err != nil { // For any other errors fail.
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2016-07-12 10:01:47 +02:00
|
|
|
} // else on success..
|
2016-06-14 10:39:40 +02:00
|
|
|
|
2018-01-30 03:43:13 +01:00
|
|
|
// Entry path is empty, just delete it.
|
|
|
|
if len(entries) == 0 {
|
2019-07-29 23:48:18 +02:00
|
|
|
err = storage.DeleteFile(volume, entryPath)
|
2018-04-06 00:04:40 +02:00
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return err
|
2018-01-30 03:43:13 +01:00
|
|
|
}
|
|
|
|
|
2016-07-12 10:01:47 +02:00
|
|
|
// Recurse and delete all other entries.
|
|
|
|
for _, entry := range entries {
|
|
|
|
if err = delFunc(pathJoin(entryPath, entry)); err != nil {
|
2016-05-08 19:15:34 +02:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2016-06-03 01:34:15 +02:00
|
|
|
err := delFunc(retainSlash(pathJoin(dirPath)))
|
|
|
|
return err
|
2016-05-08 19:15:34 +02:00
|
|
|
}
|
2018-03-15 21:03:41 +01:00
|
|
|
|
|
|
|
// Removes notification.xml for a given bucket, only used during DeleteBucket.
|
2018-04-06 00:04:40 +02:00
|
|
|
func removeNotificationConfig(ctx context.Context, objAPI ObjectLayer, bucket string) error {
|
2018-03-15 21:03:41 +01:00
|
|
|
ncPath := path.Join(bucketConfigPrefix, bucket, bucketNotificationConfig)
|
2020-05-08 22:44:44 +02:00
|
|
|
if err := deleteConfig(ctx, objAPI, ncPath); err != nil && err != errConfigNotFound {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
2018-03-15 21:03:41 +01:00
|
|
|
}
|
|
|
|
|
2019-10-16 03:35:41 +02:00
|
|
|
func listObjectsNonSlash(ctx context.Context, bucket, prefix, marker, delimiter string, maxKeys int, tpool *TreeWalkPool, listDir ListDirFunc, getObjInfo func(context.Context, string, string) (ObjectInfo, error), getObjectInfoDirs ...func(context.Context, string, string) (ObjectInfo, error)) (loi ListObjectsInfo, err error) {
|
2019-07-05 23:06:12 +02:00
|
|
|
endWalkCh := make(chan struct{})
|
|
|
|
defer close(endWalkCh)
|
|
|
|
recursive := true
|
|
|
|
walkResultCh := startTreeWalk(ctx, bucket, prefix, "", recursive, listDir, endWalkCh)
|
|
|
|
|
|
|
|
var objInfos []ObjectInfo
|
|
|
|
var eof bool
|
|
|
|
var prevPrefix string
|
|
|
|
|
|
|
|
for {
|
|
|
|
if len(objInfos) == maxKeys {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
result, ok := <-walkResultCh
|
|
|
|
if !ok {
|
|
|
|
eof = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
var objInfo ObjectInfo
|
|
|
|
var err error
|
|
|
|
|
|
|
|
index := strings.Index(strings.TrimPrefix(result.entry, prefix), delimiter)
|
|
|
|
if index == -1 {
|
|
|
|
objInfo, err = getObjInfo(ctx, bucket, result.entry)
|
|
|
|
if err != nil {
|
|
|
|
// Ignore errFileNotFound as the object might have got
|
|
|
|
// deleted in the interim period of listing and getObjectInfo(),
|
|
|
|
// ignore quorum error as it might be an entry from an outdated disk.
|
|
|
|
if IsErrIgnored(err, []error{
|
|
|
|
errFileNotFound,
|
|
|
|
errXLReadQuorum,
|
|
|
|
}...) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
return loi, toObjectErr(err, bucket, prefix)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
index = len(prefix) + index + len(delimiter)
|
|
|
|
currPrefix := result.entry[:index]
|
|
|
|
if currPrefix == prevPrefix {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
prevPrefix = currPrefix
|
|
|
|
|
|
|
|
objInfo = ObjectInfo{
|
|
|
|
Bucket: bucket,
|
|
|
|
Name: currPrefix,
|
|
|
|
IsDir: true,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if objInfo.Name <= marker {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
objInfos = append(objInfos, objInfo)
|
|
|
|
if result.end {
|
|
|
|
eof = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
result := ListObjectsInfo{}
|
|
|
|
for _, objInfo := range objInfos {
|
|
|
|
if objInfo.IsDir {
|
|
|
|
result.Prefixes = append(result.Prefixes, objInfo.Name)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
result.Objects = append(result.Objects, objInfo)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !eof {
|
|
|
|
result.IsTruncated = true
|
|
|
|
if len(objInfos) > 0 {
|
|
|
|
result.NextMarker = objInfos[len(objInfos)-1].Name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
|
2020-02-25 16:52:28 +01:00
|
|
|
// Walk a bucket, optionally prefix recursively, until we have returned
|
|
|
|
// all the content to objectInfo channel, it is callers responsibility
|
|
|
|
// to allocate a receive channel for ObjectInfo, upon any unhandled
|
|
|
|
// error walker returns error. Optionally if context.Done() is received
|
|
|
|
// then Walk() stops the walker.
|
|
|
|
func fsWalk(ctx context.Context, obj ObjectLayer, bucket, prefix string, listDir ListDirFunc, results chan<- ObjectInfo, getObjInfo func(context.Context, string, string) (ObjectInfo, error), getObjectInfoDirs ...func(context.Context, string, string) (ObjectInfo, error)) error {
|
|
|
|
if err := checkListObjsArgs(ctx, bucket, prefix, "", obj); err != nil {
|
2020-02-26 04:58:58 +01:00
|
|
|
// Upon error close the channel.
|
|
|
|
close(results)
|
2020-02-25 16:52:28 +01:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
walkResultCh := startTreeWalk(ctx, bucket, prefix, "", true, listDir, ctx.Done())
|
|
|
|
|
|
|
|
go func() {
|
|
|
|
defer close(results)
|
|
|
|
|
|
|
|
for {
|
|
|
|
walkResult, ok := <-walkResultCh
|
|
|
|
if !ok {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
var objInfo ObjectInfo
|
|
|
|
var err error
|
|
|
|
if HasSuffix(walkResult.entry, SlashSeparator) {
|
|
|
|
for _, getObjectInfoDir := range getObjectInfoDirs {
|
|
|
|
objInfo, err = getObjectInfoDir(ctx, bucket, walkResult.entry)
|
|
|
|
if err == nil {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
if err == errFileNotFound {
|
|
|
|
err = nil
|
|
|
|
objInfo = ObjectInfo{
|
|
|
|
Bucket: bucket,
|
|
|
|
Name: walkResult.entry,
|
|
|
|
IsDir: true,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
objInfo, err = getObjInfo(ctx, bucket, walkResult.entry)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
results <- objInfo
|
|
|
|
if walkResult.end {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-05-02 07:06:57 +02:00
|
|
|
func listObjects(ctx context.Context, obj ObjectLayer, bucket, prefix, marker, delimiter string, maxKeys int, tpool *TreeWalkPool, listDir ListDirFunc, getObjInfo func(context.Context, string, string) (ObjectInfo, error), getObjectInfoDirs ...func(context.Context, string, string) (ObjectInfo, error)) (loi ListObjectsInfo, err error) {
|
2019-08-06 21:08:58 +02:00
|
|
|
if delimiter != SlashSeparator && delimiter != "" {
|
2019-10-16 03:35:41 +02:00
|
|
|
return listObjectsNonSlash(ctx, bucket, prefix, marker, delimiter, maxKeys, tpool, listDir, getObjInfo, getObjectInfoDirs...)
|
2019-07-05 23:06:12 +02:00
|
|
|
}
|
|
|
|
|
2020-02-25 16:52:28 +01:00
|
|
|
if err := checkListObjsArgs(ctx, bucket, prefix, marker, obj); err != nil {
|
2019-04-17 18:52:08 +02:00
|
|
|
return loi, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Marker is set validate pre-condition.
|
|
|
|
if marker != "" {
|
|
|
|
// Marker not common with prefix is not implemented. Send an empty response
|
2019-12-06 08:16:06 +01:00
|
|
|
if !HasPrefix(marker, prefix) {
|
2019-04-17 18:52:08 +02:00
|
|
|
return loi, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// With max keys of zero we have reached eof, return right here.
|
|
|
|
if maxKeys == 0 {
|
|
|
|
return loi, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// For delimiter and prefix as '/' we do not list anything at all
|
|
|
|
// since according to s3 spec we stop at the 'delimiter'
|
|
|
|
// along // with the prefix. On a flat namespace with 'prefix'
|
|
|
|
// as '/' we don't have any entries, since all the keys are
|
|
|
|
// of form 'keyName/...'
|
2019-08-06 21:08:58 +02:00
|
|
|
if delimiter == SlashSeparator && prefix == SlashSeparator {
|
2019-04-17 18:52:08 +02:00
|
|
|
return loi, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Over flowing count - reset to maxObjectList.
|
|
|
|
if maxKeys < 0 || maxKeys > maxObjectList {
|
|
|
|
maxKeys = maxObjectList
|
|
|
|
}
|
|
|
|
|
|
|
|
// Default is recursive, if delimiter is set then list non recursive.
|
|
|
|
recursive := true
|
2019-08-06 21:08:58 +02:00
|
|
|
if delimiter == SlashSeparator {
|
2019-04-17 18:52:08 +02:00
|
|
|
recursive = false
|
|
|
|
}
|
|
|
|
|
2020-01-30 12:50:07 +01:00
|
|
|
walkResultCh, endWalkCh := tpool.Release(listParams{bucket, recursive, marker, prefix})
|
2019-04-17 18:52:08 +02:00
|
|
|
if walkResultCh == nil {
|
|
|
|
endWalkCh = make(chan struct{})
|
2019-05-02 07:06:57 +02:00
|
|
|
walkResultCh = startTreeWalk(ctx, bucket, prefix, marker, recursive, listDir, endWalkCh)
|
2019-04-17 18:52:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
var objInfos []ObjectInfo
|
|
|
|
var eof bool
|
|
|
|
var nextMarker string
|
|
|
|
|
|
|
|
// List until maxKeys requested.
|
|
|
|
for i := 0; i < maxKeys; {
|
|
|
|
walkResult, ok := <-walkResultCh
|
|
|
|
if !ok {
|
|
|
|
// Closed channel.
|
|
|
|
eof = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
var objInfo ObjectInfo
|
|
|
|
var err error
|
2019-12-06 08:16:06 +01:00
|
|
|
if HasSuffix(walkResult.entry, SlashSeparator) {
|
2019-04-17 18:52:08 +02:00
|
|
|
for _, getObjectInfoDir := range getObjectInfoDirs {
|
|
|
|
objInfo, err = getObjectInfoDir(ctx, bucket, walkResult.entry)
|
|
|
|
if err == nil {
|
|
|
|
break
|
|
|
|
}
|
2019-04-23 23:54:28 +02:00
|
|
|
if err == errFileNotFound {
|
|
|
|
err = nil
|
|
|
|
objInfo = ObjectInfo{
|
|
|
|
Bucket: bucket,
|
|
|
|
Name: walkResult.entry,
|
|
|
|
IsDir: true,
|
|
|
|
}
|
|
|
|
}
|
2019-04-17 18:52:08 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
objInfo, err = getObjInfo(ctx, bucket, walkResult.entry)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
// Ignore errFileNotFound as the object might have got
|
|
|
|
// deleted in the interim period of listing and getObjectInfo(),
|
|
|
|
// ignore quorum error as it might be an entry from an outdated disk.
|
|
|
|
if IsErrIgnored(err, []error{
|
|
|
|
errFileNotFound,
|
|
|
|
errXLReadQuorum,
|
|
|
|
}...) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
return loi, toObjectErr(err, bucket, prefix)
|
|
|
|
}
|
|
|
|
nextMarker = objInfo.Name
|
|
|
|
objInfos = append(objInfos, objInfo)
|
|
|
|
if walkResult.end {
|
|
|
|
eof = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save list routine for the next marker if we haven't reached EOF.
|
2020-01-30 12:50:07 +01:00
|
|
|
params := listParams{bucket, recursive, nextMarker, prefix}
|
2019-04-17 18:52:08 +02:00
|
|
|
if !eof {
|
|
|
|
tpool.Set(params, walkResultCh, endWalkCh)
|
|
|
|
}
|
|
|
|
|
|
|
|
result := ListObjectsInfo{}
|
|
|
|
for _, objInfo := range objInfos {
|
2019-08-06 21:08:58 +02:00
|
|
|
if objInfo.IsDir && delimiter == SlashSeparator {
|
2019-04-17 18:52:08 +02:00
|
|
|
result.Prefixes = append(result.Prefixes, objInfo.Name)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
result.Objects = append(result.Objects, objInfo)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !eof {
|
|
|
|
result.IsTruncated = true
|
|
|
|
if len(objInfos) > 0 {
|
|
|
|
result.NextMarker = objInfos[len(objInfos)-1].Name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Success.
|
|
|
|
return result, nil
|
|
|
|
}
|
2019-12-12 15:02:37 +01:00
|
|
|
|
|
|
|
// Fetch the histogram interval corresponding
|
|
|
|
// to the passed object size.
|
|
|
|
func objSizeToHistoInterval(usize uint64) string {
|
|
|
|
size := int64(usize)
|
|
|
|
|
|
|
|
var interval objectHistogramInterval
|
|
|
|
for _, interval = range ObjectsHistogramIntervals {
|
|
|
|
var cond1, cond2 bool
|
|
|
|
if size >= interval.start || interval.start == -1 {
|
|
|
|
cond1 = true
|
|
|
|
}
|
|
|
|
if size <= interval.end || interval.end == -1 {
|
|
|
|
cond2 = true
|
|
|
|
}
|
|
|
|
if cond1 && cond2 {
|
|
|
|
return interval.name
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// This would be the last element of histogram intervals
|
|
|
|
return interval.name
|
|
|
|
}
|