Probe revamped to provide for a new WrappedError struct to wrap probes as error interface

This convenience was necessary to be used for golang library functions like io.Copy and io.Pipe
where we shouldn't be writing proxies and alternatives returning *probe.Error

This change also brings more changes across code base for clear separation regarding where an error
interface should be passed encapsulating *probe.Error and where it should be used as is.

disks.go

@@ -29,27 +29,27 @@ import (
 func isUsable(mountPath string) (bool, *probe.Error) {
 	mntpoint, err := os.Stat(mountPath)
 	if err != nil {
-		return false, probe.New(err)
+		return false, probe.NewError(err)
 	}
 	parent, err := os.Stat("/")
 	if err != nil {
-		return false, probe.New(err)
+		return false, probe.NewError(err)
 	}
 	mntpointSt := mntpoint.Sys().(*syscall.Stat_t)
 	parentSt := parent.Sys().(*syscall.Stat_t)
 
 	if mntpointSt.Dev == parentSt.Dev {
-		return false, probe.New(fmt.Errorf("Not mounted %s", mountPath))
+		return false, probe.NewError(fmt.Errorf("Not mounted %s", mountPath))
 	}
 	testFile, err := ioutil.TempFile(mountPath, "writetest-")
 	if err != nil {
-		return false, probe.New(err)
+		return false, probe.NewError(err)
 	}
 	// close the file, to avoid leaky fd's
 	defer testFile.Close()
 	testFileName := testFile.Name()
 	if err := os.Remove(testFileName); err != nil {
-		return false, probe.New(err)
+		return false, probe.NewError(err)
 	}
 	return true, nil
 }

pkg/auth/auth.go

@@ -32,7 +32,7 @@ func GenerateAccessKeyID() ([]byte, *probe.Error) {
 	alpha := make([]byte, MinioAccessID)
 	_, err := rand.Read(alpha)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	for i := 0; i < MinioAccessID; i++ {
 		alpha[i] = alphaNumericTable[alpha[i]%byte(len(alphaNumericTable))]
@@ -45,7 +45,7 @@ func GenerateSecretAccessKey() ([]byte, *probe.Error) {
 	rb := make([]byte, MinioSecretID)
 	_, err := rand.Read(rb)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	return []byte(base64.StdEncoding.EncodeToString(rb))[:MinioSecretID], nil
 }

pkg/auth/config.go

@@ -44,7 +44,7 @@ func getAuthConfigPath() (string, *probe.Error) {
 	}
 	u, err := user.Current()
 	if err != nil {
-		return "", probe.New(err)
+		return "", probe.NewError(err)
 	}
 	authConfigPath := filepath.Join(u.HomeDir, ".minio", "users.json")
 	return authConfigPath, nil

pkg/controller/client.go

@@ -38,74 +38,70 @@ func GetMemStats(url string) ([]byte, *probe.Error) {
 		Method:  "MemStats.Get",
 		Request: rpc.Args{Request: ""},
 	}
-	req, err := NewRequest(url, op, http.DefaultTransport)
+	req, perr := NewRequest(url, op, http.DefaultTransport)
-	if err != nil {
+	if perr != nil {
-		return nil, err.Trace()
+		return nil, perr.Trace()
 	}
-	resp, err := req.Do()
+	resp, perr := req.Do()
 	defer closeResp(resp)
-	if err != nil {
+	if perr != nil {
-		return nil, err.Trace()
+		return nil, perr.Trace()
 	}
 	var reply rpc.MemStatsReply
 	if err := jsonrpc.DecodeClientResponse(resp.Body, &reply); err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
-	{
+	jsonRespBytes, err := json.MarshalIndent(reply, "", "\t")
-		jsonRespBytes, err := json.MarshalIndent(reply, "", "\t")
+	if err != nil {
-		if err != nil {
+		return nil, probe.NewError(err)
-			return nil, probe.New(err)
-		}
-		return jsonRespBytes, nil
 	}
+	return jsonRespBytes, nil
 }
 
 // GetSysInfo get system status of the server at given url
-func GetSysInfo(url string) ([]byte, error) {
+func GetSysInfo(url string) ([]byte, *probe.Error) {
 	op := RPCOps{
 		Method:  "SysInfo.Get",
 		Request: rpc.Args{Request: ""},
 	}
-	req, err := NewRequest(url, op, http.DefaultTransport)
+	req, perr := NewRequest(url, op, http.DefaultTransport)
-	if err != nil {
+	if perr != nil {
-		return nil, err.Trace()
+		return nil, perr.Trace()
 	}
-	resp, err := req.Do()
+	resp, perr := req.Do()
 	defer closeResp(resp)
-	if err != nil {
+	if perr != nil {
-		return nil, err.Trace()
+		return nil, perr.Trace()
 	}
 	var reply rpc.SysInfoReply
 	if err := jsonrpc.DecodeClientResponse(resp.Body, &reply); err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
-	{
+	jsonRespBytes, err := json.MarshalIndent(reply, "", "\t")
-		jsonRespBytes, err := json.MarshalIndent(reply, "", "\t")
+	if err != nil {
-		if err != nil {
+		return nil, probe.NewError(err)
-			return nil, probe.New(err)
-		}
-		return jsonRespBytes, nil
 	}
+	return jsonRespBytes, nil
 }
 
 // GetAuthKeys get access key id and secret access key
-func GetAuthKeys(url string) ([]byte, error) {
+func GetAuthKeys(url string) ([]byte, *probe.Error) {
 	op := RPCOps{
 		Method:  "Auth.Get",
 		Request: rpc.Args{Request: ""},
 	}
-	req, err := NewRequest(url, op, http.DefaultTransport)
+	req, perr := NewRequest(url, op, http.DefaultTransport)
-	if err != nil {
+	if perr != nil {
-		return nil, err.Trace()
+		return nil, perr.Trace()
 	}
-	resp, err := req.Do()
+	resp, perr := req.Do()
 	defer closeResp(resp)
-	if err != nil {
+	if perr != nil {
-		return nil, err.Trace()
+		return nil, perr.Trace()
 	}
 	var reply rpc.AuthReply
 	if err := jsonrpc.DecodeClientResponse(resp.Body, &reply); err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	authConfig := &auth.Config{}
 	authConfig.Version = "0.0.1"
@@ -118,13 +114,11 @@ func GetAuthKeys(url string) ([]byte, error) {
 	if err := auth.SaveConfig(authConfig); err != nil {
 		return nil, err.Trace()
 	}
-	{
+	jsonRespBytes, err := json.MarshalIndent(reply, "", "\t")
-		jsonRespBytes, err := json.MarshalIndent(reply, "", "\t")
+	if err != nil {
-		if err != nil {
+		return nil, probe.NewError(err)
-			return nil, probe.New(err)
-		}
-		return jsonRespBytes, nil
 	}
+	return jsonRespBytes, nil
 }
 
 // Add more functions here for other RPC messages

pkg/controller/rpc.go

@@ -40,11 +40,11 @@ type RPCRequest struct {
 func NewRequest(url string, op RPCOps, transport http.RoundTripper) (*RPCRequest, *probe.Error) {
 	params, err := json.EncodeClientRequest(op.Method, op.Request)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	req, err := http.NewRequest("POST", url, bytes.NewReader(params))
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	rpcReq := &RPCRequest{}
 	rpcReq.req = req
@@ -60,7 +60,10 @@ func NewRequest(url string, op RPCOps, transport http.RoundTripper) (*RPCRequest
 func (r RPCRequest) Do() (*http.Response, *probe.Error) {
 	resp, err := r.transport.RoundTrip(r.req)
 	if err != nil {
-		return nil, probe.New(err)
+		if werr, ok := probe.ToWrappedError(err); ok {
+			return nil, werr.ToError().Trace()
+		}
+		return nil, probe.NewError(err)
 	}
 	return resp, nil
 }

pkg/donut/bucket.go

@@ -54,7 +54,7 @@ type bucket struct {
 // newBucket - instantiate a new bucket
 func newBucket(bucketName, aclType, donutName string, nodes map[string]node) (bucket, BucketMetadata, *probe.Error) {
 	if strings.TrimSpace(bucketName) == "" || strings.TrimSpace(donutName) == "" {
-		return bucket{}, BucketMetadata{}, probe.New(InvalidArgument{})
+		return bucket{}, BucketMetadata{}, probe.NewError(InvalidArgument{})
 	}
 
 	b := bucket{}
@@ -128,7 +128,7 @@ func (b bucket) getBucketMetadata() (*AllBuckets, *probe.Error) {
 			return metadata, nil
 		}
 	}
-	return nil, probe.New(err)
+	return nil, probe.NewError(err)
 }
 
 // GetObjectMetadata - get metadata for an object
@@ -223,7 +223,7 @@ func (b bucket) ReadObject(objectName string) (reader io.ReadCloser, size int64,
 	}
 	// check if object exists
 	if _, ok := bucketMetadata.Buckets[b.getBucketName()].BucketObjects[objectName]; !ok {
-		return nil, 0, probe.New(ObjectNotFound{Object: objectName})
+		return nil, 0, probe.NewError(ObjectNotFound{Object: objectName})
 	}
 	objMetadata, err := b.readObjectMetadata(normalizeObjectName(objectName))
 	if err != nil {
@@ -239,7 +239,7 @@ func (b bucket) WriteObject(objectName string, objectData io.Reader, size int64,
 	b.lock.Lock()
 	defer b.lock.Unlock()
 	if objectName == "" || objectData == nil {
-		return ObjectMetadata{}, probe.New(InvalidArgument{})
+		return ObjectMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	writers, err := b.getObjectWriters(normalizeObjectName(objectName), "data")
 	if err != nil {
@@ -266,7 +266,7 @@ func (b bucket) WriteObject(objectName string, objectData io.Reader, size int64,
 		totalLength, err := io.Copy(mw, objectData)
 		if err != nil {
 			CleanupWritersOnError(writers)
-			return ObjectMetadata{}, probe.New(err)
+			return ObjectMetadata{}, probe.NewError(err)
 		}
 		objMetadata.Size = totalLength
 	case false:
@@ -306,7 +306,7 @@ func (b bucket) WriteObject(objectName string, objectData io.Reader, size int64,
 			//
 			// Signature mismatch occurred all temp files to be removed and all data purged.
 			CleanupWritersOnError(writers)
-			return ObjectMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return ObjectMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 	objMetadata.MD5Sum = hex.EncodeToString(dataMD5sum)
@@ -337,24 +337,24 @@ func (b bucket) isMD5SumEqual(expectedMD5Sum, actualMD5Sum string) *probe.Error
 	if strings.TrimSpace(expectedMD5Sum) != "" && strings.TrimSpace(actualMD5Sum) != "" {
 		expectedMD5SumBytes, err := hex.DecodeString(expectedMD5Sum)
 		if err != nil {
-			return probe.New(err)
+			return probe.NewError(err)
 		}
 		actualMD5SumBytes, err := hex.DecodeString(actualMD5Sum)
 		if err != nil {
-			return probe.New(err)
+			return probe.NewError(err)
 		}
 		if !bytes.Equal(expectedMD5SumBytes, actualMD5SumBytes) {
-			return probe.New(BadDigest{})
+			return probe.NewError(BadDigest{})
 		}
 		return nil
 	}
-	return probe.New(InvalidArgument{})
+	return probe.NewError(InvalidArgument{})
 }
 
 // writeObjectMetadata - write additional object metadata
 func (b bucket) writeObjectMetadata(objectName string, objMetadata ObjectMetadata) *probe.Error {
 	if objMetadata.Object == "" {
-		return probe.New(InvalidArgument{})
+		return probe.NewError(InvalidArgument{})
 	}
 	objMetadataWriters, err := b.getObjectWriters(objectName, objectMetadataConfig)
 	if err != nil {
@@ -365,7 +365,7 @@ func (b bucket) writeObjectMetadata(objectName string, objMetadata ObjectMetadat
 		if err := jenc.Encode(&objMetadata); err != nil {
 			// Close writers and purge all temporary entries
 			CleanupWritersOnError(objMetadataWriters)
-			return probe.New(err)
+			return probe.NewError(err)
 		}
 	}
 	for _, objMetadataWriter := range objMetadataWriters {
@@ -377,7 +377,7 @@ func (b bucket) writeObjectMetadata(objectName string, objMetadata ObjectMetadat
 // readObjectMetadata - read object metadata
 func (b bucket) readObjectMetadata(objectName string) (ObjectMetadata, *probe.Error) {
 	if objectName == "" {
-		return ObjectMetadata{}, probe.New(InvalidArgument{})
+		return ObjectMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	objMetadata := ObjectMetadata{}
 	objMetadataReaders, err := b.getObjectReaders(objectName, objectMetadataConfig)
@@ -395,7 +395,7 @@ func (b bucket) readObjectMetadata(objectName string) (ObjectMetadata, *probe.Er
 				return objMetadata, nil
 			}
 		}
-		return ObjectMetadata{}, probe.New(err)
+		return ObjectMetadata{}, probe.NewError(err)
 	}
 }
 
@@ -415,12 +415,12 @@ func normalizeObjectName(objectName string) string {
 // getDataAndParity - calculate k, m (data and parity) values from number of disks
 func (b bucket) getDataAndParity(totalWriters int) (k uint8, m uint8, err *probe.Error) {
 	if totalWriters <= 1 {
-		return 0, 0, probe.New(InvalidArgument{})
+		return 0, 0, probe.NewError(InvalidArgument{})
 	}
 	quotient := totalWriters / 2 // not using float or abs to let integer round off to lower value
 	// quotient cannot be bigger than (255 / 2) = 127
 	if quotient > 127 {
-		return 0, 0, probe.New(ParityOverflow{})
+		return 0, 0, probe.NewError(ParityOverflow{})
 	}
 	remainder := totalWriters % 2 // will be 1 for odd and 0 for even numbers
 	k = uint8(quotient + remainder)
@@ -450,7 +450,7 @@ func (b bucket) writeObjectData(k, m uint8, writers []io.WriteCloser, objectData
 			return 0, 0, err.Trace()
 		}
 		if _, err := writer.Write(inputData); err != nil {
-			return 0, 0, probe.New(err)
+			return 0, 0, probe.NewError(err)
 		}
 		for blockIndex, block := range encodedBlocks {
 			errCh := make(chan error, 1)
@@ -461,7 +461,7 @@ func (b bucket) writeObjectData(k, m uint8, writers []io.WriteCloser, objectData
 			}(writers[blockIndex], bytes.NewReader(block), errCh)
 			if err := <-errCh; err != nil {
 				// Returning error is fine here CleanupErrors() would cleanup writers
-				return 0, 0, probe.New(err)
+				return 0, 0, probe.NewError(err)
 			}
 		}
 		chunkCount = chunkCount + 1
@@ -473,7 +473,7 @@ func (b bucket) writeObjectData(k, m uint8, writers []io.WriteCloser, objectData
 func (b bucket) readObjectData(objectName string, writer *io.PipeWriter, objMetadata ObjectMetadata) {
 	readers, err := b.getObjectReaders(objectName, "data")
 	if err != nil {
-		writer.CloseWithError(err.Trace())
+		writer.CloseWithError(probe.NewWrappedError(err))
 		return
 	}
 	for _, reader := range readers {
@@ -484,12 +484,12 @@ func (b bucket) readObjectData(objectName string, writer *io.PipeWriter, objMeta
 		var err error
 		expectedMd5sum, err = hex.DecodeString(objMetadata.MD5Sum)
 		if err != nil {
-			writer.CloseWithError(probe.New(err))
+			writer.CloseWithError(probe.NewWrappedError(probe.NewError(err)))
 			return
 		}
 		expected512Sum, err = hex.DecodeString(objMetadata.SHA512Sum)
 		if err != nil {
-			writer.CloseWithError(probe.New(err))
+			writer.CloseWithError(probe.NewWrappedError(probe.NewError(err)))
 			return
 		}
 	}
@@ -499,23 +499,23 @@ func (b bucket) readObjectData(objectName string, writer *io.PipeWriter, objMeta
 	switch len(readers) > 1 {
 	case true:
 		if objMetadata.ErasureTechnique == "" {
-			writer.CloseWithError(probe.New(MissingErasureTechnique{}))
+			writer.CloseWithError(probe.NewWrappedError(probe.NewError(MissingErasureTechnique{})))
 			return
 		}
 		encoder, err := newEncoder(objMetadata.DataDisks, objMetadata.ParityDisks, objMetadata.ErasureTechnique)
 		if err != nil {
-			writer.CloseWithError(err.Trace())
+			writer.CloseWithError(probe.NewWrappedError(err))
 			return
 		}
 		totalLeft := objMetadata.Size
 		for i := 0; i < objMetadata.ChunkCount; i++ {
 			decodedData, err := b.decodeEncodedData(totalLeft, int64(objMetadata.BlockSize), readers, encoder, writer)
 			if err != nil {
-				writer.CloseWithError(err.Trace())
+				writer.CloseWithError(probe.NewWrappedError(err))
 				return
 			}
 			if _, err := io.Copy(mwriter, bytes.NewReader(decodedData)); err != nil {
-				writer.CloseWithError(probe.New(err))
+				writer.CloseWithError(probe.NewWrappedError(probe.NewError(err)))
 				return
 			}
 			totalLeft = totalLeft - int64(objMetadata.BlockSize)
@@ -523,17 +523,17 @@ func (b bucket) readObjectData(objectName string, writer *io.PipeWriter, objMeta
 	case false:
 		_, err := io.Copy(writer, readers[0])
 		if err != nil {
-			writer.CloseWithError(probe.New(err))
+			writer.CloseWithError(probe.NewWrappedError(probe.NewError(err)))
 			return
 		}
 	}
 	// check if decodedData md5sum matches
 	if !bytes.Equal(expectedMd5sum, hasher.Sum(nil)) {
-		writer.CloseWithError(probe.New(ChecksumMismatch{}))
+		writer.CloseWithError(probe.NewWrappedError(probe.NewError(ChecksumMismatch{})))
 		return
 	}
 	if !bytes.Equal(expected512Sum, sum512hasher.Sum(nil)) {
-		writer.CloseWithError(probe.New(ChecksumMismatch{}))
+		writer.CloseWithError(probe.NewWrappedError(probe.NewError(ChecksumMismatch{})))
 		return
 	}
 	writer.Close()
@@ -557,7 +557,7 @@ func (b bucket) decodeEncodedData(totalLeft, blockSize int64, readers map[int]io
 		var bytesBuffer bytes.Buffer
 		_, err := io.CopyN(&bytesBuffer, reader, int64(curChunkSize))
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, probe.NewError(err)
 		}
 		encodedBytes[i] = bytesBuffer.Bytes()
 	}

pkg/donut/config.go

@@ -31,7 +31,7 @@ func getDonutConfigPath() (string, *probe.Error) {
 	}
 	u, err := user.Current()
 	if err != nil {
-		return "", probe.New(err)
+		return "", probe.NewError(err)
 	}
 	donutConfigPath := filepath.Join(u.HomeDir, ".minio", "donut.json")
 	return donutConfigPath, nil

pkg/donut/disk/disk.go

@@ -39,20 +39,20 @@ type Disk struct {
 // New - instantiate new disk
 func New(diskPath string) (Disk, *probe.Error) {
 	if diskPath == "" {
-		return Disk{}, probe.New(InvalidArgument{})
+		return Disk{}, probe.NewError(InvalidArgument{})
 	}
 	st, err := os.Stat(diskPath)
 	if err != nil {
-		return Disk{}, probe.New(err)
+		return Disk{}, probe.NewError(err)
 	}
 
 	if !st.IsDir() {
-		return Disk{}, probe.New(syscall.ENOTDIR)
+		return Disk{}, probe.NewError(syscall.ENOTDIR)
 	}
 	s := syscall.Statfs_t{}
 	err = syscall.Statfs(diskPath, &s)
 	if err != nil {
-		return Disk{}, probe.New(err)
+		return Disk{}, probe.NewError(err)
 	}
 	disk := Disk{
 		lock:   &sync.Mutex{},
@@ -64,7 +64,7 @@ func New(diskPath string) (Disk, *probe.Error) {
 		disk.fsInfo["MountPoint"] = disk.path
 		return disk, nil
 	}
-	return Disk{}, probe.New(UnsupportedFilesystem{Type: strconv.FormatInt(int64(s.Type), 10)})
+	return Disk{}, probe.NewError(UnsupportedFilesystem{Type: strconv.FormatInt(int64(s.Type), 10)})
 }
 
 // IsUsable - is disk usable, alive
@@ -103,7 +103,7 @@ func (disk Disk) MakeDir(dirname string) *probe.Error {
 	disk.lock.Lock()
 	defer disk.lock.Unlock()
 	if err := os.MkdirAll(filepath.Join(disk.path, dirname), 0700); err != nil {
-		return probe.New(err)
+		return probe.NewError(err)
 	}
 	return nil
 }
@@ -115,12 +115,12 @@ func (disk Disk) ListDir(dirname string) ([]os.FileInfo, *probe.Error) {
 
 	dir, err := os.Open(filepath.Join(disk.path, dirname))
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	defer dir.Close()
 	contents, err := dir.Readdir(-1)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	var directories []os.FileInfo
 	for _, content := range contents {
@@ -139,12 +139,12 @@ func (disk Disk) ListFiles(dirname string) ([]os.FileInfo, *probe.Error) {
 
 	dir, err := os.Open(filepath.Join(disk.path, dirname))
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	defer dir.Close()
 	contents, err := dir.Readdir(-1)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	var files []os.FileInfo
 	for _, content := range contents {
@@ -162,12 +162,12 @@ func (disk Disk) CreateFile(filename string) (*atomic.File, *probe.Error) {
 	defer disk.lock.Unlock()
 
 	if filename == "" {
-		return nil, probe.New(InvalidArgument{})
+		return nil, probe.NewError(InvalidArgument{})
 	}
 
 	f, err := atomic.FileCreate(filepath.Join(disk.path, filename))
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 
 	return f, nil
@@ -179,11 +179,11 @@ func (disk Disk) Open(filename string) (*os.File, *probe.Error) {
 	defer disk.lock.Unlock()
 
 	if filename == "" {
-		return nil, probe.New(InvalidArgument{})
+		return nil, probe.NewError(InvalidArgument{})
 	}
 	dataFile, err := os.Open(filepath.Join(disk.path, filename))
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	return dataFile, nil
 }
@@ -194,11 +194,11 @@ func (disk Disk) OpenFile(filename string, flags int, perm os.FileMode) (*os.Fil
 	defer disk.lock.Unlock()
 
 	if filename == "" {
-		return nil, probe.New(InvalidArgument{})
+		return nil, probe.NewError(InvalidArgument{})
 	}
 	dataFile, err := os.OpenFile(filepath.Join(disk.path, filename), flags, perm)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	return dataFile, nil
 }

pkg/donut/disk/disk_test.go

@@ -38,8 +38,8 @@ func (s *MyDiskSuite) SetUpSuite(c *C) {
 	path, err := ioutil.TempDir(os.TempDir(), "disk-")
 	c.Assert(err, IsNil)
 	s.path = path
-	d, err := New(s.path)
+	d, perr := New(s.path)
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 	s.disk = d
 }
 

pkg/donut/donut-v1.go

@@ -54,7 +54,7 @@ const (
 // makeBucket - make a new bucket
 func (donut API) makeBucket(bucket string, acl BucketACL) *probe.Error {
 	if bucket == "" || strings.TrimSpace(bucket) == "" {
-		return probe.New(InvalidArgument{})
+		return probe.NewError(InvalidArgument{})
 	}
 	return donut.makeDonutBucket(bucket, acl.String())
 }
@@ -65,7 +65,7 @@ func (donut API) getBucketMetadata(bucketName string) (BucketMetadata, *probe.Er
 		return BucketMetadata{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucketName]; !ok {
-		return BucketMetadata{}, probe.New(BucketNotFound{Bucket: bucketName})
+		return BucketMetadata{}, probe.NewError(BucketNotFound{Bucket: bucketName})
 	}
 	metadata, err := donut.getDonutBucketMetadata()
 	if err != nil {
@@ -86,7 +86,7 @@ func (donut API) setBucketMetadata(bucketName string, bucketMetadata map[string]
 	oldBucketMetadata := metadata.Buckets[bucketName]
 	acl, ok := bucketMetadata["acl"]
 	if !ok {
-		return probe.New(InvalidArgument{})
+		return probe.NewError(InvalidArgument{})
 	}
 	oldBucketMetadata.ACL = BucketACL(acl)
 	metadata.Buckets[bucketName] = oldBucketMetadata
@@ -117,7 +117,7 @@ func (donut API) listObjects(bucket, prefix, marker, delimiter string, maxkeys i
 		return ListObjectsResults{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return ListObjectsResults{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ListObjectsResults{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	listObjects, err := donut.buckets[bucket].ListObjects(prefix, marker, delimiter, maxkeys)
 	if err != nil {
@@ -129,23 +129,23 @@ func (donut API) listObjects(bucket, prefix, marker, delimiter string, maxkeys i
 // putObject - put object
 func (donut API) putObject(bucket, object, expectedMD5Sum string, reader io.Reader, size int64, metadata map[string]string, signature *Signature) (ObjectMetadata, *probe.Error) {
 	if bucket == "" || strings.TrimSpace(bucket) == "" {
-		return ObjectMetadata{}, probe.New(InvalidArgument{})
+		return ObjectMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if object == "" || strings.TrimSpace(object) == "" {
-		return ObjectMetadata{}, probe.New(InvalidArgument{})
+		return ObjectMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if err := donut.listDonutBuckets(); err != nil {
 		return ObjectMetadata{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return ObjectMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	bucketMeta, err := donut.getDonutBucketMetadata()
 	if err != nil {
 		return ObjectMetadata{}, err.Trace()
 	}
 	if _, ok := bucketMeta.Buckets[bucket].BucketObjects[object]; ok {
-		return ObjectMetadata{}, probe.New(ObjectExists{Object: object})
+		return ObjectMetadata{}, probe.NewError(ObjectExists{Object: object})
 	}
 	objMetadata, err := donut.buckets[bucket].WriteObject(object, reader, size, expectedMD5Sum, metadata, signature)
 	if err != nil {
@@ -161,26 +161,26 @@ func (donut API) putObject(bucket, object, expectedMD5Sum string, reader io.Read
 // putObject - put object
 func (donut API) putObjectPart(bucket, object, expectedMD5Sum, uploadID string, partID int, reader io.Reader, size int64, metadata map[string]string, signature *Signature) (PartMetadata, *probe.Error) {
 	if bucket == "" || strings.TrimSpace(bucket) == "" {
-		return PartMetadata{}, probe.New(InvalidArgument{})
+		return PartMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if object == "" || strings.TrimSpace(object) == "" {
-		return PartMetadata{}, probe.New(InvalidArgument{})
+		return PartMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if err := donut.listDonutBuckets(); err != nil {
 		return PartMetadata{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return PartMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return PartMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	bucketMeta, err := donut.getDonutBucketMetadata()
 	if err != nil {
 		return PartMetadata{}, err.Trace()
 	}
 	if _, ok := bucketMeta.Buckets[bucket].Multiparts[object]; !ok {
-		return PartMetadata{}, probe.New(InvalidUploadID{UploadID: uploadID})
+		return PartMetadata{}, probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 	if _, ok := bucketMeta.Buckets[bucket].BucketObjects[object]; ok {
-		return PartMetadata{}, probe.New(ObjectExists{Object: object})
+		return PartMetadata{}, probe.NewError(ObjectExists{Object: object})
 	}
 	objectPart := object + "/" + "multipart" + "/" + strconv.Itoa(partID)
 	objmetadata, err := donut.buckets[bucket].WriteObject(objectPart, reader, size, expectedMD5Sum, metadata, signature)
@@ -205,16 +205,16 @@ func (donut API) putObjectPart(bucket, object, expectedMD5Sum, uploadID string,
 // getObject - get object
 func (donut API) getObject(bucket, object string) (reader io.ReadCloser, size int64, err *probe.Error) {
 	if bucket == "" || strings.TrimSpace(bucket) == "" {
-		return nil, 0, probe.New(InvalidArgument{})
+		return nil, 0, probe.NewError(InvalidArgument{})
 	}
 	if object == "" || strings.TrimSpace(object) == "" {
-		return nil, 0, probe.New(InvalidArgument{})
+		return nil, 0, probe.NewError(InvalidArgument{})
 	}
 	if err := donut.listDonutBuckets(); err != nil {
 		return nil, 0, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return nil, 0, probe.New(BucketNotFound{Bucket: bucket})
+		return nil, 0, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	return donut.buckets[bucket].ReadObject(object)
 }
@@ -225,14 +225,14 @@ func (donut API) getObjectMetadata(bucket, object string) (ObjectMetadata, *prob
 		return ObjectMetadata{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return ObjectMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	bucketMeta, err := donut.getDonutBucketMetadata()
 	if err != nil {
 		return ObjectMetadata{}, err.Trace()
 	}
 	if _, ok := bucketMeta.Buckets[bucket].BucketObjects[object]; !ok {
-		return ObjectMetadata{}, probe.New(ObjectNotFound{Object: object})
+		return ObjectMetadata{}, probe.NewError(ObjectNotFound{Object: object})
 	}
 	objectMetadata, err := donut.buckets[bucket].GetObjectMetadata(object)
 	if err != nil {
@@ -247,7 +247,7 @@ func (donut API) newMultipartUpload(bucket, object, contentType string) (string,
 		return "", err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return "", probe.New(BucketNotFound{Bucket: bucket})
+		return "", probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	allbuckets, err := donut.getDonutBucketMetadata()
 	if err != nil {
@@ -283,16 +283,16 @@ func (donut API) newMultipartUpload(bucket, object, contentType string) (string,
 // listObjectParts list all object parts
 func (donut API) listObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error) {
 	if bucket == "" || strings.TrimSpace(bucket) == "" {
-		return ObjectResourcesMetadata{}, probe.New(InvalidArgument{})
+		return ObjectResourcesMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if object == "" || strings.TrimSpace(object) == "" {
-		return ObjectResourcesMetadata{}, probe.New(InvalidArgument{})
+		return ObjectResourcesMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if err := donut.listDonutBuckets(); err != nil {
 		return ObjectResourcesMetadata{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return ObjectResourcesMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectResourcesMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	allBuckets, err := donut.getDonutBucketMetadata()
 	if err != nil {
@@ -300,10 +300,10 @@ func (donut API) listObjectParts(bucket, object string, resources ObjectResource
 	}
 	bucketMetadata := allBuckets.Buckets[bucket]
 	if _, ok := bucketMetadata.Multiparts[object]; !ok {
-		return ObjectResourcesMetadata{}, probe.New(InvalidUploadID{UploadID: resources.UploadID})
+		return ObjectResourcesMetadata{}, probe.NewError(InvalidUploadID{UploadID: resources.UploadID})
 	}
 	if bucketMetadata.Multiparts[object].UploadID != resources.UploadID {
-		return ObjectResourcesMetadata{}, probe.New(InvalidUploadID{UploadID: resources.UploadID})
+		return ObjectResourcesMetadata{}, probe.NewError(InvalidUploadID{UploadID: resources.UploadID})
 	}
 	objectResourcesMetadata := resources
 	objectResourcesMetadata.Bucket = bucket
@@ -326,7 +326,7 @@ func (donut API) listObjectParts(bucket, object string, resources ObjectResource
 		}
 		part, ok := bucketMetadata.Multiparts[object].Parts[strconv.Itoa(i)]
 		if !ok {
-			return ObjectResourcesMetadata{}, probe.New(InvalidPart{})
+			return ObjectResourcesMetadata{}, probe.NewError(InvalidPart{})
 		}
 		parts = append(parts, &part)
 	}
@@ -338,16 +338,16 @@ func (donut API) listObjectParts(bucket, object string, resources ObjectResource
 // completeMultipartUpload complete an incomplete multipart upload
 func (donut API) completeMultipartUpload(bucket, object, uploadID string, data io.Reader, signature *Signature) (ObjectMetadata, *probe.Error) {
 	if bucket == "" || strings.TrimSpace(bucket) == "" {
-		return ObjectMetadata{}, probe.New(InvalidArgument{})
+		return ObjectMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if object == "" || strings.TrimSpace(object) == "" {
-		return ObjectMetadata{}, probe.New(InvalidArgument{})
+		return ObjectMetadata{}, probe.NewError(InvalidArgument{})
 	}
 	if err := donut.listDonutBuckets(); err != nil {
 		return ObjectMetadata{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return ObjectMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	allBuckets, err := donut.getDonutBucketMetadata()
 	if err != nil {
@@ -355,17 +355,17 @@ func (donut API) completeMultipartUpload(bucket, object, uploadID string, data i
 	}
 	bucketMetadata := allBuckets.Buckets[bucket]
 	if _, ok := bucketMetadata.Multiparts[object]; !ok {
-		return ObjectMetadata{}, probe.New(InvalidUploadID{UploadID: uploadID})
+		return ObjectMetadata{}, probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 	if bucketMetadata.Multiparts[object].UploadID != uploadID {
-		return ObjectMetadata{}, probe.New(InvalidUploadID{UploadID: uploadID})
+		return ObjectMetadata{}, probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 	var partBytes []byte
 	{
 		var err error
 		partBytes, err = ioutil.ReadAll(data)
 		if err != nil {
-			return ObjectMetadata{}, probe.New(err)
+			return ObjectMetadata{}, probe.NewError(err)
 		}
 	}
 	if signature != nil {
@@ -374,19 +374,19 @@ func (donut API) completeMultipartUpload(bucket, object, uploadID string, data i
 			return ObjectMetadata{}, err.Trace()
 		}
 		if !ok {
-			return ObjectMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return ObjectMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 	parts := &CompleteMultipartUpload{}
 	if err := xml.Unmarshal(partBytes, parts); err != nil {
-		return ObjectMetadata{}, probe.New(MalformedXML{})
+		return ObjectMetadata{}, probe.NewError(MalformedXML{})
 	}
 	if !sort.IsSorted(completedParts(parts.Part)) {
-		return ObjectMetadata{}, probe.New(InvalidPartOrder{})
+		return ObjectMetadata{}, probe.NewError(InvalidPartOrder{})
 	}
 	for _, part := range parts.Part {
 		if strings.Trim(part.ETag, "\"") != bucketMetadata.Multiparts[object].Parts[strconv.Itoa(part.PartNumber)].ETag {
-			return ObjectMetadata{}, probe.New(InvalidPart{})
+			return ObjectMetadata{}, probe.NewError(InvalidPart{})
 		}
 	}
 	var finalETagBytes []byte
@@ -395,7 +395,7 @@ func (donut API) completeMultipartUpload(bucket, object, uploadID string, data i
 	for _, part := range bucketMetadata.Multiparts[object].Parts {
 		partETagBytes, err := hex.DecodeString(part.ETag)
 		if err != nil {
-			return ObjectMetadata{}, probe.New(err)
+			return ObjectMetadata{}, probe.NewError(err)
 		}
 		finalETagBytes = append(finalETagBytes, partETagBytes...)
 		finalSize += part.Size
@@ -416,7 +416,7 @@ func (donut API) listMultipartUploads(bucket string, resources BucketMultipartRe
 		return BucketMultipartResourcesMetadata{}, err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return BucketMultipartResourcesMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return BucketMultipartResourcesMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	allbuckets, err := donut.getDonutBucketMetadata()
 	if err != nil {
@@ -474,7 +474,7 @@ func (donut API) abortMultipartUpload(bucket, object, uploadID string) *probe.Er
 		return err.Trace()
 	}
 	if _, ok := donut.buckets[bucket]; !ok {
-		return probe.New(BucketNotFound{Bucket: bucket})
+		return probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	allbuckets, err := donut.getDonutBucketMetadata()
 	if err != nil {
@@ -482,10 +482,10 @@ func (donut API) abortMultipartUpload(bucket, object, uploadID string) *probe.Er
 	}
 	bucketMetadata := allbuckets.Buckets[bucket]
 	if _, ok := bucketMetadata.Multiparts[object]; !ok {
-		return probe.New(InvalidUploadID{UploadID: uploadID})
+		return probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 	if bucketMetadata.Multiparts[object].UploadID != uploadID {
-		return probe.New(InvalidUploadID{UploadID: uploadID})
+		return probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 	delete(bucketMetadata.Multiparts, object)
 
@@ -557,7 +557,7 @@ func (donut API) setDonutBucketMetadata(metadata *AllBuckets) *probe.Error {
 		jenc := json.NewEncoder(writer)
 		if err := jenc.Encode(metadata); err != nil {
 			CleanupWritersOnError(writers)
-			return probe.New(err)
+			return probe.NewError(err)
 		}
 	}
 	for _, writer := range writers {
@@ -584,7 +584,7 @@ func (donut API) getDonutBucketMetadata() (*AllBuckets, *probe.Error) {
 				return metadata, nil
 			}
 		}
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 }
 
@@ -594,7 +594,7 @@ func (donut API) makeDonutBucket(bucketName, acl string) *probe.Error {
 		return err.Trace()
 	}
 	if _, ok := donut.buckets[bucketName]; ok {
-		return probe.New(BucketExists{Bucket: bucketName})
+		return probe.NewError(BucketExists{Bucket: bucketName})
 	}
 	bucket, bucketMetadata, err := newBucket(bucketName, acl, donut.config.DonutName, donut.nodes)
 	if err != nil {
@@ -662,7 +662,7 @@ func (donut API) listDonutBuckets() *probe.Error {
 	for _, dir := range dirs {
 		splitDir := strings.Split(dir.Name(), "$")
 		if len(splitDir) < 3 {
-			return probe.New(CorruptedBackend{Backend: dir.Name()})
+			return probe.NewError(CorruptedBackend{Backend: dir.Name()})
 		}
 		bucketName := splitDir[0]
 		// we dont need this once we cache from makeDonutBucket()

pkg/donut/donut-v1_test.go

@@ -67,15 +67,15 @@ func (s *MyDonutSuite) SetUpSuite(c *C) {
 	conf.NodeDiskMap = createTestNodeDiskMap(root)
 	conf.MaxSize = 100000
 	SetDonutConfigPath(filepath.Join(root, "donut.json"))
-	err = SaveConfig(conf)
+	perr := SaveConfig(conf)
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 
-	dd, err = New()
+	dd, perr = New()
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 
 	// testing empty donut
-	buckets, err := dd.ListBuckets(nil)
+	buckets, perr := dd.ListBuckets(nil)
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 	c.Assert(len(buckets), Equals, 0)
 }
 

pkg/donut/donut-v2.go

@@ -98,7 +98,7 @@ func New() (Interface, *probe.Error) {
 	if len(a.config.NodeDiskMap) > 0 {
 		for k, v := range a.config.NodeDiskMap {
 			if len(v) == 0 {
-				return nil, probe.New(InvalidDisksArgument{})
+				return nil, probe.NewError(InvalidDisksArgument{})
 			}
 			err := a.AttachNode(k, v)
 			if err != nil {
@@ -131,19 +131,19 @@ func (donut API) GetObject(w io.Writer, bucket string, object string, start, len
 	defer donut.lock.Unlock()
 
 	if !IsValidBucket(bucket) {
-		return 0, probe.New(BucketNameInvalid{Bucket: bucket})
+		return 0, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(object) {
-		return 0, probe.New(ObjectNameInvalid{Object: object})
+		return 0, probe.NewError(ObjectNameInvalid{Object: object})
 	}
 	if start < 0 {
-		return 0, probe.New(InvalidRange{
+		return 0, probe.NewError(InvalidRange{
 			Start:  start,
 			Length: length,
 		})
 	}
 	if !donut.storedBuckets.Exists(bucket) {
-		return 0, probe.New(BucketNotFound{Bucket: bucket})
+		return 0, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	objectKey := bucket + "/" + object
 	data, ok := donut.objects.Get(objectKey)
@@ -156,7 +156,7 @@ func (donut API) GetObject(w io.Writer, bucket string, object string, start, len
 			}
 			if start > 0 {
 				if _, err := io.CopyN(ioutil.Discard, reader, start); err != nil {
-					return 0, probe.New(err)
+					return 0, probe.NewError(err)
 				}
 			}
 			// new proxy writer to capture data read from disk
@@ -166,12 +166,12 @@ func (donut API) GetObject(w io.Writer, bucket string, object string, start, len
 				if length > 0 {
 					written, err = io.CopyN(pw, reader, length)
 					if err != nil {
-						return 0, probe.New(err)
+						return 0, probe.NewError(err)
 					}
 				} else {
 					written, err = io.CopyN(pw, reader, size)
 					if err != nil {
-						return 0, probe.New(err)
+						return 0, probe.NewError(err)
 					}
 				}
 			}
@@ -180,23 +180,23 @@ func (donut API) GetObject(w io.Writer, bucket string, object string, start, len
 			pw.writtenBytes = nil
 			go debug.FreeOSMemory()
 			if !ok {
-				return 0, probe.New(InternalError{})
+				return 0, probe.NewError(InternalError{})
 			}
 			return written, nil
 		}
-		return 0, probe.New(ObjectNotFound{Object: object})
+		return 0, probe.NewError(ObjectNotFound{Object: object})
 	}
 	{
 		var err error
 		if start == 0 && length == 0 {
 			written, err = io.CopyN(w, bytes.NewBuffer(data), int64(donut.objects.Len(objectKey)))
 			if err != nil {
-				return 0, probe.New(err)
+				return 0, probe.NewError(err)
 			}
 		} else {
 			written, err = io.CopyN(w, bytes.NewBuffer(data[start:]), length)
 			if err != nil {
-				return 0, probe.New(err)
+				return 0, probe.NewError(err)
 			}
 		}
 		return written, nil
@@ -214,12 +214,12 @@ func (donut API) GetBucketMetadata(bucket string, signature *Signature) (BucketM
 			return BucketMetadata{}, err.Trace()
 		}
 		if !ok {
-			return BucketMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return BucketMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
 	if !IsValidBucket(bucket) {
-		return BucketMetadata{}, probe.New(BucketNameInvalid{Bucket: bucket})
+		return BucketMetadata{}, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !donut.storedBuckets.Exists(bucket) {
 		if len(donut.config.NodeDiskMap) > 0 {
@@ -231,7 +231,7 @@ func (donut API) GetBucketMetadata(bucket string, signature *Signature) (BucketM
 			storedBucket.bucketMetadata = bucketMetadata
 			donut.storedBuckets.Set(bucket, storedBucket)
 		}
-		return BucketMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return BucketMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	return donut.storedBuckets.Get(bucket).(storedBucket).bucketMetadata, nil
 }
@@ -247,15 +247,15 @@ func (donut API) SetBucketMetadata(bucket string, metadata map[string]string, si
 			return err.Trace()
 		}
 		if !ok {
-			return probe.New(SignatureDoesNotMatch{})
+			return probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
 	if !IsValidBucket(bucket) {
-		return probe.New(BucketNameInvalid{Bucket: bucket})
+		return probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !donut.storedBuckets.Exists(bucket) {
-		return probe.New(BucketNotFound{Bucket: bucket})
+		return probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	if len(donut.config.NodeDiskMap) > 0 {
 		if err := donut.setBucketMetadata(bucket, metadata); err != nil {
@@ -273,18 +273,18 @@ func isMD5SumEqual(expectedMD5Sum, actualMD5Sum string) *probe.Error {
 	if strings.TrimSpace(expectedMD5Sum) != "" && strings.TrimSpace(actualMD5Sum) != "" {
 		expectedMD5SumBytes, err := hex.DecodeString(expectedMD5Sum)
 		if err != nil {
-			return probe.New(err)
+			return probe.NewError(err)
 		}
 		actualMD5SumBytes, err := hex.DecodeString(actualMD5Sum)
 		if err != nil {
-			return probe.New(err)
+			return probe.NewError(err)
 		}
 		if !bytes.Equal(expectedMD5SumBytes, actualMD5SumBytes) {
-			return probe.New(BadDigest{})
+			return probe.NewError(BadDigest{})
 		}
 		return nil
 	}
-	return probe.New(InvalidArgument{})
+	return probe.NewError(InvalidArgument{})
 }
 
 // CreateObject - create an object
@@ -305,7 +305,7 @@ func (donut API) createObject(bucket, key, contentType, expectedMD5Sum string, s
 	if len(donut.config.NodeDiskMap) == 0 {
 		if size > int64(donut.config.MaxSize) {
 			generic := GenericObjectError{Bucket: bucket, Object: key}
-			return ObjectMetadata{}, probe.New(EntityTooLarge{
+			return ObjectMetadata{}, probe.NewError(EntityTooLarge{
 				GenericObjectError: generic,
 				Size:               strconv.FormatInt(size, 10),
 				MaxSize:            strconv.FormatUint(donut.config.MaxSize, 10),
@@ -313,19 +313,19 @@ func (donut API) createObject(bucket, key, contentType, expectedMD5Sum string, s
 		}
 	}
 	if !IsValidBucket(bucket) {
-		return ObjectMetadata{}, probe.New(BucketNameInvalid{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(key) {
-		return ObjectMetadata{}, probe.New(ObjectNameInvalid{Object: key})
+		return ObjectMetadata{}, probe.NewError(ObjectNameInvalid{Object: key})
 	}
 	if !donut.storedBuckets.Exists(bucket) {
-		return ObjectMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	storedBucket := donut.storedBuckets.Get(bucket).(storedBucket)
 	// get object key
 	objectKey := bucket + "/" + key
 	if _, ok := storedBucket.objectMetadata[objectKey]; ok == true {
-		return ObjectMetadata{}, probe.New(ObjectExists{Object: key})
+		return ObjectMetadata{}, probe.NewError(ObjectExists{Object: key})
 	}
 
 	if contentType == "" {
@@ -336,7 +336,7 @@ func (donut API) createObject(bucket, key, contentType, expectedMD5Sum string, s
 		expectedMD5SumBytes, err := base64.StdEncoding.DecodeString(strings.TrimSpace(expectedMD5Sum))
 		if err != nil {
 			// pro-actively close the connection
-			return ObjectMetadata{}, probe.New(InvalidDigest{Md5: expectedMD5Sum})
+			return ObjectMetadata{}, probe.NewError(InvalidDigest{Md5: expectedMD5Sum})
 		}
 		expectedMD5Sum = hex.EncodeToString(expectedMD5SumBytes)
 	}
@@ -375,7 +375,7 @@ func (donut API) createObject(bucket, key, contentType, expectedMD5Sum string, s
 		sha256hash.Write(byteBuffer[0:length])
 		ok := donut.objects.Append(objectKey, byteBuffer[0:length])
 		if !ok {
-			return ObjectMetadata{}, probe.New(InternalError{})
+			return ObjectMetadata{}, probe.NewError(InternalError{})
 		}
 		totalLength += int64(length)
 		go debug.FreeOSMemory()
@@ -383,17 +383,17 @@ func (donut API) createObject(bucket, key, contentType, expectedMD5Sum string, s
 	if totalLength != size {
 		// Delete perhaps the object is already saved, due to the nature of append()
 		donut.objects.Delete(objectKey)
-		return ObjectMetadata{}, probe.New(IncompleteBody{Bucket: bucket, Object: key})
+		return ObjectMetadata{}, probe.NewError(IncompleteBody{Bucket: bucket, Object: key})
 	}
 	if err != io.EOF {
-		return ObjectMetadata{}, probe.New(err)
+		return ObjectMetadata{}, probe.NewError(err)
 	}
 	md5SumBytes := hash.Sum(nil)
 	md5Sum := hex.EncodeToString(md5SumBytes)
 	// Verify if the written object is equal to what is expected, only if it is requested as such
 	if strings.TrimSpace(expectedMD5Sum) != "" {
 		if err := isMD5SumEqual(strings.TrimSpace(expectedMD5Sum), md5Sum); err != nil {
-			return ObjectMetadata{}, probe.New(BadDigest{})
+			return ObjectMetadata{}, probe.NewError(BadDigest{})
 		}
 	}
 	if signature != nil {
@@ -402,7 +402,7 @@ func (donut API) createObject(bucket, key, contentType, expectedMD5Sum string, s
 			return ObjectMetadata{}, err.Trace()
 		}
 		if !ok {
-			return ObjectMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return ObjectMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
@@ -433,7 +433,7 @@ func (donut API) MakeBucket(bucketName, acl string, location io.Reader, signatur
 	if location != nil {
 		locationConstraintBytes, err := ioutil.ReadAll(location)
 		if err != nil {
-			return probe.New(InternalError{})
+			return probe.NewError(InternalError{})
 		}
 		locationSum = hex.EncodeToString(sha256.Sum256(locationConstraintBytes)[:])
 	}
@@ -444,21 +444,21 @@ func (donut API) MakeBucket(bucketName, acl string, location io.Reader, signatur
 			return err.Trace()
 		}
 		if !ok {
-			return probe.New(SignatureDoesNotMatch{})
+			return probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
 	if donut.storedBuckets.Stats().Items == totalBuckets {
-		return probe.New(TooManyBuckets{Bucket: bucketName})
+		return probe.NewError(TooManyBuckets{Bucket: bucketName})
 	}
 	if !IsValidBucket(bucketName) {
-		return probe.New(BucketNameInvalid{Bucket: bucketName})
+		return probe.NewError(BucketNameInvalid{Bucket: bucketName})
 	}
 	if !IsValidBucketACL(acl) {
-		return probe.New(InvalidACL{ACL: acl})
+		return probe.NewError(InvalidACL{ACL: acl})
 	}
 	if donut.storedBuckets.Exists(bucketName) {
-		return probe.New(BucketExists{Bucket: bucketName})
+		return probe.NewError(BucketExists{Bucket: bucketName})
 	}
 
 	if strings.TrimSpace(acl) == "" {
@@ -493,18 +493,18 @@ func (donut API) ListObjects(bucket string, resources BucketResourcesMetadata, s
 			return nil, BucketResourcesMetadata{}, err.Trace()
 		}
 		if !ok {
-			return nil, BucketResourcesMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return nil, BucketResourcesMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
 	if !IsValidBucket(bucket) {
-		return nil, BucketResourcesMetadata{IsTruncated: false}, probe.New(BucketNameInvalid{Bucket: bucket})
+		return nil, BucketResourcesMetadata{IsTruncated: false}, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidPrefix(resources.Prefix) {
-		return nil, BucketResourcesMetadata{IsTruncated: false}, probe.New(ObjectNameInvalid{Object: resources.Prefix})
+		return nil, BucketResourcesMetadata{IsTruncated: false}, probe.NewError(ObjectNameInvalid{Object: resources.Prefix})
 	}
 	if !donut.storedBuckets.Exists(bucket) {
-		return nil, BucketResourcesMetadata{IsTruncated: false}, probe.New(BucketNotFound{Bucket: bucket})
+		return nil, BucketResourcesMetadata{IsTruncated: false}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	var results []ObjectMetadata
 	var keys []string
@@ -593,10 +593,10 @@ func (donut API) ListBuckets(signature *Signature) ([]BucketMetadata, *probe.Err
 	if signature != nil {
 		ok, err := signature.DoesSignatureMatch("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, err.Trace()
 		}
 		if !ok {
-			return nil, probe.New(SignatureDoesNotMatch{})
+			return nil, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
@@ -630,19 +630,19 @@ func (donut API) GetObjectMetadata(bucket, key string, signature *Signature) (Ob
 			return ObjectMetadata{}, err.Trace()
 		}
 		if !ok {
-			return ObjectMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return ObjectMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
 	// check if bucket exists
 	if !IsValidBucket(bucket) {
-		return ObjectMetadata{}, probe.New(BucketNameInvalid{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(key) {
-		return ObjectMetadata{}, probe.New(ObjectNameInvalid{Object: key})
+		return ObjectMetadata{}, probe.NewError(ObjectNameInvalid{Object: key})
 	}
 	if !donut.storedBuckets.Exists(bucket) {
-		return ObjectMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	storedBucket := donut.storedBuckets.Get(bucket).(storedBucket)
 	objectKey := bucket + "/" + key
@@ -659,7 +659,7 @@ func (donut API) GetObjectMetadata(bucket, key string, signature *Signature) (Ob
 		donut.storedBuckets.Set(bucket, storedBucket)
 		return objMetadata, nil
 	}
-	return ObjectMetadata{}, probe.New(ObjectNotFound{Object: key})
+	return ObjectMetadata{}, probe.NewError(ObjectNotFound{Object: key})
 }
 
 // evictedObject callback function called when an item is evicted from memory

pkg/donut/donut-v2_test.go

@@ -45,12 +45,12 @@ func (s *MyCacheSuite) SetUpSuite(c *C) {
 	s.root = root
 
 	SetDonutConfigPath(filepath.Join(root, "donut.json"))
-	dc, err = New()
+	dc, _ = New()
-	c.Assert(err, IsNil)
 
 	// testing empty cache
-	buckets, err := dc.ListBuckets(nil)
+	var buckets []BucketMetadata
-	c.Assert(err, IsNil)
+	buckets, perr := dc.ListBuckets(nil)
+	c.Assert(perr, IsNil)
 	c.Assert(len(buckets), Equals, 0)
 }
 

pkg/donut/encoder.go

@@ -38,7 +38,7 @@ func getErasureTechnique(technique string) (encoding.Technique, *probe.Error) {
 	case technique == "Vandermonde":
 		return encoding.Cauchy, nil
 	default:
-		return encoding.None, probe.New(InvalidErasureTechnique{Technique: technique})
+		return encoding.None, probe.NewError(InvalidErasureTechnique{Technique: technique})
 	}
 }
 
@@ -52,7 +52,7 @@ func newEncoder(k, m uint8, technique string) (encoder, *probe.Error) {
 	{
 		params, err := encoding.ValidateParams(k, m, t)
 		if err != nil {
-			return encoder{}, probe.New(err)
+			return encoder{}, probe.NewError(err)
 		}
 		e.encoder = encoding.NewErasure(params)
 		e.k = k
@@ -66,7 +66,7 @@ func newEncoder(k, m uint8, technique string) (encoder, *probe.Error) {
 // GetEncodedBlockLen - wrapper around erasure function with the same name
 func (e encoder) GetEncodedBlockLen(dataLength int) (int, *probe.Error) {
 	if dataLength <= 0 {
-		return 0, probe.New(InvalidArgument{})
+		return 0, probe.NewError(InvalidArgument{})
 	}
 	return encoding.GetEncodedBlockLen(dataLength, e.k), nil
 }
@@ -74,11 +74,11 @@ func (e encoder) GetEncodedBlockLen(dataLength int) (int, *probe.Error) {
 // Encode - erasure code input bytes
 func (e encoder) Encode(data []byte) ([][]byte, *probe.Error) {
 	if data == nil {
-		return nil, probe.New(InvalidArgument{})
+		return nil, probe.NewError(InvalidArgument{})
 	}
 	encodedData, err := e.encoder.Encode(data)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	return encodedData, nil
 }
@@ -86,7 +86,7 @@ func (e encoder) Encode(data []byte) ([][]byte, *probe.Error) {
 func (e encoder) EncodeStream(data io.Reader, size int64) ([][]byte, []byte, *probe.Error) {
 	encodedData, inputData, err := e.encoder.EncodeStream(data, size)
 	if err != nil {
-		return nil, nil, probe.New(err)
+		return nil, nil, probe.NewError(err)
 	}
 	return encodedData, inputData, nil
 }
@@ -95,7 +95,7 @@ func (e encoder) EncodeStream(data io.Reader, size int64) ([][]byte, []byte, *pr
 func (e encoder) Decode(encodedData [][]byte, dataLength int) ([]byte, *probe.Error) {
 	decodedData, err := e.encoder.Decode(encodedData, dataLength)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	return decodedData, nil
 }

pkg/donut/heal.go

@@ -54,7 +54,7 @@ func (donut API) healBuckets() *probe.Error {
 			defer bucketMetadataWriter.Close()
 			jenc := json.NewEncoder(bucketMetadataWriter)
 			if err := jenc.Encode(bucketMetadata); err != nil {
-				return probe.New(err)
+				return probe.NewError(err)
 			}
 			for bucket := range bucketMetadata.Buckets {
 				bucketSlice := fmt.Sprintf("%s$0$%d", bucket, order) // TODO handle node slices

pkg/donut/management.go

@@ -41,7 +41,7 @@ func (donut API) Info() (nodeDiskMap map[string][]string, err *probe.Error) {
 // AttachNode - attach node
 func (donut API) AttachNode(hostname string, disks []string) *probe.Error {
 	if hostname == "" || len(disks) == 0 {
-		return probe.New(InvalidArgument{})
+		return probe.NewError(InvalidArgument{})
 	}
 	node, err := newNode(hostname)
 	if err != nil {
@@ -71,7 +71,7 @@ func (donut API) DetachNode(hostname string) *probe.Error {
 
 // Rebalance - rebalance an existing donut with new disks and nodes
 func (donut API) Rebalance() *probe.Error {
-	return probe.New(APINotImplemented{API: "management.Rebalance"})
+	return probe.NewError(APINotImplemented{API: "management.Rebalance"})
 }
 
 // Heal - heal your donuts

pkg/donut/multipart.go

@@ -45,10 +45,10 @@ func (donut API) NewMultipartUpload(bucket, key, contentType string, signature *
 	defer donut.lock.Unlock()
 
 	if !IsValidBucket(bucket) {
-		return "", probe.New(BucketNameInvalid{Bucket: bucket})
+		return "", probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(key) {
-		return "", probe.New(ObjectNameInvalid{Object: key})
+		return "", probe.NewError(ObjectNameInvalid{Object: key})
 	}
 	if signature != nil {
 		ok, err := signature.DoesSignatureMatch("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
@@ -56,19 +56,19 @@ func (donut API) NewMultipartUpload(bucket, key, contentType string, signature *
 			return "", err.Trace()
 		}
 		if !ok {
-			return "", probe.New(SignatureDoesNotMatch{})
+			return "", probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 	if len(donut.config.NodeDiskMap) > 0 {
 		return donut.newMultipartUpload(bucket, key, contentType)
 	}
 	if !donut.storedBuckets.Exists(bucket) {
-		return "", probe.New(BucketNotFound{Bucket: bucket})
+		return "", probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	storedBucket := donut.storedBuckets.Get(bucket).(storedBucket)
 	objectKey := bucket + "/" + key
 	if _, ok := storedBucket.objectMetadata[objectKey]; ok == true {
-		return "", probe.New(ObjectExists{Object: key})
+		return "", probe.NewError(ObjectExists{Object: key})
 	}
 	id := []byte(strconv.Itoa(rand.Int()) + bucket + key + time.Now().UTC().String())
 	uploadIDSum := sha512.Sum512(id)
@@ -93,10 +93,10 @@ func (donut API) AbortMultipartUpload(bucket, key, uploadID string, signature *S
 	defer donut.lock.Unlock()
 
 	if !IsValidBucket(bucket) {
-		return probe.New(BucketNameInvalid{Bucket: bucket})
+		return probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(key) {
-		return probe.New(ObjectNameInvalid{Object: key})
+		return probe.NewError(ObjectNameInvalid{Object: key})
 	}
 	if signature != nil {
 		ok, err := signature.DoesSignatureMatch("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855")
@@ -104,18 +104,18 @@ func (donut API) AbortMultipartUpload(bucket, key, uploadID string, signature *S
 			return err.Trace()
 		}
 		if !ok {
-			return probe.New(SignatureDoesNotMatch{})
+			return probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 	if len(donut.config.NodeDiskMap) > 0 {
 		return donut.abortMultipartUpload(bucket, key, uploadID)
 	}
 	if !donut.storedBuckets.Exists(bucket) {
-		return probe.New(BucketNotFound{Bucket: bucket})
+		return probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	storedBucket := donut.storedBuckets.Get(bucket).(storedBucket)
 	if storedBucket.multiPartSession[key].UploadID != uploadID {
-		return probe.New(InvalidUploadID{UploadID: uploadID})
+		return probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 	donut.cleanupMultipartSession(bucket, key, uploadID)
 	return nil
@@ -135,10 +135,10 @@ func (donut API) CreateObjectPart(bucket, key, uploadID string, partID int, cont
 // createObject - internal wrapper function called by CreateObjectPart
 func (donut API) createObjectPart(bucket, key, uploadID string, partID int, contentType, expectedMD5Sum string, size int64, data io.Reader, signature *Signature) (string, *probe.Error) {
 	if !IsValidBucket(bucket) {
-		return "", probe.New(BucketNameInvalid{Bucket: bucket})
+		return "", probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(key) {
-		return "", probe.New(ObjectNameInvalid{Object: key})
+		return "", probe.NewError(ObjectNameInvalid{Object: key})
 	}
 	if len(donut.config.NodeDiskMap) > 0 {
 		metadata := make(map[string]string)
@@ -151,7 +151,7 @@ func (donut API) createObjectPart(bucket, key, uploadID string, partID int, cont
 			expectedMD5SumBytes, err := base64.StdEncoding.DecodeString(strings.TrimSpace(expectedMD5Sum))
 			if err != nil {
 				// pro-actively close the connection
-				return "", probe.New(InvalidDigest{Md5: expectedMD5Sum})
+				return "", probe.NewError(InvalidDigest{Md5: expectedMD5Sum})
 			}
 			expectedMD5Sum = hex.EncodeToString(expectedMD5SumBytes)
 		}
@@ -163,12 +163,12 @@ func (donut API) createObjectPart(bucket, key, uploadID string, partID int, cont
 	}
 
 	if !donut.storedBuckets.Exists(bucket) {
-		return "", probe.New(BucketNotFound{Bucket: bucket})
+		return "", probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	strBucket := donut.storedBuckets.Get(bucket).(storedBucket)
 	// Verify upload id
 	if strBucket.multiPartSession[key].UploadID != uploadID {
-		return "", probe.New(InvalidUploadID{UploadID: uploadID})
+		return "", probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 
 	// get object key
@@ -185,7 +185,7 @@ func (donut API) createObjectPart(bucket, key, uploadID string, partID int, cont
 		expectedMD5SumBytes, err := base64.StdEncoding.DecodeString(strings.TrimSpace(expectedMD5Sum))
 		if err != nil {
 			// pro-actively close the connection
-			return "", probe.New(InvalidDigest{Md5: expectedMD5Sum})
+			return "", probe.NewError(InvalidDigest{Md5: expectedMD5Sum})
 		}
 		expectedMD5Sum = hex.EncodeToString(expectedMD5SumBytes)
 	}
@@ -204,17 +204,17 @@ func (donut API) createObjectPart(bucket, key, uploadID string, partID int, cont
 		sha256hash.Write(byteBuffer[0:length])
 		ok := donut.multiPartObjects[uploadID].Append(partID, byteBuffer[0:length])
 		if !ok {
-			return "", probe.New(InternalError{})
+			return "", probe.NewError(InternalError{})
 		}
 		totalLength += int64(length)
 		go debug.FreeOSMemory()
 	}
 	if totalLength != size {
 		donut.multiPartObjects[uploadID].Delete(partID)
-		return "", probe.New(IncompleteBody{Bucket: bucket, Object: key})
+		return "", probe.NewError(IncompleteBody{Bucket: bucket, Object: key})
 	}
 	if err != io.EOF {
-		return "", probe.New(err)
+		return "", probe.NewError(err)
 	}
 
 	md5SumBytes := hash.Sum(nil)
@@ -233,7 +233,7 @@ func (donut API) createObjectPart(bucket, key, uploadID string, partID int, cont
 				return "", err.Trace()
 			}
 			if !ok {
-				return "", probe.New(SignatureDoesNotMatch{})
+				return "", probe.NewError(SignatureDoesNotMatch{})
 			}
 		}
 	}
@@ -271,11 +271,11 @@ func (donut API) CompleteMultipartUpload(bucket, key, uploadID string, data io.R
 
 	if !IsValidBucket(bucket) {
 		donut.lock.Unlock()
-		return ObjectMetadata{}, probe.New(BucketNameInvalid{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(key) {
 		donut.lock.Unlock()
-		return ObjectMetadata{}, probe.New(ObjectNameInvalid{Object: key})
+		return ObjectMetadata{}, probe.NewError(ObjectNameInvalid{Object: key})
 	}
 	if len(donut.config.NodeDiskMap) > 0 {
 		donut.lock.Unlock()
@@ -284,18 +284,18 @@ func (donut API) CompleteMultipartUpload(bucket, key, uploadID string, data io.R
 
 	if !donut.storedBuckets.Exists(bucket) {
 		donut.lock.Unlock()
-		return ObjectMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	storedBucket := donut.storedBuckets.Get(bucket).(storedBucket)
 	// Verify upload id
 	if storedBucket.multiPartSession[key].UploadID != uploadID {
 		donut.lock.Unlock()
-		return ObjectMetadata{}, probe.New(InvalidUploadID{UploadID: uploadID})
+		return ObjectMetadata{}, probe.NewError(InvalidUploadID{UploadID: uploadID})
 	}
 	partBytes, err := ioutil.ReadAll(data)
 	if err != nil {
 		donut.lock.Unlock()
-		return ObjectMetadata{}, probe.New(err)
+		return ObjectMetadata{}, probe.NewError(err)
 	}
 	if signature != nil {
 		ok, err := signature.DoesSignatureMatch(hex.EncodeToString(sha256.Sum256(partBytes)[:]))
@@ -305,17 +305,17 @@ func (donut API) CompleteMultipartUpload(bucket, key, uploadID string, data io.R
 		}
 		if !ok {
 			donut.lock.Unlock()
-			return ObjectMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return ObjectMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 	parts := &CompleteMultipartUpload{}
 	if err := xml.Unmarshal(partBytes, parts); err != nil {
 		donut.lock.Unlock()
-		return ObjectMetadata{}, probe.New(MalformedXML{})
+		return ObjectMetadata{}, probe.NewError(MalformedXML{})
 	}
 	if !sort.IsSorted(completedParts(parts.Part)) {
 		donut.lock.Unlock()
-		return ObjectMetadata{}, probe.New(InvalidPartOrder{})
+		return ObjectMetadata{}, probe.NewError(InvalidPartOrder{})
 	}
 
 	var size int64
@@ -325,7 +325,7 @@ func (donut API) CompleteMultipartUpload(bucket, key, uploadID string, data io.R
 		object, ok := donut.multiPartObjects[uploadID].Get(parts.Part[i].PartNumber)
 		if ok == false {
 			donut.lock.Unlock()
-			return ObjectMetadata{}, probe.New(InvalidPart{})
+			return ObjectMetadata{}, probe.NewError(InvalidPart{})
 		}
 		size += int64(len(object))
 		calcMD5Bytes := md5.Sum(object)
@@ -333,15 +333,15 @@ func (donut API) CompleteMultipartUpload(bucket, key, uploadID string, data io.R
 		recvMD5Bytes, err := hex.DecodeString(strings.Trim(recvMD5, "\""))
 		if err != nil {
 			donut.lock.Unlock()
-			return ObjectMetadata{}, probe.New(InvalidDigest{Md5: recvMD5})
+			return ObjectMetadata{}, probe.NewError(InvalidDigest{Md5: recvMD5})
 		}
 		if !bytes.Equal(recvMD5Bytes, calcMD5Bytes[:]) {
 			donut.lock.Unlock()
-			return ObjectMetadata{}, probe.New(BadDigest{})
+			return ObjectMetadata{}, probe.NewError(BadDigest{})
 		}
 		if _, err := io.Copy(&fullObject, bytes.NewBuffer(object)); err != nil {
 			donut.lock.Unlock()
-			return ObjectMetadata{}, probe.New(err)
+			return ObjectMetadata{}, probe.NewError(err)
 		}
 		object = nil
 		go debug.FreeOSMemory()
@@ -386,12 +386,12 @@ func (donut API) ListMultipartUploads(bucket string, resources BucketMultipartRe
 			return BucketMultipartResourcesMetadata{}, err.Trace()
 		}
 		if !ok {
-			return BucketMultipartResourcesMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return BucketMultipartResourcesMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
 	if !IsValidBucket(bucket) {
-		return BucketMultipartResourcesMetadata{}, probe.New(BucketNameInvalid{Bucket: bucket})
+		return BucketMultipartResourcesMetadata{}, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 
 	if len(donut.config.NodeDiskMap) > 0 {
@@ -399,7 +399,7 @@ func (donut API) ListMultipartUploads(bucket string, resources BucketMultipartRe
 	}
 
 	if !donut.storedBuckets.Exists(bucket) {
-		return BucketMultipartResourcesMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return BucketMultipartResourcesMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 
 	storedBucket := donut.storedBuckets.Get(bucket).(storedBucket)
@@ -468,15 +468,15 @@ func (donut API) ListObjectParts(bucket, key string, resources ObjectResourcesMe
 			return ObjectResourcesMetadata{}, err.Trace()
 		}
 		if !ok {
-			return ObjectResourcesMetadata{}, probe.New(SignatureDoesNotMatch{})
+			return ObjectResourcesMetadata{}, probe.NewError(SignatureDoesNotMatch{})
 		}
 	}
 
 	if !IsValidBucket(bucket) {
-		return ObjectResourcesMetadata{}, probe.New(BucketNameInvalid{Bucket: bucket})
+		return ObjectResourcesMetadata{}, probe.NewError(BucketNameInvalid{Bucket: bucket})
 	}
 	if !IsValidObjectName(key) {
-		return ObjectResourcesMetadata{}, probe.New(ObjectNameInvalid{Object: key})
+		return ObjectResourcesMetadata{}, probe.NewError(ObjectNameInvalid{Object: key})
 	}
 
 	if len(donut.config.NodeDiskMap) > 0 {
@@ -484,14 +484,14 @@ func (donut API) ListObjectParts(bucket, key string, resources ObjectResourcesMe
 	}
 
 	if !donut.storedBuckets.Exists(bucket) {
-		return ObjectResourcesMetadata{}, probe.New(BucketNotFound{Bucket: bucket})
+		return ObjectResourcesMetadata{}, probe.NewError(BucketNotFound{Bucket: bucket})
 	}
 	storedBucket := donut.storedBuckets.Get(bucket).(storedBucket)
 	if _, ok := storedBucket.multiPartSession[key]; ok == false {
-		return ObjectResourcesMetadata{}, probe.New(ObjectNotFound{Object: key})
+		return ObjectResourcesMetadata{}, probe.NewError(ObjectNotFound{Object: key})
 	}
 	if storedBucket.multiPartSession[key].UploadID != resources.UploadID {
-		return ObjectResourcesMetadata{}, probe.New(InvalidUploadID{UploadID: resources.UploadID})
+		return ObjectResourcesMetadata{}, probe.NewError(InvalidUploadID{UploadID: resources.UploadID})
 	}
 	storedParts := storedBucket.partMetadata[key]
 	objectResourcesMetadata := resources
@@ -515,7 +515,7 @@ func (donut API) ListObjectParts(bucket, key string, resources ObjectResourcesMe
 		}
 		part, ok := storedParts[i]
 		if !ok {
-			return ObjectResourcesMetadata{}, probe.New(InvalidPart{})
+			return ObjectResourcesMetadata{}, probe.NewError(InvalidPart{})
 		}
 		parts = append(parts, &part)
 	}

pkg/donut/node.go

@@ -30,7 +30,7 @@ type node struct {
 // newNode - instantiates a new node
 func newNode(hostname string) (node, *probe.Error) {
 	if hostname == "" {
-		return node{}, probe.New(InvalidArgument{})
+		return node{}, probe.NewError(InvalidArgument{})
 	}
 	disks := make(map[int]disk.Disk)
 	n := node{
@@ -53,7 +53,7 @@ func (n node) ListDisks() (map[int]disk.Disk, *probe.Error) {
 // AttachDisk - attach a disk
 func (n node) AttachDisk(disk disk.Disk, diskOrder int) *probe.Error {
 	if diskOrder < 0 {
-		return probe.New(InvalidArgument{})
+		return probe.NewError(InvalidArgument{})
 	}
 	n.disks[diskOrder] = disk
 	return nil
@@ -67,10 +67,10 @@ func (n node) DetachDisk(diskOrder int) *probe.Error {
 
 // SaveConfig - save node configuration
 func (n node) SaveConfig() *probe.Error {
-	return probe.New(NotImplemented{Function: "SaveConfig"})
+	return probe.NewError(NotImplemented{Function: "SaveConfig"})
 }
 
 // LoadConfig - load node configuration from saved configs
 func (n node) LoadConfig() *probe.Error {
-	return probe.New(NotImplemented{Function: "LoadConfig"})
+	return probe.NewError(NotImplemented{Function: "LoadConfig"})
 }

pkg/donut/signature-v4.go

@@ -78,7 +78,7 @@ func urlEncodeName(name string) (string, *probe.Error) {
 		default:
 			len := utf8.RuneLen(s)
 			if len < 0 {
-				return "", probe.New(InvalidArgument{})
+				return "", probe.NewError(InvalidArgument{})
 			}
 			u := make([]byte, len)
 			utf8.EncodeRune(u, s)
@@ -220,12 +220,12 @@ func (r *Signature) DoesSignatureMatch(hashedPayload string) (bool, *probe.Error
 	var date string
 	if date = r.Request.Header.Get(http.CanonicalHeaderKey("x-amz-date")); date == "" {
 		if date = r.Request.Header.Get("Date"); date == "" {
-			return false, probe.New(MissingDateHeader{})
+			return false, probe.NewError(MissingDateHeader{})
 		}
 	}
 	t, err := time.Parse(iso8601Format, date)
 	if err != nil {
-		return false, probe.New(err)
+		return false, probe.NewError(err)
 	}
 	canonicalRequest := r.getCanonicalRequest()
 	stringToSign := r.getStringToSign(canonicalRequest, t)

pkg/probe/probe.go

@@ -66,11 +66,11 @@ type Error struct {
 	tracePoints []tracePoint
 }
 
-// New function instantiates an error probe for tracing. Original errors.error (golang's error
+// NewError function instantiates an error probe for tracing. Original errors.error (golang's error
 // interface) is injected in only once during this New call. Rest of the time, you
 // trace the return path with Probe.Trace and finally handle reporting or quitting
 // at the top level.
-func New(e error) *Error {
+func NewError(e error) *Error {
 	if e == nil {
 		return nil
 	}
@@ -124,17 +124,9 @@ func (e *Error) Untrace() {
 	e.tracePoints = e.tracePoints[:l-1]
 }
 
-// Error returns error string.
-func (e *Error) Error() string {
-	if e == nil {
-		return "<nil>"
-	}
-	return e.String()
-}
-
 // String returns error message.
 func (e *Error) String() string {
-	if e == nil {
+	if e == nil || e.e == nil {
 		return "<nil>"
 	}
 	e.lock.RLock()
@@ -164,7 +156,7 @@ func (e *Error) String() string {
 
 // JSON returns JSON formated error trace.
 func (e *Error) JSON() string {
-	if e == nil {
+	if e == nil || e.e == nil {
 		return "<nil>"
 	}
 
@@ -187,8 +179,38 @@ func (e *Error) JSON() string {
 	return string(jBytes)
 }
 
-// ToError returns original emnedded error.
+// ToError returns original embedded error.
 func (e *Error) ToError() error {
 	// No need to lock. "e.e" is set once during New and never changed.
 	return e.e
 }
+
+// WrappedError implements container for *probe.Error
+type WrappedError struct {
+	err *Error
+}
+
+// NewWrappedError function wraps a *probe.Error into a 'error' compatible duck type
+func NewWrappedError(err *Error) error {
+	return &WrappedError{err: err}
+}
+
+// Error interface method
+func (w *WrappedError) Error() string {
+	return w.err.String()
+}
+
+// ToError get the *probe.Error embedded internally
+func (w *WrappedError) ToError() *Error {
+	return w.err
+}
+
+// ToWrappedError try to convert generic 'error' into typed *WrappedError, returns true if yes, false otherwise
+func ToWrappedError(err error) (*WrappedError, bool) {
+	switch e := err.(type) {
+	case *WrappedError:
+		return e, true
+	default:
+		return nil, false
+	}
+}

pkg/probe/probe_test.go

@@ -13,33 +13,41 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package probe
+package probe_test
 
 import (
 	"os"
 	"testing"
+
+	"github.com/minio/minio/pkg/probe"
+	. "gopkg.in/check.v1"
 )
 
-func testDummy() *Error {
+func Test(t *testing.T) { TestingT(t) }
-	_, e := os.Stat("this-file-cannot-exit-234234232423423")
+
-	es := New(e)
+type MySuite struct{}
-	es.Trace("this is hell", "asdf")
+
+var _ = Suite(&MySuite{})
+
+func testDummy() *probe.Error {
+	_, e := os.Stat("this-file-cannot-exit")
+	es := probe.NewError(e)
+	es.Trace("Important info 1", "Import into 2")
 	return es
 }
 
-func TestProbe(t *testing.T) {
+func (s *MySuite) TestProbe(c *C) {
 	es := testDummy()
-	if es == nil {
+	c.Assert(es, Not(Equals), nil)
-		t.Fail()
-	}
 
 	newES := es.Trace()
-	if newES == nil {
+	c.Assert(newES, Not(Equals), nil)
-		t.Fail()
+}
-	}
+
-	/*
+func (s *MySuite) TestWrappedError(c *C) {
-		fmt.Println(es)
+	_, e := os.Stat("this-file-cannot-exit")
-		fmt.Println(es.JSON())
+	es := probe.NewError(e)       // *probe.Error
-		fmt.Println(es.ToError())
+	e = probe.NewWrappedError(es) // *probe.WrappedError
-	*/
+	_, ok := probe.ToWrappedError(e)
+	c.Assert(ok, Equals, true)
 }

pkg/quick/quick.go

@@ -52,17 +52,17 @@ type config struct {
 // CheckData - checks the validity of config data. Data sould be of type struct and contain a string type field called "Version"
 func CheckData(data interface{}) *probe.Error {
 	if !structs.IsStruct(data) {
-		return probe.New(fmt.Errorf("Invalid argument type. Expecing \"struct\" type."))
+		return probe.NewError(fmt.Errorf("Invalid argument type. Expecing \"struct\" type."))
 	}
 
 	st := structs.New(data)
 	f, ok := st.FieldOk("Version")
 	if !ok {
-		return probe.New(fmt.Errorf("Invalid type of struct argument. No [%s.Version] field found.", st.Name()))
+		return probe.NewError(fmt.Errorf("Invalid type of struct argument. No [%s.Version] field found.", st.Name()))
 	}
 
 	if f.Kind() != reflect.String {
-		return probe.New(fmt.Errorf("Invalid type of struct argument. Expecting \"string\" type [%s.Version] field.", st.Name()))
+		return probe.NewError(fmt.Errorf("Invalid type of struct argument. Expecting \"string\" type [%s.Version] field.", st.Name()))
 	}
 
 	return nil
@@ -111,7 +111,7 @@ func (d config) Save(filename string) *probe.Error {
 
 	jsonData, err := json.MarshalIndent(d.data, "", "\t")
 	if err != nil {
-		return probe.New(err)
+		return probe.NewError(err)
 	}
 
 	if runtime.GOOS == "windows" {
@@ -120,7 +120,7 @@ func (d config) Save(filename string) *probe.Error {
 
 	err = ioutil.WriteFile(filename, jsonData, 0600)
 	if err != nil {
-		return probe.New(err)
+		return probe.NewError(err)
 	}
 
 	return nil
@@ -133,12 +133,12 @@ func (d *config) Load(filename string) *probe.Error {
 
 	_, err := os.Stat(filename)
 	if err != nil {
-		return probe.New(err)
+		return probe.NewError(err)
 	}
 
 	fileData, err := ioutil.ReadFile(filename)
 	if err != nil {
-		return probe.New(err)
+		return probe.NewError(err)
 	}
 
 	if runtime.GOOS == "windows" {
@@ -147,7 +147,7 @@ func (d *config) Load(filename string) *probe.Error {
 
 	err = json.Unmarshal(fileData, (*d).data)
 	if err != nil {
-		return probe.New(err)
+		return probe.NewError(err)
 	}
 
 	if err := CheckData(*(*d).data); err != nil {
@@ -157,11 +157,11 @@ func (d *config) Load(filename string) *probe.Error {
 	st := structs.New(*(*d).data)
 	f, ok := st.FieldOk("Version")
 	if !ok {
-		return probe.New(fmt.Errorf("Argument struct [%s] does not contain field \"Version\".", st.Name()))
+		return probe.NewError(fmt.Errorf("Argument struct [%s] does not contain field \"Version\".", st.Name()))
 	}
 
 	if (*d).Version() != f.Value() {
-		return probe.New(fmt.Errorf("Version mismatch"))
+		return probe.NewError(fmt.Errorf("Version mismatch"))
 	}
 
 	return nil

pkg/server/api/logging-handlers.go

@@ -24,7 +24,6 @@ import (
 	"os"
 	"time"
 
-	"github.com/minio/minio/pkg/probe"
 	"github.com/minio/minio/pkg/utils/log"
 )
 
@@ -99,12 +98,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, probe.New(err)
+		return nil, err
 	}
 	go func() {
 		for message := range ch {
 			if _, err := io.Copy(file, bytes.NewBuffer(message)); err != nil {
-				log.Errorln(probe.New(err))
+				log.Errorln(err)
 			}
 		}
 	}()

pkg/server/api/range.go

@@ -41,7 +41,7 @@ func (r *httpRange) String() string {
 }
 
 // Grab new range from request header
-func getRequestedRange(hrange string, size int64) (*httpRange, error) {
+func getRequestedRange(hrange string, size int64) (*httpRange, *probe.Error) {
 	r := &httpRange{
 		start:  0,
 		length: 0,
@@ -51,16 +51,16 @@ func getRequestedRange(hrange string, size int64) (*httpRange, error) {
 	if hrange != "" {
 		err := r.parseRange(hrange)
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, err.Trace()
 		}
 	}
 	return r, nil
 }
 
-func (r *httpRange) parse(ra string) error {
+func (r *httpRange) parse(ra string) *probe.Error {
 	i := strings.Index(ra, "-")
 	if i < 0 {
-		return probe.New(donut.InvalidRange{})
+		return probe.NewError(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 probe.New(donut.InvalidRange{})
+			return probe.NewError(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 probe.New(donut.InvalidRange{})
+			return probe.NewError(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 probe.New(donut.InvalidRange{})
+				return probe.NewError(donut.InvalidRange{})
 			}
 			if i >= r.size {
 				i = r.size - 1
@@ -99,26 +99,26 @@ func (r *httpRange) parse(ra string) error {
 }
 
 // parseRange parses a Range header string as per RFC 2616.
-func (r *httpRange) parseRange(s string) error {
+func (r *httpRange) parseRange(s string) *probe.Error {
 	if s == "" {
-		return probe.New(errors.New("header not present"))
+		return probe.NewError(errors.New("header not present"))
 	}
 	if !strings.HasPrefix(s, b) {
-		return probe.New(donut.InvalidRange{})
+		return probe.NewError(donut.InvalidRange{})
 	}
 
 	ras := strings.Split(s[len(b):], ",")
 	if len(ras) == 0 {
-		return probe.New(errors.New("invalid request"))
+		return probe.NewError(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 probe.New(errors.New("multiple ranges specified"))
+		return probe.NewError(errors.New("multiple ranges specified"))
 	}
 
 	ra := strings.TrimSpace(ras[0])
 	if ra == "" {
-		return probe.New(donut.InvalidRange{})
+		return probe.NewError(donut.InvalidRange{})
 	}
 	return r.parse(ra)
 }

pkg/server/api/signature.go

@@ -72,7 +72,7 @@ func InitSignatureV4(req *http.Request) (*donut.Signature, *probe.Error) {
 		var err error
 		accessKeyID, err = StripAccessKeyID(ah)
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, probe.NewError(err)
 		}
 	}
 	authConfig, err := auth.LoadConfig()
@@ -80,7 +80,7 @@ func InitSignatureV4(req *http.Request) (*donut.Signature, *probe.Error) {
 		return nil, err.Trace()
 	}
 	if _, ok := authConfig.Users[accessKeyID]; !ok {
-		return nil, probe.New(errors.New("AccessID not found"))
+		return nil, probe.NewError(errors.New("AccessID not found"))
 	}
 	signature := &donut.Signature{
 		AccessKeyID:     authConfig.Users[accessKeyID].AccessKeyID,

pkg/server/api_donut_cache_test.go

@@ -52,8 +52,8 @@ func (s *MyAPIDonutCacheSuite) SetUpSuite(c *C) {
 	conf.Version = "0.0.1"
 	conf.MaxSize = 100000
 	donut.SetDonutConfigPath(filepath.Join(root, "donut.json"))
-	err = donut.SaveConfig(conf)
+	perr := donut.SaveConfig(conf)
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 
 	httpHandler, minioAPI := getAPIHandler(api.Config{RateLimit: 16})
 	go startTM(minioAPI)

pkg/server/api_donut_test.go

@@ -71,8 +71,8 @@ func (s *MyAPIDonutSuite) SetUpSuite(c *C) {
 	conf.NodeDiskMap = createTestNodeDiskMap(root)
 	conf.MaxSize = 100000
 	donut.SetDonutConfigPath(filepath.Join(root, "donut.json"))
-	err = donut.SaveConfig(conf)
+	perr := donut.SaveConfig(conf)
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 
 	httpHandler, minioAPI := getAPIHandler(api.Config{RateLimit: 16})
 	go startTM(minioAPI)

pkg/server/api_signature_v4_test.go

@@ -60,13 +60,13 @@ func (s *MyAPISignatureV4Suite) SetUpSuite(c *C) {
 	conf.NodeDiskMap = createTestNodeDiskMap(root)
 	conf.MaxSize = 100000
 	donut.SetDonutConfigPath(filepath.Join(root, "donut.json"))
-	err = donut.SaveConfig(conf)
+	perr := donut.SaveConfig(conf)
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 
-	accessKeyID, err := auth.GenerateAccessKeyID()
+	accessKeyID, perr := auth.GenerateAccessKeyID()
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
-	secretAccessKey, err := auth.GenerateSecretAccessKey()
+	secretAccessKey, perr := auth.GenerateSecretAccessKey()
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 
 	authConf := &auth.Config{}
 	authConf.Users = make(map[string]*auth.User)
@@ -79,8 +79,8 @@ func (s *MyAPISignatureV4Suite) SetUpSuite(c *C) {
 	s.secretAccessKey = string(secretAccessKey)
 
 	auth.SetAuthConfigPath(filepath.Join(root, "users.json"))
-	err = auth.SaveConfig(authConf)
+	perr = auth.SaveConfig(authConf)
-	c.Assert(err, IsNil)
+	c.Assert(perr, IsNil)
 
 	httpHandler, minioAPI := getAPIHandler(api.Config{RateLimit: 16})
 	go startTM(minioAPI)

pkg/server/minhttp/http.go

@@ -41,7 +41,7 @@ type app struct {
 	listeners []net.Listener
 	sds       []httpdown.Server
 	net       *minNet
-	errors    chan error
+	errors    chan *probe.Error
 }
 
 // listen initailize listeners
@@ -79,7 +79,7 @@ func (a *app) wait() {
 		go func(s httpdown.Server) {
 			defer wg.Done()
 			if err := s.Wait(); err != nil {
-				a.errors <- probe.New(err)
+				a.errors <- probe.NewError(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 <- probe.New(err)
+						a.errors <- probe.NewError(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 <- probe.New(err)
+				a.errors <- err.Trace()
 			}
 		}
 	}
@@ -129,7 +129,7 @@ func ListenAndServe(servers ...*http.Server) *probe.Error {
 		listeners: make([]net.Listener, 0, len(servers)),
 		sds:       make([]httpdown.Server, 0, len(servers)),
 		net:       &minNet{},
-		errors:    make(chan error, 1+(len(servers)*2)),
+		errors:    make(chan *probe.Error, 1+(len(servers)*2)),
 	}
 
 	// Acquire Listeners
@@ -143,7 +143,7 @@ func ListenAndServe(servers ...*http.Server) *probe.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 probe.New(err)
+			return probe.NewError(err)
 		}
 	}
 
@@ -160,7 +160,7 @@ func ListenAndServe(servers ...*http.Server) *probe.Error {
 		if err == nil {
 			panic("unexpected nil error")
 		}
-		return probe.New(err)
+		return err.Trace()
 	case <-waitdone:
 		return nil
 	}
@@ -176,7 +176,7 @@ func ListenAndServeLimited(connLimit int, servers ...*http.Server) *probe.Error
 		listeners: make([]net.Listener, 0, len(servers)),
 		sds:       make([]httpdown.Server, 0, len(servers)),
 		net:       &minNet{connLimit: connLimit},
-		errors:    make(chan error, 1+(len(servers)*2)),
+		errors:    make(chan *probe.Error, 1+(len(servers)*2)),
 	}
 
 	// Acquire Listeners
@@ -190,7 +190,7 @@ func ListenAndServeLimited(connLimit int, servers ...*http.Server) *probe.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 probe.New(err)
+			return probe.NewError(err)
 		}
 	}
 
@@ -207,7 +207,7 @@ func ListenAndServeLimited(connLimit int, servers ...*http.Server) *probe.Error
 		if err == nil {
 			panic("unexpected nil error")
 		}
-		return probe.New(err)
+		return err.Trace()
 	case <-waitdone:
 		return nil
 	}

pkg/server/minhttp/net.go

@@ -82,7 +82,7 @@ func (n *minNet) getInheritedListeners() *probe.Error {
 		}
 		count, err := strconv.Atoi(countStr)
 		if err != nil {
-			retErr = probe.New(fmt.Errorf("found invalid count value: %s=%s", envCountKey, countStr))
+			retErr = probe.NewError(fmt.Errorf("found invalid count value: %s=%s", envCountKey, countStr))
 			return
 		}
 
@@ -92,18 +92,18 @@ func (n *minNet) getInheritedListeners() *probe.Error {
 			l, err := net.FileListener(file)
 			if err != nil {
 				file.Close()
-				retErr = probe.New(err)
+				retErr = probe.NewError(err)
 				return
 			}
 			if err := file.Close(); err != nil {
-				retErr = probe.New(err)
+				retErr = probe.NewError(err)
 				return
 			}
 			n.inheritedListeners = append(n.inheritedListeners, l)
 		}
 	})
 	if retErr != nil {
-		return probe.New(retErr)
+		return retErr.Trace()
 	}
 	return nil
 }
@@ -115,17 +115,17 @@ func (n *minNet) getInheritedListeners() *probe.Error {
 func (n *minNet) Listen(nett, laddr string) (net.Listener, *probe.Error) {
 	switch nett {
 	default:
-		return nil, probe.New(net.UnknownNetworkError(nett))
+		return nil, probe.NewError(net.UnknownNetworkError(nett))
 	case "tcp", "tcp4", "tcp6":
 		addr, err := net.ResolveTCPAddr(nett, laddr)
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, probe.NewError(err)
 		}
 		return n.ListenTCP(nett, addr)
 	case "unix", "unixpacket":
 		addr, err := net.ResolveUnixAddr(nett, laddr)
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, probe.NewError(err)
 		}
 		return n.ListenUnix(nett, addr)
 	}
@@ -158,7 +158,7 @@ func (n *minNet) ListenTCP(nett string, laddr *net.TCPAddr) (net.Listener, *prob
 	// make a fresh listener
 	l, err := net.ListenTCP(nett, laddr)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	n.activeListeners = append(n.activeListeners, rateLimitedListener(l, n.connLimit))
 	return l, nil
@@ -191,7 +191,7 @@ func (n *minNet) ListenUnix(nett string, laddr *net.UnixAddr) (net.Listener, *pr
 	// make a fresh listener
 	l, err := net.ListenUnix(nett, laddr)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 	n.activeListeners = append(n.activeListeners, rateLimitedListener(l, n.connLimit))
 	return l, nil
@@ -240,7 +240,7 @@ func (n *minNet) StartProcess() (int, *probe.Error) {
 		var err error
 		files[i], err = l.(fileListener).File()
 		if err != nil {
-			return 0, probe.New(err)
+			return 0, probe.NewError(err)
 		}
 		defer files[i].Close()
 	}
@@ -249,7 +249,7 @@ func (n *minNet) StartProcess() (int, *probe.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, probe.New(err)
+		return 0, probe.NewError(err)
 	}
 
 	// Pass on the environment and replace the old count key with the new one.
@@ -268,7 +268,7 @@ func (n *minNet) StartProcess() (int, *probe.Error) {
 		Files: allFiles,
 	})
 	if err != nil {
-		return 0, probe.New(err)
+		return 0, probe.NewError(err)
 	}
 	return process.Pid, nil
 }

pkg/server/rpc/auth.go

@@ -49,7 +49,7 @@ func getAuth(reply *AuthReply) *probe.Error {
 // Get auth keys
 func (s *AuthService) Get(r *http.Request, args *Args, reply *AuthReply) error {
 	if err := getAuth(reply); err != nil {
-		return err
+		return probe.NewWrappedError(err)
 	}
 	return nil
 }

pkg/server/rpc/donut.go

@@ -56,5 +56,8 @@ func setDonut(args *DonutArgs, reply *Reply) *probe.Error {
 
 // Set method
 func (s *DonutService) Set(r *http.Request, args *DonutArgs, reply *Reply) error {
-	return setDonut(args, reply)
+	if err := setDonut(args, reply); err != nil {
+		return probe.NewWrappedError(err)
+	}
+	return nil
 }

pkg/server/rpc/sysinfo.go

@@ -55,7 +55,7 @@ func setSysInfoReply(sis *SysInfoReply) *probe.Error {
 	var err error
 	sis.Hostname, err = os.Hostname()
 	if err != nil {
-		return probe.New(err)
+		return probe.NewError(err)
 	}
 	return nil
 }
@@ -70,7 +70,7 @@ func setMemStatsReply(sis *MemStatsReply) *probe.Error {
 // Get method
 func (s *SysInfoService) Get(r *http.Request, args *Args, reply *SysInfoReply) error {
 	if err := setSysInfoReply(reply); err != nil {
-		return err
+		return probe.NewWrappedError(err)
 	}
 	return nil
 }
@@ -78,7 +78,7 @@ func (s *SysInfoService) Get(r *http.Request, args *Args, reply *SysInfoReply) e
 // Get method
 func (s *MemStatsService) Get(r *http.Request, args *Args, reply *MemStatsReply) error {
 	if err := setMemStatsReply(reply); err != nil {
-		return err
+		return probe.NewWrappedError(err)
 	}
 	return nil
 }

pkg/server/server.go

@@ -44,13 +44,13 @@ func getAPIServer(conf api.Config, apiHandler http.Handler) (*http.Server, *prob
 		httpServer.TLSConfig.Certificates = make([]tls.Certificate, 1)
 		httpServer.TLSConfig.Certificates[0], err = tls.LoadX509KeyPair(conf.CertFile, conf.KeyFile)
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, probe.NewError(err)
 		}
 	}
 
 	host, port, err := net.SplitHostPort(conf.Address)
 	if err != nil {
-		return nil, probe.New(err)
+		return nil, probe.NewError(err)
 	}
 
 	var hosts []string
@@ -60,7 +60,7 @@ func getAPIServer(conf api.Config, apiHandler http.Handler) (*http.Server, *prob
 	default:
 		addrs, err := net.InterfaceAddrs()
 		if err != nil {
-			return nil, probe.New(err)
+			return nil, probe.NewError(err)
 		}
 		for _, addr := range addrs {
 			if addr.Network() == "ip+net" {