From 45b59b84560301035a7d0962c0b41006de2c30d4 Mon Sep 17 00:00:00 2001 From: Harshavardhana Date: Fri, 7 Aug 2015 23:47:22 -0700 Subject: [PATCH] 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 | 10 +-- pkg/auth/auth.go | 4 +- pkg/auth/config.go | 2 +- pkg/controller/client.go | 76 ++++++++++----------- pkg/controller/rpc.go | 9 ++- pkg/donut/bucket.go | 58 ++++++++-------- pkg/donut/config.go | 2 +- pkg/donut/disk/disk.go | 32 ++++----- pkg/donut/disk/disk_test.go | 4 +- pkg/donut/donut-v1.go | 88 ++++++++++++------------ pkg/donut/donut-v1_test.go | 12 ++-- pkg/donut/donut-v2.go | 100 ++++++++++++++-------------- pkg/donut/donut-v2_test.go | 8 +-- pkg/donut/encoder.go | 14 ++-- pkg/donut/heal.go | 2 +- pkg/donut/management.go | 4 +- pkg/donut/multipart.go | 84 +++++++++++------------ pkg/donut/node.go | 8 +-- pkg/donut/signature-v4.go | 6 +- pkg/probe/probe.go | 48 +++++++++---- pkg/probe/probe_test.go | 42 +++++++----- pkg/quick/quick.go | 20 +++--- pkg/server/api/logging-handlers.go | 5 +- pkg/server/api/range.go | 26 ++++---- pkg/server/api/signature.go | 4 +- pkg/server/api_donut_cache_test.go | 4 +- pkg/server/api_donut_test.go | 4 +- pkg/server/api_signature_v4_test.go | 16 ++--- pkg/server/minhttp/http.go | 20 +++--- pkg/server/minhttp/net.go | 24 +++---- pkg/server/rpc/auth.go | 2 +- pkg/server/rpc/donut.go | 5 +- pkg/server/rpc/sysinfo.go | 6 +- pkg/server/server.go | 6 +- 34 files changed, 392 insertions(+), 363 deletions(-) diff --git a/disks.go b/disks.go index 5758ec4af..1b63b30f9 100644 --- a/disks.go +++ b/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 } diff --git a/pkg/auth/auth.go b/pkg/auth/auth.go index 0c8d589ec..ceb070747 100644 --- a/pkg/auth/auth.go +++ b/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 } diff --git a/pkg/auth/config.go b/pkg/auth/config.go index ddbbff3ea..008e26f77 100644 --- a/pkg/auth/config.go +++ b/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 diff --git a/pkg/controller/client.go b/pkg/controller/client.go index c7a7bbb6c..a2b207274 100644 --- a/pkg/controller/client.go +++ b/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) - if err != nil { - return nil, err.Trace() + req, perr := NewRequest(url, op, http.DefaultTransport) + if perr != nil { + return nil, perr.Trace() } - resp, err := req.Do() + resp, perr := req.Do() defer closeResp(resp) - if err != nil { - return nil, err.Trace() + if perr != nil { + 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") - if err != nil { - return nil, probe.New(err) - } - return jsonRespBytes, nil + jsonRespBytes, err := json.MarshalIndent(reply, "", "\t") + if err != nil { + return nil, probe.NewError(err) } + 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) - if err != nil { - return nil, err.Trace() + req, perr := NewRequest(url, op, http.DefaultTransport) + if perr != nil { + return nil, perr.Trace() } - resp, err := req.Do() + resp, perr := req.Do() defer closeResp(resp) - if err != nil { - return nil, err.Trace() + if perr != nil { + 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") - if err != nil { - return nil, probe.New(err) - } - return jsonRespBytes, nil + jsonRespBytes, err := json.MarshalIndent(reply, "", "\t") + if err != nil { + return nil, probe.NewError(err) } + 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) - if err != nil { - return nil, err.Trace() + req, perr := NewRequest(url, op, http.DefaultTransport) + if perr != nil { + return nil, perr.Trace() } - resp, err := req.Do() + resp, perr := req.Do() defer closeResp(resp) - if err != nil { - return nil, err.Trace() + if perr != nil { + 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") - if err != nil { - return nil, probe.New(err) - } - return jsonRespBytes, nil + jsonRespBytes, err := json.MarshalIndent(reply, "", "\t") + if err != nil { + return nil, probe.NewError(err) } + return jsonRespBytes, nil } // Add more functions here for other RPC messages diff --git a/pkg/controller/rpc.go b/pkg/controller/rpc.go index ae180c232..157cee4f7 100644 --- a/pkg/controller/rpc.go +++ b/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 } diff --git a/pkg/donut/bucket.go b/pkg/donut/bucket.go index 8b2733f43..7646bd823 100644 --- a/pkg/donut/bucket.go +++ b/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() } diff --git a/pkg/donut/config.go b/pkg/donut/config.go index 4da2d2122..cfe4070d5 100644 --- a/pkg/donut/config.go +++ b/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 diff --git a/pkg/donut/disk/disk.go b/pkg/donut/disk/disk.go index c0882ca52..e7689a7ed 100644 --- a/pkg/donut/disk/disk.go +++ b/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 } diff --git a/pkg/donut/disk/disk_test.go b/pkg/donut/disk/disk_test.go index 5eb59a8db..70c74f8ba 100644 --- a/pkg/donut/disk/disk_test.go +++ b/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) - c.Assert(err, IsNil) + d, perr := New(s.path) + c.Assert(perr, IsNil) s.disk = d } diff --git a/pkg/donut/donut-v1.go b/pkg/donut/donut-v1.go index 3dc3d13e1..ef0d00646 100644 --- a/pkg/donut/donut-v1.go +++ b/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() diff --git a/pkg/donut/donut-v1_test.go b/pkg/donut/donut-v1_test.go index 2227dec6e..ea9957a3a 100644 --- a/pkg/donut/donut-v1_test.go +++ b/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) - c.Assert(err, IsNil) + perr := SaveConfig(conf) + c.Assert(perr, IsNil) - dd, err = New() - c.Assert(err, IsNil) + dd, perr = New() + c.Assert(perr, IsNil) // testing empty donut - buckets, err := dd.ListBuckets(nil) - c.Assert(err, IsNil) + buckets, perr := dd.ListBuckets(nil) + c.Assert(perr, IsNil) c.Assert(len(buckets), Equals, 0) } diff --git a/pkg/donut/donut-v2.go b/pkg/donut/donut-v2.go index 2558e1256..54aebd25c 100644 --- a/pkg/donut/donut-v2.go +++ b/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 diff --git a/pkg/donut/donut-v2_test.go b/pkg/donut/donut-v2_test.go index 7f00f2df2..94b42c465 100644 --- a/pkg/donut/donut-v2_test.go +++ b/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() - c.Assert(err, IsNil) + dc, _ = New() // testing empty cache - buckets, err := dc.ListBuckets(nil) - c.Assert(err, IsNil) + var buckets []BucketMetadata + buckets, perr := dc.ListBuckets(nil) + c.Assert(perr, IsNil) c.Assert(len(buckets), Equals, 0) } diff --git a/pkg/donut/encoder.go b/pkg/donut/encoder.go index 77c954ca1..587bf5f99 100644 --- a/pkg/donut/encoder.go +++ b/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 } diff --git a/pkg/donut/heal.go b/pkg/donut/heal.go index c274440c7..e496c5b3a 100644 --- a/pkg/donut/heal.go +++ b/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 diff --git a/pkg/donut/management.go b/pkg/donut/management.go index 7dafa1329..92fb2f1c0 100644 --- a/pkg/donut/management.go +++ b/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 diff --git a/pkg/donut/multipart.go b/pkg/donut/multipart.go index ca7fad101..77b2b5577 100644 --- a/pkg/donut/multipart.go +++ b/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) } diff --git a/pkg/donut/node.go b/pkg/donut/node.go index ba3be8d76..35a90b4ad 100644 --- a/pkg/donut/node.go +++ b/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"}) } diff --git a/pkg/donut/signature-v4.go b/pkg/donut/signature-v4.go index 7d5a1b4e0..6d48c7fff 100644 --- a/pkg/donut/signature-v4.go +++ b/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) diff --git a/pkg/probe/probe.go b/pkg/probe/probe.go index 957c3384a..ef283da22 100644 --- a/pkg/probe/probe.go +++ b/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 "" - } - return e.String() -} - // String returns error message. func (e *Error) String() string { - if e == nil { + if e == nil || e.e == nil { return "" } 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 "" } @@ -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 + } +} diff --git a/pkg/probe/probe_test.go b/pkg/probe/probe_test.go index f50e8c63e..25f99dce2 100644 --- a/pkg/probe/probe_test.go +++ b/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 { - _, e := os.Stat("this-file-cannot-exit-234234232423423") - es := New(e) - es.Trace("this is hell", "asdf") +func Test(t *testing.T) { TestingT(t) } + +type MySuite struct{} + +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 { - t.Fail() - } + c.Assert(es, Not(Equals), nil) newES := es.Trace() - if newES == nil { - t.Fail() - } - /* - fmt.Println(es) - fmt.Println(es.JSON()) - fmt.Println(es.ToError()) - */ + c.Assert(newES, Not(Equals), nil) +} + +func (s *MySuite) TestWrappedError(c *C) { + _, e := os.Stat("this-file-cannot-exit") + es := probe.NewError(e) // *probe.Error + e = probe.NewWrappedError(es) // *probe.WrappedError + _, ok := probe.ToWrappedError(e) + c.Assert(ok, Equals, true) } diff --git a/pkg/quick/quick.go b/pkg/quick/quick.go index f10220a9f..1c9bd203b 100644 --- a/pkg/quick/quick.go +++ b/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 diff --git a/pkg/server/api/logging-handlers.go b/pkg/server/api/logging-handlers.go index 92fc30273..0af3b6422 100644 --- a/pkg/server/api/logging-handlers.go +++ b/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) } } }() diff --git a/pkg/server/api/range.go b/pkg/server/api/range.go index a267c0e74..e90dd41ec 100644 --- a/pkg/server/api/range.go +++ b/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) } diff --git a/pkg/server/api/signature.go b/pkg/server/api/signature.go index 0b3feba88..61ed8004d 100644 --- a/pkg/server/api/signature.go +++ b/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, diff --git a/pkg/server/api_donut_cache_test.go b/pkg/server/api_donut_cache_test.go index 5bb346997..eb8709461 100644 --- a/pkg/server/api_donut_cache_test.go +++ b/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) - c.Assert(err, IsNil) + perr := donut.SaveConfig(conf) + c.Assert(perr, IsNil) httpHandler, minioAPI := getAPIHandler(api.Config{RateLimit: 16}) go startTM(minioAPI) diff --git a/pkg/server/api_donut_test.go b/pkg/server/api_donut_test.go index 22c6fc27f..4963e170e 100644 --- a/pkg/server/api_donut_test.go +++ b/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) - c.Assert(err, IsNil) + perr := donut.SaveConfig(conf) + c.Assert(perr, IsNil) httpHandler, minioAPI := getAPIHandler(api.Config{RateLimit: 16}) go startTM(minioAPI) diff --git a/pkg/server/api_signature_v4_test.go b/pkg/server/api_signature_v4_test.go index 059b0a93b..41232d9ab 100644 --- a/pkg/server/api_signature_v4_test.go +++ b/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) - c.Assert(err, IsNil) + perr := donut.SaveConfig(conf) + c.Assert(perr, IsNil) - accessKeyID, err := auth.GenerateAccessKeyID() - c.Assert(err, IsNil) - secretAccessKey, err := auth.GenerateSecretAccessKey() - c.Assert(err, IsNil) + accessKeyID, perr := auth.GenerateAccessKeyID() + c.Assert(perr, IsNil) + secretAccessKey, perr := auth.GenerateSecretAccessKey() + 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) - c.Assert(err, IsNil) + perr = auth.SaveConfig(authConf) + c.Assert(perr, IsNil) httpHandler, minioAPI := getAPIHandler(api.Config{RateLimit: 16}) go startTM(minioAPI) diff --git a/pkg/server/minhttp/http.go b/pkg/server/minhttp/http.go index 821c551b1..f27cadb0c 100644 --- a/pkg/server/minhttp/http.go +++ b/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 } diff --git a/pkg/server/minhttp/net.go b/pkg/server/minhttp/net.go index 5e0db6a1a..d651a5093 100644 --- a/pkg/server/minhttp/net.go +++ b/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 } diff --git a/pkg/server/rpc/auth.go b/pkg/server/rpc/auth.go index d55a8ad57..f6b1ff32b 100644 --- a/pkg/server/rpc/auth.go +++ b/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 } diff --git a/pkg/server/rpc/donut.go b/pkg/server/rpc/donut.go index 8e3d042a9..0ed7cb176 100644 --- a/pkg/server/rpc/donut.go +++ b/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 } diff --git a/pkg/server/rpc/sysinfo.go b/pkg/server/rpc/sysinfo.go index c7e0b92bd..8fe581865 100644 --- a/pkg/server/rpc/sysinfo.go +++ b/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 } diff --git a/pkg/server/server.go b/pkg/server/server.go index 3f06e0209..0ebf5707c 100644 --- a/pkg/server/server.go +++ b/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" {