Implement commands

Commands implemented

   $ minio put <objectname> <file>
   $ minio encode <objectname>
   $ minio get <objectname>
   $ minio list

TODO :

   $ minio init
   $ minio verify
    ...
    ...

pkgs/minio/common.go

@@ -0,0 +1,103 @@
+package minio
+
+import (
+	"errors"
+	"log"
+	"os"
+	"os/user"
+	"path"
+	"strconv"
+	"strings"
+
+	"github.com/codegangsta/cli"
+	"github.com/minio-io/minio/pkgs/strbyteconv"
+)
+
+// config representing cli input
+type inputConfig struct {
+	k          int
+	m          int
+	blockSize  uint64
+	rootDir    string
+	stagingDir string
+}
+
+// parses input and returns an inputConfig with parsed input
+func parseInput(c *cli.Context) (inputConfig, error) {
+	var k, m int
+	if c.String("protection-level") != "" {
+		protectionLevel := c.String("protection-level")
+		protectionLevelSplit := strings.Split(protectionLevel, ",")
+		if len(protectionLevelSplit) != 2 {
+			return inputConfig{}, errors.New("Malformed input for protection-level")
+		}
+
+		var err error
+		k, err = strconv.Atoi(protectionLevelSplit[0])
+		if err != nil {
+			return inputConfig{}, err
+		}
+		m, err = strconv.Atoi(protectionLevelSplit[1])
+		if err != nil {
+			return inputConfig{}, err
+		}
+	}
+
+	var blockSize uint64
+	blockSize = 0
+	if c.String("block-size") != "" {
+		if c.String("block-size") != "full" {
+			var err error
+			blockSize, err = strbyteconv.StringToBytes(c.String("block-size"))
+			if err != nil {
+				return inputConfig{}, err
+			}
+		}
+	}
+
+	var rootDir string
+	if c.String("root") != "" {
+		rootDir = c.String("root")
+	}
+
+	var stagingDir string
+	if c.String("staging") != "" {
+		stagingDir = c.String("staging")
+	}
+
+	config := inputConfig{
+		k:          k,
+		m:          m,
+		blockSize:  blockSize,
+		rootDir:    rootDir,
+		stagingDir: stagingDir,
+	}
+	return config, nil
+}
+
+func Getobjectdir(basename string) string {
+	user, err := user.Current()
+	if err != nil {
+		log.Fatal(err)
+	}
+	homePath := user.HomeDir
+	minioPath := path.Join(homePath, basename)
+	err = _initDir(minioPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return minioPath
+}
+
+func _initDir(dirPath string) error {
+	_, err := os.Lstat(dirPath)
+	if err != nil {
+		log.Printf("%s not found, creating a new-one for the first time",
+			dirPath)
+		err = os.MkdirAll(dirPath, 0700)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

pkgs/minio/encode.go

@@ -0,0 +1,37 @@
+package minio
+
+import (
+	"log"
+
+	"github.com/codegangsta/cli"
+)
+
+func Encode(c *cli.Context) {
+	config, err := parseInput(c)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var objectName string
+	switch len(c.Args()) {
+	case 1:
+		objectName = c.Args().Get(0)
+	default:
+		log.Fatal("Please specify a valid object name \n # erasure-demo encode [OBJECTNAME]")
+	}
+
+	// Get from staging area
+	stagingConfig := config
+	stagingConfig.k = 2
+	stagingConfig.m = 1
+	stagingConfig.rootDir = config.stagingDir
+	reader, err := erasureGet(stagingConfig, objectName)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Increase parity to user defined or default 10,6
+	err = erasurePut(config, objectName, reader)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

pkgs/minio/erasure.go

@@ -0,0 +1,58 @@
+package minio
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"os"
+
+	"github.com/minio-io/minio/pkgs/storage"
+	es "github.com/minio-io/minio/pkgs/storage/encodedstorage"
+)
+
+func erasureGetList(config inputConfig, objectPath string) (io.Reader, error) {
+	var objectStorage storage.ObjectStorage
+	objectStorage, err := es.NewStorage(config.rootDir, config.k, config.m, config.blockSize)
+	if err != nil {
+		return nil, err
+	}
+	objectDescList, err := objectStorage.List(objectPath)
+	if err != nil {
+		return nil, err
+	}
+	var objectDescListBytes []byte
+	if objectDescListBytes, err = json.Marshal(objectDescList); err != nil {
+		return nil, err
+	}
+	objectDescListBuffer := bytes.NewBuffer(objectDescListBytes)
+
+	return objectDescListBuffer, nil
+}
+
+func erasureGet(config inputConfig, objectPath string) (io.Reader, error) {
+	var objectStorage storage.ObjectStorage
+	objectStorage, err := es.NewStorage(config.rootDir, config.k, config.m, config.blockSize)
+	if err != nil {
+		return nil, err
+	}
+	object, err := objectStorage.Get(objectPath)
+	if err != nil {
+		return nil, err
+	}
+	return object, nil
+}
+
+func erasurePut(config inputConfig, objectPath string, reader io.Reader) error {
+	var err error
+	if err := os.MkdirAll(config.rootDir, 0700); err != nil {
+		return err
+	}
+	var objectStorage storage.ObjectStorage
+	if objectStorage, err = es.NewStorage(config.rootDir, config.k, config.m, config.blockSize); err != nil {
+		return err
+	}
+	if err = objectStorage.Put(objectPath, reader); err != nil {
+		return err
+	}
+	return nil
+}

pkgs/minio/get.go

@@ -0,0 +1,30 @@
+package minio
+
+import (
+	"io"
+	"log"
+	"os"
+
+	"github.com/codegangsta/cli"
+)
+
+func Get(c *cli.Context) {
+	config, err := parseInput(c)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var objectName string
+	var objectReader io.Reader
+	switch len(c.Args()) {
+	case 1:
+		objectName = c.Args().Get(0)
+	default:
+		log.Fatal("Please specify a valid object name \n # erasure-demo get [OBJECTNAME]")
+	}
+
+	if objectReader, err = erasureGet(config, objectName); err != nil {
+		log.Fatal(err)
+	}
+
+	io.Copy(os.Stdout, objectReader)
+}

pkgs/minio/init.go

@@ -0,0 +1 @@
+package minio

pkgs/minio/list.go

@@ -0,0 +1,24 @@
+package minio
+
+import (
+	"io"
+	"log"
+	"os"
+
+	"github.com/codegangsta/cli"
+)
+
+func List(c *cli.Context) {
+	config, err := parseInput(c)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	config.k = 10
+	config.m = 6
+	reader, err := erasureGetList(config, "")
+	if err != nil {
+		log.Fatal(err)
+	}
+	io.Copy(os.Stdout, reader)
+}

pkgs/minio/put.go

@@ -0,0 +1,43 @@
+package minio
+
+import (
+	"log"
+	"os"
+	"path"
+
+	"github.com/codegangsta/cli"
+)
+
+func Put(c *cli.Context) {
+	config, err := parseInput(c)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var filePath, objectName string
+	switch len(c.Args()) {
+	case 1:
+		objectName = path.Base(c.Args().Get(0))
+		filePath = c.Args().Get(0)
+	case 2:
+		objectName = c.Args().Get(0)
+		filePath = c.Args().Get(1)
+	default:
+		log.Fatal("Please specify a valid object name \n # erasure-demo put [OBJECTNAME] [FILENAME]")
+	}
+	inputFile, err := os.Open(filePath)
+	defer inputFile.Close()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Staging parity
+	stagingConfig := config
+	stagingConfig.k = 2
+	stagingConfig.m = 1
+	stagingConfig.rootDir = config.stagingDir
+
+	if err := erasurePut(stagingConfig, objectName, inputFile); err != nil {
+		log.Fatal(err)
+	}
+
+}

pkgs/minio/verify.go

@@ -0,0 +1 @@
+package minio

pkgs/storage/appendstorage/append_storage.go

@@ -80,7 +80,7 @@ func NewStorage(rootDir string, slice int) (storage.ObjectStorage, error) {
 func (storage *appendStorage) Get(objectPath string) (io.Reader, error) {
 	header, ok := storage.objects[objectPath]
 	if ok == false {
-		return nil, nil
+		return nil, errors.New("Object not found")
 	}
 
 	offset := header.Offset

pkgs/storage/encodedstorage/encoded_storage.go

@@ -110,7 +110,7 @@ func NewStorage(rootDir string, k, m int, blockSize uint64) (storage.ObjectStora
 func (eStorage *encodedStorage) Get(objectPath string) (io.Reader, error) {
 	entry, ok := eStorage.objects[objectPath]
 	if ok == false {
-		return nil, nil
+		return nil, errors.New("Object not found")
 	}
 	reader, writer := io.Pipe()
 	go eStorage.readObject(objectPath, entry, writer)