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         // Preparing stderr
 366         var fdStderr *os.File
 367         if StderrKeep {
 368                 fdStderr, err = os.OpenFile(
 369                         path.Join(redoDir, tgt+LogSuffix),
 370                         os.O_WRONLY|os.O_CREATE,
 371                         os.FileMode(0666),
 372                 )
 373                 if err != nil {
 374                         cleanup()
 375                         return TgtErr{tgtOrig, err}
 376                 }
 377                 fdStderr.Truncate(0)
 378         }
 379         shCtx := fmt.Sprintf(
 380                 "sh: %s: %s %s cwd:%s dirprefix:%s",
 381                 tgtOrig, cmdName, args, cwd, dirPrefix,
 382         )
 383         trace(CDebug, "%s", shCtx)
 384
 385         Jobs.Add(1)
 386         go func() {
 387                 jsToken := jsAcquire(shCtx)
 388                 if JSR == nil {
 389                         // infinite jobs
 390                         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=NO", EnvJobs))
 391                 } else {
 392                         cmd.ExtraFiles = append(cmd.ExtraFiles, JSR)
 393                         cmd.ExtraFiles = append(cmd.ExtraFiles, JSW)
 394                         cmd.Env = append(cmd.Env, fmt.Sprintf(
 395                                 "%s=%s %s%d,%d",
 396                                 MakeFlagsName, MakeFlags, MakeJSArg, 3+fdNum+0, 3+fdNum+1,
 397                         ))
 398                         fdNum += 2
 399                         cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvJSToken, jsToken))
 400                 }
 401
 402                 if FdStatus != nil {
 403                         FdStatus.Write([]byte{StatusRun})
 404                 }
 405
 406                 started := time.Now()
 407                 runErr.Started = &started
 408                 fdStdout, err = os.OpenFile(stdoutPath, os.O_RDWR, os.FileMode(0666))
 409                 if err != nil {
 410                         runErr.Err = err
 411                         errs <- runErr
 412                         return
 413                 }
 414                 cmd.Stdout = fdStdout
 415                 fdDep, err = os.OpenFile(fdDepPath, os.O_WRONLY|os.O_APPEND, os.FileMode(0666))
 416                 if err != nil {
 417                         runErr.Err = err
 418                         errs <- runErr
 419                         return
 420                 }
 421                 cmd.ExtraFiles = append(cmd.ExtraFiles, fdDep)
 422                 cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%d", EnvDepFd, 3+fdNum))
 423                 fdNum++
 424
 425                 defer func() {
 426                         jsRelease(shCtx, jsToken)
 427                         lockRelease()
 428                         fdDep.Close()
 429                         fdStdout.Close()
 430                         if fdStderr != nil {
 431                                 fdStderr.Close()
 432                         }
 433                         os.Remove(fdDep.Name())
 434                         os.Remove(fdStdout.Name())
 435                         os.Remove(tmpPath)
 436                         os.Remove(fdLock.Name())
 437                         if FdStatus != nil {
 438                                 FdStatus.Write([]byte{StatusDone})
 439                         }
 440                         Jobs.Done()
 441                 }()
 442                 stderr, err := cmd.StderrPipe()
 443                 if err != nil {
 444                         runErr.Err = err
 445                         errs <- runErr
 446                         return
 447                 }
 448                 started = time.Now()
 449                 err = cmd.Start()
 450                 if err != nil {
 451                         runErr.Err = err
 452                         errs <- runErr
 453                         return
 454                 }
 455                 pid := fmt.Sprintf("[%d]", cmd.Process.Pid)
 456                 trace(CDebug, "%s runs %s", tgtOrig, pid)
 457
 458                 stderrTerm := make(chan struct{}, 0)
 459                 go func() {
 460                         scanner := bufio.NewScanner(stderr)
 461                         var line string
 462                         ts := new(tai64n.TAI64N)
 463                         for scanner.Scan() {
 464                                 line = scanner.Text()
 465                                 if strings.HasPrefix(line, childStderrPrefix) {
 466                                         line = line[len(childStderrPrefix):]
 467                                         os.Stderr.WriteString(StderrPrefix + line + "\n")
 468                                         continue
 469                                 }
 470                                 if fdStderr != nil {
 471                                         ts.FromTime(time.Now())
 472                                         LogMutex.Lock()
 473                                         fmt.Fprintln(fdStderr, tai64n.Encode(ts[:]), line)
 474                                         LogMutex.Unlock()
 475                                 }
 476                                 if StderrSilent {
 477                                         continue
 478                                 }
 479                                 if MyPid == 0 {
 480                                         trace(CNone, "%s", line)
 481                                 } else {
 482                                         trace(CNone, "%s %s", pid, line)
 483                                 }
 484                         }
 485                         close(stderrTerm)
 486                 }()
 487
 488                 // Wait for job completion
 489                 <-stderrTerm
 490                 err = cmd.Wait()
 491                 finished := time.Now()
 492                 runErr.Finished = &finished
 493                 if err != nil {
 494                         runErr.Err = err
 495                         errs <- runErr
 496                         return
 497                 }
 498
 499                 // Was $1 touched?
 500                 if inodePrev != nil {
 501                         if fd, err := os.Open(path.Join(cwdOrig, tgt)); err == nil {
 502                                 inode, err := inodeFromFile(fd)
 503                                 fd.Close()
 504                                 if err == nil && !inode.Equals(inodePrev) {
 505                                         runErr.Err = errors.New("$1 was explicitly touched")
 506                                         errs <- runErr
 507                                         return
 508                                 }
 509                         }
 510                 }
 511
 512                 // Does it produce both stdout and tmp?
 513                 fiStdout, err := os.Stat(fdStdout.Name())
 514                 if err != nil {
 515                         runErr.Err = err
 516                         errs <- runErr
 517                         return
 518                 }
 519                 tmpExists := false
 520                 _, err = os.Stat(tmpPath)
 521                 if err == nil {
 522                         if fiStdout.Size() > 0 {
 523                                 runErr.Err = errors.New("created both tmp and stdout")
 524                                 errs <- runErr
 525                                 return
 526                         }
 527                         tmpExists = true
 528                 } else if !os.IsNotExist(err) {
 529                         runErr.Err = err
 530                         errs <- runErr
 531                         return
 532                 }
 533
 534                 // Determine what file we must process at last
 535                 var fd *os.File
 536                 if tmpExists {
 537                         fd, err = os.Open(tmpPath)
 538                         if err != nil {
 539                                 goto Finish
 540                         }
 541                         defer fd.Close()
 542                 } else if fiStdout.Size() > 0 {
 543                         fd = fdStdout
 544                 }
 545
 546                 // Do we need to ifcreate it, of ifchange with renaming?
 547                 if fd == nil {
 548                         os.Remove(path.Join(cwdOrig, tgt))
 549                         err = ifcreate(fdDep, tgt)
 550                         if err != nil {
 551                                 goto Finish
 552                         }
 553                 } else {
 554                         if !NoSync {
 555                                 err = fd.Sync()
 556                                 if err != nil {
 557                                         goto Finish
 558                                 }
 559                         }
 560                         err = os.Rename(fd.Name(), path.Join(cwdOrig, tgt))
 561                         if err != nil {
 562                                 goto Finish
 563                         }
 564                         if !NoSync {
 565                                 err = syncDir(cwdOrig)
 566                                 if err != nil {
 567                                         goto Finish
 568                                 }
 569                         }
 570                         err = writeDep(fdDep, cwdOrig, tgt)
 571                         if err != nil {
 572                                 goto Finish
 573                         }
 574                 }
 575
 576                 // Commit .rec
 577                 if !NoSync {
 578                         err = fdDep.Sync()
 579                         if err != nil {
 580                                 goto Finish
 581                         }
 582                 }
 583                 err = os.Rename(fdDep.Name(), path.Join(redoDir, tgt+DepSuffix))
 584                 if err != nil {
 585                         goto Finish
 586                 }
 587                 if !NoSync {
 588                         err = syncDir(redoDir)
 589                         if err != nil {
 590                                 goto Finish
 591                         }
 592                 }
 593         Finish:
 594                 runErr.Err = err
 595                 errs <- runErr
 596         }()
 597         return nil
 598 }
 599
 600 func isOkRun(err error) bool {
 601         if err == nil {
 602                 return true
 603         }
 604         if err, ok := err.(RunErr); ok && err.Err == nil {
 605                 trace(CRedo, "%s", err.Name())
 606                 return true
 607         }
 608         trace(CErr, "%s", err)
 609         return false
 610 }