main.go

   1 /*
   2 goredo -- redo implementation on pure Go
   3 Copyright (C) 2020 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         "golang.org/x/sys/unix"
  34 )
  35
  36 var (
  37         Cwd       string
  38         BuildUUID string
  39 )
  40
  41 func mustSetenv(key, value string) {
  42         if err := os.Setenv(key, value); err != nil {
  43                 panic(err)
  44         }
  45 }
  46
  47 func mustParseFd(v, name string) *os.File {
  48         ptr, err := strconv.ParseUint(v, 10, 64)
  49         if err != nil {
  50                 panic(err)
  51         }
  52         fd := os.NewFile(uintptr(ptr), name)
  53         if fd == nil {
  54                 panic("can not parse fd: " + name)
  55         }
  56         return fd
  57 }
  58
  59 func main() {
  60         version := flag.Bool("version", false, "print version")
  61         warranty := flag.Bool("warranty", false, "print warranty information")
  62         symlinks := flag.Bool("symlinks", false, "create necessary symlinks in current direcotyr")
  63
  64         flag.Usage = usage
  65         flag.Parse()
  66         if *warranty {
  67                 fmt.Println(Warranty)
  68                 return
  69         }
  70         if *version {
  71                 fmt.Println(versionGet())
  72                 return
  73         }
  74         if *symlinks {
  75                 rc := 0
  76                 for _, cmdName := range []string{
  77                         "redo",
  78                         "redo-always",
  79                         "redo-cleanup",
  80                         "redo-dot",
  81                         "redo-ifchange",
  82                         "redo-ifcreate",
  83                         "redo-log",
  84                         "redo-stamp",
  85                         "redo-whichdo",
  86                 } {
  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 = unix.Getwd()
  98         if err != nil {
  99                 panic(err)
 100         }
 101
 102         NoColor = os.Getenv(EnvNoColor) != ""
 103         NoHash = os.Getenv(EnvNoHash) == "1"
 104         NoSync = os.Getenv(EnvNoSync) == "1"
 105
 106         TopDir = os.Getenv(EnvTopDir)
 107         if TopDir != "" {
 108                 TopDir, err = filepath.Abs(TopDir)
 109                 if err != nil {
 110                         panic(err)
 111                 }
 112         }
 113
 114         if *flagStderrKeep {
 115                 mustSetenv(EnvStderrKeep, "1")
 116         }
 117         if *flagStderrSilent {
 118                 mustSetenv(EnvStderrSilent, "1")
 119         }
 120         if *flagDebug {
 121                 mustSetenv(EnvDebug, "1")
 122         }
 123         if *flagLogWait {
 124                 mustSetenv(EnvLogWait, "1")
 125         }
 126         if *flagLogLock {
 127                 mustSetenv(EnvLogLock, "1")
 128         }
 129         if *flagLogPid {
 130                 mustSetenv(EnvLogPid, "1")
 131         }
 132         if *flagLogJS {
 133                 mustSetenv(EnvLogJS, "1")
 134         }
 135         StderrKeep = os.Getenv(EnvStderrKeep) == "1"
 136         StderrSilent = os.Getenv(EnvStderrSilent) == "1"
 137         Debug = os.Getenv(EnvDebug) == "1"
 138         LogWait = os.Getenv(EnvLogWait) == "1"
 139         LogLock = os.Getenv(EnvLogLock) == "1"
 140         LogJS = os.Getenv(EnvLogJS) == "1"
 141         if Debug || os.Getenv(EnvLogPid) == "1" {
 142                 MyPid = os.Getpid()
 143         }
 144         if *flagTrace {
 145                 Trace = true
 146         } else {
 147                 Trace = os.Getenv(EnvTrace) == "1"
 148         }
 149
 150         // Those are internal envs
 151         StderrPrefix = os.Getenv(EnvStderrPrefix)
 152         if v := os.Getenv(EnvLevel); v != "" {
 153                 Level, err = strconv.Atoi(v)
 154                 if err != nil {
 155                         panic(err)
 156                 }
 157                 if Level < 0 {
 158                         panic("negative " + EnvLevel)
 159                 }
 160         }
 161         var fdDep *os.File
 162         if v := os.Getenv(EnvDepFd); v != "" {
 163                 fdDep = mustParseFd(v, EnvDepFd)
 164         }
 165         BuildUUID = os.Getenv(EnvBuildUUID)
 166         if BuildUUID == "" {
 167                 raw := new([16]byte)
 168                 if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
 169                         panic(err)
 170                 }
 171                 raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
 172                 BuildUUID = fmt.Sprintf(
 173                         "%x-%x-%x-%x-%x",
 174                         raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
 175                 )
 176         }
 177         StampPrev = os.Getenv(EnvStampPrev)
 178
 179         tgts := flag.Args()
 180         if len(tgts) == 0 {
 181                 tgts = []string{"all"}
 182         }
 183         ok := true
 184         err = nil
 185         cmdName := path.Base(os.Args[0])
 186         trace(CDebug, "[%s] run: %s %s [%s]", BuildUUID, cmdName, tgts, Cwd)
 187
 188 CmdSwitch:
 189         switch cmdName {
 190         case "redo":
 191                 Force = true
 192                 ok, err = ifchange(tgts)
 193         case "redo-ifchange":
 194                 ok, err = ifchange(tgts)
 195                 writeDeps(fdDep, tgts)
 196         case "redo-ifcreate":
 197                 if fdDep == nil {
 198                         log.Fatalln("no", EnvDepFd)
 199                 }
 200                 for _, tgt := range tgts {
 201                         err = ifcreate(fdDep, tgt)
 202                         if err != nil {
 203                                 break
 204                         }
 205                 }
 206         case "redo-always":
 207                 if fdDep == nil {
 208                         log.Fatalln("no", EnvDepFd)
 209                 }
 210                 err = always(fdDep)
 211         case "redo-cleanup":
 212                 for _, what := range tgts {
 213                         err = cleanupWalker(Cwd, what)
 214                         if err != nil {
 215                                 break
 216                         }
 217                 }
 218         case "redo-dot":
 219                 err = dotPrint(tgts)
 220         case "redo-stamp":
 221                 if fdDep == nil {
 222                         log.Fatalln("no", EnvDepFd)
 223                 }
 224                 err = stamp(fdDep, os.Stdin)
 225         case "redo-log":
 226                 if len(tgts) != 1 {
 227                         log.Fatalln("single target expected")
 228                 }
 229                 d, t := cwdAndTgt(tgts[0])
 230                 var fd *os.File
 231                 fd, err = os.Open(path.Join(d, RedoDir, t+LogSuffix))
 232                 if err != nil {
 233                         break
 234                 }
 235                 _, err = io.Copy(os.Stdout, fd)
 236         case "redo-whichdo":
 237                 if len(tgts) != 1 {
 238                         log.Fatalln("single target expected")
 239                 }
 240                 var fdTmp *os.File
 241                 fdTmp, err = ioutil.TempFile("", "")
 242                 if err != nil {
 243                         break
 244                 }
 245                 os.Remove(fdTmp.Name())
 246                 var doFile string
 247                 cwd, tgt := cwdAndTgt(tgts[0])
 248                 doFile, _, err = findDo(fdTmp, cwd, tgt)
 249                 if err != nil {
 250                         break
 251                 }
 252                 fdTmp.Seek(0, 0)
 253                 r := recfile.NewReader(fdTmp)
 254                 for {
 255                         m, err := r.NextMap()
 256                         if err != nil {
 257                                 if err == io.EOF {
 258                                         break
 259                                 }
 260                                 break CmdSwitch
 261                         }
 262                         fmt.Println(cwdMustRel(cwd, m["Target"]))
 263                 }
 264                 ok = doFile != ""
 265         default:
 266                 log.Fatalln("unknown command", cmdName)
 267         }
 268         if err != nil {
 269                 log.Println(err)
 270         }
 271         rc := 0
 272         if !ok || err != nil {
 273                 rc = 1
 274         }
 275         trace(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)
 276         os.Exit(rc)
 277 }