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         "sync"
  32
  33         "go.cypherpunks.ru/recfile"
  34         "golang.org/x/sys/unix"
  35 )
  36
  37 const (
  38         RedoLevelEnv        = "REDO_LEVEL"
  39         RedoDepFdEnv        = "REDO_DEP_FD"
  40         RedoDirPrefixEnv    = "REDO_DIRPREFIX"
  41         RedoBuildUUIDEnv    = "REDO_BUILD_UUID"
  42         RedoStderrPrefixEnv = "REDO_STDERR_PREFIX"
  43         RedoJSRFdEnv        = "REDO_JSR_FD"
  44         RedoJSWFdEnv        = "REDO_JSW_FD"
  45 )
  46
  47 var (
  48         Level       = 0
  49         Trace  bool = false
  50         Force  bool = false
  51         NoHash bool = false
  52         NoSync bool = false
  53         Cwd    string
  54         Jobs   sync.WaitGroup
  55
  56         JobsN = flag.Uint("j", 1, "number of parallel jobs (0 for infinite)")
  57
  58         StderrKeep   bool = false
  59         StderrSilent bool = false
  60         StderrPrefix string
  61
  62         BuildUUID string
  63         IsMaster  bool = false
  64 )
  65
  66 func mustSetenv(key, value string) {
  67         if err := os.Setenv(key, value); err != nil {
  68                 panic(err)
  69         }
  70 }
  71
  72 func mustParseFd(v, name string) *os.File {
  73         ptr, err := strconv.ParseUint(v, 10, 64)
  74         if err != nil {
  75                 panic(err)
  76         }
  77         fd := os.NewFile(uintptr(ptr), name)
  78         if fd == nil {
  79                 panic("can not parse fd: " + name)
  80         }
  81         return fd
  82 }
  83
  84 func ifchange(tgts []string) (bool, error) {
  85         jsInit()
  86         defer Jobs.Wait()
  87         defer jsAcquire()
  88         errs := make(chan error, len(tgts))
  89         jobs := 0
  90         ok := true
  91         var err error
  92         for _, tgt := range tgts {
  93                 var ood bool
  94                 if Force {
  95                         ood = true
  96                 } else {
  97                         ood, err = isOOD(Cwd, tgt, 0)
  98                         if err != nil {
  99                                 return false, err
 100                         }
 101                 }
 102                 if !ood {
 103                         continue
 104                 }
 105                 if isSrc(Cwd, tgt) {
 106                         trace(CDebug, "%s is source", tgt)
 107                         continue
 108                 }
 109                 if err = runScript(tgt, errs); err != nil {
 110                         return false, err
 111                 }
 112                 if Force {
 113                         // Sequentially run jobs
 114                         err = <-errs
 115                         Jobs.Wait()
 116                         if err != nil {
 117                                 trace(CErr, "%s", err)
 118                                 return false, nil
 119                         }
 120                         continue
 121                 }
 122                 jobs++
 123         }
 124         for i := 0; i < jobs; i++ {
 125                 if err = <-errs; err != nil {
 126                         ok = false
 127                         trace(CErr, "%s", err)
 128                 }
 129         }
 130         return ok, nil
 131 }
 132
 133 func main() {
 134         xflag := flag.Bool("x", false, "trace current target (sh -x) (set REDO_TRACE=1 for others too)")
 135         stderrKeep := flag.Bool("stderr-keep", false, "keep job's stderr (REDO_STDERR_KEEP=1)")
 136         stderrSilent := flag.Bool("stderr-silent", false, "do not print job's stderr (REDO_STDERR_SILENT=1)")
 137         debug := flag.Bool("debug", false, "enable debug logging (REDO_DEBUG=1)")
 138         logDone := flag.Bool("log-done", false, "enable done messages logging (REDO_LOG_DONE=1)")
 139         logLock := flag.Bool("log-lock", false, "enable lock messages logging (REDO_LOG_LOCK=1)")
 140         logPid := flag.Bool("log-pid", false, "append PIDs (REDO_LOG_PID=1)")
 141         logJS := flag.Bool("log-js", false, "enable jobserver messages logging (REDO_LOG_JS=1)")
 142         version := flag.Bool("version", false, "print version")
 143         warranty := flag.Bool("warranty", false, "print warranty information")
 144         symlinks := flag.Bool("symlinks", false, "create necessary symlinks in current direcotyr")
 145
 146         flag.Usage = usage
 147         flag.Parse()
 148         if *warranty {
 149                 fmt.Println(Warranty)
 150                 return
 151         }
 152         if *version {
 153                 fmt.Println(versionGet())
 154                 return
 155         }
 156         if *symlinks {
 157                 for _, cmdName := range []string{
 158                         "redo",
 159                         "redo-always",
 160                         "redo-cleanup",
 161                         "redo-ifchange",
 162                         "redo-ifcreate",
 163                         "redo-log",
 164                         "redo-stamp",
 165                         "redo-whichdo",
 166                 } {
 167                         if err := os.Symlink(os.Args[0], cmdName); err != nil {
 168                                 log.Fatalln(err)
 169                         }
 170                 }
 171                 return
 172         }
 173         log.SetFlags(0)
 174
 175         var err error
 176         Cwd, err = unix.Getwd()
 177         if err != nil {
 178                 panic(err)
 179         }
 180
 181         NoColor = os.Getenv("NO_COLOR") != ""
 182         NoHash = os.Getenv("REDO_NO_HASH") == "1"
 183         NoSync = os.Getenv("REDO_NO_SYNC") == "1"
 184
 185         TopDir = os.Getenv("REDO_TOP_DIR")
 186         if TopDir != "" {
 187                 TopDir, err = filepath.Abs(TopDir)
 188                 if err != nil {
 189                         panic(err)
 190                 }
 191         }
 192
 193         if *stderrKeep {
 194                 mustSetenv("REDO_STDERR_KEEP", "1")
 195         }
 196         if *stderrSilent {
 197                 mustSetenv("REDO_STDERR_SILENT", "1")
 198         }
 199         if *debug {
 200                 mustSetenv("REDO_DEBUG", "1")
 201         }
 202         if *logDone {
 203                 mustSetenv("REDO_LOG_DONE", "1")
 204         }
 205         if *logLock {
 206                 mustSetenv("REDO_LOG_LOCK", "1")
 207         }
 208         if *logPid {
 209                 mustSetenv("REDO_LOG_PID", "1")
 210         }
 211         if *logJS {
 212                 mustSetenv("REDO_LOG_JS", "1")
 213         }
 214         StderrKeep = os.Getenv("REDO_STDERR_KEEP") == "1"
 215         StderrSilent = os.Getenv("REDO_STDERR_SILENT") == "1"
 216         Debug = os.Getenv("REDO_DEBUG") == "1"
 217         LogDone = os.Getenv("REDO_LOG_DONE") == "1"
 218         LogLock = os.Getenv("REDO_LOG_LOCK") == "1"
 219         LogJS = os.Getenv("REDO_LOG_JS") == "1"
 220         if Debug || os.Getenv("REDO_LOG_PID") == "1" {
 221                 MyPid = os.Getpid()
 222         }
 223         if *xflag {
 224                 Trace = true
 225         } else {
 226                 Trace = os.Getenv("REDO_TRACE") == "1"
 227         }
 228
 229         // Those are internal envs
 230         StderrPrefix = os.Getenv(RedoStderrPrefixEnv)
 231         if v := os.Getenv(RedoLevelEnv); v != "" {
 232                 level, err := strconv.ParseUint(v, 10, 64)
 233                 if err != nil {
 234                         panic(err)
 235                 }
 236                 Level = int(level)
 237         }
 238         var fdDep *os.File
 239         if v := os.Getenv(RedoDepFdEnv); v != "" {
 240                 fdDep = mustParseFd(v, RedoDepFdEnv)
 241         }
 242         BuildUUID = os.Getenv(RedoBuildUUIDEnv)
 243         if BuildUUID == "" {
 244                 IsMaster = true
 245                 raw := new([16]byte)
 246                 if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
 247                         panic(err)
 248                 }
 249                 raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
 250                 BuildUUID = fmt.Sprintf(
 251                         "%x-%x-%x-%x-%x",
 252                         raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
 253                 )
 254         }
 255
 256         tgts := flag.Args()
 257         if len(tgts) == 0 {
 258                 tgts = []string{"all"}
 259         }
 260         ok := true
 261         err = nil
 262         cmdName := path.Base(os.Args[0])
 263         trace(CDebug, "[%s] run: %s %s [%s]", BuildUUID, cmdName, tgts, Cwd)
 264
 265 CmdSwitch:
 266         switch cmdName {
 267         case "redo":
 268                 Force = true
 269                 ok, err = ifchange(tgts)
 270         case "redo-ifchange":
 271                 ok, err = ifchange(tgts)
 272                 writeDeps(fdDep, tgts)
 273         case "redo-ifcreate":
 274                 if fdDep == nil {
 275                         log.Fatalln("no", RedoDepFdEnv)
 276                 }
 277                 for _, tgt := range tgts {
 278                         err = ifcreate(fdDep, tgt)
 279                         if err != nil {
 280                                 break
 281                         }
 282                 }
 283         case "redo-always":
 284                 if fdDep == nil {
 285                         log.Fatalln("no", RedoDepFdEnv)
 286                 }
 287                 err = always(fdDep)
 288         case "redo-cleanup":
 289                 for _, what := range tgts {
 290                         err = cleanupWalker(Cwd, what)
 291                         if err != nil {
 292                                 break
 293                         }
 294                 }
 295         case "redo-stamp":
 296                 if fdDep == nil {
 297                         log.Fatalln("no", RedoDepFdEnv)
 298                 }
 299                 err = stamp(fdDep, os.Stdin)
 300         case "redo-log":
 301                 if len(tgts) != 1 {
 302                         log.Fatalln("single target expected")
 303                 }
 304                 d, t := cwdAndTgt(tgts[0])
 305                 var fd *os.File
 306                 fd, err = os.Open(path.Join(d, RedoDir, t+LogSuffix))
 307                 if err != nil {
 308                         break
 309                 }
 310                 _, err = io.Copy(os.Stdout, fd)
 311         case "redo-whichdo":
 312                 if len(tgts) != 1 {
 313                         log.Fatalln("single target expected")
 314                 }
 315                 var fdTmp *os.File
 316                 fdTmp, err = ioutil.TempFile("", "")
 317                 if err != nil {
 318                         break
 319                 }
 320                 os.Remove(fdTmp.Name())
 321                 var doFile string
 322                 cwd, tgt := cwdAndTgt(tgts[0])
 323                 doFile, _, err = findDo(fdTmp, cwd, tgt)
 324                 if err != nil {
 325                         break
 326                 }
 327                 fdTmp.Seek(0, 0)
 328                 r := recfile.NewReader(fdTmp)
 329                 for {
 330                         m, err := r.NextMap()
 331                         if err != nil {
 332                                 if err == io.EOF {
 333                                         break
 334                                 }
 335                                 break CmdSwitch
 336                         }
 337                         rel, err := filepath.Rel(Cwd, path.Join(cwd, m["Target"]))
 338                         if err != nil {
 339                                 panic(err)
 340                         }
 341                         fmt.Println(rel)
 342                 }
 343                 ok = doFile != ""
 344         default:
 345                 log.Fatalln("unknown command", cmdName)
 346         }
 347         if err != nil {
 348                 log.Println(err)
 349         }
 350         if !ok || err != nil {
 351                 os.Exit(1)
 352         }
 353 }