utils.go

// Copyright (C) 2013-2017, The MetaCurrency Project (Eric Harris-Braun, Arthur Brock, et. al.)
// Use of this source code is governed by GPLv3 found in the LICENSE file
//----------------------------------------------------------------------------------------
// non exported utility functions for Holochain package

package holochain

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/BurntSushi/toml"
	"github.com/ghodss/yaml"
	"io"
	"io/ioutil"
	"os"
)

func writeToml(path string, file string, data interface{}, overwrite bool) error {
	p := path + "/" + file
	if !overwrite && fileExists(p) {
		return mkErr(path + " already exists")
	}
	f, err := os.Create(p)
	if err != nil {
		return err
	}

	defer f.Close()
	enc := toml.NewEncoder(f)
	err = enc.Encode(data)
	return err
}

func writeFile(path string, file string, data []byte) error {
	p := path + "/" + file
	if fileExists(p) {
		return mkErr(p + " already exists")
	}
	f, err := os.Create(p)
	if err != nil {
		return err
	}
	defer f.Close()

	l, err := f.Write(data)
	if err != nil {
		return err
	}

	if l != len(data) {
		return mkErr("unable to write all data")
	}
	f.Sync()
	return err
}

func readFile(path string, file string) (data []byte, err error) {
	p := path + "/" + file
	data, err = ioutil.ReadFile(p)
	return data, err
}

func mkErr(err string) error {
	return errors.New("holochain: " + err)
}

func dirExists(name string) bool {
	info, err := os.Stat(name)
	return err == nil && info.Mode().IsDir()
}

func fileExists(path string) bool {
	info, err := os.Stat(path)
	if err != nil {
		return false
	}
	return info.Mode().IsRegular()
}

// CopyDir recursively copies a directory tree, attempting to preserve permissions.
// Source directory must exist, destination directory must *not* exist.
func CopyDir(source string, dest string) (err error) {

	// get properties of source dir
	fi, err := os.Stat(source)
	if err != nil {
		return err
	}

	if !fi.IsDir() {
		return errors.New("Source is not a directory")
	}

	// ensure dest dir does not already exist

	_, err = os.Open(dest)
	if !os.IsNotExist(err) {
		return fmt.Errorf("Destination (%s) already exists", dest)
	}

	// create dest dir

	err = os.MkdirAll(dest, fi.Mode())
	if err != nil {
		return err
	}

	entries, err := ioutil.ReadDir(source)

	for _, entry := range entries {

		sfp := source + "/" + entry.Name()
		dfp := dest + "/" + entry.Name()
		if entry.IsDir() {
			err = CopyDir(sfp, dfp)
			if err != nil {
				return err
			}
		} else {
			// perform copy
			err = CopyFile(sfp, dfp)
			if err != nil {
				return err
			}
		}

	}
	return
}

// CopyFile copies file source to destination dest.
func CopyFile(source string, dest string) (err error) {
	sf, err := os.Open(source)
	if err != nil {
		return err
	}
	defer sf.Close()
	df, err := os.Create(dest)
	if err != nil {
		return err
	}
	defer df.Close()
	_, err = io.Copy(df, sf)
	if err == nil {
		var si os.FileInfo
		si, err = os.Stat(source)
		if err == nil {
			err = os.Chmod(dest, si.Mode())
		}
	}
	return
}

// Encode encodes data to the writer according to the given format
func Encode(writer io.Writer, format string, data interface{}) (err error) {
	switch format {
	case "toml":
		enc := toml.NewEncoder(writer)
		err = enc.Encode(data)

	case "json":
		enc := json.NewEncoder(writer)
		enc.SetIndent("", "    ")
		err = enc.Encode(data)

	case "yaml":
		y, e := yaml.Marshal(data)
		if e != nil {
			err = e
			return
		}
		n, e := writer.Write(y)
		if e != nil {
			err = e
			return
		}
		if n != len(y) {
			err = errors.New("unable to write all bytes while encoding")
		}

	default:
		err = errors.New("unknown encoding format: " + format)
	}
	return
}

// Decode extracts data from the reader according to the type
func Decode(reader io.Reader, format string, data interface{}) (err error) {
	switch format {
	case "toml":
		_, err = toml.DecodeReader(reader, data)

	case "json":
		dec := json.NewDecoder(reader)
		err = dec.Decode(data)
	case "yaml":
		y, e := ioutil.ReadAll(reader)
		if e != nil {
			err = e
			return
		}
		err = yaml.Unmarshal(y, data)
	default:
		err = errors.New("unknown encoding format: " + format)
	}
	return
}