From e95604ff86eb67617a55cd870b8b2f4718f3b5c4 Mon Sep 17 00:00:00 2001 From: Harshavardhana Date: Thu, 23 Apr 2015 01:20:03 -0700 Subject: [PATCH] Finishing all the test case support for ACL and other fixes --- pkg/api/api_bucket_handlers.go | 95 ++++--- pkg/api/api_generic_handlers.go | 68 ++--- pkg/api/api_object_handlers.go | 70 ++--- pkg/api/api_test.go | 380 +++++++++++++++++++++------ pkg/api/utils.go | 3 + pkg/storage/donut/objectstorage.go | 3 +- pkg/storage/drivers/api_testsuite.go | 9 +- pkg/storage/drivers/donut/donut.go | 64 +++-- pkg/storage/drivers/driver.go | 4 + pkg/storage/drivers/errors.go | 22 ++ pkg/storage/drivers/memory/memory.go | 130 +++++---- 11 files changed, 556 insertions(+), 292 deletions(-) diff --git a/pkg/api/api_bucket_handlers.go b/pkg/api/api_bucket_handlers.go index e530b5dc4..0daf1b1f3 100644 --- a/pkg/api/api_bucket_handlers.go +++ b/pkg/api/api_bucket_handlers.go @@ -25,6 +25,35 @@ import ( "github.com/minio-io/minio/pkg/utils/log" ) +func (server *minioAPI) isValidOp(w http.ResponseWriter, req *http.Request, acceptsContentType contentType) bool { + vars := mux.Vars(req) + bucket := vars["bucket"] + + bucketMetadata, err := server.driver.GetBucketMetadata(bucket) + switch iodine.ToError(err).(type) { + case drivers.BucketNotFound: + { + writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path) + return false + } + case drivers.BucketNameInvalid: + { + writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path) + return false + } + case nil: + if stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate() { + writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path) + return false + } + if bucketMetadata.ACL.IsPublicRead() && req.Method == "PUT" { + writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path) + return false + } + } + return true +} + // GET Bucket (List Objects) // ------------------------- // This implementation of the GET operation returns some or all (up to 1000) @@ -37,6 +66,10 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ writeErrorResponse(w, req, NotAcceptable, acceptsContentType, req.URL.Path) return } + // verify if bucket allows this operation + if !server.isValidOp(w, req, acceptsContentType) { + return + } resources := getBucketResources(req.URL.Query()) if resources.Maxkeys == 0 { @@ -46,16 +79,8 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ vars := mux.Vars(req) bucket := vars["bucket"] - // Enable this after tests supports them - // verify for if bucket is private or public - // bucketMetadata, err := server.driver.GetBucketMetadata(bucket) - // if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) { - // writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path) - // return - // } - objects, resources, err := server.driver.ListObjects(bucket, resources) - switch err.(type) { + switch err := iodine.ToError(err).(type) { case nil: // success { // write headers @@ -66,13 +91,9 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType) w.Write(encodedSuccessResponse) } - case drivers.BucketNotFound: + case drivers.ObjectNotFound: { - writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path) - } - case drivers.BucketNameInvalid: - { - writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path) + writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path) } case drivers.ObjectNameInvalid: { @@ -99,7 +120,7 @@ func (server *minioAPI) listBucketsHandler(w http.ResponseWriter, req *http.Requ buckets, err := server.driver.ListBuckets() // cannot fallthrough in (type) switch :( - switch err := err.(type) { + switch err := iodine.ToError(err).(type) { case nil: { response := generateBucketsListResult(buckets) @@ -138,7 +159,7 @@ func (server *minioAPI) putBucketHandler(w http.ResponseWriter, req *http.Reques vars := mux.Vars(req) bucket := vars["bucket"] err := server.driver.CreateBucket(bucket, getACLTypeString(aclType)) - switch err.(type) { + switch iodine.ToError(err).(type) { case nil: { w.Header().Set("Server", "Minio") @@ -174,37 +195,13 @@ func (server *minioAPI) headBucketHandler(w http.ResponseWriter, req *http.Reque return } - vars := mux.Vars(req) - bucket := vars["bucket"] - - // Enable this after tests supports them - // verify for if bucket is private or public - // bucketMetadata, err := server.driver.GetBucketMetadata(bucket) - // if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) { - // writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path) - // return - // } - - _, err := server.driver.GetBucketMetadata(bucket) - switch err.(type) { - case nil: - { - w.Header().Set("Server", "Minio") - w.Header().Set("Connection", "close") - w.WriteHeader(http.StatusOK) - } - case drivers.BucketNameInvalid: - { - writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path) - } - case drivers.BucketNotFound: - { - writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path) - } - default: - { - log.Error.Println(iodine.New(err, nil)) - writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path) - } + // verify if bucket allows this operation + if !server.isValidOp(w, req, acceptsContentType) { + return } + + // Always a success if isValidOp succeeds + w.Header().Set("Server", "Minio") + w.Header().Set("Connection", "close") + w.WriteHeader(http.StatusOK) } diff --git a/pkg/api/api_generic_handlers.go b/pkg/api/api_generic_handlers.go index 4202d6bc6..f7707cd61 100644 --- a/pkg/api/api_generic_handlers.go +++ b/pkg/api/api_generic_handlers.go @@ -56,43 +56,49 @@ func validateHandler(conf config.Config, h http.Handler) http.Handler { // Validate handler ServeHTTP() wrapper func (h vHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - accessKey := stripAccessKey(r) acceptsContentType := getContentType(r) if acceptsContentType == unknownContentType { writeErrorResponse(w, r, NotAcceptable, acceptsContentType, r.URL.Path) return } - switch true { - case accessKey != "": - if err := h.conf.ReadConfig(); err != nil { - writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path) - return + // success + h.handler.ServeHTTP(w, r) + + // Enable below only when webcli is ready + + /* + switch true { + case accessKey != "": + if err := h.conf.ReadConfig(); err != nil { + writeErrorResponse(w, r, InternalError, acceptsContentType, r.URL.Path) + return + } + user, ok := h.conf.Users[accessKey] + if !ok { + writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path) + return + } + ok, _ = ValidateRequest(user, r) + if !ok { + writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path) + return + } + // Success + h.handler.ServeHTTP(w, r) + default: + // Control reaches when no access key is found, ideally we would + // like to throw back `403`. But for now with our tests lacking + // this functionality it is better for us to be serving anonymous + // requests as well. + // We should remove this after adding tests to support signature request + h.handler.ServeHTTP(w, r) + // ## Uncommented below links of code after disabling anonymous requests + // error := errorCodeError(AccessDenied) + // errorResponse := getErrorResponse(error, "") + // w.WriteHeader(error.HTTPStatusCode) + // w.Write(writeErrorResponse(w, errorResponse, acceptsContentType)) } - user, ok := h.conf.Users[accessKey] - if !ok { - writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path) - return - } - ok, _ = ValidateRequest(user, r) - if !ok { - writeErrorResponse(w, r, AccessDenied, acceptsContentType, r.URL.Path) - return - } - // Success - h.handler.ServeHTTP(w, r) - default: - // Control reaches when no access key is found, ideally we would - // like to throw back `403`. But for now with our tests lacking - // this functionality it is better for us to be serving anonymous - // requests as well. - // We should remove this after adding tests to support signature request - h.handler.ServeHTTP(w, r) - // ## Uncommented below links of code after disabling anonymous requests - // error := errorCodeError(AccessDenied) - // errorResponse := getErrorResponse(error, "") - // w.WriteHeader(error.HTTPStatusCode) - // w.Write(writeErrorResponse(w, errorResponse, acceptsContentType)) - } + */ } // Ignore resources handler is wrapper handler used for API request resource validation diff --git a/pkg/api/api_object_handlers.go b/pkg/api/api_object_handlers.go index 492072f17..9c6c9775d 100644 --- a/pkg/api/api_object_handlers.go +++ b/pkg/api/api_object_handlers.go @@ -36,22 +36,17 @@ func (server *minioAPI) getObjectHandler(w http.ResponseWriter, req *http.Reques return } + if !server.isValidOp(w, req, acceptsContentType) { + return + } + var object, bucket string vars := mux.Vars(req) bucket = vars["bucket"] object = vars["object"] - // Enable this after tests supports them - - // verify for if bucket is private or public - // bucketMetadata, err := server.driver.GetBucketMetadata(bucket) - // if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) { - // writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path) - // return - // } - metadata, err := server.driver.GetObjectMetadata(bucket, object, "") - switch err := err.(type) { + switch err := iodine.ToError(err).(type) { case nil: // success { httpRange, err := getRequestedRange(req, metadata.Size) @@ -80,18 +75,10 @@ func (server *minioAPI) getObjectHandler(w http.ResponseWriter, req *http.Reques { writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path) } - case drivers.BucketNotFound: - { - writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path) - } case drivers.ObjectNameInvalid: { writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path) } - case drivers.BucketNameInvalid: - { - writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path) - } default: { log.Error.Println(iodine.New(err, nil)) @@ -110,21 +97,17 @@ func (server *minioAPI) headObjectHandler(w http.ResponseWriter, req *http.Reque return } + if !server.isValidOp(w, req, acceptsContentType) { + return + } + var object, bucket string vars := mux.Vars(req) bucket = vars["bucket"] object = vars["object"] - // verify for if bucket is private or public - // verify for if bucket is private or public - // bucketMetadata, err := server.driver.GetBucketMetadata(bucket) - // if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) { - // writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path) - // return - // } - metadata, err := server.driver.GetObjectMetadata(bucket, object, "") - switch err := err.(type) { + switch err := iodine.ToError(err).(type) { case nil: { setObjectHeaders(w, metadata) @@ -156,19 +139,16 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques return } + // handle PublicRead ACL here + if !server.isValidOp(w, req, acceptsContentType) { + return + } + var object, bucket string vars := mux.Vars(req) bucket = vars["bucket"] object = vars["object"] - // verify for if bucket is private or public - // verify for if bucket is private or public - // bucketMetadata, err := server.driver.GetBucketMetadata(bucket) - // if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) || bucketMetadtata.ACL.IsPublicRead() { - // writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path) - // return - // } - // get Content-MD5 sent by client and verify if valid md5 := req.Header.Get("Content-MD5") if !isValidMD5(md5) { @@ -176,24 +156,11 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques return } err := server.driver.CreateObject(bucket, object, "", md5, req.Body) - switch err := err.(type) { + switch err := iodine.ToError(err).(type) { case nil: w.Header().Set("Server", "Minio") w.Header().Set("Connection", "close") w.WriteHeader(http.StatusOK) - case drivers.ImplementationError: - { - log.Error.Println(err) - writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path) - } - case drivers.BucketNotFound: - { - writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path) - } - case drivers.BucketNameInvalid: - { - writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path) - } case drivers.ObjectExists: { writeErrorResponse(w, req, NotImplemented, acceptsContentType, req.URL.Path) @@ -206,6 +173,11 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques { writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path) } + case drivers.ImplementationError: + { + log.Error.Println(err) + writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path) + } default: { log.Error.Println(err) diff --git a/pkg/api/api_test.go b/pkg/api/api_test.go index 477a22209..842665626 100644 --- a/pkg/api/api_test.go +++ b/pkg/api/api_test.go @@ -14,10 +14,13 @@ * limitations under the License. */ -package api_test +package api import ( "bytes" + "crypto/hmac" + "crypto/sha1" + "fmt" "io" "io/ioutil" "log" @@ -28,11 +31,11 @@ import ( "testing" "time" + "encoding/base64" "encoding/xml" "net/http" "net/http/httptest" - "github.com/minio-io/minio/pkg/api" "github.com/minio-io/minio/pkg/storage/drivers" "github.com/minio-io/minio/pkg/storage/drivers/donut" "github.com/minio-io/minio/pkg/storage/drivers/memory" @@ -107,7 +110,20 @@ func (s *MySuite) TearDownTest(c *C) { s.Root = "" } -func (s *MySuite) TestNonExistantObject(c *C) { +func setAuthHeader(req *http.Request) { + hm := hmac.New(sha1.New, []byte("H+AVh8q5G7hEH2r3WxFP135+Q19Aw8yXWel8IGh/HrEjZyTNx/n4Xw==")) + ss := getStringToSign(req) + io.WriteString(hm, ss) + + authHeader := new(bytes.Buffer) + fmt.Fprintf(authHeader, "AWS %s:", "AC5NH40NQLTL4D2W92PM") + encoder := base64.NewEncoder(base64.StdEncoding, authHeader) + encoder.Write(hm.Sum(nil)) + encoder.Close() + req.Header.Set("Authorization", authHeader.String()) +} + +func (s *MySuite) TestNonExistantBucket(c *C) { switch driver := s.Driver.(type) { case *mocks.Driver: { @@ -115,12 +131,17 @@ func (s *MySuite) TestNonExistantObject(c *C) { } } driver := s.Driver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() - s.MockDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.BucketNotFound{Bucket: "bucket"}).Once() - response, err := http.Get(testServer.URL + "/bucket/object") + s.MockDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{Bucket: "bucket"}).Once() + request, err := http.NewRequest("HEAD", testServer.URL+"/bucket", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusNotFound) } @@ -144,10 +165,11 @@ func (s *MySuite) TestEmptyObject(c *C) { } typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once() typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once() + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice() typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Once() typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Once() - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -155,7 +177,12 @@ func (s *MySuite) TestEmptyObject(c *C) { driver.CreateBucket("bucket", "private") driver.CreateObject("bucket", "object", "", "", buffer) - response, err := http.Get(testServer.URL + "/bucket/object") + request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -180,17 +207,23 @@ func (s *MySuite) TestBucket(c *C) { metadata := drivers.BucketMetadata{ Name: "bucket", Created: time.Now(), + ACL: drivers.BucketACL("private"), } typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once() - typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice() + typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once() - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() driver.CreateBucket("bucket", "private") - response, err := http.Head(testServer.URL + "/bucket") + request, err := http.NewRequest("HEAD", testServer.URL+"/bucket", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) } @@ -214,11 +247,12 @@ func (s *MySuite) TestObject(c *C) { } typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once() typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once() + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice() typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Twice() typedDriver.SetGetObjectWriter("bucket", "object", []byte("hello world")) typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once() - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -226,7 +260,12 @@ func (s *MySuite) TestObject(c *C) { driver.CreateBucket("bucket", "private") driver.CreateObject("bucket", "object", "", "", buffer) - response, err := http.Get(testServer.URL + "/bucket/object") + request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -272,7 +311,7 @@ func (s *MySuite) TestMultipleObjects(c *C) { Md5: "5eb63bbbe01eeed093cb22bb8f5acdc3", // TODO correct md5 Size: 11, } - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -290,20 +329,34 @@ func (s *MySuite) TestMultipleObjects(c *C) { driver.CreateObject("bucket", "object3", "", "", buffer3) // test non-existant object + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once() - response, err := http.Get(testServer.URL + "/bucket/object") + request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil) c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) + c.Assert(err, IsNil) + verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound) //// test object 1 // get object + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object1", "").Return(metadata1, nil).Once() typedDriver.SetGetObjectWriter("bucket", "object1", []byte("hello one")) typedDriver.On("GetObject", mock.Anything, "bucket", "object1").Return(int64(0), nil).Once() - response, err = http.Get(testServer.URL + "/bucket/object1") + request, err = http.NewRequest("GET", testServer.URL+"/bucket/object1", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client = http.Client{} + response, err = client.Do(request) c.Assert(err, IsNil) // get metadata + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object1", "").Return(metadata1, nil).Once() metadata, err := driver.GetObjectMetadata("bucket", "object1", "") c.Assert(err, IsNil) @@ -320,13 +373,20 @@ func (s *MySuite) TestMultipleObjects(c *C) { // test object 2 // get object + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object2", "").Return(metadata2, nil).Once() typedDriver.SetGetObjectWriter("bucket", "object2", []byte("hello two")) typedDriver.On("GetObject", mock.Anything, "bucket", "object2").Return(int64(0), nil).Once() - response, err = http.Get(testServer.URL + "/bucket/object2") + request, err = http.NewRequest("GET", testServer.URL+"/bucket/object2", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client = http.Client{} + response, err = client.Do(request) c.Assert(err, IsNil) // get metadata + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object2", "").Return(metadata2, nil).Once() metadata, err = driver.GetObjectMetadata("bucket", "object2", "") c.Assert(err, IsNil) @@ -343,15 +403,23 @@ func (s *MySuite) TestMultipleObjects(c *C) { // test object 3 // get object + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object3", "").Return(metadata3, nil).Once() typedDriver.SetGetObjectWriter("bucket", "object3", []byte("hello three")) typedDriver.On("GetObject", mock.Anything, "bucket", "object3").Return(int64(0), nil).Once() - response, err = http.Get(testServer.URL + "/bucket/object3") + request, err = http.NewRequest("GET", testServer.URL+"/bucket/object3", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client = http.Client{} + response, err = client.Do(request) c.Assert(err, IsNil) // get metadata + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object3", "").Return(metadata3, nil).Once() metadata, err = driver.GetObjectMetadata("bucket", "object3", "") + c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -373,11 +441,16 @@ func (s *MySuite) TestNotImplemented(c *C) { } } driver := s.Driver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() - response, err := http.Get(testServer.URL + "/bucket/object?acl") + request, err := http.NewRequest("GET", testServer.URL+"/bucket/object?acl", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusNotImplemented) @@ -393,19 +466,33 @@ func (s *MySuite) TestHeader(c *C) { driver := s.Driver typedDriver := s.MockDriver typedDriver.AssertExpectations(c) - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once() - driver.CreateBucket("bucket", "private") - - typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once() - response, err := http.Get(testServer.URL + "/bucket/object") + err := driver.CreateBucket("bucket", "private") c.Assert(err, IsNil) + + bucketMetadata := drivers.BucketMetadata{ + Name: "bucket", + Created: time.Now(), + ACL: drivers.BucketACL("private"), + } + typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once() + typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once() + request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) + c.Assert(err, IsNil) + verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound) buffer := bytes.NewBufferString("hello world") + typedDriver.On("GetBucketMetadata", "foo").Return(bucketMetadata, nil).Once() typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once() driver.CreateObject("bucket", "object", "", "", buffer) @@ -418,13 +505,20 @@ func (s *MySuite) TestHeader(c *C) { Size: 11, } + typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(objectMetadata, nil).Once() typedDriver.SetGetObjectWriter("", "", []byte("hello world")) typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once() - response, err = http.Get(testServer.URL + "/bucket/object") + request, err = http.NewRequest("GET", testServer.URL+"/bucket/object", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client = http.Client{} + response, err = client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) + typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(objectMetadata, nil).Once() metadata, err := driver.GetObjectMetadata("bucket", "object", "") c.Assert(err, IsNil) @@ -441,7 +535,7 @@ func (s *MySuite) TestPutBucket(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -454,6 +548,7 @@ func (s *MySuite) TestPutBucket(c *C) { request, err := http.NewRequest("PUT", testServer.URL+"/bucket", bytes.NewBufferString("")) c.Assert(err, IsNil) request.Header.Add("x-amz-acl", "private") + setAuthHeader(request) client := http.Client{} response, err := client.Do(request) @@ -477,7 +572,7 @@ func (s *MySuite) TestPutObject(c *C) { } driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -486,7 +581,9 @@ func (s *MySuite) TestPutObject(c *C) { resources.Maxkeys = 1000 resources.Prefix = "" - typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once() + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() + typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{}, + drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once() objects, resources, err := driver.ListObjects("bucket", resources) c.Assert(len(objects), Equals, 0) c.Assert(resources.IsTruncated, Equals, false) @@ -498,9 +595,10 @@ func (s *MySuite) TestPutObject(c *C) { // Put Bucket before - Put Object into a bucket typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once() - request, err := http.NewRequest("PUT", testServer.URL+"/bucket", bytes.NewBufferString("")) + request, err := http.NewRequest("PUT", testServer.URL+"/bucket", nil) c.Assert(err, IsNil) request.Header.Add("x-amz-acl", "private") + setAuthHeader(request) client := http.Client{} response, err := client.Do(request) @@ -510,6 +608,7 @@ func (s *MySuite) TestPutObject(c *C) { typedDriver.On("CreateObject", "bucket", "two", "", "", mock.Anything).Return(nil).Once() request, err = http.NewRequest("PUT", testServer.URL+"/bucket/two", bytes.NewBufferString("hello world")) c.Assert(err, IsNil) + setAuthHeader(request) response, err = client.Do(request) c.Assert(err, IsNil) @@ -529,6 +628,7 @@ func (s *MySuite) TestPutObject(c *C) { resources.Maxkeys = 1000 resources.Prefix = "" + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice() typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{{}}, drivers.BucketResourcesMetadata{}, nil).Once() objects, resources, err = driver.ListObjects("bucket", resources) c.Assert(len(objects), Equals, 1) @@ -561,13 +661,17 @@ func (s *MySuite) TestListBuckets(c *C) { } driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() typedDriver.On("ListBuckets").Return([]drivers.BucketMetadata{}, nil).Once() - response, err := http.Get(testServer.URL + "/") - defer response.Body.Close() + request, err := http.NewRequest("GET", testServer.URL+"/", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} + response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -583,8 +687,12 @@ func (s *MySuite) TestListBuckets(c *C) { {Name: "foo", Created: time.Now()}, } typedDriver.On("ListBuckets").Return(bucketMetadata, nil).Once() - response, err = http.Get(testServer.URL + "/") - defer response.Body.Close() + request, err = http.NewRequest("GET", testServer.URL+"/", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client = http.Client{} + response, err = client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -603,8 +711,12 @@ func (s *MySuite) TestListBuckets(c *C) { } typedDriver.On("ListBuckets").Return(bucketMetadata, nil).Once() - response, err = http.Get(testServer.URL + "/") - defer response.Body.Close() + request, err = http.NewRequest("GET", testServer.URL+"/", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client = http.Client{} + response, err = client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -616,8 +728,8 @@ func (s *MySuite) TestListBuckets(c *C) { c.Assert(listResponse.Buckets.Bucket[1].Name, Equals, "foo") } -func readListBucket(reader io.Reader) (api.BucketListResponse, error) { - var results api.BucketListResponse +func readListBucket(reader io.Reader) (BucketListResponse, error) { + var results BucketListResponse decoder := xml.NewDecoder(reader) err := decoder.Decode(&results) return results, err @@ -687,7 +799,7 @@ func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -696,14 +808,13 @@ func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) { c.Assert(err, IsNil) typedDriver.On("ListBuckets").Return([]drivers.BucketMetadata{{Name: "foo", Created: time.Now()}}, nil) - request, err := http.NewRequest("GET", testServer.URL+"/", bytes.NewBufferString("")) + request, err := http.NewRequest("GET", testServer.URL+"/", nil) c.Assert(err, IsNil) - request.Header.Add("Accept", "application/json") + setAuthHeader(request) client := http.Client{} response, err := client.Do(request) - c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -721,7 +832,7 @@ func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) { } driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -729,15 +840,25 @@ func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) { err := driver.CreateBucket("foo", "private") c.Assert(err, IsNil) - typedDriver.On("ListObjects", "foo", mock.Anything).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, nil).Once() - request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString("")) - c.Assert(err, IsNil) + resources := drivers.BucketResourcesMetadata{} + resources.Maxkeys = 1000 + resources.Prefix = "" + metadata := drivers.BucketMetadata{ + Name: "foo", + Created: time.Now(), + ACL: drivers.BucketACL("private"), + } + + typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once() + typedDriver.On("ListObjects", "foo", resources).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, nil).Once() + request, err := http.NewRequest("GET", testServer.URL+"/foo", nil) + c.Assert(err, IsNil) request.Header.Add("Accept", "application/json") + setAuthHeader(request) client := http.Client{} response, err := client.Do(request) - c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -756,7 +877,7 @@ func (s *MySuite) TestContentTypePersists(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -764,11 +885,19 @@ func (s *MySuite) TestContentTypePersists(c *C) { err := driver.CreateBucket("bucket", "private") c.Assert(err, IsNil) - client := http.Client{} + metadata := drivers.BucketMetadata{ + Name: "bucket", + Created: time.Now(), + ACL: drivers.BucketACL("private"), + } + typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once() typedDriver.On("CreateObject", "bucket", "one", "", "", mock.Anything).Return(nil).Once() request, err := http.NewRequest("PUT", testServer.URL+"/bucket/one", bytes.NewBufferString("hello world")) delete(request.Header, "Content-Type") c.Assert(err, IsNil) + setAuthHeader(request) + + client := http.Client{} response, err := client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -782,25 +911,39 @@ func (s *MySuite) TestContentTypePersists(c *C) { Md5: "d41d8cd98f00b204e9800998ecf8427e", Size: 0, } + typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "one", "").Return(oneMetadata, nil).Once() - request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/one", bytes.NewBufferString("")) + request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/one", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream") // test get object typedDriver.SetGetObjectWriter("bucket", "once", []byte("")) + typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice() typedDriver.On("GetObjectMetadata", "bucket", "one", "").Return(oneMetadata, nil).Once() typedDriver.On("GetObject", mock.Anything, "bucket", "one").Return(int64(0), nil).Once() - response, err = http.Get(testServer.URL + "/bucket/one") + request, err = http.NewRequest("GET", testServer.URL+"/bucket/one", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + client = http.Client{} + response, err = client.Do(request) + c.Assert(err, IsNil) + c.Assert(response.StatusCode, Equals, http.StatusOK) c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream") + typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once() typedDriver.On("CreateObject", "bucket", "two", "", "", mock.Anything).Return(nil).Once() request, err = http.NewRequest("PUT", testServer.URL+"/bucket/two", bytes.NewBufferString("hello world")) delete(request.Header, "Content-Type") request.Header.Add("Content-Type", "application/json") c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) c.Assert(response.StatusCode, Equals, http.StatusOK) @@ -814,17 +957,26 @@ func (s *MySuite) TestContentTypePersists(c *C) { Md5: "d41d8cd98f00b204e9800998ecf8427e", Size: 0, } + typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once() typedDriver.On("GetObjectMetadata", "bucket", "two", "").Return(twoMetadata, nil).Once() - request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/two", bytes.NewBufferString("")) + request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/two", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream") // test get object + typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice() typedDriver.On("GetObjectMetadata", "bucket", "two", "").Return(twoMetadata, nil).Once() typedDriver.On("GetObject", mock.Anything, "bucket", "two").Return(int64(0), nil).Once() - response, err = http.Get(testServer.URL + "/bucket/two") + request, err = http.NewRequest("GET", testServer.URL+"/bucket/two", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + + response, err = client.Do(request) + c.Assert(err, IsNil) c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream") } @@ -838,7 +990,7 @@ func (s *MySuite) TestPartialContent(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() @@ -860,14 +1012,18 @@ func (s *MySuite) TestPartialContent(c *C) { // prepare for GET on range request typedDriver.SetGetObjectWriter("foo", "bar", []byte("hello world")) + + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(metadata, nil).Once() typedDriver.On("GetPartialObject", mock.Anything, "foo", "bar", int64(6), int64(2)).Return(int64(2), nil).Once() // prepare request - request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString("")) + request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil) c.Assert(err, IsNil) request.Header.Add("Accept", "application/json") request.Header.Add("Range", "bytes=6-7") + setAuthHeader(request) + client := http.Client{} response, err := client.Do(request) c.Assert(err, IsNil) @@ -892,35 +1048,54 @@ func (s *MySuite) TestListObjectsHandlerErrors(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() client := http.Client{} - typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once() - - request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString("")) + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNameInvalid{}).Once() + request, err := http.NewRequest("GET", testServer.URL+"/foo", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err := client.Do(request) - verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound) - - typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BucketNameInvalid{}).Once() - request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString("")) - c.Assert(err, IsNil) - response, err = client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "InvalidBucketName", "The specified bucket is not valid.", http.StatusBadRequest) - typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNameInvalid{}).Once() - request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString("")) + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{}).Once() + request, err = http.NewRequest("GET", testServer.URL+"/foo", nil) c.Assert(err, IsNil) + setAuthHeader(request) + + response, err = client.Do(request) + verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound) + + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once() + typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNameInvalid{}).Once() + request, err = http.NewRequest("GET", testServer.URL+"/foo", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound) - typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once() - request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString("")) + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once() + typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNotFound{}).Once() + request, err = http.NewRequest("GET", testServer.URL+"/foo", nil) c.Assert(err, IsNil) + setAuthHeader(request) + + response, err = client.Do(request) + c.Assert(err, IsNil) + verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound) + + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BackendCorrupted{}).Once() + typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once() + request, err = http.NewRequest("GET", testServer.URL+"/foo", nil) + c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError) @@ -940,14 +1115,24 @@ func (s *MySuite) TestListBucketsErrors(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() client := http.Client{} - typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once() - request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString("")) + metadata := drivers.BucketMetadata{ + Name: "foo", + Created: time.Now(), + ACL: drivers.BucketACL("private"), + } + + typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once() + typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), + drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once() + request, err := http.NewRequest("GET", testServer.URL+"/foo", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err := client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError) @@ -967,7 +1152,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() client := http.Client{} @@ -976,6 +1161,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) { request, err := http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString("")) c.Assert(err, IsNil) request.Header.Add("x-amz-acl", "private") + setAuthHeader(request) response, err := client.Do(request) c.Assert(err, IsNil) @@ -985,6 +1171,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) { request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString("")) c.Assert(err, IsNil) request.Header.Add("x-amz-acl", "private") + setAuthHeader(request) response, err = client.Do(request) c.Assert(err, IsNil) @@ -994,6 +1181,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) { request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString("")) c.Assert(err, IsNil) request.Header.Add("x-amz-acl", "private") + setAuthHeader(request) response, err = client.Do(request) c.Assert(err, IsNil) @@ -1003,6 +1191,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) { request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString("")) c.Assert(err, IsNil) request.Header.Add("x-amz-acl", "unknown") + setAuthHeader(request) response, err = client.Do(request) c.Assert(err, IsNil) @@ -1023,42 +1212,60 @@ func (s *MySuite) TestGetObjectErrors(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() client := http.Client{} + metadata := drivers.BucketMetadata{ + Name: "foo", + Created: time.Now(), + ACL: drivers.BucketACL("private"), + } + typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once() typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once() - request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString("")) + request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err := client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound) - typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BucketNotFound{}).Once() - request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString("")) + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{}).Once() + request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound) + typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once() typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNameInvalid{}).Once() - request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString("")) + request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound) - typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BucketNameInvalid{}).Once() - request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString("")) + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNameInvalid{}).Once() + request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "InvalidBucketName", "The specified bucket is not valid.", http.StatusBadRequest) + typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once() typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BackendCorrupted{}).Once() - request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString("")) + request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil) c.Assert(err, IsNil) + setAuthHeader(request) + response, err = client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError) @@ -1078,7 +1285,7 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) { driver := s.Driver typedDriver := s.MockDriver - httpHandler := api.HTTPHandler("", driver) + httpHandler := HTTPHandler("", driver) testServer := httptest.NewServer(httpHandler) defer testServer.Close() client := http.Client{} @@ -1093,10 +1300,13 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) { Size: 11, } + typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once() typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(metadata, nil).Once() - request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString("")) + request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil) request.Header.Add("Range", "bytes=7-6") c.Assert(err, IsNil) + setAuthHeader(request) + response, err := client.Do(request) c.Assert(err, IsNil) verifyError(c, response, "InvalidRange", "The requested range cannot be satisfied.", http.StatusRequestedRangeNotSatisfiable) @@ -1105,7 +1315,7 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) { func verifyError(c *C, response *http.Response, code, description string, statusCode int) { data, err := ioutil.ReadAll(response.Body) c.Assert(err, IsNil) - errorResponse := api.ErrorResponse{} + errorResponse := ErrorResponse{} err = xml.Unmarshal(data, &errorResponse) c.Assert(err, IsNil) c.Assert(errorResponse.Code, Equals, code) diff --git a/pkg/api/utils.go b/pkg/api/utils.go index 33fc2352e..1828317fb 100644 --- a/pkg/api/utils.go +++ b/pkg/api/utils.go @@ -6,6 +6,9 @@ import ( ) func isValidMD5(md5 string) bool { + if md5 == "" { + return true + } _, err := base64.StdEncoding.DecodeString(strings.TrimSpace(md5)) if err != nil { return false diff --git a/pkg/storage/donut/objectstorage.go b/pkg/storage/donut/objectstorage.go index 2fd37efed..b32512d87 100644 --- a/pkg/storage/donut/objectstorage.go +++ b/pkg/storage/donut/objectstorage.go @@ -44,9 +44,10 @@ 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) // TODO get this, from whatever is written from SetBucketMetadata + metadata["created"] = time.Now().Format(time.RFC3339Nano) metadata["acl"] = "private" return metadata, nil } diff --git a/pkg/storage/drivers/api_testsuite.go b/pkg/storage/drivers/api_testsuite.go index 157a29f90..5206af404 100644 --- a/pkg/storage/drivers/api_testsuite.go +++ b/pkg/storage/drivers/api_testsuite.go @@ -26,6 +26,7 @@ import ( "time" "github.com/minio-io/check" + "github.com/minio-io/minio/pkg/iodine" ) // APITestSuite - collection of API tests @@ -105,6 +106,7 @@ func testPaging(c *check.C, create func() Driver) { key := "obj" + strconv.Itoa(i) drivers.CreateObject("bucket", key, "", "", bytes.NewBufferString(key)) resources.Maxkeys = 5 + resources.Prefix = "" objects, resources, err = drivers.ListObjects("bucket", resources) c.Assert(len(objects), check.Equals, i+1) c.Assert(resources.IsTruncated, check.Equals, false) @@ -115,6 +117,7 @@ func testPaging(c *check.C, create func() Driver) { key := "obj" + strconv.Itoa(i) drivers.CreateObject("bucket", key, "", "", bytes.NewBufferString(key)) resources.Maxkeys = 5 + resources.Prefix = "" objects, resources, err = drivers.ListObjects("bucket", resources) c.Assert(len(objects), check.Equals, 5) c.Assert(resources.IsTruncated, check.Equals, true) @@ -329,7 +332,7 @@ func testNonExistantObjectInBucket(c *check.C, create func() Driver) { c.Assert(length, check.Equals, int64(0)) c.Assert(err, check.Not(check.IsNil)) c.Assert(len(byteBuffer.Bytes()), check.Equals, 0) - switch err := err.(type) { + switch err := iodine.ToError(err).(type) { case ObjectNotFound: { c.Assert(err, check.ErrorMatches, "Object not Found: bucket#dir1") @@ -352,7 +355,7 @@ func testGetDirectoryReturnsObjectNotFound(c *check.C, create func() Driver) { var byteBuffer bytes.Buffer length, err := drivers.GetObject(&byteBuffer, "bucket", "dir1") c.Assert(length, check.Equals, int64(0)) - switch err := err.(type) { + switch err := iodine.ToError(err).(type) { case ObjectNotFound: { c.Assert(err.Bucket, check.Equals, "bucket") @@ -369,7 +372,7 @@ func testGetDirectoryReturnsObjectNotFound(c *check.C, create func() Driver) { var byteBuffer2 bytes.Buffer length, err = drivers.GetObject(&byteBuffer, "bucket", "dir1/") c.Assert(length, check.Equals, int64(0)) - switch err := err.(type) { + switch err := iodine.ToError(err).(type) { case ObjectNotFound: { c.Assert(err.Bucket, check.Equals, "bucket") diff --git a/pkg/storage/drivers/donut/donut.go b/pkg/storage/drivers/donut/donut.go index 8227f91e8..7ef131d6a 100644 --- a/pkg/storage/drivers/donut/donut.go +++ b/pkg/storage/drivers/donut/donut.go @@ -19,7 +19,6 @@ package donut import ( "encoding/base64" "encoding/hex" - "errors" "io" "os" "path" @@ -136,7 +135,7 @@ func (d donutDriver) GetBucketMetadata(bucketName string) (drivers.BucketMetadat } metadata, err := d.donut.GetBucketMetadata(bucketName) if err != nil { - return drivers.BucketMetadata{}, drivers.BucketNotFound{Bucket: bucketName} + return drivers.BucketMetadata{}, iodine.New(drivers.BucketNotFound{Bucket: bucketName}, nil) } created, err := time.Parse(time.RFC3339Nano, metadata["created"]) if err != nil { @@ -156,25 +155,21 @@ func (d donutDriver) GetBucketMetadata(bucketName string) (drivers.BucketMetadat // GetObject retrieves an object and writes it to a writer func (d donutDriver) GetObject(target io.Writer, bucketName, objectName string) (int64, error) { - errParams := map[string]string{ - "bucketName": bucketName, - "objectName": objectName, + if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") { + return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil) } - if bucketName == "" || strings.TrimSpace(bucketName) == "" { - return 0, iodine.New(errors.New("invalid argument"), errParams) - } - if objectName == "" || strings.TrimSpace(objectName) == "" { - return 0, iodine.New(errors.New("invalid argument"), errParams) + if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" { + return 0, iodine.New(drivers.ObjectNameInvalid{Object: objectName}, nil) } reader, size, err := d.donut.GetObject(bucketName, objectName) if err != nil { - return 0, drivers.ObjectNotFound{ + return 0, iodine.New(drivers.ObjectNotFound{ Bucket: bucketName, Object: objectName, - } + }, nil) } n, err := io.CopyN(target, reader, size) - return n, iodine.New(err, errParams) + return n, iodine.New(err, nil) } // GetPartialObject retrieves an object range and writes it to a writer @@ -186,25 +181,31 @@ func (d donutDriver) GetPartialObject(w io.Writer, bucketName, objectName string "start": strconv.FormatInt(start, 10), "length": strconv.FormatInt(length, 10), } - if bucketName == "" || strings.TrimSpace(bucketName) == "" { - return 0, iodine.New(errors.New("invalid argument"), errParams) + if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") { + return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, errParams) } - if objectName == "" || strings.TrimSpace(objectName) == "" { - return 0, iodine.New(errors.New("invalid argument"), errParams) + if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" { + return 0, iodine.New(drivers.ObjectNameInvalid{Object: objectName}, errParams) } if start < 0 { - return 0, iodine.New(errors.New("invalid argument"), errParams) + return 0, iodine.New(drivers.InvalidRange{ + Start: start, + Length: length, + }, errParams) } reader, size, err := d.donut.GetObject(bucketName, objectName) defer reader.Close() if err != nil { - return 0, drivers.ObjectNotFound{ + return 0, iodine.New(drivers.ObjectNotFound{ Bucket: bucketName, Object: objectName, - } + }, nil) } if start > size || (start+length-1) > size { - return 0, iodine.New(errors.New("invalid range"), errParams) + return 0, iodine.New(drivers.InvalidRange{ + Start: start, + Length: length, + }, errParams) } _, err = io.CopyN(ioutil.Discard, reader, start) if err != nil { @@ -224,6 +225,12 @@ func (d donutDriver) GetObjectMetadata(bucketName, objectName, prefixName string "objectName": objectName, "prefixName": prefixName, } + if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") { + return drivers.ObjectMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil) + } + if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" { + return drivers.ObjectMetadata{}, iodine.New(drivers.ObjectNameInvalid{Object: objectName}, nil) + } metadata, err := d.donut.GetObjectMetadata(bucketName, objectName) if err != nil { return drivers.ObjectMetadata{}, drivers.ObjectNotFound{ @@ -262,6 +269,12 @@ func (d donutDriver) ListObjects(bucketName string, resources drivers.BucketReso errParams := map[string]string{ "bucketName": bucketName, } + if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") { + return nil, drivers.BucketResourcesMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil) + } + if !drivers.IsValidObject(resources.Prefix) { + return nil, drivers.BucketResourcesMetadata{}, iodine.New(drivers.ObjectNameInvalid{Object: resources.Prefix}, nil) + } actualObjects, commonPrefixes, isTruncated, err := d.donut.ListObjects(bucketName, resources.Prefix, resources.Marker, @@ -305,11 +318,11 @@ func (d donutDriver) CreateObject(bucketName, objectName, contentType, expectedM "objectName": objectName, "contentType": contentType, } - if bucketName == "" || strings.TrimSpace(bucketName) == "" { - return iodine.New(errors.New("invalid argument"), errParams) + if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") { + return iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil) } - if objectName == "" || strings.TrimSpace(objectName) == "" { - return iodine.New(errors.New("invalid argument"), errParams) + if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" { + return iodine.New(drivers.ObjectNameInvalid{Object: objectName}, nil) } if strings.TrimSpace(contentType) == "" { contentType = "application/octet-stream" @@ -324,7 +337,6 @@ func (d donutDriver) CreateObject(bucketName, objectName, contentType, expectedM } expectedMD5Sum = hex.EncodeToString(expectedMD5SumBytes) } - err := d.donut.PutObject(bucketName, objectName, expectedMD5Sum, ioutil.NopCloser(reader), metadata) if err != nil { return iodine.New(err, errParams) diff --git a/pkg/storage/drivers/driver.go b/pkg/storage/drivers/driver.go index 40792daaa..8f64fe565 100644 --- a/pkg/storage/drivers/driver.go +++ b/pkg/storage/drivers/driver.go @@ -19,6 +19,7 @@ package drivers import ( "io" "regexp" + "strings" "time" "unicode/utf8" ) @@ -185,6 +186,9 @@ func IsValidBucket(bucket string) bool { // IsValidObject - verify object name in accordance with // - http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html func IsValidObject(object string) bool { + if strings.TrimSpace(object) == "" { + return true + } if len(object) > 1024 || len(object) == 0 { return false } diff --git a/pkg/storage/drivers/errors.go b/pkg/storage/drivers/errors.go index bcd3a2cd3..e01dfd13b 100644 --- a/pkg/storage/drivers/errors.go +++ b/pkg/storage/drivers/errors.go @@ -16,6 +16,8 @@ package drivers +import "fmt" + // BackendError - generic disk backend error type BackendError struct { Path string @@ -164,3 +166,23 @@ func (e BadDigest) Error() string { func (e InvalidDigest) Error() string { return "Md5 provided " + e.Md5 + " is invalid" } + +// OperationNotPermitted - operation not permitted +type OperationNotPermitted struct { + Op string + Reason string +} + +func (e OperationNotPermitted) Error() string { + return "Operation " + e.Op + " not permitted for reason: " + e.Reason +} + +// InvalidRange - invalid range +type InvalidRange struct { + Start int64 + Length int64 +} + +func (e InvalidRange) Error() string { + return fmt.Sprintf("Invalid range start:%d length:%d", e.Start, e.Length) +} diff --git a/pkg/storage/drivers/memory/memory.go b/pkg/storage/drivers/memory/memory.go index 62dcb365f..0ee77aef3 100644 --- a/pkg/storage/drivers/memory/memory.go +++ b/pkg/storage/drivers/memory/memory.go @@ -25,14 +25,14 @@ import ( "sync" "time" - "github.com/minio-io/minio/pkg/storage/drivers" - "crypto/md5" "encoding/hex" "io/ioutil" "github.com/golang/groupcache/lru" + "github.com/minio-io/minio/pkg/iodine" + "github.com/minio-io/minio/pkg/storage/drivers" "github.com/minio-io/minio/pkg/utils/log" ) @@ -91,8 +91,14 @@ func start(ctrlChannel <-chan string, errorChannel chan<- error) { func (memory *memoryDriver) GetObject(w io.Writer, bucket string, object string) (int64, error) { memory.lock.RLock() defer memory.lock.RUnlock() + if !drivers.IsValidBucket(bucket) { + return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil) + } + if !drivers.IsValidObject(object) { + return 0, iodine.New(drivers.ObjectNameInvalid{Object: object}, nil) + } if _, ok := memory.bucketMetadata[bucket]; ok == false { - return 0, drivers.BucketNotFound{Bucket: bucket} + return 0, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil) } // get object objectKey := bucket + "/" + object @@ -101,10 +107,10 @@ func (memory *memoryDriver) GetObject(w io.Writer, bucket string, object string) dataSlice := data.([]byte) objectBuffer := bytes.NewBuffer(dataSlice) written, err := io.Copy(w, objectBuffer) - return written, err + return written, iodine.New(err, nil) } } - return 0, drivers.ObjectNotFound{Bucket: bucket, Object: object} + return 0, iodine.New(drivers.ObjectNotFound{Bucket: bucket, Object: object}, nil) } // GetPartialObject - GET object from memory buffer range @@ -112,11 +118,17 @@ func (memory *memoryDriver) GetPartialObject(w io.Writer, bucket, object string, memory.lock.RLock() defer memory.lock.RUnlock() var sourceBuffer bytes.Buffer + if !drivers.IsValidBucket(bucket) { + return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil) + } + if !drivers.IsValidObject(object) { + return 0, iodine.New(drivers.ObjectNameInvalid{Object: object}, nil) + } if _, err := memory.GetObject(&sourceBuffer, bucket, object); err != nil { - return 0, err + return 0, iodine.New(err, nil) } if _, err := io.CopyN(ioutil.Discard, &sourceBuffer, start); err != nil { - return 0, err + return 0, iodine.New(err, nil) } return io.CopyN(w, &sourceBuffer, length) } @@ -125,8 +137,11 @@ func (memory *memoryDriver) GetPartialObject(w io.Writer, bucket, object string, func (memory *memoryDriver) GetBucketMetadata(bucket string) (drivers.BucketMetadata, error) { memory.lock.RLock() defer memory.lock.RUnlock() + if !drivers.IsValidBucket(bucket) { + return drivers.BucketMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil) + } if _, ok := memory.bucketMetadata[bucket]; ok == false { - return drivers.BucketMetadata{}, drivers.BucketNotFound{Bucket: bucket} + return drivers.BucketMetadata{}, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil) } return memory.bucketMetadata[bucket].metadata, nil } @@ -134,17 +149,22 @@ func (memory *memoryDriver) GetBucketMetadata(bucket string) (drivers.BucketMeta // CreateObject - PUT object to memory buffer func (memory *memoryDriver) CreateObject(bucket, key, contentType, md5sum string, data io.Reader) error { memory.lock.RLock() - + if !drivers.IsValidBucket(bucket) { + memory.lock.RUnlock() + return iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil) + } + if !drivers.IsValidObject(key) { + memory.lock.RUnlock() + return iodine.New(drivers.ObjectNameInvalid{Object: key}, nil) + } if _, ok := memory.bucketMetadata[bucket]; ok == false { memory.lock.RUnlock() - return drivers.BucketNotFound{Bucket: bucket} + return iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil) } - objectKey := bucket + "/" + key - if _, ok := memory.objectMetadata[objectKey]; ok == true { memory.lock.RUnlock() - return drivers.ObjectExists{Bucket: bucket, Object: key} + return iodine.New(drivers.ObjectExists{Bucket: bucket, Object: key}, nil) } memory.lock.RUnlock() @@ -175,7 +195,7 @@ func (memory *memoryDriver) CreateObject(bucket, key, contentType, md5sum string memory.lock.Lock() if _, ok := memory.objectMetadata[objectKey]; ok == true { memory.lock.Unlock() - return drivers.ObjectExists{Bucket: bucket, Object: key} + return iodine.New(drivers.ObjectExists{Bucket: bucket, Object: key}, nil) } memory.objectMetadata[objectKey] = newObject memory.objects.Add(objectKey, dataSlice) @@ -192,15 +212,15 @@ func (memory *memoryDriver) CreateBucket(bucketName, acl string) error { memory.lock.RLock() if !drivers.IsValidBucket(bucketName) { memory.lock.RUnlock() - return drivers.BucketNameInvalid{Bucket: bucketName} + return iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil) } if !drivers.IsValidBucketACL(acl) { memory.lock.RUnlock() - return drivers.InvalidACL{ACL: acl} + return iodine.New(drivers.InvalidACL{ACL: acl}, nil) } if _, ok := memory.bucketMetadata[bucketName]; ok == true { memory.lock.RUnlock() - return drivers.BucketExists{Bucket: bucketName} + return iodine.New(drivers.BucketExists{Bucket: bucketName}, nil) } memory.lock.RUnlock() @@ -247,42 +267,53 @@ func (memory *memoryDriver) filterDelimiterPrefix(keys []string, key, delimitedN return resources, keys } +func (memory *memoryDriver) listObjectsInternal(keys []string, key string, resources drivers.BucketResourcesMetadata) ([]string, drivers.BucketResourcesMetadata) { + switch true { + // Prefix absent, delimit object key based on delimiter + case resources.IsDelimiterSet(): + delimitedName := delimiter(key, resources.Delimiter) + switch true { + case delimitedName == "" || delimitedName == key: + keys = appendUniq(keys, key) + case delimitedName != "": + resources.CommonPrefixes = appendUniq(resources.CommonPrefixes, delimitedName) + } + // Prefix present, delimit object key with prefix key based on delimiter + case resources.IsDelimiterPrefixSet(): + if strings.HasPrefix(key, resources.Prefix) { + trimmedName := strings.TrimPrefix(key, resources.Prefix) + delimitedName := delimiter(trimmedName, resources.Delimiter) + resources, keys = memory.filterDelimiterPrefix(keys, key, delimitedName, resources) + } + // Prefix present, nothing to delimit + case resources.IsPrefixSet(): + keys = appendUniq(keys, key) + // Prefix and delimiter absent + case resources.IsDefault(): + keys = appendUniq(keys, key) + } + return keys, resources +} + // ListObjects - list objects from memory func (memory *memoryDriver) ListObjects(bucket string, resources drivers.BucketResourcesMetadata) ([]drivers.ObjectMetadata, drivers.BucketResourcesMetadata, error) { memory.lock.RLock() defer memory.lock.RUnlock() + if !drivers.IsValidBucket(bucket) { + return nil, drivers.BucketResourcesMetadata{IsTruncated: false}, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil) + } + if !drivers.IsValidObject(resources.Prefix) { + return nil, drivers.BucketResourcesMetadata{IsTruncated: false}, iodine.New(drivers.ObjectNameInvalid{Object: resources.Prefix}, nil) + } if _, ok := memory.bucketMetadata[bucket]; ok == false { - return []drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{IsTruncated: false}, drivers.BucketNotFound{Bucket: bucket} + return nil, drivers.BucketResourcesMetadata{IsTruncated: false}, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil) } var results []drivers.ObjectMetadata var keys []string for key := range memory.objectMetadata { if strings.HasPrefix(key, bucket+"/") { key = key[len(bucket)+1:] - switch true { - // Prefix absent, delimit object key based on delimiter - case resources.IsDelimiterSet(): - delimitedName := delimiter(key, resources.Delimiter) - switch true { - case delimitedName == "" || delimitedName == key: - keys = appendUniq(keys, key) - case delimitedName != "": - resources.CommonPrefixes = appendUniq(resources.CommonPrefixes, delimitedName) - } - // Prefix present, delimit object key with prefix key based on delimiter - case resources.IsDelimiterPrefixSet(): - if strings.HasPrefix(key, resources.Prefix) { - trimmedName := strings.TrimPrefix(key, resources.Prefix) - delimitedName := delimiter(trimmedName, resources.Delimiter) - resources, keys = memory.filterDelimiterPrefix(keys, key, delimitedName, resources) - } - // Prefix present, nothing to delimit - case resources.IsPrefixSet(): - keys = appendUniq(keys, key) - // Prefix and delimiter absent - case resources.IsDefault(): - keys = appendUniq(keys, key) - } + keys, resources = memory.listObjectsInternal(keys, key, resources) } } sort.Strings(keys) @@ -327,21 +358,24 @@ func (memory *memoryDriver) GetObjectMetadata(bucket, key, prefix string) (drive memory.lock.RLock() defer memory.lock.RUnlock() // check if bucket exists - if _, ok := memory.bucketMetadata[bucket]; ok == false { - return drivers.ObjectMetadata{}, drivers.BucketNotFound{Bucket: bucket} + if !drivers.IsValidBucket(bucket) { + return drivers.ObjectMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil) + } + if !drivers.IsValidObject(key) || !drivers.IsValidObject(prefix) { + return drivers.ObjectMetadata{}, iodine.New(drivers.ObjectNameInvalid{Object: key}, nil) + } + if _, ok := memory.bucketMetadata[bucket]; ok == false { + return drivers.ObjectMetadata{}, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil) } - objectKey := bucket + "/" + key - if object, ok := memory.objectMetadata[objectKey]; ok == true { return object.metadata, nil } - return drivers.ObjectMetadata{}, drivers.ObjectNotFound{Bucket: bucket, Object: key} + return drivers.ObjectMetadata{}, iodine.New(drivers.ObjectNotFound{Bucket: bucket, Object: key}, nil) } func (memory *memoryDriver) evictObject(key lru.Key, value interface{}) { k := key.(string) - memory.totalSize = memory.totalSize - memory.objectMetadata[k].metadata.Size log.Println("evicting:", k) delete(memory.objectMetadata, k)