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