X-Git-Url: http://www.git.cypherpunks.ru/?p=goredo.git;a=blobdiff_plain;f=run.go;h=ea14641a9304bd85adbee7c988cebdcc3059242c;hp=0178d726b9d9b476dbd01d1db45e713d0f5c80c0;hb=d8abe40c66df8d79a025524c0d230959cacf9465;hpb=7648b1c670d38b62b6328824ceecd50303945fdf

diff --git a/run.go b/run.go
index 0178d72..ea14641 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
 
@@ -76,6 +76,8 @@ var (
 
 	RunningProcs  = map[int]*os.Process{}
 	RunningProcsM sync.Mutex
+
+	Err1WasTouched = errors.New("$1 was explicitly touched")
 )
 
 func init() {
@@ -92,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
@@ -100,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
@@ -113,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)
 }
 
@@ -138,7 +140,7 @@ 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
@@ -184,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
@@ -194,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))
@@ -241,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
 		}()
@@ -252,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
@@ -267,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() {
@@ -279,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
@@ -306,7 +316,7 @@ 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
@@ -314,10 +324,10 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 
 	if err = writeDep(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
@@ -339,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()
@@ -393,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() {
@@ -421,7 +431,9 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 		}
 
 		if FdStatus != nil {
-			FdStatus.Write([]byte{StatusRun})
+			if _, err = FdStatus.Write([]byte{StatusRun}); err != nil {
+				log.Fatalln(err)
+			}
 		}
 
 		var finished time.Time
@@ -532,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()
 		}()
@@ -553,9 +567,9 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 		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
@@ -577,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)
@@ -602,25 +616,24 @@ 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 := errors.New("$1 was explicitly touched")
+			errTouched := Err1WasTouched
 			if inodePrev == nil {
 				fd.Close()
 				runErr.Err = errTouched
 				errs <- runErr
 				return
-			} else {
-				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
-				}
+			}
+			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
 			}
 		}
 
@@ -629,7 +642,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 				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
 				}
@@ -729,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
 }