Debian Codegraph @

buildkit/client/llb/llbtest/platform_test.go

raw
1 package llbtest
2
3 import (
4 "context"
5 "strings"
6 "testing"
7
8 "github.com/containerd/platforms"
9 "github.com/moby/buildkit/client/llb"
10 "github.com/moby/buildkit/solver"
11 "github.com/moby/buildkit/solver/llbsolver"
12 "github.com/moby/buildkit/solver/pb"
13 "github.com/moby/buildkit/util/system"
14 ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
15 "github.com/stretchr/testify/require"
16 )
17
18 func TestCustomPlatform(t *testing.T) {
19 t.Parallel()
20
21 s := llb.Image("foo", llb.LinuxArmhf).
22 Run(llb.Shlex("baz")).
23 Run(llb.Shlex("bar")).
24 Run(llb.Shlex("bax"), llb.Windows).
25 Run(llb.Shlex("bay"))
26
27 def, err := s.Marshal(context.TODO())
28 require.NoError(t, err)
29
30 e, err := llbsolver.Load(context.TODO(), def.ToPB(), nil)
31 require.NoError(t, err)
32
33 require.Equal(t, 5, depth(e))
34
35 expected := ocispecs.Platform{OS: "windows", Architecture: "amd64"}
36 require.Equal(t, expected, platform(e))
37 e = parent(e, 0)
38 require.Equal(t, expected, platform(e))
39 e = parent(e, 0)
40
41 expected = ocispecs.Platform{OS: "linux", Architecture: "arm", Variant: "v7"}
42 require.Equal(t, expected, platform(e))
43 e = parent(e, 0)
44 require.Equal(t, expected, platform(e))
45 require.Equal(t, []string{"baz"}, args(e))
46 e = parent(e, 0)
47 require.Equal(t, expected, platform(e))
48 require.Equal(t, "docker-image://docker.io/library/foo:latest", id(e))
49 }
50
51 func TestDefaultPlatform(t *testing.T) {
52 t.Parallel()
53
54 s := llb.Image("foo").Run(llb.Shlex("bar"))
55
56 def, err := s.Marshal(context.TODO())
57 require.NoError(t, err)
58
59 e, err := llbsolver.Load(context.TODO(), def.ToPB(), nil)
60 require.NoError(t, err)
61
62 require.Equal(t, 2, depth(e))
63
64 // needs extra normalize for default spec
65 // https://github.com/moby/buildkit/pull/2427#issuecomment-952301867
66 expected := platforms.Normalize(platforms.DefaultSpec())
67
68 require.Equal(t, expected, platform(e))
69 require.Equal(t, []string{"bar"}, args(e))
70 e = parent(e, 0)
71 require.Equal(t, expected, platform(e))
72 require.Equal(t, "docker-image://docker.io/library/foo:latest", id(e))
73 }
74
75 func TestPlatformOnMarshal(t *testing.T) {
76 t.Parallel()
77
78 s := llb.Image("image1").Run(llb.Shlex("bar"))
79
80 def, err := s.Marshal(context.TODO(), llb.Windows)
81 require.NoError(t, err)
82
83 e, err := llbsolver.Load(context.TODO(), def.ToPB(), nil)
84 require.NoError(t, err)
85
86 expected := ocispecs.Platform{OS: "windows", Architecture: "amd64"}
87 require.Equal(t, expected, platform(e))
88 e = parent(e, 0)
89 require.Equal(t, expected, platform(e))
90 require.Equal(t, "docker-image://docker.io/library/image1:latest", id(e))
91 }
92
93 func TestPlatformMixed(t *testing.T) {
94 t.Parallel()
95
96 s1 := llb.Image("image1").Run(llb.Shlex("cmd-main"))
97 s2 := llb.Image("image2", llb.LinuxArmel).Run(llb.Shlex("cmd-sub"))
98 s1.AddMount("/mnt", s2.Root())
99
100 def, err := s1.Marshal(context.TODO(), llb.LinuxAmd64)
101 require.NoError(t, err)
102
103 e, err := llbsolver.Load(context.TODO(), def.ToPB(), nil)
104 require.NoError(t, err)
105
106 require.Equal(t, 4, depth(e))
107
108 expectedAmd := ocispecs.Platform{OS: "linux", Architecture: "amd64"}
109 require.Equal(t, []string{"cmd-main"}, args(e))
110 require.Equal(t, expectedAmd, platform(e))
111
112 e1 := mount(e, "/")
113 require.Equal(t, "docker-image://docker.io/library/image1:latest", id(e1))
114 require.Equal(t, expectedAmd, platform(e1))
115
116 expectedArm := ocispecs.Platform{OS: "linux", Architecture: "arm", Variant: "v6"}
117 e2 := mount(e, "/mnt")
118 require.Equal(t, []string{"cmd-sub"}, args(e2))
119 require.Equal(t, expectedArm, platform(e2))
120 e2 = parent(e2, 0)
121 require.Equal(t, "docker-image://docker.io/library/image2:latest", id(e2))
122 require.Equal(t, expectedArm, platform(e2))
123 }
124
125 func TestFallbackPath(t *testing.T) {
126 t.Parallel()
127
128 // With no caps we expect no PATH but also no requirement for
129 // the cap.
130 def, err := llb.Scratch().Run(llb.Shlex("cmd")).Marshal(context.TODO(), llb.LinuxAmd64)
131 require.NoError(t, err)
132 e, err := llbsolver.Load(context.TODO(), def.ToPB(), nil)
133 require.NoError(t, err)
134 require.False(t, def.Metadata[e.Vertex.Digest()].Caps[pb.CapExecMetaSetsDefaultPath])
135 _, ok := getenv(e, "PATH")
136 require.False(t, ok)
137
138 // For an empty capset we expect a system-specific default PATH, and
139 // no requirement for the cap.
140 cs := pb.Caps.CapSet(nil)
141 require.Error(t, cs.Supports(pb.CapExecMetaSetsDefaultPath))
142 def, err = llb.Scratch().Run(llb.Shlex("cmd")).Marshal(context.TODO(), llb.LinuxAmd64, llb.WithCaps(cs))
143 require.NoError(t, err)
144 e, err = llbsolver.Load(context.TODO(), def.ToPB(), nil)
145 require.NoError(t, err)
146 require.False(t, def.Metadata[e.Vertex.Digest()].Caps[pb.CapExecMetaSetsDefaultPath])
147 v, ok := getenv(e, "PATH")
148 require.True(t, ok)
149 require.Equal(t, system.DefaultPathEnvUnix, v)
150
151 // All capabilities, including pb.CapExecMetaSetsDefaultPath,
152 // so should get no PATH (not present at all, rather than
153 // present and empty), but also require the cap.
154 cs = pb.Caps.CapSet(pb.Caps.All())
155 require.NoError(t, cs.Supports(pb.CapExecMetaSetsDefaultPath))
156 def, err = llb.Scratch().Run(llb.Shlex("cmd")).Marshal(context.TODO(), llb.LinuxAmd64, llb.WithCaps(cs))
157 require.NoError(t, err)
158 e, err = llbsolver.Load(context.TODO(), def.ToPB(), nil)
159 require.NoError(t, err)
160 require.True(t, def.Metadata[e.Vertex.Digest()].Caps[pb.CapExecMetaSetsDefaultPath])
161 _, ok = getenv(e, "PATH")
162 require.False(t, ok)
163
164 // If we provide a path it should not be touched, no matter
165 // what caps we pass in. Whether the cap becomes required is
166 // irrelevant.
167 for _, cos := range [][]llb.ConstraintsOpt{
168 nil,
169 {llb.WithCaps(pb.Caps.CapSet(nil))},
170 {llb.WithCaps(pb.Caps.CapSet(pb.Caps.All()))},
171 } {
172 def, err = llb.Scratch().AddEnv("PATH", "foo").Run(llb.Shlex("cmd")).Marshal(context.TODO(), append(cos, llb.LinuxAmd64)...)
173 require.NoError(t, err)
174 e, err = llbsolver.Load(context.TODO(), def.ToPB(), nil)
175 require.NoError(t, err)
176 // pb.CapExecMetaSetsDefaultPath setting is irrelevant (and variable).
177 v, ok = getenv(e, "PATH")
178 require.True(t, ok)
179 require.Equal(t, "foo", v)
180 }
181 }
182
183 func toOp(e solver.Edge) *pb.Op {
184 return e.Vertex.Sys().(*pb.Op)
185 }
186
187 func platform(e solver.Edge) ocispecs.Platform {
188 p := toOp(e).Platform
189 return ocispecs.Platform{
190 OS: p.OS,
191 Architecture: p.Architecture,
192 Variant: p.Variant,
193 OSVersion: p.OSVersion,
194 OSFeatures: p.OSFeatures,
195 }
196 }
197
198 func depth(e solver.Edge) int {
199 i := 1
200 for _, inp := range e.Vertex.Inputs() {
201 i += depth(inp)
202 }
203 return i
204 }
205
206 func parent(e solver.Edge, i int) solver.Edge {
207 return e.Vertex.Inputs()[i]
208 }
209
210 func id(e solver.Edge) string {
211 return toOp(e).GetSource().Identifier
212 }
213
214 func args(e solver.Edge) []string {
215 return toOp(e).GetExec().Meta.Args
216 }
217
218 func mount(e solver.Edge, target string) solver.Edge {
219 op := toOp(e).GetExec()
220 for _, m := range op.Mounts {
221 if m.Dest == target {
222 return e.Vertex.Inputs()[int(m.Input)]
223 }
224 }
225 panic("could not find mount " + target)
226 }
227
228 func getenv(e solver.Edge, k string) (string, bool) {
229 env := toOp(e).GetExec().Meta.Env
230 k = k + "="
231 for _, e := range env {
232 if after, ok := strings.CutPrefix(e, k); ok {
233 return after, true
234 }
235 }
236 return "", false
237 }