Merge pull request #1729 from helderco/remove-path-lookup

Remove path based task lookup
This commit is contained in:
Andrea Luzzardi 2022-03-09 15:17:55 -08:00 committed by GitHub
commit d79c377205
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 71 additions and 109 deletions

View File

@ -101,19 +101,6 @@ 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

@ -24,7 +24,7 @@ package dagger
} }
// Access client environment variables // Access client environment variables
env: [string]: *string | #Secret env: _#clientEnv
// Execute commands in the client // Execute commands in the client
commands: [id=string]: _#clientCommand commands: [id=string]: _#clientCommand
@ -93,6 +93,13 @@ _#clientFilesystemWrite: {
} }
} }
_#clientEnv: {
$dagger: task: _name: "ClientEnv"
// CUE type defines expected content
[!~"\\$dagger"]: *string | #Secret
}
_#clientCommand: { _#clientCommand: {
$dagger: task: _name: "ClientCommand" $dagger: task: _name: "ClientCommand"

View File

@ -13,19 +13,37 @@ import (
) )
func init() { func init() {
Register("client.env.*", func() Task { return &clientEnvTask{} }) Register("ClientEnv", func() Task { return &clientEnvTask{} })
} }
type clientEnvTask struct { type clientEnvTask struct {
} }
func (t clientEnvTask) Run(ctx context.Context, pctx *plancontext.Context, _ solver.Solver, v *compiler.Value) (*compiler.Value, error) { func (t clientEnvTask) Run(ctx context.Context, pctx *plancontext.Context, _ solver.Solver, v *compiler.Value) (*compiler.Value, error) {
lg := log.Ctx(ctx) log.Ctx(ctx).Debug().Msg("loading environment variables")
envvar := v.ParentLabel(1) fields, err := v.Fields()
if err != nil {
return nil, err
}
lg.Debug().Str("envvar", envvar).Msg("loading environment variable") envs := make(map[string]interface{})
for _, field := range fields {
if field.Selector == cue.Str("$dagger") {
continue
}
envvar := field.Label()
val, err := t.getEnv(envvar, field.Value, pctx)
if err != nil {
return nil, err
}
envs[envvar] = val
}
return compiler.NewValue().FillFields(envs)
}
func (t clientEnvTask) getEnv(envvar string, v *compiler.Value, pctx *plancontext.Context) (interface{}, error) {
env := os.Getenv(envvar) env := os.Getenv(envvar)
if env == "" { if env == "" {
return nil, fmt.Errorf("environment variable %q not set", envvar) return nil, fmt.Errorf("environment variable %q not set", envvar)
@ -33,21 +51,20 @@ func (t clientEnvTask) Run(ctx context.Context, pctx *plancontext.Context, _ sol
// Resolve default in disjunction if a type hasn't been specified // Resolve default in disjunction if a type hasn't been specified
val, _ := v.Default() val, _ := v.Default()
out := compiler.NewValue()
if plancontext.IsSecretValue(val) { if plancontext.IsSecretValue(val) {
secret := pctx.Secrets.New(env) secret := pctx.Secrets.New(env)
return out.Fill(secret.MarshalCUE()) return secret.MarshalCUE(), nil
} }
if val.IsConcrete() { if val.IsConcrete() {
return nil, fmt.Errorf("unexpected concrete value, please use a type") return nil, fmt.Errorf("%s: unexpected concrete value, please use a type", envvar)
} }
k := val.IncompleteKind() k := val.IncompleteKind()
if k == cue.StringKind { if k == cue.StringKind {
return out.Fill(env) return env, nil
} }
return nil, fmt.Errorf("unsupported type %q", k) return nil, fmt.Errorf("%s: unsupported type %q", envvar, k)
} }

View File

@ -4,7 +4,6 @@ import (
"context" "context"
"errors" "errors"
"fmt" "fmt"
"strings"
"sync" "sync"
"cuelang.org/go/cue" "cuelang.org/go/cue"
@ -21,10 +20,6 @@ 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.
@ -38,7 +33,6 @@ 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)
@ -66,26 +60,13 @@ func New(typ string) Task {
} }
func Lookup(v *compiler.Value) (Task, error) { func Lookup(v *compiler.Value) (Task, error) {
for _, lookup := range lookups {
t, err := lookup(v)
if err != nil {
return nil, err
}
if t != nil {
return t, nil
}
}
return nil, ErrNotTask
}
func defaultLookup(v *compiler.Value) (Task, error) {
if v.Kind() != cue.StructKind { if v.Kind() != cue.StructKind {
return nil, nil return nil, ErrNotTask
} }
typ := v.LookupPath(typePath) typ := v.LookupPath(typePath)
if !typ.Exists() { if !typ.Exists() {
return nil, nil return nil, ErrNotTask
} }
typeString, err := typ.String() typeString, err := typ.String()
@ -100,46 +81,3 @@ func defaultLookup(v *compiler.Value) (Task, error) {
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

@ -150,22 +150,23 @@ setup() {
export TEST_STRING="foo" export TEST_STRING="foo"
export TEST_SECRET="bar" export TEST_SECRET="bar"
"$DAGGER" "do" -p ./plan/client/env test usage "$DAGGER" "do" -p ./plan/client/env/usage.cue test
} }
@test "plan/client/env not exists" { @test "plan/client/env not exists" {
cd "${TESTDIR}" cd "${TESTDIR}"
run "$DAGGER" "do" -p ./plan/client/env test usage run "$DAGGER" "do" -p ./plan/client/env/usage.cue test
assert_failure assert_failure
assert_output --regexp "environment variable \"TEST_(STRING|SECRET)\" not set"
} }
@test "plan/client/env invalid" { @test "plan/client/env concrete" {
cd "${TESTDIR}" cd "${TESTDIR}"
export TEST_FAIL="foobar" export TEST_FAIL="foobar"
run "$DAGGER" "do" -p ./plan/client/env test concrete run "$DAGGER" "do" -p ./plan/client/env/concrete.cue test
assert_failure assert_failure
assert_output --partial "TEST_FAIL: unexpected concrete value" assert_output --partial "TEST_FAIL: unexpected concrete value"
} }

19
tests/plan/client/env/concrete.cue vendored Normal file
View File

@ -0,0 +1,19 @@
package main
import (
"dagger.io/dagger"
)
dagger.#Plan & {
client: env: TEST_FAIL: "env"
actions: {
image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
}
test: dagger.#Exec & {
input: image.output
args: [client.env.TEST_FAIL]
}
}
}

View File

@ -8,18 +8,12 @@ dagger.#Plan & {
client: env: { client: env: {
TEST_STRING: string TEST_STRING: string
TEST_SECRET: dagger.#Secret TEST_SECRET: dagger.#Secret
TEST_FAIL: "env"
} }
actions: { actions: {
image: dagger.#Pull & { image: dagger.#Pull & {
source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3" source: "alpine:3.15.0@sha256:e7d88de73db3d3fd9b2d63aa7f447a10fd0220b7cbf39803c803f2af9ba256b3"
} }
test: { test: {
concrete: dagger.#Exec & {
input: image.output
args: [client.env.TEST_FAIL]
}
usage: {
string: dagger.#Exec & { string: dagger.#Exec & {
input: image.output input: image.output
args: ["test", client.env.TEST_STRING, "=", "foo"] args: ["test", client.env.TEST_STRING, "=", "foo"]
@ -40,5 +34,4 @@ dagger.#Plan & {
} }
} }
} }
}
} }