package git import ( "errors" "fmt" "os" "os/exec" "path/filepath" "regexp" "strings" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/config" "github.com/go-git/go-git/v5/plumbing" ) type Gitter interface { Clone(repo string) error FetchAll(repo string) error Checkout(repo, branchOrCommit string) error RepoDir(repo string) string } type libGitter struct { folder string } func (g libGitter) Clone(repo string) error { fold := filepath.Join(g.folder, dirifyRepo(repo)) exists, err := pathExists(fold) if err != nil { return err } if exists { return nil } _, err = git.PlainClone(fold, false, &git.CloneOptions{ URL: repo, Progress: os.Stdout, }) return err } func (g libGitter) FetchAll(repo string) error { repos, err := git.PlainOpen(filepath.Join(g.folder, dirifyRepo(repo))) if err != nil { return err } remotes, err := repos.Remotes() if err != nil { return err } err = remotes[0].Fetch(&git.FetchOptions{ RefSpecs: []config.RefSpec{"refs/*:refs/*", "HEAD:refs/heads/HEAD"}, Progress: os.Stdout, Depth: 1, }) if err != nil && err != git.NoErrAlreadyUpToDate { return err } return nil } func (g libGitter) Checkout(repo, branchOrCommit string) error { if branchOrCommit == "latest" { branchOrCommit = "master" } repos, err := git.PlainOpen(filepath.Join(g.folder, dirifyRepo(repo))) if err != nil { return err } worktree, err := repos.Worktree() if err != nil { return err } if plumbing.IsHash(branchOrCommit) { return worktree.Checkout(&git.CheckoutOptions{ Hash: plumbing.NewHash(branchOrCommit), Force: true, }) } return worktree.Checkout(&git.CheckoutOptions{ Branch: plumbing.NewBranchReferenceName(branchOrCommit), Force: true, }) } func (g libGitter) RepoDir(repo string) string { return filepath.Join(g.folder, dirifyRepo(repo)) } type binaryGitter struct { folder string } func (g binaryGitter) Clone(repo string) error { fold := filepath.Join(g.folder, dirifyRepo(repo), ".git") exists, err := pathExists(fold) if err != nil { return err } if exists { return nil } fold = filepath.Join(g.folder, dirifyRepo(repo)) cmd := exec.Command("git", "clone", repo, ".") err = os.MkdirAll(fold, 0777) if err != nil { return err } cmd.Dir = fold _, err = cmd.Output() if err != nil { return err } return err } func (g binaryGitter) FetchAll(repo string) error { cmd := exec.Command("git", "fetch", "--all") cmd.Dir = filepath.Join(g.folder, dirifyRepo(repo)) outp, err := cmd.CombinedOutput() if err != nil { return errors.New(string(outp)) } return err } func (g binaryGitter) Checkout(repo, branchOrCommit string) error { if branchOrCommit == "latest" { branchOrCommit = "master" } cmd := exec.Command("git", "checkout", "-f", branchOrCommit) cmd.Dir = filepath.Join(g.folder, dirifyRepo(repo)) outp, err := cmd.CombinedOutput() if err != nil { return errors.New(string(outp)) } return nil } func (g binaryGitter) RepoDir(repo string) string { return filepath.Join(g.folder, dirifyRepo(repo)) } func NewGitter(folder string) Gitter { if commandExists("git") { return binaryGitter{folder} } return libGitter{folder} } func commandExists(cmd string) bool { _, err := exec.LookPath(cmd) return err == nil } func dirifyRepo(s string) string { s = strings.ReplaceAll(s, "https://", "") s = strings.ReplaceAll(s, "/", "-") return s } // exists returns whether the given file or directory exists func pathExists(path string) (bool, error) { _, err := os.Stat(path) if err == nil { return true, nil } if os.IsNotExist(err) { return false, nil } return true, err } // GetRepoRoot determines the repo root from a full path. // Returns empty string and no error if not found func GetRepoRoot(fullPath string) (string, error) { // traverse parent directories prev := fullPath for { current := prev exists, err := pathExists(filepath.Join(current, ".git")) if err != nil { return "", err } if exists { return current, nil } prev = filepath.Dir(current) // reached top level, see: // https://play.golang.org/p/rDgVdk3suzb if current == prev { break } } return "", nil } const defaultRepo = "github.com/micro/services" // Source is not just git related @todo move type Source struct { // is it a local folder intended for a local runtime? Local bool // absolute path to service folder in local mode FullPath string // path of folder to repo root // be it local or github repo Folder string // github ref Ref string // for cloning purposes // blank for local Repo string // dir to repo root // blank for non local LocalRepoRoot string } // Name to be passed to RPC call runtime.Create Update Delete // eg: `helloworld/api`, `crufter/myrepo/helloworld/api`, `localfolder` func (s *Source) RuntimeName() string { if s.Repo == "github.com/micro/services" || s.Repo == "" { return s.Folder } return fmt.Sprintf("%v/%v", strings.ReplaceAll(s.Repo, "github.com/", ""), s.Folder) } // Source to be passed to RPC call runtime.Create Update Delete // eg: `helloworld`, `github.com/crufter/myrepo/helloworld`, `/path/to/localrepo/localfolder` func (s *Source) RuntimeSource() string { if s.Local { return s.FullPath } if s.Repo == "github.com/micro/services" || s.Repo == "" { return s.Folder } return fmt.Sprintf("%v/%v", s.Repo, s.Folder) } // ParseSource parses a `micro run/update/kill` source. func ParseSource(source string) (*Source, error) { // If github is not present, we got a shorthand for `micro/services` if !strings.Contains(source, "github.com") { source = "github.com/micro/services/" + source } if !strings.Contains(source, "@") { source += "@latest" } ret := &Source{} refs := strings.Split(source, "@") ret.Ref = refs[1] parts := strings.Split(refs[0], "/") ret.Repo = strings.Join(parts[0:3], "/") if len(parts) > 1 { ret.Folder = strings.Join(parts[3:], "/") } return ret, nil } // ParseSourceLocal detects and handles local pathes too // workdir should be used only from the CLI @todo better interface for this function. // PathExistsFunc exists only for testing purposes, to make the function side effect free. func ParseSourceLocal(workDir, source string, pathExistsFunc ...func(path string) (bool, error)) (*Source, error) { var pexists func(string) (bool, error) if len(pathExistsFunc) == 0 { pexists = pathExists } else { pexists = pathExistsFunc[0] } var localFullPath string if len(workDir) > 0 { localFullPath = filepath.Join(workDir, source) } else { localFullPath = source } if exists, err := pexists(localFullPath); err == nil && exists { localRepoRoot, err := GetRepoRoot(localFullPath) if err != nil { return nil, err } var folder string // If the local repo root is a top level folder, we are not in a git repo. // In this case, we should take the last folder as folder name. if localRepoRoot == "" { folder = filepath.Base(localFullPath) } else { folder = strings.ReplaceAll(localFullPath, localRepoRoot+string(filepath.Separator), "") } return &Source{ Local: true, Folder: folder, FullPath: localFullPath, LocalRepoRoot: localRepoRoot, Ref: "latest", // @todo consider extracting branch from git here }, nil } return ParseSource(source) } // CheckoutSource for the local runtime server // folder is the folder to check out the source code to // Modifies source path to set it to checked out repo absolute path locally. func CheckoutSource(folder string, source *Source) error { // if it's a local folder, do nothing if exists, err := pathExists(source.FullPath); err == nil && exists { return nil } gitter := NewGitter(folder) repo := source.Repo if !strings.Contains(repo, "https://") { repo = "https://" + repo } // Always clone, it's idempotent and only clones if needed err := gitter.Clone(repo) if err != nil { return err } source.FullPath = filepath.Join(gitter.RepoDir(source.Repo), source.Folder) return gitter.Checkout(repo, source.Ref) } // code below is not used yet var nameExtractRegexp = regexp.MustCompile(`((micro|web)\.Name\(")(.*)("\))`) func extractServiceName(fileContent []byte) string { hits := nameExtractRegexp.FindAll(fileContent, 1) if len(hits) == 0 { return "" } hit := string(hits[0]) return strings.Split(hit, "\"")[1] }