cicv_data_closed_loop/common/util/u_io.go

package util

import (
	"bytes"
	"fmt"
	"io"
	"io/fs"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strings"
)

// 压缩指定目录到ZIP文件，并排除一个指定的子目录
func ZipDir(src, dest string, excludeDirs []string) error {
	// 构造排除参数的字符串
	excludeArgs := make([]string, 0, len(excludeDirs))
	for _, excludeDir := range excludeDirs {
		relExcludeDir, err := filepath.Rel(src, excludeDir)
		if err != nil {
			return err
		}
		// 确保排除路径以 '*' 结尾，以匹配目录下的所有内容
		excludeArgs = append(excludeArgs, filepath.Join(relExcludeDir, "*"))
	}

	// 拼接 -x 参数
	excludeStr := strings.Join(excludeArgs, " -x ")

	// 构建zip命令
	cmd := exec.Command("zip", append([]string{"-r", dest, "."}, strings.Split(excludeStr, " ")...)...)

	// 设置工作目录为要压缩的源目录
	cmd.Dir = src

	// 捕获命令的标准输出和标准错误输出
	var out bytes.Buffer
	cmd.Stdout = &out
	cmd.Stderr = &out

	// 运行命令
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("zip command failed: %v, output: %s", err, out.String())
	}

	return nil
}

func GetFileSize(filePath string) (int, error) {
	fileInfo, err := os.Stat(filePath)
	if err != nil {
		return 0, err
	}
	return int(fileInfo.Size()), nil
}

func CheckSoFilesInDirectory(dirPath string) (bool, []string) {
	hasSoFile := false
	soFilePaths := make([]string, 0)
	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
		fmt.Println("Directory does not exist:", dirPath)
		return false, soFilePaths
	}

	err := filepath.Walk(dirPath, func(path string, info fs.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}

		if filepath.Ext(path) == ".so" {
			hasSoFile = true
			soFilePaths = append(soFilePaths, path)
		}
		return nil
	})

	if err != nil {
		fmt.Println("Error walking the directory:", err)
		os.Exit(1)
	}

	return hasSoFile, soFilePaths
}

func GetFirstLevelSubdirectories(dirPath string) []string {
	dirEntries, _ := os.ReadDir(dirPath)
	subdirectories := make([]string, 0)
	for _, entry := range dirEntries {
		if entry.IsDir() {
			subdirectories = append(subdirectories, entry.Name())
		}
	}
	return subdirectories
}

func GetFileNameWithoutExtension(absPath string) string {
	file := filepath.Base(absPath)
	ext := filepath.Ext(file)
	return strings.TrimSuffix(file, ext)
}

func GetSoFilePaths(dir string) []string {
	var paths []string
	err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
		if err == nil && !info.IsDir() && filepath.Ext(path) == ".so" {
			absPath, _ := filepath.Abs(path)
			paths = append(paths, absPath)
		}
		return nil
	})
	if err != nil {
		fmt.Println("Error:", err)
		return nil
	}
	return paths
}

// CreateDir 创建目录
func CreateDir(directory string) {
	if _, err := os.Stat(directory); os.IsNotExist(err) {
		_ = os.MkdirAll(directory, os.ModePerm)
	}
}

// CreateParentDir 存在不创建，不存在则创建父目录
func CreateParentDir(filePath string) error {
	if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
		return err
	}
	return nil
}

// RemoveDir 递归删除目录及其下的所有文件和子目录
func RemoveDir(dirPath string) error {
	// 打开目录
	dir, err := os.Open(dirPath)
	if err != nil {
		return err
	}
	defer dir.Close()
	// 读取目录下的文件和子目录
	fileInfos, err := dir.Readdir(-1)
	if err != nil {
		return err
	}
	// 遍历文件和子目录
	for _, fileInfo := range fileInfos {
		path := filepath.Join(dirPath, fileInfo.Name())

		if fileInfo.IsDir() {
			// 如果是子目录，递归调用removeDir删除子目录及其下的文件和子目录
			if err = RemoveDir(path); err != nil {
				return err
			}
		} else {
			// 如果是文件，直接删除文件
			if err = os.Remove(path); err != nil {
				return err
			}
		}
	}
	// 删除目录本身
	if err = os.Remove(dirPath); err != nil {
		return err
	}
	return nil
}

// RemoveSubFiles 递归删除目录及其下的所有文件和子目录
func RemoveSubFiles(dirPath string) error {
	// 打开目录
	dir, err := os.Open(dirPath)
	if err != nil {
		return err
	}
	defer dir.Close()
	// 读取目录下的文件和子目录
	fileInfos, err := dir.Readdir(-1)
	if err != nil {
		return err
	}
	// 遍历文件和子目录
	for _, fileInfo := range fileInfos {
		path := filepath.Join(dirPath, fileInfo.Name())

		if fileInfo.IsDir() {
			// 如果是子目录，递归调用removeDir删除子目录及其下的文件和子目录
			if err = RemoveDir(path); err != nil {
				return err
			}
		} else {
			// 如果是文件，直接删除文件
			if err = os.Remove(path); err != nil {
				return err
			}
		}
	}
	return nil
}

func WriteFile(sourceContent string, targetFilePath string) error {
	if err := CreateFile(targetFilePath); err != nil {
		return err
	}
	if err := os.WriteFile(targetFilePath, []byte(sourceContent), 0644); err != nil {
		return err
	}
	return nil
}

// CreateFile 存在则覆盖，不存在则创建文件
func CreateFile(filePath string) error {
	if err := CreateParentDir(filePath); err != nil {
		return err
	}
	// 创建文件，如果文件已存在则覆盖
	file, err := os.Create(filePath)
	if err != nil {
		return err
	}
	defer func(file *os.File) {
		err := file.Close()
		if err != nil {

		}
	}(file)
	return nil
}
func ReadFile(filePath string) (string, error) {
	// 1 打开文件
	file, err := os.Open(filePath)
	if err != nil {
		return "", err
	}
	defer file.Close()

	// 2 读取文件内容
	content, err := io.ReadAll(file)
	if err != nil {
		return "", err
	}
	return string(content), err
}

func ListAbsolutePathWithSuffixAndSort(dir string, suffix string) ([]string, error) {
	var result []string
	if !strings.HasSuffix(dir, "/") {
		dir = dir + "/"
	}
	files, err := os.ReadDir(dir)
	if err != nil {
		return nil, err
	}
	for _, file := range files {
		if strings.HasSuffix(file.Name(), suffix) {
			result = append(result, dir+file.Name())
		}
	}
	// 根据文件名进行升序排序
	sort.Slice(result, func(i, j int) bool {
		return filepath.Base(result[i]) < filepath.Base(result[j])
	})
	return result, nil
}

func DeleteFile(path string) error {
	// 检查文件是否存在
	if _, err := os.Stat(path); err == nil {
		// 文件存在，执行删除操作
		err = os.Remove(path)
		if err != nil {
			return err
		}
	}
	return nil
}

// WriteStringToFile 将字符串写入指定的文件路径
func WriteStringToFile(content string, filePath string) {
	// 方法一：使用os包
	file, err := os.Create(filePath)
	if err != nil {
		fmt.Println("创建文件失败:", err)
		return
	}
	defer file.Close()

	_, err = file.WriteString(content)
	if err != nil {
		fmt.Println("写入文件失败:", err)
		return
	}
	fmt.Println("字符串成功写入文件（os包）")
}