blob: 2c4356747474f5fa93be97381fa900eb2abf9929 [file] [log] [blame]
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package packagestest
import (
"context"
"fmt"
"io/ioutil"
"os"
"path"
"path/filepath"
"regexp"
"strings"
"golang.org/x/tools/internal/gocommand"
"golang.org/x/tools/internal/packagesinternal"
"golang.org/x/tools/internal/proxydir"
)
// Modules is the exporter that produces module layouts.
// Each "repository" is put in it's own module, and the module file generated
// will have replace directives for all other modules.
// Given the two files
// golang.org/repoa#a/a.go
// golang.org/repob#b/b.go
// You would get the directory layout
// /sometemporarydirectory
// ├── repoa
// │ ├── a
// │ │ └── a.go
// │ └── go.mod
// └── repob
// ├── b
// │ └── b.go
// └── go.mod
// and the working directory would be
// /sometemporarydirectory/repoa
var Modules = modules{}
type modules struct{}
type moduleAtVersion struct {
module string
version string
}
func (modules) Name() string {
return "Modules"
}
func (modules) Filename(exported *Exported, module, fragment string) string {
if module == exported.primary {
return filepath.Join(primaryDir(exported), fragment)
}
return filepath.Join(moduleDir(exported, module), fragment)
}
func (modules) Finalize(exported *Exported) error {
// Write out the primary module. This module can use symlinks and
// other weird stuff, and will be the working dir for the go command.
// It depends on all the other modules.
primaryDir := primaryDir(exported)
if err := os.MkdirAll(primaryDir, 0755); err != nil {
return err
}
exported.Config.Dir = primaryDir
if exported.written[exported.primary] == nil {
exported.written[exported.primary] = make(map[string]string)
}
// Create a map of modulepath -> {module, version} for modulepaths
// that are of the form `repoa/mod1@v1.1.0`.
versions := make(map[string]moduleAtVersion)
for module := range exported.written {
if splt := strings.Split(module, "@"); len(splt) > 1 {
versions[module] = moduleAtVersion{
module: splt[0],
version: splt[1],
}
}
}
// If the primary module already has a go.mod, write the contents to a temp
// go.mod for now and then we will reset it when we are getting all the markers.
if gomod := exported.written[exported.primary]["go.mod"]; gomod != "" {
contents, err := ioutil.ReadFile(gomod)
if err != nil {
return err
}
if err := ioutil.WriteFile(gomod+".temp", contents, 0644); err != nil {
return err
}
}
exported.written[exported.primary]["go.mod"] = filepath.Join(primaryDir, "go.mod")
primaryGomod := "module " + exported.primary + "\nrequire (\n"
for other := range exported.written {
if other == exported.primary {
continue
}
version := moduleVersion(other)
// If other is of the form `repo1/mod1@v1.1.0`,
// then we need to extract the module and the version.
if v, ok := versions[other]; ok {
other = v.module
version = v.version
}
primaryGomod += fmt.Sprintf("\t%v %v\n", other, version)
}
primaryGomod += ")\n"
if err := ioutil.WriteFile(filepath.Join(primaryDir, "go.mod"), []byte(primaryGomod), 0644); err != nil {
return err
}
// Create the mod cache so we can rename it later, even if we don't need it.
if err := os.MkdirAll(modCache(exported), 0755); err != nil {
return err
}
// Write out the go.mod files for the other modules.
for module, files := range exported.written {
if module == exported.primary {
continue
}
dir := moduleDir(exported, module)
modfile := filepath.Join(dir, "go.mod")
// If other is of the form `repo1/mod1@v1.1.0`,
// then we need to extract the module name without the version.
if v, ok := versions[module]; ok {
module = v.module
}
if err := ioutil.WriteFile(modfile, []byte("module "+module+"\n"), 0644); err != nil {
return err
}
files["go.mod"] = modfile
}
// Zip up all the secondary modules into the proxy dir.
modProxyDir := filepath.Join(exported.temp, "modproxy")
for module, files := range exported.written {
if module == exported.primary {
continue
}
version := moduleVersion(module)
// If other is of the form `repo1/mod1@v1.1.0`,
// then we need to extract the module and the version.
if v, ok := versions[module]; ok {
module = v.module
version = v.version
}
if err := writeModuleFiles(modProxyDir, module, version, files); err != nil {
return fmt.Errorf("creating module proxy dir for %v: %v", module, err)
}
}
// Discard the original mod cache dir, which contained the files written
// for us by Export.
if err := os.Rename(modCache(exported), modCache(exported)+".orig"); err != nil {
return err
}
exported.Config.Env = append(exported.Config.Env,
"GO111MODULE=on",
"GOPATH="+filepath.Join(exported.temp, "modcache"),
"GOMODCACHE=",
"GOPROXY="+proxydir.ToURL(modProxyDir),
"GOSUMDB=off",
)
gocmdRunner := &gocommand.Runner{}
packagesinternal.SetGoCmdRunner(exported.Config, gocmdRunner)
// Run go mod download to recreate the mod cache dir with all the extra
// stuff in cache. All the files created by Export should be recreated.
inv := gocommand.Invocation{
Verb: "mod",
Args: []string{"download", "all"},
Env: exported.Config.Env,
BuildFlags: exported.Config.BuildFlags,
WorkingDir: exported.Config.Dir,
}
if _, err := gocmdRunner.Run(context.Background(), inv); err != nil {
return err
}
return nil
}
func writeModuleFiles(rootDir, module, ver string, filePaths map[string]string) error {
fileData := make(map[string][]byte)
for name, path := range filePaths {
contents, err := ioutil.ReadFile(path)
if err != nil {
return err
}
fileData[name] = contents
}
return proxydir.WriteModuleVersion(rootDir, module, ver, fileData)
}
func modCache(exported *Exported) string {
return filepath.Join(exported.temp, "modcache/pkg/mod")
}
func primaryDir(exported *Exported) string {
return filepath.Join(exported.temp, path.Base(exported.primary))
}
func moduleDir(exported *Exported, module string) string {
if strings.Contains(module, "@") {
return filepath.Join(modCache(exported), module)
}
return filepath.Join(modCache(exported), path.Dir(module), path.Base(module)+"@"+moduleVersion(module))
}
var versionSuffixRE = regexp.MustCompile(`v\d+`)
func moduleVersion(module string) string {
if versionSuffixRE.MatchString(path.Base(module)) {
return path.Base(module) + ".0.0"
}
return "v1.0.0"
}