Redundant @documentencoding

[goredo.git] / run.go

diff --git a/run.go b/run.go
index 32e38004e449b8fc5c814e4780e615866b1bcc2d..2e5dbf5f7ebd5fc8e9c4cfc6e8194333b0456fd9 100644 (file)
--- a/run.go
+++ b/run.go
@@ -1,6 +1,6 @@
 /*
 goredo -- djb's redo implementation on pure Go
-Copyright (C) 2020-2022 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2020-2023 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -21,6 +21,8 @@ package main
 
 import (
        "bufio"
+       "crypto/rand"
+       "encoding/hex"
        "errors"
        "flag"
        "fmt"
@@ -124,7 +126,7 @@ func (e RunError) Error() string {
 }
 
 func mkdirs(pth string) error {
-       if _, err := os.Stat(pth); err == nil {
+       if FileExists(pth) {
                return nil
        }
        return os.MkdirAll(pth, os.FileMode(0777))
@@ -154,18 +156,13 @@ func isModified(cwd, redoDir, tgt string) (bool, *Inode, string, error) {
                if m["Type"] != DepTypeIfchange || m["Target"] != tgt {
                        continue
                }
-               fd, err := os.Open(path.Join(cwd, tgt))
+               ourInode, err = inodeFromFileByPath(path.Join(cwd, tgt))
                if err != nil {
                        if os.IsNotExist(err) {
                                return false, nil, "", nil
                        }
                        return false, nil, "", err
                }
-               ourInode, err = inodeFromFile(fd)
-               fd.Close()
-               if err != nil {
-                       return false, nil, "", err
-               }
                theirInode, err := inodeFromRec(m)
                if err != nil {
                        return false, nil, "", err
@@ -194,6 +191,15 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                return TgtError{tgtOrig, err}
        }
 
+       shCtx := fmt.Sprintf("sh: %s: cwd:%s", tgtOrig, cwd)
+       jsToken := jsAcquire(shCtx)
+       jsNeedsRelease := true
+       defer func() {
+               if jsNeedsRelease {
+                       jsRelease(shCtx, jsToken)
+               }
+       }()
+
        // Acquire lock
        fdLock, err := os.OpenFile(
                path.Join(redoDir, tgt+LockSuffix),
@@ -211,7 +217,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                tracef(CLock, "LOCK_UN: %s", fdLock.Name())
                flock.Type = unix.F_UNLCK
                if err := unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
-                       log.Fatalln(err)
+                       log.Fatalln(err, fdLock.Name())
                }
                fdLock.Close()
        }
@@ -225,7 +231,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                }
                Jobs.Add(1)
                if err = unix.FcntlFlock(fdLock.Fd(), unix.F_GETLK, &flock); err != nil {
-                       log.Fatalln(err)
+                       log.Fatalln(err, fdLock.Name())
                }
                tracef(CDebug, "waiting: %s (pid=%d)", tgtOrig, flock.Pid)
                if FdStatus != nil {
@@ -236,8 +242,11 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                go func() {
                        defer Jobs.Done()
                        tracef(CLock, "LOCK_EX: %s", fdLock.Name())
+               LockAgain:
                        if err := unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
-                               log.Fatalln(err)
+                               log.Println(err, fdLock.Name())
+                               time.Sleep(10 * time.Millisecond)
+                               goto LockAgain
                        }
                        lockRelease()
                        tracef(CDebug, "waiting done: %s", tgtOrig)
@@ -265,6 +274,7 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                Finish:
                        if err != nil {
                                err = TgtError{tgtOrig, err}
+                               fdLock.Close()
                        }
                        errs <- err
                }()
@@ -380,6 +390,10 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                path.Join(dirPrefix, basename),
                tmpPathRel,
        )
+       shCtx = fmt.Sprintf(
+               "sh: %s: %s %s cwd:%s dirprefix:%s",
+               tgtOrig, cmdName, args, cwd, dirPrefix,
+       )
 
        cmd := exec.Command(cmdName, args...)
        cmd.Dir = cwd
@@ -388,7 +402,11 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
        cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDirPrefix, dirPrefix))
        cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvBuildUUID, BuildUUID))
 
-       childStderrPrefix := tempsuffix()
+       childStderrPrefixRaw := make([]byte, 8)
+       if _, err = io.ReadFull(rand.Reader, childStderrPrefixRaw); err != nil {
+               panic(err)
+       }
+       childStderrPrefix := hex.EncodeToString(childStderrPrefixRaw)
        cmd.Env = append(cmd.Env, fmt.Sprintf(
                "%s=%s", EnvStderrPrefix, childStderrPrefix,
        ))
@@ -422,15 +440,11 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                        return TgtError{tgtOrig, err}
                }
        }
-       shCtx := fmt.Sprintf(
-               "sh: %s: %s %s cwd:%s dirprefix:%s",
-               tgtOrig, cmdName, args, cwd, dirPrefix,
-       )
        tracef(CDebug, "%s", shCtx)
 
+       jsNeedsRelease = false
        Jobs.Add(1)
        go func() {
-               jsToken := jsAcquire(shCtx)
                if JSR == nil {
                        // infinite jobs
                        cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvJobs))
@@ -452,12 +466,17 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                        }
                }
 
+               defer jsRelease(shCtx, jsToken)
+
                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))
                if err != nil {
+                       if fdStderr != nil {
+                               fdStderr.Close()
+                       }
                        runErr.Err = err
                        errs <- runErr
                        return
@@ -465,6 +484,10 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                cmd.Stdout = fdStdout
                fdDep, err = os.OpenFile(fdDepPath, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
                if err != nil {
+                       if fdStderr != nil {
+                               fdStderr.Close()
+                       }
+                       fdStdout.Close()
                        runErr.Err = err
                        errs <- runErr
                        return
@@ -475,7 +498,6 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDepCwd, cwd))
 
                defer func() {
-                       jsRelease(shCtx, jsToken)
                        fdDep.Close()
                        fdStdout.Close()
                        if fdStderr != nil {
@@ -558,7 +580,6 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                        os.Remove(fdDep.Name())
                        os.Remove(fdStdout.Name())
                        os.Remove(tmpPath)
-                       os.Remove(fdLock.Name())
                        if FdStatus != nil {
                                if _, err = FdStatus.Write([]byte{StatusDone}); err != nil {
                                        log.Fatalln(err)
@@ -631,15 +652,12 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                }
 
                // Was $1 touched?
-               if fd, err := os.Open(path.Join(cwdOrig, tgt)); err == nil {
+               if inode, err := inodeFromFileByPath(path.Join(cwdOrig, tgt)); err == nil {
                        if inodePrev == nil {
-                               fd.Close()
                                runErr.Err = Err1WasTouched
                                errs <- runErr
                                return
                        }
-                       inode, err := inodeFromFile(fd)
-                       fd.Close()
                        if err != nil {
                                runErr.Err = err
                                errs <- runErr
@@ -653,10 +671,8 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                }
 
                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) {
+                       if inode, err := inodeFromFileByPath(path.Join(cwdOrig, tgt)); err == nil {
+                               if !inode.Equals(inodePrev) {
                                        runErr.Err = Err1WasTouched
                                        errs <- runErr
                                        return