No .rec required for recursive logs

[goredo.git] / run.go

diff --git a/run.go b/run.go
index 59e134e50f3d568d09832bf7a34ed3d589ca5893..d31c8a0c5a4ffb52816cb74d90de5536c8fe515b 100644 (file)
--- 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"
@@ -418,6 +420,8 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                        FdStatus.Write([]byte{StatusRun})
                }
 
+               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))
@@ -440,12 +444,82 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
 
                defer func() {
                        jsRelease(shCtx, jsToken)
-                       lockRelease()
                        fdDep.Close()
                        fdStdout.Close()
                        if fdStderr != nil {
                                fdStderr.Close()
+                               logRecPath := path.Join(redoDir, tgt+LogSuffix+DepSuffix)
+                               if fdStderr, err = os.OpenFile(
+                                       logRecPath,
+                                       os.O_WRONLY|os.O_CREATE,
+                                       os.FileMode(0666),
+                               ); err == nil {
+                                       fdStderr.Truncate(0)
+                                       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},
+                                       }
+                                       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: "Cmd", 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(fdDep.Name())
+                                       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)
@@ -504,9 +578,10 @@ func runScript(tgtOrig string, errs chan error, traced bool) error {
                // Wait for job completion
                <-stderrTerm
                err = cmd.Wait()
-               finished := time.Now()
+               finished = time.Now()
                runErr.Finished = &finished
                if err != nil {
+                       exitErr = err.(*exec.ExitError)
                        runErr.Err = err
                        errs <- runErr
                        return