podman

1
package compression
2

3
import (
4
	"io"
5
	"io/fs"
6
	"os"
7
	"runtime"
8

9
	"github.com/containers/image/v5/pkg/compression"
10
	"github.com/sirupsen/logrus"
11
)
12

13
type genericDecompressor struct {
14
	compressedFilePath string
15
	compressedFile     *os.File
16
	compressedFileInfo os.FileInfo
17
}
18

19
func newGenericDecompressor(compressedFilePath string) (*genericDecompressor, error) {
20
	d := &genericDecompressor{}
21
	d.compressedFilePath = compressedFilePath
22
	stat, err := os.Stat(d.compressedFilePath)
23
	if err != nil {
24
		return nil, err
25
	}
26
	d.compressedFileInfo = stat
27
	return d, nil
28
}
29

30
func (d *genericDecompressor) compressedFileSize() int64 {
31
	return d.compressedFileInfo.Size()
32
}
33

34
func (d *genericDecompressor) compressedFileMode() fs.FileMode {
35
	return d.compressedFileInfo.Mode()
36
}
37

38
func (d *genericDecompressor) compressedFileReader() (io.ReadCloser, error) {
39
	compressedFile, err := os.Open(d.compressedFilePath)
40
	if err != nil {
41
		return nil, err
42
	}
43
	d.compressedFile = compressedFile
44
	return compressedFile, nil
45
}
46

47
func (d *genericDecompressor) decompress(w io.WriteSeeker, r io.Reader) error {
48
	decompressedFileReader, _, err := compression.AutoDecompress(r)
49
	if err != nil {
50
		return err
51
	}
52
	defer func() {
53
		if err := decompressedFileReader.Close(); err != nil {
54
			logrus.Errorf("Unable to close gz file: %q", err)
55
		}
56
	}()
57

58
	// Use sparse-optimized copy for macOS as applehv,
59
	// macOS native hypervisor, uses large raw VM disk
60
	// files mostly empty (~2GB of content ~8GB empty).
61
	if runtime.GOOS == macOs {
62
		err = d.sparseOptimizedCopy(w, decompressedFileReader)
63
	} else {
64
		_, err = io.Copy(w, decompressedFileReader)
65
	}
66

67
	return err
68
}
69

70
func (d *genericDecompressor) close() {
71
	if err := d.compressedFile.Close(); err != nil {
72
		logrus.Errorf("Unable to close compressed file: %q", err)
73
	}
74
}
75

76
func (d *genericDecompressor) sparseOptimizedCopy(w io.WriteSeeker, r io.Reader) error {
77
	var err error
78
	sparseWriter := NewSparseWriter(w)
79
	defer func() {
80
		e := sparseWriter.Close()
81
		if e != nil && err == nil {
82
			err = e
83
		}
84
	}()
85
	_, err = io.Copy(sparseWriter, r)
86
	return err
87
}
88