main.go

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