@@ -165,6 +165,8 @@ func (w *Worker) ResolveOp(v solver.Vertex, s frontend.FrontendLLBBridge, sm *se

 			return ops.NewSourceOp(v, op, baseOp.Platform, w.SourceManager, sm, w)

 		case *pb.Op_Exec:

 			return ops.NewExecOp(v, op, baseOp.Platform, w.CacheManager, sm, w.MetadataStore, w.Executor, w)

+		case *pb.Op_File:

+			return ops.NewFileOp(v, op, w.CacheManager, w.MetadataStore, w)

 		case *pb.Op_Build:

 			return ops.NewBuildOp(v, op, s, w)

 		}

@@ -27,8 +27,8 @@ github.com/imdario/mergo v0.3.6

 golang.org/x/sync 1d60e4601c6fd243af51cc01ddf169918a5407ca

 # buildkit

-github.com/moby/buildkit c35410878ab9070498c66f6c67d3e8bc3b92241f

-github.com/tonistiigi/fsutil 1ec1983587cde7e8ac2978e354ff5360af622464

+github.com/moby/buildkit e9aca5bef87e19173b99d8668db0338dcaaa5f33

+github.com/tonistiigi/fsutil 1bdbf124ad494a771e99e0cdcd16326375f8b2c9

 github.com/grpc-ecosystem/grpc-opentracing 8e809c8a86450a29b90dcc9efbf062d0fe6d9746

 github.com/opentracing/opentracing-go 1361b9cd60be79c4c3a7fa9841b3c132e40066a7

 github.com/google/shlex 6f45313302b9c56850fc17f99e40caebce98c716

@@ -47,6 +47,10 @@ func Checksum(ctx context.Context, ref cache.ImmutableRef, path string, followLi

 	return getDefaultManager().Checksum(ctx, ref, path, followLinks)

 }

+func ChecksumWildcard(ctx context.Context, ref cache.ImmutableRef, path string, followLinks bool) (digest.Digest, error) {

+	return getDefaultManager().ChecksumWildcard(ctx, ref, path, followLinks)

+}

+

 func GetCacheContext(ctx context.Context, md *metadata.StorageItem) (CacheContext, error) {

 	return getDefaultManager().GetCacheContext(ctx, md)

 }

@@ -84,6 +88,14 @@ func (cm *cacheManager) Checksum(ctx context.Context, ref cache.ImmutableRef, p

 	return cc.Checksum(ctx, ref, p, followLinks)

 }

+func (cm *cacheManager) ChecksumWildcard(ctx context.Context, ref cache.ImmutableRef, p string, followLinks bool) (digest.Digest, error) {

+	cc, err := cm.GetCacheContext(ctx, ensureOriginMetadata(ref.Metadata()))

+	if err != nil {

+		return "", nil

+	}

+	return cc.ChecksumWildcard(ctx, ref, p, followLinks)

+}

