status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
233
| body
stringlengths 0
186k
⌀ | issue_url
stringlengths 38
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
timestamp[us, tz=UTC] | language
stringclasses 5
values | commit_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
if err != nil {
return nil, err
}
return container.withMounted(target, payload.LLB, payload.File)
}
func (container *Container) WithMountedCache(ctx context.Context, target string, cache CacheID, source *Directory) (*Container, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
cachePayload, err := cache.decode()
if err != nil {
return nil, err
}
target = absPath(payload.Config.WorkingDir, target)
mount := ContainerMount{
Target: target,
CacheID: cachePayload.Sum(),
CacheSharingMode: "shared",
}
if source != nil {
srcPayload, err := source.ID.Decode()
if err != nil {
return nil, err
}
mount.Source = srcPayload.LLB
mount.SourcePath = srcPayload.Dir
}
payload.Mounts = append(payload.Mounts, mount)
id, err := payload.Encode()
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
if err != nil {
return nil, err
}
return &Container{ID: id}, nil
}
func (container *Container) WithMountedTemp(ctx context.Context, target string) (*Container, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
target = absPath(payload.Config.WorkingDir, target)
payload.Mounts = append(payload.Mounts, ContainerMount{
Target: target,
Tmpfs: true,
})
id, err := payload.Encode()
if err != nil {
return nil, err
}
return &Container{ID: id}, nil
}
func (container *Container) WithMountedSecret(ctx context.Context, target string, source *Secret) (*Container, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
target = absPath(payload.Config.WorkingDir, target)
payload.Secrets = append(payload.Secrets, ContainerSecret{
Secret: source.ID,
MountPath: target,
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
})
id, err := payload.Encode()
if err != nil {
return nil, err
}
return &Container{ID: id}, nil
}
func (container *Container) WithoutMount(ctx context.Context, target string) (*Container, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
target = absPath(payload.Config.WorkingDir, target)
var found bool
var foundIdx int
for i := len(payload.Mounts) - 1; i >= 0; i-- {
if payload.Mounts[i].Target == target {
found = true
foundIdx = i
break
}
}
if found {
payload.Mounts = append(payload.Mounts[:foundIdx], payload.Mounts[foundIdx+1:]...)
}
id, err := payload.Encode()
if err != nil {
return nil, err
}
return &Container{ID: id}, nil
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
}
func (container *Container) Mounts(ctx context.Context) ([]string, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
mounts := []string{}
for _, mnt := range payload.Mounts {
mounts = append(mounts, mnt.Target)
}
return mounts, nil
}
func (container *Container) WithSecretVariable(ctx context.Context, name string, secret *Secret) (*Container, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
payload.Secrets = append(payload.Secrets, ContainerSecret{
Secret: secret.ID,
EnvName: name,
})
id, err := payload.Encode()
if err != nil {
return nil, err
}
return &Container{ID: id}, nil
}
func (container *Container) Directory(ctx context.Context, gw bkgw.Client, dirPath string) (*Directory, error) {
dir, err := locatePath(ctx, container, dirPath, gw, NewDirectory)
if err != nil {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
return nil, err
}
info, err := dir.Stat(ctx, gw, ".")
if err != nil {
return nil, err
}
if !info.IsDir() {
return nil, fmt.Errorf("path %s is a file, not a directory", dirPath)
}
return dir, nil
}
func (container *Container) File(ctx context.Context, gw bkgw.Client, filePath string) (*File, error) {
file, err := locatePath(ctx, container, filePath, gw, NewFile)
if err != nil {
return nil, err
}
info, err := file.Stat(ctx, gw)
if err != nil {
return nil, err
}
if info.IsDir() {
return nil, fmt.Errorf("path %s is a directory, not a file", filePath)
}
return file, nil
}
func locatePath[T *File | *Directory](
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
ctx context.Context,
container *Container,
containerPath string,
gw bkgw.Client,
init func(context.Context, llb.State, string, specs.Platform) (T, error),
) (T, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
containerPath = absPath(payload.Config.WorkingDir, containerPath)
var found T
for i := len(payload.Mounts) - 1; i >= 0; i-- {
mnt := payload.Mounts[i]
if containerPath == mnt.Target || strings.HasPrefix(containerPath, mnt.Target+"/") {
if mnt.Tmpfs {
return nil, fmt.Errorf("%s: cannot retrieve path from tmpfs", containerPath)
}
if mnt.CacheID != "" {
return nil, fmt.Errorf("%s: cannot retrieve path from cache", containerPath)
}
st, err := mnt.SourceState()
if err != nil {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
return nil, err
}
sub := mnt.SourcePath
if containerPath != mnt.Target {
dirSub := strings.TrimPrefix(containerPath, mnt.Target+"/")
if dirSub != "" {
sub = path.Join(sub, dirSub)
}
}
found, err = init(ctx, st, sub, payload.Platform)
if err != nil {
return nil, err
}
break
}
}
if found == nil {
st, err := payload.FSState()
if err != nil {
return nil, err
}
found, err = init(ctx, st, containerPath, payload.Platform)
if err != nil {
return nil, err
}
}
return found, nil
}
func (container *Container) withMounted(target string, srcDef *pb.Definition, srcPath string) (*Container, error) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
target = absPath(payload.Config.WorkingDir, target)
payload.Mounts = append(payload.Mounts, ContainerMount{
Source: srcDef,
SourcePath: srcPath,
Target: target,
})
id, err := payload.Encode()
if err != nil {
return nil, err
}
return &Container{ID: id}, nil
}
func (container *Container) ImageConfig(ctx context.Context) (specs.ImageConfig, error) {
payload, err := container.ID.decode()
if err != nil {
return specs.ImageConfig{}, err
}
return payload.Config, nil
}
func (container *Container) UpdateImageConfig(ctx context.Context, updateFn func(specs.ImageConfig) specs.ImageConfig) (*Container, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
payload.Config = updateFn(payload.Config)
id, err := payload.Encode()
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
if err != nil {
return nil, err
}
return &Container{ID: id}, nil
}
func (container *Container) Exec(ctx context.Context, gw bkgw.Client, args *[]string, opts ContainerExecOpts) (*Container, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, fmt.Errorf("decode id: %w", err)
}
cfg := payload.Config
mounts := payload.Mounts
platform := payload.Platform
shimSt, err := shim.Build(ctx, gw, platform)
if err != nil {
return nil, fmt.Errorf("build shim: %w", err)
}
if args == nil {
args = &[]string{}
} else if len(*args) == 0 {
*args = cfg.Cmd
}
if len(cfg.Entrypoint) > 0 {
*args = append(cfg.Entrypoint, *args...)
}
runOpts := []llb.RunOption{
llb.AddMount(shim.Path, shimSt, llb.SourcePath(shim.Path)),
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
llb.Args(append([]string{shim.Path}, *args...)),
llb.WithCustomName(strings.Join(*args, " ")),
}
meta := llb.Mkdir(metaSourcePath, 0777)
if opts.Stdin != nil {
meta = meta.Mkfile(path.Join(metaSourcePath, "stdin"), 0600, []byte(*opts.Stdin))
}
runOpts = append(runOpts,
llb.AddMount(metaMount,
llb.Scratch().File(meta),
llb.SourcePath(metaSourcePath)))
if opts.RedirectStdout != nil {
runOpts = append(runOpts, llb.AddEnv("_DAGGER_REDIRECT_STDOUT", *opts.RedirectStdout))
}
if opts.RedirectStderr != nil {
runOpts = append(runOpts, llb.AddEnv("_DAGGER_REDIRECT_STDERR", *opts.RedirectStderr))
}
if cfg.User != "" {
runOpts = append(runOpts, llb.User(cfg.User))
}
if cfg.WorkingDir != "" {
runOpts = append(runOpts, llb.Dir(cfg.WorkingDir))
}
for _, env := range cfg.Env {
name, val, ok := strings.Cut(env, "=")
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
if !ok {
_ = ok
}
runOpts = append(runOpts, llb.AddEnv(name, val))
}
for i, secret := range payload.Secrets {
secretOpts := []llb.SecretOption{llb.SecretID(string(secret.Secret))}
var secretDest string
switch {
case secret.EnvName != "":
secretDest = secret.EnvName
secretOpts = append(secretOpts, llb.SecretAsEnv(true))
case secret.MountPath != "":
secretDest = secret.MountPath
default:
return nil, fmt.Errorf("malformed secret config at index %d", i)
}
runOpts = append(runOpts, llb.AddSecret(secretDest, secretOpts...))
}
fsSt, err := payload.FSState()
if err != nil {
return nil, fmt.Errorf("fs state: %w", err)
}
execSt := fsSt.Run(runOpts...)
for i, mnt := range mounts {
srcSt, err := mnt.SourceState()
if err != nil {
return nil, fmt.Errorf("mount %s: %w", mnt.Target, err)
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
}
mountOpts := []llb.MountOption{}
if mnt.SourcePath != "" {
mountOpts = append(mountOpts, llb.SourcePath(mnt.SourcePath))
}
if mnt.CacheSharingMode != "" {
var sharingMode llb.CacheMountSharingMode
switch mnt.CacheSharingMode {
case "shared":
sharingMode = llb.CacheMountShared
case "private":
sharingMode = llb.CacheMountPrivate
case "locked":
sharingMode = llb.CacheMountLocked
default:
return nil, errors.Errorf("invalid cache mount sharing mode %q", mnt.CacheSharingMode)
}
mountOpts = append(mountOpts, llb.AsPersistentCacheDir(mnt.CacheID, sharingMode))
}
if mnt.Tmpfs {
mountOpts = append(mountOpts, llb.Tmpfs())
}
mountSt := execSt.AddMount(mnt.Target, srcSt, mountOpts...)
if !mnt.Tmpfs && mnt.CacheID == "" {
execMountDef, err := mountSt.Marshal(ctx, llb.Platform(platform))
if err != nil {
return nil, fmt.Errorf("propagate %s: %w", mnt.Target, err)
}
mounts[i].Source = execMountDef.ToPB()
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
}
}
execDef, err := execSt.Root().Marshal(ctx, llb.Platform(platform))
if err != nil {
return nil, fmt.Errorf("marshal root: %w", err)
}
metaDef, err := execSt.GetMount(metaMount).Marshal(ctx, llb.Platform(platform))
if err != nil {
return nil, fmt.Errorf("get meta mount: %w", err)
}
payload.FS = execDef.ToPB()
payload.Mounts = mounts
payload.Meta = metaDef.ToPB()
id, err := payload.Encode()
if err != nil {
return nil, fmt.Errorf("encode: %w", err)
}
return &Container{ID: id}, nil
}
func (container *Container) ExitCode(ctx context.Context, gw bkgw.Client) (*int, error) {
file, err := container.MetaFile(ctx, gw, "exitCode")
if err != nil {
return nil, err
}
if file == nil {
return nil, nil
}
content, err := file.Contents(ctx, gw)
if err != nil {
return nil, err
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
}
exitCode, err := strconv.Atoi(string(content))
if err != nil {
return nil, err
}
return &exitCode, nil
}
func (container *Container) MetaFile(ctx context.Context, gw bkgw.Client, filePath string) (*File, error) {
payload, err := container.ID.decode()
if err != nil {
return nil, err
}
meta, err := payload.MetaState()
if err != nil {
return nil, err
}
if meta == nil {
return nil, nil
}
return NewFile(ctx, *meta, path.Join(metaSourcePath, filePath), payload.Platform)
}
func (container *Container) Publish(
ctx context.Context,
ref ContainerAddress,
bkClient *bkclient.Client,
solveOpts bkclient.SolveOpt,
solveCh chan<- *bkclient.SolveStatus,
) (ContainerAddress, error) {
payload, err := container.ID.decode()
if err != nil {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
return "", err
}
st, err := payload.FSState()
if err != nil {
return "", err
}
stDef, err := st.Marshal(ctx, llb.Platform(payload.Platform))
if err != nil {
return "", err
}
cfgBytes, err := json.Marshal(specs.Image{
Architecture: payload.Platform.Architecture,
OS: payload.Platform.OS,
OSVersion: payload.Platform.OSVersion,
OSFeatures: payload.Platform.OSFeatures,
Config: payload.Config,
})
if err != nil {
return "", err
}
solveOpts.Exports = []bkclient.ExportEntry{
{
Type: bkclient.ExporterImage,
Attrs: map[string]string{
"name": string(ref),
"push": "true",
},
},
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/container.go
|
ch := make(chan *bkclient.SolveStatus)
go func() {
for event := range ch {
solveCh <- event
}
}()
_, err = bkClient.Build(ctx, solveOpts, "", func(ctx context.Context, gw bkgw.Client) (*bkgw.Result, error) {
res, err := gw.Solve(ctx, bkgw.SolveRequest{
Evaluate: true,
Definition: stDef.ToPB(),
})
if err != nil {
return nil, err
}
res.AddMeta(exptypes.ExporterImageConfigKey, cfgBytes)
return res, nil
}, ch)
if err != nil {
return "", err
}
return ref, nil
}
type ContainerExecOpts struct {
Stdin *string
RedirectStdout *string
RedirectStderr *string
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
package core
import (
"context"
"strings"
"testing"
"github.com/moby/buildkit/identity"
"github.com/stretchr/testify/require"
"go.dagger.io/dagger/core"
"go.dagger.io/dagger/core/schema"
"go.dagger.io/dagger/internal/testutil"
"go.dagger.io/dagger/sdk/go/dagger"
"go.dagger.io/dagger/sdk/go/dagger/api"
)
func TestContainerScratch(t *testing.T) {
t.Parallel()
res := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
ID string
Fs struct {
Contents []string
}
}
}{}
err := testutil.Query(
`{
container {
id
fs {
contents
}
}
}`, &res, nil)
require.NoError(t, err)
require.Empty(t, res.Container.ID)
require.Empty(t, res.Container.Fs.Contents)
}
func TestContainerFrom(t *testing.T) {
t.Parallel()
res := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
Fs struct {
File struct {
Contents string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
fs {
file(path: "/etc/alpine-release") {
contents
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.Fs.File.Contents, "3.16.2\n")
}
func TestContainerWithFS(t *testing.T) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
t.Parallel()
ctx := context.Background()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
core := c.Core()
alpine316 := core.Container().From("alpine:3.16.2")
alpine316ReleaseStr, err := alpine316.File("/etc/alpine-release").Contents(ctx)
require.NoError(t, err)
alpine316ReleaseStr = strings.TrimSpace(alpine316ReleaseStr)
dirID, err := alpine316.FS().ID(ctx)
require.NoError(t, err)
exitCode, err := core.Container().WithEnvVariable("ALPINE_RELEASE", alpine316ReleaseStr).WithFS(dirID).Exec(api.ContainerExecOpts{
Args: []string{
"/bin/sh",
"-c",
"test -f /etc/alpine-release && test \"$(head -n 1 /etc/alpine-release)\" = \"$ALPINE_RELEASE\"",
},
}).ExitCode(ctx)
require.NoError(t, err)
require.NotEmpty(t, dirID)
require.Equal(t, exitCode, 0)
alpine315 := core.Container().From("alpine:3.15.6")
varVal := "testing123"
alpine315WithVar := alpine315.WithEnvVariable("DAGGER_TEST", varVal)
varValResp, err := alpine315WithVar.EnvVariable(ctx, "DAGGER_TEST")
require.NoError(t, err)
require.Equal(t, varVal, varValResp)
alpine315ReplacedFS := alpine315WithVar.WithFS(dirID)
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
varValResp, err = alpine315ReplacedFS.EnvVariable(ctx, "DAGGER_TEST")
require.NoError(t, err)
require.Equal(t, varVal, varValResp)
releaseStr, err := alpine315ReplacedFS.File("/etc/alpine-release").Contents(ctx)
require.NoError(t, err)
require.Equal(t, "3.16.2\n", releaseStr)
}
func TestContainerExecExitCode(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
Exec struct {
ExitCode *int
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
exec(args: ["true"]) {
exitCode
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.NotNil(t, res.Container.From.Exec.ExitCode)
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
require.Equal(t, 0, *res.Container.From.Exec.ExitCode)
/*
It's not currently possible to get a nonzero exit code back because
Buildkit raises an error.
We could perhaps have the shim mask the exit status and always exit 0, but
we would have to be careful not to let that happen in a big chained LLB
since it would prevent short-circuiting.
We could only do it when the user requests the exitCode, but then we would
actually need to run the command _again_ since we'd need some way to tell
the shim what to do.
Hmm...
err = testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
exec(args: ["false"]) {
exitCode
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.Exec.ExitCode, 1)
*/
}
func TestContainerExecStdoutStderr(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Exec struct {
Stdout, Stderr struct {
Contents string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
exec(args: ["sh", "-c", "echo hello; echo goodbye >/dev/stderr"]) {
stdout {
contents
}
stderr {
contents
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.Exec.Stdout.Contents, "hello\n")
require.Equal(t, res.Container.From.Exec.Stderr.Contents, "goodbye\n")
}
func TestContainerExecStdin(t *testing.T) {
t.Parallel()
res := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
exec(args: ["cat"], opts: {stdin: "hello"}) {
stdout {
contents
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.Exec.Stdout.Contents, "hello")
}
func TestContainerExecRedirectStdoutStderr(t *testing.T) {
t.Parallel()
res := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
Exec struct {
Out, Err struct {
Contents string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
exec(
args: ["sh", "-c", "echo hello; echo goodbye >/dev/stderr"],
opts: {redirectStdout: "out", redirectStderr: "err"}
) {
out: file(path: "out") {
contents
}
err: file(path: "err") {
contents
}
}
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.Exec.Out.Contents, "hello\n")
require.Equal(t, res.Container.From.Exec.Err.Contents, "goodbye\n")
err = testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
exec(
args: ["sh", "-c", "echo hello; echo goodbye >/dev/stderr"],
opts: {redirectStdout: "out", redirectStderr: "err"}
) {
stdout {
contents
}
stderr {
contents
}
}
}
}
}`, &res, nil)
require.Error(t, err)
require.Contains(t, err.Error(), "stdout: no such file or directory")
require.Contains(t, err.Error(), "stderr: no such file or directory")
}
func TestContainerNullStdoutStderr(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
From struct {
Stdout, Stderr *struct {
Contents string
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
stdout {
contents
}
stderr {
contents
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Nil(t, res.Container.From.Stdout)
require.Nil(t, res.Container.From.Stderr)
}
func TestContainerExecWithWorkdir(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
WithWorkdir struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withWorkdir(path: "/usr") {
exec(args: ["pwd"]) {
stdout {
contents
}
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithWorkdir.Exec.Stdout.Contents, "/usr\n")
}
func TestContainerExecWithUser(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
From struct {
User string
WithUser struct {
User string
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
t.Run("user name", func(t *testing.T) {
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "daemon") {
user
exec(args: ["whoami"]) {
stdout {
contents
}
}
}
}
}
}`, &res, nil)
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "daemon", res.Container.From.WithUser.User)
require.Equal(t, "daemon\n", res.Container.From.WithUser.Exec.Stdout.Contents)
})
t.Run("user and group name", func(t *testing.T) {
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "daemon:floppy") {
user
exec(args: ["sh", "-c", "whoami; groups"]) {
stdout {
contents
}
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "daemon:floppy", res.Container.From.WithUser.User)
require.Equal(t, "daemon\nfloppy\n", res.Container.From.WithUser.Exec.Stdout.Contents)
})
t.Run("user ID", func(t *testing.T) {
err := testutil.Query(
`{
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "2") {
user
exec(args: ["whoami"]) {
stdout {
contents
}
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "2", res.Container.From.WithUser.User)
require.Equal(t, "daemon\n", res.Container.From.WithUser.Exec.Stdout.Contents)
})
t.Run("user and group ID", func(t *testing.T) {
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
user
withUser(name: "2:11") {
user
exec(args: ["sh", "-c", "whoami; groups"]) {
stdout {
contents
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, "", res.Container.From.User)
require.Equal(t, "2:11", res.Container.From.WithUser.User)
require.Equal(t, "daemon\nfloppy\n", res.Container.From.WithUser.Exec.Stdout.Contents)
})
}
func TestContainerExecWithEntrypoint(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
Entrypoint []string
WithEntrypoint struct {
Entrypoint []string
Exec struct {
Stdout struct {
Contents string
}
}
WithEntrypoint struct {
Entrypoint []string
}
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
entrypoint
withEntrypoint(args: ["sh", "-c"]) {
entrypoint
exec(args: ["echo $HOME"]) {
stdout {
contents
}
}
withEntrypoint(args: []) {
entrypoint
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Empty(t, res.Container.From.Entrypoint)
require.Equal(t, []string{"sh", "-c"}, res.Container.From.WithEntrypoint.Entrypoint)
require.Equal(t, "/root\n", res.Container.From.WithEntrypoint.Exec.Stdout.Contents)
require.Empty(t, res.Container.From.WithEntrypoint.WithEntrypoint.Entrypoint)
}
func TestContainerWithDefaultArgs(t *testing.T) {
t.Parallel()
res := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
Entrypoint []string
DefaultArgs []string
Exec struct {
Stdout struct {
Contents string
}
}
WithDefaultArgs struct {
Entrypoint []string
DefaultArgs []string
}
WithEntrypoint struct {
Entrypoint []string
DefaultArgs []string
Exec struct {
Stdout struct {
Contents string
}
}
WithDefaultArgs struct {
Entrypoint []string
DefaultArgs []string
Exec struct {
Stdout struct {
Contents string
}
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
entrypoint
defaultArgs
withDefaultArgs {
entrypoint
defaultArgs
}
withEntrypoint(args: ["sh", "-c"]) {
entrypoint
defaultArgs
exec(args: ["echo $HOME"]) {
stdout {
contents
}
}
withDefaultArgs(args: ["id"]) {
entrypoint
defaultArgs
exec(args: []) {
stdout {
contents
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}
}
}`, &res, nil)
t.Run("default alpine (no entrypoint)", func(t *testing.T) {
require.NoError(t, err)
require.Empty(t, res.Container.From.Entrypoint)
require.Equal(t, []string{"/bin/sh"}, res.Container.From.DefaultArgs)
})
t.Run("with nil default args", func(t *testing.T) {
require.Empty(t, res.Container.From.WithDefaultArgs.Entrypoint)
require.Empty(t, res.Container.From.WithDefaultArgs.DefaultArgs)
})
t.Run("with entrypoint set", func(t *testing.T) {
require.Equal(t, []string{"sh", "-c"}, res.Container.From.WithEntrypoint.Entrypoint)
require.Equal(t, []string{"/bin/sh"}, res.Container.From.WithEntrypoint.DefaultArgs)
})
t.Run("with exec args", func(t *testing.T) {
require.Equal(t, "/root\n", res.Container.From.WithEntrypoint.Exec.Stdout.Contents)
})
t.Run("with default args set", func(t *testing.T) {
require.Equal(t, []string{"sh", "-c"}, res.Container.From.WithEntrypoint.WithDefaultArgs.Entrypoint)
require.Equal(t, []string{"id"}, res.Container.From.WithEntrypoint.WithDefaultArgs.DefaultArgs)
require.Equal(t, "uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11(floppy),20(dialout),26(tape),27(video)\n", res.Container.From.WithEntrypoint.WithDefaultArgs.Exec.Stdout.Contents)
})
}
func TestContainerExecWithEnvVariable(t *testing.T) {
t.Parallel()
res := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithEnvVariable struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withEnvVariable(name: "FOO", value: "bar") {
exec(args: ["env"]) {
stdout {
contents
}
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Contains(t, res.Container.From.WithEnvVariable.Exec.Stdout.Contents, "FOO=bar\n")
}
func TestContainerVariables(t *testing.T) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
t.Parallel()
res := struct {
Container struct {
From struct {
EnvVariables []schema.EnvVariable
Exec struct {
Stdout struct {
Contents string
}
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
envVariables {
name
value
}
exec(args: ["env"]) {
stdout {
contents
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, []schema.EnvVariable{
{Name: "PATH", Value: "/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
{Name: "GOLANG_VERSION", Value: "1.18.2"},
{Name: "GOPATH", Value: "/go"},
}, res.Container.From.EnvVariables)
require.Contains(t, res.Container.From.Exec.Stdout.Contents, "GOPATH=/go\n")
}
func TestContainerVariable(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
From struct {
EnvVariable *string
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
envVariable(name: "GOLANG_VERSION")
}
}
}`, &res, nil)
require.NoError(t, err)
require.NotNil(t, res.Container.From.EnvVariable)
require.Equal(t, "1.18.2", *res.Container.From.EnvVariable)
err = testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
envVariable(name: "UNKNOWN")
}
}
}`, &res, nil)
require.NoError(t, err)
require.Nil(t, res.Container.From.EnvVariable)
}
func TestContainerWithoutVariable(t *testing.T) {
t.Parallel()
res := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithoutEnvVariable struct {
EnvVariables []schema.EnvVariable
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
withoutEnvVariable(name: "GOLANG_VERSION") {
envVariables {
name
value
}
exec(args: ["env"]) {
stdout {
contents
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithoutEnvVariable.EnvVariables, []schema.EnvVariable{
{Name: "PATH", Value: "/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
{Name: "GOPATH", Value: "/go"},
})
require.NotContains(t, res.Container.From.WithoutEnvVariable.Exec.Stdout.Contents, "GOLANG_VERSION")
}
func TestContainerEnvVariablesReplace(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
WithEnvVariable struct {
EnvVariables []schema.EnvVariable
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err := testutil.Query(
`{
container {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
from(address: "golang:1.18.2-alpine") {
withEnvVariable(name: "GOPATH", value: "/gone") {
envVariables {
name
value
}
exec(args: ["env"]) {
stdout {
contents
}
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithEnvVariable.EnvVariables, []schema.EnvVariable{
{Name: "PATH", Value: "/go/bin:/usr/local/go/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"},
{Name: "GOLANG_VERSION", Value: "1.18.2"},
{Name: "GOPATH", Value: "/gone"},
})
require.Contains(t, res.Container.From.WithEnvVariable.Exec.Stdout.Contents, "GOPATH=/gone\n")
}
func TestContainerWorkdir(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
Workdir string
Exec struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Stdout struct {
Contents string
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
workdir
exec(args: ["pwd"]) {
stdout {
contents
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.Workdir, "/go")
require.Equal(t, res.Container.From.Exec.Stdout.Contents, "/go\n")
}
func TestContainerWithWorkdir(t *testing.T) {
t.Parallel()
res := struct {
Container struct {
From struct {
WithWorkdir struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Workdir string
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "golang:1.18.2-alpine") {
withWorkdir(path: "/usr") {
workdir
exec(args: ["pwd"]) {
stdout {
contents
}
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.Equal(t, res.Container.From.WithWorkdir.Workdir, "/usr")
require.Equal(t, res.Container.From.WithWorkdir.Exec.Stdout.Contents, "/usr\n")
}
func TestContainerWithMountedDirectory(t *testing.T) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
t.Parallel()
dirRes := struct {
Directory struct {
WithNewFile struct {
WithNewFile struct {
ID string
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.WithNewFile.ID
execRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithMountedDirectory struct {
Exec struct {
Stdout struct {
Contents string
}
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt", source: $id) {
exec(args: ["cat", "/mnt/some-file"]) {
stdout {
contents
}
exec(args: ["cat", "/mnt/some-dir/sub-file"]) {
stdout {
contents
}
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
require.Equal(t, "some-content", execRes.Container.From.WithMountedDirectory.Exec.Stdout.Contents)
require.Equal(t, "sub-content", execRes.Container.From.WithMountedDirectory.Exec.Exec.Stdout.Contents)
}
func TestContainerWithMountedDirectorySourcePath(t *testing.T) {
t.Parallel()
dirRes := struct {
Directory struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
WithNewFile struct {
WithNewFile struct {
Directory struct {
ID string
}
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
directory(path: "some-dir") {
id
}
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.WithNewFile.Directory.ID
execRes := struct {
Container struct {
From struct {
WithMountedDirectory struct {
Exec struct {
Exec struct {
Stdout struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Contents string
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt", source: $id) {
exec(args: ["sh", "-c", "echo >> /mnt/sub-file; echo -n more-content >> /mnt/sub-file"]) {
exec(args: ["cat", "/mnt/sub-file"]) {
stdout {
contents
}
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
require.Equal(t, "sub-content\nmore-content", execRes.Container.From.WithMountedDirectory.Exec.Exec.Stdout.Contents)
}
func TestContainerWithMountedDirectoryPropagation(t *testing.T) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
t.Parallel()
dirRes := struct {
Directory struct {
WithNewFile struct {
ID core.DirectoryID
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
id
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.ID
execRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithMountedDirectory struct {
Exec struct {
Stdout struct {
Contents string
}
Exec struct {
Exec struct {
Stdout struct {
Contents string
}
WithMountedDirectory struct {
Exec struct {
Stdout struct {
Contents string
}
Exec struct {
Stdout struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Contents string
}
}
}
}
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt", source: $id) {
exec(args: ["cat", "/mnt/some-file"]) {
# original content
stdout { contents }
exec(args: ["sh", "-c", "echo >> /mnt/some-file; echo -n more-content >> /mnt/some-file"]) {
exec(args: ["cat", "/mnt/some-file"]) {
# modified content should propagate
stdout { contents }
withMountedDirectory(path: "/mnt", source: $id) {
exec(args: ["cat", "/mnt/some-file"]) {
# should be back to the original content
stdout { contents }
exec(args: ["cat", "/mnt/some-file"]) {
# original content override should propagate
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
stdout { contents }
}
}
}
}
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
require.Equal(t,
"some-content",
execRes.Container.From.WithMountedDirectory.Exec.Stdout.Contents)
require.Equal(t,
"some-content\nmore-content",
execRes.Container.From.WithMountedDirectory.Exec.Exec.Exec.Stdout.Contents)
require.Equal(t,
"some-content",
execRes.Container.From.WithMountedDirectory.Exec.Exec.Exec.WithMountedDirectory.Exec.Stdout.Contents)
require.Equal(t,
"some-content",
execRes.Container.From.WithMountedDirectory.Exec.Exec.Exec.WithMountedDirectory.Exec.Exec.Stdout.Contents)
}
func TestContainerWithMountedFile(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
File struct {
ID core.FileID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
file(path: "some-dir/sub-file") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.File.ID
execRes := struct {
Container struct {
From struct {
WithMountedFile struct {
Exec struct {
Stdout struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Contents string
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: FileID!) {
container {
from(address: "alpine:3.16.2") {
withMountedFile(path: "/mnt/file", source: $id) {
exec(args: ["cat", "/mnt/file"]) {
stdout {
contents
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
require.Equal(t, "sub-content", execRes.Container.From.WithMountedFile.Exec.Stdout.Contents)
}
func TestContainerWithMountedCache(t *testing.T) {
t.Parallel()
cacheID := newCache(t)
execRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithEnvVariable struct {
WithMountedCache struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}
}{}
query := `query Test($cache: CacheID!, $rand: String!) {
container {
from(address: "alpine:3.16.2") {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
withEnvVariable(name: "RAND", value: $rand) {
withMountedCache(path: "/mnt/cache", cache: $cache) {
exec(args: ["sh", "-c", "echo $RAND >> /mnt/cache/file; cat /mnt/cache/file"]) {
stdout {
contents
}
}
}
}
}
}
}`
rand1 := identity.NewID()
err := testutil.Query(query, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"cache": cacheID,
"rand": rand1,
}})
require.NoError(t, err)
require.Equal(t, rand1+"\n", execRes.Container.From.WithEnvVariable.WithMountedCache.Exec.Stdout.Contents)
rand2 := identity.NewID()
err = testutil.Query(query, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"cache": cacheID,
"rand": rand2,
}})
require.NoError(t, err)
require.Equal(t, rand1+"\n"+rand2+"\n", execRes.Container.From.WithEnvVariable.WithMountedCache.Exec.Stdout.Contents)
}
func TestContainerWithMountedCacheFromDirectory(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
Directory struct {
ID core.FileID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-dir/sub-file", contents: "initial-content\n") {
directory(path: "some-dir") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
initialID := dirRes.Directory.WithNewFile.Directory.ID
cacheID := newCache(t)
execRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithEnvVariable struct {
WithMountedCache struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}
}{}
query := `query Test($cache: CacheID!, $rand: String!, $init: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withEnvVariable(name: "RAND", value: $rand) {
withMountedCache(path: "/mnt/cache", cache: $cache, source: $init) {
exec(args: ["sh", "-c", "echo $RAND >> /mnt/cache/sub-file; cat /mnt/cache/sub-file"]) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
stdout {
contents
}
}
}
}
}
}
}`
rand1 := identity.NewID()
err = testutil.Query(query, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"init": initialID,
"rand": rand1,
"cache": cacheID,
}})
require.NoError(t, err)
require.Equal(t, "initial-content\n"+rand1+"\n", execRes.Container.From.WithEnvVariable.WithMountedCache.Exec.Stdout.Contents)
rand2 := identity.NewID()
err = testutil.Query(query, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"init": initialID,
"rand": rand2,
"cache": cacheID,
}})
require.NoError(t, err)
require.Equal(t, "initial-content\n"+rand1+"\n"+rand2+"\n", execRes.Container.From.WithEnvVariable.WithMountedCache.Exec.Stdout.Contents)
}
func TestContainerWithMountedTemp(t *testing.T) {
t.Parallel()
execRes := struct {
Container struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
From struct {
WithMountedTemp struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err := testutil.Query(`{
container {
from(address: "alpine:3.16.2") {
withMountedTemp(path: "/mnt/tmp") {
exec(args: ["grep", "/mnt/tmp", "/proc/mounts"]) {
stdout {
contents
}
}
}
}
}
}`, &execRes, nil)
require.NoError(t, err)
require.Contains(t, execRes.Container.From.WithMountedTemp.Exec.Stdout.Contents, "tmpfs /mnt/tmp tmpfs")
}
func TestContainerMountsWithoutMount(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
WithNewFile struct {
ID string
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.WithNewFile.ID
execRes := struct {
Container struct {
From struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
WithMountedTemp struct {
Mounts []string
WithMountedDirectory struct {
Mounts []string
Exec struct {
Stdout struct {
Contents string
}
WithoutMount struct {
Mounts []string
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedTemp(path: "/mnt/tmp") {
mounts
withMountedDirectory(path: "/mnt/dir", source: $id) {
mounts
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
exec(args: ["ls", "/mnt/dir"]) {
stdout {
contents
}
withoutMount(path: "/mnt/dir") {
mounts
exec(args: ["ls", "/mnt/dir"]) {
stdout {
contents
}
}
}
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
require.Equal(t, []string{"/mnt/tmp"}, execRes.Container.From.WithMountedTemp.Mounts)
require.Equal(t, []string{"/mnt/tmp", "/mnt/dir"}, execRes.Container.From.WithMountedTemp.WithMountedDirectory.Mounts)
require.Equal(t, "some-dir\nsome-file\n", execRes.Container.From.WithMountedTemp.WithMountedDirectory.Exec.Stdout.Contents)
require.Equal(t, "", execRes.Container.From.WithMountedTemp.WithMountedDirectory.Exec.WithoutMount.Exec.Stdout.Contents)
require.Equal(t, []string{"/mnt/tmp"}, execRes.Container.From.WithMountedTemp.WithMountedDirectory.Exec.WithoutMount.Mounts)
}
func TestContainerStackedMounts(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
ID string
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "lower-content") {
id
}
}
}`, &dirRes, nil)
require.NoError(t, err)
lowerID := dirRes.Directory.WithNewFile.ID
err = testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "upper-content") {
id
}
}
}`, &dirRes, nil)
require.NoError(t, err)
upperID := dirRes.Directory.WithNewFile.ID
execRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithMountedDirectory struct {
Mounts []string
Exec struct {
Stdout struct {
Contents string
}
WithMountedDirectory struct {
Mounts []string
Exec struct {
Stdout struct {
Contents string
}
WithoutMount struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Mounts []string
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($lower: DirectoryID!, $upper: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $lower) {
mounts
exec(args: ["cat", "/mnt/dir/some-file"]) {
stdout {
contents
}
withMountedDirectory(path: "/mnt/dir", source: $upper) {
mounts
exec(args: ["cat", "/mnt/dir/some-file"]) {
stdout {
contents
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
withoutMount(path: "/mnt/dir") {
mounts
exec(args: ["cat", "/mnt/dir/some-file"]) {
stdout {
contents
}
}
}
}
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"lower": lowerID,
"upper": upperID,
}})
require.NoError(t, err)
require.Equal(t, []string{"/mnt/dir"}, execRes.Container.From.WithMountedDirectory.Mounts)
require.Equal(t, "lower-content", execRes.Container.From.WithMountedDirectory.Exec.Stdout.Contents)
require.Equal(t, []string{"/mnt/dir", "/mnt/dir"}, execRes.Container.From.WithMountedDirectory.Exec.WithMountedDirectory.Mounts)
require.Equal(t, "upper-content", execRes.Container.From.WithMountedDirectory.Exec.WithMountedDirectory.Exec.Stdout.Contents)
require.Equal(t, []string{"/mnt/dir"}, execRes.Container.From.WithMountedDirectory.Exec.WithMountedDirectory.Exec.WithoutMount.Mounts)
require.Equal(t, "lower-content", execRes.Container.From.WithMountedDirectory.Exec.WithMountedDirectory.Exec.WithoutMount.Exec.Stdout.Contents)
}
func TestContainerDirectory(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
WithNewFile struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.WithNewFile.ID
writeRes := struct {
Container struct {
From struct {
WithMountedDirectory struct {
WithMountedDirectory struct {
Exec struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
ID core.DirectoryID
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withMountedDirectory(path: "/mnt/dir/overlap", source: $id) {
exec(args: ["sh", "-c", "echo hello >> /mnt/dir/overlap/another-file"]) {
directory(path: "/mnt/dir/overlap") {
id
}
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
writtenID := writeRes.Container.From.WithMountedDirectory.WithMountedDirectory.Exec.Directory.ID
execRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
WithMountedDirectory struct {
Exec struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Stdout struct {
Contents string
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
exec(args: ["cat", "/mnt/dir/another-file"]) {
stdout {
contents
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "hello\n", execRes.Container.From.WithMountedDirectory.Exec.Stdout.Contents)
}
func TestContainerDirectoryErrors(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
WithNewFile struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
withNewFile(path: "some-dir/sub-file", contents: "sub-content") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.WithNewFile.ID
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
directory(path: "/mnt/dir/some-file") {
id
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "path /mnt/dir/some-file is a file, not a directory")
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
directory(path: "/mnt/dir/bogus") {
id
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: no such file or directory")
err = testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withMountedTemp(path: "/mnt/tmp") {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
directory(path: "/mnt/tmp/bogus") {
id
}
}
}
}
}`, nil, nil)
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from tmpfs")
cacheID := newCache(t)
err = testutil.Query(
`query Test($cache: CacheID!) {
container {
from(address: "alpine:3.16.2") {
withMountedCache(path: "/mnt/cache", cache: $cache) {
directory(path: "/mnt/cache/bogus") {
id
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"cache": cacheID,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from cache")
}
func TestContainerDirectorySourcePath(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
Directory struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-dir/sub-dir/sub-file", contents: "sub-content\n") {
directory(path: "some-dir") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.Directory.ID
writeRes := struct {
Container struct {
From struct {
WithMountedDirectory struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Exec struct {
Directory struct {
ID core.DirectoryID
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
exec(args: ["sh", "-c", "echo more-content >> /mnt/dir/sub-dir/sub-file"]) {
directory(path: "/mnt/dir/sub-dir") {
id
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
writtenID := writeRes.Container.From.WithMountedDirectory.Exec.Directory.ID
execRes := struct {
Container struct {
From struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
WithMountedDirectory struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
exec(args: ["cat", "/mnt/dir/sub-file"]) {
stdout {
contents
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "sub-content\nmore-content\n", execRes.Container.From.WithMountedDirectory.Exec.Stdout.Contents)
}
func TestContainerFile(t *testing.T) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
t.Parallel()
id := newDirWithFile(t, "some-file", "some-content-")
writeRes := struct {
Container struct {
From struct {
WithMountedDirectory struct {
WithMountedDirectory struct {
Exec struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
File struct {
ID core.FileID
}
}
}
}
}
}
}{}
err := testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
withMountedDirectory(path: "/mnt/dir/overlap", source: $id) {
exec(args: ["sh", "-c", "echo -n appended >> /mnt/dir/overlap/some-file"]) {
file(path: "/mnt/dir/overlap/some-file") {
id
}
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
writtenID := writeRes.Container.From.WithMountedDirectory.WithMountedDirectory.Exec.File.ID
execRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
WithMountedFile struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: FileID!) {
container {
from(address: "alpine:3.16.2") {
withMountedFile(path: "/mnt/file", source: $id) {
exec(args: ["cat", "/mnt/file"]) {
stdout {
contents
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "some-content-appended", execRes.Container.From.WithMountedFile.Exec.Stdout.Contents)
}
func TestContainerFileErrors(t *testing.T) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
t.Parallel()
id := newDirWithFile(t, "some-file", "some-content")
err := testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
file(path: "/mnt/dir/bogus") {
id
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: no such file or directory")
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
file(path: "/mnt/dir") {
id
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "path /mnt/dir is a directory, not a file")
err = testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
withMountedTemp(path: "/mnt/tmp") {
file(path: "/mnt/tmp/bogus") {
id
}
}
}
}
}`, nil, nil)
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from tmpfs")
cacheID := newCache(t)
err = testutil.Query(
`query Test($cache: CacheID!) {
container {
from(address: "alpine:3.16.2") {
withMountedCache(path: "/mnt/cache", cache: $cache) {
file(path: "/mnt/cache/bogus") {
id
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"cache": cacheID,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "bogus: cannot retrieve path from cache")
secretID := newSecret(t, "some-secret")
err = testutil.Query(
`query Test($secret: SecretID!) {
container {
from(address: "alpine:3.16.2") {
withMountedSecret(path: "/sekret", source: $secret) {
file(path: "/sekret") {
contents
}
}
}
}
}`, nil, &testutil.QueryOptions{Variables: map[string]any{
"secret": secretID,
}})
require.Error(t, err)
require.Contains(t, err.Error(), "sekret: no such file or directory")
}
func TestContainerFSDirectory(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Container struct {
From struct {
Directory struct {
ID core.DirectoryID
}
}
}
}{}
err := testutil.Query(
`{
container {
from(address: "alpine:3.16.2") {
directory(path: "/etc") {
id
}
}
}
}`, &dirRes, nil)
require.NoError(t, err)
etcID := dirRes.Container.From.Directory.ID
execRes := struct {
Container struct {
From struct {
WithMountedDirectory struct {
Exec struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Stdout struct {
Contents string
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/etc", source: $id) {
exec(args: ["cat", "/mnt/etc/alpine-release"]) {
stdout {
contents
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": etcID,
}})
require.NoError(t, err)
require.Equal(t, "3.16.2\n", execRes.Container.From.WithMountedDirectory.Exec.Stdout.Contents)
}
func TestContainerRelativePaths(t *testing.T) {
t.Parallel()
dirRes := struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
WithNewFile struct {
ID core.DirectoryID
}
}
}{}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
id
}
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.WithNewFile.ID
writeRes := struct {
Container struct {
From struct {
Exec struct {
WithWorkdir struct {
WithWorkdir struct {
Workdir string
WithMountedDirectory struct {
WithMountedTemp struct {
WithMountedCache struct {
Mounts []string
Exec struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Directory struct {
ID core.DirectoryID
}
}
WithoutMount struct {
Mounts []string
}
}
}
}
}
}
}
}
}
}{}
cacheID := newCache(t)
err = testutil.Query(
`query Test($id: DirectoryID!, $cache: CacheID!) {
container {
from(address: "alpine:3.16.2") {
exec(args: ["mkdir", "-p", "/mnt/sub"]) {
withWorkdir(path: "/mnt") {
withWorkdir(path: "sub") {
workdir
withMountedDirectory(path: "dir", source: $id) {
withMountedTemp(path: "tmp") {
withMountedCache(path: "cache", cache: $cache) {
mounts
exec(args: ["touch", "dir/another-file"]) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
directory(path: "dir") {
id
}
}
withoutMount(path: "cache") {
mounts
}
}
}
}
}
}
}
}
}
}`, &writeRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
"cache": cacheID,
}})
require.NoError(t, err)
require.Equal(t,
[]string{"/mnt/sub/dir", "/mnt/sub/tmp", "/mnt/sub/cache"},
writeRes.Container.From.Exec.WithWorkdir.WithWorkdir.WithMountedDirectory.WithMountedTemp.WithMountedCache.Mounts)
require.Equal(t,
[]string{"/mnt/sub/dir", "/mnt/sub/tmp"},
writeRes.Container.From.Exec.WithWorkdir.WithWorkdir.WithMountedDirectory.WithMountedTemp.WithMountedCache.WithoutMount.Mounts)
writtenID := writeRes.Container.From.Exec.WithWorkdir.WithWorkdir.WithMountedDirectory.WithMountedTemp.WithMountedCache.Exec.Directory.ID
execRes := struct {
Container struct {
From struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
WithMountedDirectory struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "alpine:3.16.2") {
withMountedDirectory(path: "/mnt/dir", source: $id) {
exec(args: ["ls", "/mnt/dir"]) {
stdout {
contents
}
}
}
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": writtenID,
}})
require.NoError(t, err)
require.Equal(t, "another-file\nsome-file\n", execRes.Container.From.WithMountedDirectory.Exec.Stdout.Contents)
}
func TestContainerMultiFrom(t *testing.T) {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
t.Parallel()
dirRes := struct {
Directory struct {
ID core.DirectoryID
}
}{}
err := testutil.Query(
`{
directory {
id
}
}`, &dirRes, nil)
require.NoError(t, err)
id := dirRes.Directory.ID
execRes := struct {
Container struct {
From struct {
WithMountedDirectory struct {
Exec struct {
From struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
Exec struct {
Exec struct {
Stdout struct {
Contents string
}
}
}
}
}
}
}
}
}{}
err = testutil.Query(
`query Test($id: DirectoryID!) {
container {
from(address: "node:18.10.0-alpine") {
withMountedDirectory(path: "/mnt", source: $id) {
exec(args: ["sh", "-c", "node --version >> /mnt/versions"]) {
from(address: "golang:1.18.2-alpine") {
exec(args: ["sh", "-c", "go version >> /mnt/versions"]) {
exec(args: ["cat", "/mnt/versions"]) {
stdout {
contents
}
}
}
}
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}
}`, &execRes, &testutil.QueryOptions{Variables: map[string]any{
"id": id,
}})
require.NoError(t, err)
require.Contains(t, execRes.Container.From.WithMountedDirectory.Exec.From.Exec.Exec.Stdout.Contents, "v18.10.0\n")
require.Contains(t, execRes.Container.From.WithMountedDirectory.Exec.From.Exec.Exec.Stdout.Contents, "go version go1.18.2")
}
func TestContainerPublish(t *testing.T) {
ctx := context.Background()
c, err := dagger.Connect(ctx)
require.NoError(t, err)
defer c.Close()
randomID := identity.NewID()
go func() {
err := c.Do(ctx,
&dagger.Request{
Query: `query RunRegistry($rand: String!) {
container {
from(address: "registry:2") {
withEnvVariable(name: "RANDOM", value: $rand) {
exec(args: ["/etc/docker/registry/config.yml"]) {
stdout {
contents
}
stderr {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
contents
}
}
}
}
}
}`,
Variables: map[string]any{
"rand": randomID,
},
},
&dagger.Response{Data: new(map[string]any)},
)
if err != nil {
t.Logf("error running registry: %v", err)
}
}()
err = c.Do(ctx,
&dagger.Request{
Query: `query WaitForRegistry($rand: String!) {
container {
from(address: "alpine:3.16.2") {
withEnvVariable(name: "RANDOM", value: $rand) {
exec(args: ["sh", "-c", "for i in $(seq 1 60); do nc -zv 127.0.0.1 5000 && exit 0; sleep 1; done; exit 1"]) {
stdout {
contents
}
}
}
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
}
}`,
Variables: map[string]any{
"rand": randomID,
},
},
&dagger.Response{Data: new(map[string]any)},
)
require.NoError(t, err)
testRef := core.ContainerAddress("127.0.0.1:5000/testimagepush:latest")
err = c.Do(ctx,
&dagger.Request{
Query: `query TestImagePush($ref: ContainerAddress!) {
container {
from(address: "alpine:3.16.2") {
publish(address: $ref)
}
}
}`,
Variables: map[string]any{
"ref": testRef,
},
},
&dagger.Response{Data: new(map[string]any)},
)
require.NoError(t, err)
res := struct {
Container struct {
From struct {
Fs struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/integration/container_test.go
|
File struct {
Contents string
}
}
}
}
}{}
err = c.Do(ctx,
&dagger.Request{
Query: `query TestImagePull($ref: ContainerAddress!) {
container {
from(address: $ref) {
fs {
file(path: "/etc/alpine-release") {
contents
}
}
}
}
}`,
Variables: map[string]any{
"ref": testRef,
},
},
&dagger.Response{Data: &res},
)
require.NoError(t, err)
require.Equal(t, res.Container.From.Fs.File.Contents, "3.16.2\n")
}
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/schema/container.go
|
package schema
import (
"encoding/json"
"fmt"
"path"
"strings"
"github.com/docker/distribution/reference"
"github.com/moby/buildkit/client/llb"
specs "github.com/opencontainers/image-spec/specs-go/v1"
"go.dagger.io/dagger/core"
"go.dagger.io/dagger/router"
)
type containerSchema struct {
|
closed
|
dagger/dagger
|
https://github.com/dagger/dagger
| 3,340 |
API: inline ExecOpts in exec
|
Would it make sense to move that stuff as optional arguments to `exec`, rather than wrapped in a `ExecOpts` input?
Otherwise it ends up double wrapped:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Opts: dagger.ExecOpts {
Stdin: "foo",
}
}
```
vs:
```go
Exec(dagger.ContainerExecOpts{
Args: []string{"ls"},
Stdin: "foo",
}
```
/cc @vito @shykes
|
https://github.com/dagger/dagger/issues/3340
|
https://github.com/dagger/dagger/pull/3402
|
1d9236da031514e3c5f8dbcfb186eb87ea3af5d6
|
1cc6d7b558c44d2512f582e4fa6ce447b327cd3c
| 2022-10-12T20:15:16Z |
go
| 2022-10-18T20:20:37Z |
core/schema/container.go
|
*baseSchema
}
var _ router.ExecutableSchema = &containerSchema{}
func (s *containerSchema) Name() string {
return "container"
}
func (s *containerSchema) Schema() string {
return Container
}
func (s *containerSchema) Resolvers() router.Resolvers {
return router.Resolvers{
"ContainerID": stringResolver(core.ContainerID("")),
"ContainerAddress": stringResolver(core.ContainerAddress("")),
"Query": router.ObjectResolver{
"container": router.ToResolver(s.container),
},
"Container": router.ObjectResolver{
"from": router.ToResolver(s.from),
"fs": router.ToResolver(s.fs),
"withFS": router.ToResolver(s.withFS),
"file": router.ToResolver(s.file),
"directory": router.ToResolver(s.directory),
"user": router.ToResolver(s.user),
"withUser": router.ToResolver(s.withUser),
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.