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         "os"
  29         "os/exec"
  30         "path"
  31         "path/filepath"
  32         "strings"
  33         "sync"
  34         "syscall"
  35         "time"
  36
  37         "go.cypherpunks.ru/recfile"
  38         "go.cypherpunks.ru/tai64n/v2"
  39         "golang.org/x/sys/unix"
  40 )
  41
  42 const (
  43         EnvDepFd        = "REDO_DEP_FD"
  44         EnvDirPrefix    = "REDO_DIRPREFIX"
  45         EnvBuildUUID    = "REDO_BUILD_UUID"
  46         EnvStderrPrefix = "REDO_STDERR_PREFIX"
  47         EnvTrace        = "REDO_TRACE"
  48         EnvStderrKeep   = "REDO_LOGS"
  49         EnvStderrSilent = "REDO_SILENT"
  50         EnvNoSync       = "REDO_NO_SYNC"
  51
  52         RedoDir    = ".redo"
  53         LockSuffix = ".lock"
  54         DepSuffix  = ".rec"
  55         TmpPrefix  = ".redo."
  56         LogSuffix  = ".log"
  57 )
  58
  59 var (
  60         NoSync       bool = false
  61         StderrKeep   bool = false
  62         StderrSilent bool = false
  63         StderrPrefix string
  64         Jobs         sync.WaitGroup
  65
  66         flagTrace        = flag.Bool("x", false, "trace (sh -x) current targets")
  67         flagTraceAll     = flag.Bool("xx", false, fmt.Sprintf("trace (sh -x) all targets (%s=1)", EnvTrace))
  68         flagStderrKeep   = flag.Bool("logs", false, fmt.Sprintf("keep job's stderr (%s=1)", EnvStderrKeep))
  69         flagStderrSilent = flag.Bool("silent", false, fmt.Sprintf("do not print job's stderr (%s=1)", EnvStderrSilent))
  70
  71         TracedAll bool
  72 )
  73
  74 type RunErr struct {
  75         Tgt      string
  76         DoFile   string
  77         Started  *time.Time
  78         Finished *time.Time
  79         Err      error
  80 }
  81
  82 func (e *RunErr) Name() string {
  83         var name string
  84         if e.DoFile == "" {
  85                 name = e.Tgt
  86         } else {
  87                 name = fmt.Sprintf("%s (%s)", e.Tgt, e.DoFile)
  88         }
  89         if e.Finished == nil {
  90                 return name
  91         }
  92         return fmt.Sprintf("%s (%.3fs)", name, e.Finished.Sub(*e.Started).Seconds())
  93 }
  94
  95 func (e RunErr) Error() string {
  96         return fmt.Sprintf("%s: %s", e.Name(), e.Err)
  97 }
  98
  99 func mkdirs(pth string) error {
 100         if _, err := os.Stat(pth); err == nil {
 101                 return nil
 102         }
 103         return os.MkdirAll(pth, os.FileMode(0777))
 104 }
 105
 106 func isModified(cwd, redoDir, tgt string) (bool, *Inode, error) {
 107         fdDep, err := os.Open(path.Join(redoDir, tgt+DepSuffix))
 108         if err != nil {
 109                 if os.IsNotExist(err) {
 110                         return false, nil, nil
 111                 }
 112                 return false, nil, err
 113         }
 114         defer fdDep.Close()
 115         r := recfile.NewReader(fdDep)
 116         var ourInode *Inode
 117         for {
 118                 m, err := r.NextMap()
 119                 if err != nil {
 120                         if err == io.EOF {
 121                                 break
 122                         }
 123                         return false, nil, err
 124                 }
 125                 if m["Target"] != tgt {
 126                         continue
 127                 }
 128                 fd, err := os.Open(path.Join(cwd, tgt))
 129                 if err != nil {
 130                         if os.IsNotExist(err) {
 131                                 return false, nil, nil
 132                         }
 133                         return false, nil, err
 134                 }
 135                 ourInode, err = inodeFromFile(fd)
 136                 fd.Close()
 137                 if err != nil {
 138                         return false, nil, err
 139                 }
 140                 theirInode, err := inodeFromRec(m)
 141                 if err != nil {
 142                         return false, nil, err
 143                 }
 144                 if !ourInode.Equals(theirInode) {
 145                         return true, ourInode, nil
 146                 }
 147                 break
 148         }
 149         return false, ourInode, nil
 150 }
 151
 152 func syncDir(dir string) error {
 153         fd, err := os.Open(dir)
 154         if err != nil {
 155                 return err
 156         }
 157         err = fd.Sync()
 158         fd.Close()
 159         return err
 160 }
 161
 162 func runScript(tgtOrig string, errs chan error, traced bool) error {
 163         cwd, tgt := cwdAndTgt(tgtOrig)
 164         redoDir := path.Join(cwd, RedoDir)
 165         if err := mkdirs(redoDir); err != nil {
 166                 return TgtErr{tgtOrig, err}
 167         }
 168
 169         // Acquire lock
 170         fdLock, err := os.OpenFile(
 171                 path.Join(redoDir, tgt+LockSuffix),
 172                 os.O_WRONLY|os.O_TRUNC|os.O_CREATE,
 173                 os.FileMode(0666),
 174         )
 175         if err != nil {
 176                 return TgtErr{tgtOrig, err}
 177         }
 178         lockRelease := func() {
 179                 trace(CLock, "LOCK_UN: %s", fdLock.Name())
 180                 unix.Flock(int(fdLock.Fd()), unix.LOCK_UN)
 181                 fdLock.Close()
 182         }
 183         trace(CLock, "LOCK_NB: %s", fdLock.Name())
 184
 185         // Waiting for job completion, already taken by someone else
 186         if err = unix.Flock(int(fdLock.Fd()), unix.LOCK_EX|unix.LOCK_NB); err != nil {
 187                 if uintptr(err.(syscall.Errno)) != uintptr(unix.EWOULDBLOCK) {
 188                         fdLock.Close()
 189                         return TgtErr{tgtOrig, err}
 190                 }
 191                 Jobs.Add(1)
 192                 trace(CDebug, "waiting: %s", tgtOrig)
 193                 if FdStatus != nil {
 194                         FdStatus.Write([]byte{StatusWait})
 195                 }
 196                 go func() {
 197                         defer Jobs.Done()
 198                         trace(CLock, "LOCK_EX: %s", fdLock.Name())
 199                         unix.Flock(int(fdLock.Fd()), unix.LOCK_EX)
 200                         lockRelease()
 201                         trace(CDebug, "waiting done: %s", tgtOrig)
 202                         if FdStatus != nil {
 203                                 FdStatus.Write([]byte{StatusWaited})
 204                         }
 205                         var depInfo *DepInfo
 206                         fdDep, err := os.Open(path.Join(redoDir, tgt+DepSuffix))
 207                         if err != nil {
 208                                 if os.IsNotExist(err) {
 209                                         err = errors.New("was not built: no .rec")
 210                                 }
 211                                 goto Finish
 212                         }
 213                         defer fdDep.Close()
 214                         depInfo, err = depRead(fdDep)
 215                         if err != nil {
 216                                 goto Finish
 217                         }
 218                         if depInfo.build != BuildUUID {
 219                                 err = errors.New("was not built: build differs")
 220                         }
 221                 Finish:
 222                         if err != nil {
 223                                 err = TgtErr{tgtOrig, err}
 224                         }
 225                         errs <- err
 226                 }()
 227                 return nil
 228         }
 229
 230         // Check if target is not modified externally
 231         modified, inodePrev, err := isModified(cwd, redoDir, tgt)
 232         if err != nil {
 233                 lockRelease()
 234                 return TgtErr{tgtOrig, err}
 235         }
 236         if modified {
 237                 trace(CWarn, "%s externally modified: not redoing", tgtOrig)
 238                 lockRelease()
 239                 go func() {
 240                         errs <- nil
 241                 }()
 242                 return nil
 243         }
 244
 245         // Start preparing .rec
 246         fdDep, err := tempfile(redoDir, tgt+DepSuffix)
 247         if err != nil {
 248                 lockRelease()
 249                 return TgtErr{tgtOrig, err}
 250         }
 251         fdDepPath := fdDep.Name()
 252         cleanup := func() {
 253                 lockRelease()
 254                 fdDep.Close()
 255                 os.Remove(fdDep.Name())
 256         }
 257         if _, err = recfile.NewWriter(fdDep).WriteFields(
 258                 recfile.Field{Name: "Build", Value: BuildUUID},
 259         ); err != nil {
 260                 cleanup()
 261                 return TgtErr{tgtOrig, err}
 262         }
 263
 264         // Find .do
 265         doFile, upLevels, err := findDo(fdDep, cwd, tgt)
 266         if err != nil {
 267                 cleanup()
 268                 return TgtErr{tgtOrig, err}
 269         }
 270         if doFile == "" {
 271                 cleanup()
 272                 return TgtErr{tgtOrig, errors.New("no .do found")}
 273         }
 274
 275         // Determine basename and DIRPREFIX
 276         doFileRelPath := doFile
 277         ents := strings.Split(cwd, "/")
 278         ents = ents[len(ents)-upLevels:]
 279         dirPrefix := path.Join(ents...)
 280         cwdOrig := cwd
 281         for i := 0; i < upLevels; i++ {
 282                 cwd = path.Join(cwd, "..")
 283                 doFileRelPath = path.Join("..", doFileRelPath)
 284         }
 285         cwd = path.Clean(cwd)
 286         doFilePath := path.Join(cwd, doFile)
 287         basename := tgt
 288         runErr := RunErr{Tgt: tgtOrig}
 289         if strings.HasPrefix(doFile, "default.") {
 290                 basename = tgt[:len(tgt)-(len(doFile)-len("default.")-len(".do"))-1]
 291                 runErr.DoFile = doFileRelPath
 292         }
 293
 294         if err = writeDep(fdDep, cwdOrig, doFileRelPath); err != nil {
 295                 cleanup()
 296                 return TgtErr{tgtOrig, err}
 297         }
 298         fdDep.Close()
 299         trace(CWait, "%s", runErr.Name())
 300
 301         // Prepare command line
 302         var cmdName string
 303         var args []string
 304         if err = unix.Access(doFilePath, unix.X_OK); err == nil {
 305                 cmdName = doFilePath
 306                 args = make([]string, 0, 3)
 307         } else {
 308                 cmdName = "/bin/sh"
 309                 if traced || TracedAll {
 310                         args = append(args, "-ex")
 311                 } else {
 312                         args = append(args, "-e")
 313                 }
 314                 args = append(args, doFile)
 315         }
 316
 317         // Temporary file for stdout
 318         fdStdout, err := tempfile(cwdOrig, tgt)
 319         if err != nil {
 320                 cleanup()
 321                 return TgtErr{tgtOrig, err}
 322         }
 323         stdoutPath := fdStdout.Name()
 324         fdStdout.Close()
 325         tmpPath := stdoutPath + ".3" // and for $3
 326         tmpPathRel, err := filepath.Rel(cwd, tmpPath)
 327         if err != nil {
 328                 panic(err)
 329         }
 330         args = append(
 331                 args,
 332                 path.Join(dirPrefix, tgt),
 333                 path.Join(dirPrefix, basename),
 334                 tmpPathRel,
 335         )
 336
 337         cmd := exec.Command(cmdName, args...)
 338         cmd.Dir = cwd
 339         // cmd.Stdin reads from /dev/null by default
 340         cmd.Env = append(os.Environ(), fmt.Sprintf("%s=%d", EnvLevel, Level+1))
 341         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvDirPrefix, dirPrefix))
 342         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", EnvBuildUUID, BuildUUID))
 343
 344         childStderrPrefix := tempsuffix()
 345         cmd.Env = append(cmd.Env, fmt.Sprintf(
 346                 "%s=%s", EnvStderrPrefix, childStderrPrefix,
 347         ))
 348
 349         fdNum := 0
 350         cmd.ExtraFiles = append(cmd.ExtraFiles, FdOODTgts)
 351         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvOODTgtsFd, 3+fdNum))
 352         fdNum++
 353         cmd.ExtraFiles = append(cmd.ExtraFiles, FdOODTgtsLock)
 354         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvOODTgtsLockFd, 3+fdNum))
 355         fdNum++
 356
 357         if FdStatus == nil {
 358                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvStatusFd))
 359         } else {
 360                 cmd.ExtraFiles = append(cmd.ExtraFiles, FdStatus)
 361                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvStatusFd, 3+fdNum))
 362                 fdNum++
 363         }
 364
 365         if JSR == nil {
 366                 // infinite jobs
 367                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvJSFd))
 368         } else {
 369                 cmd.ExtraFiles = append(cmd.ExtraFiles, JSR)
 370                 cmd.ExtraFiles = append(cmd.ExtraFiles, JSW)
 371                 cmd.Env = append(cmd.Env, fmt.Sprintf(
 372                         "%s=%d,%d", EnvJSFd, 3+fdNum+0, 3+fdNum+1,
 373                 ))
 374                 fdNum += 2
 375         }
 376
 377         // Preparing stderr
 378         var fdStderr *os.File
 379         if StderrKeep {
 380                 fdStderr, err = os.OpenFile(
 381                         path.Join(redoDir, tgt+LogSuffix),
 382                         os.O_WRONLY|os.O_CREATE,
 383                         os.FileMode(0666),
 384                 )
 385                 if err != nil {
 386                         cleanup()
 387                         return TgtErr{tgtOrig, err}
 388                 }
 389                 fdStderr.Truncate(0)
 390         }
 391         shCtx := fmt.Sprintf(
 392                 "sh: %s: %s %s cwd:%s dirprefix:%s",
 393                 tgtOrig, cmdName, args, cwd, dirPrefix,
 394         )
 395         trace(CDebug, "%s", shCtx)
 396
 397         Jobs.Add(1)
 398         go func() {
 399                 jsAcquire(shCtx)
 400                 if FdStatus != nil {
 401                         FdStatus.Write([]byte{StatusRun})
 402                 }
 403
 404                 started := time.Now()
 405                 runErr.Started = &started
 406                 fdStdout, err = os.OpenFile(stdoutPath, os.O_RDWR, os.FileMode(0666))
 407                 if err != nil {
 408                         runErr.Err = err
 409                         errs <- runErr
 410                         return
 411                 }
 412                 cmd.Stdout = fdStdout
 413                 fdDep, err = os.OpenFile(fdDepPath, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
 414                 if err != nil {
 415                         runErr.Err = err
 416                         errs <- runErr
 417                         return
 418                 }
 419                 cmd.ExtraFiles = append(cmd.ExtraFiles, fdDep)
 420                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvDepFd, 3+fdNum))
 421                 fdNum++
 422
 423                 defer func() {
 424                         jsRelease(shCtx)
 425                         lockRelease()
 426                         fdDep.Close()
 427                         fdStdout.Close()
 428                         if fdStderr != nil {
 429                                 fdStderr.Close()
 430                         }
 431                         os.Remove(fdDep.Name())
 432                         os.Remove(fdStdout.Name())
 433                         os.Remove(tmpPath)
 434                         os.Remove(fdLock.Name())
 435                         if FdStatus != nil {
 436                                 FdStatus.Write([]byte{StatusDone})
 437                         }
 438                         Jobs.Done()
 439                 }()
 440                 stderr, err := cmd.StderrPipe()
 441                 if err != nil {
 442                         runErr.Err = err
 443                         errs <- runErr
 444                         return
 445                 }
 446                 started = time.Now()
 447                 err = cmd.Start()
 448                 if err != nil {
 449                         runErr.Err = err
 450                         errs <- runErr
 451                         return
 452                 }
 453                 pid := fmt.Sprintf("[%d]", cmd.Process.Pid)
 454                 trace(CDebug, "%s runs %s", tgtOrig, pid)
 455
 456                 stderrTerm := make(chan struct{}, 0)
 457                 go func() {
 458                         scanner := bufio.NewScanner(stderr)
 459                         var line string
 460                         ts := new(tai64n.TAI64N)
 461                         for scanner.Scan() {
 462                                 line = scanner.Text()
 463                                 if strings.HasPrefix(line, childStderrPrefix) {
 464                                         line = line[len(childStderrPrefix):]
 465                                         os.Stderr.WriteString(StderrPrefix + line + "\n")
 466                                         continue
 467                                 }
 468                                 if fdStderr != nil {
 469                                         ts.FromTime(time.Now())
 470                                         LogMutex.Lock()
 471                                         fmt.Fprintln(fdStderr, tai64n.Encode(ts[:]), line)
 472                                         LogMutex.Unlock()
 473                                 }
 474                                 if StderrSilent {
 475                                         continue
 476                                 }
 477                                 if MyPid == 0 {
 478                                         trace(CNone, "%s", line)
 479                                 } else {
 480                                         trace(CNone, "%s %s", pid, line)
 481                                 }
 482                         }
 483                         close(stderrTerm)
 484                 }()
 485
 486                 // Wait for job completion
 487                 <-stderrTerm
 488                 err = cmd.Wait()
 489                 finished := time.Now()
 490                 runErr.Finished = &finished
 491                 if err != nil {
 492                         runErr.Err = err
 493                         errs <- runErr
 494                         return
 495                 }
 496
 497                 // Was $1 touched?
 498                 if inodePrev != nil {
 499                         if fd, err := os.Open(path.Join(cwdOrig, tgt)); err == nil {
 500                                 inode, err := inodeFromFile(fd)
 501                                 fd.Close()
 502                                 if err == nil && !inode.Equals(inodePrev) {
 503                                         runErr.Err = errors.New("$1 was explicitly touched")
 504                                         errs <- runErr
 505                                         return
 506                                 }
 507                         }
 508                 }
 509
 510                 // Does it produce both stdout and tmp?
 511                 fiStdout, err := os.Stat(fdStdout.Name())
 512                 if err != nil {
 513                         runErr.Err = err
 514                         errs <- runErr
 515                         return
 516                 }
 517                 tmpExists := false
 518                 _, err = os.Stat(tmpPath)
 519                 if err == nil {
 520                         if fiStdout.Size() > 0 {
 521                                 runErr.Err = errors.New("created both tmp and stdout")
 522                                 errs <- runErr
 523                                 return
 524                         }
 525                         tmpExists = true
 526                 } else if !os.IsNotExist(err) {
 527                         runErr.Err = err
 528                         errs <- runErr
 529                         return
 530                 }
 531
 532                 // Determine what file we must process at last
 533                 var fd *os.File
 534                 if tmpExists {
 535                         fd, err = os.Open(tmpPath)
 536                         if err != nil {
 537                                 goto Finish
 538                         }
 539                         defer fd.Close()
 540                 } else if fiStdout.Size() > 0 {
 541                         fd = fdStdout
 542                 }
 543
 544                 // Do we need to ifcreate it, of ifchange with renaming?
 545                 if fd == nil {
 546                         os.Remove(path.Join(cwdOrig, tgt))
 547                         err = ifcreate(fdDep, tgt)
 548                         if err != nil {
 549                                 goto Finish
 550                         }
 551                 } else {
 552                         if !NoSync {
 553                                 err = fd.Sync()
 554                                 if err != nil {
 555                                         goto Finish
 556                                 }
 557                         }
 558                         err = os.Rename(fd.Name(), path.Join(cwdOrig, tgt))
 559                         if err != nil {
 560                                 goto Finish
 561                         }
 562                         if !NoSync {
 563                                 err = syncDir(cwdOrig)
 564                                 if err != nil {
 565                                         goto Finish
 566                                 }
 567                         }
 568                         err = writeDep(fdDep, cwdOrig, tgt)
 569                         if err != nil {
 570                                 goto Finish
 571                         }
 572                 }
 573
 574                 // Commit .rec
 575                 if !NoSync {
 576                         err = fdDep.Sync()
 577                         if err != nil {
 578                                 goto Finish
 579                         }
 580                 }
 581                 err = os.Rename(fdDep.Name(), path.Join(redoDir, tgt+DepSuffix))
 582                 if err != nil {
 583                         goto Finish
 584                 }
 585                 if !NoSync {
 586                         err = syncDir(redoDir)
 587                         if err != nil {
 588                                 goto Finish
 589                         }
 590                 }
 591         Finish:
 592                 runErr.Err = err
 593                 errs <- runErr
 594         }()
 595         return nil
 596 }
 597
 598 func isOkRun(err error) bool {
 599         if err == nil {
 600                 return true
 601         }
 602         if err, ok := err.(RunErr); ok && err.Err == nil {
 603                 trace(CRedo, "%s", err.Name())
 604                 return true
 605         }
 606         trace(CErr, "%s", err)
 607         return false
 608 }