kjuulh/dagger
Archived
1
0
Fork 0
Code Issues 1 Pull Requests 1 Projects Releases Wiki Activity

Merge pull request #2051 from marcosnils/feat/platform_flag

Browse Source 
Add experimental way to set a target platform when building
This commit is contained in:
Andrea Luzzardi 2022-04-06 11:33:23 -07:00 committed by GitHub
commit f3ac279f73
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 60 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ci.cue
View File

@ -14,11 +14,6 @@ import (
)
dagger.#Plan & {
// FIXME: Ideally we would want to automatically set the platform's arch identical to the host
// to avoid the performance hit caused by qemu (linter goes from <3s to >3m when arch is x86)
// Uncomment if running locally on Mac M1 to bypass qemu
// platform: "linux/aarch64"
// platform: "linux/amd64"
client: filesystem: ".": read: exclude: [
"bin",

11
client/client.go
View File

@ -44,6 +44,8 @@ type Config struct {
CacheExports []bk.CacheOptionsEntry
CacheImports []bk.CacheOptionsEntry
TargetPlatform *specs.Platform
}
func New(ctx context.Context, host string, cfg Config) (*Client, error) {
@ -81,8 +83,9 @@ func (c *Client) Do(ctx context.Context, pctx *plancontext.Context, fn DoFunc) e
lg := log.Ctx(ctx)
eg, gctx := errgroup.WithContext(ctx)
// if platform is set through plan config, skip detection.
if !pctx.Platform.IsSet() {
if c.cfg.TargetPlatform != nil {
pctx.Platform.Set(*c.cfg.TargetPlatform)
} else {
p, err := c.detectPlatform(ctx)
if err != nil {
return err
@ -107,8 +110,8 @@ func (c *Client) Do(ctx context.Context, pctx *plancontext.Context, fn DoFunc) e
return eg.Wait()
}
// detectPlatform will try to automatically Buildkit's target platform.
// If not possible, default platform will be used.
// detectPlatform tries using Buildkit's target platform;
// if not possible, default platform will be used.
func (c *Client) detectPlatform(ctx context.Context) (*specs.Platform, error) {
w, err := c.c.ListWorkers(ctx)
if err != nil {

13
cmd/dagger/cmd/common/common.go
View File

@ -6,7 +6,9 @@ import (
"strings"
"cuelang.org/go/cue"
"github.com/containerd/containerd/platforms"
"github.com/docker/buildx/util/buildflags"
specs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/rs/zerolog/log"
"github.com/spf13/viper"
"go.dagger.io/dagger/client"
@ -95,10 +97,21 @@ func NewClient(ctx context.Context) *client.Client {
lg.Fatal().Err(err).Msg("unable to parse --cache-from options")
}
ep := viper.GetString("platform")
var p *specs.Platform
if len(ep) > 0 {
pp, err := platforms.Parse(ep)
if err != nil {
lg.Fatal().Err(err).Msg("invalid value for --platform")
}
p = &pp
}
cl, err := client.New(ctx, "", client.Config{
CacheExports: cacheExports,
CacheImports: cacheImports,
NoCache: viper.GetBool("no-cache"),
TargetPlatform: p,
})
if err != nil {
lg.Fatal().Err(err).Msg("unable to create client")

6
cmd/dagger/cmd/do.go
View File

@ -42,6 +42,11 @@ var doCmd = &cobra.Command{
err error
)
switch !viper.GetBool("experimental") {
case len(viper.GetString("platform")) > 0:
lg.Fatal().Err(err).Msg("--platform requires --experimental flag")
}
if f := viper.GetString("log-format"); f == "tty" || f == "auto" && term.IsTerminal(int(os.Stdout.Fd())) {
tty, err = logger.NewTTYOutput(os.Stderr)
if err != nil {
@ -157,6 +162,7 @@ func init() {
doCmd.Flags().StringArrayP("with", "w", []string{}, "")
doCmd.Flags().StringP("plan", "p", ".", "Path to plan (defaults to current directory)")
doCmd.Flags().Bool("no-cache", false, "Disable caching")
doCmd.Flags().String("platform", "", "Set target build platform (requires experimental)")
doCmd.Flags().StringArray("cache-to", []string{},
"Cache export destinations (eg. user/app:cache, type=local,dest=path/to/dir)")
doCmd.Flags().StringArray("cache-from", []string{},

1
cmd/dagger/cmd/root.go
View File

@ -23,6 +23,7 @@ var rootCmd = &cobra.Command{
func init() {
rootCmd.PersistentFlags().String("log-format", "auto", "Log format (auto, plain, tty, json)")
rootCmd.PersistentFlags().StringP("log-level", "l", "info", "Log level")
rootCmd.PersistentFlags().Bool("experimental", false, "Enable experimental features")
rootCmd.PersistentPreRun = func(cmd *cobra.Command, _ []string) {
go checkVersion()

3
plan/plan.go
View File

@ -109,7 +109,8 @@ func (p *Plan) Action() *Action {
// configPlatform load the platform specified in the context
// Buildkit will then run every operation using that platform
// If platform is not define, context keep default platform
// FIXME: `platform` field temporarily disabled
// FIXME: `platform` field temporarily disabled until we decide the proper
// DX for multi-platform builds
// func (p *Plan) configPlatform() error {
// platformField := p.source.Lookup("platform")

4
plancontext/platform.go
View File

@ -25,7 +25,3 @@ func (c *platformContext) SetString(platform string) error {
func (c *platformContext) Set(p specs.Platform) {
c.platform = &p
}
func (c *platformContext) IsSet() bool {
return c.platform != nil
}

1
solver/solver.go
View File

@ -85,7 +85,6 @@ func (s *Solver) AddCredentials(target, username, secret string) {
}
func (s *Solver) Marshal(ctx context.Context, st llb.State, co ...llb.ConstraintsOpt) (*bkpb.Definition, error) {
// FIXME: do not hardcode the platform
def, err := st.Marshal(ctx, co...)
if err != nil {
return nil, err

24
tests/plan.bats
View File

@ -228,15 +228,23 @@ setup() {
}
@test "plan/platform" {
cd "$TESTDIR"
# Run with amd64 platform
run "$DAGGER" "do" -p./plan/platform/config_platform_linux_amd64.cue verify
# Run with arm64 platform
run "$DAGGER" "do" -p./plan/platform/config_platform_linux_arm64.cue verify
# Run with invalid platform
run "$DAGGER" "do" -p./plan/platform/config_platform_failure_invalid_platform.cue verify
# Run with invalid platform format
run "$DAGGER" "do" --experimental --platform invalid -p./plan/platform/platform.cue test
assert_failure
assert_output --partial "unknown operating system or architecture: invalid argument"
# Require --experimental flag
run "$DAGGER" "do" --platform linux/arm64 -p./plan/platform/platform.cue test
assert_failure
assert_output --partial "--platform requires --experimental flag"
# Run with non-existing platform
run "$DAGGER" "do" --experimental --platform invalid/invalid -p./plan/platform/platform.cue test
assert_failure
assert_output --partial "no match for platform in manifest"
}

33
tests/plan/platform/config_platform_failure_invalid_platform.cue
View File

@ -1,33 +0,0 @@
package main
import (
"dagger.io/dagger"
"dagger.io/dagger/core"
)
dagger.#Plan & {
platform: "linux/unknown"
actions: {
image: core.#Pull & {
source: "alpine:3.15.0"
}
writeArch: core.#Exec & {
input: image.output
always: true
args: [
"sh", "-c", #"""
echo -n $(uname -m) >> /arch.txt
"""#,
]
}
verify: core.#ReadFile & {
input: writeArch.output
path: "/arch.txt"
} & {
contents: "s390x"
}
}
}

33
tests/plan/platform/config_platform_linux_amd64.cue
View File

@ -1,33 +0,0 @@
package main
import (
"dagger.io/dagger"
"dagger.io/dagger/core"
)
dagger.#Plan & {
platform: "linux/amd64"
actions: {
image: core.#Pull & {
source: "alpine:3.15.0"
}
writeArch: core.#Exec & {
input: image.output
always: true
args: [
"sh", "-c", #"""
echo -n $(uname -m) >> /arch.txt
"""#,
]
}
verify: core.#ReadFile & {
input: writeArch.output
path: "/arch.txt"
} & {
contents: "x86_64"
}
}
}

33
tests/plan/platform/config_platform_linux_arm64.cue
View File

@ -1,33 +0,0 @@
package main
import (
"dagger.io/dagger"
"dagger.io/dagger/core"
)
dagger.#Plan & {
platform: "linux/arm64"
actions: {
image: core.#Pull & {
source: "alpine:3.15.0"
}
writeArch: core.#Exec & {
input: image.output
always: true
args: [
"sh", "-c", #"""
echo -n $(uname -m) >> /arch.txt
"""#,
]
}
verify: core.#ReadFile & {
input: writeArch.output
path: "/arch.txt"
} & {
contents: "aarch64"
}
}
}

12
tests/plan/platform/platform.cue Normal file
View File

@ -0,0 +1,12 @@
package main
import (
"dagger.io/dagger"
"dagger.io/dagger/core"
)
dagger.#Plan & {
actions: test: image: core.#Pull & {
source: "alpine:3.15.0"
}
}