utils/file-util.go

// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
// All rights reserved.

// file_util.go
package utils

import (
	"bytes"
	"crypto/md5"
	"errors"
	"fmt"
	"io"
	"os"
	"path"
	"strconv"
	"strings"
)

func FileSize(filePath string) (size int64) {
	info, err := os.Stat(filePath)
	if err == nil {
		size = info.Size()
	} else {
		size = -1
	}
	return
}

// Return true if filePath exists
func FileExists(filePath string) bool {
	_, osErr := os.Stat(filePath)
	return osErr == nil || osErr == os.ErrExist
}

// Return true if filePath exists and it is a regular file
func IsRegularFile(filePath string) bool {
	if filePath != "" {
		info, err := os.Stat(filePath)
		// return (err == nil || os.IsExist(err)) && info.Mode().IsRegular()
		return (err == nil || errors.Is(err, os.ErrExist)) && info.Mode().IsRegular()
	}
	return false
}

func IsDirectory(filePath string) bool {
	if filePath != "" {
		info, err := os.Stat(filePath)
		return (err == nil || errors.Is(err, os.ErrExist)) && info.Mode().IsDir()
	}
	return false
}

func IsSymLink(filePath string) bool {
	if filePath != "" {
		info, err := os.Stat(filePath)
		return (err == nil || errors.Is(err, os.ErrExist)) && (info.Mode()&os.ModeSymlink != 0)
	}
	return false
}

func IsSocket(filePath string) bool {
	if filePath != "" {
		info, err := os.Stat(filePath)
		return (err == nil || errors.Is(err, os.ErrExist)) && (info.Mode()&os.ModeSocket != 0)
	}
	return false
}

func IsNamedPipe(filePath string) bool {
	if filePath != "" {
		info, err := os.Stat(filePath)
		return (err == nil || errors.Is(err, os.ErrExist)) && (info.Mode()&os.ModeNamedPipe != 0)
	}
	return false
}

func IsSymLinkByDirEntry(e os.DirEntry) bool {
	info, _ := e.Info()
	return info.Mode()&os.ModeSymlink != 0
}

func StreamIsTerminal(fh *os.File) bool {
	var isTerminal bool = false
	if fh != nil {
		fi, _ := fh.Stat()
		isTerminal = (fi.Mode() & os.ModeCharDevice) != 0
	}
	return isTerminal
}

/*
 * Ispirata a https://stackoverflow.com/a/50741908
 */
func MoveFile(sourcePath, destPath string) (int64, error) {
	var size int64 = 0

	err := os.Rename(sourcePath, destPath)
	if err != nil {
		inputFile, err := os.Open(sourcePath)
		if err != nil {
			return 0, fmt.Errorf("couldn't open source file: %s", err)
		}
		outputFile, err := os.Create(destPath)
		if err != nil {
			inputFile.Close()
			return 0, fmt.Errorf("couldn't open dest file: %s", err)
		}
		defer outputFile.Close()
		size, err = io.Copy(outputFile, inputFile)
		inputFile.Close()
		if err != nil {
			return 0, fmt.Errorf("failed writing to output file: %s", err)
		}
		// The copy was successful, so now delete the original file
		err = os.Remove(sourcePath)
		if err != nil {
			return 0, fmt.Errorf("failed removing original file: %s", err)
		}
	}
	return size, nil
}

func ParseMemSize(s string) (size int64, err error) {
	const MULTIPLES = "BKMGTP"
	// s = strings.TrimSpace(s)
	if len(s) != 0 {
		s = strings.ToUpper(s)
		s = strings.ReplaceAll(s, ".", "")
		s = strings.ReplaceAll(s, ",", "")
		s = strings.ReplaceAll(s, " ", "")
		pos := strings.IndexAny(s, MULTIPLES)
		if pos >= 0 {
			size, err = strconv.ParseInt(s[0:pos], 10, 64)
			mul := strings.IndexByte(MULTIPLES, s[pos])
			for ; mul > 0; mul-- {
				size = size * 1_000
			}
		} else {
			size, err = strconv.ParseInt(s, 10, 64)
		}
	} else {
		err = errors.New("empty string")
	}
	return
}

func CopyFileWithParent(src, dst string, perm os.FileMode) (int64, error) {
	parent := path.Dir(dst)
	if err := os.MkdirAll(parent, 0775); err != nil {
		return 0, err
	}
	return CopyFile(src, dst, perm)
}

func CopyFile(src, dst string, perm os.FileMode) (int64, error) {
	sourceFileStat, err := os.Stat(src)
	if err != nil {
		return 0, err
	}

	if !sourceFileStat.Mode().IsRegular() {
		return 0, fmt.Errorf("%s is not a regular file", src)
	}

	source, err := os.Open(src)
	if err != nil {
		return 0, err
	}
	defer source.Close()

	destination, err := os.Create(dst)
	if err != nil {
		return 0, err
	}
	defer destination.Close()

	if perm != 0 {
		os.Chmod(dst, perm)
	}
	nBytes, err := io.Copy(destination, source)
	return nBytes, err
}

func CompareFilesByMd5(filePath1, filePath2 string) (same bool, err error) {
	var fh1, fh2 *os.File

	if fh1, err = os.Open(filePath1); err != nil {
		return
	}
	defer fh1.Close()

	if fh2, err = os.Open(filePath2); err != nil {
		return
	}
	defer fh2.Close()

	h1 := md5.New()
	if _, err = io.Copy(h1, fh1); err != nil {
		return
	}

	h2 := md5.New()
	if _, err = io.Copy(h2, fh2); err != nil {
		return
	}

	s1 := h1.Sum(nil)
	s2 := h2.Sum(nil)
	same = bytes.Equal(s1, s2)
	// same = bytes.Equal(h1.Sum(nil), h2.Sum(nil))
	return
}

// <0 = first newer than second
// =0 = same date
// >1 = first older than second
func CompareLastChangeTime(first, second string) (result int, err error) {
	var info os.FileInfo

	if info, err = os.Stat(first); err != nil {
		return
	}

	if info, err = os.Stat(second); err != nil {
		return
	}

	tFirst := info.ModTime()
	tSecond := info.ModTime()
	if tFirst.After(tSecond) {
		result = -1
	} else if tFirst.Before(tSecond) {
		result = 1
	} else {
		result = 0
	}
	return
}

func LoadFile(filePath string) (data []byte, err error) {
	data, err = os.ReadFile(filePath)
	if err != nil {
		err = fmt.Errorf("error reading file %q: %w", filePath, err)
	}
	return
}