aboutsummaryrefslogtreecommitdiff
path: root/gopls/internal/lsp/fake/workdir.go
diff options
context:
space:
mode:
Diffstat (limited to 'gopls/internal/lsp/fake/workdir.go')
-rw-r--r--gopls/internal/lsp/fake/workdir.go438
1 files changed, 438 insertions, 0 deletions
diff --git a/gopls/internal/lsp/fake/workdir.go b/gopls/internal/lsp/fake/workdir.go
new file mode 100644
index 000000000..29344514d
--- /dev/null
+++ b/gopls/internal/lsp/fake/workdir.go
@@ -0,0 +1,438 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fake
+
+import (
+ "bytes"
+ "context"
+ "crypto/sha256"
+ "fmt"
+ "io/fs"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "runtime"
+ "sort"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/tools/gopls/internal/lsp/protocol"
+ "golang.org/x/tools/gopls/internal/span"
+ "golang.org/x/tools/internal/robustio"
+)
+
+// RelativeTo is a helper for operations relative to a given directory.
+type RelativeTo string
+
+// AbsPath returns an absolute filesystem path for the workdir-relative path.
+func (r RelativeTo) AbsPath(path string) string {
+ fp := filepath.FromSlash(path)
+ if filepath.IsAbs(fp) {
+ return fp
+ }
+ return filepath.Join(string(r), filepath.FromSlash(path))
+}
+
+// RelPath returns a '/'-encoded path relative to the working directory (or an
+// absolute path if the file is outside of workdir)
+func (r RelativeTo) RelPath(fp string) string {
+ root := string(r)
+ if rel, err := filepath.Rel(root, fp); err == nil && !strings.HasPrefix(rel, "..") {
+ return filepath.ToSlash(rel)
+ }
+ return filepath.ToSlash(fp)
+}
+
+// writeFileData writes content to the relative path, replacing the special
+// token $SANDBOX_WORKDIR with the relative root given by rel. It does not
+// trigger any file events.
+func writeFileData(path string, content []byte, rel RelativeTo) error {
+ content = bytes.ReplaceAll(content, []byte("$SANDBOX_WORKDIR"), []byte(rel))
+ fp := rel.AbsPath(path)
+ if err := os.MkdirAll(filepath.Dir(fp), 0755); err != nil {
+ return fmt.Errorf("creating nested directory: %w", err)
+ }
+ backoff := 1 * time.Millisecond
+ for {
+ err := ioutil.WriteFile(fp, []byte(content), 0644)
+ if err != nil {
+ // This lock file violation is not handled by the robustio package, as it
+ // indicates a real race condition that could be avoided.
+ if isWindowsErrLockViolation(err) {
+ time.Sleep(backoff)
+ backoff *= 2
+ continue
+ }
+ return fmt.Errorf("writing %q: %w", path, err)
+ }
+ return nil
+ }
+}
+
+// isWindowsErrLockViolation reports whether err is ERROR_LOCK_VIOLATION
+// on Windows.
+var isWindowsErrLockViolation = func(err error) bool { return false }
+
+// Workdir is a temporary working directory for tests. It exposes file
+// operations in terms of relative paths, and fakes file watching by triggering
+// events on file operations.
+type Workdir struct {
+ RelativeTo
+
+ watcherMu sync.Mutex
+ watchers []func(context.Context, []protocol.FileEvent)
+
+ fileMu sync.Mutex
+ // File identities we know about, for the purpose of detecting changes.
+ //
+ // Since files is only used for detecting _changes_, we are tolerant of
+ // fileIDs that may have hash and mtime coming from different states of the
+ // file: if either are out of sync, then the next poll should detect a
+ // discrepancy. It is OK if we detect too many changes, but not OK if we miss
+ // changes.
+ //
+ // For that matter, this mechanism for detecting changes can still be flaky
+ // on platforms where mtime is very coarse (such as older versions of WSL).
+ // It would be much better to use a proper fs event library, but we can't
+ // currently import those into x/tools.
+ //
+ // TODO(golang/go#52284): replace this polling mechanism with a
+ // cross-platform library for filesystem notifications.
+ files map[string]fileID
+}
+
+// NewWorkdir writes the txtar-encoded file data in txt to dir, and returns a
+// Workir for operating on these files using
+func NewWorkdir(dir string, files map[string][]byte) (*Workdir, error) {
+ w := &Workdir{RelativeTo: RelativeTo(dir)}
+ for name, data := range files {
+ if err := writeFileData(name, data, w.RelativeTo); err != nil {
+ return nil, fmt.Errorf("writing to workdir: %w", err)
+ }
+ }
+ _, err := w.pollFiles() // poll files to populate the files map.
+ return w, err
+}
+
+// fileID identifies a file version on disk.
+type fileID struct {
+ mtime time.Time
+ hash string // empty if mtime is old enough to be reliabe; otherwise a file digest
+}
+
+func hashFile(data []byte) string {
+ return fmt.Sprintf("%x", sha256.Sum256(data))
+}
+
+// RootURI returns the root URI for this working directory of this scratch
+// environment.
+func (w *Workdir) RootURI() protocol.DocumentURI {
+ return toURI(string(w.RelativeTo))
+}
+
+// AddWatcher registers the given func to be called on any file change.
+func (w *Workdir) AddWatcher(watcher func(context.Context, []protocol.FileEvent)) {
+ w.watcherMu.Lock()
+ w.watchers = append(w.watchers, watcher)
+ w.watcherMu.Unlock()
+}
+
+// URI returns the URI to a the workdir-relative path.
+func (w *Workdir) URI(path string) protocol.DocumentURI {
+ return toURI(w.AbsPath(path))
+}
+
+// URIToPath converts a uri to a workdir-relative path (or an absolute path,
+// if the uri is outside of the workdir).
+func (w *Workdir) URIToPath(uri protocol.DocumentURI) string {
+ fp := uri.SpanURI().Filename()
+ return w.RelPath(fp)
+}
+
+func toURI(fp string) protocol.DocumentURI {
+ return protocol.DocumentURI(span.URIFromPath(fp))
+}
+
+// ReadFile reads a text file specified by a workdir-relative path.
+func (w *Workdir) ReadFile(path string) ([]byte, error) {
+ backoff := 1 * time.Millisecond
+ for {
+ b, err := ioutil.ReadFile(w.AbsPath(path))
+ if err != nil {
+ if runtime.GOOS == "plan9" && strings.HasSuffix(err.Error(), " exclusive use file already open") {
+ // Plan 9 enforces exclusive access to locked files.
+ // Give the owner time to unlock it and retry.
+ time.Sleep(backoff)
+ backoff *= 2
+ continue
+ }
+ return nil, err
+ }
+ return b, nil
+ }
+}
+
+// RegexpSearch searches the file corresponding to path for the first position
+// matching re.
+func (w *Workdir) RegexpSearch(path string, re string) (protocol.Location, error) {
+ content, err := w.ReadFile(path)
+ if err != nil {
+ return protocol.Location{}, err
+ }
+ mapper := protocol.NewMapper(w.URI(path).SpanURI(), content)
+ return regexpLocation(mapper, re)
+}
+
+// RemoveFile removes a workdir-relative file path and notifies watchers of the
+// change.
+func (w *Workdir) RemoveFile(ctx context.Context, path string) error {
+ fp := w.AbsPath(path)
+ if err := robustio.RemoveAll(fp); err != nil {
+ return fmt.Errorf("removing %q: %w", path, err)
+ }
+
+ return w.CheckForFileChanges(ctx)
+}
+
+// WriteFiles writes the text file content to workdir-relative paths and
+// notifies watchers of the changes.
+func (w *Workdir) WriteFiles(ctx context.Context, files map[string]string) error {
+ for path, content := range files {
+ fp := w.AbsPath(path)
+ _, err := os.Stat(fp)
+ if err != nil && !os.IsNotExist(err) {
+ return fmt.Errorf("checking if %q exists: %w", path, err)
+ }
+ if err := writeFileData(path, []byte(content), w.RelativeTo); err != nil {
+ return err
+ }
+ }
+ return w.CheckForFileChanges(ctx)
+}
+
+// WriteFile writes text file content to a workdir-relative path and notifies
+// watchers of the change.
+func (w *Workdir) WriteFile(ctx context.Context, path, content string) error {
+ return w.WriteFiles(ctx, map[string]string{path: content})
+}
+
+func (w *Workdir) fileEvent(path string, changeType protocol.FileChangeType) protocol.FileEvent {
+ return protocol.FileEvent{
+ URI: w.URI(path),
+ Type: changeType,
+ }
+}
+
+// RenameFile performs an on disk-renaming of the workdir-relative oldPath to
+// workdir-relative newPath, and notifies watchers of the changes.
+//
+// oldPath must either be a regular file or in the same directory as newPath.
+func (w *Workdir) RenameFile(ctx context.Context, oldPath, newPath string) error {
+ oldAbs := w.AbsPath(oldPath)
+ newAbs := w.AbsPath(newPath)
+
+ // For os.Rename, “OS-specific restrictions may apply when oldpath and newpath
+ // are in different directories.” If that applies here, we may fall back to
+ // ReadFile, WriteFile, and RemoveFile to perform the rename non-atomically.
+ //
+ // However, the fallback path only works for regular files: renaming a
+ // directory would be much more complex and isn't needed for our tests.
+ fallbackOk := false
+ if filepath.Dir(oldAbs) != filepath.Dir(newAbs) {
+ fi, err := os.Stat(oldAbs)
+ if err == nil && !fi.Mode().IsRegular() {
+ return &os.PathError{
+ Op: "RenameFile",
+ Path: oldPath,
+ Err: fmt.Errorf("%w: file is not regular and not in the same directory as %s", os.ErrInvalid, newPath),
+ }
+ }
+ fallbackOk = true
+ }
+
+ var renameErr error
+ const debugFallback = false
+ if fallbackOk && debugFallback {
+ renameErr = fmt.Errorf("%w: debugging fallback path", os.ErrInvalid)
+ } else {
+ renameErr = robustio.Rename(oldAbs, newAbs)
+ }
+ if renameErr != nil {
+ if !fallbackOk {
+ return renameErr // The OS-specific Rename restrictions do not apply.
+ }
+
+ content, err := w.ReadFile(oldPath)
+ if err != nil {
+ // If we can't even read the file, the error from Rename may be accurate.
+ return renameErr
+ }
+ fi, err := os.Stat(newAbs)
+ if err == nil {
+ if fi.IsDir() {
+ // “If newpath already exists and is not a directory, Rename replaces it.”
+ // But if it is a directory, maybe not?
+ return renameErr
+ }
+ // On most platforms, Rename replaces the named file with a new file,
+ // rather than overwriting the existing file it in place. Mimic that
+ // behavior here.
+ if err := robustio.RemoveAll(newAbs); err != nil {
+ // Maybe we don't have permission to replace newPath?
+ return renameErr
+ }
+ } else if !os.IsNotExist(err) {
+ // If the destination path already exists or there is some problem with it,
+ // the error from Rename may be accurate.
+ return renameErr
+ }
+ if writeErr := writeFileData(newPath, []byte(content), w.RelativeTo); writeErr != nil {
+ // At this point we have tried to actually write the file.
+ // If it still doesn't exist, assume that the error from Rename was accurate:
+ // for example, maybe we don't have permission to create the new path.
+ // Otherwise, return the error from the write, which may indicate some
+ // other problem (such as a full disk).
+ if _, statErr := os.Stat(newAbs); !os.IsNotExist(statErr) {
+ return writeErr
+ }
+ return renameErr
+ }
+ if err := robustio.RemoveAll(oldAbs); err != nil {
+ // If we failed to remove the old file, that may explain the Rename error too.
+ // Make a best effort to back out the write to the new path.
+ robustio.RemoveAll(newAbs)
+ return renameErr
+ }
+ }
+
+ return w.CheckForFileChanges(ctx)
+}
+
+// ListFiles returns a new sorted list of the relative paths of files in dir,
+// recursively.
+func (w *Workdir) ListFiles(dir string) ([]string, error) {
+ absDir := w.AbsPath(dir)
+ var paths []string
+ if err := filepath.Walk(absDir, func(fp string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ if info.Mode()&(fs.ModeDir|fs.ModeSymlink) == 0 {
+ paths = append(paths, w.RelPath(fp))
+ }
+ return nil
+ }); err != nil {
+ return nil, err
+ }
+ sort.Strings(paths)
+ return paths, nil
+}
+
+// CheckForFileChanges walks the working directory and checks for any files
+// that have changed since the last poll.
+func (w *Workdir) CheckForFileChanges(ctx context.Context) error {
+ evts, err := w.pollFiles()
+ if err != nil {
+ return err
+ }
+ if len(evts) == 0 {
+ return nil
+ }
+ w.watcherMu.Lock()
+ watchers := make([]func(context.Context, []protocol.FileEvent), len(w.watchers))
+ copy(watchers, w.watchers)
+ w.watcherMu.Unlock()
+ for _, w := range watchers {
+ w(ctx, evts)
+ }
+ return nil
+}
+
+// pollFiles updates w.files and calculates FileEvents corresponding to file
+// state changes since the last poll. It does not call sendEvents.
+func (w *Workdir) pollFiles() ([]protocol.FileEvent, error) {
+ w.fileMu.Lock()
+ defer w.fileMu.Unlock()
+
+ newFiles := make(map[string]fileID)
+ var evts []protocol.FileEvent
+ if err := filepath.Walk(string(w.RelativeTo), func(fp string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ // Skip directories and symbolic links (which may be links to directories).
+ //
+ // The latter matters for repos like Kubernetes, which use symlinks.
+ if info.Mode()&(fs.ModeDir|fs.ModeSymlink) != 0 {
+ return nil
+ }
+
+ // Opt: avoid reading the file if mtime is sufficently old to be reliable.
+ //
+ // If mtime is recent, it may not sufficiently identify the file contents:
+ // a subsequent write could result in the same mtime. For these cases, we
+ // must read the file contents.
+ id := fileID{mtime: info.ModTime()}
+ if time.Since(info.ModTime()) < 2*time.Second {
+ data, err := ioutil.ReadFile(fp)
+ if err != nil {
+ return err
+ }
+ id.hash = hashFile(data)
+ }
+ path := w.RelPath(fp)
+ newFiles[path] = id
+
+ if w.files != nil {
+ oldID, ok := w.files[path]
+ delete(w.files, path)
+ switch {
+ case !ok:
+ evts = append(evts, protocol.FileEvent{
+ URI: w.URI(path),
+ Type: protocol.Created,
+ })
+ case oldID != id:
+ changed := true
+
+ // Check whether oldID and id do not match because oldID was polled at
+ // a recent enough to time such as to require hashing.
+ //
+ // In this case, read the content to check whether the file actually
+ // changed.
+ if oldID.mtime.Equal(id.mtime) && oldID.hash != "" && id.hash == "" {
+ data, err := ioutil.ReadFile(fp)
+ if err != nil {
+ return err
+ }
+ if hashFile(data) == oldID.hash {
+ changed = false
+ }
+ }
+ if changed {
+ evts = append(evts, protocol.FileEvent{
+ URI: w.URI(path),
+ Type: protocol.Changed,
+ })
+ }
+ }
+ }
+
+ return nil
+ }); err != nil {
+ return nil, err
+ }
+
+ // Any remaining files must have been deleted.
+ for path := range w.files {
+ evts = append(evts, protocol.FileEvent{
+ URI: w.URI(path),
+ Type: protocol.Deleted,
+ })
+ }
+ w.files = newFiles
+ return evts, nil
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-24 19:17:33 +0000