run.go

   1 /*
   2 goredo -- djb's redo implementation on pure Go
   3 Copyright (C) 2020-2021 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 // Targets runner
  19
  20 package main
  21
  22 import (
  23         "bufio"
  24         "errors"
  25         "flag"
  26         "fmt"
  27         "io"
  28         "log"
  29         "os"
  30         "os/exec"
  31         "path"
  32         "path/filepath"
  33         "strconv"
  34         "strings"
  35         "sync"
  36         "syscall"
  37         "time"
  38
  39         "go.cypherpunks.ru/recfile"
  40         "go.cypherpunks.ru/tai64n/v2"
  41         "golang.org/x/sys/unix"
  42 )
  43
  44 const (
  45         EnvDepFd        = "REDO_DEP_FD"
  46         EnvDirPrefix    = "REDO_DIRPREFIX"
  47         EnvDepCwd       = "REDO_DEP_CWD"
  48         EnvBuildUUID    = "REDO_BUILD_UUID"
  49         EnvStderrPrefix = "REDO_STDERR_PREFIX"
  50         EnvTrace        = "REDO_TRACE"
  51         EnvStderrKeep   = "REDO_LOGS"
  52         EnvStderrSilent = "REDO_SILENT"
  53         EnvNoSync       = "REDO_NO_SYNC"
  54
  55         RedoDir      = ".redo"
  56         LockSuffix   = ".lock"
  57         DepSuffix    = ".rec"
  58         TmpPrefix    = ".redo."
  59         LogSuffix    = ".log"
  60         LogRecSuffix = ".log-rec"
  61 )
  62
  63 var (
  64         NoSync       bool = false
  65         StderrKeep   bool = false
  66         StderrSilent bool = false
  67         StderrPrefix string
  68         Jobs         sync.WaitGroup
  69
  70         flagTrace        *bool
  71         flagTraceAll     *bool
  72         flagStderrKeep   *bool
  73         flagStderrSilent *bool
  74
  75         TracedAll bool
  76
  77         RunningProcs  = map[int]*os.Process{}
  78         RunningProcsM sync.Mutex
  79 )
  80
  81 func init() {
  82         cmdName := CmdName()
  83         if !(cmdName == CmdNameRedo || cmdName == CmdNameRedoIfchange) {
  84                 return
  85         }
  86         flagTrace = flag.Bool("x", false, "trace (sh -x) current targets")
  87         flagTraceAll = flag.Bool("xx", false,
  88                 fmt.Sprintf("trace (sh -x) all targets (%s=1)", EnvTrace))
  89         flagStderrKeep = flag.Bool("k", false,
  90                 fmt.Sprintf("keep job's stderr (%s=1)", EnvStderrKeep))
  91         flagStderrSilent = flag.Bool("s", false,
  92                 fmt.Sprintf("silent, do not print job's stderr (%s=1)", EnvStderrSilent))
  93 }
  94
  95 type RunErr struct {
  96         Tgt      string
  97         DoFile   string
  98         Started  *time.Time
  99         Finished *time.Time
 100         Err      error
 101 }
 102
 103 func (e *RunErr) Name() string {
 104         var name string
 105         if e.DoFile == "" {
 106                 name = e.Tgt
 107         } else {
 108                 name = fmt.Sprintf("%s (%s)", e.Tgt, e.DoFile)
 109         }
 110         if e.Finished == nil {
 111                 return name
 112         }
 113         return fmt.Sprintf("%s (%.3fs)", name, e.Finished.Sub(*e.Started).Seconds())
 114 }
 115
 116 func (e RunErr) Error() string {
 117         return fmt.Sprintf("%s: %s", e.Name(), e.Err)
 118 }
 119
 120 func mkdirs(pth string) error {
 121         if _, err := os.Stat(pth); err == nil {
 122                 return nil
 123         }
 124         return os.MkdirAll(pth, os.FileMode(0777))
 125 }
 126
 127 func isModified(cwd, redoDir, tgt string) (bool, *Inode, error) {
 128         fdDep, err := os.Open(path.Join(redoDir, tgt+DepSuffix))
 129         if err != nil {
 130                 if os.IsNotExist(err) {
 131                         return false, nil, nil
 132                 }
 133                 return false, nil, err
 134         }
 135         defer fdDep.Close()
 136         r := recfile.NewReader(fdDep)
 137         var ourInode *Inode
 138         for {
 139                 m, err := r.NextMap()
 140                 if err != nil {
 141                         if err == io.EOF {
 142                                 break
 143                         }
 144                         return false, nil, err
 145                 }
 146                 if m["Type"] != DepTypeIfchange || m["Target"] != tgt {
 147                         continue
 148                 }
 149                 fd, err := os.Open(path.Join(cwd, tgt))
 150                 if err != nil {
 151                         if os.IsNotExist(err) {
 152                                 return false, nil, nil
 153                         }
 154                         return false, nil, err
 155                 }
 156                 ourInode, err = inodeFromFile(fd)
 157                 fd.Close()
 158                 if err != nil {
 159                         return false, nil, err
 160                 }
 161                 theirInode, err := inodeFromRec(m)
 162                 if err != nil {
 163                         return false, nil, err
 164                 }
 165                 if !ourInode.Equals(theirInode) {
 166                         return true, ourInode, nil
 167                 }
 168                 break
 169         }
 170         return false, ourInode, nil
 171 }
 172
 173 func syncDir(dir string) error {
 174         fd, err := os.Open(dir)
 175         if err != nil {
 176                 return err
 177         }
 178         err = fd.Sync()
 179         fd.Close()
 180         return err
 181 }
 182
 183 func runScript(tgtOrig string, errs chan error, traced bool) error {
 184         cwd, tgt := cwdAndTgt(tgtOrig)
 185         redoDir := path.Join(cwd, RedoDir)
 186         if err := mkdirs(redoDir); err != nil {
 187                 return TgtErr{tgtOrig, err}
 188         }
 189
 190         // Acquire lock
 191         fdLock, err := os.OpenFile(
 192                 path.Join(redoDir, tgt+LockSuffix),
 193                 os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
 194                 os.FileMode(0666),
 195         )
 196         if err != nil {
 197                 return TgtErr{tgtOrig, err}
 198         }
 199         lockRelease := func() {
 200                 trace(CLock, "LOCK_UN: %s", fdLock.Name())
 201                 unix.Flock(int(fdLock.Fd()), unix.LOCK_UN)
 202                 fdLock.Close()
 203         }
 204         trace(CLock, "LOCK_NB: %s", fdLock.Name())
 205
 206         // Waiting for job completion, already taken by someone else
 207         if err = unix.Flock(int(fdLock.Fd()), unix.LOCK_EX|unix.LOCK_NB); err != nil {
 208                 if uintptr(err.(syscall.Errno)) != uintptr(unix.EWOULDBLOCK) {
 209                         fdLock.Close()
 210                         return TgtErr{tgtOrig, err}
 211                 }
 212                 Jobs.Add(1)
 213                 trace(CDebug, "waiting: %s", tgtOrig)
 214                 if FdStatus != nil {
 215                         FdStatus.Write([]byte{StatusWait})
 216                 }
 217                 go func() {
 218                         defer Jobs.Done()
 219                         trace(CLock, "LOCK_EX: %s", fdLock.Name())
 220                         unix.Flock(int(fdLock.Fd()), unix.LOCK_EX)
 221                         lockRelease()
 222                         trace(CDebug, "waiting done: %s", tgtOrig)
 223                         if FdStatus != nil {
 224                                 FdStatus.Write([]byte{StatusWaited})
 225                         }
 226                         var depInfo *DepInfo
 227                         fdDep, err := os.Open(path.Join(redoDir, tgt+DepSuffix))
 228                         if err != nil {
 229                                 if os.IsNotExist(err) {
 230                                         err = errors.New("was not built: no .rec")
 231                                 }
 232                                 goto Finish
 233                         }
 234                         defer fdDep.Close()
 235                         depInfo, err = depRead(fdDep)
 236                         if err != nil {
 237                                 goto Finish
 238                         }
 239                         if depInfo.build != BuildUUID {
 240                                 err = errors.New("was not built: build differs")
 241                         }
 242                 Finish:
 243                         if err != nil {
 244                                 err = TgtErr{tgtOrig, err}
 245                         }
 246                         errs <- err
 247                 }()
 248                 return nil
 249         }
 250
 251         // Check if target is not modified externally
 252         modified, inodePrev, err := isModified(cwd, redoDir, tgt)
 253         if err != nil {
 254                 lockRelease()
 255                 return TgtErr{tgtOrig, err}
 256         }
 257         if modified {
 258                 trace(CWarn, "%s externally modified: not redoing", tgtOrig)
 259                 lockRelease()
 260                 go func() {
 261                         errs <- nil
 262                 }()
 263                 return nil
 264         }
 265
 266         // Start preparing .rec
 267         fdDep, err := tempfile(redoDir, tgt+DepSuffix)
 268         if err != nil {
 269                 lockRelease()
 270                 return TgtErr{tgtOrig, err}
 271         }
 272         fdDepPath := fdDep.Name()
 273         cleanup := func() {
 274                 lockRelease()
 275                 fdDep.Close()
 276                 os.Remove(fdDep.Name())
 277         }
 278         if _, err = recfile.NewWriter(fdDep).WriteFields(
 279                 recfile.Field{Name: "Build", Value: BuildUUID},
 280         ); err != nil {
 281                 cleanup()
 282                 return TgtErr{tgtOrig, err}
 283         }
 284
 285         // Find .do
 286         doFile, upLevels, err := findDo(fdDep, cwd, tgt)
 287         if err != nil {
 288                 cleanup()
 289                 return TgtErr{tgtOrig, err}
 290         }
 291         if doFile == "" {
 292                 cleanup()
 293                 return TgtErr{tgtOrig, errors.New("no .do found")}
 294         }
 295
 296         // Determine basename and DIRPREFIX
 297         doFileRelPath := doFile
 298         ents := strings.Split(cwd, "/")
 299         ents = ents[len(ents)-upLevels:]
 300         dirPrefix := path.Join(ents...)
 301         cwdOrig := cwd
 302         for i := 0; i < upLevels; i++ {
 303                 cwd = path.Join(cwd, "..")
 304                 doFileRelPath = path.Join("..", doFileRelPath)
 305         }
 306         cwd = path.Clean(cwd)
 307         doFilePath := path.Join(cwd, doFile)
 308         basename := tgt
 309         runErr := RunErr{Tgt: tgtOrig}
 310         if strings.HasPrefix(doFile, "default.") {
 311                 basename = tgt[:len(tgt)-(len(doFile)-len("default.")-len(".do"))-1]
 312                 runErr.DoFile = doFileRelPath
 313         }
 314
 315         if err = writeDep(fdDep, cwdOrig, doFileRelPath); err != nil {
 316                 cleanup()
 317                 return TgtErr{tgtOrig, err}
 318         }
 319         fdDep.Close()
 320         trace(CWait, "%s", runErr.Name())
 321
 322         // Prepare command line
 323         var cmdName string
 324         var args []string
 325         if err = unix.Access(doFilePath, unix.X_OK); err == nil {
 326                 cmdName = doFilePath
 327                 args = make([]string, 0, 3)
 328         } else {
 329                 cmdName = "/bin/sh"
 330                 if traced || TracedAll {
 331                         args = append(args, "-ex")
 332                 } else {
 333                         args = append(args, "-e")
 334                 }
 335                 args = append(args, doFile)
 336         }
 337
 338         // Temporary file for stdout
 339         fdStdout, err := tempfile(cwdOrig, tgt)
 340         if err != nil {
 341                 cleanup()
 342                 return TgtErr{tgtOrig, err}
 343         }
 344         stdoutPath := fdStdout.Name()
 345         fdStdout.Close()
 346         tmpPath := stdoutPath + ".3" // and for $3
 347         tmpPathRel, err := filepath.Rel(cwd, tmpPath)
 348         if err != nil {
 349                 panic(err)
 350         }
 351         args = append(
 352                 args,
 353                 path.Join(dirPrefix, tgt),
 354                 path.Join(dirPrefix, basename),
 355                 tmpPathRel,
 356         )
 357
 358         cmd := exec.Command(cmdName, args...)
 359         cmd.Dir = cwd
 360         // cmd.Stdin reads from /dev/null by default
 361         cmd.Env = append(os.Environ(), fmt.Sprintf("%s=%d", EnvLevel, Level+1))
 362         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDirPrefix, dirPrefix))
 363         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvBuildUUID, BuildUUID))
 364
 365         childStderrPrefix := tempsuffix()
 366         cmd.Env = append(cmd.Env, fmt.Sprintf(
 367                 "%s=%s", EnvStderrPrefix, childStderrPrefix,
 368         ))
 369
 370         fdNum := 0
 371         cmd.ExtraFiles = append(cmd.ExtraFiles, FdOODTgts)
 372         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvOODTgtsFd, 3+fdNum))
 373         fdNum++
 374         cmd.ExtraFiles = append(cmd.ExtraFiles, FdOODTgtsLock)
 375         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvOODTgtsLockFd, 3+fdNum))
 376         fdNum++
 377
 378         if FdStatus == nil {
 379                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvStatusFd))
 380         } else {
 381                 cmd.ExtraFiles = append(cmd.ExtraFiles, FdStatus)
 382                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvStatusFd, 3+fdNum))
 383                 fdNum++
 384         }
 385
 386         // Preparing stderr
 387         var fdStderr *os.File
 388         if StderrKeep {
 389                 fdStderr, err = os.OpenFile(
 390                         path.Join(redoDir, tgt+LogSuffix),
 391                         os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
 392                         os.FileMode(0666),
 393                 )
 394                 if err != nil {
 395                         cleanup()
 396                         return TgtErr{tgtOrig, err}
 397                 }
 398         }
 399         shCtx := fmt.Sprintf(
 400                 "sh: %s: %s %s cwd:%s dirprefix:%s",
 401                 tgtOrig, cmdName, args, cwd, dirPrefix,
 402         )
 403         trace(CDebug, "%s", shCtx)
 404
 405         Jobs.Add(1)
 406         go func() {
 407                 jsToken := jsAcquire(shCtx)
 408                 if JSR == nil {
 409                         // infinite jobs
 410                         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvJobs))
 411                 } else {
 412                         cmd.ExtraFiles = append(cmd.ExtraFiles, JSR)
 413                         cmd.ExtraFiles = append(cmd.ExtraFiles, JSW)
 414                         makeFlags := fmt.Sprintf(
 415                                 "%s %s%d,%d", MakeFlags, MakeJSArg, 3+fdNum+0, 3+fdNum+1,
 416                         )
 417                         makeFlags = strings.Trim(makeFlags, " ")
 418                         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", MakeFlagsName, makeFlags))
 419                         fdNum += 2
 420                         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvJSToken, jsToken))
 421                 }
 422
 423                 if FdStatus != nil {
 424                         FdStatus.Write([]byte{StatusRun})
 425                 }
 426
 427                 var finished time.Time
 428                 var exitErr *exec.ExitError
 429                 started := time.Now()
 430                 runErr.Started = &started
 431                 fdStdout, err = os.OpenFile(stdoutPath, os.O_RDWR, os.FileMode(0666))
 432                 if err != nil {
 433                         runErr.Err = err
 434                         errs <- runErr
 435                         return
 436                 }
 437                 cmd.Stdout = fdStdout
 438                 fdDep, err = os.OpenFile(fdDepPath, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
 439                 if err != nil {
 440                         runErr.Err = err
 441                         errs <- runErr
 442                         return
 443                 }
 444                 cmd.ExtraFiles = append(cmd.ExtraFiles, fdDep)
 445                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvDepFd, 3+fdNum))
 446                 fdNum++
 447                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDepCwd, cwd))
 448
 449                 defer func() {
 450                         jsRelease(shCtx, jsToken)
 451                         fdDep.Close()
 452                         fdStdout.Close()
 453                         if fdStderr != nil {
 454                                 fdStderr.Close()
 455                                 logRecPath := path.Join(redoDir, tgt+LogRecSuffix)
 456                                 if fdStderr, err = os.OpenFile(
 457                                         logRecPath,
 458                                         os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
 459                                         os.FileMode(0666),
 460                                 ); err == nil {
 461                                         fields := []recfile.Field{
 462                                                 {Name: "Build", Value: BuildUUID},
 463                                                 {Name: "PPID", Value: strconv.Itoa(os.Getpid())},
 464                                                 {Name: "Cwd", Value: cwd},
 465                                         }
 466                                         if cmd.Process != nil {
 467                                                 fields = append(fields, recfile.Field{
 468                                                         Name: "PID", Value: strconv.Itoa(cmd.Process.Pid),
 469                                                 })
 470                                         }
 471                                         ts := new(tai64n.TAI64N)
 472                                         ts.FromTime(started)
 473                                         fields = append(fields,
 474                                                 recfile.Field{Name: "Started", Value: tai64n.Encode(ts[:])},
 475                                         )
 476                                         ts.FromTime(finished)
 477                                         fields = append(fields,
 478                                                 recfile.Field{Name: "Finished", Value: tai64n.Encode(ts[:])})
 479                                         fields = append(fields, recfile.Field{
 480                                                 Name:  "Duration",
 481                                                 Value: strconv.FormatInt(finished.Sub(started).Nanoseconds(), 10),
 482                                         })
 483                                         fields = append(fields, recfile.Field{Name: "Cmd", Value: cmdName})
 484                                         for _, arg := range args {
 485                                                 fields = append(fields, recfile.Field{Name: "Arg", Value: arg})
 486                                         }
 487                                         for _, env := range cmd.Env {
 488                                                 fields = append(fields, recfile.Field{Name: "Env", Value: env})
 489                                         }
 490                                         if exitErr != nil {
 491                                                 fields = append(fields, recfile.Field{
 492                                                         Name:  "ExitCode",
 493                                                         Value: strconv.Itoa(exitErr.ProcessState.ExitCode()),
 494                                                 })
 495                                         }
 496                                         w := bufio.NewWriter(fdStderr)
 497
 498                                         var depInfo *DepInfo
 499                                         fdDep, err := os.Open(fdDepPath)
 500                                         if err != nil {
 501                                                 goto Err
 502                                         }
 503                                         depInfo, err = depRead(fdDep)
 504                                         fdDep.Close()
 505                                         if err != nil {
 506                                                 goto Err
 507                                         }
 508                                         for _, dep := range depInfo.ifchanges {
 509                                                 fields = append(fields, recfile.Field{
 510                                                         Name:  "Ifchange",
 511                                                         Value: dep["Target"],
 512                                                 })
 513                                         }
 514                                         _, err = recfile.NewWriter(w).WriteFields(fields...)
 515                                         if err != nil {
 516                                                 goto Err
 517                                         }
 518                                         err = w.Flush()
 519                                 Err:
 520                                         if err != nil {
 521                                                 log.Println(err)
 522                                                 os.Remove(logRecPath)
 523                                         }
 524                                         fdStderr.Close()
 525                                 } else {
 526                                         log.Println("can not open", logRecPath, ":", err)
 527                                 }
 528                         }
 529                         lockRelease()
 530                         os.Remove(fdDep.Name())
 531                         os.Remove(fdStdout.Name())
 532                         os.Remove(tmpPath)
 533                         os.Remove(fdLock.Name())
 534                         if FdStatus != nil {
 535                                 FdStatus.Write([]byte{StatusDone})
 536                         }
 537                         Jobs.Done()
 538                 }()
 539                 stderr, err := cmd.StderrPipe()
 540                 if err != nil {
 541                         runErr.Err = err
 542                         errs <- runErr
 543                         return
 544                 }
 545                 started = time.Now()
 546                 err = cmd.Start()
 547                 if err != nil {
 548                         runErr.Err = err
 549                         errs <- runErr
 550                         return
 551                 }
 552                 RunningProcsM.Lock()
 553                 RunningProcs[cmd.Process.Pid] = cmd.Process
 554                 RunningProcsM.Unlock()
 555                 pid := fmt.Sprintf("[%d]", cmd.Process.Pid)
 556                 trace(CDebug, "%s runs %s", tgtOrig, pid)
 557
 558                 stderrTerm := make(chan struct{}, 0)
 559                 go func() {
 560                         scanner := bufio.NewScanner(stderr)
 561                         var line string
 562                         ts := new(tai64n.TAI64N)
 563                         for scanner.Scan() {
 564                                 line = scanner.Text()
 565                                 if strings.HasPrefix(line, childStderrPrefix) {
 566                                         line = line[len(childStderrPrefix):]
 567                                         os.Stderr.WriteString(StderrPrefix + line + "\n")
 568                                         continue
 569                                 }
 570                                 if fdStderr != nil {
 571                                         ts.FromTime(time.Now())
 572                                         LogMutex.Lock()
 573                                         fmt.Fprintln(fdStderr, tai64n.Encode(ts[:]), line)
 574                                         LogMutex.Unlock()
 575                                 }
 576                                 if StderrSilent {
 577                                         continue
 578                                 }
 579                                 if MyPid == 0 {
 580                                         trace(CNone, "%s", line)
 581                                 } else {
 582                                         trace(CNone, "%s %s", pid, line)
 583                                 }
 584                         }
 585                         close(stderrTerm)
 586                 }()
 587
 588                 // Wait for job completion
 589                 <-stderrTerm
 590                 err = cmd.Wait()
 591                 RunningProcsM.Lock()
 592                 delete(RunningProcs, cmd.Process.Pid)
 593                 RunningProcsM.Unlock()
 594                 finished = time.Now()
 595                 runErr.Finished = &finished
 596                 if err != nil {
 597                         exitErr = err.(*exec.ExitError)
 598                         runErr.Err = err
 599                         errs <- runErr
 600                         return
 601                 }
 602
 603                 // Was $1 touched?
 604                 if fd, err := os.Open(path.Join(cwdOrig, tgt)); err == nil {
 605                         errTouched := errors.New("$1 was explicitly touched")
 606                         if inodePrev == nil {
 607                                 fd.Close()
 608                                 runErr.Err = errTouched
 609                                 errs <- runErr
 610                                 return
 611                         } else {
 612                                 inode, err := inodeFromFile(fd)
 613                                 fd.Close()
 614                                 if err != nil {
 615                                         runErr.Err = err
 616                                         errs <- runErr
 617                                         return
 618                                 }
 619                                 if !inode.Equals(inodePrev) {
 620                                         runErr.Err = errTouched
 621                                         errs <- runErr
 622                                         return
 623                                 }
 624                         }
 625                 }
 626
 627                 if inodePrev != nil {
 628                         if fd, err := os.Open(path.Join(cwdOrig, tgt)); err == nil {
 629                                 inode, err := inodeFromFile(fd)
 630                                 fd.Close()
 631                                 if err == nil && !inode.Equals(inodePrev) {
 632                                         runErr.Err = errors.New("$1 was explicitly touched")
 633                                         errs <- runErr
 634                                         return
 635                                 }
 636                         }
 637                 }
 638
 639                 // Does it produce both stdout and tmp?
 640                 fiStdout, err := os.Stat(fdStdout.Name())
 641                 if err != nil {
 642                         runErr.Err = err
 643                         errs <- runErr
 644                         return
 645                 }
 646                 tmpExists := false
 647                 _, err = os.Stat(tmpPath)
 648                 if err == nil {
 649                         if fiStdout.Size() > 0 {
 650                                 runErr.Err = errors.New("created both tmp and stdout")
 651                                 errs <- runErr
 652                                 return
 653                         }
 654                         tmpExists = true
 655                 } else if !os.IsNotExist(err) {
 656                         runErr.Err = err
 657                         errs <- runErr
 658                         return
 659                 }
 660
 661                 // Determine what file we must process at last
 662                 var fd *os.File
 663                 if tmpExists {
 664                         fd, err = os.Open(tmpPath)
 665                         if err != nil {
 666                                 goto Finish
 667                         }
 668                         defer fd.Close()
 669                 } else if fiStdout.Size() > 0 {
 670                         fd = fdStdout
 671                 }
 672
 673                 // Do we need to ifcreate it, of ifchange with renaming?
 674                 if fd == nil {
 675                         os.Remove(path.Join(cwdOrig, tgt))
 676                         err = ifcreate(fdDep, tgt)
 677                         if err != nil {
 678                                 goto Finish
 679                         }
 680                 } else {
 681                         if !NoSync {
 682                                 err = fd.Sync()
 683                                 if err != nil {
 684                                         goto Finish
 685                                 }
 686                         }
 687                         err = os.Rename(fd.Name(), path.Join(cwdOrig, tgt))
 688                         if err != nil {
 689                                 goto Finish
 690                         }
 691                         if !NoSync {
 692                                 err = syncDir(cwdOrig)
 693                                 if err != nil {
 694                                         goto Finish
 695                                 }
 696                         }
 697                         err = writeDep(fdDep, cwdOrig, tgt)
 698                         if err != nil {
 699                                 goto Finish
 700                         }
 701                 }
 702
 703                 // Commit .rec
 704                 if !NoSync {
 705                         err = fdDep.Sync()
 706                         if err != nil {
 707                                 goto Finish
 708                         }
 709                 }
 710                 fdDepPath = path.Join(redoDir, tgt+DepSuffix)
 711                 err = os.Rename(fdDep.Name(), fdDepPath)
 712                 if err != nil {
 713                         goto Finish
 714                 }
 715                 if !NoSync {
 716                         err = syncDir(redoDir)
 717                         if err != nil {
 718                                 goto Finish
 719                         }
 720                 }
 721         Finish:
 722                 runErr.Err = err
 723                 errs <- runErr
 724         }()
 725         return nil
 726 }
 727
 728 func isOkRun(err error) bool {
 729         if err == nil {
 730                 return true
 731         }
 732         if err, ok := err.(RunErr); ok && err.Err == nil {
 733                 trace(CRedo, "%s", err.Name())
 734                 return true
 735         }
 736         trace(CErr, "%s", err)
 737         return false
 738 }