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