MyFavMirrors/minio
1
0
Fork 0
mirror of https://github.com/minio/minio.git synced 2025-01-13 16:03:21 -05:00
Code Issues Packages Projects Releases Wiki Activity

Now donut supports bucket ACL's, bringing in this support for dl.minio.io

Browse Source
This commit is contained in:
Harshavardhana 2015-04-27 02:04:05 -07:00
parent f5a51ae1bb
commit c99d96dbc2
8 changed files with 165 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/api/api_bucket_handlers.go
View File

@ -45,13 +45,13 @@ func (server *minioAPI) isValidOp(w http.ResponseWriter, req *http.Request, acce
if stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate() {
return true
// Uncomment this when we have webCli
// Uncomment this before release
// writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
// return false
}
if bucketMetadata.ACL.IsPublicRead() && req.Method == "PUT" {
return true
// Uncomment this when we have webCli
// Uncomment this before release
// writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
// return false
}

9
pkg/storage/donut/donut_bucket.go
View File

@ -43,15 +43,18 @@ type bucket struct {
}
// NewBucket - instantiate a new bucket
func NewBucket(bucketName, aclType, donutName string, nodes map[string]Node) (Bucket, error) {
func NewBucket(bucketName, aclType, donutName string, nodes map[string]Node) (Bucket, map[string]string, error) {
errParams := map[string]string{
"bucketName": bucketName,
"donutName": donutName,
"aclType": aclType,
}
if strings.TrimSpace(bucketName) == "" || strings.TrimSpace(donutName) == "" {
return nil, iodine.New(errors.New("invalid argument"), errParams)
return nil, nil, iodine.New(errors.New("invalid argument"), errParams)
}
bucketMetadata := make(map[string]string)
bucketMetadata["acl"] = aclType
bucketMetadata["created"] = time.Now().Format(time.RFC3339Nano)
b := bucket{}
b.name = bucketName
b.acl = aclType
@ -59,7 +62,7 @@ func NewBucket(bucketName, aclType, donutName string, nodes map[string]Node) (Bu
b.donutName = donutName
b.objects = make(map[string]Object)
b.nodes = nodes
return b, nil
return b, bucketMetadata, nil
}
// ListObjects - list all objects

2
pkg/storage/donut/donut_disk.go
View File

@ -133,7 +133,7 @@ func (d disk) MakeFile(filename string) (*os.File, error) {
if err := os.MkdirAll(path.Dir(filePath), 0700); err != nil {
return nil, iodine.New(err, nil)
}
dataFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
dataFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0600)
if err != nil {
return nil, iodine.New(err, nil)
}

57
pkg/storage/donut/objectstorage.go
View File

@ -19,10 +19,10 @@ package donut
import (
"errors"
"io"
"os"
"sort"
"strconv"
"strings"
"time"
"github.com/minio-io/minio/pkg/iodine"
)
@ -44,17 +44,25 @@ func (d donut) GetBucketMetadata(bucket string) (map[string]string, error) {
if _, ok := d.buckets[bucket]; !ok {
return nil, iodine.New(errors.New("bucket does not exist"), nil)
}
// TODO get this, from whatever is written from SetBucketMetadata
metadata := make(map[string]string)
metadata["name"] = bucket
metadata["created"] = time.Now().Format(time.RFC3339Nano)
metadata["acl"] = "private"
return metadata, nil
metadata, err := d.getDonutBucketMetadata()
if err != nil {
return nil, iodine.New(err, nil)
}
return metadata[bucket], nil
}
// SetBucketMetadata - set bucket metadata
func (d donut) SetBucketMetadata(bucket string, metadata map[string]string) error {
return errors.New("Not implemented")
func (d donut) SetBucketMetadata(bucket string, bucketMetadata map[string]string) error {
err := d.getDonutBuckets()
if err != nil {
return iodine.New(err, nil)
}
metadata, err := d.getDonutBucketMetadata()
if err != nil {
return iodine.New(err, nil)
}
metadata[bucket] = bucketMetadata
return d.setDonutBucketMetadata(metadata)
}
// ListBuckets - return list of buckets
@ -63,7 +71,16 @@ func (d donut) ListBuckets() (results []string, err error) {
if err != nil {
return nil, iodine.New(err, nil)
}
for name := range d.buckets {
metadata, err := d.getDonutBucketMetadata()
if err != nil {
err = iodine.ToError(err)
if os.IsNotExist(err) {
// valid case
return nil, nil
}
return nil, iodine.New(err, nil)
}
for name := range metadata {
results = append(results, name)
}
sort.Strings(results)
@ -151,6 +168,15 @@ func (d donut) PutObject(bucket, object, expectedMD5Sum string, reader io.ReadCl
if _, ok := d.buckets[bucket]; !ok {
return iodine.New(errors.New("bucket does not exist"), nil)
}
objectList, err := d.buckets[bucket].ListObjects()
if err != nil {
return iodine.New(err, nil)
}
for objectName := range objectList {
if objectName == object {
return iodine.New(errors.New("object exists"), nil)
}
}
err = d.buckets[bucket].PutObject(object, reader, expectedMD5Sum, metadata)
if err != nil {
return iodine.New(err, errParams)
@ -177,7 +203,16 @@ func (d donut) GetObject(bucket, object string) (reader io.ReadCloser, size int6
if _, ok := d.buckets[bucket]; !ok {
return nil, 0, iodine.New(errors.New("bucket does not exist"), errParams)
}
return d.buckets[bucket].GetObject(object)
objectList, err := d.buckets[bucket].ListObjects()
if err != nil {
return nil, 0, iodine.New(err, nil)
}
for objectName := range objectList {
if objectName == object {
return d.buckets[bucket].GetObject(object)
}
}
return nil, 0, iodine.New(errors.New("object not found"), nil)
}
// GetObjectMetadata - get object metadata

104
pkg/storage/donut/objectstorage_internal.go
View File

@ -17,15 +17,94 @@
package donut
import (
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path"
"strings"
"github.com/minio-io/minio/pkg/iodine"
)
// TODO we have to store the acl's
/// This file contains all the internal functions used by Object interface
// getDiskWriters -
func (d donut) getBucketMetadataWriters() ([]io.WriteCloser, error) {
var writers []io.WriteCloser
for _, node := range d.nodes {
disks, err := node.ListDisks()
if err != nil {
return nil, iodine.New(err, nil)
}
writers = make([]io.WriteCloser, len(disks))
for _, disk := range disks {
bucketMetaDataWriter, err := disk.MakeFile(path.Join(d.name, bucketMetadataConfig))
if err != nil {
return nil, iodine.New(err, nil)
}
writers[disk.GetOrder()] = bucketMetaDataWriter
}
}
return writers, nil
}
func (d donut) getBucketMetadataReaders() ([]io.ReadCloser, error) {
var readers []io.ReadCloser
for _, node := range d.nodes {
disks, err := node.ListDisks()
if err != nil {
return nil, iodine.New(err, nil)
}
readers = make([]io.ReadCloser, len(disks))
for _, disk := range disks {
bucketMetaDataReader, err := disk.OpenFile(path.Join(d.name, bucketMetadataConfig))
if err != nil {
return nil, iodine.New(err, nil)
}
readers[disk.GetOrder()] = bucketMetaDataReader
}
}
return readers, nil
}
//
func (d donut) setDonutBucketMetadata(metadata map[string]map[string]string) error {
writers, err := d.getBucketMetadataWriters()
if err != nil {
return iodine.New(err, nil)
}
for _, writer := range writers {
defer writer.Close()
}
for _, writer := range writers {
jenc := json.NewEncoder(writer)
if err := jenc.Encode(metadata); err != nil {
return iodine.New(err, nil)
}
}
return nil
}
func (d donut) getDonutBucketMetadata() (map[string]map[string]string, error) {
metadata := make(map[string]map[string]string)
readers, err := d.getBucketMetadataReaders()
if err != nil {
return nil, iodine.New(err, nil)
}
for _, reader := range readers {
defer reader.Close()
}
for _, reader := range readers {
jenc := json.NewDecoder(reader)
if err := jenc.Decode(&metadata); err != nil {
return nil, iodine.New(err, nil)
}
}
return metadata, nil
}
func (d donut) makeDonutBucket(bucketName, acl string) error {
err := d.getDonutBuckets()
if err != nil {
@ -34,7 +113,7 @@ func (d donut) makeDonutBucket(bucketName, acl string) error {
if _, ok := d.buckets[bucketName]; ok {
return iodine.New(errors.New("bucket exists"), nil)
}
bucket, err := NewBucket(bucketName, acl, d.name, d.nodes)
bucket, bucketMetadata, err := NewBucket(bucketName, acl, d.name, d.nodes)
if err != nil {
return iodine.New(err, nil)
}
@ -54,6 +133,25 @@ func (d donut) makeDonutBucket(bucketName, acl string) error {
}
nodeNumber = nodeNumber + 1
}
metadata, err := d.getDonutBucketMetadata()
if err != nil {
err = iodine.ToError(err)
if os.IsNotExist(err) {
metadata := make(map[string]map[string]string)
metadata[bucketName] = bucketMetadata
err = d.setDonutBucketMetadata(metadata)
if err != nil {
return iodine.New(err, nil)
}
return nil
}
return iodine.New(err, nil)
}
metadata[bucketName] = bucketMetadata
err = d.setDonutBucketMetadata(metadata)
if err != nil {
return iodine.New(err, nil)
}
return nil
}
@ -75,7 +173,7 @@ func (d donut) getDonutBuckets() error {
}
bucketName := splitDir[0]
// we dont need this NewBucket once we cache from makeDonutBucket()
bucket, err := NewBucket(bucketName, "private", d.name, d.nodes)
bucket, _, err := NewBucket(bucketName, "private", d.name, d.nodes)
if err != nil {
return iodine.New(err, nil)
}

2
pkg/storage/drivers/api_testsuite.go
View File

@ -235,7 +235,7 @@ func testBucketMetadata(c *check.C, create func() Driver) {
metadata, err := drivers.GetBucketMetadata("string")
c.Assert(err, check.IsNil)
c.Assert(metadata.Name, check.Equals, "string")
c.Assert(metadata.ACL, check.Equals, BucketACL("private"))
}
func testBucketRecreateFails(c *check.C, create func() Driver) {

5
pkg/storage/drivers/donut/donut.go
View File

@ -150,6 +150,9 @@ func (d donutDriver) CreateBucket(bucketName, acl string) error {
return iodine.New(drivers.InvalidACL{ACL: acl}, nil)
}
if drivers.IsValidBucket(bucketName) && !strings.Contains(bucketName, ".") {
if strings.TrimSpace(acl) == "" {
acl = "private"
}
return d.donut.MakeBucket(bucketName, acl)
}
return iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil)
@ -173,7 +176,7 @@ func (d donutDriver) GetBucketMetadata(bucketName string) (drivers.BucketMetadat
return drivers.BucketMetadata{}, iodine.New(drivers.BackendCorrupted{}, nil)
}
bucketMetadata := drivers.BucketMetadata{
Name: metadata["name"],
Name: bucketName,
Created: created,
ACL: drivers.BucketACL(acl),
}

4
pkg/storage/drivers/memory/memory.go
View File

@ -285,6 +285,10 @@ func (memory *memoryDriver) CreateBucket(bucketName, acl string) error {
}
memory.lock.RUnlock()
if strings.TrimSpace(acl) == "" {
// default is private
acl = "private"
}
var newBucket = storedBucket{}
newBucket.metadata = drivers.BucketMetadata{}
newBucket.metadata.Name = bucketName