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 "github.com/google/uuid"
39 "go.cypherpunks.ru/recfile"
40 "golang.org/x/sys/unix"
44 CmdNameGoredo = "goredo"
46 CmdNameRedoAffects = "redo-affects"
47 CmdNameRedoAlways = "redo-always"
48 CmdNameRedoCleanup = "redo-cleanup"
49 CmdNameRedoDep2Rec = "redo-dep2rec"
50 CmdNameRedoDepFix = "redo-depfix"
51 CmdNameRedoDot = "redo-dot"
52 CmdNameRedoIfchange = "redo-ifchange"
53 CmdNameRedoIfcreate = "redo-ifcreate"
54 CmdNameRedoInode = "redo-inode"
55 CmdNameRedoLog = "redo-log"
56 CmdNameRedoOOD = "redo-ood"
57 CmdNameRedoSources = "redo-sources"
58 CmdNameRedoStamp = "redo-stamp"
59 CmdNameRedoTargets = "redo-targets"
60 CmdNameRedoWhichdo = "redo-whichdo"
66 IsTopRedo bool // is it the top redo instance
70 func mustSetenv(key string) {
71 if err := os.Setenv(key, "1"); err != nil {
76 func mustParseFd(v, name string) *os.File {
77 ptr, err := strconv.ParseUint(v, 10, 64)
81 fd := os.NewFile(uintptr(ptr), name)
83 panic("can not parse fd: " + name)
88 func CmdName() string {
89 return path.Base(os.Args[0])
93 version := flag.Bool("version", false, "print version")
94 warranty := flag.Bool("warranty", false, "print warranty information")
98 if cmdName == "goredo" {
99 symlinks = flag.Bool("symlinks", false, "create necessary symlinks in current directory")
102 flag.Usage = func() { usage(os.Args[0]) }
104 BuildUUIDStr := os.Getenv(EnvBuildUUID)
105 IsTopRedo = BuildUUIDStr == ""
116 fmt.Println(Warranty)
120 fmt.Println("goredo", Version, "built with", runtime.Version())
123 if cmdName == CmdNameGoredo && *symlinks {
125 for _, cmdName := range []string{
143 fmt.Println(os.Args[0], "<-", cmdName)
144 if err := os.Symlink(os.Args[0], cmdName); err != nil {
151 log.SetFlags(log.Lshortfile)
153 UmaskCur = syscall.Umask(0)
154 syscall.Umask(UmaskCur)
157 Cwd, err = os.Getwd()
162 TopDir = os.Getenv(EnvTopDir)
166 TopDir = mustAbs(TopDir)
168 DirPrefix = os.Getenv(EnvDirPrefix)
169 DepCwd = os.Getenv(EnvDepCwd)
171 if flagStderrKeep != nil && *flagStderrKeep {
172 mustSetenv(EnvStderrKeep)
174 if flagStderrSilent != nil && *flagStderrSilent {
175 mustSetenv(EnvStderrSilent)
177 if flagNoProgress != nil && *flagNoProgress {
178 mustSetenv(EnvNoProgress)
180 if flagDebug != nil && *flagDebug {
183 if flagLogWait != nil && *flagLogWait {
184 mustSetenv(EnvLogWait)
186 if flagLogLock != nil && *flagLogLock {
187 mustSetenv(EnvLogLock)
189 if flagLogPid != nil && *flagLogPid {
190 mustSetenv(EnvLogPid)
192 if flagLogJS != nil && *flagLogJS {
195 StderrKeep = os.Getenv(EnvStderrKeep) == "1"
196 StderrSilent = os.Getenv(EnvStderrSilent) == "1"
197 NoProgress = os.Getenv(EnvNoProgress) == "1"
198 Debug = os.Getenv(EnvDebug) == "1"
199 LogWait = os.Getenv(EnvLogWait) == "1"
200 LogLock = os.Getenv(EnvLogLock) == "1"
201 LogJS = os.Getenv(EnvLogJS) == "1"
202 if Debug || os.Getenv(EnvLogPid) == "1" {
206 if flagTraceAll != nil && *flagTraceAll {
209 if os.Getenv(EnvTrace) == "1" {
212 } else if flagTrace != nil {
215 NoColor = os.Getenv(EnvNoColor) != ""
216 NoSync = os.Getenv(EnvNoSync) == "1"
217 StopIfMod = os.Getenv(EnvStopIfMod) == "1"
218 switch s := os.Getenv(EnvInodeTrust); s {
220 InodeTrust = InodeTrustNone
222 InodeTrust = InodeTrustCtime
224 InodeTrust = InodeTrustMtime
226 log.Fatalln("unknown", EnvInodeTrust, "value")
229 // Those are internal envs
230 FdOODTgts, err = os.CreateTemp("", "ood-tgts")
234 if err = os.Remove(FdOODTgts.Name()); err != nil {
237 FdOODTgtsLock, err = os.CreateTemp("", "ood-tgts.lock")
241 if err = os.Remove(FdOODTgtsLock.Name()); err != nil {
246 if v := os.Getenv(EnvOODTgtsFd); v != "" {
247 fd := mustParseFd(v, EnvOODTgtsFd)
248 fdLock = mustParseFd(v, EnvOODTgtsLockFd)
250 flock := unix.Flock_t{
252 Whence: io.SeekStart,
254 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
257 if _, err = fd.Seek(0, io.SeekStart); err != nil {
260 tgtsRaw, err := io.ReadAll(bufio.NewReader(fd))
264 flock.Type = unix.F_UNLCK
265 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
268 OODTgts = make(map[string]struct{})
269 for _, tgtRaw := range bytes.Split(tgtsRaw, []byte{0}) {
274 OODTgts[t] = struct{}{}
275 tracef(CDebug, "ood: known to be: %s", t)
279 StderrPrefix = os.Getenv(EnvStderrPrefix)
280 if v := os.Getenv(EnvLevel); v != "" {
281 Level, err = strconv.Atoi(v)
286 panic("negative " + EnvLevel)
291 if v := os.Getenv(EnvDepFd); v != "" {
292 fdDep = mustParseFd(v, EnvDepFd)
295 tgts := make([]*Tgt, 0, len(args))
296 for _, arg := range args {
297 tgts = append(tgts, NewTgt(arg))
299 tgtsWasEmpty := len(tgts) == 0
300 if BuildUUIDStr == "" {
301 BuildUUID = uuid.New()
303 tgts = append(tgts, NewTgt("all"))
305 tracef(CDebug, "inode-trust: %s", InodeTrust)
307 BuildUUID, err = uuid.Parse(BuildUUIDStr)
313 if cmdName == CmdNameRedo {
317 killed := make(chan os.Signal, 1)
318 signal.Notify(killed, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
321 tracef(CDebug, "[%s] killed", BuildUUID)
324 for pid, proc := range RunningProcs {
325 tracef(CDebug, "[%s] killing child %d", BuildUUID, pid)
326 _ = proc.Signal(syscall.SIGTERM)
333 tracef(CDebug, "[%s] run: %s %s cwd:%s dirprefix:%s",
334 BuildUUID, cmdName, tgts, Cwd, DirPrefix)
338 for _, tgt := range tgts {
339 ok, err = ifchange([]*Tgt{tgt}, true, traced)
340 if err != nil || !ok {
344 case CmdNameRedoIfchange:
345 ok, err = ifchange(tgts, *flagForcedIfchange, traced)
347 err = depsWrite(fdDep, tgts)
349 case CmdNameRedoIfcreate:
351 log.Fatalln("no", EnvDepFd)
353 fdDepW := bufio.NewWriter(fdDep)
354 for _, tgt := range tgts {
355 err = ifcreate(fdDepW, fdDep.Name(), tgt.RelTo(path.Join(Cwd, DirPrefix)))
361 case CmdNameRedoAlways:
363 log.Fatalln("no", EnvDepFd)
365 err = always(fdDep, fdDep.Name())
366 case CmdNameRedoCleanup:
367 for _, what := range tgts {
368 err = cleanupWalker(Cwd, path.Base(what.a))
375 case CmdNameRedoStamp:
377 log.Fatalln("no", EnvDepFd)
380 hsh, err = fileHash(os.Stdin)
384 err = stamp(fdDep, fdDep.Name(), hsh)
387 log.Fatal("single target expected")
389 err = showBuildLog(tgts[0], nil, 0)
390 case CmdNameRedoWhichdo:
392 log.Fatal("single target expected")
395 dos, err = whichdo(tgts[0])
397 if errors.Is(err, fs.ErrNotExist) {
404 for _, do := range dos {
407 case CmdNameRedoTargets:
408 raws := make([]string, 0, len(tgts))
409 for _, tgt := range tgts {
410 raws = append(raws, tgt.rel)
415 raws, err = targetsWalker(raws)
421 for _, tgt := range raws {
424 case CmdNameRedoAffects:
426 log.Fatal("no targets specified")
430 var tgtsKnown []string
431 tgtsKnown, err = targetsWalker([]string{Cwd})
436 deps := make(map[string]map[string]*Tgt)
437 for _, tgt := range tgtsKnown {
438 collectDeps(NewTgt(tgt), 0, deps, true)
440 seen := make(map[string]*Tgt)
441 for _, tgt := range tgts {
442 collectWholeDeps(deps[tgt.rel], deps, seen)
444 res = make([]string, 0, len(seen))
445 for _, dep := range seen {
446 res = append(res, dep.rel)
450 for _, dep := range res {
454 raws := make([]string, 0, len(tgts))
455 for _, tgt := range tgts {
456 raws = append(raws, tgt.rel)
459 raws, err = targetsWalker([]string{Cwd})
466 for _, tgt := range raws {
467 ood, err = isOOD(NewTgt(tgt), 0, nil)
476 case CmdNameRedoSources:
477 srcs := make(map[string]*Tgt)
479 raws := make([]string, 0, len(tgts))
480 for _, tgt := range tgts {
481 raws = append(raws, tgt.rel)
484 raws, err = targetsWalker([]string{Cwd})
492 for _, raw := range raws {
493 tgts = append(tgts, NewTgt(raw))
495 seen := make(map[string]struct{})
496 seenDeps := make(map[string]struct{})
497 err = ErrLine(sourcesWalker(tgts, seen, seenDeps, srcs))
502 res := make([]string, 0, len(srcs))
503 for _, tgt := range srcs {
504 res = append(res, tgt.rel)
508 for _, src := range res {
511 case CmdNameRedoDepFix:
513 DepFixHashCache = make(map[string]Hash)
515 case CmdNameRedoInode:
517 for _, tgt := range tgts {
518 inode, err = inodeFromFileByPath(tgt.a)
523 err = recfileWrite(os.Stdout, append(
524 []recfile.Field{{Name: "Target", Value: tgt.String()}},
525 inode.RecfileFields()...)...)
531 case CmdNameRedoDep2Rec:
533 data, err = os.ReadFile(tgts[0].a)
538 build, data, err = depHeadParse(data)
542 w := bufio.NewWriter(os.Stdout)
543 err = recfileWrite(w, []recfile.Field{
544 {Name: "Build", Value: build.String()},
553 typ, chunk, data, _ = chunkRead(data)
556 err = recfileWrite(w, []recfile.Field{
557 {Name: "Type", Value: "always"},
560 err = recfileWrite(w, []recfile.Field{
561 {Name: "Type", Value: "stamp"},
562 {Name: "Hash", Value: hex.EncodeToString(chunk)},
564 case DepTypeIfcreate:
565 err = recfileWrite(w, []recfile.Field{
566 {Name: "Type", Value: "ifcreate"},
567 {Name: "Target", Value: string(chunk)},
569 case DepTypeIfchange:
570 name := string(chunk[InodeLen+HashLen:])
571 meta := chunk[:InodeLen+HashLen]
572 fields := []recfile.Field{
573 {Name: "Type", Value: "ifchange"},
574 {Name: "Target", Value: name},
576 fields = append(fields, recfile.Field{
577 Name: "Hash", Value: Hash(meta[InodeLen:]).String(),
579 inode = Inode(meta[:][:InodeLen])
580 fields = append(fields, inode.RecfileFields()...)
581 err = recfileWrite(w, fields...)
582 case DepTypeIfchangeNonex:
583 err = recfileWrite(w, []recfile.Field{
584 {Name: "Type", Value: "ifchange"},
585 {Name: "Target", Value: string(chunk)},
594 log.Fatalln("unknown command", cmdName)
600 if !ok || err != nil {
603 tracef(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)