Recursive serialized logs capability

[goredo.git] / run.go

diff --git a/run.go b/run.go
index 1c1b0d7759295786f9e1237975a5a8e18064bd1f..fe78a87e68198abb8f63d20383394a3f50c37121 100644 (file)
--- a/run.go
+++ b/run.go
@@ -29,6 +29,7 @@ import (
        "os/exec"
        "path"
        "path/filepath"
+       "strconv"
        "strings"
        "sync"
        "syscall"
@@ -42,6 +43,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"
@@ -63,14 +65,28 @@ var (
        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
 )
 
+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 RunErr struct {
        Tgt      string
        DoFile   string
@@ -403,6 +419,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))
@@ -421,15 +439,62 @@ 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, 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 _, e := range cmd.Env {
+                                               fields = append(fields, recfile.Field{Name: "Env", Value: e})
+                                       }
+                                       if exitErr != nil {
+                                               fields = append(fields, recfile.Field{
+                                                       Name:  "ExitCode",
+                                                       Value: strconv.Itoa(exitErr.ProcessState.ExitCode()),
+                                               })
+                                       }
+                                       w := bufio.NewWriter(fdStderr)
+                                       _, err = recfile.NewWriter(w).WriteFields(fields...)
+                                       w.Flush()
+                                       fdStderr.Close()
+                                       if err != nil {
+                                               os.Remove(logRecPath)
+                                       }
+                               }
                        }
+                       lockRelease()
                        os.Remove(fdDep.Name())
                        os.Remove(fdStdout.Name())
                        os.Remove(tmpPath)
@@ -488,9 +553,19 @@ 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 {
+                       // Try to commit .rec anyway
+                       if !NoSync {
+                               fdDep.Sync()
+                       }
+                       os.Rename(fdDep.Name(), path.Join(redoDir, tgt+DepSuffix))
+                       if !NoSync {
+                               err = syncDir(redoDir)
+                       }
+
+                       exitErr = err.(*exec.ExitError)
                        runErr.Err = err
                        errs <- runErr
                        return