Add new Client API

Signed-off-by: Helder Correia <174525+helderco@users.noreply.github.com>
This commit is contained in:
Helder Correia 2022-03-07 12:12:39 -01:00
parent a5a0207dde
commit da90baa087
No known key found for this signature in database
GPG Key ID: C6490D872EF1DCA7
30 changed files with 1566 additions and 9 deletions

View File

@ -45,6 +45,14 @@ func (v *Value) FillFields(values map[string]interface{}) (*Value, error) {
return v, nil return v, nil
} }
// Fill updates a value, in place
func (v *Value) Fill(value interface{}) (*Value, error) {
if err := v.FillPath(cue.MakePath(), value); err != nil {
return nil, err
}
return v, nil
}
// LookupPath is a concurrency safe wrapper around cue.Value.LookupPath // LookupPath is a concurrency safe wrapper around cue.Value.LookupPath
func (v *Value) LookupPath(p cue.Path) *Value { func (v *Value) LookupPath(p cue.Path) *Value {
v.cc.rlock() v.cc.rlock()
@ -93,6 +101,19 @@ func (f Field) Label() string {
return l return l
} }
// ParentLabel returns the unquoted parent selector of a value
func (v *Value) ParentLabel(depth int) string {
sel := v.Path().Selectors()
if depth > len(sel) {
return ""
}
l := sel[len(sel)-depth].String()
if unquoted, err := strconv.Unquote(l); err == nil {
return unquoted
}
return l
}
// Proxy function to the underlying cue.Value // Proxy function to the underlying cue.Value
// Field ordering is guaranteed to be stable. // Field ordering is guaranteed to be stable.
func (v *Value) Fields(opts ...cue.Option) ([]Field, error) { func (v *Value) Fields(opts ...cue.Option) ([]Field, error) {

View File

@ -0,0 +1,190 @@
---
slug: /1203/client
displayed_sidebar: europa
---
# Interacting with the client
`dagger.#Plan` has a `client` field that allows interaction with the local machine where the `dagger` command line client is run. You can:
- Read and write files and directories;
- Use local sockets;
- Load environment variables;
- Run commands;
- Get current platform.
## Accessing the file system
You may need to load a local directory as a `dagger.#FS` type in your plan:
```cue
dagger.#Plan & {
// Path may be absolute, or relative to current working directory
client: filesystem: ".": read: {
// CUE type defines expected content
contents: dagger.#FS
exclude: ["node_modules"]
}
actions: {
...
copy: docker.Copy & {
contents: client.filesystem.".".read.contents
}
...
}
}
```
Its also easy to write a file locally:
```cue
dagger.#Plan & {
client: filesystem: "config.yaml": write: {
contents: yaml.Marshal(actions.pull.output.config)
}
actions: {
pull: docker.#Pull & {
source: "alpine"
}
}
}
```
## Using a local socket
You can use a local socket in an action:
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
<Tabs defaultValue="unix" groupId="client-env">
<TabItem value="unix" label="Linux/macOS">
```cue
dagger.#Plan & {
client: filesystem: "/var/run/docker.sock": read: {
contents: dagger.#Service
}
actions: {
image: alpine.#Build & {
packages: "docker-cli": {}
}
run: docker.#Run & {
input: image.output
mounts: docker: {
dest: "/var/run/docker.sock"
contents: client.filesystem."/var/run/docker.sock".read.contents
}
command: {
name: "docker"
args: ["info"]
}
}
}
}
```
</TabItem>
<TabItem value="windows" label="Windows">
```cue
dagger.#Plan & {
client: filesystem: "//./pipe/docker_engine": read: {
contents: dagger.#Service
type: "npipe"
}
actions: {
image: alpine.#Build & {
packages: "docker-cli": {}
}
run: docker.#Run & {
input: image.output
mounts: docker: {
dest: "/var/run/docker.sock"
contents: client.filesystem."//./pipe/docker_engine".read.contents
}
command: {
name: "docker"
args: ["info"]
}
}
}
}
```
</TabItem>
</Tabs>
## Environment variables
Environment variables can be read from the local machine as strings or secrets, just specify the type:
```cue
dagger.#Plan & {
client: env: {
GITLAB_USER: string
GITLAB_TOKEN: dagger.#Secret
}
actions: {
pull: docker.#Pull & {
source: "registry.gitlab.com/myuser/myrepo"
auth: {
username: client.env.GITLAB_USR
secret: client.env.GITLAB_TOKEN
}
}
}
}
```
## Running commands
Sometimes you need something more advanced that only a local command can give you:
```cue
dagger.#Plan & {
client: commands: {
os: {
name: "uname"
args: ["-s"]
}
arch: {
name: "uname"
args: ["-m"]
}
}
actions: {
build: docker.#Run & {
env: {
CLIENT_OS: client.commands.os.stdout
CLIENT_ARCH: client.commands.arch.stdout
}
}
}
}
```
You can also capture `stderr` for errors and provide `stdin` for input.
## Platform
If you need the current platform though, theres a more portable way than running `uname` like in the previous example:
```cue
dagger.#Plan & {
client: platform: _
actions: {
build: docker.#Run & {
env: {
CLIENT_OS: client.platform.os
CLIENT_ARCH: client.platform.arch
}
}
}
}
```

View File

@ -1,6 +0,0 @@
---
slug: /1203/inputs
displayed_sidebar: europa
---
# Configuring inputs

View File

@ -4,3 +4,85 @@ displayed_sidebar: europa
--- ---
# How to use secrets # How to use secrets
Most operations in `client` support handling secrets (see [Interacting with the client](./1203-client.md)). More specifically, you can:
- Write a secret to a file;
- Read a secret from a file;
- Read a secret from an environment variable;
- Read a secret from the output of a command;
- Use a secret as the input of a command.
## Environmnet
The simplest use case is reading from an environment variable:
```cue
dagger.#Plan & {
client: env: GITHUB_TOKEN: dagger.#Secret
}
```
## File
You may need to trim the whitespace, especially when reading from a file:
```cue
dagger.#Plan & {
// Path may be absolute, or relative to current working directory
client: filesystem: ".registry": read: {
// CUE type defines expected content
contents: dagger.#Secret
}
actions: {
registry: dagger.#TrimSecret & {
input: client.filesystem.".registry".read.contents
}
pull: docker.#Pull & {
source: "myprivate/image"
auth: {
username: "_token_"
secret: registry.output
}
}
}
}
```
## SOPS
Theres many ways to store encrypted secrets in your git repository. If you use [SOPS](https://github.com/mozilla/sops), here's a simple example where you can access keys from an encrypted yaml file:
```yaml title="secrets.yaml"
myToken: ENC[AES256_GCM,data:AlUz7g==,iv:lq3mHi4GDLfAssqhPcuUIHMm5eVzJ/EpM+q7RHGCROU=,tag:dzbT5dEGhMnHbiRTu4bHdg==,type:str]
sops:
...
```
```cue title="main.cue"
dagger.#Plan & {
client: commands: sops: {
name: "sops"
args: ["-d", "./secrets.yaml"]
stdout: dagger.#Secret
}
actions: {
// Makes the yaml keys easily accessible
secrets: dagger.#DecodeSecret & {
input: client.commands.sops.stdout
format: "yaml"
}
run: docker.#Run & {
mounts: secret: {
dest: "/run/secrets/token"
contents: secrets.output.myToken
}
// Do something with `/run/secrets/token`
...
}
}
}
```

View File

@ -2,6 +2,37 @@ package dagger
// A special kind of program which `dagger` can execute. // A special kind of program which `dagger` can execute.
#Plan: { #Plan: {
// Access client machine
client: {
// Access client filesystem
// Path may be absolute, or relative to client working directory
filesystem: [path=string]: {
// Read data from that path
read?: _#clientFilesystemRead & {
"path": path
}
// If set, Write to that path
write?: _#clientFilesystemWrite & {
"path": path
// avoid race condition
if read != _|_ {
_after: read
}
}
}
// Access client environment variables
env: [string]: *string | #Secret
// Execute commands in the client
commands: [id=string]: _#clientCommand
// Platform of the client machine
platform: _#clientPlatform
}
// Receive inputs from the client // Receive inputs from the client
inputs: { inputs: {
// Receive directories // Receive directories
@ -32,6 +63,84 @@ package dagger
} }
} }
_#clientFilesystemRead: {
$dagger: task: _name: "ClientFilesystemRead"
// Path may be absolute, or relative to client working directory
path: string
{
// CUE type defines expected content:
// string: contents of a regular file
// #Secret: secure reference to the file contents
contents: string | #Secret
} | {
// CUE type defines expected content:
// #FS: contents of a directory
contents: #FS
// Filename patterns to include
// Example: ["*.go", "Dockerfile"]
include?: [...string]
// Filename patterns to exclude
// Example: ["node_modules"]
exclude?: [...string]
} | {
// CUE type defines expected content:
// #Service: unix socket or npipe
contents: #Service
// Type of service
type: *"unix" | "npipe"
}
}
_#clientFilesystemWrite: {
$dagger: task: _name: "ClientFilesystemWrite"
// Path may be absolute, or relative to client working directory
path: string
{
// File contents to export (as a string or secret)
contents: string | #Secret
// File permissions (defaults to 0o644)
permissions?: int
} | {
// Filesystem contents to export
// Reference an #FS field produced by an action
contents: #FS
}
}
_#clientCommand: {
$dagger: task: _name: "ClientCommand"
name: string
args: [...string]
flags: [string]: bool | string
env: [string]: string | #Secret
// Capture standard output (as a string or secret)
stdout?: *string | #Secret
// Capture standard error (as a string or secret)
stderr?: *string | #Secret
// Inject standard input (from a string or secret)
stdin?: string | #Secret
}
_#clientPlatform: {
$dagger: task: _name: "ClientPlatform"
// Operating system of the client machine
os: string
// Hardware architecture of the client machine
arch: string
}
_#inputDirectory: { _#inputDirectory: {
// FIXME: rename to "InputDirectory" for consistency // FIXME: rename to "InputDirectory" for consistency
$dagger: task: _name: "InputDirectory" $dagger: task: _name: "InputDirectory"

