Redundant @documentencoding

[goredo.git] / ood.go

diff --git a/ood.go b/ood.go
index 40e6da8b3c17f535d7f03ab4d9cbe2fa3da897ca..b46ea63ee8d6a076090c6255caf2c311795397a3 100644 (file)
--- a/ood.go
+++ b/ood.go
@@ -1,6 +1,6 @@
 /*
 goredo -- djb's redo implementation on pure Go
-Copyright (C) 2020-2022 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2020-2023 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -47,9 +47,27 @@ var (
        FdOODTgts     *os.File
        FdOODTgtsLock *os.File
 
+       OODCache        map[string]bool = make(map[string]bool)
+       FileExistsCache map[string]bool = make(map[string]bool)
+
        ErrMissingTarget = errors.New("invalid format of .rec: missing Target")
 )
 
+func FileExists(p string) bool {
+       if exists, known := FileExistsCache[p]; known {
+               return exists
+       }
+       _, err := os.Stat(p)
+       if err == nil {
+               FileExistsCache[p] = true
+               return true
+       }
+       if os.IsNotExist(err) {
+               FileExistsCache[p] = false
+       }
+       return false
+}
+
 type TgtError struct {
        Tgt string
        Err error
@@ -80,13 +98,13 @@ func cwdAndTgt(tgt string) (string, string) {
 
 func isSrc(cwd, tgt string) bool {
        d, f := path.Split(path.Join(cwd, tgt))
-       if _, err := os.Stat(path.Join(d, f)); err != nil {
+       if !FileExists(path.Join(d, f)) {
                return false
        }
-       if _, err := os.Stat(path.Join(d, f+".do")); err == nil {
+       if FileExists(path.Join(d, f+".do")) {
                return false
        }
-       if _, err := os.Stat(path.Join(d, RedoDir, f+DepSuffix)); err == nil {
+       if FileExists(path.Join(d, RedoDir, f+DepSuffix)) {
                return false
        }
        return true
@@ -111,11 +129,23 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
        indent := strings.Repeat(". ", level)
        tracef(CDebug, "ood: %s%s checking", indent, tgtOrig)
        cwd, tgt := cwdAndTgt(path.Join(cwd, tgtOrig))
+       ood, cached := OODCache[path.Join(cwd, tgt)]
+       if cached {
+               tracef(CDebug, "ood: %s%s -> cached: %v", indent, tgtOrig, ood)
+               return ood, nil
+       }
        depPath := path.Join(cwd, RedoDir, tgt+DepSuffix)
        fdDep, err := os.Open(depPath)
        if err != nil {
-               tracef(CDebug, "ood: %s%s -> no dep: %s", indent, tgtOrig, depPath)
-               return true, nil
+               if isSrc(cwd, tgt) {
+                       ood = false
+                       tracef(CDebug, "ood: %s%s -> is source", indent, tgtOrig)
+               } else {
+                       ood = true
+                       tracef(CDebug, "ood: %s%s -> no dep: %s", indent, tgtOrig, depPath)
+               }
+               OODCache[path.Join(cwd, tgt)] = ood
+               return ood, nil
        }
        depInfo, err := depRead(fdDep)
        fdDep.Close()
@@ -125,16 +155,17 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
 
        if depInfo.build == BuildUUID {
                tracef(CDebug, "ood: %s%s -> already built", indent, tgtOrig)
+               OODCache[path.Join(cwd, tgt)] = false
                return false, nil
        }
-       if _, err := os.Stat(path.Join(cwd, tgt)); err != nil && os.IsNotExist(err) {
+       if !FileExists(path.Join(cwd, tgt)) {
                tracef(CDebug, "ood: %s%s -> non-existent", indent, tgtOrig)
+               OODCache[path.Join(cwd, tgt)] = true
                return true, nil
        }
-       ood := false
 
        for _, dep := range depInfo.ifcreates {
-               if _, err := os.Stat(path.Join(cwd, dep)); err == nil {
+               if FileExists(path.Join(cwd, dep)) {
                        tracef(CDebug, "ood: %s%s -> %s created", indent, tgtOrig, dep)
                        ood = true
                        goto Done
@@ -152,43 +183,53 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
                }
                theirHsh := m["Hash"]
                tracef(CDebug, "ood: %s%s -> %s: checking", indent, tgtOrig, dep)
+               ood, cached = OODCache[path.Join(cwd, dep)]
+               if cached {
+                       tracef(CDebug, "ood: %s%s -> %s: cached: %v", indent, tgtOrig, dep, ood)
+                       if ood {
+                               goto Done
+                       }
+                       continue
+               }
 
-               fd, err := os.Open(path.Join(cwd, dep))
+               inode, err := inodeFromFileByPath(path.Join(cwd, dep))
                if err != nil {
                        if os.IsNotExist(err) {
                                tracef(CDebug, "ood: %s%s -> %s: not exists", indent, tgtOrig, dep)
                                ood = true
+                               OODCache[path.Join(cwd, dep)] = ood
                                goto Done
                        }
                        return ood, TgtError{tgtOrig, err}
                }
-               defer fd.Close()
 
-               inode, err := inodeFromFile(fd)
-               if err != nil {
-                       return ood, TgtError{tgtOrig, err}
-               }
                if inode.Size != theirInode.Size {
                        tracef(CDebug, "ood: %s%s -> %s: size differs", indent, tgtOrig, dep)
                        ood = true
+                       OODCache[path.Join(cwd, dep)] = ood
                        goto Done
                }
                if InodeTrust != InodeTrustNone && inode.Equals(theirInode) {
                        tracef(CDebug, "ood: %s%s -> %s: same inode", indent, tgtOrig, dep)
                } else {
                        tracef(CDebug, "ood: %s%s -> %s: inode differs", indent, tgtOrig, dep)
+                       fd, err := os.Open(path.Join(cwd, dep))
+                       if err != nil {
+                               return ood, TgtError{tgtOrig, err}
+                       }
                        hsh, err := fileHash(fd)
+                       fd.Close()
                        if err != nil {
                                return ood, TgtError{tgtOrig, err}
                        }
                        if theirHsh != hsh {
                                tracef(CDebug, "ood: %s%s -> %s: hash differs", indent, tgtOrig, dep)
                                ood = true
+                               OODCache[path.Join(cwd, dep)] = ood
                                goto Done
                        }
                        tracef(CDebug, "ood: %s%s -> %s: same hash", indent, tgtOrig, dep)
                }
-               fd.Close()
 
                if dep == tgt {
                        tracef(CDebug, "ood: %s%s -> %s: same target", indent, tgtOrig, dep)
@@ -196,11 +237,13 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
                }
                if isSrc(cwd, dep) {
                        tracef(CDebug, "ood: %s%s -> %s: is source", indent, tgtOrig, dep)
+                       OODCache[path.Join(cwd, dep)] = false
                        continue
                }
 
                if _, ok := seen[cwdMustRel(cwd, dep)]; ok {
                        tracef(CDebug, "ood: %s%s -> %s: was always built", indent, tgtOrig, dep)
+                       OODCache[path.Join(cwd, dep)] = false
                        continue
                }
 
@@ -218,6 +261,7 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
 
 Done:
        tracef(CDebug, "ood: %s%s: %v", indent, tgtOrig, ood)
+       OODCache[path.Join(cwd, tgt)] = ood
        return ood, nil
 }