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