gopkg.in/tools/godep.v45@v45.0.0-20151228215228-7e51f1a9c00c/restore.go (about) 1 package main 2 3 import ( 4 "errors" 5 "go/build" 6 "log" 7 "os" 8 "path/filepath" 9 10 "github.com/tools/godep/Godeps/_workspace/src/golang.org/x/tools/go/vcs" 11 ) 12 13 var cmdRestore = &Command{ 14 Name: "restore", 15 Short: "check out listed dependency versions in GOPATH", 16 Long: ` 17 Restore checks out the Godeps-specified version of each package in GOPATH. 18 19 `, 20 Run: runRestore, 21 } 22 23 // Three phases: 24 // 1. Download all deps 25 // 2. Restore all deps (checkout the recorded rev) 26 // 3. Attempt to load all deps as a simple consistency check 27 func runRestore(cmd *Command, args []string) { 28 var hadError bool 29 checkErr := func(s string) { 30 if hadError { 31 log.Println(s) 32 os.Exit(1) 33 } 34 } 35 36 g, err := loadDefaultGodepsFile() 37 if err != nil { 38 log.Fatalln(err) 39 } 40 for i, dep := range g.Deps { 41 verboseln("Downloading dependency (if needed):", dep.ImportPath) 42 err := download(&dep) 43 if err != nil { 44 log.Printf("error downloading dep (%s): %s\n", dep.ImportPath, err) 45 hadError = true 46 } 47 g.Deps[i] = dep 48 } 49 checkErr("Error downloading some deps. Aborting restore and check.") 50 for _, dep := range g.Deps { 51 verboseln("Restoring dependency (if needed):", dep.ImportPath) 52 err := restore(dep) 53 if err != nil { 54 log.Printf("error restoring dep (%s): %s\n", dep.ImportPath, err) 55 hadError = true 56 } 57 } 58 checkErr("Error restoring some deps. Aborting check.") 59 for _, dep := range g.Deps { 60 verboseln("Checking dependency:", dep.ImportPath) 61 _, err := LoadPackages(dep.ImportPath) 62 if err != nil { 63 log.Printf("Dep (%s) restored, but was unable to load it with error:\n\t%s\n", dep.ImportPath, err) 64 if me, ok := err.(errorMissingDep); ok { 65 log.Println("\tThis may be because the dependencies were saved with an older version of godep (< v33).") 66 log.Printf("\tTry `go get %s`. Then `godep save` to update deps.\n", me.i) 67 } 68 hadError = true 69 } 70 } 71 checkErr("Error checking some deps.") 72 } 73 74 var downloaded = make(map[string]bool) 75 76 // download downloads the given dependency. 77 // 2 Passes: 1) go get -d <pkg>, 2) git pull (if necessary) 78 func download(dep *Dependency) error { 79 80 rr, err := vcs.RepoRootForImportPath(dep.ImportPath, debug) 81 if err != nil { 82 debugln("Error determining repo root for", dep.ImportPath) 83 return err 84 } 85 ppln("rr", rr) 86 87 dep.vcs = cmd[rr.VCS] 88 89 // try to find an existing directory in the GOPATHs 90 for _, gp := range filepath.SplitList(build.Default.GOPATH) { 91 t := filepath.Join(gp, "src", rr.Root) 92 fi, err := os.Stat(t) 93 if err != nil { 94 continue 95 } 96 if fi.IsDir() { 97 dep.root = t 98 break 99 } 100 } 101 102 // If none found, just pick the first GOPATH entry (AFAICT that's what go get does) 103 if dep.root == "" { 104 dep.root = filepath.Join(filepath.SplitList(build.Default.GOPATH)[0], "src", rr.Root) 105 } 106 ppln("dep", dep) 107 108 if downloaded[rr.Repo] { 109 verboseln("Skipping already downloaded repo", rr.Repo) 110 return nil 111 } 112 113 fi, err := os.Stat(dep.root) 114 if err != nil { 115 if os.IsNotExist(err) { 116 if err := os.MkdirAll(filepath.Dir(dep.root), os.ModePerm); err != nil { 117 debugln("Error creating base dir of", dep.root) 118 return err 119 } 120 err := rr.VCS.CreateAtRev(dep.root, rr.Repo, dep.Rev) 121 debugln("CreatedAtRev", dep.root, rr.Repo, dep.Rev) 122 if err != nil { 123 debugln("CreateAtRev error", err) 124 return err 125 } 126 downloaded[rr.Repo] = true 127 return nil 128 } 129 debugln("Error checking repo root for", dep.ImportPath, "at", dep.root, ":", err) 130 return err 131 } 132 133 if !fi.IsDir() { 134 return errors.New("repo root src dir exists, but isn't a directory for " + dep.ImportPath + " at " + dep.root) 135 } 136 137 if !dep.vcs.exists(dep.root, dep.Rev) { 138 debugln("Updating existing", dep.root) 139 dep.vcs.vcs.Download(dep.root) 140 downloaded[rr.Repo] = true 141 } 142 143 debugln("Nothing to download") 144 return nil 145 } 146 147 var restored = make(map[string]string) // dep.root -> dep.Rev 148 149 // restore checks out the given revision. 150 func restore(dep Dependency) error { 151 rev, ok := restored[dep.root] 152 debugln(rev) 153 debugln(ok) 154 debugln(dep.root) 155 if ok { 156 if rev != dep.Rev { 157 return errors.New("Wanted to restore rev " + dep.Rev + ", already restored rev " + rev + " for another package in the repo") 158 } 159 verboseln("Skipping already restored repo") 160 return nil 161 } 162 163 debugln("Restoring:", dep.ImportPath, dep.Rev) 164 pkg, err := build.Import(dep.ImportPath, ".", build.FindOnly) 165 if err != nil { 166 // This should never happen 167 debugln("Error finding package "+dep.ImportPath+" on restore:", err) 168 return err 169 } 170 err = dep.vcs.RevSync(pkg.Dir, dep.Rev) 171 if err == nil { 172 restored[dep.root] = dep.Rev 173 } 174 return err 175 }