165
plan/task/clientcommand.go Normal file
View File

@ -0,0 +1,165 @@
package task
import (
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"strings"
"cuelang.org/go/cue"
"github.com/rs/zerolog/log"
"go.dagger.io/dagger/compiler"
"go.dagger.io/dagger/plancontext"
"go.dagger.io/dagger/solver"
)
func init() {
Register("ClientCommand", func() Task { return &clientCommandTask{} })
}
type clientCommandTask struct {
}
func (t clientCommandTask) Run(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value) (*compiler.Value, error) {
var opts struct {
Name string
Args []string
}
if err := v.Decode(&opts); err != nil {
return nil, err
}
flags, err := v.Lookup("flags").Fields()
if err != nil {
return nil, err
}
var flagArgs []string
for _, flag := range flags {
switch flag.Value.Kind() {
case cue.BoolKind:
if b, _ := flag.Value.Bool(); b {
flagArgs = append(flagArgs, flag.Label())
}
case cue.StringKind:
if s, _ := flag.Value.String(); s != "" {
flagArgs = append(flagArgs, flag.Label(), s)
}
}
}
opts.Args = append(flagArgs, opts.Args...)
envs, err := v.Lookup("env").Fields()
if err != nil {
return nil, err
}
env := make([]string, len(envs))
for _, envvar := range envs {
s, err := t.getString(pctx, envvar.Value)
if err != nil {
return nil, err
}
env = append(env, fmt.Sprintf("%s=%s", envvar.Label(), s))
}
lg := log.Ctx(ctx)
lg.Debug().Str("name", opts.Name).Str("args", strings.Join(opts.Args, " ")).Msg("running client command")
cmd := exec.CommandContext(ctx, opts.Name, opts.Args...) //#nosec G204
cmd.Env = append(os.Environ(), env...)
if i := v.Lookup("stdin"); i.Exists() {
val, err := t.getString(pctx, i)
if err != nil {
return nil, err
}
stdin, err := cmd.StdinPipe()
if err != nil {
return nil, err
}
go func() {
defer stdin.Close()
io.WriteString(stdin, val)
}()
}
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
if err := cmd.Start(); err != nil {
return nil, err
}
stdoutVal, err := t.readPipe(&stdout, pctx, v.Lookup("stdout"))
if err != nil {
return nil, err
}
stderrVal, err := t.readPipe(&stderr, pctx, v.Lookup("stderr"))
if err != nil {
return nil, err
}
if err := cmd.Wait(); err != nil {
var exitErr *exec.ExitError
if errors.As(err, &exitErr) {
// FIXME: stderr may be requested as a secret
lg.Err(err).Msg(string(exitErr.Stderr))
}
return nil, err
}
return compiler.NewValue().FillFields(map[string]interface{}{
"stdout": stdoutVal,
"stderr": stderrVal,
})
}
func (t clientCommandTask) getString(pctx *plancontext.Context, v *compiler.Value) (string, error) {
if plancontext.IsSecretValue(v) {
secret, err := pctx.Secrets.FromValue(v)
if err != nil {
return "", err
}
return secret.PlainText(), nil
}
s, err := v.String()
if err != nil {
return "", err
}
return s, nil
}
func (t clientCommandTask) readPipe(pipe *io.ReadCloser, pctx *plancontext.Context, v *compiler.Value) (*compiler.Value, error) {
slurp, err := io.ReadAll(*pipe)
if err != nil {
return nil, err
}
read := string(slurp)
val, _ := v.Default()
out := compiler.NewValue()
if plancontext.IsSecretValue(val) {
secret := pctx.Secrets.New(read)
return out.Fill(secret.MarshalCUE())
}
return out.Fill(read)
}

