Unify dep*Read/Write name

[goredo.git] / ood.go

diff --git a/ood.go b/ood.go
index cad1ce38f5f23f6beb1124749774a7d4111303ec..fdb0d846b219534549ac2ac31842bbef0a56fb6c 100644 (file)
--- a/ood.go
+++ b/ood.go
@@ -22,6 +22,8 @@ package main
 import (
        "errors"
        "fmt"
+       "io"
+       "log"
        "os"
        "path"
        "path/filepath"
@@ -46,14 +48,14 @@ var (
        FdOODTgtsLock *os.File
 )
 
-type TgtErr struct {
+type TgtError struct {
        Tgt string
        Err error
 }
 
-func (e TgtErr) Unwrap() error { return e.Err }
+func (e TgtError) Unwrap() error { return e.Err }
 
-func (e TgtErr) Error() string {
+func (e TgtError) Error() string {
        return fmt.Sprintf("%s: %s", e.Tgt, e.Err)
 }
 
@@ -88,31 +90,50 @@ func isSrc(cwd, tgt string) bool {
        return true
 }
 
+func isOODByBuildUUID(cwd, tgtOrig string) bool {
+       cwd, tgt := cwdAndTgt(path.Join(cwd, tgtOrig))
+       depPath := path.Join(cwd, RedoDir, tgt+DepSuffix)
+       fdDep, err := os.Open(depPath)
+       if err != nil {
+               return true
+       }
+       depInfo, err := depRead(fdDep)
+       fdDep.Close()
+       if err != nil || depInfo.build != BuildUUID {
+               return true
+       }
+       return false
+}
+
 func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, error) {
        indent := strings.Repeat(". ", level)
-       trace(CDebug, "ood: %s%s checking", indent, tgtOrig)
+       tracef(CDebug, "ood: %s%s checking", indent, tgtOrig)
        cwd, tgt := cwdAndTgt(path.Join(cwd, tgtOrig))
        depPath := path.Join(cwd, RedoDir, tgt+DepSuffix)
        fdDep, err := os.Open(depPath)
        if err != nil {
-               trace(CDebug, "ood: %s%s -> no dep: %s", indent, tgtOrig, depPath)
+               tracef(CDebug, "ood: %s%s -> no dep: %s", indent, tgtOrig, depPath)
                return true, nil
        }
        depInfo, err := depRead(fdDep)
        fdDep.Close()
        if err != nil {
-               return true, TgtErr{tgtOrig, err}
+               return true, TgtError{tgtOrig, err}
        }
 
        if depInfo.build == BuildUUID {
-               trace(CDebug, "ood: %s%s -> already built", indent, tgtOrig)
+               tracef(CDebug, "ood: %s%s -> already built", indent, tgtOrig)
                return false, nil
        }
+       if _, err := os.Stat(path.Join(cwd, tgt)); err != nil && os.IsNotExist(err) {
+               tracef(CDebug, "ood: %s%s -> non-existent", indent, tgtOrig)
+               return true, nil
+       }
        ood := false
 
        for _, dep := range depInfo.ifcreates {
                if _, err := os.Stat(path.Join(cwd, dep)); err == nil {
-                       trace(CDebug, "ood: %s%s -> %s created", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s created", indent, tgtOrig, dep)
                        ood = true
                        goto Done
                }
@@ -121,80 +142,80 @@ func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, erro
        for _, m := range depInfo.ifchanges {
                dep := m["Target"]
                if dep == "" {
-                       return ood, TgtErr{tgtOrig, errors.New("invalid format of .rec: missing Target")}
+                       return ood, TgtError{tgtOrig, errors.New("invalid format of .rec: missing Target")}
                }
                theirInode, err := inodeFromRec(m)
                if err != nil {
-                       return ood, TgtErr{tgtOrig, fmt.Errorf("invalid format of .rec: %v", err)}
+                       return ood, TgtError{tgtOrig, fmt.Errorf("invalid format of .rec: %w", err)}
                }
                theirHsh := m["Hash"]
-               trace(CDebug, "ood: %s%s -> %s: checking", indent, tgtOrig, dep)
+               tracef(CDebug, "ood: %s%s -> %s: checking", indent, tgtOrig, dep)
 
                fd, err := os.Open(path.Join(cwd, dep))
                if err != nil {
                        if os.IsNotExist(err) {
-                               trace(CDebug, "ood: %s%s -> %s: not exists", indent, tgtOrig, dep)
+                               tracef(CDebug, "ood: %s%s -> %s: not exists", indent, tgtOrig, dep)
                                ood = true
                                goto Done
                        }
-                       return ood, TgtErr{tgtOrig, err}
+                       return ood, TgtError{tgtOrig, err}
                }
                defer fd.Close()
 
                inode, err := inodeFromFile(fd)
                if err != nil {
-                       return ood, TgtErr{tgtOrig, err}
+                       return ood, TgtError{tgtOrig, err}
                }
                if inode.Size != theirInode.Size {
-                       trace(CDebug, "ood: %s%s -> %s: size differs", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: size differs", indent, tgtOrig, dep)
                        ood = true
                        goto Done
                }
                if InodeTrust && inode.Equals(theirInode) {
-                       trace(CDebug, "ood: %s%s -> %s: same inode", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: same inode", indent, tgtOrig, dep)
                } else {
-                       trace(CDebug, "ood: %s%s -> %s: inode differs", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: inode differs", indent, tgtOrig, dep)
                        hsh, err := fileHash(fd)
                        if err != nil {
-                               return ood, TgtErr{tgtOrig, err}
+                               return ood, TgtError{tgtOrig, err}
                        }
                        if theirHsh != hsh {
-                               trace(CDebug, "ood: %s%s -> %s: hash differs", indent, tgtOrig, dep)
+                               tracef(CDebug, "ood: %s%s -> %s: hash differs", indent, tgtOrig, dep)
                                ood = true
                                goto Done
                        }
-                       trace(CDebug, "ood: %s%s -> %s: same hash", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: same hash", indent, tgtOrig, dep)
                }
                fd.Close() // optimization not to hold it for long
 
                if dep == tgt {
-                       trace(CDebug, "ood: %s%s -> %s: same target", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: same target", indent, tgtOrig, dep)
                        continue
                }
                if isSrc(cwd, dep) {
-                       trace(CDebug, "ood: %s%s -> %s: is source", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: is source", indent, tgtOrig, dep)
                        continue
                }
 
                if _, ok := seen[cwdMustRel(cwd, dep)]; ok {
-                       trace(CDebug, "ood: %s%s -> %s: was always built", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: was always built", indent, tgtOrig, dep)
                        continue
                }
 
                depOod, err := isOODWithTrace(cwd, dep, level+1, seen)
                if err != nil {
-                       return ood, TgtErr{tgtOrig, err}
+                       return ood, TgtError{tgtOrig, err}
                }
                if depOod {
-                       trace(CDebug, "ood: %s%s -> %s: ood", indent, tgtOrig, dep)
+                       tracef(CDebug, "ood: %s%s -> %s: ood", indent, tgtOrig, dep)
                        ood = true
                        goto Done
                }
-               trace(CDebug, "ood: %s%s -> %s: !ood", indent, tgtOrig, dep)
+               tracef(CDebug, "ood: %s%s -> %s: !ood", indent, tgtOrig, dep)
        }
 
 Done:
-       trace(CDebug, "ood: %s%s: %v", indent, tgtOrig, ood)
+       tracef(CDebug, "ood: %s%s: %v", indent, tgtOrig, ood)
        return ood, nil
 }
 
@@ -209,7 +230,15 @@ func isOODWithTrace(
        }
        _, ood := OODTgts[p]
        if ood {
-               trace(
+               if !isOODByBuildUUID(cwd, tgtOrig) {
+                       tracef(
+                               CDebug,
+                               "ood: %s%s -> already built",
+                               strings.Repeat(". ", level), tgtOrig,
+                       )
+                       return false, nil
+               }
+               tracef(
                        CDebug,
                        "ood: %s%s true, external decision",
                        strings.Repeat(". ", level), tgtOrig,
@@ -222,24 +251,29 @@ func isOODWithTrace(
        }
 RecordOODTgt:
        if err = unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_EX); err != nil {
-               panic(err)
+               log.Fatalln(err)
        }
-       if _, err = FdOODTgts.Seek(0, os.SEEK_END); err != nil {
-               panic(err)
+       if _, err = FdOODTgts.Seek(0, io.SeekEnd); err != nil {
+               log.Fatalln(err)
        }
        if _, err := FdOODTgts.WriteString(p + "\x00"); err != nil {
-               panic(err)
+               log.Fatalln(err)
+       }
+       if err = unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_UN); err != nil {
+               log.Fatalln(err)
        }
-       unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_UN)
        return true, nil
 }
 
 func oodTgtsClear() {
-       if err := unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_EX); err != nil {
-               panic(err)
+       var err error
+       if err = unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_EX); err != nil {
+               log.Fatalln(err)
        }
-       if err := FdOODTgts.Truncate(0); err != nil {
-               panic(err)
+       if err = FdOODTgts.Truncate(0); err != nil {
+               log.Fatalln(err)
+       }
+       if err = unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_UN); err != nil {
+               log.Fatalln(err)
        }
-       unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_UN)
 }