mirror of
https://github.com/minio/minio.git
synced 2025-02-25 04:19:13 -05:00
Merge pull request #474 from harshavardhana/pr_out_finishing_all_the_test_case_support_for_acl_and_other_fixes
This commit is contained in:
Harshavardhana
commit
b153834d4d
@ -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"]
|
||||
// verify if bucket allows this operation
|
||||
if !server.isValidOp(w, req, acceptsContentType) {
|
||||
return
|
||||
}
|
||||
|
||||
// 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:
|
||||
{
|
||||
// Always a success if isValidOp succeeds
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -56,12 +56,17 @@ 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
|
||||
}
|
||||
// success
|
||||
h.handler.ServeHTTP(w, r)
|
||||
|
||||
// Enable below only when webcli is ready
|
||||
|
||||
/*
|
||||
switch true {
|
||||
case accessKey != "":
|
||||
if err := h.conf.ReadConfig(); err != nil {
|
||||
@ -93,6 +98,7 @@ func (h vHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
// w.WriteHeader(error.HTTPStatusCode)
|
||||
// w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
// Ignore resources handler is wrapper handler used for API request resource validation
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
@ -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")
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
@ -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)
|
||||
}
|
||||
|
||||
@ -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,18 +267,7 @@ func (memory *memoryDriver) filterDelimiterPrefix(keys []string, key, delimitedN
|
||||
return resources, keys
|
||||
}
|
||||
|
||||
// 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 _, ok := memory.bucketMetadata[bucket]; ok == false {
|
||||
return []drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{IsTruncated: false}, drivers.BucketNotFound{Bucket: bucket}
|
||||
}
|
||||
var results []drivers.ObjectMetadata
|
||||
var keys []string
|
||||
for key := range memory.objectMetadata {
|
||||
if strings.HasPrefix(key, bucket+"/") {
|
||||
key = key[len(bucket)+1:]
|
||||
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():
|
||||
@ -283,6 +292,28 @@ func (memory *memoryDriver) ListObjects(bucket string, resources drivers.BucketR
|
||||
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 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:]
|
||||
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)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user