This repository has been archived on 2024-04-08. You can view files and clone it, but cannot push or open issues or pull requests.
dagger/plan/task/clientfilesystemread.go
Helder Correia da90baa087
Add new Client API
Signed-off-by: Helder Correia <174525+helderco@users.noreply.github.com>
2022-03-07 17:13:16 -01:00

200 lines
4.6 KiB
Go

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
}