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