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/>.
37 "go.cypherpunks.ru/recfile"
38 "golang.org/x/sys/unix"
42 CmdNameGoredo = "goredo"
44 CmdNameRedoAffects = "redo-affects"
45 CmdNameRedoAlways = "redo-always"
46 CmdNameRedoCleanup = "redo-cleanup"
47 CmdNameRedoDepFix = "redo-depfix"
48 CmdNameRedoDot = "redo-dot"
49 CmdNameRedoIfchange = "redo-ifchange"
50 CmdNameRedoIfcreate = "redo-ifcreate"
51 CmdNameRedoInode = "redo-inode"
52 CmdNameRedoLog = "redo-log"
53 CmdNameRedoOOD = "redo-ood"
54 CmdNameRedoSources = "redo-sources"
55 CmdNameRedoStamp = "redo-stamp"
56 CmdNameRedoTargets = "redo-targets"
57 CmdNameRedoWhichdo = "redo-whichdo"
63 IsTopRedo bool // is it the top redo instance
67 func mustSetenv(key string) {
68 if err := os.Setenv(key, "1"); err != nil {
73 func mustParseFd(v, name string) *os.File {
74 ptr, err := strconv.ParseUint(v, 10, 64)
78 fd := os.NewFile(uintptr(ptr), name)
80 panic("can not parse fd: " + name)
85 func CmdName() string {
86 return path.Base(os.Args[0])
90 version := flag.Bool("version", false, "print version")
91 warranty := flag.Bool("warranty", false, "print warranty information")
95 if cmdName == "goredo" {
96 symlinks = flag.Bool("symlinks", false, "create necessary symlinks in current directory")
99 flag.Usage = func() { usage(os.Args[0]) }
102 fmt.Println(Warranty)
106 fmt.Println("goredo", Version, "built with", runtime.Version())
109 if cmdName == CmdNameGoredo && *symlinks {
111 for _, cmdName := range []string{
128 fmt.Println(os.Args[0], "<-", cmdName)
129 if err := os.Symlink(os.Args[0], cmdName); err != nil {
136 log.SetFlags(log.Lshortfile)
138 UmaskCur = syscall.Umask(0)
139 syscall.Umask(UmaskCur)
142 Cwd, err = os.Getwd()
147 TopDir = os.Getenv(EnvTopDir)
151 TopDir = mustAbs(TopDir)
153 DirPrefix = os.Getenv(EnvDirPrefix)
154 DepCwd = os.Getenv(EnvDepCwd)
156 if flagStderrKeep != nil && *flagStderrKeep {
157 mustSetenv(EnvStderrKeep)
159 if flagStderrSilent != nil && *flagStderrSilent {
160 mustSetenv(EnvStderrSilent)
162 if flagNoProgress != nil && *flagNoProgress {
163 mustSetenv(EnvNoProgress)
165 if flagDebug != nil && *flagDebug {
168 if flagLogWait != nil && *flagLogWait {
169 mustSetenv(EnvLogWait)
171 if flagLogLock != nil && *flagLogLock {
172 mustSetenv(EnvLogLock)
174 if flagLogPid != nil && *flagLogPid {
175 mustSetenv(EnvLogPid)
177 if flagLogJS != nil && *flagLogJS {
180 StderrKeep = os.Getenv(EnvStderrKeep) == "1"
181 StderrSilent = os.Getenv(EnvStderrSilent) == "1"
182 NoProgress = os.Getenv(EnvNoProgress) == "1"
183 Debug = os.Getenv(EnvDebug) == "1"
184 LogWait = os.Getenv(EnvLogWait) == "1"
185 LogLock = os.Getenv(EnvLogLock) == "1"
186 LogJS = os.Getenv(EnvLogJS) == "1"
187 if Debug || os.Getenv(EnvLogPid) == "1" {
191 if flagTraceAll != nil && *flagTraceAll {
194 if os.Getenv(EnvTrace) == "1" {
197 } else if flagTrace != nil {
200 NoColor = os.Getenv(EnvNoColor) != ""
201 NoSync = os.Getenv(EnvNoSync) == "1"
202 StopIfMod = os.Getenv(EnvStopIfMod) == "1"
203 switch s := os.Getenv(EnvInodeTrust); s {
205 InodeTrust = InodeTrustNone
207 InodeTrust = InodeTrustCtime
209 InodeTrust = InodeTrustMtime
211 log.Fatalln("unknown", EnvInodeTrust, "value")
214 // Those are internal envs
215 FdOODTgts, err = os.CreateTemp("", "ood-tgts")
219 if err = os.Remove(FdOODTgts.Name()); err != nil {
222 FdOODTgtsLock, err = os.CreateTemp("", "ood-tgts.lock")
226 if err = os.Remove(FdOODTgtsLock.Name()); err != nil {
231 if v := os.Getenv(EnvOODTgtsFd); v != "" {
232 fd := mustParseFd(v, EnvOODTgtsFd)
233 fdLock = mustParseFd(v, EnvOODTgtsLockFd)
235 flock := unix.Flock_t{
237 Whence: io.SeekStart,
239 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
242 if _, err = fd.Seek(0, io.SeekStart); err != nil {
245 tgtsRaw, err := io.ReadAll(bufio.NewReader(fd))
249 flock.Type = unix.F_UNLCK
250 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
253 OODTgts = make(map[string]struct{})
254 for _, tgtRaw := range bytes.Split(tgtsRaw, []byte{0}) {
259 OODTgts[t] = struct{}{}
260 tracef(CDebug, "ood: known to be: %s", t)
264 StderrPrefix = os.Getenv(EnvStderrPrefix)
265 if v := os.Getenv(EnvLevel); v != "" {
266 Level, err = strconv.Atoi(v)
271 panic("negative " + EnvLevel)
276 if v := os.Getenv(EnvDepFd); v != "" {
277 fdDep = mustParseFd(v, EnvDepFd)
280 tgts := make([]*Tgt, 0, len(flag.Args()))
281 for _, arg := range flag.Args() {
282 tgts = append(tgts, NewTgt(arg))
284 BuildUUID = os.Getenv(EnvBuildUUID)
285 tgtsWasEmpty := len(tgts) == 0
289 if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
292 raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
293 BuildUUID = fmt.Sprintf(
295 raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
298 tgts = append(tgts, NewTgt("all"))
300 tracef(CDebug, "inode-trust: %s", InodeTrust)
303 if cmdName == CmdNameRedo {
307 killed := make(chan os.Signal, 1)
308 signal.Notify(killed, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
311 tracef(CDebug, "[%s] killed", BuildUUID)
314 for pid, proc := range RunningProcs {
315 tracef(CDebug, "[%s] killing child %d", BuildUUID, pid)
316 _ = proc.Signal(syscall.SIGTERM)
324 CDebug, "[%s] run: %s %s cwd:%s dirprefix:%s",
325 BuildUUID, cmdName, tgts, Cwd, DirPrefix,
331 for _, tgt := range tgts {
332 ok, err = ifchange([]*Tgt{tgt}, true, traced)
333 if err != nil || !ok {
337 case CmdNameRedoIfchange:
338 ok, err = ifchange(tgts, *flagForcedIfchange, traced)
340 err = depsWrite(fdDep, tgts)
342 case CmdNameRedoIfcreate:
344 log.Fatalln("no", EnvDepFd)
346 for _, tgt := range tgts {
347 err = ifcreate(fdDep, tgt.RelTo(path.Join(Cwd, DirPrefix)))
352 case CmdNameRedoAlways:
354 log.Fatalln("no", EnvDepFd)
357 case CmdNameRedoCleanup:
358 for _, what := range tgts {
359 err = cleanupWalker(Cwd, what.t)
366 case CmdNameRedoStamp:
368 log.Fatalln("no", EnvDepFd)
370 err = stamp(fdDep, os.Stdin)
373 log.Fatal("single target expected")
375 err = showBuildLog(tgts[0], nil, 0)
376 case CmdNameRedoWhichdo:
378 log.Fatal("single target expected")
381 fdTmp, err = os.CreateTemp("", "whichdo")
386 err = ErrLine(os.Remove(fdTmp.Name()))
393 doFile, upLevels, err = findDo(fdTmp, tgt.h, tgt.t)
398 _, err = fdTmp.Seek(0, io.SeekStart)
403 r := recfile.NewReader(fdTmp)
405 m, err := r.NextMap()
407 if errors.Is(err, io.EOF) {
413 fmt.Println(cwdMustRel(tgt.h, m["Target"]))
418 p := make([]string, 0, upLevels+2)
420 for i := 0; i < upLevels; i++ {
423 p = append(p, doFile)
424 rel := mustRel(Cwd, path.Join(p...))
427 case CmdNameRedoTargets:
428 raws := make([]string, 0, len(tgts))
429 for _, tgt := range tgts {
430 raws = append(raws, tgt.rel)
435 raws, err = targetsWalker(raws)
441 for _, tgt := range raws {
444 case CmdNameRedoAffects:
446 log.Fatal("no targets specified")
450 var tgtsKnown []string
451 tgtsKnown, err = targetsWalker([]string{Cwd})
456 deps := make(map[string]map[string]*Tgt)
457 for _, tgt := range tgtsKnown {
458 collectDeps(NewTgt(tgt), 0, deps, true, make(map[string]struct{}))
460 seen := make(map[string]*Tgt)
461 for _, tgt := range tgts {
462 collectWholeDeps(deps[tgt.rel], deps, seen)
464 res = make([]string, 0, len(seen))
465 for _, dep := range seen {
466 res = append(res, dep.rel)
470 for _, dep := range res {
474 raws := make([]string, 0, len(tgts))
475 for _, tgt := range tgts {
476 raws = append(raws, tgt.rel)
479 raws, err = targetsWalker([]string{Cwd})
486 for _, tgt := range raws {
487 ood, err = isOOD(NewTgt(tgt), 0, nil)
496 case CmdNameRedoSources:
497 srcs := make(map[string]*Tgt)
499 raws := make([]string, 0, len(tgts))
500 for _, tgt := range tgts {
501 raws = append(raws, tgt.rel)
504 raws, err = targetsWalker([]string{Cwd})
512 for _, raw := range raws {
513 tgts = append(tgts, NewTgt(raw))
515 seen := make(map[string]struct{})
516 seenDeps := make(map[string]struct{})
517 err = ErrLine(sourcesWalker(tgts, seen, seenDeps, srcs))
522 res := make([]string, 0, len(srcs))
523 for _, tgt := range srcs {
524 res = append(res, tgt.rel)
528 for _, src := range res {
531 case CmdNameRedoDepFix:
533 case CmdNameRedoInode:
535 for _, tgt := range tgts {
536 inode, err = inodeFromFileByPath(tgt.a)
541 err = recfileWrite(os.Stdout, append(
542 []recfile.Field{{Name: "Target", Value: tgt.String()}},
543 inode.RecfileFields()...)...)
550 log.Fatalln("unknown command", cmdName)
556 if !ok || err != nil {
559 tracef(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)