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