From 53439d7768e0c076249bc450530034d8ed96c381 Mon Sep 17 00:00:00 2001 From: "Frederick F. Kautz IV" Date: Thu, 26 Mar 2015 15:55:06 -0700 Subject: [PATCH] Updating iodine to match new api --- Godeps/Godeps.json | 2 +- .../src/github.com/minio-io/iodine/iodine.go | 16 ++++---- .../github.com/minio-io/iodine/iodine_test.go | 16 ++++---- main.go | 2 +- pkg/drivers/donut/donut.go | 2 +- pkg/server/server.go | 8 ++-- pkg/storage/donut/bucket.go | 4 +- pkg/storage/donut/donut.go | 40 +++++++++---------- pkg/storage/donut/erasure.go | 30 +++++++------- pkg/storage/donut/node_local.go | 22 +++++----- pkg/storage/donut/object_writer.go | 10 ++--- 11 files changed, 76 insertions(+), 76 deletions(-) diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 412c11080..82325aa0a 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -20,7 +20,7 @@ }, { "ImportPath": "github.com/minio-io/iodine", - "Rev": "8c8985d5a45e388dccb5ca280c897672abb18278" + "Rev": "b44f7faaff4e722dcdb60b9788d33850606dc07b" }, { "ImportPath": "gopkg.in/check.v1", diff --git a/Godeps/_workspace/src/github.com/minio-io/iodine/iodine.go b/Godeps/_workspace/src/github.com/minio-io/iodine/iodine.go index a1fd95b2e..093fa5f1b 100644 --- a/Godeps/_workspace/src/github.com/minio-io/iodine/iodine.go +++ b/Godeps/_workspace/src/github.com/minio-io/iodine/iodine.go @@ -30,7 +30,7 @@ import ( // WrappedError is the iodine error which contains a pointer to the original error // and stack traces. -type WrappedError struct { +type Error struct { EmbeddedError error `json:"-"` ErrorMessage string @@ -90,20 +90,20 @@ func GetGlobalStateKey(k string) string { // Error - instantiate an error, turning it into an iodine error. // Adds an initial stack trace. -func Error(err error, data map[string]string) error { +func New(err error, data map[string]string) error { if err != nil { entry := createStackEntry() - var newErr WrappedError + var newErr Error // check if error is wrapped switch typedError := err.(type) { - case WrappedError: + case Error: { newErr = typedError } default: { - newErr = WrappedError{ + newErr = Error{ EmbeddedError: err, ErrorMessage: err.Error(), Stack: []StackEntry{}, @@ -170,12 +170,12 @@ func getSystemData() map[string]string { //} // EmitJSON writes JSON output for the error -func (err WrappedError) EmitJSON() ([]byte, error) { +func (err Error) EmitJSON() ([]byte, error) { return json.Marshal(err) } // EmitHumanReadable returns a human readable error message -func (err WrappedError) EmitHumanReadable() string { +func (err Error) EmitHumanReadable() string { var errorBuffer bytes.Buffer fmt.Fprintln(&errorBuffer, err.ErrorMessage) for i, entry := range err.Stack { @@ -185,7 +185,7 @@ func (err WrappedError) EmitHumanReadable() string { } // Emits the original error message -func (err WrappedError) Error() string { +func (err Error) Error() string { return err.EmitHumanReadable() } diff --git a/Godeps/_workspace/src/github.com/minio-io/iodine/iodine_test.go b/Godeps/_workspace/src/github.com/minio-io/iodine/iodine_test.go index 3aa7b39f4..5f52b9598 100644 --- a/Godeps/_workspace/src/github.com/minio-io/iodine/iodine_test.go +++ b/Godeps/_workspace/src/github.com/minio-io/iodine/iodine_test.go @@ -24,12 +24,12 @@ import ( ) func TestIodine(t *testing.T) { - iodineError := Error(errors.New("Hello"), nil) - iodineError = Error(iodineError, nil) - iodineError = Error(iodineError, nil) - iodineError = Error(iodineError, nil) + iodineError := New(errors.New("Hello"), nil) + iodineError = New(iodineError, nil) + iodineError = New(iodineError, nil) + iodineError = New(iodineError, nil) switch typedError := iodineError.(type) { - case WrappedError: + case Error: { if len(typedError.Stack) != 4 { t.Fail() @@ -63,9 +63,9 @@ func TestState(t *testing.T) { t.Fail() } SetGlobalState("foo", "bar") - err := Error(errors.New("a simple error"), nil) + err := New(errors.New("a simple error"), nil) switch typedError := err.(type) { - case WrappedError: + case Error: { if res, ok := typedError.Stack[0].Data["foo"]; ok { if res != "bar" { @@ -74,7 +74,7 @@ func TestState(t *testing.T) { } else { t.Fail() } - typedError = Error(typedError, map[string]string{"foo2": "bar2"}).(WrappedError) + typedError = New(typedError, map[string]string{"foo2": "bar2"}).(Error) if res, ok := typedError.Stack[0].Data["foo"]; ok { if res != "bar" { t.Error("annotate should not modify previous data entries") diff --git a/main.go b/main.go index 4835e9525..572e36d5d 100644 --- a/main.go +++ b/main.go @@ -133,7 +133,7 @@ func main() { app.Action = runCmd err := app.Run(os.Args) switch typedErr := err.(type) { - case *iodine.WrappedError: + case *iodine.Error: { log.Errorln(typedErr.EmitHumanReadable()) } diff --git a/pkg/drivers/donut/donut.go b/pkg/drivers/donut/donut.go index a3b4f7809..5b673a110 100644 --- a/pkg/drivers/donut/donut.go +++ b/pkg/drivers/donut/donut.go @@ -48,7 +48,7 @@ func Start(path string) (chan<- string, <-chan error, drivers.Driver) { // TODO donut driver should be passed in as Start param and driven by config var err error s.donut, err = donut.NewDonut(path) - err = iodine.Error(err, map[string]string{"path": path}) + err = iodine.New(err, map[string]string{"path": path}) if err != nil { log.Println(err) } diff --git a/pkg/server/server.go b/pkg/server/server.go index 8bdb95616..306745b36 100644 --- a/pkg/server/server.go +++ b/pkg/server/server.go @@ -110,7 +110,7 @@ func getHTTPChannels(configs []Config) (ctrlChans []chan<- string, statusChans [ } default: { - err := iodine.Error(errors.New("Invalid API type"), nil) + err := iodine.New(errors.New("Invalid API type"), nil) log.Fatal(err) } } @@ -142,7 +142,7 @@ func getDriverChannels(driverType DriverType) (ctrlChans []chan<- string, status { u, err := user.Current() if err != nil { - log.Errorln(iodine.Error(err, nil)) + log.Errorln(iodine.New(err, nil)) return nil, nil, nil } root := path.Join(u.HomeDir, "minio-storage", "file") @@ -154,7 +154,7 @@ func getDriverChannels(driverType DriverType) (ctrlChans []chan<- string, status { u, err := user.Current() if err != nil { - log.Errorln(iodine.Error(err, nil)) + log.Errorln(iodine.New(err, nil)) return nil, nil, nil } root := path.Join(u.HomeDir, "minio-driver", "donut") @@ -164,7 +164,7 @@ func getDriverChannels(driverType DriverType) (ctrlChans []chan<- string, status } default: // should never happen { - log.Fatal(iodine.Error(errors.New("No driver found"), nil)) + log.Fatal(iodine.New(errors.New("No driver found"), nil)) } } return diff --git a/pkg/storage/donut/bucket.go b/pkg/storage/donut/bucket.go index d45da2373..a898deaac 100644 --- a/pkg/storage/donut/bucket.go +++ b/pkg/storage/donut/bucket.go @@ -26,7 +26,7 @@ func (b donutBucket) AddNode(nodeID, bucketID string) error { errParams := map[string]string{"node": nodeID, "bucketID": bucketID} tokens := strings.Split(bucketID, ":") if len(tokens) != 3 { - return iodine.Error(errors.New("Bucket ID malformeD: "+bucketID), errParams) + return iodine.New(errors.New("Bucket ID malformeD: "+bucketID), errParams) } // bucketName := tokens[0] @@ -34,7 +34,7 @@ func (b donutBucket) AddNode(nodeID, bucketID string) error { // aggregate := "0" part, err := strconv.Atoi(tokens[2]) if err != nil { - return iodine.Error(errors.New("Part malformed: "+tokens[2]), errParams) + return iodine.New(errors.New("Part malformed: "+tokens[2]), errParams) } b.nodes[part] = nodeID return nil diff --git a/pkg/storage/donut/donut.go b/pkg/storage/donut/donut.go index 312497cad..510ea95cf 100644 --- a/pkg/storage/donut/donut.go +++ b/pkg/storage/donut/donut.go @@ -26,7 +26,7 @@ func NewDonut(root string) (Donut, error) { for nodeID, node := range nodes { bucketIDs, err := node.GetBuckets() if err != nil { - return nil, iodine.Error(err, map[string]string{"root": root}) + return nil, iodine.New(err, map[string]string{"root": root}) } for _, bucketID := range bucketIDs { tokens := strings.Split(bucketID, ":") @@ -38,7 +38,7 @@ func NewDonut(root string) (Donut, error) { driver.buckets[tokens[0]] = bucket } if err = driver.buckets[tokens[0]].AddNode(nodeID, bucketID); err != nil { - return nil, iodine.Error(err, map[string]string{"root": root}) + return nil, iodine.New(err, map[string]string{"root": root}) } } } @@ -50,7 +50,7 @@ func (d donut) CreateBucket(bucketName string) error { if _, ok := d.buckets[bucketName]; ok == false { bucketName = strings.TrimSpace(bucketName) if bucketName == "" { - return iodine.Error(errors.New("Cannot create bucket with no name"), map[string]string{"bucket": bucketName}) + return iodine.New(errors.New("Cannot create bucket with no name"), map[string]string{"bucket": bucketName}) } // assign nodes // TODO assign other nodes @@ -60,7 +60,7 @@ func (d donut) CreateBucket(bucketName string) error { if node, ok := d.nodes["localhost"]; ok { err := node.CreateBucket(bucketName + ":0:" + strconv.Itoa(i)) if err != nil { - return iodine.Error(err, map[string]string{"node": nodes[i], "bucket": bucketName}) + return iodine.New(err, map[string]string{"node": nodes[i], "bucket": bucketName}) } } } @@ -70,7 +70,7 @@ func (d donut) CreateBucket(bucketName string) error { d.buckets[bucketName] = bucket return nil } - return iodine.Error(errors.New("Bucket exists"), map[string]string{"bucket": bucketName}) + return iodine.New(errors.New("Bucket exists"), map[string]string{"bucket": bucketName}) } // ListBuckets - list all buckets @@ -89,7 +89,7 @@ func (d donut) GetObjectWriter(bucketName, objectName string) (ObjectWriter, err writers := make([]Writer, 16) nodes, err := bucket.GetNodes() if err != nil { - return nil, iodine.Error(err, map[string]string{"bucket": bucketName, "object": objectName}) + return nil, iodine.New(err, map[string]string{"bucket": bucketName, "object": objectName}) } for i, nodeID := range nodes { if node, ok := d.nodes[nodeID]; ok == true { @@ -98,17 +98,17 @@ func (d donut) GetObjectWriter(bucketName, objectName string) (ObjectWriter, err if err != nil { for _, writerToClose := range writers { if writerToClose != nil { - writerToClose.CloseWithError(iodine.Error(err, nil)) + writerToClose.CloseWithError(iodine.New(err, nil)) } } - return nil, iodine.Error(err, map[string]string{"bucketid": bucketID}) + return nil, iodine.New(err, map[string]string{"bucketid": bucketID}) } writers[i] = writer } } return newErasureWriter(writers), nil } - return nil, iodine.Error(errors.New("Bucket not found"), map[string]string{"bucket": bucketName}) + return nil, iodine.New(errors.New("Bucket not found"), map[string]string{"bucket": bucketName}) } // GetObjectReader - get a new reader interface for a new object @@ -119,7 +119,7 @@ func (d donut) GetObjectReader(bucketName, objectName string) (io.ReadCloser, er readers := make([]io.ReadCloser, 16) nodes, err := bucket.GetNodes() if err != nil { - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } var metadata map[string]string for i, nodeID := range nodes { @@ -128,14 +128,14 @@ func (d donut) GetObjectReader(bucketName, objectName string) (io.ReadCloser, er reader, err := node.GetReader(bucketID, objectName) if err != nil { errParams["node"] = nodeID - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } readers[i] = reader if metadata == nil { metadata, err = node.GetDonutMetadata(bucketID, objectName) if err != nil { errParams["node"] = nodeID - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } } } @@ -143,7 +143,7 @@ func (d donut) GetObjectReader(bucketName, objectName string) (io.ReadCloser, er go erasureReader(readers, metadata, w) return r, nil } - return nil, iodine.Error(errors.New("Bucket not found"), errParams) + return nil, iodine.New(errors.New("Bucket not found"), errParams) } // GetObjectMetadata returns metadata for a given object in a bucket @@ -152,19 +152,19 @@ func (d donut) GetObjectMetadata(bucketName, object string) (map[string]string, if bucket, ok := d.buckets[bucketName]; ok { nodes, err := bucket.GetNodes() if err != nil { - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } if node, ok := d.nodes[nodes[0]]; ok { bucketID := bucketName + ":0:0" metadata, err := node.GetMetadata(bucketID, object) if err != nil { errParams["bucketID"] = bucketID - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } donutMetadata, err := node.GetDonutMetadata(bucketID, object) if err != nil { errParams["bucketID"] = bucketID - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } metadata["sys.created"] = donutMetadata["created"] metadata["sys.md5"] = donutMetadata["md5"] @@ -172,7 +172,7 @@ func (d donut) GetObjectMetadata(bucketName, object string) (map[string]string, return metadata, nil } errParams["node"] = nodes[0] - return nil, iodine.Error(errors.New("Cannot connect to node: "+nodes[0]), errParams) + return nil, iodine.New(errors.New("Cannot connect to node: "+nodes[0]), errParams) } return nil, errors.New("Bucket not found") } @@ -183,14 +183,14 @@ func (d donut) ListObjects(bucketName string) ([]string, error) { if bucket, ok := d.buckets[bucketName]; ok { nodes, err := bucket.GetNodes() if err != nil { - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } if node, ok := d.nodes[nodes[0]]; ok { bucketID := bucketName + ":0:0" objects, err := node.ListObjects(bucketID) errParams["bucketID"] = bucketID - return objects, iodine.Error(err, errParams) + return objects, iodine.New(err, errParams) } } - return nil, iodine.Error(errors.New("Bucket not found"), errParams) + return nil, iodine.New(errors.New("Bucket not found"), errParams) } diff --git a/pkg/storage/donut/erasure.go b/pkg/storage/donut/erasure.go index 341082023..459984fd2 100644 --- a/pkg/storage/donut/erasure.go +++ b/pkg/storage/donut/erasure.go @@ -25,7 +25,7 @@ func getErasureTechnique(technique string) (erasure.Technique, error) { case technique == "Vandermonde": return erasure.Cauchy, nil default: - return erasure.None, iodine.Error(errors.New("Invalid erasure technique: "+technique), nil) + return erasure.None, iodine.New(errors.New("Invalid erasure technique: "+technique), nil) } } @@ -33,45 +33,45 @@ func getErasureTechnique(technique string) (erasure.Technique, error) { func erasureReader(readers []io.ReadCloser, donutMetadata map[string]string, writer *io.PipeWriter) { totalChunks, err := strconv.Atoi(donutMetadata["chunkCount"]) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) return } totalLeft, err := strconv.ParseInt(donutMetadata["size"], 10, 64) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) return } blockSize, err := strconv.Atoi(donutMetadata["blockSize"]) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) return } parsedk, err := strconv.ParseUint(donutMetadata["erasureK"], 10, 8) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) return } k := uint8(parsedk) parsedm, err := strconv.ParseUint(donutMetadata["erasureM"], 10, 8) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) return } m := uint8(parsedm) expectedMd5sum, err := hex.DecodeString(donutMetadata["md5"]) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) return } technique, err := getErasureTechnique(donutMetadata["erasureTechnique"]) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) return } hasher := md5.New() params, err := erasure.ParseEncoderParams(k, m, technique) if err != nil { - writer.CloseWithError(iodine.Error(err, donutMetadata)) + writer.CloseWithError(iodine.New(err, donutMetadata)) } encoder := erasure.NewEncoder(params) for i := 0; i < totalChunks; i++ { @@ -83,12 +83,12 @@ func erasureReader(readers []io.ReadCloser, donutMetadata map[string]string, wri for k, v := range donutMetadata { errParams[k] = v } - writer.CloseWithError(iodine.Error(err, errParams)) + writer.CloseWithError(iodine.New(err, errParams)) } } actualMd5sum := hasher.Sum(nil) if bytes.Compare(expectedMd5sum, actualMd5sum) != 0 { - writer.CloseWithError(iodine.Error(errors.New("decoded md5sum did not match. expected: "+string(expectedMd5sum)+" actual: "+string(actualMd5sum)), donutMetadata)) + writer.CloseWithError(iodine.New(errors.New("decoded md5sum did not match. expected: "+string(expectedMd5sum)+" actual: "+string(actualMd5sum)), donutMetadata)) return } writer.Close() @@ -114,7 +114,7 @@ func decodeChunk(writer *io.PipeWriter, readers []io.ReadCloser, encoder *erasur errParams["part"] = strconv.FormatInt(written, 10) errParams["block.written"] = strconv.FormatInt(written, 10) errParams["block.length"] = strconv.Itoa(curChunkSize) - return totalLeft, iodine.Error(err, errParams) + return totalLeft, iodine.New(err, errParams) } encodedBytes[i] = bytesBuffer.Bytes() } @@ -122,19 +122,19 @@ func decodeChunk(writer *io.PipeWriter, readers []io.ReadCloser, encoder *erasur if err != nil { errParams := map[string]string{} errParams["block.length"] = strconv.Itoa(curChunkSize) - return totalLeft, iodine.Error(err, errParams) + return totalLeft, iodine.New(err, errParams) } _, err = hasher.Write(decodedData) // not expecting errors from hash, will also catch further down on .Sum mismatch in parent if err != nil { errParams := map[string]string{} errParams["block.length"] = strconv.Itoa(curChunkSize) - return totalLeft, iodine.Error(err, errParams) + return totalLeft, iodine.New(err, errParams) } _, err = io.Copy(writer, bytes.NewBuffer(decodedData)) if err != nil { errParams := map[string]string{} errParams["block.length"] = strconv.Itoa(curChunkSize) - return totalLeft, iodine.Error(err, errParams) + return totalLeft, iodine.New(err, errParams) } totalLeft = totalLeft - int64(blockSize) return totalLeft, nil diff --git a/pkg/storage/donut/node_local.go b/pkg/storage/donut/node_local.go index bb4e18da1..6d9f75611 100644 --- a/pkg/storage/donut/node_local.go +++ b/pkg/storage/donut/node_local.go @@ -19,13 +19,13 @@ type localDirectoryNode struct { func (d localDirectoryNode) CreateBucket(bucket string) error { objectPath := path.Join(d.root, bucket) - return iodine.Error(os.MkdirAll(objectPath, 0700), map[string]string{"bucket": bucket}) + return iodine.New(os.MkdirAll(objectPath, 0700), map[string]string{"bucket": bucket}) } func (d localDirectoryNode) GetBuckets() ([]string, error) { files, err := ioutil.ReadDir(d.root) if err != nil { - return nil, iodine.Error(err, nil) + return nil, iodine.New(err, nil) } var results []string for _, file := range files { @@ -41,24 +41,24 @@ func (d localDirectoryNode) GetWriter(bucket, object string) (Writer, error) { objectPath := path.Join(d.root, bucket, object) err := os.MkdirAll(objectPath, 0700) if err != nil { - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } writer, err := newDonutObjectWriter(objectPath) - return writer, iodine.Error(err, errParams) + return writer, iodine.New(err, errParams) } func (d localDirectoryNode) GetReader(bucket, object string) (io.ReadCloser, error) { reader, err := os.Open(path.Join(d.root, bucket, object, "data")) - return reader, iodine.Error(err, map[string]string{"bucket": bucket, "object": object}) + return reader, iodine.New(err, map[string]string{"bucket": bucket, "object": object}) } func (d localDirectoryNode) GetMetadata(bucket, object string) (map[string]string, error) { m, err := d.getMetadata(bucket, object, "metadata.json") - return m, iodine.Error(err, map[string]string{"bucket": bucket, "object": object}) + return m, iodine.New(err, map[string]string{"bucket": bucket, "object": object}) } func (d localDirectoryNode) GetDonutMetadata(bucket, object string) (map[string]string, error) { m, err := d.getMetadata(bucket, object, "donutMetadata.json") - return m, iodine.Error(err, map[string]string{"bucket": bucket, "object": object}) + return m, iodine.New(err, map[string]string{"bucket": bucket, "object": object}) } func (d localDirectoryNode) getMetadata(bucket, object, fileName string) (map[string]string, error) { @@ -66,12 +66,12 @@ func (d localDirectoryNode) getMetadata(bucket, object, fileName string) (map[st file, err := os.Open(path.Join(d.root, bucket, object, fileName)) defer file.Close() if err != nil { - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } metadata := make(map[string]string) decoder := json.NewDecoder(file) if err := decoder.Decode(&metadata); err != nil { - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } return metadata, nil @@ -83,7 +83,7 @@ func (d localDirectoryNode) ListObjects(bucketName string) ([]string, error) { var objects []string if err := filepath.Walk(prefix, func(path string, info os.FileInfo, err error) error { if err != nil { - return iodine.Error(err, errParams) + return iodine.New(err, errParams) } if !info.IsDir() && strings.HasSuffix(path, "data") { object := strings.TrimPrefix(path, prefix+"/") @@ -92,7 +92,7 @@ func (d localDirectoryNode) ListObjects(bucketName string) ([]string, error) { } return nil }); err != nil { - return nil, iodine.Error(err, errParams) + return nil, iodine.New(err, errParams) } sort.Strings(objects) return objects, nil diff --git a/pkg/storage/donut/object_writer.go b/pkg/storage/donut/object_writer.go index 2a3fade98..eb461979a 100644 --- a/pkg/storage/donut/object_writer.go +++ b/pkg/storage/donut/object_writer.go @@ -11,7 +11,7 @@ import ( func newDonutObjectWriter(objectDir string) (Writer, error) { dataFile, err := os.OpenFile(path.Join(objectDir, "data"), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600) if err != nil { - return nil, iodine.Error(err, map[string]string{"objectDir": objectDir}) + return nil, iodine.New(err, map[string]string{"objectDir": objectDir}) } return donutObjectWriter{ root: objectDir, @@ -31,26 +31,26 @@ type donutObjectWriter struct { func (d donutObjectWriter) Write(data []byte) (int, error) { written, err := d.file.Write(data) - return written, iodine.Error(err, nil) + return written, iodine.New(err, nil) } func (d donutObjectWriter) Close() error { if d.err != nil { - return iodine.Error(d.err, nil) + return iodine.New(d.err, nil) } metadata, _ := json.Marshal(d.metadata) ioutil.WriteFile(path.Join(d.root, "metadata.json"), metadata, 0600) donutMetadata, _ := json.Marshal(d.donutMetadata) ioutil.WriteFile(path.Join(d.root, "donutMetadata.json"), donutMetadata, 0600) - return iodine.Error(d.file.Close(), nil) + return iodine.New(d.file.Close(), nil) } func (d donutObjectWriter) CloseWithError(err error) error { if d.err != nil { d.err = err } - return iodine.Error(d.Close(), nil) + return iodine.New(d.Close(), nil) } func (d donutObjectWriter) SetMetadata(metadata map[string]string) error {