talos

1
// This Source Code Form is subject to the terms of the Mozilla Public
2
// License, v. 2.0. If a copy of the MPL was not distributed with this
3
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
4

5
package archiver_test
6

7
import (
8
	"archive/tar"
9
	"bytes"
10
	"context"
11
	"io"
12
	"os"
13
	"path/filepath"
14
	"testing"
15

16
	"github.com/stretchr/testify/suite"
17

18
	"github.com/siderolabs/talos/pkg/archiver"
19
)
20

21
type TarSuite struct {
22
	CommonSuite
23
}
24

25
func (suite *TarSuite) TestArchiveDir() {
26
	ch, err := archiver.Walker(context.Background(), suite.tmpDir)
27
	suite.Require().NoError(err)
28

29
	var buf bytes.Buffer
30

31
	err = archiver.Tar(context.Background(), ch, &buf)
32
	suite.Require().NoError(err)
33

34
	pathsSeen := map[string]struct{}{}
35

36
	tr := tar.NewReader(&buf)
37

38
	for {
39
		hdr, err := tr.Next()
40
		if err == io.EOF {
41
			break
42
		}
43

44
		suite.Require().NoError(err)
45

46
		if hdr.Typeflag == tar.TypeDir {
47
			continue
48
		}
49

50
		contents, err := io.ReadAll(tr)
51
		suite.Require().NoError(err)
52

53
		found := false
54

55
		for _, fi := range filesFixture {
56
			if fi.Path[1:] == hdr.Name {
57
				found = true
58
				pathsSeen[fi.Path] = struct{}{}
59

60
				switch {
61
				case fi.Mode&os.ModeSymlink != 0:
62
					suite.Require().Equal(string(fi.Contents), hdr.Linkname)
63
				case fi.Size > 0:
64
					suite.Require().Len(contents, fi.Size)
65
				case fi.Contents != nil:
66
					suite.Require().EqualValues(fi.Contents, contents)
67
				default:
68
					suite.Require().Len(contents, 0)
69
				}
70
			}
71
		}
72

73
		suite.Require().True(found, "file %q", hdr.Name)
74
	}
75

76
	for _, fi := range filesFixture {
77
		_, ok := pathsSeen[fi.Path]
78
		suite.Require().True(ok, "path %q", fi.Path)
79
	}
80
}
81

82
func (suite *TarSuite) TestArchiveFile() {
83
	ch, err := archiver.Walker(context.Background(), filepath.Join(suite.tmpDir, "/usr/bin/cp"))
84
	suite.Require().NoError(err)
85

86
	var buf bytes.Buffer
87

88
	err = archiver.Tar(context.Background(), ch, &buf)
89
	suite.Require().NoError(err)
90

91
	tr := tar.NewReader(&buf)
92

93
	for {
94
		hdr, err := tr.Next()
95
		if err == io.EOF {
96
			break
97
		}
98

99
		suite.Require().NoError(err)
100

101
		expectedContents := []byte("ELF EXECUTABLE IIRC")
102

103
		suite.Require().EqualValues(hdr.Typeflag, tar.TypeReg)
104
		suite.Require().EqualValues(hdr.Name, "cp")
105
		suite.Require().EqualValues(hdr.Size, len(expectedContents))
106

107
		contents, err := io.ReadAll(tr)
108
		suite.Require().NoError(err)
109

110
		suite.Require().Equal(expectedContents, contents)
111
	}
112
}
113

114
func (suite *TarSuite) TestArchiveProcfs() {
115
	ch, err := archiver.Walker(context.Background(), "/proc/self/", archiver.WithMaxRecurseDepth(0))
116
	suite.Require().NoError(err)
117

118
	var buf bytes.Buffer
119

120
	// it's okay to have some errors here, as some files are not readable
121
	archiver.Tar(context.Background(), ch, &buf) //nolint:errcheck
122

123
	tr := tar.NewReader(&buf)
124

125
	expectedNonZeroFiles := map[string]struct{}{
126
		"cmdline": {},
127
		"environ": {},
128
		"limits":  {},
129
		"io":      {},
130
		"stat":    {},
131
	}
132

133
	for {
134
		hdr, err := tr.Next()
135
		if err == io.EOF {
136
			break
137
		}
138

139
		suite.Require().NoError(err)
140

141
		if _, expected := expectedNonZeroFiles[hdr.Name]; !expected {
142
			continue
143
		}
144

145
		suite.Assert().EqualValues(hdr.Typeflag, tar.TypeReg)
146
		suite.Assert().NotZero(hdr.Size)
147

148
		delete(expectedNonZeroFiles, hdr.Name)
149
	}
150

151
	suite.Assert().Empty(expectedNonZeroFiles)
152
}
153

154
func TestTarSuite(t *testing.T) {
155
	suite.Run(t, new(TarSuite))
156
}
157