Make donut fully integrated back into API handlers

2025-11-21 02:09:08 -05:00 · 2015-07-02 20:31:22 -07:00
parent 12bde7df30
commit 7c37e9d06a
18 changed files with 971 additions and 595 deletions
--- a/pkg/server/api/object-handlers.go
+++ b/pkg/server/api/object-handlers.go
@@ -9,7 +9,7 @@
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implieapi.Donut.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@@ -25,6 +25,7 @@ import (

 	"github.com/gorilla/mux"
 	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/storage/donut"
 	"github.com/minio/minio/pkg/utils/log"
 )

@@ -37,17 +38,16 @@ const (
 // This implementation of the GET operation retrieves object. To use GET,
 // you must have READ access to the object.
 func (api Minio) GetObjectHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)
+
+	acceptsContentType := getContentType(req)

 	// verify if this operation is allowed
 	if !api.isValidOp(w, req, acceptsContentType) {
@@ -58,25 +58,57 @@ func (api Minio) GetObjectHandler(w http.ResponseWriter, req *http.Request) {
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
-	log.Println(bucket, object)

+	metadata, err := api.Donut.GetObjectMetadata(bucket, object)
+	switch iodine.ToError(err).(type) {
+	case nil: // success
+		{
+			httpRange, err := getRequestedRange(req, metadata.Size)
+			if err != nil {
+				writeErrorResponse(w, req, InvalidRange, acceptsContentType, req.URL.Path)
+				return
+			}
+			switch httpRange.start == 0 && httpRange.length == 0 {
+			case true:
+				setObjectHeaders(w, metadata)
+				if _, err := api.Donut.GetObject(w, bucket, object); err != nil {
+					// unable to write headers, we've already printed data. Just close the connection.
+					log.Error.Println(iodine.New(err, nil))
+				}
+			case false:
+				metadata.Size = httpRange.length
+				setRangeObjectHeaders(w, metadata, httpRange)
+				w.WriteHeader(http.StatusPartialContent)
+				if _, err := api.Donut.GetPartialObject(w, bucket, object, httpRange.start, httpRange.length); err != nil {
+					// unable to write headers, we've already printed data. Just close the connection.
+					log.Error.Println(iodine.New(err, nil))
+				}
+			}
+		}
+	case donut.ObjectNotFound:
+		writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
+	case donut.ObjectNameInvalid:
+		writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }

 // HeadObjectHandler - HEAD Object
 // -----------
 // The HEAD operation retrieves metadata from an object without returning the object itself.
 func (api Minio) HeadObjectHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)
+
+	acceptsContentType := getContentType(req)

 	// verify if this operation is allowed
 	if !api.isValidOp(w, req, acceptsContentType) {
@@ -87,25 +119,42 @@ func (api Minio) HeadObjectHandler(w http.ResponseWriter, req *http.Request) {
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
-	log.Println(bucket, object)
+
+	metadata, err := api.Donut.GetObjectMetadata(bucket, object)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		setObjectHeaders(w, metadata)
+		w.WriteHeader(http.StatusOK)
+	case donut.ObjectNotFound:
+		error := getErrorCode(NoSuchKey)
+		w.Header().Set("Server", "Minio")
+		w.WriteHeader(error.HTTPStatusCode)
+	case donut.ObjectNameInvalid:
+		error := getErrorCode(NoSuchKey)
+		w.Header().Set("Server", "Minio")
+		w.WriteHeader(error.HTTPStatusCode)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		error := getErrorCode(InternalError)
+		w.Header().Set("Server", "Minio")
+		w.WriteHeader(error.HTTPStatusCode)
+	}
 }

 // PutObjectHandler - PUT Object
 // ----------
 // This implementation of the PUT operation adds an object to a bucket.
 func (api Minio) PutObjectHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// Ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)

+	acceptsContentType := getContentType(req)
 	// verify if this operation is allowed
 	if !api.isValidOp(w, req, acceptsContentType) {
 		return
@@ -122,7 +171,7 @@ func (api Minio) PutObjectHandler(w http.ResponseWriter, req *http.Request) {
 		writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
 		return
 	}
-	/// if Content-Length missing, throw away
+	/// if Content-Length missing, deny the request
 	size := req.Header.Get("Content-Length")
 	if size == "" {
 		writeErrorResponse(w, req, MissingContentLength, acceptsContentType, req.URL.Path)
@@ -148,24 +197,40 @@ func (api Minio) PutObjectHandler(w http.ResponseWriter, req *http.Request) {
 		writeErrorResponse(w, req, InvalidRequest, acceptsContentType, req.URL.Path)
 		return
 	}
-	log.Println(bucket, object, sizeInt64)
+
+	metadata, err := api.Donut.CreateObject(bucket, object, md5, sizeInt64, req.Body, nil)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		w.Header().Set("ETag", metadata.MD5Sum)
+		writeSuccessResponse(w, acceptsContentType)
+	case donut.ObjectExists:
+		writeErrorResponse(w, req, MethodNotAllowed, acceptsContentType, req.URL.Path)
+	case donut.BadDigest:
+		writeErrorResponse(w, req, BadDigest, acceptsContentType, req.URL.Path)
+	case donut.EntityTooLarge:
+		writeErrorResponse(w, req, EntityTooLarge, acceptsContentType, req.URL.Path)
+	case donut.InvalidDigest:
+		writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }

 /// Multipart API

 // NewMultipartUploadHandler - New multipart upload
 func (api Minio) NewMultipartUploadHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// Ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)
+
+	acceptsContentType := getContentType(req)

 	// handle ACL's here at bucket level
 	if !api.isValidOp(w, req, acceptsContentType) {
@@ -181,22 +246,38 @@ func (api Minio) NewMultipartUploadHandler(w http.ResponseWriter, req *http.Requ
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
-	log.Println(bucket, object)
+
+	uploadID, err := api.Donut.NewMultipartUpload(bucket, object, "")
+	switch iodine.ToError(err).(type) {
+	case nil:
+		{
+			response := generateInitiateMultipartUploadResult(bucket, object, uploadID)
+			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+			// write headers
+			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+			// write body
+			w.Write(encodedSuccessResponse)
+		}
+	case donut.ObjectExists:
+		writeErrorResponse(w, req, MethodNotAllowed, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }

 // PutObjectPartHandler - Upload part
 func (api Minio) PutObjectPartHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// Ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)
+
+	acceptsContentType := getContentType(req)

 	// handle ACL's here at bucket level
 	if !api.isValidOp(w, req, acceptsContentType) {
@@ -232,7 +313,6 @@ func (api Minio) PutObjectPartHandler(w http.ResponseWriter, req *http.Request)
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
 	object := vars["object"]
-	log.Println(bucket, object, sizeInt64)

 	uploadID := req.URL.Query().Get("uploadId")
 	partIDString := req.URL.Query().Get("partNumber")
@@ -241,22 +321,40 @@ func (api Minio) PutObjectPartHandler(w http.ResponseWriter, req *http.Request)
 	if err != nil {
 		writeErrorResponse(w, req, InvalidPart, acceptsContentType, req.URL.Path)
 	}
-	log.Println(uploadID, partID)
+
+	calculatedMD5, err := api.Donut.CreateObjectPart(bucket, object, uploadID, partID, "", md5, sizeInt64, req.Body)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		w.Header().Set("ETag", calculatedMD5)
+		writeSuccessResponse(w, acceptsContentType)
+	case donut.InvalidUploadID:
+		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
+	case donut.ObjectExists:
+		writeErrorResponse(w, req, MethodNotAllowed, acceptsContentType, req.URL.Path)
+	case donut.BadDigest:
+		writeErrorResponse(w, req, BadDigest, acceptsContentType, req.URL.Path)
+	case donut.EntityTooLarge:
+		writeErrorResponse(w, req, EntityTooLarge, acceptsContentType, req.URL.Path)
+	case donut.InvalidDigest:
+		writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }

 // AbortMultipartUploadHandler - Abort multipart upload
 func (api Minio) AbortMultipartUploadHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// Ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)
+
+	acceptsContentType := getContentType(req)

 	// handle ACL's here at bucket level
 	if !api.isValidOp(w, req, acceptsContentType) {
@@ -267,23 +365,33 @@ func (api Minio) AbortMultipartUploadHandler(w http.ResponseWriter, req *http.Re
 	bucket := vars["bucket"]
 	object := vars["object"]

-	//objectResourcesMetadata := getObjectResources(req.URL.Query())
-	log.Println(bucket, object)
+	objectResourcesMetadata := getObjectResources(req.URL.Query())
+
+	err := api.Donut.AbortMultipartUpload(bucket, object, objectResourcesMetadata.UploadID)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), 0)
+		w.WriteHeader(http.StatusNoContent)
+	case donut.InvalidUploadID:
+		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }

 // ListObjectPartsHandler - List object parts
 func (api Minio) ListObjectPartsHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// Ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)
+
+	acceptsContentType := getContentType(req)

 	// handle ACL's here at bucket level
 	if !api.isValidOp(w, req, acceptsContentType) {
@@ -298,22 +406,38 @@ func (api Minio) ListObjectPartsHandler(w http.ResponseWriter, req *http.Request
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
 	object := vars["object"]
-	log.Println(bucket, object)
+
+	objectResourcesMetadata, err := api.Donut.ListObjectParts(bucket, object, objectResourcesMetadata)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		{
+			response := generateListPartsResult(objectResourcesMetadata)
+			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+			// write headers
+			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+			// write body
+			w.Write(encodedSuccessResponse)
+		}
+	case donut.InvalidUploadID:
+		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }

 // CompleteMultipartUploadHandler - Complete multipart upload
 func (api Minio) CompleteMultipartUploadHandler(w http.ResponseWriter, req *http.Request) {
-	acceptsContentType := getContentType(req)
-
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
+	// Ticket master block
 	{
-		// do you operation
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
 	}
-	log.Println(acceptsContentType)
+
+	acceptsContentType := getContentType(req)

 	// handle ACL's here at bucket level
 	if !api.isValidOp(w, req, acceptsContentType) {
@@ -336,15 +460,31 @@ func (api Minio) CompleteMultipartUploadHandler(w http.ResponseWriter, req *http
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
 	object := vars["object"]
-	log.Println(bucket, object)

-	//objectResourcesMetadata := getObjectResources(req.URL.Query())
+	objectResourcesMetadata := getObjectResources(req.URL.Query())

 	partMap := make(map[int]string)
 	for _, part := range parts.Part {
 		partMap[part.PartNumber] = part.ETag
 	}

+	metadata, err := api.Donut.CompleteMultipartUpload(bucket, object, objectResourcesMetadata.UploadID, partMap)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		{
+			response := generateCompleteMultpartUploadResult(bucket, object, "", metadata.MD5Sum)
+			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+			// write headers
+			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+			// write body
+			w.Write(encodedSuccessResponse)
+		}
+	case donut.InvalidUploadID:
+		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }

 /// Delete API