Fast implementation of Git in pure Go codeberg.org/lindenii/furgit
git go
6
fork

Configure Feed

Select the types of activity you want to include in your feed.

commitquery: Use fetcher

Runxi Yu ecdae2b7 df73a4c6

+84 -52
+4 -4
commitquery/queries.go
··· 4 4 "sync" 5 5 6 6 commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" 7 - objectstore "codeberg.org/lindenii/furgit/object/store" 7 + objectfetch "codeberg.org/lindenii/furgit/object/fetch" 8 8 ) 9 9 10 - // Queries provides commit-domain queries over one object store 10 + // Queries provides commit-domain queries over one object fetcher 11 11 // and optional commit-graph reader. 12 12 // 13 13 // Queries reuses internal mutable query workers across operations. 14 14 // 15 15 // Labels: MT-Safe. 16 16 type Queries struct { 17 - store objectstore.ReadingStore 18 - graph *commitgraphread.Reader 17 + fetcher *objectfetch.Fetcher 18 + graph *commitgraphread.Reader 19 19 20 20 mu sync.Mutex 21 21 idle []*query
+1 -1
commitquery/queries_acquire.go
··· 7 7 8 8 count := len(queries.idle) 9 9 if count == 0 { 10 - return newQuery(queries.store, queries.graph) 10 + return newQuery(queries.fetcher, queries.graph) 11 11 } 12 12 13 13 q := queries.idle[count-1]
+5 -4
commitquery/queries_is_ancestor_integration_test.go
··· 7 7 "codeberg.org/lindenii/furgit/commitquery" 8 8 giterrors "codeberg.org/lindenii/furgit/errors" 9 9 "codeberg.org/lindenii/furgit/internal/testgit" 10 + "codeberg.org/lindenii/furgit/object/fetch" 10 11 objectid "codeberg.org/lindenii/furgit/object/id" 11 12 ) 12 13 ··· 33 34 34 35 store := testRepo.OpenObjectStore(t) 35 36 36 - got, err := commitquery.New(store, nil).IsAncestor(c1, tag) 37 + got, err := commitquery.New(fetch.New(store), nil).IsAncestor(c1, tag) 37 38 if err != nil { 38 39 t.Fatalf("Is(c1, tag): %v", err) 39 40 } ··· 43 44 t.Fatalf("Is(c1, tag)=%v, want %v", got, want) 44 45 } 45 46 46 - got, err = commitquery.New(store, nil).IsAncestor(c3, c2) 47 + got, err = commitquery.New(fetch.New(store), nil).IsAncestor(c3, c2) 47 48 if err != nil { 48 49 t.Fatalf("Is(c3, c2): %v", err) 49 50 } ··· 78 79 store := testRepo.OpenObjectStore(t) 79 80 graph := testRepo.OpenCommitGraph(t) 80 81 81 - got, err := commitquery.New(store, graph).IsAncestor(c1, c2) 82 + got, err := commitquery.New(fetch.New(store), graph).IsAncestor(c1, c2) 82 83 if err != nil { 83 84 t.Fatalf("Is(c1, c2): %v", err) 84 85 } ··· 106 107 107 108 store := testRepo.OpenObjectStore(t) 108 109 109 - _, err := commitquery.New(store, nil).IsAncestor(treeID, commitID) 110 + _, err := commitquery.New(fetch.New(store), nil).IsAncestor(treeID, commitID) 110 111 if err == nil { 111 112 t.Fatal("expected error") 112 113 }
+4 -3
commitquery/queries_is_ancestor_unit_test.go
··· 7 7 8 8 giterrors "codeberg.org/lindenii/furgit/errors" 9 9 "codeberg.org/lindenii/furgit/internal/testgit" 10 + "codeberg.org/lindenii/furgit/object/fetch" 10 11 objectid "codeberg.org/lindenii/furgit/object/id" 11 12 "codeberg.org/lindenii/furgit/object/store/memory" 12 13 objecttree "codeberg.org/lindenii/furgit/object/tree" ··· 71 72 c3 := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(otherTree)) 72 73 tag := store.AddObject(objecttype.TypeTag, ancestorTagBody(c2, objecttype.TypeCommit)) 73 74 74 - ok, err := commitquery.New(store, nil).IsAncestor(c1, tag) 75 + ok, err := commitquery.New(fetch.New(store), nil).IsAncestor(c1, tag) 75 76 if err != nil { 76 77 t.Fatalf("Is(c1, tag): %v", err) 77 78 } ··· 80 81 t.Fatal("expected c1 to be ancestor of tag->c2") 81 82 } 82 83 83 - ok, err = commitquery.New(store, nil).IsAncestor(c3, c2) 84 + ok, err = commitquery.New(fetch.New(store), nil).IsAncestor(c3, c2) 84 85 if err != nil { 85 86 t.Fatalf("Is(c3, c2): %v", err) 86 87 } ··· 105 106 commit := store.AddObject(objecttype.TypeCommit, ancestorCommitBody(tree)) 106 107 tagToTree := store.AddObject(objecttype.TypeTag, ancestorTagBody(tree, objecttype.TypeTree)) 107 108 108 - _, err := commitquery.New(store, nil).IsAncestor(commit, tagToTree) 109 + _, err := commitquery.New(fetch.New(store), nil).IsAncestor(commit, tagToTree) 109 110 if err == nil { 110 111 t.Fatal("expected error") 111 112 }
+6 -5
commitquery/queries_merge_bases_integration_test.go
··· 8 8 9 9 "codeberg.org/lindenii/furgit/commitquery" 10 10 "codeberg.org/lindenii/furgit/internal/testgit" 11 + "codeberg.org/lindenii/furgit/object/fetch" 11 12 objectid "codeberg.org/lindenii/furgit/object/id" 12 13 ) 13 14 ··· 34 35 35 36 store := testRepo.OpenObjectStore(t) 36 37 37 - query := commitquery.New(store, nil) 38 + query := commitquery.New(fetch.New(store), nil) 38 39 39 40 all, err := query.MergeBases(left, tag) 40 41 if err != nil { ··· 77 78 78 79 store := testRepo.OpenObjectStore(t) 79 80 80 - query := commitquery.New(store, nil) 81 + query := commitquery.New(fetch.New(store), nil) 81 82 82 83 all, err := query.MergeBases(left, right) 83 84 if err != nil { ··· 138 139 store := testRepo.OpenObjectStore(t) 139 140 graph := testRepo.OpenCommitGraph(t) 140 141 141 - query := commitquery.New(store, graph) 142 + query := commitquery.New(fetch.New(store), graph) 142 143 143 144 all, err := query.MergeBases(left, right) 144 145 if err != nil { ··· 200 201 201 202 store := testRepo.OpenObjectStore(t) 202 203 203 - query := commitquery.New(store, nil) 204 + query := commitquery.New(fetch.New(store), nil) 204 205 205 206 got, ok, err := query.MergeBase(left, right) 206 207 if err != nil { ··· 222 223 223 224 graph := testRepo.OpenCommitGraph(t) 224 225 225 - got, ok, err = commitquery.New(store, graph).MergeBase(left, right) 226 + got, ok, err = commitquery.New(fetch.New(store), graph).MergeBase(left, right) 226 227 if err != nil { 227 228 t.Fatalf("Base(left, right) with commit-graph: %v", err) 228 229 }
+7 -6
commitquery/queries_merge_bases_unit_test.go
··· 10 10 "codeberg.org/lindenii/furgit/commitquery" 11 11 giterrors "codeberg.org/lindenii/furgit/errors" 12 12 "codeberg.org/lindenii/furgit/internal/testgit" 13 + "codeberg.org/lindenii/furgit/object/fetch" 13 14 objectid "codeberg.org/lindenii/furgit/object/id" 14 15 "codeberg.org/lindenii/furgit/object/store/memory" 15 16 "codeberg.org/lindenii/furgit/object/tree" ··· 83 84 left := store.AddObject(objecttype.TypeCommit, commitBody(tree, base)) 84 85 right := store.AddObject(objecttype.TypeCommit, commitBody(tree, left)) 85 86 86 - query := commitquery.New(store, nil) 87 + query := commitquery.New(fetch.New(store), nil) 87 88 88 89 got, err := query.MergeBases(left, right) 89 90 if err != nil { ··· 130 131 right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree, base)) 131 132 tag := store.AddObject(objecttype.TypeTag, tagBody(right, objecttype.TypeCommit)) 132 133 133 - query := commitquery.New(store, nil) 134 + query := commitquery.New(fetch.New(store), nil) 134 135 135 136 got, err := query.MergeBases(left, tag) 136 137 if err != nil { ··· 180 181 left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree, base1, base2)) 181 182 right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree, base2, base1)) 182 183 183 - query := commitquery.New(store, nil) 184 + query := commitquery.New(fetch.New(store), nil) 184 185 185 186 all, err := query.MergeBases(left, right) 186 187 if err != nil { ··· 229 230 left := store.AddObject(objecttype.TypeCommit, commitBody(leftTree)) 230 231 right := store.AddObject(objecttype.TypeCommit, commitBody(rightTree)) 231 232 232 - query := commitquery.New(store, nil) 233 + query := commitquery.New(fetch.New(store), nil) 233 234 234 235 got, err := query.MergeBases(left, right) 235 236 if err != nil { ··· 265 266 commit := store.AddObject(objecttype.TypeCommit, commitBody(tree)) 266 267 tagToTree := store.AddObject(objecttype.TypeTag, tagBody(tree, objecttype.TypeTree)) 267 268 268 - query := commitquery.New(store, nil) 269 + query := commitquery.New(fetch.New(store), nil) 269 270 270 271 _, err := query.MergeBases(commit, tagToTree) 271 272 if err == nil { ··· 298 299 left := store.AddObject(objecttype.TypeCommit, commitBody(tree, base)) 299 300 right := store.AddObject(objecttype.TypeCommit, commitBody(tree, left)) 300 301 301 - query := commitquery.New(store, nil) 302 + query := commitquery.New(fetch.New(store), nil) 302 303 303 304 first, err := query.MergeBases(left, right) 304 305 if err != nil {
+4 -4
commitquery/queries_new.go
··· 4 4 "runtime" 5 5 6 6 commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" 7 - objectstore "codeberg.org/lindenii/furgit/object/store" 7 + objectfetch "codeberg.org/lindenii/furgit/object/fetch" 8 8 ) 9 9 10 - // New builds one concurrent-safe commit query service over one object store 10 + // New builds one concurrent-safe commit query service over one object fetcher 11 11 // and optional commit-graph reader. 12 12 // 13 13 // Labels: Deps-Borrowed, Life-Parent. 14 - func New(store objectstore.ReadingStore, graph *commitgraphread.Reader) *Queries { 14 + func New(fetcher *objectfetch.Fetcher, graph *commitgraphread.Reader) *Queries { 15 15 maxIdle := max(runtime.GOMAXPROCS(0), 1) 16 16 17 17 return &Queries{ 18 - store: store, 18 + fetcher: fetcher, 19 19 graph: graph, 20 20 maxIdle: maxIdle, 21 21 }
+3 -3
commitquery/query.go
··· 2 2 3 3 import ( 4 4 commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" 5 + objectfetch "codeberg.org/lindenii/furgit/object/fetch" 5 6 objectid "codeberg.org/lindenii/furgit/object/id" 6 - objectstore "codeberg.org/lindenii/furgit/object/store" 7 7 ) 8 8 9 9 // query stores one mutable reusable worker and its cached node arena. 10 10 // 11 11 // Labels: MT-Unsafe. 12 12 type query struct { 13 - store objectstore.ReadingStore 14 - graph *commitgraphread.Reader 13 + fetcher *objectfetch.Fetcher 14 + graph *commitgraphread.Reader 15 15 16 16 nodes []node 17 17
+9 -9
commitquery/query_load_by_oid.go
··· 5 5 6 6 giterrors "codeberg.org/lindenii/furgit/errors" 7 7 commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" 8 - objectcommit "codeberg.org/lindenii/furgit/object/commit" 8 + "codeberg.org/lindenii/furgit/object/commit" 9 9 objectstore "codeberg.org/lindenii/furgit/object/store" 10 10 objecttype "codeberg.org/lindenii/furgit/object/type" 11 11 ) ··· 25 25 } 26 26 } 27 27 28 - ty, content, err := query.store.ReadBytesContent(id) 28 + obj, err := query.fetcher.ExactObject(id) 29 29 if err != nil { 30 30 if stderrors.Is(err, objectstore.ErrObjectNotFound) { 31 31 return &giterrors.ObjectMissingError{OID: id} ··· 34 34 return err 35 35 } 36 36 37 - if ty != objecttype.TypeCommit { 38 - return &giterrors.ObjectTypeError{OID: id, Got: ty, Want: objecttype.TypeCommit} 39 - } 40 - 41 - commitObj, err := objectcommit.Parse(content, id.Algorithm()) 42 - if err != nil { 43 - return err 37 + commitObj, ok := obj.Object().(*commit.Commit) 38 + if !ok { 39 + return &giterrors.ObjectTypeError{ 40 + OID: id, 41 + Got: obj.Object().ObjectType(), 42 + Want: objecttype.TypeCommit, 43 + } 44 44 } 45 45 46 46 parents := make([]parentRef, 0, len(commitObj.Parents))
+4 -4
commitquery/query_new.go
··· 2 2 3 3 import ( 4 4 commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" 5 + objectfetch "codeberg.org/lindenii/furgit/object/fetch" 5 6 objectid "codeberg.org/lindenii/furgit/object/id" 6 - objectstore "codeberg.org/lindenii/furgit/object/store" 7 7 ) 8 8 9 - // newQuery builds one empty mutable worker over one object store and graph. 9 + // newQuery builds one empty mutable worker over one object fetcher and graph. 10 10 // 11 11 // Labels: Deps-Borrowed, Life-Parent. 12 - func newQuery(store objectstore.ReadingStore, graph *commitgraphread.Reader) *query { 12 + func newQuery(fetcher *objectfetch.Fetcher, graph *commitgraphread.Reader) *query { 13 13 return &query{ 14 - store: store, 14 + fetcher: fetcher, 15 15 graph: graph, 16 16 byOID: make(map[objectid.ObjectID]nodeIndex), 17 17 byGraphPos: make(map[commitgraphread.Position]nodeIndex),
+29 -6
commitquery/query_resolve_commitish.go
··· 1 1 package commitquery 2 2 3 3 import ( 4 - "codeberg.org/lindenii/furgit/internal/peel" 4 + stderrors "errors" 5 + 6 + giterrors "codeberg.org/lindenii/furgit/errors" 7 + "codeberg.org/lindenii/furgit/object/commit" 5 8 objectid "codeberg.org/lindenii/furgit/object/id" 9 + objectstore "codeberg.org/lindenii/furgit/object/store" 10 + "codeberg.org/lindenii/furgit/object/tag" 11 + objecttype "codeberg.org/lindenii/furgit/object/type" 6 12 ) 7 13 8 14 // resolveCommitish peels one commit-ish object ID and resolves the commit. 9 15 func (query *query) resolveCommitish(id objectid.ObjectID) (nodeIndex, error) { 10 - commitID, err := peel.ToCommit(query.store, id) 11 - if err != nil { 12 - return 0, err 16 + for { 17 + obj, err := query.fetcher.ExactObject(id) 18 + if err != nil { 19 + if stderrors.Is(err, objectstore.ErrObjectNotFound) { 20 + return 0, &giterrors.ObjectMissingError{OID: id} 21 + } 22 + 23 + return 0, err 24 + } 25 + 26 + switch parsed := obj.Object().(type) { 27 + case *commit.Commit: 28 + return query.resolveOID(id) 29 + case *tag.Tag: 30 + id = parsed.Target 31 + default: 32 + return 0, &giterrors.ObjectTypeError{ 33 + OID: id, 34 + Got: parsed.ObjectType(), 35 + Want: objecttype.TypeCommit, 36 + } 37 + } 13 38 } 14 - 15 - return query.resolveOID(commitID) 16 39 }
+2 -1
network/receivepack/hooks/reject_force_push.go
··· 7 7 8 8 "codeberg.org/lindenii/furgit/commitquery" 9 9 receivepack "codeberg.org/lindenii/furgit/network/receivepack" 10 + "codeberg.org/lindenii/furgit/object/fetch" 10 11 objectmix "codeberg.org/lindenii/furgit/object/store/mix" 11 12 refstore "codeberg.org/lindenii/furgit/ref/store" 12 13 ) ··· 24 25 25 26 defer func() { _ = objects.Close() }() 26 27 27 - queries := commitquery.New(objects, req.CommitGraph) 28 + queries := commitquery.New(fetch.New(objects), req.CommitGraph) 28 29 29 30 decisions := make([]receivepack.UpdateDecision, len(req.Updates)) 30 31 for i := range decisions {
+1 -1
repository/fetcher.go
··· 10 10 // 11 11 // Labels: Life-Parent, Close-No. 12 12 func (repo *Repository) Fetcher() *fetch.Fetcher { 13 - return fetch.New(repo.objects) 13 + return repo.fetcher 14 14 }
+3 -1
repository/open.go
··· 5 5 "os" 6 6 7 7 "codeberg.org/lindenii/furgit/commitquery" 8 + "codeberg.org/lindenii/furgit/object/fetch" 8 9 reffiles "codeberg.org/lindenii/furgit/ref/store/files" 9 10 ) 10 11 ··· 44 45 } 45 46 46 47 repo.objects = objects 48 + repo.fetcher = fetch.New(objects) 47 49 repo.objectsRoot = objectsRoot 48 50 repo.objectsPackRoot = objectsPackRoot 49 51 repo.objectsLoose = objectsLoose ··· 55 57 } 56 58 57 59 repo.commitGraph = commitGraph 58 - repo.commitQueries = commitquery.New(objects, commitGraph) 60 + repo.commitQueries = commitquery.New(repo.fetcher, commitGraph) 59 61 60 62 refRoot, err := root.OpenRoot(".") 61 63 if err != nil {
+2
repository/repository.go
··· 13 13 "codeberg.org/lindenii/furgit/commitquery" 14 14 "codeberg.org/lindenii/furgit/config" 15 15 commitgraphread "codeberg.org/lindenii/furgit/format/commitgraph/read" 16 + "codeberg.org/lindenii/furgit/object/fetch" 16 17 objectid "codeberg.org/lindenii/furgit/object/id" 17 18 objectstore "codeberg.org/lindenii/furgit/object/store" 18 19 objectloose "codeberg.org/lindenii/furgit/object/store/loose" ··· 32 33 algo objectid.Algorithm 33 34 34 35 objects objectstore.ReadingStore 36 + fetcher *fetch.Fetcher 35 37 objectsRoot *os.Root 36 38 objectsPackRoot *os.Root 37 39 objectsLoose *objectloose.Store