Something went wrong. Try again.
Monorepo for Tangled
Something went wrong. Try again.
11 kB · 543 lines
Go
at commit ca2bb4cd
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544package git
import ( "archive/tar" "bytes" "fmt" "io" "io/fs" "os/exec" "path" "sort" "strconv" "strings" "sync" "time"
"github.com/dgraph-io/ristretto" "github.com/go-git/go-git/v5" "github.com/go-git/go-git/v5/plumbing" "github.com/go-git/go-git/v5/plumbing/object" "tangled.sh/tangled.sh/core/types")
var ( commitCache *ristretto.Cache cacheMu sync.RWMutex)
func init() { cache, _ := ristretto.NewCache(&ristretto.Config{ NumCounters: 1e7, MaxCost: 1 << 30, BufferItems: 64, TtlTickerDurationInSec: 120, }) commitCache = cache}
var ( ErrBinaryFile = fmt.Errorf("binary file") ErrNotBinaryFile = fmt.Errorf("not binary file"))
type GitRepo struct { path string r *git.Repository h plumbing.Hash}
type TagList struct { refs []*TagReference r *git.Repository}
// TagReference is used to list both tag and non-annotated tags.// Non-annotated tags should only contains a reference.// Annotated tags should contain its reference and its tag information.type TagReference struct { ref *plumbing.Reference tag *object.Tag}
// infoWrapper wraps the property of a TreeEntry so it can export fs.FileInfo// to tar WriteHeadertype infoWrapper struct { name string size int64 mode fs.FileMode modTime time.Time isDir bool}
func (self *TagList) Len() int { return len(self.refs)}
func (self *TagList) Swap(i, j int) { self.refs[i], self.refs[j] = self.refs[j], self.refs[i]}
// sorting tags in reverse chronological orderfunc (self *TagList) Less(i, j int) bool { var dateI time.Time var dateJ time.Time
if self.refs[i].tag != nil { dateI = self.refs[i].tag.Tagger.When } else { c, err := self.r.CommitObject(self.refs[i].ref.Hash()) if err != nil { dateI = time.Now() } else { dateI = c.Committer.When } }
if self.refs[j].tag != nil { dateJ = self.refs[j].tag.Tagger.When } else { c, err := self.r.CommitObject(self.refs[j].ref.Hash()) if err != nil { dateJ = time.Now() } else { dateJ = c.Committer.When } }
return dateI.After(dateJ)}
func Open(path string, ref string) (*GitRepo, error) { var err error g := GitRepo{path: path} g.r, err = git.PlainOpen(path) if err != nil { return nil, fmt.Errorf("opening %s: %w", path, err) }
if ref == "" { head, err := g.r.Head() if err != nil { return nil, fmt.Errorf("getting head of %s: %w", path, err) } g.h = head.Hash() } else { hash, err := g.r.ResolveRevision(plumbing.Revision(ref)) if err != nil { return nil, fmt.Errorf("resolving rev %s for %s: %w", ref, path, err) } g.h = *hash } return &g, nil}
func PlainOpen(path string) (*GitRepo, error) { var err error g := GitRepo{path: path} g.r, err = git.PlainOpen(path) if err != nil { return nil, fmt.Errorf("opening %s: %w", path, err) } return &g, nil}
func (g *GitRepo) Commits() ([]*object.Commit, error) { ci, err := g.r.Log(&git.LogOptions{From: g.h}) if err != nil { return nil, fmt.Errorf("commits from ref: %w", err) }
commits := []*object.Commit{} ci.ForEach(func(c *object.Commit) error { commits = append(commits, c) return nil })
return commits, nil}
func (g *GitRepo) Commit(h plumbing.Hash) (*object.Commit, error) { return g.r.CommitObject(h)}
func (g *GitRepo) LastCommit() (*object.Commit, error) { c, err := g.r.CommitObject(g.h) if err != nil { return nil, fmt.Errorf("last commit: %w", err) } return c, nil}
func (g *GitRepo) FileContentN(path string, cap int64) ([]byte, error) { buf := []byte{}
c, err := g.r.CommitObject(g.h) if err != nil { return nil, fmt.Errorf("commit object: %w", err) }
tree, err := c.Tree() if err != nil { return nil, fmt.Errorf("file tree: %w", err) }
file, err := tree.File(path) if err != nil { return nil, err }
isbin, _ := file.IsBinary()
if !isbin { reader, err := file.Reader() if err != nil { return nil, err } bufReader := io.LimitReader(reader, cap) _, err = bufReader.Read(buf) if err != nil { return nil, err } return buf, nil } else { return nil, ErrBinaryFile }}
func (g *GitRepo) FileContent(path string) (string, error) { c, err := g.r.CommitObject(g.h) if err != nil { return "", fmt.Errorf("commit object: %w", err) }
tree, err := c.Tree() if err != nil { return "", fmt.Errorf("file tree: %w", err) }
file, err := tree.File(path) if err != nil { return "", err }
isbin, _ := file.IsBinary()
if !isbin { return file.Contents() } else { return "", ErrBinaryFile }}
func (g *GitRepo) RawContent(path string) ([]byte, error) { c, err := g.r.CommitObject(g.h) if err != nil { return nil, fmt.Errorf("commit object: %w", err) }
tree, err := c.Tree() if err != nil { return nil, fmt.Errorf("file tree: %w", err) }
file, err := tree.File(path) if err != nil { return nil, err }
reader, err := file.Reader() if err != nil { return nil, fmt.Errorf("opening file reader: %w", err) } defer reader.Close()
return io.ReadAll(reader)}
func (g *GitRepo) Tags() ([]*TagReference, error) { iter, err := g.r.Tags() if err != nil { return nil, fmt.Errorf("tag objects: %w", err) }
tags := make([]*TagReference, 0)
if err := iter.ForEach(func(ref *plumbing.Reference) error { obj, err := g.r.TagObject(ref.Hash()) switch err { case nil: tags = append(tags, &TagReference{ ref: ref, tag: obj, }) case plumbing.ErrObjectNotFound: tags = append(tags, &TagReference{ ref: ref, }) default: return err } return nil }); err != nil { return nil, err }
tagList := &TagList{r: g.r, refs: tags} sort.Sort(tagList) return tags, nil}
func (g *GitRepo) Branches() ([]types.Branch, error) { bi, err := g.r.Branches() if err != nil { return nil, fmt.Errorf("branchs: %w", err) }
branches := []types.Branch{}
defaultBranch, err := g.FindMainBranch()
_ = bi.ForEach(func(ref *plumbing.Reference) error { b := types.Branch{} b.Hash = ref.Hash().String() b.Name = ref.Name().Short()
// resolve commit that this branch points to commit, _ := g.Commit(ref.Hash()) if commit != nil { b.Commit = commit }
if defaultBranch != "" && defaultBranch == b.Name { b.IsDefault = true }
branches = append(branches, b)
return nil })
return branches, nil}
func (g *GitRepo) Branch(name string) (*plumbing.Reference, error) { ref, err := g.r.Reference(plumbing.NewBranchReferenceName(name), false) if err != nil { return nil, fmt.Errorf("branch: %w", err) }
if !ref.Name().IsBranch() { return nil, fmt.Errorf("branch: %s is not a branch", ref.Name()) }
return ref, nil}
func (g *GitRepo) SetDefaultBranch(branch string) error { ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.NewBranchReferenceName(branch)) return g.r.Storer.SetReference(ref)}
func (g *GitRepo) FindMainBranch() (string, error) { ref, err := g.r.Head() if err != nil { return "", fmt.Errorf("unable to find main branch: %w", err) } if ref.Name().IsBranch() { return strings.TrimPrefix(string(ref.Name()), "refs/heads/"), nil }
return "", fmt.Errorf("unable to find main branch: %w", err)}
// WriteTar writes itself from a tree into a binary tar file format.// prefix is root folder to be appended.func (g *GitRepo) WriteTar(w io.Writer, prefix string) error { tw := tar.NewWriter(w) defer tw.Close()
c, err := g.r.CommitObject(g.h) if err != nil { return fmt.Errorf("commit object: %w", err) }
tree, err := c.Tree() if err != nil { return err }
walker := object.NewTreeWalker(tree, true, nil) defer walker.Close()
name, entry, err := walker.Next() for ; err == nil; name, entry, err = walker.Next() { info, err := newInfoWrapper(name, prefix, &entry, tree) if err != nil { return err }
header, err := tar.FileInfoHeader(info, "") if err != nil { return err }
err = tw.WriteHeader(header) if err != nil { return err }
if !info.IsDir() { file, err := tree.File(name) if err != nil { return err }
reader, err := file.Blob.Reader() if err != nil { return err }
_, err = io.Copy(tw, reader) if err != nil { reader.Close() return err } reader.Close() } }
return nil}
func (g *GitRepo) LastCommitForPath(path string) (*types.LastCommitInfo, error) { cacheKey := fmt.Sprintf("%s:%s", g.h.String(), path) cacheMu.RLock() if commitInfo, found := commitCache.Get(cacheKey); found { cacheMu.RUnlock() return commitInfo.(*types.LastCommitInfo), nil } cacheMu.RUnlock()
cmd := exec.Command("git", "-C", g.path, "log", g.h.String(), "-1", "--format=%H %ct", "--", path)
var out bytes.Buffer cmd.Stdout = &out cmd.Stderr = &out
if err := cmd.Run(); err != nil { return nil, fmt.Errorf("failed to get commit hash: %w", err) }
output := strings.TrimSpace(out.String()) if output == "" { return nil, fmt.Errorf("no commits found for path: %s", path) }
parts := strings.SplitN(output, " ", 2) if len(parts) < 2 { return nil, fmt.Errorf("unexpected commit log format") }
commitHash := parts[0] commitTimeUnix, err := strconv.ParseInt(parts[1], 10, 64) if err != nil { return nil, fmt.Errorf("parsing commit time: %w", err) } commitTime := time.Unix(commitTimeUnix, 0)
hash := plumbing.NewHash(commitHash)
commitInfo := &types.LastCommitInfo{ Hash: hash, Message: "", When: commitTime, }
cacheMu.Lock() commitCache.Set(cacheKey, commitInfo, 1) cacheMu.Unlock()
return commitInfo, nil}
func newInfoWrapper( name string, prefix string, entry *object.TreeEntry, tree *object.Tree,) (*infoWrapper, error) { var ( size int64 mode fs.FileMode isDir bool )
if entry.Mode.IsFile() { file, err := tree.TreeEntryFile(entry) if err != nil { return nil, err } mode = fs.FileMode(file.Mode)
size, err = tree.Size(name) if err != nil { return nil, err } } else { isDir = true mode = fs.ModeDir | fs.ModePerm }
fullname := path.Join(prefix, name) return &infoWrapper{ name: fullname, size: size, mode: mode, modTime: time.Unix(0, 0), isDir: isDir, }, nil}
func (i *infoWrapper) Name() string { return i.name}
func (i *infoWrapper) Size() int64 { return i.size}
func (i *infoWrapper) Mode() fs.FileMode { return i.mode}
func (i *infoWrapper) ModTime() time.Time { return i.modTime}
func (i *infoWrapper) IsDir() bool { return i.isDir}
func (i *infoWrapper) Sys() any { return nil}
func (t *TagReference) Name() string { return t.ref.Name().Short()}
func (t *TagReference) Message() string { if t.tag != nil { return t.tag.Message } return ""}
func (t *TagReference) TagObject() *object.Tag { return t.tag}
func (t *TagReference) Hash() plumbing.Hash { return t.ref.Hash()}