X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=run.go;h=3e6cd35fdbe5a3e41c2167b4436bca1f1840a7a6;hb=b42c8c2dba5ea7667c32681338930969ed5c1cdb;hp=4ca90d649af939e151326ea2636f65cd59e6f3bc;hpb=ce60c3b66ff2d3f14392cac1eb3ec6dfc33fc893;p=goredo.git

diff --git a/run.go b/run.go
index 4ca90d6..3e6cd35 100644
--- a/run.go
+++ b/run.go
@@ -25,10 +25,12 @@ import (
 	"flag"
 	"fmt"
 	"io"
+	"log"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"sync"
 	"syscall"
@@ -42,6 +44,7 @@ import (
 const (
 	EnvDepFd        = "REDO_DEP_FD"
 	EnvDirPrefix    = "REDO_DIRPREFIX"
+	EnvDepCwd       = "REDO_DEP_CWD"
 	EnvBuildUUID    = "REDO_BUILD_UUID"
 	EnvStderrPrefix = "REDO_STDERR_PREFIX"
 	EnvTrace        = "REDO_TRACE"
@@ -49,29 +52,49 @@ 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
 
-	flagTrace        = flag.Bool("x", false, "trace (sh -x) current targets")
-	flagTraceAll     = flag.Bool("xx", false, fmt.Sprintf("trace (sh -x) all targets (%s=1)", EnvTrace))
-	flagStderrKeep   = flag.Bool("logs", false, fmt.Sprintf("keep job's stderr (%s=1)", EnvStderrKeep))
-	flagStderrSilent = flag.Bool("silent", false, fmt.Sprintf("do not print job's stderr (%s=1)", EnvStderrSilent))
+	flagTrace        *bool
+	flagTraceAll     *bool
+	flagStderrKeep   *bool
+	flagStderrSilent *bool
 
 	TracedAll bool
+
+	RunningProcs  = map[int]*os.Process{}
+	RunningProcsM sync.Mutex
+
+	Err1WasTouched = errors.New("$1 was explicitly touched")
 )
 
-type RunErr struct {
+func init() {
+	cmdName := CmdName()
+	if !(cmdName == CmdNameRedo || cmdName == CmdNameRedoIfchange) {
+		return
+	}
+	flagTrace = flag.Bool("x", false, "trace (sh -x) current targets")
+	flagTraceAll = flag.Bool("xx", false,
+		fmt.Sprintf("trace (sh -x) all targets (%s=1)", EnvTrace))
+	flagStderrKeep = flag.Bool("k", false,
+		fmt.Sprintf("keep job's stderr (%s=1)", EnvStderrKeep))
+	flagStderrSilent = flag.Bool("s", false,
+		fmt.Sprintf("silent, do not print job's stderr (%s=1)", EnvStderrSilent))
+}
+
+type RunError struct {
 	Tgt      string
 	DoFile   string
 	Started  *time.Time
@@ -79,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
@@ -92,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)
 }
 
@@ -117,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))
@@ -163,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
@@ -173,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))
@@ -220,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
 		}()
@@ -231,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
@@ -246,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() {
@@ -258,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
@@ -285,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
@@ -318,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()
@@ -362,45 +393,51 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 		fdNum++
 	}
 
-	if JSR == nil {
-		// infinite jobs
-		cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvJSFd))
-	} else {
-		cmd.ExtraFiles = append(cmd.ExtraFiles, JSR)
-		cmd.ExtraFiles = append(cmd.ExtraFiles, JSW)
-		cmd.Env = append(cmd.Env, fmt.Sprintf(
-			"%s=%d,%d", EnvJSFd, 3+fdNum+0, 3+fdNum+1,
-		))
-		fdNum += 2
-	}
-
 	// Preparing stderr
 	var fdStderr *os.File
 	if StderrKeep {
 		fdStderr, err = os.OpenFile(
 			path.Join(redoDir, tgt+LogSuffix),
-			os.O_WRONLY|os.O_CREATE,
+			os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
 			os.FileMode(0666),
 		)
 		if err != nil {
 			cleanup()
-			return TgtErr{tgtOrig, err}
+			return TgtError{tgtOrig, err}
 		}
-		fdStderr.Truncate(0)
 	}
 	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() {
-		jsAcquire(shCtx)
+		jsToken := jsAcquire(shCtx)
+		if JSR == nil {
+			// infinite jobs
+			cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvJobs))
+		} else {
+			cmd.ExtraFiles = append(cmd.ExtraFiles, JSR)
+			cmd.ExtraFiles = append(cmd.ExtraFiles, JSW)
+			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
+		var exitErr *exec.ExitError
 		started := time.Now()
 		runErr.Started = &started
 		fdStdout, err = os.OpenFile(stdoutPath, os.O_RDWR, os.FileMode(0666))
@@ -419,21 +456,97 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 		cmd.ExtraFiles = append(cmd.ExtraFiles, fdDep)
 		cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvDepFd, 3+fdNum))
 		fdNum++