53
plan/task/clientenv.go Normal file
View File

@ -0,0 +1,53 @@
package task
import (
"context"
"fmt"
"os"
"cuelang.org/go/cue"
"github.com/rs/zerolog/log"
"go.dagger.io/dagger/compiler"
"go.dagger.io/dagger/plancontext"
"go.dagger.io/dagger/solver"
)
func init() {
Register("client.env.*", func() Task { return &clientEnvTask{} })
}
type clientEnvTask struct {
}
func (t clientEnvTask) Run(ctx context.Context, pctx *plancontext.Context, _ solver.Solver, v *compiler.Value) (*compiler.Value, error) {
lg := log.Ctx(ctx)
envvar := v.ParentLabel(1)
lg.Debug().Str("envvar", envvar).Msg("loading environment variable")
env := os.Getenv(envvar)
if env == "" {
return nil, fmt.Errorf("environment variable %q not set", envvar)
}
// Resolve default in disjunction if a type hasn't been specified
val, _ := v.Default()
out := compiler.NewValue()
if plancontext.IsSecretValue(val) {
secret := pctx.Secrets.New(env)
return out.Fill(secret.MarshalCUE())
}
if val.IsConcrete() {
return nil, fmt.Errorf("unexpected concrete value, please use a type")
}
k := val.IncompleteKind()
if k == cue.StringKind {
return out.Fill(env)
}
return nil, fmt.Errorf("unsupported type %q", k)
}

