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