Make donut fully integrated back into API handlers

pkg/server/api/api.go

@@ -16,6 +16,8 @@
 
 package api
 
+import "github.com/minio/minio/pkg/storage/donut"
+
 // Operation container for individual operations read by Ticket Master
 type Operation struct {
 	ProceedCh chan struct{}
@@ -23,10 +25,16 @@ type Operation struct {
 
 // Minio container for API and also carries OP (operation) channel
 type Minio struct {
-	OP chan Operation
+	OP    chan Operation
+	Donut donut.Interface
 }
 
 // New instantiate a new minio API
 func New() Minio {
-	return Minio{OP: make(chan Operation)}
+	// ignore errors for now
+	d, _ := donut.LoadDonut()
+	return Minio{
+		OP:    make(chan Operation),
+		Donut: d,
+	}
 }

pkg/server/api/bucket-handlers.go

@@ -17,16 +17,51 @@
 package api
 
 import (
-	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
+	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/storage/donut"
+	"github.com/minio/minio/pkg/utils/log"
 )
 
 func (api Minio) isValidOp(w http.ResponseWriter, req *http.Request, acceptsContentType contentType) bool {
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
-	log.Println(bucket)
+
+	bucketMetadata, err := api.Donut.GetBucketMetadata(bucket)
+	switch iodine.ToError(err).(type) {
+	case donut.BucketNotFound:
+		{
+			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
+			return false
+		}
+	case donut.BucketNameInvalid:
+		{
+			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
+			return false
+		}
+	case nil:
+		if _, err := stripAuth(req); err != nil {
+			if bucketMetadata.ACL.IsPrivate() {
+				return true
+				//uncomment this when we have webcli
+				//writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+				//return false
+			}
+			if bucketMetadata.ACL.IsPublicRead() && req.Method == "PUT" {
+				return true
+				//uncomment this when we have webcli
+				//writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+				//return false
+			}
+		}
+	default:
+		{
+			log.Error.Println(iodine.New(err, nil))
+			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+		}
+	}
 	return true
 }
 
@@ -38,18 +73,16 @@ func (api Minio) isValidOp(w http.ResponseWriter, req *http.Request, acceptsCont
 // This operation returns at most 1,000 multipart uploads in the response.
 //
 func (api Minio) ListMultipartUploadsHandler(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)
 	resources := getBucketMultipartResources(req.URL.Query())
 	if resources.MaxUploads == 0 {
 		resources.MaxUploads = maxObjectList
@@ -57,7 +90,29 @@ func (api Minio) ListMultipartUploadsHandler(w http.ResponseWriter, req *http.Re
 
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
-	log.Println(bucket)
+
+	resources, err := api.Donut.ListMultipartUploads(bucket, resources)
+	switch iodine.ToError(err).(type) {
+	case nil: // success
+		{
+			// generate response
+			response := generateListMultipartUploadsResult(bucket, resources)
+			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+			// write headers
+			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+			// write body
+			w.Write(encodedSuccessResponse)
+		}
+	case donut.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)
+		}
+	}
 }
 
 // ListObjectsHandler - GET Bucket (List Objects)
@@ -67,18 +122,16 @@ func (api Minio) ListMultipartUploadsHandler(w http.ResponseWriter, req *http.Re
 // criteria to return a subset of the objects in a bucket.
 //
 func (api Minio) ListObjectsHandler(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 bucket allows this operation
 	if !api.isValidOp(w, req, acceptsContentType) {
 		return
@@ -96,8 +149,25 @@ func (api Minio) ListObjectsHandler(w http.ResponseWriter, req *http.Request) {
 
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
-	log.Println(bucket)
 
+	objects, resources, err := api.Donut.ListObjects(bucket, resources)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		// generate response
+		response := generateListObjectsResponse(bucket, objects, resources)
+		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+		// write headers
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+		// write body
+		w.Write(encodedSuccessResponse)
+	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)
+	}
 }
 
 // ListBucketsHandler - GET Service
@@ -105,6 +175,15 @@ func (api Minio) ListObjectsHandler(w http.ResponseWriter, req *http.Request) {
 // This implementation of the GET operation returns a list of all buckets
 // owned by the authenticated sender of the request.
 func (api Minio) ListBucketsHandler(w http.ResponseWriter, req *http.Request) {
+	// Ticket master block
+	{
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
+	}
+
 	acceptsContentType := getContentType(req)
 	// uncomment this when we have webcli
 	// without access key credentials one cannot list buckets
@@ -112,21 +191,36 @@ func (api Minio) ListBucketsHandler(w http.ResponseWriter, req *http.Request) {
 	//	writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
 	//	return
 	// }
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
-	{
-		// do you operation
+
+	buckets, err := api.Donut.ListBuckets()
+	switch iodine.ToError(err).(type) {
+	case nil:
+		// generate response
+		response := generateListBucketsResponse(buckets)
+		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+		// write headers
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+		// write response
+		w.Write(encodedSuccessResponse)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
-	log.Println(acceptsContentType)
 }
 
 // PutBucketHandler - PUT Bucket
 // ----------
 // This implementation of the PUT operation creates a new bucket for authenticated request
 func (api Minio) PutBucketHandler(w http.ResponseWriter, req *http.Request) {
+	// Ticket master block
+	{
+		op := Operation{}
+		op.ProceedCh = make(chan struct{})
+		api.OP <- op
+		// block until Ticket master gives us a go
+		<-op.ProceedCh
+	}
+
 	acceptsContentType := getContentType(req)
 	// uncomment this when we have webcli
 	// without access key credentials one cannot create a bucket
@@ -134,15 +228,6 @@ func (api Minio) PutBucketHandler(w http.ResponseWriter, req *http.Request) {
 	// 	writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
 	//	return
 	// }
-	op := Operation{}
-	op.ProceedCh = make(chan struct{})
-	api.OP <- op
-	// block until Ticket master gives us a go
-	<-op.ProceedCh
-	{
-		// do you operation
-	}
-	log.Println(acceptsContentType)
 
 	if isRequestBucketACL(req.URL.Query()) {
 		api.PutBucketACLHandler(w, req)
@@ -157,24 +242,39 @@ func (api Minio) PutBucketHandler(w http.ResponseWriter, req *http.Request) {
 
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
-	log.Println(bucket)
+
+	err := api.Donut.MakeBucket(bucket, getACLTypeString(aclType))
+	switch iodine.ToError(err).(type) {
+	case nil:
+		// Make sure to add Location information here only for bucket
+		w.Header().Set("Location", "/"+bucket)
+		writeSuccessResponse(w, acceptsContentType)
+	case donut.TooManyBuckets:
+		writeErrorResponse(w, req, TooManyBuckets, acceptsContentType, req.URL.Path)
+	case donut.BucketNameInvalid:
+		writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
+	case donut.BucketExists:
+		writeErrorResponse(w, req, BucketAlreadyExists, acceptsContentType, req.URL.Path)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+	}
 }
 
 // PutBucketACLHandler - PUT Bucket ACL
 // ----------
 // This implementation of the PUT operation modifies the bucketACL for authenticated request
 func (api Minio) PutBucketACLHandler(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)
 
 	// read from 'x-amz-acl'
 	aclType := getACLType(req)
@@ -185,7 +285,19 @@ func (api Minio) PutBucketACLHandler(w http.ResponseWriter, req *http.Request) {
 
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
-	log.Println(bucket)
+
+	err := api.Donut.SetBucketMetadata(bucket, map[string]string{"acl": getACLTypeString(aclType)})
+	switch iodine.ToError(err).(type) {
+	case nil:
+		writeSuccessResponse(w, acceptsContentType)
+	case donut.BucketNameInvalid:
+		writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
+	case donut.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)
+	}
 }
 
 // HeadBucketHandler - HEAD Bucket
@@ -195,19 +307,33 @@ func (api Minio) PutBucketACLHandler(w http.ResponseWriter, req *http.Request) {
 // have permission to access it. Otherwise, the operation might
 // return responses such as 404 Not Found and 403 Forbidden.
 func (api Minio) HeadBucketHandler(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)
 
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
-	log.Println(bucket)
+
+	_, err := api.Donut.GetBucketMetadata(bucket)
+	switch iodine.ToError(err).(type) {
+	case nil:
+		writeSuccessResponse(w, acceptsContentType)
+	case donut.BucketNotFound:
+		error := getErrorCode(NoSuchBucket)
+		w.WriteHeader(error.HTTPStatusCode)
+	case donut.BucketNameInvalid:
+		error := getErrorCode(InvalidBucketName)
+		w.WriteHeader(error.HTTPStatusCode)
+	default:
+		log.Error.Println(iodine.New(err, nil))
+		error := getErrorCode(InternalError)
+		w.WriteHeader(error.HTTPStatusCode)
+	}
 }

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