View File

@ -0,0 +1,199 @@
package task
import (
"context"
"errors"
"fmt"
"os"
"path/filepath"
"cuelang.org/go/cue"
"github.com/moby/buildkit/client/llb"
"github.com/rs/zerolog/log"
"go.dagger.io/dagger/compiler"
"go.dagger.io/dagger/plancontext"
"go.dagger.io/dagger/solver"
)
func init() {
Register("ClientFilesystemRead", func() Task { return &clientFilesystemReadTask{} })
}
type clientFilesystemReadTask struct {
}
func (t clientFilesystemReadTask) PreRun(ctx context.Context, pctx *plancontext.Context, v *compiler.Value) error {
path, err := t.parsePath(v)
if err != nil {
return err
}
if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
return fmt.Errorf("path %q does not exist", path)
}
if plancontext.IsFSValue(v.Lookup("contents")) {
pctx.LocalDirs.Add(path)
}
return nil
}
func (t clientFilesystemReadTask) Run(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value) (*compiler.Value, error) {
path, err := t.parsePath(v)
if err != nil {
return nil, err
}
contents, err := t.readContents(ctx, pctx, s, v, path)
if err != nil {
return nil, err
}
return compiler.NewValue().FillFields(map[string]interface{}{
"contents": contents,
})
}
func (t clientFilesystemReadTask) parsePath(v *compiler.Value) (path string, err error) {
path, err = v.Lookup("path").String()
if err != nil {
return
}
// Keep socket paths as is (e.g., npipe)
if plancontext.IsServiceValue(v.Lookup("contents")) {
return
}
path, err = filepath.Abs(path)
if err != nil {
return
}
return
}
func (t clientFilesystemReadTask) readContents(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value, path string) (interface{}, error) {
lg := log.Ctx(ctx)
contents := v.Lookup("contents")
if plancontext.IsFSValue(contents) {
lg.Debug().Str("path", path).Msg("loading local directory")
return t.readFS(ctx, pctx, s, v, path)
}
if plancontext.IsServiceValue(contents) {
lg.Debug().Str("path", path).Msg("loading local service")
return t.readService(pctx, v, path)
}
if plancontext.IsSecretValue(contents) {
lg.Debug().Str("path", path).Msg("loading local secret file")
return t.readSecret(pctx, path)
}
if contents.IsConcrete() {
return nil, fmt.Errorf("unexpected concrete value, please use a type")
}
k := contents.IncompleteKind()
if k == cue.StringKind {
lg.Debug().Str("path", path).Msg("loading local file")
return t.readString(path)
}
return nil, fmt.Errorf("unsupported type %q", k)
}
func (t clientFilesystemReadTask) readFS(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value, path string) (*compiler.Value, error) {
var dir struct {
Include []string
Exclude []string
}
if err := v.Decode(&dir); err != nil {
return nil, err
}
opts := []llb.LocalOption{
withCustomName(v, "Local %s", path),
// Without hint, multiple `llb.Local` operations on the
// same path get a different digest.
llb.SessionID(s.SessionID()),
llb.SharedKeyHint(path),
}
if len(dir.Include) > 0 {
opts = append(opts, llb.IncludePatterns(dir.Include))
}
// Excludes .dagger directory by default
excludePatterns := []string{"**/.dagger/"}
if len(dir.Exclude) > 0 {
excludePatterns = dir.Exclude
}
opts = append(opts, llb.ExcludePatterns(excludePatterns))
// FIXME: Remove the `Copy` and use `Local` directly.
//
// Copy'ing is a costly operation which should be unnecessary.
// However, using llb.Local directly breaks caching sometimes for unknown reasons.
st := llb.Scratch().File(
llb.Copy(
llb.Local(
path,
opts...,
),
"/",
"/",
),
withCustomName(v, "Local %s [copy]", path),
)
result, err := s.Solve(ctx, st, pctx.Platform.Get())
if err != nil {
return nil, err
}
fs := pctx.FS.New(result)
return fs.MarshalCUE(), nil
}
func (t clientFilesystemReadTask) readService(pctx *plancontext.Context, v *compiler.Value, path string) (*compiler.Value, error) {
typ, err := v.Lookup("type").String()
if err != nil {
return nil, err
}
var unix, npipe string
switch typ {
case "unix":
unix = path
case "npipe":
npipe = path
default:
return nil, fmt.Errorf("invalid service type %q", typ)
}
service := pctx.Services.New(unix, npipe)
return service.MarshalCUE(), nil
}
func (t clientFilesystemReadTask) readSecret(pctx *plancontext.Context, path string) (*compiler.Value, error) {
contents, err := t.readString(path)
if err != nil {
return nil, err
}
secret := pctx.Secrets.New(contents)
return secret.MarshalCUE(), nil
}
func (t clientFilesystemReadTask) readString(path string) (string, error) {
contents, err := os.ReadFile(path)
if err != nil {
return "", err
}
return string(contents), nil
}

