MyFavMirrors/minio
1
0
Fork 0
mirror of https://github.com/minio/minio.git synced 2025-11-07 12:52:58 -05:00
Code Issues Packages Projects Releases Wiki Activity

Updating iodine to match new api

Browse Source
This commit is contained in:
Frederick F. Kautz IV
2015-03-26 15:55:06 -07:00
parent ebc1e062a9
commit 53439d7768
11 changed files with 76 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/storage/donut/bucket.go
View File

@@ -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

40
pkg/storage/donut/donut.go
View File

@@ -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)
}

30
pkg/storage/donut/erasure.go
View File

@@ -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

22
pkg/storage/donut/node_local.go
View File

@@ -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

10
pkg/storage/donut/object_writer.go
View File

@@ -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 {