Migrate from iodine to probe

pkg/server/api/bucket-handlers.go

@@ -21,7 +21,7 @@ import (
 
 	"github.com/gorilla/mux"
 	"github.com/minio/minio/pkg/donut"
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/utils/log"
 )
 
@@ -30,18 +30,7 @@ func (api Minio) isValidOp(w http.ResponseWriter, req *http.Request, acceptsCont
 	bucket := vars["bucket"]
 
 	bucketMetadata, err := api.Donut.GetBucketMetadata(bucket, nil)
-	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 == nil {
 		if _, err := StripAccessKeyID(req.Header.Get("Authorization")); err != nil {
 			if bucketMetadata.ACL.IsPrivate() {
 				return true
@@ -56,13 +45,20 @@ func (api Minio) isValidOp(w http.ResponseWriter, req *http.Request, acceptsCont
 				//return false
 			}
 		}
-	default:
-		{
-			log.Error.Println(iodine.New(err, nil))
-			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
-		}
+		return true
+	}
+	switch err.ToError().(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
+	default:
+		log.Error.Println(err.Trace())
+		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+		return false
 	}
-	return true
 }
 
 // ListMultipartUploadsHandler - GET Bucket (List Multipart uploads)
@@ -102,7 +98,7 @@ func (api Minio) ListMultipartUploadsHandler(w http.ResponseWriter, req *http.Re
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -111,23 +107,23 @@ func (api Minio) ListMultipartUploadsHandler(w http.ResponseWriter, req *http.Re
 	}
 
 	resources, err := api.Donut.ListMultipartUploads(bucket, resources, signature)
-	switch iodine.ToError(err).(type) {
-	case nil: // success
-		{
-			// generate response
-			response := generateListMultipartUploadsResponse(bucket, resources)
-			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
-			// write headers
-			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
-			// write body
-			w.Write(encodedSuccessResponse)
-		}
+	if err == nil {
+		// generate response
+		response := generateListMultipartUploadsResponse(bucket, resources)
+		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+		// write headers
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+		// write body
+		w.Write(encodedSuccessResponse)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.BucketNotFound:
 		writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -173,7 +169,7 @@ func (api Minio) ListObjectsHandler(w http.ResponseWriter, req *http.Request) {
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -182,8 +178,7 @@ func (api Minio) ListObjectsHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	objects, resources, err := api.Donut.ListObjects(bucket, resources, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		// generate response
 		response := generateListObjectsResponse(bucket, objects, resources)
 		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
@@ -191,6 +186,9 @@ func (api Minio) ListObjectsHandler(w http.ResponseWriter, req *http.Request) {
 		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
 		// write body
 		w.Write(encodedSuccessResponse)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.BucketNameInvalid:
@@ -202,7 +200,7 @@ func (api Minio) ListObjectsHandler(w http.ResponseWriter, req *http.Request) {
 	case donut.ObjectNameInvalid:
 		writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -232,7 +230,7 @@ func (api Minio) ListBucketsHandler(w http.ResponseWriter, req *http.Request) {
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -241,8 +239,7 @@ func (api Minio) ListBucketsHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	buckets, err := api.Donut.ListBuckets(signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		// generate response
 		response := generateListBucketsResponse(buckets)
 		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
@@ -250,10 +247,13 @@ func (api Minio) ListBucketsHandler(w http.ResponseWriter, req *http.Request) {
 		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
 		// write response
 		w.Write(encodedSuccessResponse)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -296,7 +296,7 @@ func (api Minio) PutBucketHandler(w http.ResponseWriter, req *http.Request) {
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -315,11 +315,13 @@ func (api Minio) PutBucketHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	err := api.Donut.MakeBucket(bucket, getACLTypeString(aclType), req.Body, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		// Make sure to add Location information here only for bucket
 		w.Header().Set("Location", "/"+bucket)
 		writeSuccessResponse(w, acceptsContentType)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.TooManyBuckets:
@@ -329,7 +331,7 @@ func (api Minio) PutBucketHandler(w http.ResponseWriter, req *http.Request) {
 	case donut.BucketExists:
 		writeErrorResponse(w, req, BucketAlreadyExists, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -362,7 +364,7 @@ func (api Minio) PutBucketACLHandler(w http.ResponseWriter, req *http.Request) {
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -371,9 +373,11 @@ func (api Minio) PutBucketACLHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	err := api.Donut.SetBucketMetadata(bucket, map[string]string{"acl": getACLTypeString(aclType)}, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		writeSuccessResponse(w, acceptsContentType)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.BucketNameInvalid:
@@ -381,7 +385,7 @@ func (api Minio) PutBucketACLHandler(w http.ResponseWriter, req *http.Request) {
 	case donut.BucketNotFound:
 		writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -410,7 +414,7 @@ func (api Minio) HeadBucketHandler(w http.ResponseWriter, req *http.Request) {
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -419,9 +423,11 @@ func (api Minio) HeadBucketHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	_, err := api.Donut.GetBucketMetadata(bucket, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		writeSuccessResponse(w, acceptsContentType)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.BucketNotFound:
@@ -429,7 +435,7 @@ func (api Minio) HeadBucketHandler(w http.ResponseWriter, req *http.Request) {
 	case donut.BucketNameInvalid:
 		writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }

pkg/server/api/logging-handlers.go

@@ -24,7 +24,7 @@ import (
 	"os"
 	"time"
 
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/utils/log"
 )
 
@@ -99,12 +99,12 @@ func fileLogger(filename string) (chan<- []byte, error) {
 	ch := make(chan []byte)
 	file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
 	if err != nil {
-		return nil, iodine.New(err, map[string]string{"logfile": filename})
+		return nil, probe.New(err)
 	}
 	go func() {
 		for message := range ch {
 			if _, err := io.Copy(file, bytes.NewBuffer(message)); err != nil {
-				log.Errorln(iodine.New(err, nil))
+				log.Errorln(probe.New(err))
 			}
 		}
 	}()

pkg/server/api/object-handlers.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/gorilla/mux"
 	"github.com/minio/minio/pkg/donut"
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/utils/log"
 )
 
@@ -57,7 +57,7 @@ func (api Minio) GetObjectHandler(w http.ResponseWriter, req *http.Request) {
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -66,21 +66,21 @@ func (api Minio) GetObjectHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	metadata, err := api.Donut.GetObjectMetadata(bucket, object, signature)
-	switch iodine.ToError(err).(type) {
-	case nil: // success
-		{
-			httpRange, err := getRequestedRange(req.Header.Get("Range"), metadata.Size)
-			if err != nil {
-				writeErrorResponse(w, req, InvalidRange, acceptsContentType, req.URL.Path)
-				return
-			}
-			setObjectHeaders(w, metadata, httpRange)
-			if _, err := api.Donut.GetObject(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))
-				return
-			}
+	if err == nil {
+		httpRange, err := getRequestedRange(req.Header.Get("Range"), metadata.Size)
+		if err != nil {
+			writeErrorResponse(w, req, InvalidRange, acceptsContentType, req.URL.Path)
+			return
 		}
+		setObjectHeaders(w, metadata, httpRange)
+		if _, err := api.Donut.GetObject(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(err.Trace())
+			return
+		}
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.BucketNameInvalid:
@@ -92,7 +92,7 @@ func (api Minio) GetObjectHandler(w http.ResponseWriter, req *http.Request) {
 	case donut.ObjectNameInvalid:
 		writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -123,7 +123,7 @@ func (api Minio) HeadObjectHandler(w http.ResponseWriter, req *http.Request) {
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -132,10 +132,12 @@ func (api Minio) HeadObjectHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	metadata, err := api.Donut.GetObjectMetadata(bucket, object, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		setObjectHeaders(w, metadata, nil)
 		w.WriteHeader(http.StatusOK)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.BucketNameInvalid:
@@ -147,7 +149,7 @@ func (api Minio) HeadObjectHandler(w http.ResponseWriter, req *http.Request) {
 	case donut.ObjectNameInvalid:
 		writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -202,16 +204,20 @@ func (api Minio) PutObjectHandler(w http.ResponseWriter, req *http.Request) {
 	//      writeErrorResponse(w, req, EntityTooSmall, acceptsContentType, req.URL.Path)
 	//	return
 	// }
-	sizeInt64, err := strconv.ParseInt(size, 10, 64)
-	if err != nil {
-		writeErrorResponse(w, req, InvalidRequest, acceptsContentType, req.URL.Path)
-		return
+	var sizeInt64 int64
+	{
+		var err error
+		sizeInt64, err = strconv.ParseInt(size, 10, 64)
+		if err != nil {
+			writeErrorResponse(w, req, InvalidRequest, acceptsContentType, req.URL.Path)
+			return
+		}
 	}
 
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -220,10 +226,12 @@ func (api Minio) PutObjectHandler(w http.ResponseWriter, req *http.Request) {
 	}
 
 	metadata, err := api.Donut.CreateObject(bucket, object, md5, sizeInt64, req.Body, nil, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		w.Header().Set("ETag", metadata.MD5Sum)
 		writeSuccessResponse(w, acceptsContentType)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.BucketNotFound:
 		writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
 	case donut.BucketNameInvalid:
@@ -243,7 +251,7 @@ func (api Minio) PutObjectHandler(w http.ResponseWriter, req *http.Request) {
 	case donut.InvalidDigest:
 		writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -279,7 +287,7 @@ func (api Minio) NewMultipartUploadHandler(w http.ResponseWriter, req *http.Requ
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -288,22 +296,22 @@ func (api Minio) NewMultipartUploadHandler(w http.ResponseWriter, req *http.Requ
 	}
 
 	uploadID, err := api.Donut.NewMultipartUpload(bucket, object, req.Header.Get("Content-Type"), signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
-		{
-			response := generateInitiateMultipartUploadResponse(bucket, object, uploadID)
-			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
-			// write headers
-			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
-			// write body
-			w.Write(encodedSuccessResponse)
-		}
+	if err == nil {
+		response := generateInitiateMultipartUploadResponse(bucket, object, uploadID)
+		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+		// write headers
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+		// write body
+		w.Write(encodedSuccessResponse)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.ObjectExists:
 		writeErrorResponse(w, req, MethodNotAllowed, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -344,10 +352,14 @@ func (api Minio) PutObjectPartHandler(w http.ResponseWriter, req *http.Request)
 		return
 	}
 
-	sizeInt64, err := strconv.ParseInt(size, 10, 64)
-	if err != nil {
-		writeErrorResponse(w, req, InvalidRequest, acceptsContentType, req.URL.Path)
-		return
+	var sizeInt64 int64
+	{
+		var err error
+		sizeInt64, err = strconv.ParseInt(size, 10, 64)
+		if err != nil {
+			writeErrorResponse(w, req, InvalidRequest, acceptsContentType, req.URL.Path)
+			return
+		}
 	}
 
 	vars := mux.Vars(req)
@@ -357,15 +369,19 @@ func (api Minio) PutObjectPartHandler(w http.ResponseWriter, req *http.Request)
 	uploadID := req.URL.Query().Get("uploadId")
 	partIDString := req.URL.Query().Get("partNumber")
 
-	partID, err := strconv.Atoi(partIDString)
-	if err != nil {
-		writeErrorResponse(w, req, InvalidPart, acceptsContentType, req.URL.Path)
+	var partID int
+	{
+		var err error
+		partID, err = strconv.Atoi(partIDString)
+		if err != nil {
+			writeErrorResponse(w, req, InvalidPart, acceptsContentType, req.URL.Path)
+		}
 	}
 
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -374,10 +390,12 @@ func (api Minio) PutObjectPartHandler(w http.ResponseWriter, req *http.Request)
 	}
 
 	calculatedMD5, err := api.Donut.CreateObjectPart(bucket, object, uploadID, partID, "", md5, sizeInt64, req.Body, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		w.Header().Set("ETag", calculatedMD5)
 		writeSuccessResponse(w, acceptsContentType)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.InvalidUploadID:
 		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
 	case donut.ObjectExists:
@@ -393,7 +411,7 @@ func (api Minio) PutObjectPartHandler(w http.ResponseWriter, req *http.Request)
 	case donut.InvalidDigest:
 		writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -423,7 +441,7 @@ func (api Minio) AbortMultipartUploadHandler(w http.ResponseWriter, req *http.Re
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -432,16 +450,18 @@ func (api Minio) AbortMultipartUploadHandler(w http.ResponseWriter, req *http.Re
 	}
 
 	err := api.Donut.AbortMultipartUpload(bucket, object, objectResourcesMetadata.UploadID, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
+	if err == nil {
 		setCommonHeaders(w, getContentTypeString(acceptsContentType), 0)
 		w.WriteHeader(http.StatusNoContent)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.InvalidUploadID:
 		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -482,7 +502,7 @@ func (api Minio) ListObjectPartsHandler(w http.ResponseWriter, req *http.Request
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -491,22 +511,22 @@ func (api Minio) ListObjectPartsHandler(w http.ResponseWriter, req *http.Request
 	}
 
 	objectResourcesMetadata, err := api.Donut.ListObjectParts(bucket, object, objectResourcesMetadata, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
-		{
-			response := generateListPartsResponse(objectResourcesMetadata)
-			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
-			// write headers
-			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
-			// write body
-			w.Write(encodedSuccessResponse)
-		}
+	if err == nil {
+		response := generateListPartsResponse(objectResourcesMetadata)
+		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+		// write headers
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+		// write body
+		w.Write(encodedSuccessResponse)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.SignatureDoesNotMatch:
 		writeErrorResponse(w, req, SignatureDoesNotMatch, acceptsContentType, req.URL.Path)
 	case donut.InvalidUploadID:
 		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }
@@ -536,7 +556,7 @@ func (api Minio) CompleteMultipartUploadHandler(w http.ResponseWriter, req *http
 	var signature *donut.Signature
 	if _, ok := req.Header["Authorization"]; ok {
 		// Init signature V4 verification
-		var err error
+		var err *probe.Error
 		signature, err = InitSignatureV4(req)
 		if err != nil {
 			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
@@ -544,16 +564,16 @@ func (api Minio) CompleteMultipartUploadHandler(w http.ResponseWriter, req *http
 		}
 	}
 	metadata, err := api.Donut.CompleteMultipartUpload(bucket, object, objectResourcesMetadata.UploadID, req.Body, signature)
-	switch iodine.ToError(err).(type) {
-	case nil:
-		{
-			response := generateCompleteMultpartUploadResponse(bucket, object, "", metadata.MD5Sum)
-			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
-			// write headers
-			setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
-			// write body
-			w.Write(encodedSuccessResponse)
-		}
+	if err == nil {
+		response := generateCompleteMultpartUploadResponse(bucket, object, "", metadata.MD5Sum)
+		encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
+		// write headers
+		setCommonHeaders(w, getContentTypeString(acceptsContentType), len(encodedSuccessResponse))
+		// write body
+		w.Write(encodedSuccessResponse)
+		return
+	}
+	switch err.ToError().(type) {
 	case donut.InvalidUploadID:
 		writeErrorResponse(w, req, NoSuchUpload, acceptsContentType, req.URL.Path)
 	case donut.InvalidPart:
@@ -569,7 +589,7 @@ func (api Minio) CompleteMultipartUploadHandler(w http.ResponseWriter, req *http
 	case donut.MalformedXML:
 		writeErrorResponse(w, req, MalformedXML, acceptsContentType, req.URL.Path)
 	default:
-		log.Error.Println(iodine.New(err, nil))
+		log.Error.Println(err.Trace())
 		writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
 	}
 }

pkg/server/api/range.go

@@ -23,7 +23,7 @@ import (
 	"strings"
 
 	"github.com/minio/minio/pkg/donut"
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 )
 
 const (
@@ -51,7 +51,7 @@ func getRequestedRange(hrange string, size int64) (*httpRange, error) {
 	if hrange != "" {
 		err := r.parseRange(hrange)
 		if err != nil {
-			return nil, iodine.New(err, nil)
+			return nil, probe.New(err)
 		}
 	}
 	return r, nil
@@ -60,7 +60,7 @@ func getRequestedRange(hrange string, size int64) (*httpRange, error) {
 func (r *httpRange) parse(ra string) error {
 	i := strings.Index(ra, "-")
 	if i < 0 {
-		return iodine.New(donut.InvalidRange{}, nil)
+		return probe.New(donut.InvalidRange{})
 	}
 	start, end := strings.TrimSpace(ra[:i]), strings.TrimSpace(ra[i+1:])
 	if start == "" {
@@ -68,7 +68,7 @@ func (r *httpRange) parse(ra string) error {
 		// range start relative to the end of the file.
 		i, err := strconv.ParseInt(end, 10, 64)
 		if err != nil {
-			return iodine.New(donut.InvalidRange{}, nil)
+			return probe.New(donut.InvalidRange{})
 		}
 		if i > r.size {
 			i = r.size
@@ -78,7 +78,7 @@ func (r *httpRange) parse(ra string) error {
 	} else {
 		i, err := strconv.ParseInt(start, 10, 64)
 		if err != nil || i > r.size || i < 0 {
-			return iodine.New(donut.InvalidRange{}, nil)
+			return probe.New(donut.InvalidRange{})
 		}
 		r.start = i
 		if end == "" {
@@ -87,7 +87,7 @@ func (r *httpRange) parse(ra string) error {
 		} else {
 			i, err := strconv.ParseInt(end, 10, 64)
 			if err != nil || r.start > i {
-				return iodine.New(donut.InvalidRange{}, nil)
+				return probe.New(donut.InvalidRange{})
 			}
 			if i >= r.size {
 				i = r.size - 1
@@ -101,24 +101,24 @@ func (r *httpRange) parse(ra string) error {
 // parseRange parses a Range header string as per RFC 2616.
 func (r *httpRange) parseRange(s string) error {
 	if s == "" {
-		return iodine.New(errors.New("header not present"), nil)
+		return probe.New(errors.New("header not present"))
 	}
 	if !strings.HasPrefix(s, b) {
-		return iodine.New(donut.InvalidRange{}, nil)
+		return probe.New(donut.InvalidRange{})
 	}
 
 	ras := strings.Split(s[len(b):], ",")
 	if len(ras) == 0 {
-		return iodine.New(errors.New("invalid request"), nil)
+		return probe.New(errors.New("invalid request"))
 	}
 	// Just pick the first one and ignore the rest, we only support one range per object
 	if len(ras) > 1 {
-		return iodine.New(errors.New("multiple ranges specified"), nil)
+		return probe.New(errors.New("multiple ranges specified"))
 	}
 
 	ra := strings.TrimSpace(ras[0])
 	if ra == "" {
-		return iodine.New(donut.InvalidRange{}, nil)
+		return probe.New(donut.InvalidRange{})
 	}
 	return r.parse(ra)
 }

pkg/server/api/signature.go

@@ -23,7 +23,7 @@ import (
 
 	"github.com/minio/minio/pkg/auth"
 	"github.com/minio/minio/pkg/donut"
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 )
 
 const (
@@ -64,16 +64,23 @@ func StripAccessKeyID(ah string) (string, error) {
 }
 
 // InitSignatureV4 initializing signature verification
-func InitSignatureV4(req *http.Request) (*donut.Signature, error) {
+func InitSignatureV4(req *http.Request) (*donut.Signature, *probe.Error) {
 	// strip auth from authorization header
 	ah := req.Header.Get("Authorization")
-	accessKeyID, err := StripAccessKeyID(ah)
-	if err != nil {
-		return nil, iodine.New(err, nil)
+	var accessKeyID string
+	{
+		var err error
+		accessKeyID, err = StripAccessKeyID(ah)
+		if err != nil {
+			return nil, probe.New(err)
+		}
 	}
 	authConfig, err := auth.LoadConfig()
+	if err != nil {
+		return nil, err.Trace()
+	}
 	if _, ok := authConfig.Users[accessKeyID]; !ok {
-		return nil, errors.New("Access ID not found")
+		return nil, probe.New(errors.New("AccessID not found"))
 	}
 	signature := &donut.Signature{
 		AccessKeyID:     authConfig.Users[accessKeyID].AccessKeyID,

pkg/server/minhttp/http.go

@@ -32,7 +32,7 @@ import (
 	"time"
 
 	"github.com/facebookgo/httpdown"
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 )
 
 // An app contains one or more servers and their associated configuration.
@@ -45,11 +45,11 @@ type app struct {
 }
 
 // listen initailize listeners
-func (a *app) listen() error {
+func (a *app) listen() *probe.Error {
 	for _, s := range a.servers {
 		l, err := a.net.Listen("tcp", s.Addr)
 		if err != nil {
-			return iodine.New(err, nil)
+			return probe.New(err)
 		}
 		if s.TLSConfig != nil {
 			l = tls.NewListener(l, s.TLSConfig)
@@ -79,7 +79,7 @@ func (a *app) wait() {
 		go func(s httpdown.Server) {
 			defer wg.Done()
 			if err := s.Wait(); err != nil {
-				a.errors <- iodine.New(err, nil)
+				a.errors <- probe.New(err)
 			}
 		}(s)
 	}
@@ -101,7 +101,7 @@ func (a *app) trapSignal(wg *sync.WaitGroup) {
 				go func(s httpdown.Server) {
 					defer wg.Done()
 					if err := s.Stop(); err != nil {
-						a.errors <- iodine.New(err, nil)
+						a.errors <- probe.New(err)
 					}
 				}(s)
 			}
@@ -112,7 +112,7 @@ func (a *app) trapSignal(wg *sync.WaitGroup) {
 			// we only return here if there's an error, otherwise the new process
 			// will send us a TERM when it's ready to trigger the actual shutdown.
 			if _, err := a.net.StartProcess(); err != nil {
-				a.errors <- iodine.New(err, nil)
+				a.errors <- probe.New(err)
 			}
 		}
 	}
@@ -120,7 +120,7 @@ func (a *app) trapSignal(wg *sync.WaitGroup) {
 
 // ListenAndServe will serve the given http.Servers and will monitor for signals
 // allowing for graceful termination (SIGTERM) or restart (SIGUSR2/SIGHUP).
-func ListenAndServe(servers ...*http.Server) error {
+func ListenAndServe(servers ...*http.Server) *probe.Error {
 	// get parent process id
 	ppid := os.Getppid()
 
@@ -134,7 +134,7 @@ func ListenAndServe(servers ...*http.Server) error {
 
 	// Acquire Listeners
 	if err := a.listen(); err != nil {
-		return iodine.New(err, nil)
+		return err.Trace()
 	}
 
 	// Start serving.
@@ -143,7 +143,7 @@ func ListenAndServe(servers ...*http.Server) error {
 	// Close the parent if we inherited and it wasn't init that started us.
 	if os.Getenv("LISTEN_FDS") != "" && ppid != 1 {
 		if err := syscall.Kill(ppid, syscall.SIGTERM); err != nil {
-			return iodine.New(err, nil)
+			return probe.New(err)
 		}
 	}
 
@@ -160,14 +160,14 @@ func ListenAndServe(servers ...*http.Server) error {
 		if err == nil {
 			panic("unexpected nil error")
 		}
-		return iodine.New(err, nil)
+		return probe.New(err)
 	case <-waitdone:
 		return nil
 	}
 }
 
 // ListenAndServeLimited is similar to ListenAndServe but ratelimited with connLimit value
-func ListenAndServeLimited(connLimit int, servers ...*http.Server) error {
+func ListenAndServeLimited(connLimit int, servers ...*http.Server) *probe.Error {
 	// get parent process id
 	ppid := os.Getppid()
 
@@ -181,7 +181,7 @@ func ListenAndServeLimited(connLimit int, servers ...*http.Server) error {
 
 	// Acquire Listeners
 	if err := a.listen(); err != nil {
-		return iodine.New(err, nil)
+		return err.Trace()
 	}
 
 	// Start serving.
@@ -190,7 +190,7 @@ func ListenAndServeLimited(connLimit int, servers ...*http.Server) error {
 	// Close the parent if we inherited and it wasn't init that started us.
 	if os.Getenv("LISTEN_FDS") != "" && ppid != 1 {
 		if err := syscall.Kill(ppid, syscall.SIGTERM); err != nil {
-			return iodine.New(err, nil)
+			return probe.New(err)
 		}
 	}
 
@@ -207,7 +207,7 @@ func ListenAndServeLimited(connLimit int, servers ...*http.Server) error {
 		if err == nil {
 			panic("unexpected nil error")
 		}
-		return iodine.New(err, nil)
+		return probe.New(err)
 	case <-waitdone:
 		return nil
 	}

pkg/server/minhttp/listen.go

@@ -20,8 +20,6 @@ import (
 	"net"
 	"os"
 	"sync"
-
-	"github.com/minio/minio/pkg/iodine"
 )
 
 // rateLimitedListener returns a Listener that accepts at most n simultaneous
@@ -53,7 +51,7 @@ func (l *rateLimitListener) Accept() (net.Conn, error) {
 	c, err := l.Listener.Accept()
 	if err != nil {
 		l.release()
-		return nil, iodine.New(err, nil)
+		return nil, err
 	}
 	return &rateLimitListenerConn{Conn: c, release: l.release}, nil
 }
@@ -67,5 +65,5 @@ type rateLimitListenerConn struct {
 func (l *rateLimitListenerConn) Close() error {
 	err := l.Conn.Close()
 	l.releaseOnce.Do(l.release)
-	return iodine.New(err, nil)
+	return err
 }

pkg/server/minhttp/net.go

@@ -25,7 +25,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 )
 
 // This package is a fork https://github.com/facebookgo/grace
@@ -71,8 +71,8 @@ type fileListener interface {
 }
 
 // getInheritedListeners - look for LISTEN_FDS in environment variables and populate listeners accordingly
-func (n *minNet) getInheritedListeners() error {
-	var retErr error
+func (n *minNet) getInheritedListeners() *probe.Error {
+	var retErr *probe.Error
 	n.inheritOnce.Do(func() {
 		n.mutex.Lock()
 		defer n.mutex.Unlock()
@@ -82,7 +82,7 @@ func (n *minNet) getInheritedListeners() error {
 		}
 		count, err := strconv.Atoi(countStr)
 		if err != nil {
-			retErr = fmt.Errorf("found invalid count value: %s=%s", envCountKey, countStr)
+			retErr = probe.New(fmt.Errorf("found invalid count value: %s=%s", envCountKey, countStr))
 			return
 		}
 
@@ -92,37 +92,40 @@ func (n *minNet) getInheritedListeners() error {
 			l, err := net.FileListener(file)
 			if err != nil {
 				file.Close()
-				retErr = iodine.New(fmt.Errorf("error inheriting socket fd %d: %s", i, err), nil)
+				retErr = probe.New(err)
 				return
 			}
 			if err := file.Close(); err != nil {
-				retErr = iodine.New(fmt.Errorf("error closing inherited socket fd %d: %s", i, err), nil)
+				retErr = probe.New(err)
 				return
 			}
 			n.inheritedListeners = append(n.inheritedListeners, l)
 		}
 	})
-	return iodine.New(retErr, nil)
+	if retErr != nil {
+		return probe.New(retErr)
+	}
+	return nil
 }
 
 // Listen announces on the local network address laddr. The network net must be
 // a stream-oriented network: "tcp", "tcp4", "tcp6", "unix" or "unixpacket". It
 // returns an inherited net.Listener for the matching network and address, or
 // creates a new one using net.Listen()
-func (n *minNet) Listen(nett, laddr string) (net.Listener, error) {
+func (n *minNet) Listen(nett, laddr string) (net.Listener, *probe.Error) {
 	switch nett {
 	default:
-		return nil, net.UnknownNetworkError(nett)
+		return nil, probe.New(net.UnknownNetworkError(nett))
 	case "tcp", "tcp4", "tcp6":
 		addr, err := net.ResolveTCPAddr(nett, laddr)
 		if err != nil {
-			return nil, iodine.New(err, nil)
+			return nil, probe.New(err)
 		}
 		return n.ListenTCP(nett, addr)
 	case "unix", "unixpacket":
 		addr, err := net.ResolveUnixAddr(nett, laddr)
 		if err != nil {
-			return nil, iodine.New(err, nil)
+			return nil, probe.New(err)
 		}
 		return n.ListenUnix(nett, addr)
 	}
@@ -131,10 +134,9 @@ func (n *minNet) Listen(nett, laddr string) (net.Listener, error) {
 // ListenTCP announces on the local network address laddr. The network net must
 // be: "tcp", "tcp4" or "tcp6". It returns an inherited net.Listener for the
 // matching network and address, or creates a new one using net.ListenTCP.
-func (n *minNet) ListenTCP(nett string, laddr *net.TCPAddr) (net.Listener, error) {
-	var err error
+func (n *minNet) ListenTCP(nett string, laddr *net.TCPAddr) (net.Listener, *probe.Error) {
 	if err := n.getInheritedListeners(); err != nil {
-		return nil, iodine.New(err, nil)
+		return nil, err.Trace()
 	}
 
 	n.mutex.Lock()
@@ -153,11 +155,10 @@ func (n *minNet) ListenTCP(nett string, laddr *net.TCPAddr) (net.Listener, error
 		}
 	}
 
-	var l net.Listener
 	// make a fresh listener
-	l, err = net.ListenTCP(nett, laddr)
+	l, err := net.ListenTCP(nett, laddr)
 	if err != nil {
-		return nil, iodine.New(err, nil)
+		return nil, probe.New(err)
 	}
 	n.activeListeners = append(n.activeListeners, rateLimitedListener(l, n.connLimit))
 	return l, nil
@@ -166,10 +167,9 @@ func (n *minNet) ListenTCP(nett string, laddr *net.TCPAddr) (net.Listener, error
 // ListenUnix announces on the local network address laddr. The network net
 // must be a: "unix" or "unixpacket". It returns an inherited net.Listener for
 // the matching network and address, or creates a new one using net.ListenUnix.
-func (n *minNet) ListenUnix(nett string, laddr *net.UnixAddr) (net.Listener, error) {
-	var err error
+func (n *minNet) ListenUnix(nett string, laddr *net.UnixAddr) (net.Listener, *probe.Error) {
 	if err := n.getInheritedListeners(); err != nil {
-		return nil, iodine.New(err, nil)
+		return nil, err.Trace()
 	}
 
 	n.mutex.Lock()
@@ -188,23 +188,22 @@ func (n *minNet) ListenUnix(nett string, laddr *net.UnixAddr) (net.Listener, err
 		}
 	}
 
-	var l net.Listener
 	// make a fresh listener
-	l, err = net.ListenUnix(nett, laddr)
+	l, err := net.ListenUnix(nett, laddr)
 	if err != nil {
-		return nil, iodine.New(err, nil)
+		return nil, probe.New(err)
 	}
 	n.activeListeners = append(n.activeListeners, rateLimitedListener(l, n.connLimit))
 	return l, nil
 }
 
 // activeListeners returns a snapshot copy of the active listeners.
-func (n *minNet) getActiveListeners() ([]net.Listener, error) {
+func (n *minNet) getActiveListeners() []net.Listener {
 	n.mutex.Lock()
 	defer n.mutex.Unlock()
 	ls := make([]net.Listener, len(n.activeListeners))
 	copy(ls, n.activeListeners)
-	return ls, nil
+	return ls
 }
 
 // IsEqual is synonymous with IP.IsEqual() method, here IsEqual matches net.Addr instead of net.IP
@@ -233,18 +232,15 @@ func (n1 minAddr) IsEqual(n2 net.Addr) bool {
 // arguments as when it was originally started. This allows for a newly
 // deployed binary to be started. It returns the pid of the newly started
 // process when successful.
-func (n *minNet) StartProcess() (int, error) {
-	listeners, err := n.getActiveListeners()
-	if err != nil {
-		return 0, iodine.New(err, nil)
-	}
-
+func (n *minNet) StartProcess() (int, *probe.Error) {
+	listeners := n.getActiveListeners()
 	// Extract the fds from the listeners.
 	files := make([]*os.File, len(listeners))
 	for i, l := range listeners {
+		var err error
 		files[i], err = l.(fileListener).File()
 		if err != nil {
-			return 0, iodine.New(err, nil)
+			return 0, probe.New(err)
 		}
 		defer files[i].Close()
 	}
@@ -253,7 +249,7 @@ func (n *minNet) StartProcess() (int, error) {
 	// the file it points to has been changed we will use the updated symlink.
 	argv0, err := exec.LookPath(os.Args[0])
 	if err != nil {
-		return 0, iodine.New(err, nil)
+		return 0, probe.New(err)
 	}
 
 	// Pass on the environment and replace the old count key with the new one.
@@ -272,7 +268,7 @@ func (n *minNet) StartProcess() (int, error) {
 		Files: allFiles,
 	})
 	if err != nil {
-		return 0, iodine.New(err, nil)
+		return 0, probe.New(err)
 	}
 	return process.Pid, nil
 }

pkg/server/minhttp/net_test.go

@@ -1,78 +0,0 @@
-/*
- * Minio Cloud Storage, (C) 2015 Minio, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * 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.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package minhttp
-
-import (
-	"os"
-	"regexp"
-	"testing"
-
-	"github.com/minio/minio/pkg/iodine"
-	. "gopkg.in/check.v1"
-)
-
-func Test(t *testing.T) { TestingT(t) }
-
-type MySuite struct{}
-
-var _ = Suite(&MySuite{})
-
-func (s *MySuite) TestEmptyCountEnvVariable(c *C) {
-	os.Setenv(envCountKey, "")
-	n := &minNet{}
-	c.Assert(n.getInheritedListeners(), IsNil)
-}
-
-func (s *MySuite) TestZeroCountEnvVariable(c *C) {
-	os.Setenv(envCountKey, "0")
-	n := &minNet{}
-	c.Assert(n.getInheritedListeners(), IsNil)
-}
-
-func (s *MySuite) TestInvalidCountEnvVariable(c *C) {
-	os.Setenv(envCountKey, "a")
-	n := &minNet{}
-	expected := regexp.MustCompile("^found invalid count value: LISTEN_FDS=a$")
-	err := n.getInheritedListeners()
-	c.Assert(err, Not(IsNil))
-	c.Assert(expected.MatchString(iodine.ToError(err).Error()), Equals, true)
-}
-
-func (s *MySuite) TestInheritErrorOnListenTCPWithInvalidCount(c *C) {
-	os.Setenv(envCountKey, "a")
-	n := &minNet{}
-	expected := regexp.MustCompile("^found invalid count value: LISTEN_FDS=a$")
-	_, err := n.Listen("tcp", ":0")
-	c.Assert(err, Not(IsNil))
-	c.Assert(expected.MatchString(iodine.ToError(err).Error()), Equals, true)
-}
-
-func (s *MySuite) TestInvalidNetwork(c *C) {
-	os.Setenv(envCountKey, "")
-	n := &minNet{}
-	_, err := n.Listen("foo", "")
-	c.Assert(err, Not(IsNil))
-	c.Assert(regexp.MustCompile("^unknown network foo$").MatchString(iodine.ToError(err).Error()), Equals, true)
-}
-
-func (s *MySuite) TestInvalidTcpAddr(c *C) {
-	os.Setenv(envCountKey, "")
-	n := &minNet{}
-	_, err := n.Listen("tcp", "abc")
-	c.Assert(err, Not(IsNil))
-	c.Assert(regexp.MustCompile("^missing port in address abc$").MatchString(iodine.ToError(err).Error()), Equals, true)
-}

pkg/server/rpc/auth.go

@@ -20,7 +20,7 @@ import (
 	"net/http"
 
 	"github.com/minio/minio/pkg/auth"
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 )
 
 // AuthService auth service
@@ -32,15 +32,15 @@ type AuthReply struct {
 	SecretAccessKey string `json:"secretaccesskey"`
 }
 
-func getAuth(reply *AuthReply) error {
+func getAuth(reply *AuthReply) *probe.Error {
 	accessID, err := auth.GenerateAccessKeyID()
 	if err != nil {
-		return iodine.New(err, nil)
+		return err.Trace()
 	}
 	reply.AccessKeyID = string(accessID)
 	secretID, err := auth.GenerateSecretAccessKey()
 	if err != nil {
-		return iodine.New(err, nil)
+		return err.Trace()
 	}
 	reply.SecretAccessKey = string(secretID)
 	return nil
@@ -48,5 +48,8 @@ func getAuth(reply *AuthReply) error {
 
 // Get auth keys
 func (s *AuthService) Get(r *http.Request, args *Args, reply *AuthReply) error {
-	return getAuth(reply)
+	if err := getAuth(reply); err != nil {
+		return err
+	}
+	return nil
 }

pkg/server/rpc/donut.go

@@ -20,7 +20,7 @@ import (
 	"net/http"
 
 	"github.com/minio/minio/pkg/donut"
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 )
 
 // DonutService donut service
@@ -40,14 +40,14 @@ type Reply struct {
 	Error   error  `json:"error"`
 }
 
-func setDonut(args *DonutArgs, reply *Reply) error {
+func setDonut(args *DonutArgs, reply *Reply) *probe.Error {
 	conf := &donut.Config{Version: "0.0.1"}
 	conf.DonutName = args.Name
 	conf.MaxSize = args.MaxSize
 	conf.NodeDiskMap = make(map[string][]string)
 	conf.NodeDiskMap[args.Hostname] = args.Disks
 	if err := donut.SaveConfig(conf); err != nil {
-		return iodine.New(err, nil)
+		return err.Trace()
 	}
 	reply.Message = "success"
 	reply.Error = nil

pkg/server/rpc/sysinfo.go

@@ -21,7 +21,7 @@ import (
 	"os"
 	"runtime"
 
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 )
 
 // SysInfoService -
@@ -45,7 +45,7 @@ type MemStatsReply struct {
 	runtime.MemStats `json:"memstats"`
 }
 
-func setSysInfoReply(sis *SysInfoReply) error {
+func setSysInfoReply(sis *SysInfoReply) *probe.Error {
 	sis.SysARCH = runtime.GOARCH
 	sis.SysOS = runtime.GOOS
 	sis.SysCPUS = runtime.NumCPU()
@@ -55,12 +55,12 @@ func setSysInfoReply(sis *SysInfoReply) error {
 	var err error
 	sis.Hostname, err = os.Hostname()
 	if err != nil {
-		return iodine.New(err, nil)
+		return probe.New(err)
 	}
 	return nil
 }
 
-func setMemStatsReply(sis *MemStatsReply) error {
+func setMemStatsReply(sis *MemStatsReply) *probe.Error {
 	var memStats runtime.MemStats
 	runtime.ReadMemStats(&memStats)
 	sis.MemStats = memStats
@@ -69,10 +69,16 @@ func setMemStatsReply(sis *MemStatsReply) error {
 
 // Get method
 func (s *SysInfoService) Get(r *http.Request, args *Args, reply *SysInfoReply) error {
-	return setSysInfoReply(reply)
+	if err := setSysInfoReply(reply); err != nil {
+		return err
+	}
+	return nil
 }
 
 // Get method
 func (s *MemStatsService) Get(r *http.Request, args *Args, reply *MemStatsReply) error {
-	return setMemStatsReply(reply)
+	if err := setMemStatsReply(reply); err != nil {
+		return err
+	}
+	return nil
 }

pkg/server/rpc_test.go

@@ -56,8 +56,7 @@ func (s *MyRPCSuite) TestMemStats(c *C) {
 	c.Assert(resp.StatusCode, Equals, http.StatusOK)
 
 	var reply rpc.MemStatsReply
-	err = jsonrpc.DecodeClientResponse(resp.Body, &reply)
-	c.Assert(err, IsNil)
+	c.Assert(jsonrpc.DecodeClientResponse(resp.Body, &reply), IsNil)
 	resp.Body.Close()
 	c.Assert(reply, Not(DeepEquals), rpc.MemStatsReply{})
 }
@@ -75,8 +74,7 @@ func (s *MyRPCSuite) TestSysInfo(c *C) {
 	c.Assert(resp.StatusCode, Equals, http.StatusOK)
 
 	var reply rpc.SysInfoReply
-	err = jsonrpc.DecodeClientResponse(resp.Body, &reply)
-	c.Assert(err, IsNil)
+	c.Assert(jsonrpc.DecodeClientResponse(resp.Body, &reply), IsNil)
 	resp.Body.Close()
 	c.Assert(reply, Not(DeepEquals), rpc.SysInfoReply{})
 }
@@ -94,8 +92,7 @@ func (s *MyRPCSuite) TestAuth(c *C) {
 	c.Assert(resp.StatusCode, Equals, http.StatusOK)
 
 	var reply rpc.AuthReply
-	err = jsonrpc.DecodeClientResponse(resp.Body, &reply)
-	c.Assert(err, IsNil)
+	c.Assert(jsonrpc.DecodeClientResponse(resp.Body, &reply), IsNil)
 	resp.Body.Close()
 	c.Assert(reply, Not(DeepEquals), rpc.AuthReply{})
 	c.Assert(len(reply.AccessKeyID), Equals, 20)

pkg/server/server.go

@@ -24,13 +24,13 @@ import (
 	"os"
 	"strings"
 
-	"github.com/minio/minio/pkg/iodine"
+	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/server/api"
 	"github.com/minio/minio/pkg/server/minhttp"
 )
 
 // getAPI server instance
-func getAPIServer(conf api.Config, apiHandler http.Handler) (*http.Server, error) {
+func getAPIServer(conf api.Config, apiHandler http.Handler) (*http.Server, *probe.Error) {
 	// Minio server config
 	httpServer := &http.Server{
 		Addr:           conf.Address,
@@ -44,13 +44,13 @@ func getAPIServer(conf api.Config, apiHandler http.Handler) (*http.Server, error
 		httpServer.TLSConfig.Certificates = make([]tls.Certificate, 1)
 		httpServer.TLSConfig.Certificates[0], err = tls.LoadX509KeyPair(conf.CertFile, conf.KeyFile)
 		if err != nil {
-			return nil, iodine.New(err, nil)
+			return nil, probe.New(err)
 		}
 	}
 
 	host, port, err := net.SplitHostPort(conf.Address)
 	if err != nil {
-		return nil, iodine.New(err, nil)
+		return nil, probe.New(err)
 	}
 
 	var hosts []string
@@ -60,7 +60,7 @@ func getAPIServer(conf api.Config, apiHandler http.Handler) (*http.Server, error
 	default:
 		addrs, err := net.InterfaceAddrs()
 		if err != nil {
-			return nil, iodine.New(err, nil)
+			return nil, probe.New(err)
 		}
 		for _, addr := range addrs {
 			if addr.Network() == "ip+net" {
@@ -104,18 +104,18 @@ func startTM(a api.Minio) {
 }
 
 // StartServices starts basic services for a server
-func StartServices(conf api.Config) error {
+func StartServices(conf api.Config) *probe.Error {
 	apiHandler, minioAPI := getAPIHandler(conf)
 	apiServer, err := getAPIServer(conf, apiHandler)
 	if err != nil {
-		return iodine.New(err, nil)
+		return err.Trace()
 	}
 	rpcServer := getRPCServer(getRPCHandler())
 	// start ticket master
 	go startTM(minioAPI)
 
 	if err := minhttp.ListenAndServeLimited(conf.RateLimit, apiServer, rpcServer); err != nil {
-		return iodine.New(err, nil)
+		return err.Trace()
 	}
 	return nil
 }