102 lines
2.6 KiB
Go
102 lines
2.6 KiB
Go
package remotecontext // import "github.com/docker/docker/builder/remotecontext"
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/docker/docker/builder"
|
|
"github.com/docker/docker/pkg/containerfs"
|
|
"github.com/docker/docker/pkg/pools"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// NewLazySource creates a new LazyContext. LazyContext defines a hashed build
|
|
// context based on a root directory. Individual files are hashed first time
|
|
// they are asked. It is not safe to call methods of LazyContext concurrently.
|
|
func NewLazySource(root containerfs.ContainerFS) (builder.Source, error) {
|
|
return &lazySource{
|
|
root: root,
|
|
sums: make(map[string]string),
|
|
}, nil
|
|
}
|
|
|
|
type lazySource struct {
|
|
root containerfs.ContainerFS
|
|
sums map[string]string
|
|
}
|
|
|
|
func (c *lazySource) Root() containerfs.ContainerFS {
|
|
return c.root
|
|
}
|
|
|
|
func (c *lazySource) Close() error {
|
|
return nil
|
|
}
|
|
|
|
func (c *lazySource) Hash(path string) (string, error) {
|
|
cleanPath, fullPath, err := normalize(path, c.root)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
relPath, err := Rel(c.root, fullPath)
|
|
if err != nil {
|
|
return "", errors.WithStack(convertPathError(err, cleanPath))
|
|
}
|
|
|
|
fi, err := c.root.Lstat(fullPath)
|
|
if err != nil {
|
|
// Backwards compatibility: a missing file returns a path as hash.
|
|
// This is reached in the case of a broken symlink.
|
|
return relPath, nil
|
|
}
|
|
|
|
sum, ok := c.sums[relPath]
|
|
if !ok {
|
|
sum, err = c.prepareHash(relPath, fi)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
}
|
|
|
|
return sum, nil
|
|
}
|
|
|
|
func (c *lazySource) prepareHash(relPath string, fi os.FileInfo) (string, error) {
|
|
p := c.root.Join(c.root.Path(), relPath)
|
|
h, err := NewFileHash(p, relPath, fi)
|
|
if err != nil {
|
|
return "", errors.Wrapf(err, "failed to create hash for %s", relPath)
|
|
}
|
|
if fi.Mode().IsRegular() && fi.Size() > 0 {
|
|
f, err := c.root.Open(p)
|
|
if err != nil {
|
|
return "", errors.Wrapf(err, "failed to open %s", relPath)
|
|
}
|
|
defer f.Close()
|
|
if _, err := pools.Copy(h, f); err != nil {
|
|
return "", errors.Wrapf(err, "failed to copy file data for %s", relPath)
|
|
}
|
|
}
|
|
sum := hex.EncodeToString(h.Sum(nil))
|
|
c.sums[relPath] = sum
|
|
return sum, nil
|
|
}
|
|
|
|
// Rel makes a path relative to base path. Same as `filepath.Rel` but can also
|
|
// handle UUID paths in windows.
|
|
func Rel(basepath containerfs.ContainerFS, targpath string) (string, error) {
|
|
// filepath.Rel can't handle UUID paths in windows
|
|
if basepath.OS() == "windows" {
|
|
pfx := basepath.Path() + `\`
|
|
if strings.HasPrefix(targpath, pfx) {
|
|
p := strings.TrimPrefix(targpath, pfx)
|
|
if p == "" {
|
|
p = "."
|
|
}
|
|
return p, nil
|
|
}
|
|
}
|
|
return basepath.Rel(basepath.Path(), targpath)
|
|
}
|