+

 func (cm *cacheManager) GetCacheContext(ctx context.Context, md *metadata.StorageItem) (CacheContext, error) {

 	cm.locker.Lock(md.ID())

 	cm.lruMu.Lock()

@@ -91,6 +103,7 @@ func (cm *cacheManager) GetCacheContext(ctx context.Context, md *metadata.Storag

 	cm.lruMu.Unlock()

 	if ok {

 		cm.locker.Unlock(md.ID())

+		v.(*cacheContext).linkMap = map[string][][]byte{}

 		return v.(*cacheContext), nil

 	}

 	cc, err := newCacheContext(md)

@@ -115,6 +128,7 @@ func (cm *cacheManager) SetCacheContext(ctx context.Context, md *metadata.Storag

 			md:       md,

 			tree:     cci.(*cacheContext).tree,

 			dirtyMap: map[string]struct{}{},

+			linkMap:  map[string][][]byte{},

 		}

 	} else {

 		if err := cc.save(); err != nil {

@@ -137,6 +151,7 @@ type cacheContext struct {

 	txn      *iradix.Txn

 	node     *iradix.Node

 	dirtyMap map[string]struct{}

+	linkMap  map[string][][]byte

 }

 type mount struct {

@@ -181,6 +196,7 @@ func newCacheContext(md *metadata.StorageItem) (*cacheContext, error) {

 		md:       md,

 		tree:     iradix.New(),

 		dirtyMap: map[string]struct{}{},

+		linkMap:  map[string][][]byte{},

 	}

 	if err := cc.load(); err != nil {

 		return nil, err

@@ -313,7 +329,35 @@ func (cc *cacheContext) HandleChange(kind fsutil.ChangeKind, p string, fi os.Fil

 		p += "/"

 	}

 	cr.Digest = h.Digest()

+

+	// if we receive a hardlink just use the digest of the source

+	// note that the source may be called later because data writing is async

+	if fi.Mode()&os.ModeSymlink == 0 && stat.Linkname != "" {

+		ln := path.Join("/", filepath.ToSlash(stat.Linkname))

+		v, ok := cc.txn.Get(convertPathToKey([]byte(ln)))

+		if ok {

+			cp := *v.(*CacheRecord)

+			cr = &cp

+		}

+		cc.linkMap[ln] = append(cc.linkMap[ln], k)

+	}

+

 	cc.txn.Insert(k, cr)

+	if !fi.IsDir() {

+		if links, ok := cc.linkMap[p]; ok {

+			for _, l := range links {

+				pp := convertKeyToPath(l)

+				cc.txn.Insert(l, cr)

+				d := path.Dir(string(pp))

+				if d == "/" {

+					d = ""

+				}

+				cc.dirtyMap[d] = struct{}{}

+			}

+			delete(cc.linkMap, p)

+		}

+	}

+

 	d := path.Dir(p)

 	if d == "/" {

 		d = ""

@@ -343,6 +387,9 @@ func (cc *cacheContext) ChecksumWildcard(ctx context.Context, mountable cache.Mo

 			}

 		}

 	}

+	if len(wildcards) == 0 {

+		return digest.FromBytes([]byte{}), nil

+	}

 	if len(wildcards) > 1 {

 		digester := digest.Canonical.Digester()

@@ -543,12 +590,13 @@ func (cc *cacheContext) lazyChecksum(ctx context.Context, m *mount, p string) (*

 }

 func (cc *cacheContext) checksum(ctx context.Context, root *iradix.Node, txn *iradix.Txn, m *mount, k []byte, follow bool) (*CacheRecord, bool, error) {

+	origk := k

 	k, cr, err := getFollowLinks(root, k, follow)

 	if err != nil {

 		return nil, false, err

 	}

 	if cr == nil {

-		return nil, false, errors.Wrapf(errNotFound, "%s not found", convertKeyToPath(k))

+		return nil, false, errors.Wrapf(errNotFound, "%q not found", convertKeyToPath(origk))

 	}

 	if cr.Digest != "" {

 		return cr, false, nil

@@ -311,7 +311,7 @@ func (sr *mutableRef) updateLastUsed() bool {

 func (sr *mutableRef) commit(ctx context.Context) (ImmutableRef, error) {

 	if !sr.mutable || len(sr.refs) == 0 {

-		return nil, errors.Wrapf(errInvalid, "invalid mutable ref")

+		return nil, errors.Wrapf(errInvalid, "invalid mutable ref %p", sr)

 	}

 	id := identity.NewID()

new file mode 100644

@@ -0,0 +1,727 @@

+package llb

+

+import (

+	_ "crypto/sha256"

+	"os"

+	"path"

+	"strconv"

+	"strings"

+	"time"

+

+	"github.com/moby/buildkit/solver/pb"

+	digest "github.com/opencontainers/go-digest"

+	"github.com/pkg/errors"

+)

+

+// Examples:

+// local := llb.Local(...)

+// llb.Image().Dir("/abc").File(Mkdir("./foo").Mkfile("/abc/foo/bar", []byte("data")))

+// llb.Image().File(Mkdir("/foo").Mkfile("/foo/bar", []byte("data")))

+// llb.Image().File(Copy(local, "/foo", "/bar")).File(Copy(local, "/foo2", "/bar2"))

+//

+// a := Mkdir("./foo")  // *FileAction /ced/foo

+// b := Mkdir("./bar") // /abc/bar

+// c := b.Copy(a.WithState(llb.Scratch().Dir("/ced")), "./foo", "./baz") // /abc/baz

+// llb.Image().Dir("/abc").File(c)

+//

+// In future this can be extended to multiple outputs with:

+// a := Mkdir("./foo")

+// b, id := a.GetSelector()

+// c := b.Mkdir("./bar")

+// filestate = state.File(c)

+// filestate.GetOutput(id).Exec()

+

+func NewFileOp(s State, action *FileAction, c Constraints) *FileOp {

+	action = action.bind(s)

+

+	f := &FileOp{

+		action:      action,

+		constraints: c,

+	}

+

+	f.output = &output{vertex: f, getIndex: func() (pb.OutputIndex, error) {

+		return pb.OutputIndex(0), nil

+	}}

+

+	return f

+}

+

+// CopyInput is either llb.State or *FileActionWithState

+type CopyInput interface {

+	isFileOpCopyInput()

+}

+

+type subAction interface {

+	toProtoAction(string, pb.InputIndex) pb.IsFileAction

+}

+

+type FileAction struct {

+	state  *State

+	prev   *FileAction

+	action subAction

+	err    error

+}

+

+func (fa *FileAction) Mkdir(p string, m os.FileMode, opt ...MkdirOption) *FileAction {

+	a := Mkdir(p, m, opt...)

+	a.prev = fa

+	return a

+}

+

+func (fa *FileAction) Mkfile(p string, m os.FileMode, dt []byte, opt ...MkfileOption) *FileAction {

+	a := Mkfile(p, m, dt, opt...)

+	a.prev = fa

+	return a

+}

+

+func (fa *FileAction) Rm(p string, opt ...RmOption) *FileAction {

+	a := Rm(p, opt...)

+	a.prev = fa

+	return a

+}

+

+func (fa *FileAction) Copy(input CopyInput, src, dest string, opt ...CopyOption) *FileAction {

+	a := Copy(input, src, dest, opt...)

+	a.prev = fa

+	return a

+}

+

+func (fa *FileAction) allOutputs(m map[Output]struct{}) {

+	if fa == nil {

+		return

+	}

+	if fa.state != nil && fa.state.Output() != nil {

+		m[fa.state.Output()] = struct{}{}

+	}

+

+	if a, ok := fa.action.(*fileActionCopy); ok {

+		if a.state != nil {

+			if out := a.state.Output(); out != nil {

+				m[out] = struct{}{}

+			}

+		} else if a.fas != nil {

+			a.fas.allOutputs(m)

+		}

+	}

+	fa.prev.allOutputs(m)

+}

+

+func (fa *FileAction) bind(s State) *FileAction {

+	if fa == nil {

+		return nil

+	}

+	fa2 := *fa

+	fa2.prev = fa.prev.bind(s)

+	fa2.state = &s

+	return &fa2

+}

+

+func (fa *FileAction) WithState(s State) CopyInput {

+	return &fileActionWithState{FileAction: fa.bind(s)}

+}

+

+type fileActionWithState struct {

+	*FileAction

+}

+

+func (fas *fileActionWithState) isFileOpCopyInput() {}

+

+func Mkdir(p string, m os.FileMode, opt ...MkdirOption) *FileAction {

+	var mi MkdirInfo

+	for _, o := range opt {

+		o.SetMkdirOption(&mi)

+	}

+	return &FileAction{

+		action: &fileActionMkdir{

+			file: p,

+			mode: m,

+			info: mi,

+		},

+	}

+}

+

+type fileActionMkdir struct {

+	file string

+	mode os.FileMode

+	info MkdirInfo

+}

+

+func (a *fileActionMkdir) toProtoAction(parent string, base pb.InputIndex) pb.IsFileAction {

+	return &pb.FileAction_Mkdir{

+		Mkdir: &pb.FileActionMkDir{

+			Path:        normalizePath(parent, a.file, false),

+			Mode:        int32(a.mode & 0777),

+			MakeParents: a.info.MakeParents,

+			Owner:       a.info.ChownOpt.marshal(base),

+			Timestamp:   marshalTime(a.info.CreatedTime),

+		},

+	}

+}

+

+type MkdirOption interface {

+	SetMkdirOption(*MkdirInfo)

+}

+

+type ChownOption interface {

+	MkdirOption

+	MkfileOption

+	CopyOption

+}

+

+type mkdirOptionFunc func(*MkdirInfo)

+

+func (fn mkdirOptionFunc) SetMkdirOption(mi *MkdirInfo) {

+	fn(mi)

+}

+

+var _ MkdirOption = &MkdirInfo{}

+

+func WithParents(b bool) MkdirOption {

+	return mkdirOptionFunc(func(mi *MkdirInfo) {

+		mi.MakeParents = b

+	})

+}

+

+type MkdirInfo struct {

+	MakeParents bool

+	ChownOpt    *ChownOpt

+	CreatedTime *time.Time

+}

+

+func (mi *MkdirInfo) SetMkdirOption(mi2 *MkdirInfo) {

+	*mi2 = *mi

+}

+

+func WithUser(name string) ChownOption {

+	opt := ChownOpt{}

+

+	parts := strings.SplitN(name, ":", 2)

+	for i, v := range parts {

+		switch i {

+		case 0:

+			uid, err := parseUID(v)

+			if err != nil {

+				opt.User = &UserOpt{Name: v}

+			} else {

+				opt.User = &UserOpt{UID: uid}

+			}

+		case 1:

+			gid, err := parseUID(v)

+			if err != nil {

+				opt.Group = &UserOpt{Name: v}

+			} else {

+				opt.Group = &UserOpt{UID: gid}

+			}

+		}

+	}

+

+	return opt

+}

+

+func parseUID(str string) (int, error) {

+	if str == "root" {

+		return 0, nil

+	}

+	uid, err := strconv.ParseInt(str, 10, 32)

+	if err != nil {

+		return 0, err

+	}

+	return int(uid), nil

+}

+

+func WithUIDGID(uid, gid int) ChownOption {

+	return ChownOpt{

+		User:  &UserOpt{UID: uid},

+		Group: &UserOpt{UID: gid},

+	}

+}

+

+type ChownOpt struct {

+	User  *UserOpt

+	Group *UserOpt

+}

+

+func (co ChownOpt) SetMkdirOption(mi *MkdirInfo) {

+	mi.ChownOpt = &co

+}

+func (co ChownOpt) SetMkfileOption(mi *MkfileInfo) {

+	mi.ChownOpt = &co

+}

+func (co ChownOpt) SetCopyOption(mi *CopyInfo) {

+	mi.ChownOpt = &co

+}

+

+func (cp *ChownOpt) marshal(base pb.InputIndex) *pb.ChownOpt {

+	if cp == nil {

+		return nil

+	}

+	return &pb.ChownOpt{

+		User:  cp.User.marshal(base),

+		Group: cp.Group.marshal(base),

+	}

+}

+

+type UserOpt struct {

+	UID  int

+	Name string

+}

+

+func (up *UserOpt) marshal(base pb.InputIndex) *pb.UserOpt {

+	if up == nil {

+		return nil

+	}

+	if up.Name != "" {

+		return &pb.UserOpt{User: &pb.UserOpt_ByName{ByName: &pb.NamedUserOpt{

+			Name: up.Name, Input: base}}}

+	}

+	return &pb.UserOpt{User: &pb.UserOpt_ByID{ByID: uint32(up.UID)}}

+}

+

+func Mkfile(p string, m os.FileMode, dt []byte, opts ...MkfileOption) *FileAction {

+	var mi MkfileInfo

+	for _, o := range opts {

+		o.SetMkfileOption(&mi)

+	}

+

+	return &FileAction{

+		action: &fileActionMkfile{

+			file: p,

+			mode: m,

+			dt:   dt,

+			info: mi,

+		},

+	}

+}

+

+type MkfileOption interface {

+	SetMkfileOption(*MkfileInfo)

+}

+

+type MkfileInfo struct {

+	ChownOpt    *ChownOpt

+	CreatedTime *time.Time

+}

+

+func (mi *MkfileInfo) SetMkfileOption(mi2 *MkfileInfo) {

+	*mi2 = *mi

+}

+

+var _ MkfileOption = &MkfileInfo{}

+

+type fileActionMkfile struct {

+	file string

+	mode os.FileMode

+	dt   []byte

+	info MkfileInfo

+}

+

+func (a *fileActionMkfile) toProtoAction(parent string, base pb.InputIndex) pb.IsFileAction {

+	return &pb.FileAction_Mkfile{

+		Mkfile: &pb.FileActionMkFile{

+			Path:      normalizePath(parent, a.file, false),

+			Mode:      int32(a.mode & 0777),

+			Data:      a.dt,

+			Owner:     a.info.ChownOpt.marshal(base),

+			Timestamp: marshalTime(a.info.CreatedTime),

+		},

+	}

+}

+

+func Rm(p string, opts ...RmOption) *FileAction {

+	var mi RmInfo

+	for _, o := range opts {

+		o.SetRmOption(&mi)

+	}

+

+	return &FileAction{

+		action: &fileActionRm{

+			file: p,

+			info: mi,

+		},

+	}

+}

+

+type RmOption interface {

+	SetRmOption(*RmInfo)

+}

+

+type rmOptionFunc func(*RmInfo)

+

+func (fn rmOptionFunc) SetRmOption(mi *RmInfo) {

+	fn(mi)

+}

+

+type RmInfo struct {

+	AllowNotFound bool

+	AllowWildcard bool

+}

+

+func (mi *RmInfo) SetRmOption(mi2 *RmInfo) {

+	*mi2 = *mi

+}

+

+var _ RmOption = &RmInfo{}

+

+func WithAllowNotFound(b bool) RmOption {

+	return rmOptionFunc(func(mi *RmInfo) {

+		mi.AllowNotFound = b

+	})

+}

+

+func WithAllowWildcard(b bool) RmOption {

+	return rmOptionFunc(func(mi *RmInfo) {

+		mi.AllowWildcard = b

+	})

+}

+

+type fileActionRm struct {

+	file string

+	info RmInfo

+}

+

+func (a *fileActionRm) toProtoAction(parent string, base pb.InputIndex) pb.IsFileAction {

+	return &pb.FileAction_Rm{

+		Rm: &pb.FileActionRm{

+			Path:          normalizePath(parent, a.file, false),

+			AllowNotFound: a.info.AllowNotFound,

+			AllowWildcard: a.info.AllowWildcard,

+		},

+	}

+}

+

+func Copy(input CopyInput, src, dest string, opts ...CopyOption) *FileAction {

+	var state *State

+	var fas *fileActionWithState

+	var err error

+	if st, ok := input.(State); ok {

+		state = &st

+	} else if v, ok := input.(*fileActionWithState); ok {

+		fas = v

+	} else {

+		err = errors.Errorf("invalid input type %T for copy", input)

+	}

+

+	var mi CopyInfo

+	for _, o := range opts {

+		o.SetCopyOption(&mi)

+	}

+

+	return &FileAction{

+		action: &fileActionCopy{

+			state: state,

+			fas:   fas,

+			src:   src,

+			dest:  dest,

+			info:  mi,

+		},

+		err: err,

+	}

+}

+

+type CopyOption interface {

+	SetCopyOption(*CopyInfo)

+}

+

+type CopyInfo struct {

+	Mode                *os.FileMode

+	FollowSymlinks      bool

+	CopyDirContentsOnly bool

+	AttemptUnpack       bool

+	CreateDestPath      bool

+	AllowWildcard       bool

+	AllowEmptyWildcard  bool

+	ChownOpt            *ChownOpt

+	CreatedTime         *time.Time

+}

+

+func (mi *CopyInfo) SetCopyOption(mi2 *CopyInfo) {

+	*mi2 = *mi

+}

+

+var _ CopyOption = &CopyInfo{}

+

+type fileActionCopy struct {

+	state *State

+	fas   *fileActionWithState

+	src   string

+	dest  string

+	info  CopyInfo

+}

+

+func (a *fileActionCopy) toProtoAction(parent string, base pb.InputIndex) pb.IsFileAction {

+	c := &pb.FileActionCopy{

+		Src:                              a.sourcePath(),

+		Dest:                             normalizePath(parent, a.dest, true),

+		Owner:                            a.info.ChownOpt.marshal(base),

+		AllowWildcard:                    a.info.AllowWildcard,

+		AllowEmptyWildcard:               a.info.AllowEmptyWildcard,

+		FollowSymlink:                    a.info.FollowSymlinks,

+		DirCopyContents:                  a.info.CopyDirContentsOnly,

+		AttemptUnpackDockerCompatibility: a.info.AttemptUnpack,

+		CreateDestPath:                   a.info.CreateDestPath,

+		Timestamp:                        marshalTime(a.info.CreatedTime),

+	}

+	if a.info.Mode != nil {

+		c.Mode = int32(*a.info.Mode)

+	} else {

+		c.Mode = -1

+	}

+	return &pb.FileAction_Copy{

+		Copy: c,

+	}

+}

+

+func (c *fileActionCopy) sourcePath() string {

+	p := path.Clean(c.src)

+	if !path.IsAbs(p) {

+		if c.state != nil {

+			p = path.Join("/", c.state.GetDir(), p)

+		} else if c.fas != nil {

+			p = path.Join("/", c.fas.state.GetDir(), p)

+		}

+	}

+	return p

+}

+

+type CreatedTime time.Time

+

+func WithCreatedTime(t time.Time) CreatedTime {

+	return CreatedTime(t)

+}

+

+func (c CreatedTime) SetMkdirOption(mi *MkdirInfo) {

+	mi.CreatedTime = (*time.Time)(&c)

+}

+

+func (c CreatedTime) SetMkfileOption(mi *MkfileInfo) {

+	mi.CreatedTime = (*time.Time)(&c)

+}

+

+func (c CreatedTime) SetCopyOption(mi *CopyInfo) {

+	mi.CreatedTime = (*time.Time)(&c)

+}

+

+func marshalTime(t *time.Time) int64 {

+	if t == nil {

+		return -1

+	}

+	return t.UnixNano()

+}

+

+type FileOp struct {

+	MarshalCache

+	action *FileAction

+	output Output

+

+	constraints Constraints

+	isValidated bool

+}

+

+func (f *FileOp) Validate() error {

+	if f.isValidated {

+		return nil

+	}

+	if f.action == nil {

+		return errors.Errorf("action is required")

+	}

+	f.isValidated = true

+	return nil

+}

+

+type marshalState struct {

+	visited map[*FileAction]*fileActionState

+	inputs  []*pb.Input

+	actions []*fileActionState

+}

+

+func newMarshalState() *marshalState {

+	return &marshalState{

+		visited: map[*FileAction]*fileActionState{},

+	}

+}

+

+type fileActionState struct {

+	base           pb.InputIndex

+	input          pb.InputIndex

+	inputRelative  *int

+	input2         pb.InputIndex

+	input2Relative *int

+	target         int

+	action         subAction

+	fa             *FileAction

+}

+

+func (ms *marshalState) addInput(st *fileActionState, c *Constraints, o Output) (pb.InputIndex, error) {

+	inp, err := o.ToInput(c)

+	if err != nil {

+		return 0, err

+	}

+	for i, inp2 := range ms.inputs {

+		if *inp == *inp2 {

+			return pb.InputIndex(i), nil

+		}

+	}

+	i := pb.InputIndex(len(ms.inputs))

+	ms.inputs = append(ms.inputs, inp)

+	return i, nil

+}

+

+func (ms *marshalState) add(fa *FileAction, c *Constraints) (*fileActionState, error) {

+	if st, ok := ms.visited[fa]; ok {

+		return st, nil

+	}

+

+	if fa.err != nil {

+		return nil, fa.err

+	}

+

+	var prevState *fileActionState

+	if parent := fa.prev; parent != nil {

+		var err error

+		prevState, err = ms.add(parent, c)

+		if err != nil {

+			return nil, err

+		}

+	}

+

+	st := &fileActionState{

+		action: fa.action,

+		input:  -1,

+		input2: -1,

+		base:   -1,

+		fa:     fa,

+	}

+

+	if source := fa.state.Output(); source != nil {

+		inp, err := ms.addInput(st, c, source)

+		if err != nil {

+			return nil, err

+		}

+		st.base = inp

+	}

+

+	if fa.prev == nil {

+		st.input = st.base

+	} else {

+		st.inputRelative = &prevState.target

+	}

+

+	if a, ok := fa.action.(*fileActionCopy); ok {

+		if a.state != nil {

+			if out := a.state.Output(); out != nil {

+				inp, err := ms.addInput(st, c, out)

+				if err != nil {

+					return nil, err

+				}

+				st.input2 = inp

+			}

+		} else if a.fas != nil {

+			src, err := ms.add(a.fas.FileAction, c)

+			if err != nil {

+				return nil, err

+			}

+			st.input2Relative = &src.target

+		} else {

+			return nil, errors.Errorf("invalid empty source for copy")

+		}

+	}

+

+	st.target = len(ms.actions)

+

+	ms.visited[fa] = st

+	ms.actions = append(ms.actions, st)

+

+	return st, nil

+}

+

+func (f *FileOp) Marshal(c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, error) {

+	if f.Cached(c) {

+		return f.Load()

+	}

+	if err := f.Validate(); err != nil {

+		return "", nil, nil, err

+	}

+

+	addCap(&f.constraints, pb.CapFileBase)

+

+	pfo := &pb.FileOp{}

+

+	pop, md := MarshalConstraints(c, &f.constraints)

+	pop.Op = &pb.Op_File{

+		File: pfo,

+	}

+

+	state := newMarshalState()

+	_, err := state.add(f.action, c)

+	if err != nil {

+		return "", nil, nil, err

+	}

+	pop.Inputs = state.inputs

+

+	for i, st := range state.actions {

+		output := pb.OutputIndex(-1)

+		if i+1 == len(state.actions) {

+			output = 0

+		}

+

+		var parent string

+		if st.fa.state != nil {

+			parent = st.fa.state.GetDir()

+		}

+

+		pfo.Actions = append(pfo.Actions, &pb.FileAction{

+			Input:          getIndex(st.input, len(state.inputs), st.inputRelative),

+			SecondaryInput: getIndex(st.input2, len(state.inputs), st.input2Relative),

+			Output:         output,

+			Action:         st.action.toProtoAction(parent, st.base),

+		})

+	}

+

+	dt, err := pop.Marshal()

+	if err != nil {

+		return "", nil, nil, err

+	}

+	f.Store(dt, md, c)

+	return f.Load()

+}

+

+func normalizePath(parent, p string, keepSlash bool) string {

+	origPath := p

+	p = path.Clean(p)

+	if !path.IsAbs(p) {

+		p = path.Join("/", parent, p)

+	}

+	if keepSlash {

+		if strings.HasSuffix(origPath, "/") && !strings.HasSuffix(p, "/") {

+			p += "/"

+		} else if strings.HasSuffix(origPath, "/.") {

+			if p != "/" {

+				p += "/"

+			}

+			p += "."

+		}

+	}

+	return p

+}

+

+func (f *FileOp) Output() Output {

+	return f.output

+}

+

+func (f *FileOp) Inputs() (inputs []Output) {

+	mm := map[Output]struct{}{}

+

+	f.action.allOutputs(mm)

+