2 goredo -- djb's redo implementation on pure Go
3 Copyright (C) 2020-2023 Sergey Matveev <stargrave@stargrave.org>
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, version 3 of the License.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>.
38 "go.cypherpunks.ru/recfile"
39 "golang.org/x/sys/unix"
43 CmdNameGoredo = "goredo"
45 CmdNameRedoAffects = "redo-affects"
46 CmdNameRedoAlways = "redo-always"
47 CmdNameRedoCleanup = "redo-cleanup"
48 CmdNameRedoDot = "redo-dot"
49 CmdNameRedoIfchange = "redo-ifchange"
50 CmdNameRedoIfcreate = "redo-ifcreate"
51 CmdNameRedoLog = "redo-log"
52 CmdNameRedoOOD = "redo-ood"
53 CmdNameRedoSources = "redo-sources"
54 CmdNameRedoStamp = "redo-stamp"
55 CmdNameRedoTargets = "redo-targets"
56 CmdNameRedoWhichdo = "redo-whichdo"
57 CmdNameRedoDepFix = "redo-depfix"
58 CmdNameRedoInode = "redo-inode"
64 IsTopRedo bool // is it the top redo instance
68 func mustSetenv(key string) {
69 if err := os.Setenv(key, "1"); err != nil {
74 func mustParseFd(v, name string) *os.File {
75 ptr, err := strconv.ParseUint(v, 10, 64)
79 fd := os.NewFile(uintptr(ptr), name)
81 panic("can not parse fd: " + name)
86 func CmdName() string {
87 return path.Base(os.Args[0])
91 version := flag.Bool("version", false, "print version")
92 warranty := flag.Bool("warranty", false, "print warranty information")
96 if cmdName == "goredo" {
97 symlinks = flag.Bool("symlinks", false, "create necessary symlinks in current directory")
100 flag.Usage = func() { usage(os.Args[0]) }
103 fmt.Println(Warranty)
107 fmt.Println("goredo", Version, "built with", runtime.Version())
110 if cmdName == CmdNameGoredo && *symlinks {
112 for _, cmdName := range []string{
129 fmt.Println(os.Args[0], "<-", cmdName)
130 if err := os.Symlink(os.Args[0], cmdName); err != nil {
137 log.SetFlags(log.Lshortfile)
139 UmaskCur = syscall.Umask(0)
140 syscall.Umask(UmaskCur)
143 Cwd, err = os.Getwd()
148 TopDir = os.Getenv(EnvTopDir)
152 TopDir = mustAbs(TopDir)
154 DirPrefix = os.Getenv(EnvDirPrefix)
155 DepCwd = os.Getenv(EnvDepCwd)
157 if flagStderrKeep != nil && *flagStderrKeep {
158 mustSetenv(EnvStderrKeep)
160 if flagStderrSilent != nil && *flagStderrSilent {
161 mustSetenv(EnvStderrSilent)
163 if flagNoProgress != nil && *flagNoProgress {
164 mustSetenv(EnvNoProgress)
166 if flagDebug != nil && *flagDebug {
169 if flagLogWait != nil && *flagLogWait {
170 mustSetenv(EnvLogWait)
172 if flagLogLock != nil && *flagLogLock {
173 mustSetenv(EnvLogLock)
175 if flagLogPid != nil && *flagLogPid {
176 mustSetenv(EnvLogPid)
178 if flagLogJS != nil && *flagLogJS {
181 StderrKeep = os.Getenv(EnvStderrKeep) == "1"
182 StderrSilent = os.Getenv(EnvStderrSilent) == "1"
183 NoProgress = os.Getenv(EnvNoProgress) == "1"
184 Debug = os.Getenv(EnvDebug) == "1"
185 LogWait = os.Getenv(EnvLogWait) == "1"
186 LogLock = os.Getenv(EnvLogLock) == "1"
187 LogJS = os.Getenv(EnvLogJS) == "1"
188 if Debug || os.Getenv(EnvLogPid) == "1" {
192 if flagTraceAll != nil && *flagTraceAll {
195 if os.Getenv(EnvTrace) == "1" {
198 } else if flagTrace != nil {
201 NoColor = os.Getenv(EnvNoColor) != ""
202 NoSync = os.Getenv(EnvNoSync) == "1"
203 StopIfMod = os.Getenv(EnvStopIfMod) == "1"
204 switch s := os.Getenv(EnvInodeTrust); s {
206 InodeTrust = InodeTrustNone
208 InodeTrust = InodeTrustCtime
210 InodeTrust = InodeTrustMtime
212 log.Fatalln("unknown", EnvInodeTrust, "value")
214 tracef(CDebug, "inode-trust: %s", InodeTrust)
216 // Those are internal envs
217 FdOODTgts, err = os.CreateTemp("", "ood-tgts")
221 if err = os.Remove(FdOODTgts.Name()); err != nil {
224 FdOODTgtsLock, err = os.CreateTemp("", "ood-tgts.lock")
228 if err = os.Remove(FdOODTgtsLock.Name()); err != nil {
233 if v := os.Getenv(EnvOODTgtsFd); v != "" {
234 fd := mustParseFd(v, EnvOODTgtsFd)
235 fdLock = mustParseFd(v, EnvOODTgtsLockFd)
237 flock := unix.Flock_t{
239 Whence: io.SeekStart,
241 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
244 if _, err = fd.Seek(0, io.SeekStart); err != nil {
247 tgtsRaw, err := io.ReadAll(bufio.NewReader(fd))
251 flock.Type = unix.F_UNLCK
252 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
255 OODTgts = map[string]struct{}{}
256 for _, tgtRaw := range bytes.Split(tgtsRaw, []byte{0}) {
261 OODTgts[t] = struct{}{}
262 tracef(CDebug, "ood: known to be: %s", t)
266 StderrPrefix = os.Getenv(EnvStderrPrefix)
267 if v := os.Getenv(EnvLevel); v != "" {
268 Level, err = strconv.Atoi(v)
273 panic("negative " + EnvLevel)
278 if v := os.Getenv(EnvDepFd); v != "" {
279 fdDep = mustParseFd(v, EnvDepFd)
283 BuildUUID = os.Getenv(EnvBuildUUID)
284 tgtsWasEmpty := len(tgts) == 0
288 if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
291 raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
292 BuildUUID = fmt.Sprintf(
294 raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
297 tgts = []string{"all"}
301 if cmdName == CmdNameRedo {
305 for i, tgt := range tgts {
307 tgts[i] = cwdMustRel(tgt)
311 killed := make(chan os.Signal, 1)
312 signal.Notify(killed, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
315 tracef(CDebug, "[%s] killed", BuildUUID)
318 for pid, proc := range RunningProcs {
319 tracef(CDebug, "[%s] killing child %d", BuildUUID, pid)
320 _ = proc.Signal(syscall.SIGTERM)
328 CDebug, "[%s] run: %s %s cwd:%s dirprefix:%s",
329 BuildUUID, cmdName, tgts, Cwd, DirPrefix,
335 for _, tgt := range tgts {
336 ok, err = ifchange([]string{tgt}, true, traced)
337 if err != nil || !ok {
341 case CmdNameRedoIfchange:
342 ok, err = ifchange(tgts, *flagForcedIfchange, traced)
344 err = depsWrite(fdDep, tgts)
346 case CmdNameRedoIfcreate:
348 log.Fatalln("no", EnvDepFd)
350 for _, tgt := range tgts {
351 tgtRel, err := filepath.Rel(
352 path.Join(Cwd, DirPrefix),
359 err = ifcreate(fdDep, tgtRel)
364 case CmdNameRedoAlways:
366 log.Fatalln("no", EnvDepFd)
369 case CmdNameRedoCleanup:
370 for _, what := range tgts {
371 err = cleanupWalker(Cwd, what)
378 case CmdNameRedoStamp:
380 log.Fatalln("no", EnvDepFd)
382 err = stamp(fdDep, os.Stdin)
385 log.Fatal("single target expected")
387 d, t := cwdAndTgt(tgts[0])
388 err = showBuildLog(d, t, nil, 0)
389 case CmdNameRedoWhichdo:
391 log.Fatal("single target expected")
394 fdTmp, err = os.CreateTemp("", "whichdo")
399 if err = os.Remove(fdTmp.Name()); err != nil {
403 cwd, tgt := cwdAndTgt(tgts[0])
404 doFile, upLevels, err := findDo(fdTmp, cwd, tgt)
409 _, err = fdTmp.Seek(0, io.SeekStart)
414 r := recfile.NewReader(fdTmp)
416 m, err := r.NextMap()
418 if errors.Is(err, io.EOF) {
424 fmt.Println(cwdMustRel(cwd, m["Target"]))
429 p := make([]string, 0, upLevels+2)
431 for i := 0; i < upLevels; i++ {
434 p = append(p, doFile)
435 rel := mustRel(Cwd, path.Join(p...))
438 case CmdNameRedoTargets:
442 tgts, err = targetsWalker(tgts)
448 for _, tgt := range tgts {
451 case CmdNameRedoAffects:
453 log.Fatal("no targets specified")
455 var tgtsKnown []string
456 tgtsKnown, err = targetsWalker([]string{Cwd})
461 deps := map[string]map[string]struct{}{}
462 for _, tgt := range tgtsKnown {
463 collectDeps(Cwd, tgt, 0, deps, true, map[string]struct{}{})
465 seen := map[string]struct{}{}
466 for _, tgt := range tgts {
467 collectWholeDeps(deps[tgt], deps, seen)
469 tgts := make([]string, 0, len(seen))
470 for dep := range seen {
471 tgts = append(tgts, dep)
474 for _, dep := range tgts {
479 tgts, err = targetsWalker([]string{Cwd})
486 for _, tgt := range tgts {
487 ood, err = isOOD(Cwd, tgt, 0, nil)
496 case CmdNameRedoSources:
498 tgts, err = targetsWalker([]string{Cwd})
505 seen := make(map[string]struct{})
506 seenDeps := make(map[string]struct{})
507 srcs := make(map[string]struct{})
508 err = ErrLine(sourcesWalker(tgts, seen, seenDeps, srcs))
515 res := make([]string, 0, len(srcs))
516 for p := range srcs {
521 for _, src := range res {
524 case CmdNameRedoDepFix:
526 case CmdNameRedoInode:
528 for _, tgt := range tgts {
529 inode, err = inodeFromFileByPath(tgt)
534 err = recfileWrite(os.Stdout, append(
535 []recfile.Field{{Name: "Target", Value: tgt}},
536 inode.RecfileFields()...)...)
543 log.Fatalln("unknown command", cmdName)
549 if !ok || err != nil {
552 tracef(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)