Optimise memory storage of dependency information

[goredo.git] / ood.go

diff --git a/ood.go b/ood.go
index 4a284c6ceaf31db355b53890957473a06ec30cf5..3843fa1170b173e2469d240a2feef8ab005d7c2c 100644 (file)
--- a/ood.go
+++ b/ood.go
@@ -20,6 +20,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package main
 
 import (
+       "bytes"
        "errors"
        "fmt"
        "io"
@@ -110,22 +111,22 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
                return ood, nil
        }
        depPath := path.Join(cwd, RedoDir, tgt+DepSuffix)
-       fdDep, err := os.Open(depPath)
+       depInfo, err := depRead(depPath)
        if err != 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)
+               if errors.Is(err, fs.ErrNotExist) {
+                       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
+               }
+               if err != nil {
+                       return true, TgtError{tgtOrig, ErrLine(err)}
                }
-               OODCache[path.Join(cwd, tgt)] = ood
-               return ood, nil
-       }
-       depInfo, err := depRead(fdDep)
-       fdDep.Close()
-       if err != nil {
-               return true, TgtError{tgtOrig, ErrLine(err)}
        }
 
        if depInfo.build == BuildUUID {
@@ -147,48 +148,42 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
                }
        }
 
-       for _, m := range depInfo.ifchanges {
-               dep := m["Target"]
-               if dep == "" {
+       for _, dep := range depInfo.ifchanges {
+               if dep.tgt == "" {
                        return ood, TgtError{tgtOrig, ErrMissingTarget}
                }
-               theirInode, err := inodeFromRec(m)
-               if err != nil {
-                       return ood, TgtError{tgtOrig, fmt.Errorf("invalid format of .rec: %w", err)}
-               }
-               theirHsh := m["Hash"]
-               tracef(CDebug, "ood: %s%s -> %s: checking", indent, tgtOrig, dep)
-               ood, cached = OODCache[path.Join(cwd, dep)]
+               tracef(CDebug, "ood: %s%s -> %s: checking", indent, tgtOrig, dep.tgt)
+               ood, cached = OODCache[path.Join(cwd, dep.tgt)]
                if cached {
-                       tracef(CDebug, "ood: %s%s -> %s: cached: %v", indent, tgtOrig, dep, ood)
+                       tracef(CDebug, "ood: %s%s -> %s: cached: %v", indent, tgtOrig, dep.tgt, ood)
                        if ood {
                                goto Done
                        }
                        continue
                }
 
-               inode, err := inodeFromFileByPath(path.Join(cwd, dep))
+               inode, err := inodeFromFileByPath(path.Join(cwd, dep.tgt))
                if err != nil {
                        if errors.Is(err, fs.ErrNotExist) {
-                               tracef(CDebug, "ood: %s%s -> %s: not exists", indent, tgtOrig, dep)
+                               tracef(CDebug, "ood: %s%s -> %s: not exists", indent, tgtOrig, dep.tgt)
                                ood = true
-                               OODCache[path.Join(cwd, dep)] = ood
+                               OODCache[path.Join(cwd, dep.tgt)] = ood
                                goto Done
                        }
                        return ood, TgtError{tgtOrig, ErrLine(err)}
                }
 
-               if inode.Size != theirInode.Size {
-                       tracef(CDebug, "ood: %s%s -> %s: size differs", indent, tgtOrig, dep)
+               if inode.Size != dep.inode.Size {
+                       tracef(CDebug, "ood: %s%s -> %s: size differs", indent, tgtOrig, dep.tgt)
                        ood = true
-                       OODCache[path.Join(cwd, dep)] = ood
+                       OODCache[path.Join(cwd, dep.tgt)] = ood
                        goto Done
                }
-               if InodeTrust != InodeTrustNone && inode.Equals(theirInode) {
-                       tracef(CDebug, "ood: %s%s -> %s: same inode", indent, tgtOrig, dep)
+               if InodeTrust != InodeTrustNone && inode.Equals(dep.inode) {
+                       tracef(CDebug, "ood: %s%s -> %s: same inode", indent, tgtOrig, dep.tgt)
                } else {
-                       tracef(CDebug, "ood: %s%s -> %s: inode differs", indent, tgtOrig, dep)
-                       fd, err := os.Open(path.Join(cwd, dep))
+                       tracef(CDebug, "ood: %s%s -> %s: inode differs", indent, tgtOrig, dep.tgt)
+                       fd, err := os.Open(path.Join(cwd, dep.tgt))
                        if err != nil {
                                return ood, TgtError{tgtOrig, ErrLine(err)}
                        }
@@ -197,41 +192,41 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
                        if err != nil {
                                return ood, TgtError{tgtOrig, ErrLine(err)}
                        }
-                       if theirHsh != hsh {
-                               tracef(CDebug, "ood: %s%s -> %s: hash differs", indent, tgtOrig, dep)
+                       if !bytes.Equal(dep.hash, hsh) {
+                               tracef(CDebug, "ood: %s%s -> %s: hash differs", indent, tgtOrig, dep.tgt)
                                ood = true
-                               OODCache[path.Join(cwd, dep)] = ood
+                               OODCache[path.Join(cwd, dep.tgt)] = ood
                                goto Done
                        }
-                       tracef(CDebug, "ood: %s%s -> %s: same hash", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: same hash", indent, tgtOrig, dep.tgt)
                }
 
-               if dep == tgt {
-                       tracef(CDebug, "ood: %s%s -> %s: same target", indent, tgtOrig, dep)
+               if dep.tgt == tgt {
+                       tracef(CDebug, "ood: %s%s -> %s: same target", indent, tgtOrig, dep.tgt)
                        continue
                }
-               if isSrc(cwd, dep) {
-                       tracef(CDebug, "ood: %s%s -> %s: is source", indent, tgtOrig, dep)
-                       OODCache[path.Join(cwd, dep)] = false
+               if isSrc(cwd, dep.tgt) {
+                       tracef(CDebug, "ood: %s%s -> %s: is source", indent, tgtOrig, dep.tgt)
+                       OODCache[path.Join(cwd, dep.tgt)] = 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
+               if _, ok := seen[cwdMustRel(cwd, dep.tgt)]; ok {
+                       tracef(CDebug, "ood: %s%s -> %s: was always built", indent, tgtOrig, dep.tgt)
+                       OODCache[path.Join(cwd, dep.tgt)] = false
                        continue
                }
 
-               depOOD, err := isOODWithTrace(cwd, dep, level+1, seen)
+               depOOD, err := isOODWithTrace(cwd, dep.tgt, level+1, seen)
                if err != nil {
                        return ood, TgtError{tgtOrig, err}
                }
                if depOOD {
-                       tracef(CDebug, "ood: %s%s -> %s: ood", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: ood", indent, tgtOrig, dep.tgt)
                        ood = true
                        goto Done
                }
-               tracef(CDebug, "ood: %s%s -> %s: !ood", indent, tgtOrig, dep)
+               tracef(CDebug, "ood: %s%s -> %s: !ood", indent, tgtOrig, dep.tgt)
        }
 
 Done: