X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=ood.go;h=cad1ce38f5f23f6beb1124749774a7d4111303ec;hb=ce96a1c785b32af13264225c0bf7ae8370a5af21;hp=15d0ae5abb6d15990dda880b627c14e096ab8ca7;hpb=67e92d5a298516292bbbee1f7714708cdc0766f8;p=goredo.git diff --git a/ood.go b/ood.go index 15d0ae5..cad1ce3 100644 --- a/ood.go +++ b/ood.go @@ -1,6 +1,6 @@ /* -goredo -- redo implementation on pure Go -Copyright (C) 2020 Sergey Matveev +goredo -- djb's redo implementation on pure Go +Copyright (C) 2020-2021 Sergey Matveev 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 @@ -22,13 +22,12 @@ package main import ( "errors" "fmt" - "io" "os" "path" "path/filepath" "strings" - "go.cypherpunks.ru/recfile" + "golang.org/x/sys/unix" ) const ( @@ -36,6 +35,15 @@ const ( DepTypeIfchange = "ifchange" DepTypeAlways = "always" DepTypeStamp = "stamp" + + EnvOODTgtsFd = "REDO_OOD_TGTS_FD" + EnvOODTgtsLockFd = "REDO_OOD_TGTS_LOCK_FD" +) + +var ( + OODTgts map[string]struct{} + FdOODTgts *os.File + FdOODTgtsLock *os.File ) type TgtErr struct { @@ -71,63 +79,16 @@ func isSrc(cwd, tgt string) bool { if _, err := os.Stat(path.Join(d, f)); err != nil { return false } + if _, err := os.Stat(path.Join(d, f+".do")); err == nil { + return false + } if _, err := os.Stat(path.Join(d, RedoDir, f+DepSuffix)); err == nil { return false } return true } -func isBuiltNow(fdDep *os.File) (bool, *recfile.Reader, error) { - r := recfile.NewReader(fdDep) - m, err := r.NextMap() - if err != nil { - return false, nil, err - } - if m["Build"] == "" { - return false, r, errors.New(".dep missing Build:") - } - return m["Build"] == BuildUUID, r, nil -} - -func rebuildStamped(cwd, tgt, depPath string) (string, error) { - relTgt := cwdMustRel(cwd, tgt) - errs := make(chan error, 1) - if err := runScript(relTgt, errs); err != nil { - return "", err - } - if err := <-errs; !isOkRun(err) { - return "", errors.New("build failed") - } - fdDep, err := os.Open(depPath) - if err != nil { - return "", err - } - defer fdDep.Close() - builtNow, r, err := isBuiltNow(fdDep) - if err != nil { - return "", err - } - if !builtNow { - return "", errors.New("is not built") - } - var stampTheir string - for { - m, err := r.NextMap() - if err != nil { - if err == io.EOF { - break - } - return "", err - } - if m["Type"] == DepTypeStamp { - stampTheir = m["Hash"] - break - } - } - return stampTheir, nil -} - -func isOOD(cwd, tgtOrig string, level int) (bool, error) { +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) cwd, tgt := cwdAndTgt(path.Join(cwd, tgtOrig)) @@ -137,89 +98,62 @@ func isOOD(cwd, tgtOrig string, level int) (bool, error) { trace(CDebug, "ood: %s%s -> no dep: %s", indent, tgtOrig, depPath) return true, nil } - defer fdDep.Close() - ood := false - - builtNow, r, err := isBuiltNow(fdDep) + depInfo, err := depRead(fdDep) + fdDep.Close() if err != nil { return true, TgtErr{tgtOrig, err} } - if builtNow { + + if depInfo.build == BuildUUID { trace(CDebug, "ood: %s%s -> already built", indent, tgtOrig) return false, nil } + ood := false - var stampOur string - ifcreates := []map[string]string{} - ifchanges := []map[string]string{} - for { - m, err := r.NextMap() - if err != nil { - if err == io.EOF { - break - } - return true, TgtErr{tgtOrig, err} - } - switch m["Type"] { - case DepTypeAlways: - trace(CDebug, "ood: %s%s -> always", indent, tgtOrig) + 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) ood = true - case DepTypeIfcreate: - ifcreates = append(ifcreates, m) - case DepTypeIfchange: - ifchanges = append(ifchanges, m) - case DepTypeStamp: - stampOur = m["Hash"] - trace(CDebug, "ood: %s%s -> stamped: %s", indent, tgtOrig, stampOur) - default: - return ood, TgtErr{tgtOrig, errors.New("invalid format of .dep")} + goto Done } } - if ood { - goto StampCheck - } - for _, m := range ifcreates { - theirTgt := m["Target"] - if theirTgt == "" { - return ood, TgtErr{tgtOrig, errors.New("invalid format of .dep")} + for _, m := range depInfo.ifchanges { + dep := m["Target"] + if dep == "" { + return ood, TgtErr{tgtOrig, errors.New("invalid format of .rec: missing Target")} } - if _, err = os.Stat(path.Join(cwd, theirTgt)); err == nil { - trace(CDebug, "ood: %s%s -> created", indent, tgtOrig) - ood = true - goto StampCheck + theirInode, err := inodeFromRec(m) + if err != nil { + return ood, TgtErr{tgtOrig, fmt.Errorf("invalid format of .rec: %v", err)} } - } - - for _, m := range ifchanges { - dep := m["Target"] - theirTs := m["Ctime"] theirHsh := m["Hash"] - if dep == "" || theirTs == "" { - return ood, TgtErr{tgtOrig, errors.New("invalid format of .dep")} - } trace(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) ood = true - goto StampCheck + goto Done } return ood, TgtErr{tgtOrig, err} } defer fd.Close() - ts, err := fileCtime(fd) + + inode, err := inodeFromFile(fd) if err != nil { return ood, TgtErr{tgtOrig, err} } - if theirTs == ts { - trace(CDebug, "ood: %s%s -> %s: same ctime", indent, tgtOrig, dep) - } else if NoHash || theirHsh == "" { - trace(CDebug, "ood: %s%s -> %s: ctime differs", indent, tgtOrig, dep) + if inode.Size != theirInode.Size { + trace(CDebug, "ood: %s%s -> %s: size differs", indent, tgtOrig, dep) ood = true - goto StampCheck + goto Done + } + if InodeTrust && inode.Equals(theirInode) { + trace(CDebug, "ood: %s%s -> %s: same inode", indent, tgtOrig, dep) } else { + trace(CDebug, "ood: %s%s -> %s: inode differs", indent, tgtOrig, dep) hsh, err := fileHash(fd) if err != nil { return ood, TgtErr{tgtOrig, err} @@ -227,11 +161,12 @@ func isOOD(cwd, tgtOrig string, level int) (bool, error) { if theirHsh != hsh { trace(CDebug, "ood: %s%s -> %s: hash differs", indent, tgtOrig, dep) ood = true - goto StampCheck + goto Done } trace(CDebug, "ood: %s%s -> %s: same hash", indent, tgtOrig, dep) } - fd.Close() + fd.Close() // optimization not to hold it for long + if dep == tgt { trace(CDebug, "ood: %s%s -> %s: same target", indent, tgtOrig, dep) continue @@ -240,30 +175,71 @@ func isOOD(cwd, tgtOrig string, level int) (bool, error) { trace(CDebug, "ood: %s%s -> %s: is source", indent, tgtOrig, dep) continue } - depOod, err := isOOD(cwd, dep, level+1) + + if _, ok := seen[cwdMustRel(cwd, dep)]; ok { + trace(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} } if depOod { trace(CDebug, "ood: %s%s -> %s: ood", indent, tgtOrig, dep) ood = true - goto StampCheck + goto Done } trace(CDebug, "ood: %s%s -> %s: !ood", indent, tgtOrig, dep) } -StampCheck: - if ood && stampOur != "" { - trace(CDebug, "ood: %s%s run, because stamped", indent, tgtOrig) - stampTheir, err := rebuildStamped(cwd, tgt, depPath) - if err != nil { - return true, TgtErr{tgtOrig, err} - } - trace(CDebug, "ood: %s%s -> stamp: %s %s", indent, tgtOrig, stampOur, stampTheir) - if stampOur == stampTheir { - ood = false - } - } +Done: trace(CDebug, "ood: %s%s: %v", indent, tgtOrig, ood) return ood, nil } + +func isOODWithTrace( + cwd, tgtOrig string, + level int, + seen map[string]struct{}, +) (bool, error) { + p, err := filepath.Abs(path.Join(cwd, tgtOrig)) + if err != nil { + panic(err) + } + _, ood := OODTgts[p] + if ood { + trace( + CDebug, + "ood: %s%s true, external decision", + strings.Repeat(". ", level), tgtOrig, + ) + goto RecordOODTgt + } + ood, err = isOOD(cwd, tgtOrig, level, seen) + if !ood { + return ood, err + } +RecordOODTgt: + if err = unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_EX); err != nil { + panic(err) + } + if _, err = FdOODTgts.Seek(0, os.SEEK_END); err != nil { + panic(err) + } + if _, err := FdOODTgts.WriteString(p + "\x00"); err != nil { + panic(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) + } + if err := FdOODTgts.Truncate(0); err != nil { + panic(err) + } + unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_UN) +}