chore: sync with go1.14.15

Author: ldez

internal/cache/cache.go

@@ -75,7 +75,22 @@ func (c *Cache) fileName(id [HashSize]byte, key string) string {
 	return filepath.Join(c.dir, fmt.Sprintf("%02x", id[0]), fmt.Sprintf("%x", id)+"-"+key)
 }
 
-var errMissing = errors.New("cache entry not found")
+// An entryNotFoundError indicates that a cache entry was not found, with an
+// optional underlying reason.
+type entryNotFoundError struct {
+	Err error
+}
+
+func (e *entryNotFoundError) Error() string {
+	if e.Err == nil {
+		return "cache entry not found"
+	}
+	return fmt.Sprintf("cache entry not found: %v", e.Err)
+}
+
+func (e *entryNotFoundError) Unwrap() error {
+	return e.Err
+}
 
 const (
 	// action entry file is "v1 <hex id> <hex out> <decimal size space-padded to 20 bytes> <unixnano space-padded to 20 bytes>\n"
@@ -94,6 +109,8 @@ const (
 // GODEBUG=gocacheverify=1.
 var verify = false
 
+var errVerifyMode = errors.New("gocachevrify=1")
+
 // DebugTest is set when GODEBUG=gocachetest=1 is in the environment.
 var DebugTest = false
 
@@ -122,7 +139,7 @@ func initEnv() {
 // saved file for that output ID is still available.
 func (c *Cache) Get(id ActionID) (Entry, error) {
 	if verify {
-		return Entry{}, errMissing
+		return Entry{}, &entryNotFoundError{Err: errVerifyMode}
 	}
 	return c.get(id)
 }
@@ -135,50 +152,60 @@ type Entry struct {
 
 // get is Get but does not respect verify mode, so that Put can use it.
 func (c *Cache) get(id ActionID) (Entry, error) {
-	missing := func() (Entry, error) {
-		return Entry{}, errMissing
+	missing := func(reason error) (Entry, error) {
+		return Entry{}, &entryNotFoundError{Err: reason}
 	}
 	f, err := os.Open(c.fileName(id, "a"))
 	if err != nil {
-		if os.IsNotExist(err) {
-			return missing()
-		}
-		return Entry{}, err
+		return missing(err)
 	}
 	defer f.Close()
 	entry := make([]byte, entrySize+1) // +1 to detect whether f is too long
-	if n, err := io.ReadFull(f, entry); n != entrySize || err != io.ErrUnexpectedEOF {
-		return Entry{}, fmt.Errorf("read %d/%d bytes from %s with error %w", n, entrySize, c.fileName(id, "a"), err)
+	if n, err := io.ReadFull(f, entry); n > entrySize {
+		return missing(errors.New("too long"))
+	} else if err != io.ErrUnexpectedEOF {
+		if err == io.EOF {
+			return missing(errors.New("file is empty"))
+		}
+		return missing(err)
+	} else if n < entrySize {
+		return missing(errors.New("entry file incomplete"))
 	}
 	if entry[0] != 'v' || entry[1] != '1' || entry[2] != ' ' || entry[3+hexSize] != ' ' || entry[3+hexSize+1+hexSize] != ' ' || entry[3+hexSize+1+hexSize+1+20] != ' ' || entry[entrySize-1] != '\n' {
-		return Entry{}, fmt.Errorf("bad data in %s", c.fileName(id, "a"))
+		return missing(errors.New("invalid header"))
 	}
 	eid, entry := entry[3:3+hexSize], entry[3+hexSize:]
 	eout, entry := entry[1:1+hexSize], entry[1+hexSize:]
 	esize, entry := entry[1:1+20], entry[1+20:]
 	etime, entry := entry[1:1+20], entry[1+20:]
 	var buf [HashSize]byte
-	if _, err := hex.Decode(buf[:], eid); err != nil || buf != id {
-		return Entry{}, fmt.Errorf("failed to hex decode eid data in %s: %w", c.fileName(id, "a"), err)
+	if _, err := hex.Decode(buf[:], eid); err != nil {
+		return missing(fmt.Errorf("decoding ID: %v", err))
+	} else if buf != id {
+		return missing(errors.New("mismatched ID"))
 	}
 	if _, err := hex.Decode(buf[:], eout); err != nil {
-		return Entry{}, fmt.Errorf("failed to hex decode eout data in %s: %w", c.fileName(id, "a"), err)
+		return missing(fmt.Errorf("decoding output ID: %v", err))
 	}
 	i := 0
 	for i < len(esize) && esize[i] == ' ' {
 		i++
 	}
 	size, err := strconv.ParseInt(string(esize[i:]), 10, 64)
-	if err != nil || size < 0 {
-		return Entry{}, fmt.Errorf("failed to parse esize int from %s with error %w", c.fileName(id, "a"), err)
+	if err != nil {
+		return missing(fmt.Errorf("parsing size: %v", err))
+	} else if size < 0 {
+		return missing(errors.New("negative size"))
 	}
 	i = 0
 	for i < len(etime) && etime[i] == ' ' {
 		i++
 	}
 	tm, err := strconv.ParseInt(string(etime[i:]), 10, 64)
-	if err != nil || tm < 0 {
-		return Entry{}, fmt.Errorf("failed to parse etime int from %s with error %w", c.fileName(id, "a"), err)
+	if err != nil {
+		return missing(fmt.Errorf("parsing timestamp: %v", err))
+	} else if tm < 0 {
+		return missing(errors.New("negative timestamp"))
 	}
 
 	err = c.used(c.fileName(id, "a"))
@@ -203,8 +230,11 @@ func (c *Cache) GetFile(id ActionID) (file string, entry Entry, err error) {
 	}
 
 	info, err := os.Stat(file)
-	if err != nil || info.Size() != entry.Size {
-		return "", Entry{}, errMissing
+	if err != nil {
+		return "", Entry{}, &entryNotFoundError{Err: err}
+	}
+	if info.Size() != entry.Size {
+		return "", Entry{}, &entryNotFoundError{Err: errors.New("file incomplete")}
 	}
 	return file, entry, nil
 }
@@ -222,7 +252,7 @@ func (c *Cache) GetBytes(id ActionID) ([]byte, Entry, error) {
 		return nil, entry, err
 	}
 	if sha256.Sum256(data) != entry.OutputID {
-		return nil, entry, errMissing
+		return nil, entry, &entryNotFoundError{Err: errors.New("bad checksum")}
 	}
 	return data, entry, nil
 }
@@ -272,9 +302,9 @@ func (c *Cache) used(file string) error {
 
 	if err != nil {
 		if os.IsNotExist(err) {
-			return errMissing
+			return &entryNotFoundError{Err: err}
 		}
-		return fmt.Errorf("failed to stat file %s: %w", file, err)
+		return &entryNotFoundError{Err: fmt.Errorf("failed to stat file %s: %w", file, err)}
 	}
 
 	err = os.Chtimes(file, c.now(), c.now())

internal/cache/cache_gcil.go

@@ -6,8 +6,11 @@ import (
 	"github.com/golangci/golangci-lint/internal/robustio"
 )
 
+// IsErrMissing allows to access to the internal error.
+// TODO(ldez) the handling of this error inside runner_action.go should be refactored.
 func IsErrMissing(err error) bool {
-	return errors.Is(err, errMissing)
+	var errENF *entryNotFoundError
+	return errors.As(err, &errENF)
 }
 
 func (c *Cache) readFileCGIL(outputFile string, err error) ([]byte, error) {

internal/cache/readme.md

@@ -2,6 +2,10 @@
 
 Extracted from `go/src/cmd/go/internal/cache/`.
 
+- sync with go1.14.15
+
+# Previous History
+
 Based on the initial PR/commit the based in a mix between go1.12 and go1.13:
 - cache.go (go1.13)
 - cache_test.go (go1.12?)