func runTest(ctx *cli.Context) {
if err := setup(ctx); err != nil {
errors.SetError(err)
return
}
if err := linkVendors(ctx, ""); err != nil {
errors.SetError(err)
return
}
log.Info("Testing...")
cmdArgs := []string{"go", "test"}
if len(ctx.String("tags")) > 0 {
cmdArgs = append(cmdArgs, "-tags")
cmdArgs = append(cmdArgs, ctx.String("tags"))
}
if ctx.IsSet("verbose") {
cmdArgs = append(cmdArgs, "-v")
}
cmdArgs = append(cmdArgs, ctx.Args()...)
if err := execCmd(setting.DefaultVendor, setting.WorkDir, cmdArgs...); err != nil {
errors.SetError(fmt.Errorf("fail to run program: %v", err))
return
}
log.Info("Command executed successfully!")
}
// getDepList gets list of dependencies in root path format and nature order.
func getDepList(ctx *cli.Context, target, pkgPath, vendor string) ([]string, error) {
vendorSrc := path.Join(vendor, "src")
rootPath := doc.GetRootPath(target)
// If work directory is not in GOPATH, then need to setup a vendor path.
if !setting.HasGOPATHSetting || !strings.HasPrefix(pkgPath, setting.InstallGopath) {
// Make link of self.
log.Debug("Linking %s...", rootPath)
from := pkgPath
to := path.Join(vendorSrc, rootPath)
if setting.Debug {
log.Debug("Linking from %s to %s", from, to)
}
if err := autoLink(from, to); err != nil {
return nil, err
}
}
imports, err := doc.ListImports(target, rootPath, vendor, pkgPath, ctx.String("tags"), ctx.Bool("test"))
if err != nil {
return nil, err
}
list := make([]string, 0, len(imports))
for _, name := range imports {
name = doc.GetRootPath(name)
if !base.IsSliceContainsStr(list, name) {
list = append(list, name)
}
}
sort.Strings(list)
return list, nil
}
func runInstall(ctx *cli.Context) {
if err := setup(ctx); err != nil {
errors.SetError(err)
return
}
if err := linkVendors(ctx, ""); err != nil {
errors.SetError(err)
return
}
// Get target name.
gfPath := path.Join(setting.WorkDir, setting.GOPMFILE)
_, target, err := parseGopmfile(gfPath)
if err != nil {
errors.SetError(fmt.Errorf("fail to parse gopmfile: %v", err))
return
}
log.Info("Installing...")
cmdArgs := []string{"go", "install"}
if ctx.Bool("verbose") {
cmdArgs = append(cmdArgs, "-v")
}
if len(ctx.String("tags")) > 0 {
cmdArgs = append(cmdArgs, "-tags")
cmdArgs = append(cmdArgs, ctx.String("tags"))
}
cmdArgs = append(cmdArgs, target)
if err := execCmd(setting.DefaultVendor, setting.WorkDir, cmdArgs...); err != nil {
errors.SetError(fmt.Errorf("fail to run program: %v", err))
return
}
log.Info("Command executed successfully!")
}
func buildBinary(ctx *cli.Context, args ...string) error {
_, target, err := parseGopmfile(setting.GOPMFILE)
if err != nil {
return err
}
if err := linkVendors(ctx, ""); err != nil {
return err
}
log.Info("Building...")
cmdArgs := []string{"go", "build"}
cmdArgs = append(cmdArgs, args...)
if len(ctx.String("o")) > 0 {
cmdArgs = append(cmdArgs, "-o")
cmdArgs = append(cmdArgs, ctx.String("o"))
}
if len(ctx.String("tags")) > 0 {
cmdArgs = append(cmdArgs, "-tags")
cmdArgs = append(cmdArgs, ctx.String("tags"))
}
if err := execCmd(setting.DefaultVendor, setting.WorkDir, cmdArgs...); err != nil {
return fmt.Errorf("fail to build program: %v", err)
}
if setting.IsWindowsXP {
fName := path.Base(target)
binName := fName + ".exe"
os.Remove(binName)
exePath := path.Join(setting.DefaultVendorSrc, target, binName)
if base.IsFile(exePath) {
if err := os.Rename(exePath, path.Join(setting.WorkDir, binName)); err != nil {
return fmt.Errorf("fail to move binary: %v", err)
}
} else {
log.Warn("No binary generated")
}
}
return nil
}
func runBin(ctx *cli.Context) {
if err := setup(ctx); err != nil {
errors.SetError(err)
return
}
if len(ctx.Args()) != 1 {
errors.SetError(fmt.Errorf("Incorrect number of arguments for command: should have 1"))
return
}
// Check if given directory exists if specified.
if ctx.IsSet("dir") && !base.IsDir(ctx.String("dir")) {
errors.SetError(fmt.Errorf("Indicated path does not exist or not a directory"))
return
}
// Parse package version.
info := ctx.Args().First()
pkgPath := info
n := doc.NewNode(pkgPath, doc.BRANCH, "", true)
if i := strings.Index(info, "@"); i > -1 {
pkgPath = info[:i]
var err error
tp, val, err := validPkgInfo(info[i+1:])
if err != nil {
errors.SetError(err)
return
}
n = doc.NewNode(pkgPath, tp, val, !ctx.Bool("download"))
}
// Check package name.
if !strings.Contains(pkgPath, "/") {
tmpPath, err := setting.GetPkgFullPath(pkgPath)
if err != nil {
errors.SetError(err)
return
}
if tmpPath != pkgPath {
n = doc.NewNode(tmpPath, n.Type, n.Value, n.IsGetDeps)
}
}
if err := downloadPackages(".", ctx, []*doc.Node{n}); err != nil {
errors.SetError(err)
return
}
// Check if previous steps were successful.
if !n.IsExist() {
errors.SetError(fmt.Errorf("Download steps weren't successful"))
return
}
tmpVendor := path.Join("vendor", path.Base(n.RootPath))
os.RemoveAll(tmpVendor)
os.RemoveAll(setting.VENDOR)
// TODO: should use .gopm/temp path.
if err := autoLink(n.InstallPath, tmpVendor); err != nil {
errors.SetError(fmt.Errorf("Fail to link slef: %v", err))
return
}
os.Chdir(tmpVendor)
oldWorkDir := setting.WorkDir
setting.WorkDir = path.Join(setting.WorkDir, tmpVendor)
if !setting.Debug {
defer func() {
os.Chdir(oldWorkDir)
os.RemoveAll("vendor")
os.RemoveAll(setting.VENDOR)
}()
}
// if err := buildBinary(ctx); err != nil {
// errors.SetError(err)
// return
// }
if err := linkVendors(ctx, n.ImportPath); err != nil {
errors.SetError(err)
return
}
log.Info("Installing...")
cmdArgs := []string{"go", "install"}
if ctx.Bool("verbose") {
cmdArgs = append(cmdArgs, "-v")
}
cmdArgs = append(cmdArgs, n.ImportPath)
if err := execCmd(setting.DefaultVendor, setting.WorkDir, cmdArgs...); err != nil {
errors.SetError(fmt.Errorf("fail to run program: %v", err))
return
}
gf, _, err := parseGopmfile(setting.GOPMFILE)
if err != nil {
errors.SetError(err)
return
}
// Because build command moved binary to root path.
binName := path.Base(n.RootPath)
binPath := path.Join(setting.DefaultVendor, "bin", path.Base(n.RootPath))
if runtime.GOOS == "windows" {
binName += ".exe"
}
// Move binary to given directory.
movePath := oldWorkDir
if ctx.IsSet("dir") {
movePath = ctx.String("dir")
} else if strings.HasPrefix(n.ImportPath, "code.google.com/p/go.tools/cmd/") {
movePath = path.Join(runtime.GOROOT(), "pkg/tool", runtime.GOOS+"_"+runtime.GOARCH)
log.Info("Command executed successfully!")
fmt.Println("Binary has been built into: " + movePath)
return
}
if !base.IsFile(binPath) {
errors.SetError(fmt.Errorf("Previous steps weren't successful or the project does not contain main package"))
return
}
if base.IsExist(path.Join(movePath, binName)) {
if err := os.Remove(path.Join(movePath, binName)); err != nil {
log.Warn("Cannot remove binary in work directory: %v", err)
}
}
if err := os.Rename(binPath, movePath+"/"+binName); err != nil {
errors.SetError(fmt.Errorf("Fail to move binary: %v", err))
return
}
os.Chmod(movePath+"/"+binName, os.ModePerm)
includes := strings.Split(gf.MustValue("res", "include"), "|")
if len(includes) > 0 {
log.Info("Copying resources to %s", movePath)
for _, include := range includes {
if base.IsDir(include) {
os.RemoveAll(path.Join(movePath, include))
if err := base.CopyDir(include, filepath.Join(movePath, include)); err != nil {
errors.AppendError(errors.NewErrCopyResource(include))
}
}
}
}
log.Info("Command executed successfully!")
fmt.Println("Binary has been built into: " + movePath)
}
func linkVendors(ctx *cli.Context, optTarget string) error {
gfPath := path.Join(setting.WorkDir, setting.GOPMFILE)
gf, target, err := parseGopmfile(gfPath)
if err != nil {
return fmt.Errorf("fail to parse gopmfile: %v", err)
}
if len(optTarget) > 0 {
target = optTarget
}
rootPath := doc.GetRootPath(target)
// TODO: local support.
// Make link of self.
log.Debug("Linking %s...", rootPath)
from := setting.WorkDir
to := path.Join(setting.DefaultVendorSrc, rootPath)
if setting.Debug {
log.Debug("Linking from %s to %s", from, to)
}
if err := autoLink(from, to); err != nil {
return fmt.Errorf("fail to link self: %v", err)
}
// Check and loads dependency packages.
log.Debug("Loading dependencies...")
imports, err := doc.ListImports(target, rootPath, setting.DefaultVendor, setting.WorkDir, ctx.String("tags"), ctx.Bool("test"))
if err != nil {
return fmt.Errorf("fail to list imports: %v", err)
}
stack := make([]*doc.Pkg, len(imports))
for i, name := range imports {
name := doc.GetRootPath(name)
tp, val, err := validPkgInfo(gf.MustValue("deps", name))
if err != nil {
return fmt.Errorf("fail to validate package(%s): %v", name, err)
}
stack[i] = doc.NewPkg(name, tp, val)
}
// FIXME: at least link once, need a set
lastIdx := len(stack) - 1
for lastIdx >= 0 {
pkg := stack[lastIdx]
linkPath := path.Join(setting.DefaultVendorSrc, pkg.RootPath)
if setting.Debug {
log.Debug("Import path: %s", pkg.ImportPath)
log.Debug("Linking path: %s", linkPath)
}
if base.IsExist(linkPath) {
stack = stack[:lastIdx]
lastIdx = len(stack) - 1
continue
}
if pkg.IsEmptyVal() && setting.HasGOPATHSetting &&
base.IsExist(path.Join(setting.InstallGopath, pkg.RootPath)) {
stack = stack[:lastIdx]
lastIdx = len(stack) - 1
continue
}
venderPath := path.Join(setting.InstallRepoPath, pkg.RootPath+pkg.ValSuffix())
if !base.IsExist(venderPath) {
return fmt.Errorf("package not installed: %s", pkg.RootPath+pkg.VerSuffix())
}
log.Debug("Linking %s...", pkg.RootPath+pkg.ValSuffix())
if err := autoLink(venderPath, linkPath); err != nil {
return fmt.Errorf("fail to link dependency(%s): %v", pkg.RootPath, err)
}
stack = stack[:lastIdx]
gf, target, err := parseGopmfile(path.Join(linkPath, setting.GOPMFILE))
if err != nil {
return fmt.Errorf("fail to parse gopmfile(%s): %v", linkPath, err)
}
// parseGopmfile only returns right target when parse work directory.
target = pkg.RootPath
rootPath := target
imports, err := doc.ListImports(target, rootPath, setting.DefaultVendor, linkPath, ctx.String("tags"), ctx.Bool("test"))
if err != nil {
errors.SetError(err)
}
for _, name := range imports {
if name == "C" {
continue
}
name := doc.GetRootPath(name)
tp, val, err := validPkgInfo(gf.MustValue("deps", name))
if err != nil {
return fmt.Errorf("fail to validate package(%s): %v", name, err)
}
stack = append(stack, doc.NewPkg(name, tp, val))
}
lastIdx = len(stack) - 1
}
return nil
}