main.go

   1 /*
   2 goredo -- djb's redo implementation on pure Go
   3 Copyright (C) 2020-2023 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 package main
  19
  20 import (
  21         "bufio"
  22         "bytes"
  23         "crypto/rand"
  24         "errors"
  25         "flag"
  26         "fmt"
  27         "io"
  28         "log"
  29         "os"
  30         "os/signal"
  31         "path"
  32         "path/filepath"
  33         "runtime"
  34         "sort"
  35         "strconv"
  36         "syscall"
  37
  38         "go.cypherpunks.ru/recfile"
  39         "golang.org/x/sys/unix"
  40 )
  41
  42 const (
  43         CmdNameGoredo       = "goredo"
  44         CmdNameRedo         = "redo"
  45         CmdNameRedoAffects  = "redo-affects"
  46         CmdNameRedoAlways   = "redo-always"
  47         CmdNameRedoCleanup  = "redo-cleanup"
  48         CmdNameRedoDot      = "redo-dot"
  49         CmdNameRedoIfchange = "redo-ifchange"
  50         CmdNameRedoIfcreate = "redo-ifcreate"
  51         CmdNameRedoLog      = "redo-log"
  52         CmdNameRedoOOD      = "redo-ood"
  53         CmdNameRedoSources  = "redo-sources"
  54         CmdNameRedoStamp    = "redo-stamp"
  55         CmdNameRedoTargets  = "redo-targets"
  56         CmdNameRedoWhichdo  = "redo-whichdo"
  57         CmdNameRedoDepFix   = "redo-depfix"
  58         CmdNameRedoInode    = "redo-inode"
  59 )
  60
  61 var (
  62         Cwd       string
  63         BuildUUID string
  64         IsTopRedo bool // is it the top redo instance
  65         UmaskCur  int
  66 )
  67
  68 func mustSetenv(key string) {
  69         if err := os.Setenv(key, "1"); err != nil {
  70                 panic(err)
  71         }
  72 }
  73
  74 func mustParseFd(v, name string) *os.File {
  75         ptr, err := strconv.ParseUint(v, 10, 64)
  76         if err != nil {
  77                 panic(err)
  78         }
  79         fd := os.NewFile(uintptr(ptr), name)
  80         if fd == nil {
  81                 panic("can not parse fd: " + name)
  82         }
  83         return fd
  84 }
  85
  86 func CmdName() string {
  87         return path.Base(os.Args[0])
  88 }
  89
  90 func main() {
  91         version := flag.Bool("version", false, "print version")
  92         warranty := flag.Bool("warranty", false, "print warranty information")
  93
  94         var symlinks *bool
  95         cmdName := CmdName()
  96         if cmdName == "goredo" {
  97                 symlinks = flag.Bool("symlinks", false, "create necessary symlinks in current directory")
  98         }
  99
 100         flag.Usage = func() { usage(os.Args[0]) }
 101         flag.Parse()
 102         if *warranty {
 103                 fmt.Println(Warranty)
 104                 return
 105         }
 106         if *version {
 107                 fmt.Println("goredo", Version, "built with", runtime.Version())
 108                 return
 109         }
 110         if cmdName == CmdNameGoredo && *symlinks {
 111                 rc := 0
 112                 for _, cmdName := range []string{
 113                         CmdNameRedo,
 114                         CmdNameRedoAffects,
 115                         CmdNameRedoAlways,
 116                         CmdNameRedoCleanup,
 117                         CmdNameRedoDepFix,
 118                         CmdNameRedoDot,
 119                         CmdNameRedoIfchange,
 120                         CmdNameRedoIfcreate,
 121                         CmdNameRedoLog,
 122                         CmdNameRedoOOD,
 123                         CmdNameRedoSources,
 124                         CmdNameRedoStamp,
 125                         CmdNameRedoTargets,
 126                         CmdNameRedoWhichdo,
 127                 } {
 128                         fmt.Println(os.Args[0], "<-", cmdName)
 129                         if err := os.Symlink(os.Args[0], cmdName); err != nil {
 130                                 rc = 1
 131                                 log.Print(err)
 132                         }
 133                 }
 134                 os.Exit(rc)
 135         }
 136         log.SetFlags(log.Lshortfile)
 137
 138         UmaskCur = syscall.Umask(0)
 139         syscall.Umask(UmaskCur)
 140
 141         var err error
 142         Cwd, err = os.Getwd()
 143         if err != nil {
 144                 log.Fatal(err)
 145         }
 146
 147         TopDir = os.Getenv(EnvTopDir)
 148         if TopDir == "" {
 149                 TopDir = "/"
 150         } else {
 151                 TopDir, err = filepath.Abs(TopDir)
 152                 if err != nil {
 153                         panic(err)
 154                 }
 155         }
 156         DirPrefix = os.Getenv(EnvDirPrefix)
 157         DepCwd = os.Getenv(EnvDepCwd)
 158
 159         if flagStderrKeep != nil && *flagStderrKeep {
 160                 mustSetenv(EnvStderrKeep)
 161         }
 162         if flagStderrSilent != nil && *flagStderrSilent {
 163                 mustSetenv(EnvStderrSilent)
 164         }
 165         if flagNoProgress != nil && *flagNoProgress {
 166                 mustSetenv(EnvNoProgress)
 167         }
 168         if flagDebug != nil && *flagDebug {
 169                 mustSetenv(EnvDebug)
 170         }
 171         if flagLogWait != nil && *flagLogWait {
 172                 mustSetenv(EnvLogWait)
 173         }
 174         if flagLogLock != nil && *flagLogLock {
 175                 mustSetenv(EnvLogLock)
 176         }
 177         if flagLogPid != nil && *flagLogPid {
 178                 mustSetenv(EnvLogPid)
 179         }
 180         if flagLogJS != nil && *flagLogJS {
 181                 mustSetenv(EnvLogJS)
 182         }
 183         StderrKeep = os.Getenv(EnvStderrKeep) == "1"
 184         StderrSilent = os.Getenv(EnvStderrSilent) == "1"
 185         NoProgress = os.Getenv(EnvNoProgress) == "1"
 186         Debug = os.Getenv(EnvDebug) == "1"
 187         LogWait = os.Getenv(EnvLogWait) == "1"
 188         LogLock = os.Getenv(EnvLogLock) == "1"
 189         LogJS = os.Getenv(EnvLogJS) == "1"
 190         if Debug || os.Getenv(EnvLogPid) == "1" {
 191                 MyPid = os.Getpid()
 192         }
 193         var traced bool
 194         if flagTraceAll != nil && *flagTraceAll {
 195                 mustSetenv(EnvTrace)
 196         }
 197         if os.Getenv(EnvTrace) == "1" {
 198                 TracedAll = true
 199                 traced = true
 200         } else if flagTrace != nil {
 201                 traced = *flagTrace
 202         }
 203         NoColor = os.Getenv(EnvNoColor) != ""
 204         NoSync = os.Getenv(EnvNoSync) == "1"
 205         StopIfMod = os.Getenv(EnvStopIfMod) == "1"
 206         switch s := os.Getenv(EnvInodeTrust); s {
 207         case "none":
 208                 InodeTrust = InodeTrustNone
 209         case "", "ctime":
 210                 InodeTrust = InodeTrustCtime
 211         case "mtime":
 212                 InodeTrust = InodeTrustMtime
 213         default:
 214                 log.Fatalln("unknown", EnvInodeTrust, "value")
 215         }
 216         tracef(CDebug, "inode-trust: %s", InodeTrust)
 217
 218         // Those are internal envs
 219         FdOODTgts, err = os.CreateTemp("", "ood-tgts")
 220         if err != nil {
 221                 log.Fatal(err)
 222         }
 223         if err = os.Remove(FdOODTgts.Name()); err != nil {
 224                 log.Fatal(err)
 225         }
 226         FdOODTgtsLock, err = os.CreateTemp("", "ood-tgts.lock")
 227         if err != nil {
 228                 log.Fatal(err)
 229         }
 230         if err = os.Remove(FdOODTgtsLock.Name()); err != nil {
 231                 log.Fatal(err)
 232         }
 233
 234         if v := os.Getenv(EnvOODTgtsFd); v != "" {
 235                 fd := mustParseFd(v, EnvOODTgtsFd)
 236                 fdLock := mustParseFd(v, EnvOODTgtsLockFd)
 237                 flock := unix.Flock_t{
 238                         Type:   unix.F_WRLCK,
 239                         Whence: io.SeekStart,
 240                 }
 241                 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
 242                         log.Fatal(err)
 243                 }
 244                 if _, err = fd.Seek(0, io.SeekStart); err != nil {
 245                         log.Fatal(err)
 246                 }
 247                 tgtsRaw, err := io.ReadAll(bufio.NewReader(fd))
 248                 if err != nil {
 249                         log.Fatal(err)
 250                 }
 251                 flock.Type = unix.F_UNLCK
 252                 if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
 253                         log.Fatal(err)
 254                 }
 255                 OODTgts = map[string]struct{}{}
 256                 for _, tgtRaw := range bytes.Split(tgtsRaw, []byte{0}) {
 257                         t := string(tgtRaw)
 258                         if t == "" {
 259                                 continue
 260                         }
 261                         OODTgts[t] = struct{}{}
 262                         tracef(CDebug, "ood: known to be: %s", t)
 263                 }
 264         }
 265
 266         StderrPrefix = os.Getenv(EnvStderrPrefix)
 267         if v := os.Getenv(EnvLevel); v != "" {
 268                 Level, err = strconv.Atoi(v)
 269                 if err != nil {
 270                         panic(err)
 271                 }
 272                 if Level < 0 {
 273                         panic("negative " + EnvLevel)
 274                 }
 275         }
 276
 277         var fdDep *os.File
 278         if v := os.Getenv(EnvDepFd); v != "" {
 279                 fdDep = mustParseFd(v, EnvDepFd)
 280         }
 281
 282         tgts := flag.Args()
 283         BuildUUID = os.Getenv(EnvBuildUUID)
 284         tgtsWasEmpty := len(tgts) == 0
 285         if BuildUUID == "" {
 286                 IsTopRedo = true
 287                 raw := new([16]byte)
 288                 if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
 289                         log.Fatal(err)
 290                 }
 291                 raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
 292                 BuildUUID = fmt.Sprintf(
 293                         "%x-%x-%x-%x-%x",
 294                         raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
 295                 )
 296                 if tgtsWasEmpty {
 297                         tgts = []string{"all"}
 298                 }
 299         }
 300
 301         if cmdName == CmdNameRedo {
 302                 statusInit()
 303         }
 304
 305         for i, tgt := range tgts {
 306                 if path.IsAbs(tgt) {
 307                         tgts[i] = cwdMustRel(tgt)
 308                 }
 309         }
 310
 311         killed := make(chan os.Signal, 1)
 312         signal.Notify(killed, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
 313         go func() {
 314                 <-killed
 315                 tracef(CDebug, "[%s] killed", BuildUUID)
 316                 jsReleaseAll()
 317                 RunningProcsM.Lock()
 318                 for pid, proc := range RunningProcs {
 319                         tracef(CDebug, "[%s] killing child %d", BuildUUID, pid)
 320                         _ = proc.Signal(syscall.SIGTERM)
 321                 }
 322                 os.Exit(1)
 323         }()
 324
 325         ok := true
 326         err = nil
 327         tracef(
 328                 CDebug, "[%s] run: %s %s cwd:%s dirprefix:%s",
 329                 BuildUUID, cmdName, tgts, Cwd, DirPrefix,
 330         )
 331
 332 CmdSwitch:
 333         switch cmdName {
 334         case CmdNameRedo:
 335                 for _, tgt := range tgts {
 336                         ok, err = ifchange([]string{tgt}, true, traced)
 337                         if err != nil || !ok {
 338                                 break
 339                         }
 340                 }
 341         case CmdNameRedoIfchange:
 342                 ok, err = ifchange(tgts, *flagForcedIfchange, traced)
 343                 if err == nil {
 344                         err = depsWrite(fdDep, tgts)
 345                 }
 346         case CmdNameRedoIfcreate:
 347                 if fdDep == nil {
 348                         log.Fatalln("no", EnvDepFd)
 349                 }
 350                 for _, tgt := range tgts {
 351                         tgtRel, err := filepath.Rel(
 352                                 path.Join(Cwd, DirPrefix),
 353                                 path.Join(Cwd, tgt),
 354                         )
 355                         if err != nil {
 356                                 err = ErrLine(err)
 357                                 break
 358                         }
 359                         err = ifcreate(fdDep, tgtRel)
 360                         if err != nil {
 361                                 break
 362                         }
 363                 }
 364         case CmdNameRedoAlways:
 365                 if fdDep == nil {
 366                         log.Fatalln("no", EnvDepFd)
 367                 }
 368                 err = always(fdDep)
 369         case CmdNameRedoCleanup:
 370                 for _, what := range tgts {
 371                         err = cleanupWalker(Cwd, what)
 372                         if err != nil {
 373                                 break
 374                         }
 375                 }
 376         case CmdNameRedoDot:
 377                 err = dotPrint(tgts)
 378         case CmdNameRedoStamp:
 379                 if fdDep == nil {
 380                         log.Fatalln("no", EnvDepFd)
 381                 }
 382                 err = stamp(fdDep, os.Stdin)
 383         case CmdNameRedoLog:
 384                 if len(tgts) != 1 {
 385                         log.Fatal("single target expected")
 386                 }
 387                 d, t := cwdAndTgt(tgts[0])
 388                 err = showBuildLog(d, t, nil, 0)
 389         case CmdNameRedoWhichdo:
 390                 if len(tgts) != 1 {
 391                         log.Fatal("single target expected")
 392                 }
 393                 var fdTmp *os.File
 394                 fdTmp, err = os.CreateTemp("", "whichdo")
 395                 if err != nil {
 396                         err = ErrLine(err)
 397                         break
 398                 }
 399                 if err = os.Remove(fdTmp.Name()); err != nil {
 400                         err = ErrLine(err)
 401                         break
 402                 }
 403                 cwd, tgt := cwdAndTgt(tgts[0])
 404                 doFile, upLevels, err := findDo(fdTmp, cwd, tgt)
 405                 if err != nil {
 406                         err = ErrLine(err)
 407                         break
 408                 }
 409                 _, err = fdTmp.Seek(0, io.SeekStart)
 410                 if err != nil {
 411                         err = ErrLine(err)
 412                         break
 413                 }
 414                 r := recfile.NewReader(fdTmp)
 415                 for {
 416                         m, err := r.NextMap()
 417                         if err != nil {
 418                                 if errors.Is(err, io.EOF) {
 419                                         break
 420                                 }
 421                                 err = ErrLine(err)
 422                                 break CmdSwitch
 423                         }
 424                         fmt.Println(cwdMustRel(cwd, m["Target"]))
 425                 }
 426                 if doFile == "" {
 427                         ok = false
 428                 } else {
 429                         p := make([]string, 0, upLevels+2)
 430                         p = append(p, cwd)
 431                         for i := 0; i < upLevels; i++ {
 432                                 p = append(p, "..")
 433                         }
 434                         p = append(p, doFile)
 435                         rel, err := filepath.Rel(Cwd, path.Join(p...))
 436                         if err != nil {
 437                                 panic(err)
 438                         }
 439                         fmt.Println(rel)
 440                 }
 441         case CmdNameRedoTargets:
 442                 if tgtsWasEmpty {
 443                         tgts = []string{Cwd}
 444                 }
 445                 tgts, err = targetsWalker(tgts)
 446                 if err != nil {
 447                         err = ErrLine(err)
 448                         break
 449                 }
 450                 sort.Strings(tgts)
 451                 for _, tgt := range tgts {
 452                         fmt.Println(tgt)
 453                 }
 454         case CmdNameRedoAffects:
 455                 if tgtsWasEmpty {
 456                         log.Fatal("no targets specified")
 457                 }
 458                 var tgtsKnown []string
 459                 tgtsKnown, err = targetsWalker([]string{Cwd})
 460                 if err != nil {
 461                         err = ErrLine(err)
 462                         break
 463                 }
 464                 deps := map[string]map[string]struct{}{}
 465                 for _, tgt := range tgtsKnown {
 466                         collectDeps(Cwd, tgt, 0, deps, true, map[string]struct{}{})
 467                 }
 468                 seen := map[string]struct{}{}
 469                 for _, tgt := range tgts {
 470                         collectWholeDeps(deps[tgt], deps, seen)
 471                 }
 472                 tgts := make([]string, 0, len(seen))
 473                 for dep := range seen {
 474                         tgts = append(tgts, dep)
 475                 }
 476                 sort.Strings(tgts)
 477                 for _, dep := range tgts {
 478                         fmt.Println(dep)
 479                 }
 480         case CmdNameRedoOOD:
 481                 if tgtsWasEmpty {
 482                         tgts, err = targetsWalker([]string{Cwd})
 483                         if err != nil {
 484                                 break
 485                         }
 486                 }
 487                 sort.Strings(tgts)
 488                 var ood bool
 489                 for _, tgt := range tgts {
 490                         ood, err = isOOD(Cwd, tgt, 0, nil)
 491                         if err != nil {
 492                                 err = ErrLine(err)
 493                                 break
 494                         }
 495                         if ood {
 496                                 fmt.Println(tgt)
 497                         }
 498                 }
 499         case CmdNameRedoSources:
 500                 if tgtsWasEmpty {
 501                         tgts, err = targetsWalker([]string{Cwd})
 502                         if err != nil {
 503                                 err = ErrLine(err)
 504                                 break
 505                         }
 506                 }
 507                 sort.Strings(tgts)
 508                 var srcs []string
 509                 srcs, err = sourcesWalker(tgts)
 510                 err = ErrLine(err)
 511                 sort.Strings(srcs)
 512                 for _, src := range srcs {
 513                         fmt.Println(src)
 514                 }
 515         case CmdNameRedoDepFix:
 516                 err = depFix(Cwd)
 517         case CmdNameRedoInode:
 518                 var inode *Inode
 519                 for _, tgt := range tgts {
 520                         inode, err = inodeFromFileByPath(tgt)
 521                         if err != nil {
 522                                 err = ErrLine(err)
 523                                 break
 524                         }
 525                         err = recfileWrite(os.Stdout, append(
 526                                 []recfile.Field{{Name: "Target", Value: tgt}},
 527                                 inode.RecfileFields()...)...)
 528                         if err != nil {
 529                                 err = ErrLine(err)
 530                                 break
 531                         }
 532                 }
 533         default:
 534                 log.Fatalln("unknown command", cmdName)
 535         }
 536         if err != nil {
 537                 log.Print(err)
 538         }
 539         rc := 0
 540         if !ok || err != nil {
 541                 rc = 1
 542         }
 543         tracef(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)
 544         os.Exit(rc)
 545 }