X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=run.go;h=0b77d499613f5549704b528fbfff49b440282ebd;hb=dec78abffe14ae2e7c3383c215803c3792788d3e;hp=1d1138b0287f07460afbdd0cf54dc6a9aceae08b;hpb=c85dc52372fd44ddb285713c23906df407da4551;p=goredo.git

diff --git a/run.go b/run.go
index 1d1138b..0b77d49 100644
--- a/run.go
+++ b/run.go
@@ -52,17 +52,18 @@ const (
 	EnvStderrSilent = "REDO_SILENT"
 	EnvNoSync       = "REDO_NO_SYNC"
 
-	RedoDir    = ".redo"
-	LockSuffix = ".lock"
-	DepSuffix  = ".rec"
-	TmpPrefix  = ".redo."
-	LogSuffix  = ".log"
+	RedoDir      = ".redo"
+	LockSuffix   = ".lock"
+	DepSuffix    = ".rec"
+	TmpPrefix    = ".redo."
+	LogSuffix    = ".log"
+	LogRecSuffix = ".log-rec"
 )
 
 var (
-	NoSync       bool = false
-	StderrKeep   bool = false
-	StderrSilent bool = false
+	NoSync       = false
+	StderrKeep   = false
+	StderrSilent = false
 	StderrPrefix string
 	Jobs         sync.WaitGroup
 
@@ -72,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() {
@@ -88,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
@@ -96,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
@@ -109,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)
 }
 
@@ -134,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))
@@ -180,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
@@ -190,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))
@@ -237,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
 		}()
@@ -248,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
@@ -263,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() {
@@ -275,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
@@ -302,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
@@ -335,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()
@@ -389,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() {
@@ -407,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
@@ -447,7 +464,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 			fdStdout.Close()
 			if fdStderr != nil {
 				fdStderr.Close()
-				logRecPath := path.Join(redoDir, tgt+LogSuffix+DepSuffix)
+				logRecPath := path.Join(redoDir, tgt+LogRecSuffix)
 				if fdStderr, err = os.OpenFile(
 					logRecPath,
 					os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
@@ -455,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,
@@ -473,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})
@@ -523,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()
 		}()
@@ -540,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
@@ -565,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)
@@ -576,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 {
@@ -586,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
 				}
@@ -632,7 +683,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 			fd = fdStdout
 		}
 
-		// Do we need to ifcreate it, of ifchange with renaming?
+		// Do we need to ifcreate it, or ifchange with renaming?
 		if fd == nil {
 			os.Remove(path.Join(cwdOrig, tgt))
 			err = ifcreate(fdDep, tgt)
@@ -656,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
 			}
@@ -680,6 +731,26 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 				goto Finish
 			}
 		}
+
+		// Post-commit .rec sanitizing
+		fdDep.Close()
+		if fdDepR, err := os.Open(fdDepPath); err == nil {
+			depInfo, err := depRead(fdDepR)
+			fdDepR.Close()
+			if err != nil {
+				goto Finish
+			}
+			ifchangeSeen := make(map[string]struct{}, len(depInfo.ifchanges))
+			for _, dep := range depInfo.ifchanges {
+				ifchangeSeen[dep["Target"]] = struct{}{}
+			}
+			for _, dep := range depInfo.ifcreates {
+				if _, exists := ifchangeSeen[dep]; exists {
+					tracef(CWarn, "simultaneous ifcreate and ifchange records: %s", tgt)
+				}
+			}
+		}
+
 	Finish:
 		runErr.Err = err
 		errs <- runErr
@@ -691,10 +762,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
 }