97 lines
1.7 KiB
Go
97 lines
1.7 KiB
Go
package plancontext
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
|
|
"cuelang.org/go/cue"
|
|
"github.com/google/uuid"
|
|
"github.com/moby/buildkit/client/llb"
|
|
bkgw "github.com/moby/buildkit/frontend/gateway/client"
|
|
"go.dagger.io/dagger/compiler"
|
|
"go.dagger.io/dagger/stdlib"
|
|
)
|
|
|
|
var (
|
|
fsIDPath = cue.MakePath(
|
|
cue.Str("$dagger"),
|
|
cue.Str("fs"),
|
|
cue.Hid("_id", stdlib.EnginePackage),
|
|
)
|
|
)
|
|
|
|
func IsFSValue(v *compiler.Value) bool {
|
|
return v.LookupPath(fsIDPath).Exists()
|
|
}
|
|
|
|
type FS struct {
|
|
id string
|
|
result bkgw.Reference
|
|
}
|
|
|
|
func (fs *FS) Result() bkgw.Reference {
|
|
return fs.result
|
|
}
|
|
|
|
func (fs *FS) State() (llb.State, error) {
|
|
if fs.Result() == nil {
|
|
return llb.Scratch(), nil
|
|
}
|
|
return fs.Result().ToState()
|
|
}
|
|
|
|
func (fs *FS) MarshalCUE() *compiler.Value {
|
|
v := compiler.NewValue()
|
|
if fs.result == nil {
|
|
if err := v.FillPath(fsIDPath, nil); err != nil {
|
|
panic(err)
|
|
}
|
|
} else {
|
|
if err := v.FillPath(fsIDPath, fs.id); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
return v
|
|
}
|
|
|
|
type fsContext struct {
|
|
l sync.RWMutex
|
|
store map[string]*FS
|
|
}
|
|
|
|
func (c *fsContext) New(result bkgw.Reference) *FS {
|
|
c.l.Lock()
|
|
defer c.l.Unlock()
|
|
|
|
fs := &FS{
|
|
// FIXME: get a hash from result instead
|
|
id: uuid.New().String(),
|
|
result: result,
|
|
}
|
|
|
|
c.store[fs.id] = fs
|
|
return fs
|
|
}
|
|
|
|
func (c *fsContext) FromValue(v *compiler.Value) (*FS, error) {
|
|
c.l.RLock()
|
|
defer c.l.RUnlock()
|
|
|
|
// This is #Scratch, so we'll return an empty FS
|
|
if v.LookupPath(fsIDPath).Kind() == cue.NullKind {
|
|
return &FS{}, nil
|
|
}
|
|
|
|
id, err := v.LookupPath(fsIDPath).String()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid FS %q: %w", v.Path(), err)
|
|
}
|
|
|
|
fs, ok := c.store[id]
|
|
if !ok {
|
|
return nil, fmt.Errorf("fs %q not found", id)
|
|
}
|
|
|
|
return fs, nil
|
|
}
|