|
|
|
@ -33,6 +33,7 @@ import ( |
|
|
|
"time" |
|
|
|
"time" |
|
|
|
|
|
|
|
|
|
|
|
"github.com/minio/minio/pkg/iodine" |
|
|
|
"github.com/minio/minio/pkg/iodine" |
|
|
|
|
|
|
|
"github.com/minio/minio/pkg/quick" |
|
|
|
"github.com/minio/minio/pkg/storage/donut/trove" |
|
|
|
"github.com/minio/minio/pkg/storage/donut/trove" |
|
|
|
) |
|
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
@ -41,15 +42,24 @@ const ( |
|
|
|
totalBuckets = 100 |
|
|
|
totalBuckets = 100 |
|
|
|
) |
|
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
// Cache - local variables
|
|
|
|
// Config donut config
|
|
|
|
type Cache struct { |
|
|
|
type Config struct { |
|
|
|
storedBuckets map[string]storedBucket |
|
|
|
Version string `json:"version"` |
|
|
|
|
|
|
|
MaxSize uint64 `json:"max-size"` |
|
|
|
|
|
|
|
Expiration time.Duration `json:"expiration"` |
|
|
|
|
|
|
|
DonutName string `json:"donut-name"` |
|
|
|
|
|
|
|
NodeDiskMap map[string][]string `json:"node-disk-map"` |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// API - local variables
|
|
|
|
|
|
|
|
type API struct { |
|
|
|
|
|
|
|
config *Config |
|
|
|
lock *sync.RWMutex |
|
|
|
lock *sync.RWMutex |
|
|
|
objects *trove.Cache |
|
|
|
objects *trove.Cache |
|
|
|
multiPartObjects *trove.Cache |
|
|
|
multiPartObjects *trove.Cache |
|
|
|
maxSize uint64 |
|
|
|
storedBuckets map[string]storedBucket |
|
|
|
expiration time.Duration |
|
|
|
nodes map[string]node |
|
|
|
donut Donut |
|
|
|
buckets map[string]bucket |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// storedBucket saved bucket
|
|
|
|
// storedBucket saved bucket
|
|
|
|
@ -67,79 +77,85 @@ type multiPartSession struct { |
|
|
|
initiated time.Time |
|
|
|
initiated time.Time |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
type proxyWriter struct { |
|
|
|
// New instantiate a new donut
|
|
|
|
writer io.Writer |
|
|
|
func New(c *Config) (Interface, error) { |
|
|
|
writtenBytes []byte |
|
|
|
if err := quick.CheckData(c); err != nil { |
|
|
|
} |
|
|
|
return nil, iodine.New(err, nil) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
a := API{config: c} |
|
|
|
|
|
|
|
a.storedBuckets = make(map[string]storedBucket) |
|
|
|
|
|
|
|
a.nodes = make(map[string]node) |
|
|
|
|
|
|
|
a.buckets = make(map[string]bucket) |
|
|
|
|
|
|
|
a.objects = trove.NewCache(a.config.MaxSize, a.config.Expiration) |
|
|
|
|
|
|
|
a.multiPartObjects = trove.NewCache(0, time.Duration(0)) |
|
|
|
|
|
|
|
a.objects.OnExpired = a.expiredObject |
|
|
|
|
|
|
|
a.multiPartObjects.OnExpired = a.expiredPart |
|
|
|
|
|
|
|
a.lock = new(sync.RWMutex) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// set up cache expiration
|
|
|
|
|
|
|
|
a.objects.ExpireObjects(time.Second * 5) |
|
|
|
|
|
|
|
|
|
|
|
func (r *proxyWriter) Write(p []byte) (n int, err error) { |
|
|
|
if len(a.config.NodeDiskMap) > 0 { |
|
|
|
n, err = r.writer.Write(p) |
|
|
|
for k, v := range a.config.NodeDiskMap { |
|
|
|
|
|
|
|
if len(v) == 0 { |
|
|
|
|
|
|
|
return nil, iodine.New(InvalidDisksArgument{}, nil) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
err := a.AttachNode(k, v) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
return |
|
|
|
return nil, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
r.writtenBytes = append(r.writtenBytes, p[0:n]...) |
|
|
|
} |
|
|
|
return |
|
|
|
/// Initialization, populate all buckets into memory
|
|
|
|
} |
|
|
|
buckets, err := a.listBuckets() |
|
|
|
|
|
|
|
if err != nil { |
|
|
|
func newProxyWriter(w io.Writer) *proxyWriter { |
|
|
|
return nil, iodine.New(err, nil) |
|
|
|
return &proxyWriter{writer: w, writtenBytes: nil} |
|
|
|
} |
|
|
|
} |
|
|
|
for k, v := range buckets { |
|
|
|
|
|
|
|
storedBucket := a.storedBuckets[k] |
|
|
|
// NewCache new cache
|
|
|
|
storedBucket.bucketMetadata = v |
|
|
|
func NewCache(maxSize uint64, expiration time.Duration, donutName string, nodeDiskMap map[string][]string) Cache { |
|
|
|
a.storedBuckets[k] = storedBucket |
|
|
|
c := Cache{} |
|
|
|
} |
|
|
|
c.storedBuckets = make(map[string]storedBucket) |
|
|
|
} |
|
|
|
c.objects = trove.NewCache(maxSize, expiration) |
|
|
|
return a, nil |
|
|
|
c.multiPartObjects = trove.NewCache(0, time.Duration(0)) |
|
|
|
|
|
|
|
c.objects.OnExpired = c.expiredObject |
|
|
|
|
|
|
|
c.multiPartObjects.OnExpired = c.expiredPart |
|
|
|
|
|
|
|
c.lock = new(sync.RWMutex) |
|
|
|
|
|
|
|
c.maxSize = maxSize |
|
|
|
|
|
|
|
c.expiration = expiration |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// set up cache expiration
|
|
|
|
|
|
|
|
c.objects.ExpireObjects(time.Second * 5) |
|
|
|
|
|
|
|
c.donut, _ = NewDonut(donutName, nodeDiskMap) |
|
|
|
|
|
|
|
return c |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// GetObject - GET object from cache buffer
|
|
|
|
// GetObject - GET object from cache buffer
|
|
|
|
func (cache Cache) GetObject(w io.Writer, bucket string, object string) (int64, error) { |
|
|
|
func (donut API) GetObject(w io.Writer, bucket string, object string) (int64, error) { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
return 0, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if !IsValidObjectName(object) { |
|
|
|
if !IsValidObjectName(object) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(ObjectNameInvalid{Object: object}, nil) |
|
|
|
return 0, iodine.New(ObjectNameInvalid{Object: object}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, ok := cache.storedBuckets[bucket]; ok == false { |
|
|
|
if _, ok := donut.storedBuckets[bucket]; ok == false { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
return 0, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
objectKey := bucket + "/" + object |
|
|
|
objectKey := bucket + "/" + object |
|
|
|
data, ok := cache.objects.Get(objectKey) |
|
|
|
data, ok := donut.objects.Get(objectKey) |
|
|
|
if !ok { |
|
|
|
if !ok { |
|
|
|
if cache.donut != nil { |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
reader, size, err := cache.donut.GetObject(bucket, object) |
|
|
|
reader, size, err := donut.getObject(bucket, object) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
// new proxy writer to capture data read from disk
|
|
|
|
// new proxy writer to capture data read from disk
|
|
|
|
pw := newProxyWriter(w) |
|
|
|
pw := NewProxyWriter(w) |
|
|
|
written, err := io.CopyN(pw, reader, size) |
|
|
|
written, err := io.CopyN(pw, reader, size) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
/// cache object read from disk
|
|
|
|
/// cache object read from disk
|
|
|
|
{ |
|
|
|
{ |
|
|
|
cache.lock.Lock() |
|
|
|
donut.lock.Lock() |
|
|
|
ok := cache.objects.Set(objectKey, pw.writtenBytes) |
|
|
|
ok := donut.objects.Set(objectKey, pw.writtenBytes) |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
pw.writtenBytes = nil |
|
|
|
pw.writtenBytes = nil |
|
|
|
go debug.FreeOSMemory() |
|
|
|
go debug.FreeOSMemory() |
|
|
|
if !ok { |
|
|
|
if !ok { |
|
|
|
@ -148,65 +164,65 @@ func (cache Cache) GetObject(w io.Writer, bucket string, object string) (int64, |
|
|
|
} |
|
|
|
} |
|
|
|
return written, nil |
|
|
|
return written, nil |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(ObjectNotFound{Object: object}, nil) |
|
|
|
return 0, iodine.New(ObjectNotFound{Object: object}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
written, err := io.CopyN(w, bytes.NewBuffer(data), int64(cache.objects.Len(objectKey))) |
|
|
|
written, err := io.CopyN(w, bytes.NewBuffer(data), int64(donut.objects.Len(objectKey))) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return written, nil |
|
|
|
return written, nil |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// GetPartialObject - GET object from cache buffer range
|
|
|
|
// GetPartialObject - GET object from cache buffer range
|
|
|
|
func (cache Cache) GetPartialObject(w io.Writer, bucket, object string, start, length int64) (int64, error) { |
|
|
|
func (donut API) GetPartialObject(w io.Writer, bucket, object string, start, length int64) (int64, error) { |
|
|
|
errParams := map[string]string{ |
|
|
|
errParams := map[string]string{ |
|
|
|
"bucket": bucket, |
|
|
|
"bucket": bucket, |
|
|
|
"object": object, |
|
|
|
"object": object, |
|
|
|
"start": strconv.FormatInt(start, 10), |
|
|
|
"start": strconv.FormatInt(start, 10), |
|
|
|
"length": strconv.FormatInt(length, 10), |
|
|
|
"length": strconv.FormatInt(length, 10), |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(BucketNameInvalid{Bucket: bucket}, errParams) |
|
|
|
return 0, iodine.New(BucketNameInvalid{Bucket: bucket}, errParams) |
|
|
|
} |
|
|
|
} |
|
|
|
if !IsValidObjectName(object) { |
|
|
|
if !IsValidObjectName(object) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(ObjectNameInvalid{Object: object}, errParams) |
|
|
|
return 0, iodine.New(ObjectNameInvalid{Object: object}, errParams) |
|
|
|
} |
|
|
|
} |
|
|
|
if start < 0 { |
|
|
|
if start < 0 { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(InvalidRange{ |
|
|
|
return 0, iodine.New(InvalidRange{ |
|
|
|
Start: start, |
|
|
|
Start: start, |
|
|
|
Length: length, |
|
|
|
Length: length, |
|
|
|
}, errParams) |
|
|
|
}, errParams) |
|
|
|
} |
|
|
|
} |
|
|
|
objectKey := bucket + "/" + object |
|
|
|
objectKey := bucket + "/" + object |
|
|
|
data, ok := cache.objects.Get(objectKey) |
|
|
|
data, ok := donut.objects.Get(objectKey) |
|
|
|
if !ok { |
|
|
|
if !ok { |
|
|
|
if cache.donut != nil { |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
reader, _, err := cache.donut.GetObject(bucket, object) |
|
|
|
reader, _, err := donut.getObject(bucket, object) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, err := io.CopyN(ioutil.Discard, reader, start); err != nil { |
|
|
|
if _, err := io.CopyN(ioutil.Discard, reader, start); err != nil { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
pw := newProxyWriter(w) |
|
|
|
pw := NewProxyWriter(w) |
|
|
|
written, err := io.CopyN(w, reader, length) |
|
|
|
written, err := io.CopyN(w, reader, length) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
{ |
|
|
|
{ |
|
|
|
cache.lock.Lock() |
|
|
|
donut.lock.Lock() |
|
|
|
ok := cache.objects.Set(objectKey, pw.writtenBytes) |
|
|
|
ok := donut.objects.Set(objectKey, pw.writtenBytes) |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
pw.writtenBytes = nil |
|
|
|
pw.writtenBytes = nil |
|
|
|
go debug.FreeOSMemory() |
|
|
|
go debug.FreeOSMemory() |
|
|
|
if !ok { |
|
|
|
if !ok { |
|
|
|
@ -215,72 +231,70 @@ func (cache Cache) GetPartialObject(w io.Writer, bucket, object string, start, l |
|
|
|
} |
|
|
|
} |
|
|
|
return written, nil |
|
|
|
return written, nil |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return 0, iodine.New(ObjectNotFound{Object: object}, nil) |
|
|
|
return 0, iodine.New(ObjectNotFound{Object: object}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
written, err := io.CopyN(w, bytes.NewBuffer(data[start:]), length) |
|
|
|
written, err := io.CopyN(w, bytes.NewBuffer(data[start:]), length) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
return 0, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return written, nil |
|
|
|
return written, nil |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// GetBucketMetadata -
|
|
|
|
// GetBucketMetadata -
|
|
|
|
func (cache Cache) GetBucketMetadata(bucket string) (BucketMetadata, error) { |
|
|
|
func (donut API) GetBucketMetadata(bucket string) (BucketMetadata, error) { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return BucketMetadata{}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
return BucketMetadata{}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, ok := cache.storedBuckets[bucket]; ok == false { |
|
|
|
if _, ok := donut.storedBuckets[bucket]; ok == false { |
|
|
|
if cache.donut == nil { |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
cache.lock.RUnlock() |
|
|
|
bucketMetadata, err := donut.getBucketMetadata(bucket) |
|
|
|
return BucketMetadata{}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
bucketMetadata, err := cache.donut.GetBucketMetadata(bucket) |
|
|
|
|
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return BucketMetadata{}, iodine.New(err, nil) |
|
|
|
return BucketMetadata{}, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
storedBucket := cache.storedBuckets[bucket] |
|
|
|
storedBucket := donut.storedBuckets[bucket] |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
cache.lock.Lock() |
|
|
|
{ |
|
|
|
|
|
|
|
donut.lock.Lock() |
|
|
|
storedBucket.bucketMetadata = bucketMetadata |
|
|
|
storedBucket.bucketMetadata = bucketMetadata |
|
|
|
cache.storedBuckets[bucket] = storedBucket |
|
|
|
donut.storedBuckets[bucket] = storedBucket |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
} |
|
|
|
return cache.storedBuckets[bucket].bucketMetadata, nil |
|
|
|
return BucketMetadata{}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
donut.lock.RUnlock() |
|
|
|
|
|
|
|
return donut.storedBuckets[bucket].bucketMetadata, nil |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// SetBucketMetadata -
|
|
|
|
// SetBucketMetadata -
|
|
|
|
func (cache Cache) SetBucketMetadata(bucket, acl string) error { |
|
|
|
func (donut API) SetBucketMetadata(bucket string, metadata map[string]string) error { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
return iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, ok := cache.storedBuckets[bucket]; ok == false { |
|
|
|
if _, ok := donut.storedBuckets[bucket]; ok == false { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
return iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if strings.TrimSpace(acl) == "" { |
|
|
|
donut.lock.RUnlock() |
|
|
|
acl = "private" |
|
|
|
donut.lock.Lock() |
|
|
|
} |
|
|
|
{ |
|
|
|
cache.lock.RUnlock() |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
cache.lock.Lock() |
|
|
|
if err := donut.setBucketMetadata(bucket, metadata); err != nil { |
|
|
|
m := make(map[string]string) |
|
|
|
|
|
|
|
m["acl"] = acl |
|
|
|
|
|
|
|
if cache.donut != nil { |
|
|
|
|
|
|
|
if err := cache.donut.SetBucketMetadata(bucket, m); err != nil { |
|
|
|
|
|
|
|
return iodine.New(err, nil) |
|
|
|
return iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
storedBucket := cache.storedBuckets[bucket] |
|
|
|
storedBucket := donut.storedBuckets[bucket] |
|
|
|
storedBucket.bucketMetadata.ACL = BucketACL(acl) |
|
|
|
storedBucket.bucketMetadata.ACL = BucketACL(metadata["acl"]) |
|
|
|
cache.storedBuckets[bucket] = storedBucket |
|
|
|
donut.storedBuckets[bucket] = storedBucket |
|
|
|
cache.lock.Unlock() |
|
|
|
} |
|
|
|
|
|
|
|
donut.lock.Unlock() |
|
|
|
return nil |
|
|
|
return nil |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -304,44 +318,45 @@ func isMD5SumEqual(expectedMD5Sum, actualMD5Sum string) error { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// CreateObject -
|
|
|
|
// CreateObject -
|
|
|
|
func (cache Cache) CreateObject(bucket, key, contentType, expectedMD5Sum string, size int64, data io.Reader) (ObjectMetadata, error) { |
|
|
|
func (donut API) CreateObject(bucket, key, expectedMD5Sum string, size int64, data io.Reader, metadata map[string]string) (ObjectMetadata, error) { |
|
|
|
if size > int64(cache.maxSize) { |
|
|
|
if size > int64(donut.config.MaxSize) { |
|
|
|
generic := GenericObjectError{Bucket: bucket, Object: key} |
|
|
|
generic := GenericObjectError{Bucket: bucket, Object: key} |
|
|
|
return ObjectMetadata{}, iodine.New(EntityTooLarge{ |
|
|
|
return ObjectMetadata{}, iodine.New(EntityTooLarge{ |
|
|
|
GenericObjectError: generic, |
|
|
|
GenericObjectError: generic, |
|
|
|
Size: strconv.FormatInt(size, 10), |
|
|
|
Size: strconv.FormatInt(size, 10), |
|
|
|
MaxSize: strconv.FormatUint(cache.maxSize, 10), |
|
|
|
MaxSize: strconv.FormatUint(donut.config.MaxSize, 10), |
|
|
|
}, nil) |
|
|
|
}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
objectMetadata, err := cache.createObject(bucket, key, contentType, expectedMD5Sum, size, data) |
|
|
|
contentType := metadata["contentType"] |
|
|
|
|
|
|
|
objectMetadata, err := donut.createObject(bucket, key, contentType, expectedMD5Sum, size, data) |
|
|
|
// free
|
|
|
|
// free
|
|
|
|
debug.FreeOSMemory() |
|
|
|
debug.FreeOSMemory() |
|
|
|
return objectMetadata, iodine.New(err, nil) |
|
|
|
return objectMetadata, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// createObject - PUT object to cache buffer
|
|
|
|
// createObject - PUT object to cache buffer
|
|
|
|
func (cache Cache) createObject(bucket, key, contentType, expectedMD5Sum string, size int64, data io.Reader) (ObjectMetadata, error) { |
|
|
|
func (donut API) createObject(bucket, key, contentType, expectedMD5Sum string, size int64, data io.Reader) (ObjectMetadata, error) { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if !IsValidObjectName(key) { |
|
|
|
if !IsValidObjectName(key) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectNameInvalid{Object: key}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectNameInvalid{Object: key}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, ok := cache.storedBuckets[bucket]; ok == false { |
|
|
|
if _, ok := donut.storedBuckets[bucket]; ok == false { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
storedBucket := cache.storedBuckets[bucket] |
|
|
|
storedBucket := donut.storedBuckets[bucket] |
|
|
|
// get object key
|
|
|
|
// get object key
|
|
|
|
objectKey := bucket + "/" + key |
|
|
|
objectKey := bucket + "/" + key |
|
|
|
if _, ok := storedBucket.objectMetadata[objectKey]; ok == true { |
|
|
|
if _, ok := storedBucket.objectMetadata[objectKey]; ok == true { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectExists{Object: key}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectExists{Object: key}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
|
|
|
|
|
|
|
|
if contentType == "" { |
|
|
|
if contentType == "" { |
|
|
|
contentType = "application/octet-stream" |
|
|
|
contentType = "application/octet-stream" |
|
|
|
@ -356,15 +371,15 @@ func (cache Cache) createObject(bucket, key, contentType, expectedMD5Sum string, |
|
|
|
expectedMD5Sum = hex.EncodeToString(expectedMD5SumBytes) |
|
|
|
expectedMD5Sum = hex.EncodeToString(expectedMD5SumBytes) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if cache.donut != nil { |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
objMetadata, err := cache.donut.PutObject(bucket, key, expectedMD5Sum, data, map[string]string{"contentType": contentType}) |
|
|
|
objMetadata, err := donut.putObject(bucket, key, expectedMD5Sum, data, map[string]string{"contentType": contentType}) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
return ObjectMetadata{}, iodine.New(err, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.Lock() |
|
|
|
donut.lock.Lock() |
|
|
|
storedBucket.objectMetadata[objectKey] = objMetadata |
|
|
|
storedBucket.objectMetadata[objectKey] = objMetadata |
|
|
|
cache.storedBuckets[bucket] = storedBucket |
|
|
|
donut.storedBuckets[bucket] = storedBucket |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
return objMetadata, nil |
|
|
|
return objMetadata, nil |
|
|
|
} |
|
|
|
} |
|
|
|
// calculate md5
|
|
|
|
// calculate md5
|
|
|
|
@ -382,9 +397,9 @@ func (cache Cache) createObject(bucket, key, contentType, expectedMD5Sum string, |
|
|
|
break |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
hash.Write(byteBuffer[0:length]) |
|
|
|
hash.Write(byteBuffer[0:length]) |
|
|
|
cache.lock.Lock() |
|
|
|
donut.lock.Lock() |
|
|
|
ok := cache.objects.Append(objectKey, byteBuffer[0:length]) |
|
|
|
ok := donut.objects.Append(objectKey, byteBuffer[0:length]) |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
if !ok { |
|
|
|
if !ok { |
|
|
|
return ObjectMetadata{}, iodine.New(InternalError{}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(InternalError{}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
@ -416,40 +431,40 @@ func (cache Cache) createObject(bucket, key, contentType, expectedMD5Sum string, |
|
|
|
Size: int64(totalLength), |
|
|
|
Size: int64(totalLength), |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
cache.lock.Lock() |
|
|
|
donut.lock.Lock() |
|
|
|
storedBucket.objectMetadata[objectKey] = newObject |
|
|
|
storedBucket.objectMetadata[objectKey] = newObject |
|
|
|
cache.storedBuckets[bucket] = storedBucket |
|
|
|
donut.storedBuckets[bucket] = storedBucket |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
return newObject, nil |
|
|
|
return newObject, nil |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// MakeBucket - create bucket in cache
|
|
|
|
// MakeBucket - create bucket in cache
|
|
|
|
func (cache Cache) MakeBucket(bucketName, acl string) error { |
|
|
|
func (donut API) MakeBucket(bucketName, acl string) error { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
if len(cache.storedBuckets) == totalBuckets { |
|
|
|
if len(donut.storedBuckets) == totalBuckets { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return iodine.New(TooManyBuckets{Bucket: bucketName}, nil) |
|
|
|
return iodine.New(TooManyBuckets{Bucket: bucketName}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if !IsValidBucket(bucketName) { |
|
|
|
if !IsValidBucket(bucketName) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return iodine.New(BucketNameInvalid{Bucket: bucketName}, nil) |
|
|
|
return iodine.New(BucketNameInvalid{Bucket: bucketName}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if !IsValidBucketACL(acl) { |
|
|
|
if !IsValidBucketACL(acl) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return iodine.New(InvalidACL{ACL: acl}, nil) |
|
|
|
return iodine.New(InvalidACL{ACL: acl}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, ok := cache.storedBuckets[bucketName]; ok == true { |
|
|
|
if _, ok := donut.storedBuckets[bucketName]; ok == true { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return iodine.New(BucketExists{Bucket: bucketName}, nil) |
|
|
|
return iodine.New(BucketExists{Bucket: bucketName}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
|
|
|
|
|
|
|
|
if strings.TrimSpace(acl) == "" { |
|
|
|
if strings.TrimSpace(acl) == "" { |
|
|
|
// default is private
|
|
|
|
// default is private
|
|
|
|
acl = "private" |
|
|
|
acl = "private" |
|
|
|
} |
|
|
|
} |
|
|
|
if cache.donut != nil { |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
if err := cache.donut.MakeBucket(bucketName, BucketACL(acl)); err != nil { |
|
|
|
if err := donut.makeBucket(bucketName, BucketACL(acl)); err != nil { |
|
|
|
return iodine.New(err, nil) |
|
|
|
return iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
@ -461,29 +476,29 @@ func (cache Cache) MakeBucket(bucketName, acl string) error { |
|
|
|
newBucket.bucketMetadata.Name = bucketName |
|
|
|
newBucket.bucketMetadata.Name = bucketName |
|
|
|
newBucket.bucketMetadata.Created = time.Now().UTC() |
|
|
|
newBucket.bucketMetadata.Created = time.Now().UTC() |
|
|
|
newBucket.bucketMetadata.ACL = BucketACL(acl) |
|
|
|
newBucket.bucketMetadata.ACL = BucketACL(acl) |
|
|
|
cache.lock.Lock() |
|
|
|
donut.lock.Lock() |
|
|
|
cache.storedBuckets[bucketName] = newBucket |
|
|
|
donut.storedBuckets[bucketName] = newBucket |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
return nil |
|
|
|
return nil |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// ListObjects - list objects from cache
|
|
|
|
// ListObjects - list objects from cache
|
|
|
|
func (cache Cache) ListObjects(bucket string, resources BucketResourcesMetadata) ([]ObjectMetadata, BucketResourcesMetadata, error) { |
|
|
|
func (donut API) ListObjects(bucket string, resources BucketResourcesMetadata) ([]ObjectMetadata, BucketResourcesMetadata, error) { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
defer cache.lock.RUnlock() |
|
|
|
defer donut.lock.RUnlock() |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
return nil, BucketResourcesMetadata{IsTruncated: false}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
return nil, BucketResourcesMetadata{IsTruncated: false}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if !IsValidPrefix(resources.Prefix) { |
|
|
|
if !IsValidPrefix(resources.Prefix) { |
|
|
|
return nil, BucketResourcesMetadata{IsTruncated: false}, iodine.New(ObjectNameInvalid{Object: resources.Prefix}, nil) |
|
|
|
return nil, BucketResourcesMetadata{IsTruncated: false}, iodine.New(ObjectNameInvalid{Object: resources.Prefix}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, ok := cache.storedBuckets[bucket]; ok == false { |
|
|
|
if _, ok := donut.storedBuckets[bucket]; ok == false { |
|
|
|
return nil, BucketResourcesMetadata{IsTruncated: false}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
return nil, BucketResourcesMetadata{IsTruncated: false}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
var results []ObjectMetadata |
|
|
|
var results []ObjectMetadata |
|
|
|
var keys []string |
|
|
|
var keys []string |
|
|
|
if cache.donut != nil { |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
listObjects, err := cache.donut.ListObjects( |
|
|
|
listObjects, err := donut.listObjects( |
|
|
|
bucket, |
|
|
|
bucket, |
|
|
|
resources.Prefix, |
|
|
|
resources.Prefix, |
|
|
|
resources.Marker, |
|
|
|
resources.Marker, |
|
|
|
@ -507,7 +522,7 @@ func (cache Cache) ListObjects(bucket string, resources BucketResourcesMetadata) |
|
|
|
} |
|
|
|
} |
|
|
|
return results, resources, nil |
|
|
|
return results, resources, nil |
|
|
|
} |
|
|
|
} |
|
|
|
storedBucket := cache.storedBuckets[bucket] |
|
|
|
storedBucket := donut.storedBuckets[bucket] |
|
|
|
for key := range storedBucket.objectMetadata { |
|
|
|
for key := range storedBucket.objectMetadata { |
|
|
|
if strings.HasPrefix(key, bucket+"/") { |
|
|
|
if strings.HasPrefix(key, bucket+"/") { |
|
|
|
key = key[len(bucket)+1:] |
|
|
|
key = key[len(bucket)+1:] |
|
|
|
@ -561,11 +576,11 @@ func (b byBucketName) Swap(i, j int) { b[i], b[j] = b[j], b[i] } |
|
|
|
func (b byBucketName) Less(i, j int) bool { return b[i].Name < b[j].Name } |
|
|
|
func (b byBucketName) Less(i, j int) bool { return b[i].Name < b[j].Name } |
|
|
|
|
|
|
|
|
|
|
|
// ListBuckets - List buckets from cache
|
|
|
|
// ListBuckets - List buckets from cache
|
|
|
|
func (cache Cache) ListBuckets() ([]BucketMetadata, error) { |
|
|
|
func (donut API) ListBuckets() ([]BucketMetadata, error) { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
defer cache.lock.RUnlock() |
|
|
|
defer donut.lock.RUnlock() |
|
|
|
var results []BucketMetadata |
|
|
|
var results []BucketMetadata |
|
|
|
for _, bucket := range cache.storedBuckets { |
|
|
|
for _, bucket := range donut.storedBuckets { |
|
|
|
results = append(results, bucket.bucketMetadata) |
|
|
|
results = append(results, bucket.bucketMetadata) |
|
|
|
} |
|
|
|
} |
|
|
|
sort.Sort(byBucketName(results)) |
|
|
|
sort.Sort(byBucketName(results)) |
|
|
|
@ -573,50 +588,50 @@ func (cache Cache) ListBuckets() ([]BucketMetadata, error) { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// GetObjectMetadata - get object metadata from cache
|
|
|
|
// GetObjectMetadata - get object metadata from cache
|
|
|
|
func (cache Cache) GetObjectMetadata(bucket, key string) (ObjectMetadata, error) { |
|
|
|
func (donut API) GetObjectMetadata(bucket, key string) (ObjectMetadata, error) { |
|
|
|
cache.lock.RLock() |
|
|
|
donut.lock.RLock() |
|
|
|
// check if bucket exists
|
|
|
|
// check if bucket exists
|
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
if !IsValidBucket(bucket) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNameInvalid{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if !IsValidObjectName(key) { |
|
|
|
if !IsValidObjectName(key) { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectNameInvalid{Object: key}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectNameInvalid{Object: key}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
if _, ok := cache.storedBuckets[bucket]; ok == false { |
|
|
|
if _, ok := donut.storedBuckets[bucket]; ok == false { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(BucketNotFound{Bucket: bucket}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
storedBucket := cache.storedBuckets[bucket] |
|
|
|
storedBucket := donut.storedBuckets[bucket] |
|
|
|
objectKey := bucket + "/" + key |
|
|
|
objectKey := bucket + "/" + key |
|
|
|
if objMetadata, ok := storedBucket.objectMetadata[objectKey]; ok == true { |
|
|
|
if objMetadata, ok := storedBucket.objectMetadata[objectKey]; ok == true { |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return objMetadata, nil |
|
|
|
return objMetadata, nil |
|
|
|
} |
|
|
|
} |
|
|
|
if cache.donut != nil { |
|
|
|
if len(donut.config.NodeDiskMap) > 0 { |
|
|
|
objMetadata, err := cache.donut.GetObjectMetadata(bucket, key) |
|
|
|
objMetadata, err := donut.getObjectMetadata(bucket, key) |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
return ObjectMetadata{}, iodine.New(err, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(err, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
// update
|
|
|
|
// update
|
|
|
|
cache.lock.Lock() |
|
|
|
donut.lock.Lock() |
|
|
|
storedBucket.objectMetadata[objectKey] = objMetadata |
|
|
|
storedBucket.objectMetadata[objectKey] = objMetadata |
|
|
|
cache.lock.Unlock() |
|
|
|
donut.lock.Unlock() |
|
|
|
return objMetadata, nil |
|
|
|
return objMetadata, nil |
|
|
|
} |
|
|
|
} |
|
|
|
cache.lock.RUnlock() |
|
|
|
donut.lock.RUnlock() |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectNotFound{Object: key}, nil) |
|
|
|
return ObjectMetadata{}, iodine.New(ObjectNotFound{Object: key}, nil) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
func (cache Cache) expiredObject(a ...interface{}) { |
|
|
|
func (donut API) expiredObject(a ...interface{}) { |
|
|
|
cacheStats := cache.objects.Stats() |
|
|
|
cacheStats := donut.objects.Stats() |
|
|
|
log.Printf("CurrentSize: %d, CurrentItems: %d, TotalExpirations: %d", |
|
|
|
log.Printf("CurrentSize: %d, CurrentItems: %d, TotalExpirations: %d", |
|
|
|
cacheStats.Bytes, cacheStats.Items, cacheStats.Expired) |
|
|
|
cacheStats.Bytes, cacheStats.Items, cacheStats.Expired) |
|
|
|
key := a[0].(string) |
|
|
|
key := a[0].(string) |
|
|
|
// loop through all buckets
|
|
|
|
// loop through all buckets
|
|
|
|
for _, storedBucket := range cache.storedBuckets { |
|
|
|
for _, storedBucket := range donut.storedBuckets { |
|
|
|
delete(storedBucket.objectMetadata, key) |
|
|
|
delete(storedBucket.objectMetadata, key) |
|
|
|
} |
|
|
|
} |
|
|
|
debug.FreeOSMemory() |
|
|
|
debug.FreeOSMemory() |
Harshavardhana
9 years ago