X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=run.go;h=3e6cd35fdbe5a3e41c2167b4436bca1f1840a7a6;hb=b42c8c2dba5ea7667c32681338930969ed5c1cdb;hp=ca8eebbcd9ca542dd7c9f31e77dfaca18eb4b7de;hpb=3d2efdb8e781a148ab3633405534534dfd8c7545;p=goredo.git diff --git a/run.go b/run.go index ca8eebb..3e6cd35 100644 --- a/run.go +++ b/run.go @@ -61,9 +61,9 @@ const ( ) var ( - NoSync bool = false - StderrKeep bool = false - StderrSilent bool = false + NoSync = false + StderrKeep = false + StderrSilent = false StderrPrefix string Jobs sync.WaitGroup @@ -73,6 +73,11 @@ var ( flagStderrSilent *bool TracedAll bool + + RunningProcs = map[int]*os.Process{} + RunningProcsM sync.Mutex + + Err1WasTouched = errors.New("$1 was explicitly touched") ) func init() { @@ -89,7 +94,7 @@ func init() { fmt.Sprintf("silent, do not print job's stderr (%s=1)", EnvStderrSilent)) } -type RunErr struct { +type RunError struct { Tgt string DoFile string Started *time.Time @@ -97,7 +102,7 @@ type RunErr struct { Err error } -func (e *RunErr) Name() string { +func (e *RunError) Name() string { var name string if e.DoFile == "" { name = e.Tgt @@ -110,7 +115,7 @@ func (e *RunErr) Name() string { return fmt.Sprintf("%s (%.3fs)", name, e.Finished.Sub(*e.Started).Seconds()) } -func (e RunErr) Error() string { +func (e RunError) Error() string { return fmt.Sprintf("%s: %s", e.Name(), e.Err) } @@ -135,12 +140,12 @@ func isModified(cwd, redoDir, tgt string) (bool, *Inode, error) { for { m, err := r.NextMap() if err != nil { - if err == io.EOF { + if errors.Is(err, io.EOF) { break } return false, nil, err } - if m["Target"] != tgt { + if m["Type"] != DepTypeIfchange || m["Target"] != tgt { continue } fd, err := os.Open(path.Join(cwd, tgt)) @@ -181,7 +186,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { cwd, tgt := cwdAndTgt(tgtOrig) redoDir := path.Join(cwd, RedoDir) if err := mkdirs(redoDir); err != nil { - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } // Acquire lock @@ -191,34 +196,42 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { os.FileMode(0666), ) if err != nil { - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } lockRelease := func() { - trace(CLock, "LOCK_UN: %s", fdLock.Name()) - unix.Flock(int(fdLock.Fd()), unix.LOCK_UN) + tracef(CLock, "LOCK_UN: %s", fdLock.Name()) + if err := unix.Flock(int(fdLock.Fd()), unix.LOCK_UN); err != nil { + log.Fatalln(err) + } fdLock.Close() } - trace(CLock, "LOCK_NB: %s", fdLock.Name()) + tracef(CLock, "LOCK_NB: %s", fdLock.Name()) // Waiting for job completion, already taken by someone else if err = unix.Flock(int(fdLock.Fd()), unix.LOCK_EX|unix.LOCK_NB); err != nil { if uintptr(err.(syscall.Errno)) != uintptr(unix.EWOULDBLOCK) { fdLock.Close() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } Jobs.Add(1) - trace(CDebug, "waiting: %s", tgtOrig) + tracef(CDebug, "waiting: %s", tgtOrig) if FdStatus != nil { - FdStatus.Write([]byte{StatusWait}) + if _, err = FdStatus.Write([]byte{StatusWait}); err != nil { + log.Fatalln(err) + } } go func() { defer Jobs.Done() - trace(CLock, "LOCK_EX: %s", fdLock.Name()) - unix.Flock(int(fdLock.Fd()), unix.LOCK_EX) + tracef(CLock, "LOCK_EX: %s", fdLock.Name()) + if err := unix.Flock(int(fdLock.Fd()), unix.LOCK_EX); err != nil { + log.Fatalln(err) + } lockRelease() - trace(CDebug, "waiting done: %s", tgtOrig) + tracef(CDebug, "waiting done: %s", tgtOrig) if FdStatus != nil { - FdStatus.Write([]byte{StatusWaited}) + if _, err = FdStatus.Write([]byte{StatusWaited}); err != nil { + log.Fatalln(err) + } } var depInfo *DepInfo fdDep, err := os.Open(path.Join(redoDir, tgt+DepSuffix)) @@ -238,7 +251,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { } Finish: if err != nil { - err = TgtErr{tgtOrig, err} + err = TgtError{tgtOrig, err} } errs <- err }() @@ -249,10 +262,10 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { modified, inodePrev, err := isModified(cwd, redoDir, tgt) if err != nil { lockRelease() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } if modified { - trace(CWarn, "%s externally modified: not redoing", tgtOrig) + tracef(CWarn, "%s externally modified: not redoing", tgtOrig) lockRelease() go func() { errs <- nil @@ -264,7 +277,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { fdDep, err := tempfile(redoDir, tgt+DepSuffix) if err != nil { lockRelease() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } fdDepPath := fdDep.Name() cleanup := func() { @@ -276,18 +289,18 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { recfile.Field{Name: "Build", Value: BuildUUID}, ); err != nil { cleanup() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } // Find .do doFile, upLevels, err := findDo(fdDep, cwd, tgt) if err != nil { cleanup() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } if doFile == "" { cleanup() - return TgtErr{tgtOrig, errors.New("no .do found")} + return TgtError{tgtOrig, errors.New("no .do found")} } // Determine basename and DIRPREFIX @@ -303,18 +316,18 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { cwd = path.Clean(cwd) doFilePath := path.Join(cwd, doFile) basename := tgt - runErr := RunErr{Tgt: tgtOrig} + runErr := RunError{Tgt: tgtOrig} if strings.HasPrefix(doFile, "default.") { basename = tgt[:len(tgt)-(len(doFile)-len("default.")-len(".do"))-1] runErr.DoFile = doFileRelPath } - if err = writeDep(fdDep, cwdOrig, doFileRelPath); err != nil { + if err = depWrite(fdDep, cwdOrig, doFileRelPath); err != nil { cleanup() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } fdDep.Close() - trace(CWait, "%s", runErr.Name()) + tracef(CWait, "%s", runErr.Name()) // Prepare command line var cmdName string @@ -336,7 +349,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { fdStdout, err := tempfile(cwdOrig, tgt) if err != nil { cleanup() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } stdoutPath := fdStdout.Name() fdStdout.Close() @@ -390,14 +403,14 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { ) if err != nil { cleanup() - return TgtErr{tgtOrig, err} + return TgtError{tgtOrig, err} } } shCtx := fmt.Sprintf( "sh: %s: %s %s cwd:%s dirprefix:%s", tgtOrig, cmdName, args, cwd, dirPrefix, ) - trace(CDebug, "%s", shCtx) + tracef(CDebug, "%s", shCtx) Jobs.Add(1) go func() { @@ -408,16 +421,19 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { } else { cmd.ExtraFiles = append(cmd.ExtraFiles, JSR) cmd.ExtraFiles = append(cmd.ExtraFiles, JSW) - cmd.Env = append(cmd.Env, fmt.Sprintf( - "%s=%s %s%d,%d", - MakeFlagsName, MakeFlags, MakeJSArg, 3+fdNum+0, 3+fdNum+1, - )) + makeFlags := fmt.Sprintf( + "%s %s%d,%d", MakeFlags, MakeJSArg, 3+fdNum+0, 3+fdNum+1, + ) + makeFlags = strings.Trim(makeFlags, " ") + cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", MakeFlagsName, makeFlags)) fdNum += 2 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvJSToken, jsToken)) } if FdStatus != nil { - FdStatus.Write([]byte{StatusRun}) + if _, err = FdStatus.Write([]byte{StatusRun}); err != nil { + log.Fatalln(err) + } } var finished time.Time @@ -456,10 +472,14 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { ); err == nil { fields := []recfile.Field{ {Name: "Build", Value: BuildUUID}, - {Name: "PID", Value: strconv.Itoa(cmd.Process.Pid)}, {Name: "PPID", Value: strconv.Itoa(os.Getpid())}, {Name: "Cwd", Value: cwd}, } + if cmd.Process != nil { + fields = append(fields, recfile.Field{ + Name: "PID", Value: strconv.Itoa(cmd.Process.Pid), + }) + } ts := new(tai64n.TAI64N) ts.FromTime(started) fields = append(fields, @@ -474,7 +494,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { }) fields = append(fields, recfile.Field{Name: "Cmd", Value: cmdName}) for _, arg := range args { - fields = append(fields, recfile.Field{Name: "Cmd", Value: arg}) + fields = append(fields, recfile.Field{Name: "Arg", Value: arg}) } for _, env := range cmd.Env { fields = append(fields, recfile.Field{Name: "Env", Value: env}) @@ -524,7 +544,9 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { os.Remove(tmpPath) os.Remove(fdLock.Name()) if FdStatus != nil { - FdStatus.Write([]byte{StatusDone}) + if _, err = FdStatus.Write([]byte{StatusDone}); err != nil { + log.Fatalln(err) + } } Jobs.Done() }() @@ -541,10 +563,13 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { errs <- runErr return } + RunningProcsM.Lock() + RunningProcs[cmd.Process.Pid] = cmd.Process + RunningProcsM.Unlock() pid := fmt.Sprintf("[%d]", cmd.Process.Pid) - trace(CDebug, "%s runs %s", tgtOrig, pid) + tracef(CDebug, "%s runs %s", tgtOrig, pid) - stderrTerm := make(chan struct{}, 0) + stderrTerm := make(chan struct{}) go func() { scanner := bufio.NewScanner(stderr) var line string @@ -566,9 +591,9 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { continue } if MyPid == 0 { - trace(CNone, "%s", line) + tracef(CNone, "%s", line) } else { - trace(CNone, "%s %s", pid, line) + tracef(CNone, "%s %s", pid, line) } } close(stderrTerm) @@ -577,6 +602,9 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { // Wait for job completion <-stderrTerm err = cmd.Wait() + RunningProcsM.Lock() + delete(RunningProcs, cmd.Process.Pid) + RunningProcsM.Unlock() finished = time.Now() runErr.Finished = &finished if err != nil { @@ -587,12 +615,34 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { } // Was $1 touched? + if fd, err := os.Open(path.Join(cwdOrig, tgt)); err == nil { + errTouched := Err1WasTouched + if inodePrev == nil { + fd.Close() + runErr.Err = errTouched + errs <- runErr + return + } + inode, err := inodeFromFile(fd) + fd.Close() + if err != nil { + runErr.Err = err + errs <- runErr + return + } + if !inode.Equals(inodePrev) { + runErr.Err = errTouched + errs <- runErr + return + } + } + if inodePrev != nil { if fd, err := os.Open(path.Join(cwdOrig, tgt)); err == nil { inode, err := inodeFromFile(fd) fd.Close() if err == nil && !inode.Equals(inodePrev) { - runErr.Err = errors.New("$1 was explicitly touched") + runErr.Err = Err1WasTouched errs <- runErr return } @@ -657,7 +707,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error { goto Finish } } - err = writeDep(fdDep, cwdOrig, tgt) + err = depWrite(fdDep, cwdOrig, tgt) if err != nil { goto Finish } @@ -692,10 +742,11 @@ func isOkRun(err error) bool { if err == nil { return true } - if err, ok := err.(RunErr); ok && err.Err == nil { - trace(CRedo, "%s", err.Name()) + var runErr RunError + if errors.As(err, &runErr) && runErr.Err == nil { + tracef(CRedo, "%s", runErr.Name()) return true } - trace(CErr, "%s", err) + tracef(CErr, "%s", err) return false }