1 // goredo -- djb's redo implementation on pure Go
2 // Copyright (C) 2020-2024 Sergey Matveev <stargrave@stargrave.org>
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, version 3 of the License.
8 // This program is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 // GNU General Public License for more details.
13 // You should have received a copy of the GNU General Public License
14 // along with this program. If not, see <http://www.gnu.org/licenses/>.
36 "github.com/google/uuid"
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 CmdNameRedoDep2Rec = "redo-dep2rec"
48 CmdNameRedoDepFix = "redo-depfix"
49 CmdNameRedoDot = "redo-dot"
50 CmdNameRedoIfchange = "redo-ifchange"
51 CmdNameRedoIfcreate = "redo-ifcreate"
52 CmdNameRedoInode = "redo-inode"
53 CmdNameRedoLog = "redo-log"
54 CmdNameRedoOOD = "redo-ood"
55 CmdNameRedoSources = "redo-sources"
56 CmdNameRedoStamp = "redo-stamp"
57 CmdNameRedoTargets = "redo-targets"
58 CmdNameRedoWhichdo = "redo-whichdo"
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 == CmdNameGoredo {
97 symlinks = flag.Bool("symlinks", false, "create necessary symlinks in current directory")
100 flag.Usage = func() { usage(os.Args[0]) }
102 BuildUUIDStr := os.Getenv(EnvBuildUUID)
103 IsTopRedo = BuildUUIDStr == ""
114 fmt.Println(Warranty)
118 fmt.Println("goredo", Version, "built with", runtime.Version())
121 if cmdName == CmdNameGoredo && *symlinks {
123 for _, cmdName := range []string{
141 fmt.Println(os.Args[0], "<-", cmdName)
142 if err := os.Symlink(os.Args[0], cmdName); err != nil {
149 log.SetFlags(log.Lshortfile)
151 UmaskCur = syscall.Umask(0)
152 syscall.Umask(UmaskCur)
155 Cwd, err = os.Getwd()
160 TopDir = os.Getenv(EnvTopDir)
164 TopDir = mustAbs(TopDir)
166 DirPrefix = os.Getenv(EnvDirPrefix)
167 DepCwd = os.Getenv(EnvDepCwd)
169 if flagStderrKeep != nil && *flagStderrKeep {
170 mustSetenv(EnvStderrKeep)
172 if flagStderrSilent != nil && *flagStderrSilent {
173 mustSetenv(EnvStderrSilent)
175 if flagNoProgress != nil && *flagNoProgress {
176 mustSetenv(EnvNoProgress)
178 if flagDebug != nil && *flagDebug {
181 if flagLogWait != nil && *flagLogWait {
182 mustSetenv(EnvLogWait)
184 if flagLogLock != nil && *flagLogLock {
185 mustSetenv(EnvLogLock)
187 if flagLogPid != nil && *flagLogPid {
188 mustSetenv(EnvLogPid)
190 if flagLogJS != nil && *flagLogJS {
193 StderrKeep = os.Getenv(EnvStderrKeep) == "1"
194 StderrSilent = os.Getenv(EnvStderrSilent) == "1"
195 NoProgress = os.Getenv(EnvNoProgress) == "1"
196 Debug = os.Getenv(EnvDebug) == "1"
197 LogWait = os.Getenv(EnvLogWait) == "1"
198 LogLock = os.Getenv(EnvLogLock) == "1"
199 LogJS = os.Getenv(EnvLogJS) == "1"
200 if Debug || os.Getenv(EnvLogPid) == "1" {
204 if flagTraceAll != nil && *flagTraceAll {
207 if os.Getenv(EnvTrace) == "1" {
210 } else if flagTrace != nil {
213 NoColor = os.Getenv(EnvNoColor) != ""
214 NoSync = os.Getenv(EnvNoSync) == "1"
215 StopIfMod = os.Getenv(EnvStopIfMod) == "1"
216 switch s := os.Getenv(EnvInodeTrust); s {
218 InodeTrust = InodeTrustNone
220 InodeTrust = InodeTrustCtime
222 InodeTrust = InodeTrustMtime
224 log.Fatalln("unknown", EnvInodeTrust, "value")
227 // Those are internal envs
228 FdOODTgts, err = os.CreateTemp("", "ood-tgts")
232 if err = os.Remove(FdOODTgts.Name()); err != nil {
235 FdOODTgtsLock, err = os.CreateTemp("", "ood-tgts.lock")
239 if err = os.Remove(FdOODTgtsLock.Name()); err != nil {
244 if v := os.Getenv(EnvOODTgtsFd); v != "" {
245 fd := mustParseFd(v, EnvOODTgtsFd)
246 fdLock = mustParseFd(v, EnvOODTgtsLockFd)
248 flock := unix.Flock_t{
250 Whence: io.SeekStart,
252 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
255 if _, err = fd.Seek(0, io.SeekStart); err != nil {
258 tgtsRaw, err := io.ReadAll(bufio.NewReader(fd))
262 flock.Type = unix.F_UNLCK
263 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
266 OODTgts = make(map[string]struct{})
267 for _, tgtRaw := range bytes.Split(tgtsRaw, []byte{0}) {
272 OODTgts[t] = struct{}{}
273 tracef(CDebug, "ood: known to be: %s", t)
277 StderrPrefix = os.Getenv(EnvStderrPrefix)
278 if v := os.Getenv(EnvLevel); v != "" {
279 Level, err = strconv.Atoi(v)
284 panic("negative " + EnvLevel)
289 if v := os.Getenv(EnvDepFd); v != "" {
290 fdDep = mustParseFd(v, EnvDepFd)
293 tgts := make([]*Tgt, 0, len(args))
294 for _, arg := range args {
295 tgts = append(tgts, NewTgt(arg))
297 tgtsWasEmpty := len(tgts) == 0
298 if BuildUUIDStr == "" {
299 BuildUUID = uuid.New()
301 tgts = append(tgts, NewTgt("all"))
303 tracef(CDebug, "inode-trust: %s", InodeTrust)
305 BuildUUID, err = uuid.Parse(BuildUUIDStr)
311 if cmdName == CmdNameRedo {
315 killed := make(chan os.Signal, 1)
316 signal.Notify(killed, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
319 tracef(CDebug, "[%s] killed", BuildUUID)
322 for pid, proc := range RunningProcs {
323 tracef(CDebug, "[%s] killing child %d", BuildUUID, pid)
324 _ = proc.Signal(syscall.SIGTERM)
331 tracef(CDebug, "[%s] run: %s %s cwd:%s dirprefix:%s",
332 BuildUUID, cmdName, tgts, Cwd, DirPrefix)
336 for _, tgt := range tgts {
337 ok, err = ifchange([]*Tgt{tgt}, true, traced)
338 if err != nil || !ok {
342 case CmdNameRedoIfchange:
343 ok, err = ifchange(tgts, *flagForcedIfchange, traced)
345 err = depsWrite(fdDep, tgts)
347 case CmdNameRedoIfcreate:
349 log.Fatalln("no", EnvDepFd)
351 fdDepW := bufio.NewWriter(fdDep)
352 for _, tgt := range tgts {
353 err = ifcreate(fdDepW, fdDep.Name(), tgt.RelTo(path.Join(Cwd, DirPrefix)))
359 case CmdNameRedoAlways:
361 log.Fatalln("no", EnvDepFd)
363 err = always(fdDep, fdDep.Name())
364 case CmdNameRedoCleanup:
365 for _, what := range tgts {
366 err = cleanupWalker(Cwd, path.Base(what.a))
373 case CmdNameRedoStamp:
375 log.Fatalln("no", EnvDepFd)
378 hsh, err = fileHash(os.Stdin)
382 err = stamp(fdDep, fdDep.Name(), hsh)
385 log.Fatal("single target expected")
387 err = showBuildLog(tgts[0], nil, 0)
388 case CmdNameRedoWhichdo:
390 log.Fatal("single target expected")
393 dos, err = whichdo(tgts[0])
395 if errors.Is(err, fs.ErrNotExist) {
402 for _, do := range dos {
405 case CmdNameRedoTargets:
406 raws := make([]string, 0, len(tgts))
407 for _, tgt := range tgts {
408 raws = append(raws, tgt.rel)
413 raws, err = targetsWalker(raws)
419 for _, tgt := range raws {
422 case CmdNameRedoAffects:
424 log.Fatal("no targets specified")
428 var tgtsKnown []string
429 tgtsKnown, err = targetsWalker([]string{Cwd})
434 deps := make(map[string]map[string]*Tgt)
435 for _, tgt := range tgtsKnown {
436 collectDeps(NewTgt(tgt), 0, deps, true)
438 seen := make(map[string]*Tgt)
439 for _, tgt := range tgts {
440 collectWholeDeps(deps[tgt.rel], deps, seen)
442 res = make([]string, 0, len(seen))
443 for _, dep := range seen {
444 res = append(res, dep.rel)
448 for _, dep := range res {
452 raws := make([]string, 0, len(tgts))
453 for _, tgt := range tgts {
454 raws = append(raws, tgt.rel)
457 raws, err = targetsWalker([]string{Cwd})
464 for _, tgt := range raws {
465 ood, err = isOOD(NewTgt(tgt), 0, nil)
474 case CmdNameRedoSources:
475 srcs := make(map[string]*Tgt)
477 raws := make([]string, 0, len(tgts))
478 for _, tgt := range tgts {
479 raws = append(raws, tgt.rel)
482 raws, err = targetsWalker([]string{Cwd})
490 for _, raw := range raws {
491 tgts = append(tgts, NewTgt(raw))
493 seen := make(map[string]struct{})
494 seenDeps := make(map[string]struct{})
495 err = ErrLine(sourcesWalker(tgts, seen, seenDeps, srcs))
500 res := make([]string, 0, len(srcs))
501 for _, tgt := range srcs {
502 res = append(res, tgt.rel)
506 for _, src := range res {
509 case CmdNameRedoDepFix:
511 DepFixHashCache = make(map[string]Hash)
513 case CmdNameRedoInode:
515 for _, tgt := range tgts {
516 inode, err = inodeFromFileByPath(tgt.a)
521 err = recfileWrite(os.Stdout, append(
522 []recfile.Field{{Name: "Target", Value: tgt.String()}},
523 inode.RecfileFields()...)...)
529 case CmdNameRedoDep2Rec:
531 data, err = os.ReadFile(tgts[0].a)
536 build, data, err = depHeadParse(data)
540 w := bufio.NewWriter(os.Stdout)
541 err = recfileWrite(w, []recfile.Field{
542 {Name: "Build", Value: build.String()},
551 typ, chunk, data, _ = chunkRead(data)
554 err = recfileWrite(w, []recfile.Field{
555 {Name: "Type", Value: "always"},
558 err = recfileWrite(w, []recfile.Field{
559 {Name: "Type", Value: "stamp"},
560 {Name: "Hash", Value: hex.EncodeToString(chunk)},
562 case DepTypeIfcreate:
563 err = recfileWrite(w, []recfile.Field{
564 {Name: "Type", Value: "ifcreate"},
565 {Name: "Target", Value: string(chunk)},
567 case DepTypeIfchange:
568 name := string(chunk[InodeLen+HashLen:])
569 meta := chunk[:InodeLen+HashLen]
570 fields := []recfile.Field{
571 {Name: "Type", Value: "ifchange"},
572 {Name: "Target", Value: name},
574 fields = append(fields, recfile.Field{
575 Name: "Hash", Value: Hash(meta[InodeLen:]).String(),
577 inode = Inode(meta[:][:InodeLen])
578 fields = append(fields, inode.RecfileFields()...)
579 err = recfileWrite(w, fields...)
580 case DepTypeIfchangeNonex:
581 err = recfileWrite(w, []recfile.Field{
582 {Name: "Type", Value: "ifchange"},
583 {Name: "Target", Value: string(chunk)},
592 log.Fatalln("unknown command", cmdName)
598 if !ok || err != nil {
601 tracef(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)