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         "crypto/rand"
  22         "flag"
  23         "fmt"
  24         "io"
  25         "io/ioutil"
  26         "log"
  27         "os"
  28         "path"
  29         "path/filepath"
  30         "strconv"
  31
  32         "go.cypherpunks.ru/recfile"
  33 )
  34
  35 var (
  36         Cwd       string
  37         BuildUUID string
  38 )
  39
  40 func mustSetenv(key, value string) {
  41         if err := os.Setenv(key, value); err != nil {
  42                 panic(err)
  43         }
  44 }
  45
  46 func mustParseFd(v, name string) *os.File {
  47         ptr, err := strconv.ParseUint(v, 10, 64)
  48         if err != nil {
  49                 panic(err)
  50         }
  51         fd := os.NewFile(uintptr(ptr), name)
  52         if fd == nil {
  53                 panic("can not parse fd: " + name)
  54         }
  55         return fd
  56 }
  57
  58 func main() {
  59         version := flag.Bool("version", false, "print version")
  60         warranty := flag.Bool("warranty", false, "print warranty information")
  61         symlinks := flag.Bool("symlinks", false, "create necessary symlinks in current directory")
  62
  63         flag.Usage = usage
  64         flag.Parse()
  65         if *warranty {
  66                 fmt.Println(Warranty)
  67                 return
  68         }
  69         if *version {
  70                 fmt.Println(versionGet())
  71                 return
  72         }
  73         if *symlinks {
  74                 rc := 0
  75                 for _, cmdName := range []string{
  76                         "redo",
  77                         "redo-always",
  78                         "redo-cleanup",
  79                         "redo-dot",
  80                         "redo-ifchange",
  81                         "redo-ifcreate",
  82                         "redo-log",
  83                         "redo-stamp",
  84                         "redo-whichdo",
  85                 } {
  86                         fmt.Println(os.Args[0], "<-", cmdName)
  87                         if err := os.Symlink(os.Args[0], cmdName); err != nil {
  88                                 rc = 1
  89                                 log.Println(err)
  90                         }
  91                 }
  92                 os.Exit(rc)
  93         }
  94         log.SetFlags(0)
  95
  96         var err error
  97         Cwd, err = os.Getwd()
  98         if err != nil {
  99                 panic(err)
 100         }
 101
 102         NoColor = os.Getenv(EnvNoColor) != ""
 103         NoSync = os.Getenv(EnvNoSync) == "1"
 104         InodeTrust = os.Getenv(EnvInodeNoTrust) == ""
 105
 106         TopDir = os.Getenv(EnvTopDir)
 107         if TopDir == "" {
 108                 TopDir = "/"
 109         } else {
 110                 TopDir, err = filepath.Abs(TopDir)
 111                 if err != nil {
 112                         panic(err)
 113                 }
 114         }
 115         DirPrefix = os.Getenv(EnvDirPrefix)
 116
 117         if *flagStderrKeep {
 118                 mustSetenv(EnvStderrKeep, "1")
 119         }
 120         if *flagStderrSilent {
 121                 mustSetenv(EnvStderrSilent, "1")
 122         }
 123         if *flagNoProgress {
 124                 mustSetenv(EnvNoProgress, "1")
 125         }
 126         if *flagDebug {
 127                 mustSetenv(EnvDebug, "1")
 128         }
 129         if *flagLogWait {
 130                 mustSetenv(EnvLogWait, "1")
 131         }
 132         if *flagLogLock {
 133                 mustSetenv(EnvLogLock, "1")
 134         }
 135         if *flagLogPid {
 136                 mustSetenv(EnvLogPid, "1")
 137         }
 138         if *flagLogJS {
 139                 mustSetenv(EnvLogJS, "1")
 140         }
 141         StderrKeep = os.Getenv(EnvStderrKeep) == "1"
 142         StderrSilent = os.Getenv(EnvStderrSilent) == "1"
 143         NoProgress = os.Getenv(EnvNoProgress) == "1"
 144         Debug = os.Getenv(EnvDebug) == "1"
 145         LogWait = os.Getenv(EnvLogWait) == "1"
 146         LogLock = os.Getenv(EnvLogLock) == "1"
 147         LogJS = os.Getenv(EnvLogJS) == "1"
 148         if Debug || os.Getenv(EnvLogPid) == "1" {
 149                 MyPid = os.Getpid()
 150         }
 151         var traced bool
 152         if *flagTraceAll {
 153                 mustSetenv(EnvTrace, "1")
 154         }
 155         if *flagTrace {
 156                 traced = true
 157         } else {
 158                 traced = os.Getenv(EnvTrace) == "1"
 159         }
 160
 161         // Those are internal envs
 162         StderrPrefix = os.Getenv(EnvStderrPrefix)
 163         if v := os.Getenv(EnvLevel); v != "" {
 164                 Level, err = strconv.Atoi(v)
 165                 if err != nil {
 166                         panic(err)
 167                 }
 168                 if Level < 0 {
 169                         panic("negative " + EnvLevel)
 170                 }
 171         }
 172         var fdDep *os.File
 173         if v := os.Getenv(EnvDepFd); v != "" {
 174                 fdDep = mustParseFd(v, EnvDepFd)
 175         }
 176         BuildUUID = os.Getenv(EnvBuildUUID)
 177         tgts := flag.Args()
 178         if BuildUUID == "" {
 179                 raw := new([16]byte)
 180                 if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
 181                         panic(err)
 182                 }
 183                 raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
 184                 BuildUUID = fmt.Sprintf(
 185                         "%x-%x-%x-%x-%x",
 186                         raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
 187                 )
 188                 if len(tgts) == 0 {
 189                         tgts = []string{"all"}
 190                 }
 191         }
 192         statusInit()
 193
 194         for i, tgt := range tgts {
 195                 if path.IsAbs(tgt) {
 196                         tgts[i] = cwdMustRel(tgt)
 197                 }
 198         }
 199
 200         ok := true
 201         err = nil
 202         cmdName := path.Base(os.Args[0])
 203         trace(
 204                 CDebug, "[%s] run: %s %s cwd:%s dirprefix:%s",
 205                 BuildUUID, cmdName, tgts, Cwd, DirPrefix,
 206         )
 207
 208 CmdSwitch:
 209         switch cmdName {
 210         case "redo":
 211                 for _, tgt := range tgts {
 212                         ok, err = ifchange([]string{tgt}, true, traced)
 213                         if err != nil || !ok {
 214                                 break
 215                         }
 216                 }
 217         case "redo-ifchange":
 218                 ok, err = ifchange(tgts, false, traced)
 219                 if err == nil {
 220                         err = writeDeps(fdDep, tgts)
 221                 }
 222         case "redo-ifcreate":
 223                 if fdDep == nil {
 224                         log.Fatalln("no", EnvDepFd)
 225                 }
 226                 for _, tgt := range tgts {
 227                         err = ifcreate(fdDep, tgt)
 228                         if err != nil {
 229                                 break
 230                         }
 231                 }
 232         case "redo-always":
 233                 if fdDep == nil {
 234                         log.Fatalln("no", EnvDepFd)
 235                 }
 236                 err = always(fdDep)
 237         case "redo-cleanup":
 238                 for _, what := range tgts {
 239                         err = cleanupWalker(Cwd, what)
 240                         if err != nil {
 241                                 break
 242                         }
 243                 }
 244         case "redo-dot":
 245                 err = dotPrint(tgts)
 246         case "redo-stamp":
 247                 if fdDep == nil {
 248                         log.Fatalln("no", EnvDepFd)
 249                 }
 250                 err = stamp(fdDep, os.Stdin)
 251         case "redo-log":
 252                 if len(tgts) != 1 {
 253                         log.Fatalln("single target expected")
 254                 }
 255                 d, t := cwdAndTgt(tgts[0])
 256                 var fd *os.File
 257                 fd, err = os.Open(path.Join(d, RedoDir, t+LogSuffix))
 258                 if err != nil {
 259                         break
 260                 }
 261                 _, err = io.Copy(os.Stdout, fd)
 262         case "redo-whichdo":
 263                 if len(tgts) != 1 {
 264                         log.Fatalln("single target expected")
 265                 }
 266                 var fdTmp *os.File
 267                 fdTmp, err = ioutil.TempFile("", "")
 268                 if err != nil {
 269                         break
 270                 }
 271                 os.Remove(fdTmp.Name())
 272                 cwd, tgt := cwdAndTgt(tgts[0])
 273                 doFile, upLevels, err := findDo(fdTmp, cwd, tgt)
 274                 if err != nil {
 275                         break
 276                 }
 277                 _, err = fdTmp.Seek(0, 0)
 278                 if err != nil {
 279                         break
 280                 }
 281                 r := recfile.NewReader(fdTmp)
 282                 for {
 283                         m, err := r.NextMap()
 284                         if err != nil {
 285                                 if err == io.EOF {
 286                                         break
 287                                 }
 288                                 break CmdSwitch
 289                         }
 290                         fmt.Println(cwdMustRel(cwd, m["Target"]))
 291                 }
 292                 if doFile == "" {
 293                         ok = false
 294                 } else {
 295                         p := make([]string, 0, upLevels+2)
 296                         p = append(p, cwd)
 297                         for i := 0; i < upLevels; i++ {
 298                                 p = append(p, "..")
 299                         }
 300                         p = append(p, doFile)
 301                         rel, err := filepath.Rel(Cwd, path.Join(p...))
 302                         if err != nil {
 303                                 panic(err)
 304                         }
 305                         fmt.Println(rel)
 306                 }
 307         default:
 308                 log.Fatalln("unknown command", cmdName)
 309         }
 310         if err != nil {
 311                 log.Println(err)
 312         }
 313         rc := 0
 314         if !ok || err != nil {
 315                 rc = 1
 316         }
 317         trace(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)
 318         os.Exit(rc)
 319 }