podman

1
package ocipull
2

3
import (
4
	"archive/tar"
5
	"context"
6
	"errors"
7
	"fmt"
8
	"io"
9
	"os"
10
	"strings"
11

12
	"github.com/containers/image/v5/pkg/compression"
13
	"github.com/containers/image/v5/types"
14
	diskcompression "github.com/containers/podman/v5/pkg/machine/compression"
15
	"github.com/containers/podman/v5/pkg/machine/define"
16
	"github.com/sirupsen/logrus"
17
)
18

19
type LocalBlobDir struct {
20
	blob            *types.BlobInfo
21
	blobDirPath     string
22
	ctx             context.Context
23
	imageName       string
24
	machineImageDir string
25
	vmName          string
26
}
27

28
func NewOCIDir(ctx context.Context, inputDir, machineImageDir, vmName string) *LocalBlobDir {
29
	strippedInputDir := strings.TrimPrefix(inputDir, fmt.Sprintf("%s:/", OCIDir.String()))
30
	l := LocalBlobDir{
31
		blob:            nil,
32
		blobDirPath:     strippedInputDir,
33
		ctx:             ctx,
34
		imageName:       "",
35
		machineImageDir: machineImageDir,
36
		vmName:          vmName,
37
	}
38
	return &l
39
}
40

41
func (l *LocalBlobDir) Pull() error {
42
	localBlob, err := GetLocalBlob(l.ctx, l.DiskEndpoint())
43
	if err != nil {
44
		return err
45
	}
46
	l.blob = localBlob
47
	return nil
48
}
49

50
func (l *LocalBlobDir) Decompress(compressedFile *define.VMFile) (*define.VMFile, error) {
51
	finalName := finalFQImagePathName(l.vmName, l.imageName)
52
	if err := diskcompression.Decompress(compressedFile, finalName); err != nil {
53
		return nil, err
54
	}
55
	return define.NewMachineFile(finalName, nil)
56
}
57

58
func (l *LocalBlobDir) Unpack() (*define.VMFile, error) {
59
	tbPath := localOCIDiskImageDir(l.blobDirPath, l.blob)
60
	unPackedFile, err := unpackOCIDir(tbPath, l.machineImageDir)
61
	if err != nil {
62
		return nil, err
63
	}
64
	l.imageName = unPackedFile.GetPath()
65
	return unPackedFile, err
66
}
67

68
func (l *LocalBlobDir) DiskEndpoint() string {
69
	return l.blobDirPath
70
}
71

72
func (l *LocalBlobDir) LocalBlob() *types.BlobInfo {
73
	return l.blob
74
}
75

76
// findTarComponent returns a header and a reader matching componentPath within inputFile,
77
// or (nil, nil, nil) if not found.
78
func findTarComponent(pathToTar string) (string, error) {
79
	f, err := os.Open(pathToTar)
80
	if err != nil {
81
		return "", err
82
	}
83
	defer func() {
84
		if err := f.Close(); err != nil {
85
			logrus.Error(err)
86
		}
87
	}()
88
	uncompressedReader, _, err := compression.AutoDecompress(f)
89
	if err != nil {
90
		return "", err
91
	}
92
	defer func() {
93
		if err := uncompressedReader.Close(); err != nil {
94
			logrus.Error(err)
95
		}
96
	}()
97
	var (
98
		filename    string
99
		headerCount uint
100
	)
101
	t := tar.NewReader(uncompressedReader)
102
	for {
103
		h, err := t.Next()
104
		if err == io.EOF {
105
			break
106
		}
107
		if err != nil {
108
			return "", err
109
		}
110
		filename = h.Name
111
		headerCount++
112
	}
113
	if headerCount != 1 {
114
		return "", errors.New("invalid oci machine image")
115
	}
116
	return filename, nil
117
}
118