fs.go

package com

import (
	"archive/tar"
	"bytes"
	"compress/gzip"
	"crypto/md5"
	"encoding/hex"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"math/rand"
	"os"
	"os/exec"
	"os/user"
	"path/filepath"
	"runtime"
	"strings"

	"github.com/martinlindhe/base36"
)

var (
	base36map = map[rune]int{
		'0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
		'5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
		'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14,
		'F': 15, 'G': 16, 'H': 17, 'I': 18, 'J': 19,
		'K': 20, 'L': 21, 'M': 22, 'N': 23, 'O': 24,
		'P': 25, 'Q': 26, 'R': 27, 'S': 28, 'T': 29,
		'U': 30, 'V': 31, 'W': 32, 'X': 33, 'Y': 34,
		'Z': 35,
	}
	base36mix = []rune{
		'L', '9', 'M', 'U', '7', 'B', '2', 'H', 'S', '3',
		'O', 'R', 'I', 'G', '5', 'K', 'Q', '6', 'J', 'T',
		'0', 'Y', 'N', '8', 'F', 'P', 'E', 'A', '1', 'Z',
		'D', 'W', 'V', 'X', '4', 'C',
	}
)

// PathExist 检查文件或目录是否存在
// 如果由 filename 指定的文件或目录存在则返回 true，否则返回 false
func PathExist(filename string) bool {
	_, err := os.Stat(filename)
	return err == nil || os.IsExist(err)
}

// ReadFileByte 读取文件
func ReadFileByte(path string) ([]byte, error) {
	fi, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer fi.Close()
	return ioutil.ReadAll(fi)
}

// ReadFileString 读取文本文件
func ReadFileString(path string) (string, error) {
	fi, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer fi.Close()
	fd, err := ioutil.ReadAll(fi)
	return string(fd), err
}

// ReadFile 读取文本文件
func ReadFile(path string) (string, error) {
	fi, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer fi.Close()
	fd, err := ioutil.ReadAll(fi)

	return string(fd), err
}

// FileExist 检查文件或目录是否存在
// 如果由 filename 指定的文件或目录存在则返回 true，否则返回 false
func FileExist(filename string) bool {
	_, err := os.Stat(filename)
	return err == nil || os.IsExist(err)
}

// WriteFile 字符串写入文件
func WriteFile(fullpath string, str string) error {
	data := []byte(str)
	return ioutil.WriteFile(fullpath, data, 0644)
}

// WriteFile 字符串写入文件追加
func WriteFileAppend(fullpath string, str string) error {
	data := []byte(str)
	return writeFileAppend(fullpath, data, 0644)
}

func writeFileAppend(filename string, data []byte, perm os.FileMode) error {
	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, perm)
	if err != nil {
		return err
	}
	n, err := f.Write(data)
	if err == nil && n < len(data) {
		err = io.ErrShortWrite
	}
	if err1 := f.Close(); err == nil {
		err = err1
	}
	return err
}

// Mkdir 创建文件夹
func Mkdir(path string) error {
	return os.Mkdir(path, os.ModePerm)
}

// Copyfile
func CopyFile(dstName, srcName string) (written int64, err error) {
	src, err := os.Open(srcName)
	if err != nil {
		return
	}
	defer src.Close()
	dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		return
	}
	defer dst.Close()
	return io.Copy(dst, src)
}

func MkdirWithCreatePath(fullpath string) error {
	dirArray := strings.Split(fullpath, string(filepath.Separator))
	if len(dirArray) < 1 {
		return errors.New("fullpath mistake")
	} else if len(dirArray) == 1 {
		Mkdir(fullpath)
		return nil
	}

	path := ""
	var err error = nil
	for i := 0; i < len(dirArray); i++ {
		dir := dirArray[i]
		path = path + string(filepath.Separator) + dir
		p := SubString(path, 1, len(path)-1)
		if !PathExist(p) {
			err = Mkdir(p)
		}
	}

	return err
}

// 写入文件，若目录不存在则自动创建
func WriteFileWithCreatePath(fullpath string, str string) error {
	fileDir := ""
	var err error = nil
	if !FileExist(fullpath) {
		fileDir = filepath.Dir(fullpath)
		err = MkdirWithCreatePath(fileDir)
	}
	err = WriteFile(fullpath, str)

	return err
}

