fix unTargz

liuxiaolong

2019-12-20 7ce84b3d1e45d35c7c9f73561893039a05c16995

fix unTargz

 extend/util/util.go

@@ -1,11 +1,8 @@
package util

import (
    "archive/tar"
    "archive/zip"
    "basic.com/valib/logger.git"
    "bytes"
    "compress/gzip"
    "crypto/md5"
    "encoding/hex"
    "encoding/json"
@@ -301,106 +298,6 @@
    }

    return nil
}

//压缩 使用gzip压缩成tar.gz
func TarCompress(files []*os.File, dest string) error {
    d, _ := os.Create(dest)
    defer d.Close()
    gw := gzip.NewWriter(d)
    defer gw.Close()
    tw := tar.NewWriter(gw)
    defer tw.Close()
    for _, file := range files {
        err := gzipCompress(file, "", tw)
        if err != nil {
            return err
        }
    }
    return nil
}

func gzipCompress(file *os.File, prefix string, tw *tar.Writer) error {
    info, err := file.Stat()
    if err != nil {
        return err
    }
    if info.IsDir() {
        prefix = prefix + "/" + info.Name()
        fileInfos, err := file.Readdir(-1)
        if err != nil {
            return err
        }
        for _, fi := range fileInfos {
            f, err := os.Open(file.Name() + "/" + fi.Name())
            if err != nil {
                return err
            }
            err = gzipCompress(f, prefix, tw)
            if err != nil {
                return err
            }
        }
    } else {
        header, err := tar.FileInfoHeader(info, "")
        header.Name = prefix + "/" + header.Name
        if err != nil {
            return err
        }
        err = tw.WriteHeader(header)
        if err != nil {
            return err
        }
        _, err = io.Copy(tw, file)
        file.Close()
        if err != nil {
            return err
        }
    }
    return nil
}

//解压 tar.gz
func DeCompress(tarFile, dest string) error {
    srcFile, err := os.Open(tarFile)
    if err != nil {
        logger.Debug("open tarFile err:",err)
        return err
    }
    defer srcFile.Close()
    gr, err := gzip.NewReader(srcFile)
    if err != nil {
        logger.Debug("gzip.NewReader err:",err)
        return err
    }
    defer gr.Close()
    tr := tar.NewReader(gr)
    for {
        hdr, err := tr.Next()
        if err != nil {
            if err == io.EOF {
                break
            } else {
                return err
            }
        }
        filename := dest + hdr.Name
        file, err := createFile(filename)
        if err != nil {
            logger.Debug("createFile err:",err)
            return err
        }
        io.Copy(file, tr)
    }
    return nil
}

func createFile(name string) (*os.File, error) {
    err := os.MkdirAll(string([]rune(name)[0:strings.LastIndex(name, "/")]), 0755)
    if err != nil {
        return nil, err
    }
    return os.Create(name)
}

