/
gcompress_gzip.go
135 lines (122 loc) · 3.34 KB
/
gcompress_gzip.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gcompress
import (
"bytes"
"compress/gzip"
"io"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/os/gfile"
)
// Gzip compresses `data` using gzip algorithm.
// The optional parameter `level` specifies the compression level from
// 1 to 9 which means from none to the best compression.
//
// Note that it returns error if given `level` is invalid.
func Gzip(data []byte, level ...int) ([]byte, error) {
var (
writer *gzip.Writer
buf bytes.Buffer
err error
)
if len(level) > 0 {
writer, err = gzip.NewWriterLevel(&buf, level[0])
if err != nil {
err = gerror.Wrapf(err, `gzip.NewWriterLevel failed for level "%d"`, level[0])
return nil, err
}
} else {
writer = gzip.NewWriter(&buf)
}
if _, err = writer.Write(data); err != nil {
err = gerror.Wrap(err, `writer.Write failed`)
return nil, err
}
if err = writer.Close(); err != nil {
err = gerror.Wrap(err, `writer.Close failed`)
return nil, err
}
return buf.Bytes(), nil
}
// GzipFile compresses the file `src` to `dst` using gzip algorithm.
func GzipFile(srcFilePath, dstFilePath string, level ...int) (err error) {
dstFile, err := gfile.Create(dstFilePath)
if err != nil {
return err
}
defer dstFile.Close()
return GzipPathWriter(srcFilePath, dstFile, level...)
}
// GzipPathWriter compresses `filePath` to `writer` using gzip compressing algorithm.
//
// Note that the parameter `path` can be either a directory or a file.
func GzipPathWriter(filePath string, writer io.Writer, level ...int) error {
var (
gzipWriter *gzip.Writer
err error
)
srcFile, err := gfile.Open(filePath)
if err != nil {
return err
}
defer srcFile.Close()
if len(level) > 0 {
gzipWriter, err = gzip.NewWriterLevel(writer, level[0])
if err != nil {
return gerror.Wrap(err, `gzip.NewWriterLevel failed`)
}
} else {
gzipWriter = gzip.NewWriter(writer)
}
defer gzipWriter.Close()
if _, err = io.Copy(gzipWriter, srcFile); err != nil {
err = gerror.Wrap(err, `io.Copy failed`)
return err
}
return nil
}
// UnGzip decompresses `data` with gzip algorithm.
func UnGzip(data []byte) ([]byte, error) {
var buf bytes.Buffer
reader, err := gzip.NewReader(bytes.NewReader(data))
if err != nil {
err = gerror.Wrap(err, `gzip.NewReader failed`)
return nil, err
}
if _, err = io.Copy(&buf, reader); err != nil {
err = gerror.Wrap(err, `io.Copy failed`)
return nil, err
}
if err = reader.Close(); err != nil {
err = gerror.Wrap(err, `reader.Close failed`)
return buf.Bytes(), err
}
return buf.Bytes(), nil
}
// UnGzipFile decompresses srcFilePath `src` to `dst` using gzip algorithm.
func UnGzipFile(srcFilePath, dstFilePath string) error {
srcFile, err := gfile.Open(srcFilePath)
if err != nil {
return err
}
defer srcFile.Close()
dstFile, err := gfile.Create(dstFilePath)
if err != nil {
return err
}
defer dstFile.Close()
reader, err := gzip.NewReader(srcFile)
if err != nil {
err = gerror.Wrap(err, `gzip.NewReader failed`)
return err
}
defer reader.Close()
if _, err = io.Copy(dstFile, reader); err != nil {
err = gerror.Wrap(err, `io.Copy failed`)
return err
}
return nil
}