Linting

[goredo.git] / run.go

diff --git a/run.go b/run.go
index 0178d726b9d9b476dbd01d1db45e713d0f5c80c0..ea14641a9304bd85adbee7c988cebdcc3059242c 100644 (file)
--- 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
 }