View File

@ -0,0 +1,100 @@
package task
import (
"context"
"fmt"
"io/fs"
"os"
"path/filepath"
"cuelang.org/go/cue"
bk "github.com/moby/buildkit/client"
"github.com/rs/zerolog/log"
"go.dagger.io/dagger/compiler"
"go.dagger.io/dagger/plancontext"
"go.dagger.io/dagger/solver"
)
func init() {
Register("ClientFilesystemWrite", func() Task { return &clientFilesystemWriteTask{} })
}
type clientFilesystemWriteTask struct {
}
func (t clientFilesystemWriteTask) Run(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value) (*compiler.Value, error) {
path, err := v.Lookup("path").String()
if err != nil {
return nil, err
}
path, err = filepath.Abs(path)
if err != nil {
return nil, err
}
if err := t.writeContents(ctx, pctx, s, v, path); err != nil {
return nil, err
}
return compiler.NewValue(), nil
}
func (t clientFilesystemWriteTask) writeContents(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value, path string) error {
lg := log.Ctx(ctx)
contents := v.Lookup("contents")
if plancontext.IsFSValue(contents) {
lg.Debug().Str("path", path).Msg("writing files to local directory")
return t.writeFS(ctx, pctx, s, contents, path)
}
permissions := fs.FileMode(0644) // default permission
if vl := v.Lookup("permissions"); vl.Exists() {
p, err := vl.Int64()
if err != nil {
return err
}
permissions = fs.FileMode(p)
}
if plancontext.IsSecretValue(contents) {
lg.Debug().Str("path", path).Msg("writing secret to local file")
secret, err := pctx.Secrets.FromValue(contents)
if err != nil {
return err
}
return os.WriteFile(path, []byte(secret.PlainText()), permissions)
}
k := contents.Kind()
if k == cue.StringKind {
lg.Debug().Str("path", path).Msg("writing to local file")
text, err := contents.String()
if err != nil {
return err
}
return os.WriteFile(path, []byte(text), permissions)
}
return fmt.Errorf("unsupported type %q", k)
}
func (t clientFilesystemWriteTask) writeFS(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value, path string) error {
contents, err := pctx.FS.FromValue(v)
if err != nil {
return err
}
st, err := contents.State()
if err != nil {
return err
}
_, err = s.Export(ctx, st, nil, bk.ExportEntry{
Type: bk.ExporterLocal,
OutputDir: path,
}, pctx.Platform.Get())
return err
}

View File

@ -0,0 +1,24 @@
package task
import (
"context"
"runtime"
"go.dagger.io/dagger/compiler"
"go.dagger.io/dagger/plancontext"
"go.dagger.io/dagger/solver"
)
func init() {
Register("ClientPlatform", func() Task { return &clientPlatformTask{} })
}
type clientPlatformTask struct {
}
func (t clientPlatformTask) Run(ctx context.Context, pctx *plancontext.Context, _ solver.Solver, v *compiler.Value) (*compiler.Value, error) {
return compiler.NewValue().FillFields(map[string]interface{}{
"os": runtime.GOOS,
"arch": runtime.GOARCH,
})
}

View File