func FormatNum(oNum int,n int) string {

 extend/util/zip.go

New file
@@ -0,0 +1,314 @@
package util

import (
    "archive/tar"
    "basic.com/valib/logger.git"
    "compress/gzip"
    "errors"
    "io"
    "io/ioutil"
    "os"
    "path"
    "strings"
)

//FileName 待压缩的文件名
//DesPathName 压缩完之后存放的目录名
func Gzip(FilePathName, DesPathName string) error {
    // 清理路径字符串
    FilePathName = path.Clean(FilePathName)
    // 要解压的文件名字
    FileName := FilePathName
    index := strings.LastIndex(FilePathName, "\\")
    if index != -1 {
        FileName = FilePathName[index+1:]
    }
    logger.Debug("文件名称是", FileName)
    //创建存放压缩文件的路径(如果文件夹不存在)

    if !dirExists(DesPathName) {
        os.MkdirAll(DesPathName, 0777)
    }
    logger.Debug("创建文件")
    //创建压缩文件
    DesFileName := DesPathName + "\\" + FileName + ".gz"
    fw, er := os.Create(DesFileName)
    if er != nil {
        return er
    }
    defer fw.Close()
    gw := gzip.NewWriter(fw)
    defer gw.Close()

    //读取文件内容
    rd := make([]byte, 1024*1024)
    rd, err := ioutil.ReadFile(FilePathName)
    if err != nil {
        logger.Debug("读取文件内的数据出错 err:", err)
        return err
    }
    // 获取文件或目录信息
    fi, err := os.Stat(FilePathName)
    if err != nil {
        logger.Debug("获取文件的详细信息出错 err :", err)
        return nil
    }
    gw.Name = fi.Name()
    gw.ModTime = fi.ModTime()
    _, err = gw.Write(rd)
    if err != nil {
        logger.Debug("写入压缩文件出错 err:", err)
        return err
    }
    err = gw.Flush()
    if err != nil {
        logger.Debug("gw.Flush() 出错 err:", err)
        return err
    }
    return nil
}
func UnGz(srcGz string, filePath string) error {
    fr, err := os.Open(srcGz)
    if err != nil {
        logger.Debug("open secGZ failed. err:%v", err)
        return err
    }
    gr, err := gzip.NewReader(fr)
    if err != nil {
        fr.Close()
        logger.Debug("create gzip.reader failed. err:%v", err)
        return err
    }
    index := strings.LastIndex(srcGz, ".")
    if index == -1 {
        gr.Close()
        fr.Close()
        logger.Debug("find . failed. err:%v", err)
        return err
    }
    fw, err := os.Create(filePath)
    if err != nil {
        gr.Close()
        fr.Close()
        logger.Debug("create file failed. err:%v", err)
        return err
    }
    // 写文件
    _, err = io.Copy(fw, gr)
    if err != nil {
        fw.Close()
        gr.Close()
        fr.Close()
        logger.Debug("write file failed. err:%v", err)
        return err
    }
    fw.Close()
    gr.Close()
    fr.Close()
    //删除gz压缩文件
    err = os.Remove(srcGz)
    if err != nil {
        logger.Debug("remove file failed. err:%v", err)
        return err
    }
    return nil
}
// 将文件或目录打包成 .tar 文件
// src 是要打包的文件或目录的路径
// dstTar 是要生成的 .tar 文件的路径
// failIfExiBst 标记如果 dstTar 文件存在，是否放弃打包，如果否，则会覆盖已存在的文件
func TarGz(src string, dstTar string, failIfExist bool) error {
    // 清理路径字符串
    src = path.Clean(src)
    // 判断要打包的文件或目录是否存在
    if !exists(src) {
        return errors.New("要打包的文件或目录不存在：" + src)
    }
    // 判断目标文件是否存在
    if fileExists(dstTar) {
        if failIfExist { // 不覆盖已存在的文件
            return errors.New("目标文件已经存在：" + dstTar)
        } else { // 覆盖已存在的文件
            if er := os.Remove(dstTar); er != nil {
                return er
            }
        }
    }
    // 创建空的目标文件
    fw, er := os.Create(dstTar)
    if er != nil {
        return er
    }
    defer fw.Close()
    gw := gzip.NewWriter(fw)
    defer gw.Close()
    // 创建 tar.Writer，执行打包操作
    tw := tar.NewWriter(gw)
    var err error
    defer func() {
        // 这里要判断 tw 是否关闭成功，如果关闭失败，则 .tar 文件可能不完整
        if er := tw.Close(); er != nil {
            err = er
        }
    }()
    // 获取文件或目录信息
    fi, er := os.Stat(src)
    if er != nil {
        return er
    }
    // 获取要打包的文件或目录的所在位置和名称
    srcBase, srcRelative := path.Split(path.Clean(src))
    // 开始打包
    if fi.IsDir() {
        logger.Debug("第一层目录：", srcRelative)
        tarDir(srcBase, srcRelative, tw, fi)
    } else {
        tarFile(srcBase, srcRelative, tw, fi)
    }
    return nil
}
// 因为要执行遍历操作，所以要单独创建一个函数
func tarDir(srcBase, srcRelative string, tw *tar.Writer, fi os.FileInfo) (err error) {
    // 获取完整路径
    srcFull := srcBase + srcRelative
    logger.Debug("srcFull:", srcFull)
    // 在结尾添加 "/"
    last := len(srcRelative) - 1
    if srcRelative[last] != os.PathSeparator {
        srcRelative += string(os.PathSeparator)
    }
    // 获取 srcFull 下的文件或子目录列表
    fis, er := ioutil.ReadDir(srcFull)
    if er != nil {
        return er
    }
    // 开始遍历
    for _, fi := range fis {
        if fi.IsDir() {
            logger.Debug("下层目录")
            tarDir(srcBase, srcRelative+fi.Name(), tw, fi)
        } else {
            logger.Debug("是文件")
            tarFile(srcBase, srcRelative+fi.Name(), tw, fi)
        }
    }
    return nil
}
// 因为要在 defer 中关闭文件，所以要单独创建一个函数
func tarFile(srcBase, srcRelative string, tw *tar.Writer, fi os.FileInfo) (err error) {
    // 获取完整路径
    srcFull := srcBase + srcRelative
    logger.Debug("文件的全路径", srcFull)
    // 写入文件信息
    hdr, er := tar.FileInfoHeader(fi, "")
    if er != nil {
        return er
    }
    logger.Debug(srcRelative)
    hdr.Name = srcRelative
    logger.Debug("文件hdr.name", hdr.Name)
    if er = tw.WriteHeader(hdr); er != nil {
        return er
    }
    // 打开要打包的文件，准备读取
    fr, er := os.Open(srcFull)
    if er != nil {
        return er
    }
    defer fr.Close()
    // 将文件数据写入 tw 中
    if _, er = io.Copy(tw, fr); er != nil {
        return er
    }
    return nil
}

//解包  可以解压，压缩文件里有文件夹的，也可以解压压缩文件里全是文件的
//srcGz待解包文件
//dstDir 解包之后存放的目录
func UnTarGz(srcGz string, dstDir string) error {
    dstDir = path.Clean(dstDir) + string(os.PathSeparator)
    //打开压缩文件
    fr, err := os.Open(srcGz)
    if err != nil {
        return err
    }
    defer fr.Close()
    gw, err := gzip.NewReader(fr)
    defer gw.Close()
    // 创建 tar.Reader 对象，准备执行解包操作
    // 可以用 tr.Next() 来遍历包中的文件
    tr := tar.NewReader(gw)
    // 遍历包中的文件
    for hdr, er := tr.Next(); er != io.EOF; hdr, er = tr.Next() {
        if er != nil {
            logger.Debug("--------- er:", er)
            return er
        }
        // 获取文件信息
        fi := hdr.FileInfo()
        // 获取绝对路径
        dstFullPath := dstDir + hdr.Name
        logger.Debug("--- dstFullPath:", dstFullPath)
        if hdr.Typeflag == tar.TypeDir {
            logger.Debug("--- type is floder")
            // 创建目录
            os.MkdirAll(dstFullPath, fi.Mode().Perm())
            // 设置目录权限
            os.Chmod(dstFullPath, fi.Mode().Perm())
        } else {
            logger.Debug(dstFullPath, "--- type is file")
            // 创建文件所在的目录

            strtemp := dstFullPath[:strings.LastIndex(dstFullPath, "\\")+1]
            //os.MkdirAll(path.Dir(dstFullPath), os.ModePerm)

            os.MkdirAll(strtemp, os.ModePerm)
            // 将 tr 中的数据写入文件中
            if er := unTarFile(dstFullPath, tr); er != nil {
                logger.Debug("unTarFile:",er)
                return er
            }
            // 设置文件权限
            os.Chmod(dstFullPath, fi.Mode().Perm())
        }
    }

    return nil
}

// 因为要在 defer 中关闭文件，所以要单独创建一个函数
func unTarFile(dstFile string, tr *tar.Reader) error {
    // 创建空文件，准备写入解包后的数据
    fw, er := os.Create(dstFile)
    if er != nil {
        return er
    }
    defer fw.Close()

    // 写入解包后的数据
    _, er = io.Copy(fw, tr)
    if er != nil {
        return er
    }

    return nil
}

// 判断档案是否存在
func exists(name string) bool {
    _, err := os.Stat(name)
    return err == nil || os.IsExist(err)
}

// 判断文件是否存在
func fileExists(filename string) bool {
    fi, err := os.Stat(filename)
    return (err == nil || os.IsExist(err)) && !fi.IsDir()
}

// 判断目录是否存在
func dirExists(dirname string) bool {
    fi, err := os.Stat(dirname)
    return (err == nil || os.IsExist(err)) && fi.IsDir()
}

 service/SysService.go

@@ -235,7 +235,7 @@
    }

    unPackFilePath := configPatchPath+"/"+identifier+ext
    err := util.DeCompress(unPackFilePath, unPackPath)
    err := util.UnTarGz(unPackFilePath, unPackPath)
    if err !=nil {
        logger.Debug("UnPack err:",err,"unPackFile:",unPackFilePath)
        return false