| 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) |
| } |