@ -4,6 +4,7 @@ import (
"context" "context"
"errors" "errors"
"fmt" "fmt"
"strings"
"sync" "sync"
"cuelang.org/go/cue" "cuelang.org/go/cue"
@ -20,6 +21,10 @@ var (
cue.Str("$dagger"), cue.Str("$dagger"),
cue.Str("task"), cue.Str("task"),
cue.Hid("_name", pkg.DaggerPackage)) cue.Hid("_name", pkg.DaggerPackage))
lookups = []LookupFunc{
defaultLookup,
pathLookup,
}
) )
// State is the state of the task. // State is the state of the task.
@ -33,6 +38,7 @@ const (
) )
type NewFunc func() Task type NewFunc func() Task
type LookupFunc func(*compiler.Value) (Task, error)
type Task interface { type Task interface {
Run(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value) (*compiler.Value, error) Run(ctx context.Context, pctx *plancontext.Context, s solver.Solver, v *compiler.Value) (*compiler.Value, error)
@ -60,13 +66,26 @@ func New(typ string) Task {
} }
func Lookup(v *compiler.Value) (Task, error) { func Lookup(v *compiler.Value) (Task, error) {
if v.Kind() != cue.StructKind { for _, lookup := range lookups {
t, err := lookup(v)
if err != nil {
return nil, err
}
if t != nil {
return t, nil
}
}
return nil, ErrNotTask return nil, ErrNotTask
} }
func defaultLookup(v *compiler.Value) (Task, error) {
if v.Kind() != cue.StructKind {
return nil, nil
}
typ := v.LookupPath(typePath) typ := v.LookupPath(typePath)
if !typ.Exists() { if !typ.Exists() {
return nil, ErrNotTask return nil, nil
} }
typeString, err := typ.String() typeString, err := typ.String()
@ -78,5 +97,49 @@ func Lookup(v *compiler.Value) (Task, error) {
if t == nil { if t == nil {
return nil, fmt.Errorf("unknown type %q", typeString) return nil, fmt.Errorf("unknown type %q", typeString)
} }
return t, nil return t, nil
} }
func pathLookup(v *compiler.Value) (Task, error) {
selectors := v.Path().Selectors()
// The `actions` field won't have any path based tasks since it's in user land
if len(selectors) == 0 || selectors[0].String() == "actions" {
return nil, nil
}
// Try an exact match first
if t := New(v.Path().String()); t != nil {
return t, nil
}
// FIXME: is there a way to avoid having to loop here?
var t Task
tasks.Range(func(key, value interface{}) bool {
if matchPathMask(selectors, key.(string)) {
fn := value.(NewFunc)
t = fn()
return false
}
return true
})
return t, nil
}
func matchPathMask(sels []cue.Selector, mask string) bool {
parts := strings.Split(mask, ".")
if len(sels) != len(parts) {
return false
}
for i, sel := range sels {
// use a '*' in a path mask part to match any selector
if parts[i] == "*" {
continue
}
if sel.String() != parts[i] {
return false
}
}
return true
}

View File

@ -10,6 +10,142 @@ setup() {
"$DAGGER" "do" -p ./plan/hello-europa test "$DAGGER" "do" -p ./plan/hello-europa test
} }
@test "plan/client/filesystem/read/fs/usage" {
cd "$TESTDIR/plan/client/filesystem/read/fs"
"$DAGGER" "do" -p ./usage test valid
run "$DAGGER" "do" -p ./usage test conflictingValues
assert_failure
assert_output --partial 'conflicting values "local directory" and "local foobar"'
run "$DAGGER" "do" -p ./usage test excluded
assert_failure
assert_line --partial 'test.log: no such file or directory'
run "$DAGGER" "do" -p ./usage test notExists
assert_failure
assert_output --partial 'test.json: no such file or directory'
}
@test "plan/client/filesystem/read/fs/not_exists" {
cd "$TESTDIR/plan/client/filesystem/read/fs/not_exists"
run "$DAGGER" "do" -p . test
assert_failure
assert_output --partial 'path "/foobar" does not exist'
}
@test "plan/client/filesystem/read/fs/relative" {
cd "$TESTDIR/plan/client/filesystem/read/fs/relative"
"$DAGGER" "do" -p . test valid
run "$DAGGER" "do" -p . test notIncluded
assert_failure
assert_output --partial 'test.log: no such file or directory'
}
@test "plan/client/filesystem/read/file" {
cd "$TESTDIR/plan/client/filesystem/read/file"
"$DAGGER" "do" -p . test usage
run "$DAGGER" "do" -p . test concrete
assert_failure
assert_output --partial "unexpected concrete value"
}
@test "plan/client/filesystem/read/service" {
cd "$TESTDIR"
"$DAGGER" "do" -p ./plan/client/filesystem/read/service/valid.cue test
run "$DAGGER" "do" -p ./plan/client/filesystem/read/service/invalid.cue test
assert_failure
}
@test "plan/client/filesystem/write fs" {
cd "$TESTDIR/plan/client/filesystem/write"
rm -rf "./out_fs"
"$DAGGER" "do" -p . test fs
assert [ "$(cat ./out_fs/test)" = "foobar" ]
rm -rf "./out_fs"
}
@test "plan/client/filesystem/write files" {
cd "$TESTDIR/plan/client/filesystem/write"
mkdir -p ./out_files
rm -f ./out_files/*
# -- string --
"$DAGGER" "do" -p ./ test file
assert [ "$(cat ./out_files/test.txt)" = "foobaz" ]
run ls -l "./out_files/test.txt"
assert_output --partial "-rw-r--r--"
# -- secret --
"$DAGGER" "do" -p ./ test secret
assert [ "$(cat ./out_files/secret.txt)" = "foo-barab-oof" ]
run ls -l "./out_files/secret.txt"
assert_output --partial "-rw-------"
rm -rf ./out_files
}
@test "plan/client/filesystem/conflict" {
cd "$TESTDIR/plan/client/filesystem/conflict"
echo -n foo > test.txt
run "$DAGGER" "do" --log-level debug -p . test
assert_line --regexp "client\.filesystem\..+\.write.+dependency=client\.filesystem\..+\.read"
rm -f test.txt
}
@test "plan/client/env usage" {
cd "${TESTDIR}"
export TEST_STRING="foo"
export TEST_SECRET="bar"
"$DAGGER" "do" -p ./plan/client/env test usage
}
@test "plan/client/env not exists" {
cd "${TESTDIR}"
run "$DAGGER" "do" -p ./plan/client/env test usage
assert_failure
}
@test "plan/client/env invalid" {
cd "${TESTDIR}"
export TEST_FAIL="foobar"
run "$DAGGER" "do" -p ./plan/client/env test concrete
assert_failure
assert_output --partial "TEST_FAIL: unexpected concrete value"
}
@test "plan/client/commands" {
cd "${TESTDIR}/plan/client/commands"
"$DAGGER" "do" -p . test valid
run "$DAGGER" "do" -p . test invalid
assert_failure
assert_output --partial 'exec: "foobar": executable file not found'
}
@test "plan/proxy invalid schema" { @test "plan/proxy invalid schema" {
cd "$TESTDIR" cd "$TESTDIR"
run "$DAGGER" "do" -p ./plan/proxy/invalid_schema.cue verify run "$DAGGER" "do" -p ./plan/proxy/invalid_schema.cue verify

View File

@ -0,0 +1,68 @@
package main
import (
"strings"
"dagger.io/dagger"
)
dagger.#Plan & {
client: commands: {
normal: {
name: "echo"
args: ["hello europa"]
}
relative: {
name: "cat"
args: ["./test.txt"]
}
secret: {
name: "tee"
stdout: dagger.#Secret
stdin: "hello secretive europa"
}
error: {
name: "sh"
flags: "-c": ">&2 echo 'error'"
stderr: string
}
invalid: name: "foobar"
}
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
test: {
invalid: dagger.#Exec & {
input: image.output
args: ["echo", client.commands.invalid.stdout]
}
valid: {
normal: dagger.#Exec & {
input: image.output
args: ["test", strings.TrimSpace(client.commands.normal.stdout), "=", "hello europa"]
}
relative: dagger.#Exec & {
input: image.output
args: ["test", strings.TrimSpace(client.commands.relative.stdout), "=", "test"]
}
error: dagger.#Exec & {
input: image.output
args: ["test", strings.TrimSpace(client.commands.error.stderr), "=", "error"]
}
secret: dagger.#Exec & {
input: image.output
mounts: secret: {
dest: "/run/secrets/test"
contents: client.commands.secret.stdout
}
args: [
"sh", "-c",
#"""
test "$(cat /run/secrets/test)" = "hello secretive europa"
"""#,
]
}
}
}
}
}

View File

@ -0,0 +1 @@
test

44
tests/plan/client/env/test.cue vendored Normal file
View File

@ -0,0 +1,44 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: env: {
TEST_STRING: string
TEST_SECRET: dagger.#Secret
TEST_FAIL: "env"
}
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
test: {
concrete: dagger.#Exec & {
input: image.output
args: [client.env.TEST_FAIL]
}
usage: {
string: dagger.#Exec & {
input: image.output
args: ["test", client.env.TEST_STRING, "=", "foo"]
}
secret: dagger.#Exec & {
input: image.output
mounts: secret: {
dest: "/run/secrets/test"
contents: client.env.TEST_SECRET
}
args: [
"sh", "-c",
#"""
test "$(cat /run/secrets/test)" = "bar"
ls -l /run/secrets/test | grep -- "-r--------"
"""#,
]
}
}
}
}
}

View File

@ -0,0 +1,41 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: "test.txt": {
// no dependencies between these two, one must be forced
read: contents: string
write: contents: actions.test.export.contents
}
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
test: {
read: dagger.#Exec & {
input: image.output
args: ["echo", client.filesystem."test.txt".read.contents]
}
write: dagger.#Exec & {
input: image.output
args: ["sh", "-c",
#"""
echo -n bar > /out.txt
"""#,
]
}
export: dagger.#ReadFile & {
input: write.output
path: "out.txt"
}
// FIXME: hack until we can do outputs with `dagger do`
verify: dagger.#Exec & {
input: image.output
args: ["echo", client.filesystem."test.txt".write.contents]
}
}
}
}

View File

@ -0,0 +1,3 @@
#!/bin/sh
env

View File

@ -0,0 +1 @@
bar

View File

@ -0,0 +1,44 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: {
"cmd.sh": read: contents: "env"
"test.txt": read: contents: string
"secret.txt": read: contents: dagger.#Secret
}
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
test: {
concrete: dagger.#Exec & {
input: image.output
args: ["sh", "-c", client.filesystem."cmd.sh".read.contents]
}
usage: {
string: dagger.#Exec & {
input: image.output
args: ["test", client.filesystem."test.txt".read.contents, "=", "foo"]
}
secret: dagger.#Exec & {
input: image.output
mounts: secret: {
dest: "/run/secrets/test"
contents: client.filesystem."secret.txt".read.contents
}
args: [
"sh", "-c",
#"""
test "$(cat /run/secrets/test)" = "bar"
ls -l /run/secrets/test | grep -- "-r--------"
"""#,
]
}
}
}
}
}

View File

@ -0,0 +1 @@
foo

View File

@ -0,0 +1,11 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: "/foobar": read: contents: dagger.#FS
actions: test: {
}
}

View File

@ -0,0 +1,22 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: "../rootfs": read: {
contents: dagger.#FS
include: ["*.txt"]
}
actions: test: {
[string]: dagger.#ReadFile & {
input: client.filesystem."../rootfs".read.contents
}
valid: {
path: "test.txt"
contents: "local directory"
}
notIncluded: path: "test.log"
}
}

View File

@ -0,0 +1 @@
excluded

View File

@ -0,0 +1 @@
local directory

View File

@ -0,0 +1,27 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: rootfs: read: {
contents: dagger.#FS
exclude: ["*.log"]
}
actions: test: {
[string]: dagger.#ReadFile & {
input: client.filesystem.rootfs.read.contents
}
valid: {
path: "test.txt"
contents: "local directory"
}
conflictingValues: {
path: "test.txt"
contents: "local foobar"
}
excluded: path: "test.log"
notExists: path: "test.json"
}
}

View File

@ -0,0 +1,29 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: "/var/run/docker.soc": read: contents: dagger.#Service
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
imageWithDocker: dagger.#Exec & {
input: image.output
args: ["apk", "add", "--no-cache", "docker-cli"]
}
test: dagger.#Exec & {
input: imageWithDocker.output
mounts: docker: {
dest: "/var/run/docker.sock"
contents: client.filesystem."/var/run/docker.soc".read.contents
}
args: ["docker", "info"]
}
}
}

View File

@ -0,0 +1,29 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: "/var/run/docker.sock": read: contents: dagger.#Service
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
imageWithDocker: dagger.#Exec & {
input: image.output
args: ["apk", "add", "--no-cache", "docker-cli"]
}
test: dagger.#Exec & {
input: imageWithDocker.output
mounts: docker: {
dest: "/var/run/docker.sock"
contents: client.filesystem."/var/run/docker.sock".read.contents
}
args: ["docker", "info"]
}
}
}

View File

@ -0,0 +1,29 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: "//./pipe/docker_engine": read: contents: dagger.#Service
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
imageWithDocker: dagger.#Exec & {
input: image.output
args: ["apk", "add", "--no-cache", "docker-cli"]
}
test: dagger.#Exec & {
input: imageWithDocker.output
mounts: docker: {
dest: "/var/run/docker.sock"
contents: client.filesystem."//./pipe/docker_engine".read.contents
}
args: ["docker", "info"]
}
}
}

View File

@ -0,0 +1,69 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: filesystem: {
out_fs: write: contents: actions.test.fs.data.output
"out_files/test.txt": write: contents: actions.test.file.data.contents
"out_files/secret.txt": write: {
contents: actions.test.secret.data.output
permissions: 0o600
}
}
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
test: {
fs: {
data: dagger.#WriteFile & {
input: dagger.#Scratch
path: "/test"
contents: "foobar"
}
// FIXME: hack until we can do outputs with `dagger do`
verify: dagger.#ReadFile & {
input: client.filesystem."out_fs".write.contents
path: "test"
}
}
file: {
// Only using contents for reference in client
data: dagger.#WriteFile & {
input: dagger.#Scratch
path: "/test"
contents: "foobaz"
}
// FIXME: hack until we can do outputs with `dagger do`
verify: dagger.#Exec & {
input: image.output
args: ["echo", "-c", client.filesystem."out_files/test.txt".write.contents]
}
}
secret: {
create: dagger.#WriteFile & {
input: dagger.#Scratch
path: "/test"
contents: "foo-barab-oof"
}
data: dagger.#NewSecret & {
input: create.output
path: "/test"
}
// FIXME: hack until we can do outputs with `dagger do`
verify: dagger.#Exec & {
input: image.output
mounts: secret: {
dest: "/run/secrets/test"
contents: client.filesystem."out_files/secret.txt".write.contents
}
args: ["id"]
}
}
}
}
}

View File

@ -88,7 +88,7 @@ module.exports = {
collapsed: false, collapsed: false,
items: [ items: [
"core-concepts/plan", "core-concepts/plan",
"core-concepts/inputs", "core-concepts/client",
"core-concepts/secrets", "core-concepts/secrets",
"core-concepts/caching", "core-concepts/caching",
"core-concepts/container-images", "core-concepts/container-images",