aboutsummaryrefslogtreecommitdiff
path: root/repository/repository.go
diff options
context:
space:
mode:
Diffstat (limited to 'repository/repository.go')
-rw-r--r--repository/repository.go130
1 files changed, 47 insertions, 83 deletions
diff --git a/repository/repository.go b/repository/repository.go
index 1e2834a3..a1efe92f 100644
--- a/repository/repository.go
+++ b/repository/repository.go
@@ -24,11 +24,6 @@ import (
// Open expects path to be the Git directory itself:
// a bare repository root or a non-bare ".git" directory.
type Repository struct {
- root *os.Root
- objectsRoot *os.Root
- packRoot *os.Root
- reftableRoot *os.Root
-
config *config.Config
algo objectid.Algorithm
@@ -38,19 +33,20 @@ type Repository struct {
// Open opens a repository and wires object/ref stores from its on-disk format.
func Open(path string) (repo *Repository, err error) {
- root, err := os.OpenRoot(path)
+ setupRoot, err := os.OpenRoot(path)
if err != nil {
return nil, err
}
+ defer func() { _ = setupRoot.Close() }()
- repo = &Repository{root: root}
+ repo = &Repository{}
defer func() {
if err != nil {
_ = repo.Close()
}
}()
- cfg, err := parseRepositoryConfig(root)
+ cfg, err := parseRepositoryConfig(setupRoot)
if err != nil {
return nil, err
}
@@ -62,20 +58,17 @@ func Open(path string) (repo *Repository, err error) {
}
repo.algo = algo
- objects, objectsRoot, packRoot, err := openObjectStore(root, algo)
+ objects, err := openObjectStore(path, algo)
if err != nil {
return nil, err
}
repo.objects = objects
- repo.objectsRoot = objectsRoot
- repo.packRoot = packRoot
- refs, reftableRoot, err := openRefStore(root, algo)
+ refs, err := openRefStore(path, algo)
if err != nil {
return nil, err
}
repo.refs = refs
- repo.reftableRoot = reftableRoot
return repo, nil
}
@@ -112,38 +105,11 @@ func (repo *Repository) Close() error {
if err := repo.refs.Close(); err != nil {
errs = append(errs, err)
}
- repo.refs = nil
}
if repo.objects != nil {
if err := repo.objects.Close(); err != nil {
errs = append(errs, err)
}
- repo.objects = nil
- }
-
- if repo.reftableRoot != nil {
- if err := repo.reftableRoot.Close(); err != nil {
- errs = append(errs, err)
- }
- repo.reftableRoot = nil
- }
- if repo.packRoot != nil {
- if err := repo.packRoot.Close(); err != nil {
- errs = append(errs, err)
- }
- repo.packRoot = nil
- }
- if repo.objectsRoot != nil {
- if err := repo.objectsRoot.Close(); err != nil {
- errs = append(errs, err)
- }
- repo.objectsRoot = nil
- }
- if repo.root != nil {
- if err := repo.root.Close(); err != nil {
- errs = append(errs, err)
- }
- repo.root = nil
}
return errors.Join(errs...)
@@ -175,11 +141,18 @@ func detectObjectAlgorithm(cfg *config.Config) (objectid.Algorithm, error) {
return algo, nil
}
-func openObjectStore(root *os.Root, algo objectid.Algorithm) (out objectstore.Store, objectsRoot *os.Root, packRoot *os.Root, err error) {
- objectsRoot, err = root.OpenRoot("objects")
+func openObjectStore(path string, algo objectid.Algorithm) (out objectstore.Store, err error) {
+ repoRoot, err := os.OpenRoot(path)
+ if err != nil {
+ return nil, fmt.Errorf("repository: open root: %w", err)
+ }
+ defer func() { _ = repoRoot.Close() }()
+
+ objectsRoot, err := repoRoot.OpenRoot("objects")
if err != nil {
- return nil, nil, nil, fmt.Errorf("repository: open objects: %w", err)
+ return nil, fmt.Errorf("repository: open objects: %w", err)
}
+ var packRoot *os.Root
defer func() {
if err != nil {
if out != nil {
@@ -194,7 +167,7 @@ func openObjectStore(root *os.Root, algo objectid.Algorithm) (out objectstore.St
looseStore, err := objectloose.New(objectsRoot, algo)
if err != nil {
- return nil, nil, nil, err
+ return nil, err
}
backends := []objectstore.Store{looseStore}
@@ -203,77 +176,68 @@ func openObjectStore(root *os.Root, algo objectid.Algorithm) (out objectstore.St
var packedStore *objectpacked.Store
packedStore, err = objectpacked.New(packRoot, algo)
if err != nil {
- return nil, nil, nil, err
+ return nil, err
}
backends = append(backends, packedStore)
} else if !errors.Is(err, os.ErrNotExist) {
- return nil, nil, nil, fmt.Errorf("repository: open objects/pack: %w", err)
+ return nil, fmt.Errorf("repository: open objects/pack: %w", err)
}
err = nil
out = objectchain.New(backends...)
- return out, objectsRoot, packRoot, nil
+ return out, nil
}
-func openRefStore(root *os.Root, algo objectid.Algorithm) (out refstore.Store, reftableRoot *os.Root, err error) {
- var closePackedStore refstore.Store
- defer func() {
- if err != nil {
- if out != nil {
- _ = out.Close()
- }
- if closePackedStore != nil {
- _ = closePackedStore.Close()
- }
- if reftableRoot != nil {
- _ = reftableRoot.Close()
- }
- }
- }()
+func openRefStore(path string, algo objectid.Algorithm) (out refstore.Store, err error) {
+ metaRoot, err := os.OpenRoot(path)
+ if err != nil {
+ return nil, fmt.Errorf("repository: open root: %w", err)
+ }
+ defer func() { _ = metaRoot.Close() }()
- hasReftable, err := hasReftableStack(root)
+ hasReftable, err := hasReftableStack(metaRoot)
if err != nil {
- return nil, nil, err
+ return nil, err
}
if hasReftable {
- reftableRoot, err = root.OpenRoot("reftable")
+ reftableRoot, err := metaRoot.OpenRoot("reftable")
if err != nil {
- return nil, nil, fmt.Errorf("repository: open reftable: %w", err)
+ return nil, fmt.Errorf("repository: open reftable: %w", err)
}
- var reftableStore *reftable.Store
- reftableStore, err = reftable.New(reftableRoot, algo)
+ reftableStore, err := reftable.New(reftableRoot, algo)
if err != nil {
- return nil, nil, err
+ _ = reftableRoot.Close()
+ return nil, err
}
- err = nil
- out = reftableStore
- return reftableStore, reftableRoot, nil
+ return reftableStore, nil
}
- looseStore, err := refloose.New(root, algo)
+ looseRoot, err := os.OpenRoot(path)
if err != nil {
- return nil, nil, err
+ return nil, fmt.Errorf("repository: open root for loose refs: %w", err)
+ }
+ looseStore, err := refloose.New(looseRoot, algo)
+ if err != nil {
+ _ = looseRoot.Close()
+ return nil, err
}
backends := []refstore.Store{looseStore}
- packedRefsFile, err := root.Open("packed-refs")
+ packedRefsFile, err := metaRoot.Open("packed-refs")
if err == nil {
packedStore, packedErr := refpacked.New(packedRefsFile, algo)
_ = packedRefsFile.Close()
if packedErr != nil {
- err = packedErr
- return nil, nil, err
+ _ = looseStore.Close()
+ return nil, packedErr
}
- closePackedStore = packedStore
backends = append(backends, packedStore)
} else if !errors.Is(err, os.ErrNotExist) {
- return nil, nil, fmt.Errorf("repository: open packed-refs: %w", err)
+ _ = looseStore.Close()
+ return nil, fmt.Errorf("repository: open packed-refs: %w", err)
}
- err = nil
- out = refchain.New(backends...)
- closePackedStore = nil
- return out, nil, nil
+ return refchain.New(backends...), nil
}
func hasReftableStack(root *os.Root) (bool, error) {
generated by cgit v1.3.1-10-gc9f91 (git 2.54.0) at 2026-05-25 13:55:43 +0000