+		cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDepCwd, cwd))
 
 		defer func() {
-			jsRelease(shCtx)
-			lockRelease()
+			jsRelease(shCtx, jsToken)
 			fdDep.Close()
 			fdStdout.Close()
 			if fdStderr != nil {
 				fdStderr.Close()
+				logRecPath := path.Join(redoDir, tgt+LogRecSuffix)
+				if fdStderr, err = os.OpenFile(
+					logRecPath,
+					os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
+					os.FileMode(0666),
+				); err == nil {
+					fields := []recfile.Field{
+						{Name: "Build", Value: BuildUUID},
+						{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,
+						recfile.Field{Name: "Started", Value: tai64n.Encode(ts[:])},
+					)
+					ts.FromTime(finished)
+					fields = append(fields,
+						recfile.Field{Name: "Finished", Value: tai64n.Encode(ts[:])})
+					fields = append(fields, recfile.Field{
+						Name:  "Duration",
+						Value: strconv.FormatInt(finished.Sub(started).Nanoseconds(), 10),
+					})
+					fields = append(fields, recfile.Field{Name: "Cmd", Value: cmdName})
+					for _, arg := range args {
+						fields = append(fields, recfile.Field{Name: "Arg", Value: arg})
+					}
+					for _, env := range cmd.Env {
+						fields = append(fields, recfile.Field{Name: "Env", Value: env})
+					}
+					if exitErr != nil {
+						fields = append(fields, recfile.Field{
+							Name:  "ExitCode",
+							Value: strconv.Itoa(exitErr.ProcessState.ExitCode()),
+						})
+					}
+					w := bufio.NewWriter(fdStderr)
+
+					var depInfo *DepInfo
+					fdDep, err := os.Open(fdDepPath)
+					if err != nil {
+						goto Err
+					}
+					depInfo, err = depRead(fdDep)
+					fdDep.Close()
+					if err != nil {
+						goto Err
+					}
+					for _, dep := range depInfo.ifchanges {
+						fields = append(fields, recfile.Field{
+							Name:  "Ifchange",
+							Value: dep["Target"],
+						})
+					}
+					_, err = recfile.NewWriter(w).WriteFields(fields...)
+					if err != nil {
+						goto Err
+					}
+					err = w.Flush()
+				Err:
+					if err != nil {
+						log.Println(err)
+						os.Remove(logRecPath)
+					}
+					fdStderr.Close()
+				} else {
+					log.Println("can not open", logRecPath, ":", err)
+				}
 			}
+			lockRelease()
 			os.Remove(fdDep.Name())
 			os.Remove(fdStdout.Name())
 			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()
 		}()
@@ -450,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
@@ -475,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)
@@ -486,21 +602,47 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 		// Wait for job completion
 		<-stderrTerm
 		err = cmd.Wait()
-		finished := time.Now()
+		RunningProcsM.Lock()
+		delete(RunningProcs, cmd.Process.Pid)
+		RunningProcsM.Unlock()
+		finished = time.Now()
 		runErr.Finished = &finished
 		if err != nil {
+			exitErr = err.(*exec.ExitError)
 			runErr.Err = err
 			errs <- runErr
 			return
 		}
 
 		// 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
 				}
@@ -565,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
 			}
@@ -578,7 +720,8 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 				goto Finish
 			}
 		}
-		err = os.Rename(fdDep.Name(), path.Join(redoDir, tgt+DepSuffix))
+		fdDepPath = path.Join(redoDir, tgt+DepSuffix)
+		err = os.Rename(fdDep.Name(), fdDepPath)
 		if err != nil {
 			goto Finish
 		}
@@ -599,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
 }