forgepb/clone.go

215 lines
6.1 KiB
Go

package forgepb
import (
"errors"
"fmt"
"io/ioutil"
"net/http"
"path/filepath"
"strings"
"go.wit.com/lib/protobuf/gitpb"
"go.wit.com/log"
)
// will not violate filesystem namespace
// always returns the path or a parent path
//
// attemps to exec git clone based off of a golang path
// will transferse parent directories in case the path
// is a child of a git repo
//
// returns *gitpb.Repo if already cloned
//
// example gopath = go.wit.com/apps/go-clone
// or "go.googlesource.com/go/src/cmd/internal/pkgpath/" returns repo for "go.googlesource.com/go"
func (f *Forge) GoClone(gopath string) (*gitpb.Repo, error) {
// will match /root/go/src/go.wit.com/apps/go-clone/something/inside
// and return the *gitpb.Repo for "go.wit.com/apps/go-clone"
fullpath := filepath.Join(f.goSrc, gopath)
if pb := f.FindAnyPath(fullpath); pb != nil {
// repo already exists
return pb, nil
}
// try a direct git clone against the gopath
// if this doesn't work, probably the package is abandoned and you
// are probably using something old, broken, or wrong
if repo, err := f.urlClone(gopath, "https://"+gopath); repo != nil {
return repo, err
}
// check for parent git repos
if repo, err := f.goClonePop(gopath); repo != nil {
return repo, err
}
// query the golang package system for the last known location
// NOTE: take time to thank the go developers and google for designing this wonderful system
if pkgurl, err := runGoList(gopath); err == nil {
if repo, err := f.urlClone(gopath, pkgurl); repo != nil {
return repo, err
}
}
// todo: emit some sort of warning?
// hacks
if repo, err := f.clonePathHack(gopath); repo != nil {
return repo, err
}
return nil, errors.New("can not find git sources for gopath " + gopath)
}
// this is obvious a experiemental hack
// todo: make a config file for this?
func overridePath(gopath string) string {
switch gopath {
case "golang.org/x/crypto":
return "https://" + "go.googlesource.com/crypto"
case "golang.org/x/mod":
return "https://" + "go.googlesource.com/mod"
case "golang.org/x/net":
return "https://" + "go.googlesource.com/net"
case "golang.org/x/sys":
return "https://" + "go.googlesource.com/sys"
case "golang.org/x/sync":
return "https://" + "go.googlesource.com/sync"
case "golang.org/x/term":
return "https://" + "go.googlesource.com/term"
case "golang.org/x/text":
return "https://" + "go.googlesource.com/text"
case "golang.org/x/tools":
return "https://" + "go.googlesource.com/tools"
case "golang.org/x/xerrors":
return "https://" + "go.googlesource.com/xerrors"
case "google.golang.org/protobuf":
return "https://" + "go.googlesource.com/protobuf"
case "google.golang.org/genproto":
return "https://" + "go.googlesource.com/genproto"
case "google.golang.org/api":
return "https://" + "go.googlesource.com/api"
case "google.golang.org/grpc":
return "https://" + "go.googlesource.com/grpc"
case "google.golang.org/appengine":
return "https://" + "go.googlesource.com/appengine"
}
if strings.HasPrefix(gopath, "github.com/go-gl/glfw") {
return "https://github.com/go-gl/glfw"
}
return ""
}
// TODO: make some config file for things like this
// can be used to work around temporary problems
func (f *Forge) clonePathHack(gopath string) (*gitpb.Repo, error) {
// newdir = helloworld
// basedir = /home/jcarr/go/src/go.wit.com/apps
// giturl = https://gitea.wit.com/gui/helloworld
url := overridePath(gopath)
if url == "" {
return nil, errors.New("no gopath override here")
}
return f.urlClone(gopath, url)
}
// for: github.com/gdamore/tcell/v2
// tries git clone github.com/gdamore/tcell/v2
// then git clone github.com/gdamore/tcell
// then git clone github.com/gdamore , etc
func (f *Forge) goClonePop(gopath string) (*gitpb.Repo, error) {
log.Info("forge.goClonePop() trying", gopath)
if gopath == "" {
return nil, nil
}
newpath, newdir := filepath.Split(gopath)
if newdir == "" {
// nothing to chop
return nil, nil
}
if repo, _ := f.urlClone(newpath, "https://"+newpath); repo != nil {
return repo, nil
}
if repo, err := f.goClonePop(newpath); repo != nil {
return repo, err
}
return nil, fmt.Errorf("forge.goClonePop() did not work %s", gopath)
}
// clone a URL directly, also try cloning if 'go-import' is sent
// newdir = helloworld
// basedir = /home/jcarr/go/src/go.wit.com/apps
// giturl = https://gitea.wit.com/gui/helloworld
func (f *Forge) urlClone(gopath, giturl string) (*gitpb.Repo, error) {
var err error
fullpath := filepath.Join(f.goSrc, gopath)
basedir, newdir := filepath.Split(fullpath)
// clone the URL directly
if err = RunGitClone(newdir, basedir, giturl); err == nil {
return f.NewGoRepo(gopath, giturl)
}
// see if the URL has go-import for a new URL
if giturl, err = findGoImport(giturl); err == nil {
if err = RunGitClone(newdir, basedir, giturl); err == nil {
return f.NewGoRepo(gopath, giturl)
}
}
// log.Info("git clone from 'go-import' info failed", url)
// yes, this misses the first error
return nil, err
}
// check the server for the current go path to git url mapping
// for example:
// This will check go.wit.com for "go.wit.com/apps/go-clone"
// and return where the URL to do git clone should be
func findGoImport(url string) (string, error) {
resp, err := http.Get(url)
if err != nil {
return "", err
}
defer resp.Body.Close()
bodyBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
tmp := string(bodyBytes)
parts := strings.Split(tmp, "go-import")
if len(parts) < 2 {
return "", errors.New("missing go-import")
}
// this is terrible, it doesn't even look for 'content='
// but again, this is just a hack for my own code to be
// usuable after the removal in go v1.22 of the go get clone behavior that was in v1.21
parts = strings.Split(parts[1], "\"")
var newurl string
for {
if len(parts) == 0 {
break
}
tmp := strings.TrimSpace(parts[0])
fields := strings.Split(tmp, " ")
// log.Info("FIELDS:", fields)
if len(fields) == 3 {
newurl = fields[2]
break
}
parts = parts[1:]
}
if newurl == "" {
return "", errors.New("missing git content string")
}
return newurl, nil
}