starting to write the manager library

common/engine/filesystem.go

@@ -0,0 +1,140 @@
+package engine
+
+import (
+	"bytes"
+	"compress/gzip"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	logger "github.com/apsdehal/go-logger"
+)
+
+var log *logger.Logger
+
+func init() {
+	var err error
+	log, err = logger.New("utilities logger", 1, os.Stdout)
+	if err != nil {
+		panic(err)
+	}
+	log.SetFormat("[%{module}] [%{level}] %{message}")
+	log.Info("Utilities logger Created")
+}
+
+// CompressIntArray compresses an array of integers into a buffer
+func CompressIntArray(arry []int64, compressionBuffer *bytes.Buffer) (float64, error) {
+	buf := new(bytes.Buffer)
+	err := binary.Write(buf, binary.LittleEndian, arry)
+	if err != nil {
+		return 0, err
+	}
+	//now compress it
+	compressor := gzip.NewWriter(compressionBuffer)
+	// if err != nil {
+	// 	fmt.Println("writer level failed to set compression level")
+	// }
+	if _, err := compressor.Write(buf.Bytes()); err != nil {
+		return 0, err
+	}
+	if err := compressor.Close(); err != nil {
+		return 0, err
+	}
+	ratio := float64(len(compressionBuffer.Bytes())) / float64(len(buf.Bytes()))
+	return ratio, nil
+}
+
+// ExpandToIntArray firstly unzips the byte array, then it
+// converts the byte array back into an int array for use
+func ExpandToIntArray(length int64, arry []byte, intArray *[]int64) error {
+	buf := bytes.NewBuffer(arry)
+	if reader, err := gzip.NewReader(buf); err != nil {
+		fmt.Println("gzip failed ", err)
+		return err
+	} else {
+		*intArray = make([]int64, length) //you must know the length of the original data if you are to do it this way.
+		err := binary.Read(reader, binary.LittleEndian, intArray)
+		if err != nil {
+			fmt.Println("read failed ", err)
+		}
+		return nil
+	}
+}
+
+// VerifySrcFile checks to see that the file is a regular file
+// that the OS has meta information about and that can be read by
+// the os.
+func VerifySrcFile(src string) (string, error) {
+	_, fileName := filepath.Split(src) //dirPath
+	sourceFileStat, err := os.Stat(src)
+	if err != nil {
+		return fileName, errors.New("error on os.Stat " + err.Error())
+	}
+
+	if !sourceFileStat.Mode().IsRegular() {
+		return fileName, errors.New("%s is not a regular file" + src)
+	}
+	return fileName, nil
+}
+
+func InitiateDirectory(directory string) {
+	// For the keys-folder we need to check if the folder exists...
+	checkDir, err := IsDirectory(directory)
+	if err != nil {
+		log.ErrorF("Error checking for "+directory+" directory: %s\r\n", err)
+		panic(err)
+	}
+
+	if checkDir == true {
+		log.Warning(directory + " already exists")
+	} else {
+		// Create the directory.
+		log.Info("Creating " + directory)
+		err = CreateDirectory(directory)
+		if err != nil {
+			log.ErrorF("Error creating the folder %s\r\n", err)
+		}
+	}
+}
+
+func IsDirectory(path string) (bool, error) {
+
+	s, err := os.Stat(path) // returns an error if the path does not exist.
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err // Different error...?
+	}
+
+	if s.IsDir() {
+		return true, nil
+	}
+
+	return false, nil // Redundancy
+
+}
+
+func CreateDirectory(path string) error {
+	// Assumes checks have been done on if the directory exists...
+	err := os.MkdirAll(path, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	return nil // Redundancy
+
+}
+
+func DeleteDirectory(path string) error {
+	err := os.RemoveAll(path)
+	return err
+
+}
+
+//TODO: Most likely can be done with the filepath command so replace this everywhere
+func StripFilePathBase(pathToFile, base string) string {
+	return strings.Replace(pathToFile, base, "", -1)
+}