// 写入文件，若目录不存在则自动创建，若存在文件则追加
func WriteFileAppendWithCreatePath(fullpath string, str string) error {
	fileDir := ""
	var err error = nil
	if !FileExist(fullpath) {
		fileDir = filepath.Dir(fullpath)
		err = MkdirWithCreatePath(fileDir)
	}
	err = WriteFileAppend(fullpath, str)

	return err
}

// 获取用户目录
func Home() (string, error) {
	user, err := user.Current()
	if nil == err {
		return user.HomeDir, nil
	}

	// cross compile support

	if "windows" == runtime.GOOS {
		return homeWindows()
	}

	// Unix-like system, so just assume Unix
	return homeUnix()
}

func homeUnix() (string, error) {
	// First prefer the HOME environmental variable
	if home := os.Getenv("HOME"); home != "" {
		return home, nil
	}

	// If that fails, try the shell
	var stdout bytes.Buffer
	cmd := exec.Command("sh", "-c", "eval echo ~$USER")
	cmd.Stdout = &stdout
	if err := cmd.Run(); err != nil {
		return "", err
	}

	result := strings.TrimSpace(stdout.String())
	if result == "" {
		return "", errors.New("blank output when reading home directory")
	}

	return result, nil
}

func homeWindows() (string, error) {
	drive := os.Getenv("HOMEDRIVE")
	path := os.Getenv("HOMEPATH")
	home := drive + path
	if drive == "" || path == "" {
		home = os.Getenv("USERPROFILE")
	}
	if home == "" {
		return "", errors.New("HOMEDRIVE, HOMEPATH, and USERPROFILE are blank")
	}

	return home, nil
}

// Dir 获取路径所在目录
func Dir(fullpath string) string {
	unixPath := strings.Replace(fullpath, fmt.Sprintf("%c", filepath.Separator), "/", -1)
	return strings.Replace(filepath.Dir(unixPath), "/", fmt.Sprintf("%c", filepath.Separator), -1)
}

// 解压 tar.gz
func UnpackTar(fpath string, dist string) error {
	if fpath == "" {
		return fmt.Errorf("empty input")
	}

	_ = os.Mkdir(dist, 0755)

	f, err := os.Open(fpath)
	if err != nil {
		return err
	}
	defer f.Close()

	gzf, err := gzip.NewReader(f)
	if err != nil {
		return err
	}

	tarReader := tar.NewReader(gzf)

	for true {
		header, err := tarReader.Next()

		if err == io.EOF {
			break
		}

		if err != nil {
			return err
		}

		name := filepath.Join(dist, header.Name)

		switch header.Typeflag {
		case tar.TypeDir:
			if err := os.MkdirAll(name, header.FileInfo().Mode()); err != nil {
				return err
			}
		case tar.TypeReg:
			outFile, err := os.Create(name)
			if err != nil {
				return err
			}
			defer outFile.Close()
			if _, err := io.Copy(outFile, tarReader); err != nil {
				return err
			}
		default:
			return fmt.Errorf(
				"ExtractTarGz: uknown type: %d in %s",
				header.Typeflag,
				name)
		}
	}
	return nil
}

// 计算文件MD5
func FileMD5(fpath string) string {
	file, err := os.OpenFile(fpath, os.O_RDONLY, 0755)
	if err != nil {
		log.Println("get md5 err:", err.Error())
		return ""
	}
	defer file.Close()

	buf := md5.New()
	io.Copy(buf, file)

	return hex.EncodeToString(buf.Sum(nil))
}

// GenSuid 生成随机短号
func GenSuid() string {
	uidMin := base36.Decode("10000000")
	uidMax := base36.Decode("zzzzzzzz")
	uid := rand.Intn(int(uidMax-uidMin)) + int(uidMin)
	b36s := base36.Encode(uint64(uid))
	mb36b := bytes.Buffer{}
	for _, c := range b36s {
		idx := base36map[c]
		mb36b.WriteRune(base36mix[idx])
	}
	return strings.ToLower(mb36b.String())
}