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