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/>.
42 "go.cypherpunks.ru/recfile"
43 "go.cypherpunks.ru/tai64n/v2"
44 "golang.org/x/sys/unix"
48 EnvDepFd = "REDO_DEP_FD"
49 EnvDirPrefix = "REDO_DIRPREFIX"
50 EnvDepCwd = "REDO_DEP_CWD"
51 EnvBuildUUID = "REDO_BUILD_UUID"
52 EnvStderrPrefix = "REDO_STDERR_PREFIX"
53 EnvTrace = "REDO_TRACE"
54 EnvStderrKeep = "REDO_LOGS"
55 EnvStderrSilent = "REDO_SILENT"
56 EnvNoSync = "REDO_NO_SYNC"
57 EnvStopIfMod = "REDO_STOP_IF_MODIFIED"
64 LogRecSuffix = ".log-rec"
78 flagStderrSilent *bool
79 flagForcedIfchange *bool
83 RunningProcs = map[int]*os.Process{}
84 RunningProcsM sync.Mutex
86 Err1WasTouched = errors.New("$1 was explicitly touched")
91 if !(cmdName == CmdNameRedo || cmdName == CmdNameRedoIfchange) {
94 flagTrace = flag.Bool("x", false, "trace (sh -x) current targets")
95 flagTraceAll = flag.Bool("xx", false,
96 fmt.Sprintf("trace (sh -x) all targets (%s=1)", EnvTrace))
97 flagStderrKeep = flag.Bool("k", false,
98 fmt.Sprintf("keep job's stderr (%s=1)", EnvStderrKeep))
99 flagStderrSilent = flag.Bool("s", false,
100 fmt.Sprintf("silent, do not print job's stderr (%s=1)", EnvStderrSilent))
101 flagForcedIfchange = flag.Bool("f", false, "forced redo-ifchange")
104 type RunError struct {
112 func (e *RunError) Name() string {
115 name = e.Tgt.String()
117 name = fmt.Sprintf("%s (%s)", e.Tgt, e.DoFile)
119 if e.Finished == nil {
122 return fmt.Sprintf("%s (%.3fs)", name, e.Finished.Sub(*e.Started).Seconds())
125 func (e RunError) Error() string {
126 return fmt.Sprintf("%s: %s", e.Name(), e.Err)
129 func mkdirs(pth string) error {
133 return os.MkdirAll(pth, os.FileMode(0777))
136 func isModified(depInfo *DepInfo, tgt *Tgt) (
137 modified bool, ourInode *Inode, hshPrev []byte, err error,
142 for _, dep := range depInfo.ifchanges {
143 if dep.tgt.a != tgt.a {
146 ourInode, err = inodeFromFileByPath(tgt.a)
148 if os.IsNotExist(err) {
156 modified = !ourInode.Equals(dep.inode)
162 func syncDir(dir string) error {
163 fd, err := os.Open(dir)
172 func runScript(tgt *Tgt, errs chan error, forced, traced bool) error {
173 redoDir := path.Join(tgt.h, RedoDir)
174 if err := mkdirs(redoDir); err != nil {
175 return TgtError{tgt, ErrLine(err)}
178 shCtx := fmt.Sprintf("sh: %s: cwd:%s", tgt, tgt.h)
179 jsToken := jsAcquire(shCtx)
180 jsNeedsRelease := true
183 jsRelease(shCtx, jsToken)
188 fdLock, err := os.OpenFile(
189 path.Join(redoDir, tgt.t+LockSuffix),
190 os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
194 return TgtError{tgt, ErrLine(err)}
196 flock := unix.Flock_t{
198 Whence: io.SeekStart,
200 lockRelease := func() {
201 tracef(CLock, "LOCK_UN: %s", fdLock.Name())
202 flock.Type = unix.F_UNLCK
203 if err := unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
204 log.Fatalln(err, fdLock.Name())
208 tracef(CLock, "LOCK_NB: %s", fdLock.Name())
210 // Waiting for job completion, already taken by someone else
211 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
212 if uintptr(err.(syscall.Errno)) != uintptr(unix.EAGAIN) {
214 return TgtError{tgt, ErrLine(err)}
217 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_GETLK, &flock); err != nil {
218 log.Fatalln(err, fdLock.Name())
220 tracef(CDebug, "waiting: %s (pid=%d)", tgt, flock.Pid)
222 if _, err = FdStatus.Write([]byte{StatusWait}); err != nil {
228 tracef(CLock, "LOCK_EX: %s", fdLock.Name())
230 if err := unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
231 if errors.Is(err, unix.EDEADLK) {
232 time.Sleep(10 * time.Millisecond)
235 log.Fatalln(err, fdLock.Name())
238 tracef(CDebug, "waiting done: %s", tgt)
240 if _, err = FdStatus.Write([]byte{StatusWaited}); err != nil {
244 build, err := depReadBuild(tgt.Dep())
246 if build != BuildUUID {
247 err = errors.New("was not built: build differs")
250 if errors.Is(err, fs.ErrNotExist) {
251 err = errors.New("was not built: no .rec")
255 err = TgtError{tgt, err}
262 // It scans the whole .rec file while searching for the single target,
263 // but that one is always located at the very end
264 depInfo, err := depRead(tgt)
266 if errors.Is(err, fs.ErrNotExist) {
270 return TgtError{tgt, ErrLine(err)}
274 // Check if it was already built in parallel
275 if !forced && depInfo != nil && depInfo.build == BuildUUID {
281 // Check if target is not modified externally
282 modified, inodePrev, hshPrev, err := isModified(depInfo, tgt)
285 return TgtError{tgt, ErrLine(err)}
290 return fmt.Errorf("%s externally modified", tgt)
292 tracef(CWarn, "%s externally modified: not redoing", tgt)
300 // Start preparing .rec
301 fdDep, err := tempfile(redoDir, tgt.t+DepSuffix)
304 return TgtError{tgt, ErrLine(err)}
314 os.Remove(fdDep.Name())
317 if _, err = recfile.NewWriter(fdDep).WriteFields(
318 recfile.Field{Name: "Build", Value: BuildUUID},
321 return TgtError{tgt, ErrLine(err)}
328 runErr := RunError{Tgt: tgt}
329 // Determine basename and DIRPREFIX
331 doFileRelPath, upLevels, err := findDo(fdDep, tgt.h, tgt.t)
334 return TgtError{tgt, ErrLine(err)}
336 if doFileRelPath == "" {
338 return TgtError{tgt, errors.New("no .do found")}
340 // ents := strings.Split(strings.TrimSuffix(tgt.h, "/"), "/")
341 ents := strings.Split(tgt.h, "/")
342 ents = ents[len(ents)-upLevels:]
343 dirPrefix = path.Join(ents...)
344 ups := make([]string, 0, upLevels+2)
345 ups = append(ups, tgt.h)
346 for i := 0; i < upLevels; i++ {
347 ups = append(ups, "..")
349 ups = append(ups, doFileRelPath)
350 cwd = path.Clean(path.Join(ups[:len(ups)-1]...))
351 doFile = NewTgt(path.Join(ups...))
352 if strings.HasPrefix(doFile.t, "default.") {
353 basename = basename[:len(basename)-(len(doFile.t)-len("default.")-len(".do"))-1]
354 runErr.DoFile = doFile.String()
358 if err = depWrite(fdDep, tgt.h, doFile, nil); err != nil {
360 return TgtError{tgt, ErrLine(err)}
364 tracef(CWait, "%s", runErr.Name())
366 // Prepare command line
369 if err = unix.Access(doFile.String(), unix.X_OK); err == nil {
371 args = make([]string, 0, 3)
374 if traced || TracedAll {
375 args = append(args, "-ex")
377 args = append(args, "-e")
379 args = append(args, doFile.t)
382 // Temporary file for stdout
383 fdStdout, err := tempfile(tgt.h, tgt.t)
386 return TgtError{tgt, ErrLine(err)}
389 tmpPath := fdStdout.Name() + ".3" // and for $3
390 tmpPathRel := mustRel(cwd, tmpPath)
393 path.Join(dirPrefix, tgt.t),
394 path.Join(dirPrefix, basename),
398 "sh: %s: %s %s cwd:%s dirprefix:%s",
399 tgt, cmdName, args, cwd, dirPrefix,
402 cmd := exec.Command(cmdName, args...)
404 // cmd.Stdin reads from /dev/null by default
405 cmd.Env = append(os.Environ(), fmt.Sprintf("%s=%d", EnvLevel, Level+1))
406 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDirPrefix, dirPrefix))
407 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvBuildUUID, BuildUUID))
409 childStderrPrefixRaw := make([]byte, 8)
410 if _, err = io.ReadFull(rand.Reader, childStderrPrefixRaw); err != nil {
413 childStderrPrefix := hex.EncodeToString(childStderrPrefixRaw)
414 cmd.Env = append(cmd.Env, fmt.Sprintf(
415 "%s=%s", EnvStderrPrefix, childStderrPrefix,
419 cmd.ExtraFiles = append(cmd.ExtraFiles, FdOODTgts)
420 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvOODTgtsFd, 3+fdNum))
422 cmd.ExtraFiles = append(cmd.ExtraFiles, FdOODTgtsLock)
423 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvOODTgtsLockFd, 3+fdNum))
427 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvStatusFd))
429 cmd.ExtraFiles = append(cmd.ExtraFiles, FdStatus)
430 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvStatusFd, 3+fdNum))
435 var fdStderr *os.File
437 fdStderr, err = os.OpenFile(
438 path.Join(redoDir, tgt.t+LogSuffix),
439 os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
444 return TgtError{tgt, ErrLine(err)}
447 tracef(CDebug, "%s", shCtx)
449 jsNeedsRelease = false
454 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvJobs))
456 cmd.ExtraFiles = append(cmd.ExtraFiles, JSR)
457 cmd.ExtraFiles = append(cmd.ExtraFiles, JSW)
458 makeFlags := fmt.Sprintf(
459 "%s %s%d,%d", MakeFlags, MakeJSArg, 3+fdNum+0, 3+fdNum+1,
461 makeFlags = strings.Trim(makeFlags, " ")
462 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", MakeFlagsName, makeFlags))
464 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvJSToken, jsToken))
468 if _, err = FdStatus.Write([]byte{StatusRun}); err != nil {
473 defer jsRelease(shCtx, jsToken)
475 var finished time.Time
476 var exitErr *exec.ExitError
477 started := time.Now()
478 runErr.Started = &started
479 fdStdout, err = os.OpenFile(fdStdout.Name(), os.O_RDWR, os.FileMode(0666))
488 cmd.Stdout = fdStdout
489 fdDep, err = os.OpenFile(fdDep.Name(), os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
500 cmd.ExtraFiles = append(cmd.ExtraFiles, fdDep)
501 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvDepFd, 3+fdNum))
503 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDepCwd, cwd))
512 logRecPath := path.Join(redoDir, tgt.t+LogRecSuffix)
513 if fdStderr, err = os.OpenFile(
515 os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
518 fields := []recfile.Field{
519 {Name: "Build", Value: BuildUUID},
520 {Name: "PPID", Value: strconv.Itoa(os.Getpid())},
521 {Name: "Cwd", Value: cwd},
523 if cmd.Process != nil {
524 fields = append(fields, recfile.Field{
525 Name: "PID", Value: strconv.Itoa(cmd.Process.Pid),
528 ts := new(tai64n.TAI64N)
530 fields = append(fields,
531 recfile.Field{Name: "Started", Value: tai64n.Encode(ts[:])},
533 ts.FromTime(finished)
534 fields = append(fields,
535 recfile.Field{Name: "Finished", Value: tai64n.Encode(ts[:])})
536 fields = append(fields, recfile.Field{
538 Value: strconv.FormatInt(finished.Sub(started).Nanoseconds(), 10),
540 fields = append(fields, recfile.Field{Name: "Cmd", Value: cmdName})
541 for _, arg := range args {
542 fields = append(fields, recfile.Field{Name: "Arg", Value: arg})
544 for _, env := range cmd.Env {
545 fields = append(fields, recfile.Field{Name: "Env", Value: env})
548 fields = append(fields, recfile.Field{
550 Value: strconv.Itoa(exitErr.ProcessState.ExitCode()),
554 w := bufio.NewWriter(fdStderr)
556 var ifchanges []string
557 ifchanges, err = depReadOnlyIfchanges(tgt.Dep())
562 for _, dep := range ifchanges {
563 fields = append(fields, recfile.Field{
569 _, err = recfile.NewWriter(w).WriteFields(fields...)
574 err = ErrLine(w.Flush())
578 os.Remove(logRecPath)
582 log.Println("can not open", logRecPath, ":", err)
587 os.Remove(fdDep.Name())
589 os.Remove(fdStdout.Name())
592 if _, err = FdStatus.Write([]byte{StatusDone}); err != nil {
598 stderr, err := cmd.StderrPipe()
612 RunningProcs[cmd.Process.Pid] = cmd.Process
613 RunningProcsM.Unlock()
614 pid := fmt.Sprintf("[%d]", cmd.Process.Pid)
615 tracef(CDebug, "%s runs %s", tgt, pid)
617 stderrTerm := make(chan struct{})
619 scanner := bufio.NewScanner(stderr)
621 ts := new(tai64n.TAI64N)
623 line = scanner.Text()
624 if strings.HasPrefix(line, childStderrPrefix) {
625 line = line[len(childStderrPrefix):]
626 os.Stderr.WriteString(StderrPrefix + line + "\n")
630 ts.FromTime(time.Now())
632 fmt.Fprintln(fdStderr, tai64n.Encode(ts[:]), line)
639 tracef(CNone, "%s", line)
641 tracef(CNone, "%s %s", pid, line)
647 // Wait for job completion
651 delete(RunningProcs, cmd.Process.Pid)
652 RunningProcsM.Unlock()
653 finished = time.Now()
654 runErr.Finished = &finished
656 exitErr = err.(*exec.ExitError)
663 if inode, err := inodeFromFileByPath(tgt.a); err == nil {
664 if inodePrev == nil {
665 runErr.Err = Err1WasTouched
674 if !inode.Equals(inodePrev) {
675 runErr.Err = Err1WasTouched
681 // Does it produce both stdout and tmp?
682 fiStdout, err := os.Stat(fdStdout.Name())
684 runErr.Err = ErrLine(err)
689 _, err = os.Stat(tmpPath)
691 if fiStdout.Size() > 0 {
692 runErr.Err = errors.New("created both tmp and stdout")
697 } else if !errors.Is(err, fs.ErrNotExist) {
698 runErr.Err = ErrLine(err)
703 // Determine what file we must process at last
706 fd, err = os.Open(tmpPath)
712 } else if fiStdout.Size() > 0 {
716 // Do we need to ifcreate it, or ifchange with renaming?
719 err = ifcreate(fdDep, tgt.t)
727 _, err = fd.Seek(0, io.SeekStart)
732 hsh, err = fileHash(fd)
737 if bytes.Equal(hsh, hshPrev) {
738 tracef(CDebug, "%s has same hash, not renaming", tgt)
739 err = ErrLine(os.Remove(fd.Name()))
743 err = ErrLine(os.Chtimes(tgt.a, finished, finished))
748 err = ErrLine(syncDir(tgt.h))
753 err = ErrLine(depWrite(fdDep, tgt.h, tgt, hsh))
761 err = ErrLine(fd.Sync())
766 err = ErrLine(os.Rename(fd.Name(), tgt.a))
771 err = ErrLine(syncDir(tgt.h))
776 err = ErrLine(depWrite(fdDep, tgt.h, tgt, hsh))
785 err = ErrLine(fdDep.Sync())
790 err = ErrLine(os.Rename(fdDep.Name(), tgt.Dep()))
796 err = ErrLine(syncDir(redoDir))
804 // Post-commit .rec sanitizing
805 if depInfo, err := depRead(tgt); err == nil {
806 ifchangeSeen := make(map[string]struct{}, len(depInfo.ifchanges))
807 for _, dep := range depInfo.ifchanges {
808 ifchangeSeen[dep.tgt.a] = struct{}{}
810 for _, dep := range depInfo.ifcreates {
811 if _, exists := ifchangeSeen[dep.a]; exists {
812 tracef(CWarn, "simultaneous ifcreate and ifchange records: %s", tgt)
815 } else if errors.Is(err, fs.ErrNotExist) {
829 func isOkRun(err error) bool {
834 if errors.As(err, &runErr) && runErr.Err == nil {
835 tracef(CRedo, "%s", runErr.Name())
838 tracef(CErr, "%s", err)