ood.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 // Out-of-date determination
  19
  20 package main
  21
  22 import (
  23         "errors"
  24         "fmt"
  25         "io"
  26         "log"
  27         "os"
  28         "path"
  29         "path/filepath"
  30         "strings"
  31
  32         "golang.org/x/sys/unix"
  33 )
  34
  35 const (
  36         DepTypeIfcreate = "ifcreate"
  37         DepTypeIfchange = "ifchange"
  38         DepTypeAlways   = "always"
  39         DepTypeStamp    = "stamp"
  40
  41         EnvOODTgtsFd     = "REDO_OOD_TGTS_FD"
  42         EnvOODTgtsLockFd = "REDO_OOD_TGTS_LOCK_FD"
  43 )
  44
  45 var (
  46         OODTgts       map[string]struct{}
  47         FdOODTgts     *os.File
  48         FdOODTgtsLock *os.File
  49 )
  50
  51 type TgtErr struct {
  52         Tgt string
  53         Err error
  54 }
  55
  56 func (e TgtErr) Unwrap() error { return e.Err }
  57
  58 func (e TgtErr) Error() string {
  59         return fmt.Sprintf("%s: %s", e.Tgt, e.Err)
  60 }
  61
  62 func cwdMustRel(paths ...string) string {
  63         rel, err := filepath.Rel(Cwd, path.Join(paths...))
  64         if err != nil {
  65                 panic(err)
  66         }
  67         return rel
  68 }
  69
  70 func cwdAndTgt(tgt string) (string, string) {
  71         cwd, tgt := path.Split(tgt)
  72         cwd, err := filepath.Abs(cwd)
  73         if err != nil {
  74                 panic(err)
  75         }
  76         return cwd, tgt
  77 }
  78
  79 func isSrc(cwd, tgt string) bool {
  80         d, f := path.Split(path.Join(cwd, tgt))
  81         if _, err := os.Stat(path.Join(d, f)); err != nil {
  82                 return false
  83         }
  84         if _, err := os.Stat(path.Join(d, f+".do")); err == nil {
  85                 return false
  86         }
  87         if _, err := os.Stat(path.Join(d, RedoDir, f+DepSuffix)); err == nil {
  88                 return false
  89         }
  90         return true
  91 }
  92
  93 func isOOD(cwd, tgtOrig string, level int, seen map[string]struct{}) (bool, error) {
  94         indent := strings.Repeat(". ", level)
  95         trace(CDebug, "ood: %s%s checking", indent, tgtOrig)
  96         cwd, tgt := cwdAndTgt(path.Join(cwd, tgtOrig))
  97         depPath := path.Join(cwd, RedoDir, tgt+DepSuffix)
  98         fdDep, err := os.Open(depPath)
  99         if err != nil {
 100                 trace(CDebug, "ood: %s%s -> no dep: %s", indent, tgtOrig, depPath)
 101                 return true, nil
 102         }
 103         depInfo, err := depRead(fdDep)
 104         fdDep.Close()
 105         if err != nil {
 106                 return true, TgtErr{tgtOrig, err}
 107         }
 108
 109         if depInfo.build == BuildUUID {
 110                 trace(CDebug, "ood: %s%s -> already built", indent, tgtOrig)
 111                 return false, nil
 112         }
 113         ood := false
 114
 115         for _, dep := range depInfo.ifcreates {
 116                 if _, err := os.Stat(path.Join(cwd, dep)); err == nil {
 117                         trace(CDebug, "ood: %s%s -> %s created", indent, tgtOrig, dep)
 118                         ood = true
 119                         goto Done
 120                 }
 121         }
 122
 123         for _, m := range depInfo.ifchanges {
 124                 dep := m["Target"]
 125                 if dep == "" {
 126                         return ood, TgtErr{tgtOrig, errors.New("invalid format of .rec: missing Target")}
 127                 }
 128                 theirInode, err := inodeFromRec(m)
 129                 if err != nil {
 130                         return ood, TgtErr{tgtOrig, fmt.Errorf("invalid format of .rec: %w", err)}
 131                 }
 132                 theirHsh := m["Hash"]
 133                 trace(CDebug, "ood: %s%s -> %s: checking", indent, tgtOrig, dep)
 134
 135                 fd, err := os.Open(path.Join(cwd, dep))
 136                 if err != nil {
 137                         if os.IsNotExist(err) {
 138                                 trace(CDebug, "ood: %s%s -> %s: not exists", indent, tgtOrig, dep)
 139                                 ood = true
 140                                 goto Done
 141                         }
 142                         return ood, TgtErr{tgtOrig, err}
 143                 }
 144                 defer fd.Close()
 145
 146                 inode, err := inodeFromFile(fd)
 147                 if err != nil {
 148                         return ood, TgtErr{tgtOrig, err}
 149                 }
 150                 if inode.Size != theirInode.Size {
 151                         trace(CDebug, "ood: %s%s -> %s: size differs", indent, tgtOrig, dep)
 152                         ood = true
 153                         goto Done
 154                 }
 155                 if InodeTrust && inode.Equals(theirInode) {
 156                         trace(CDebug, "ood: %s%s -> %s: same inode", indent, tgtOrig, dep)
 157                 } else {
 158                         trace(CDebug, "ood: %s%s -> %s: inode differs", indent, tgtOrig, dep)
 159                         hsh, err := fileHash(fd)
 160                         if err != nil {
 161                                 return ood, TgtErr{tgtOrig, err}
 162                         }
 163                         if theirHsh != hsh {
 164                                 trace(CDebug, "ood: %s%s -> %s: hash differs", indent, tgtOrig, dep)
 165                                 ood = true
 166                                 goto Done
 167                         }
 168                         trace(CDebug, "ood: %s%s -> %s: same hash", indent, tgtOrig, dep)
 169                 }
 170                 fd.Close() // optimization not to hold it for long
 171
 172                 if dep == tgt {
 173                         trace(CDebug, "ood: %s%s -> %s: same target", indent, tgtOrig, dep)
 174                         continue
 175                 }
 176                 if isSrc(cwd, dep) {
 177                         trace(CDebug, "ood: %s%s -> %s: is source", indent, tgtOrig, dep)
 178                         continue
 179                 }
 180
 181                 if _, ok := seen[cwdMustRel(cwd, dep)]; ok {
 182                         trace(CDebug, "ood: %s%s -> %s: was always built", indent, tgtOrig, dep)
 183                         continue
 184                 }
 185
 186                 depOod, err := isOODWithTrace(cwd, dep, level+1, seen)
 187                 if err != nil {
 188                         return ood, TgtErr{tgtOrig, err}
 189                 }
 190                 if depOod {
 191                         trace(CDebug, "ood: %s%s -> %s: ood", indent, tgtOrig, dep)
 192                         ood = true
 193                         goto Done
 194                 }
 195                 trace(CDebug, "ood: %s%s -> %s: !ood", indent, tgtOrig, dep)
 196         }
 197
 198 Done:
 199         trace(CDebug, "ood: %s%s: %v", indent, tgtOrig, ood)
 200         return ood, nil
 201 }
 202
 203 func isOODWithTrace(
 204         cwd, tgtOrig string,
 205         level int,
 206         seen map[string]struct{},
 207 ) (bool, error) {
 208         p, err := filepath.Abs(path.Join(cwd, tgtOrig))
 209         if err != nil {
 210                 panic(err)
 211         }
 212         _, ood := OODTgts[p]
 213         if ood {
 214                 trace(
 215                         CDebug,
 216                         "ood: %s%s true, external decision",
 217                         strings.Repeat(". ", level), tgtOrig,
 218                 )
 219                 goto RecordOODTgt
 220         }
 221         ood, err = isOOD(cwd, tgtOrig, level, seen)
 222         if !ood {
 223                 return ood, err
 224         }
 225 RecordOODTgt:
 226         if err = unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_EX); err != nil {
 227                 log.Fatalln(err)
 228         }
 229         if _, err = FdOODTgts.Seek(0, io.SeekEnd); err != nil {
 230                 log.Fatalln(err)
 231         }
 232         if _, err := FdOODTgts.WriteString(p + "\x00"); err != nil {
 233                 log.Fatalln(err)
 234         }
 235         unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_UN)
 236         return true, nil
 237 }
 238
 239 func oodTgtsClear() {
 240         if err := unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_EX); err != nil {
 241                 log.Fatalln(err)
 242         }
 243         if err := FdOODTgts.Truncate(0); err != nil {
 244                 log.Fatalln(err)
 245         }
 246         unix.Flock(int(FdOODTgtsLock.Fd()), unix.LOCK_UN)
 247 }