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