Fast implementation of Git in pure Go
codeberg.org/lindenii/furgit
git
go
commitquery: Use fetcher
+84
-52
+4
-4
commitquery/queries.go
+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
+1
-1
commitquery/queries_acquire.go
+5
-4
commitquery/queries_is_ancestor_integration_test.go
+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
+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
+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
+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
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
+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
+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
+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
+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
+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
+1
-1
repository/fetcher.go
+3
-1
repository/open.go
+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
+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