2020-12-17 14:00:47 +00:00
|
|
|
// Copyright 2015 The Gogs Authors. All rights reserved.
|
|
|
|
// Copyright 2017 The Gitea Authors. All rights reserved.
|
2022-11-27 18:20:29 +00:00
|
|
|
// SPDX-License-Identifier: MIT
|
2020-12-17 14:00:47 +00:00
|
|
|
|
2021-08-24 16:47:09 +00:00
|
|
|
//go:build !gogit
|
2020-12-17 14:00:47 +00:00
|
|
|
|
|
|
|
package git
|
|
|
|
|
|
|
|
import (
|
2021-05-10 01:27:03 +00:00
|
|
|
"bufio"
|
|
|
|
"context"
|
2020-12-17 14:00:47 +00:00
|
|
|
"path/filepath"
|
2021-06-25 16:54:08 +00:00
|
|
|
|
|
|
|
"code.gitea.io/gitea/modules/log"
|
2024-03-06 06:26:32 +00:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2020-12-17 14:00:47 +00:00
|
|
|
)
|
|
|
|
|
2024-05-06 16:34:16 +00:00
|
|
|
const isGogit = false
|
2024-01-19 16:05:02 +00:00
|
|
|
|
2020-12-17 14:00:47 +00:00
|
|
|
// Repository represents a Git repository.
|
|
|
|
type Repository struct {
|
|
|
|
Path string
|
|
|
|
|
2024-11-20 19:26:12 +00:00
|
|
|
tagCache *ObjectCache[*Tag]
|
2020-12-17 14:00:47 +00:00
|
|
|
|
|
|
|
gpgSettings *GPGSettings
|
2021-05-10 01:27:03 +00:00
|
|
|
|
2024-08-20 17:04:57 +00:00
|
|
|
batchInUse bool
|
|
|
|
batch *Batch
|
2021-05-10 01:27:03 +00:00
|
|
|
|
2024-08-20 17:04:57 +00:00
|
|
|
checkInUse bool
|
|
|
|
check *Batch
|
2021-11-30 20:06:32 +00:00
|
|
|
|
2022-07-25 15:39:42 +00:00
|
|
|
Ctx context.Context
|
|
|
|
LastCommitCache *LastCommitCache
|
2023-12-13 21:02:00 +00:00
|
|
|
|
|
|
|
objectFormat ObjectFormat
|
2020-12-17 14:00:47 +00:00
|
|
|
}
|
|
|
|
|
2022-03-29 19:13:41 +00:00
|
|
|
// openRepositoryWithDefaultContext opens the repository at the given path with DefaultContext.
|
|
|
|
func openRepositoryWithDefaultContext(repoPath string) (*Repository, error) {
|
|
|
|
return OpenRepository(DefaultContext, repoPath)
|
2021-11-30 20:06:32 +00:00
|
|
|
}
|
|
|
|
|
2022-03-29 19:13:41 +00:00
|
|
|
// OpenRepository opens the repository at the given path with the provided context.
|
|
|
|
func OpenRepository(ctx context.Context, repoPath string) (*Repository, error) {
|
2020-12-17 14:00:47 +00:00
|
|
|
repoPath, err := filepath.Abs(repoPath)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !isDir(repoPath) {
|
2024-03-06 06:26:32 +00:00
|
|
|
return nil, util.NewNotExistErrorf("no such file or directory")
|
2020-12-17 14:00:47 +00:00
|
|
|
}
|
2021-05-10 01:27:03 +00:00
|
|
|
|
2024-08-20 17:04:57 +00:00
|
|
|
return &Repository{
|
2020-12-17 14:00:47 +00:00
|
|
|
Path: repoPath,
|
2024-11-20 19:26:12 +00:00
|
|
|
tagCache: newObjectCache[*Tag](),
|
2021-11-30 20:06:32 +00:00
|
|
|
Ctx: ctx,
|
2024-08-20 17:04:57 +00:00
|
|
|
}, nil
|
2021-05-10 01:27:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// CatFileBatch obtains a CatFileBatch for this repository
|
2024-08-20 17:04:57 +00:00
|
|
|
func (repo *Repository) CatFileBatch(ctx context.Context) (WriteCloserError, *bufio.Reader, func(), error) {
|
|
|
|
if repo.batch == nil {
|
|
|
|
var err error
|
|
|
|
repo.batch, err = repo.NewBatch(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, nil, err
|
|
|
|
}
|
2021-05-10 01:27:03 +00:00
|
|
|
}
|
2024-08-20 17:04:57 +00:00
|
|
|
|
|
|
|
if !repo.batchInUse {
|
|
|
|
repo.batchInUse = true
|
|
|
|
return repo.batch.Writer, repo.batch.Reader, func() {
|
|
|
|
repo.batchInUse = false
|
|
|
|
}, nil
|
Prevent double use of `git cat-file` session. (#29298)
Fixes the reason why #29101 is hard to replicate.
Related #29297
Create a repo with a file with minimum size 4097 bytes (I use 10000) and
execute the following code:
```go
gitRepo, err := gitrepo.OpenRepository(db.DefaultContext, <repo>)
assert.NoError(t, err)
commit, err := gitRepo.GetCommit(<sha>)
assert.NoError(t, err)
entry, err := commit.GetTreeEntryByPath(<file>)
assert.NoError(t, err)
b := entry.Blob()
// Create a reader
r, err := b.DataAsync()
assert.NoError(t, err)
defer r.Close()
// Create a second reader
r2, err := b.DataAsync()
assert.NoError(t, err) // Should be no error but is ErrNotExist
defer r2.Close()
```
The problem is the check in `CatFileBatch`:
https://github.com/go-gitea/gitea/blob/79217ea63c1f77de7ca79813ae45950724e63d02/modules/git/repo_base_nogogit.go#L81-L87
`Buffered() > 0` is used to check if there is a "operation" in progress
at the moment. This is a problem because we can't control the internal
buffer in the `bufio.Reader`. The code above demonstrates a sequence
which initiates an operation for which the code thinks there is no
active processing. The second call to `DataAsync()` therefore reuses the
existing instances instead of creating a new batch reader.
2024-02-21 18:54:17 +00:00
|
|
|
}
|
2024-08-20 17:04:57 +00:00
|
|
|
|
|
|
|
log.Debug("Opening temporary cat file batch for: %s", repo.Path)
|
|
|
|
tempBatch, err := repo.NewBatch(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, nil, err
|
|
|
|
}
|
|
|
|
return tempBatch.Writer, tempBatch.Reader, tempBatch.Close, nil
|
2021-05-10 01:27:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// CatFileBatchCheck obtains a CatFileBatchCheck for this repository
|
2024-08-20 17:04:57 +00:00
|
|
|
func (repo *Repository) CatFileBatchCheck(ctx context.Context) (WriteCloserError, *bufio.Reader, func(), error) {
|
|
|
|
if repo.check == nil {
|
|
|
|
var err error
|
|
|
|
repo.check, err = repo.NewBatchCheck(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, nil, err
|
|
|
|
}
|
2021-05-10 01:27:03 +00:00
|
|
|
}
|
2024-08-20 17:04:57 +00:00
|
|
|
|
|
|
|
if !repo.checkInUse {
|
|
|
|
repo.checkInUse = true
|
|
|
|
return repo.check.Writer, repo.check.Reader, func() {
|
|
|
|
repo.checkInUse = false
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Debug("Opening temporary cat file batch-check for: %s", repo.Path)
|
|
|
|
tempBatchCheck, err := repo.NewBatchCheck(ctx)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, nil, err
|
Prevent double use of `git cat-file` session. (#29298)
Fixes the reason why #29101 is hard to replicate.
Related #29297
Create a repo with a file with minimum size 4097 bytes (I use 10000) and
execute the following code:
```go
gitRepo, err := gitrepo.OpenRepository(db.DefaultContext, <repo>)
assert.NoError(t, err)
commit, err := gitRepo.GetCommit(<sha>)
assert.NoError(t, err)
entry, err := commit.GetTreeEntryByPath(<file>)
assert.NoError(t, err)
b := entry.Blob()
// Create a reader
r, err := b.DataAsync()
assert.NoError(t, err)
defer r.Close()
// Create a second reader
r2, err := b.DataAsync()
assert.NoError(t, err) // Should be no error but is ErrNotExist
defer r2.Close()
```
The problem is the check in `CatFileBatch`:
https://github.com/go-gitea/gitea/blob/79217ea63c1f77de7ca79813ae45950724e63d02/modules/git/repo_base_nogogit.go#L81-L87
`Buffered() > 0` is used to check if there is a "operation" in progress
at the moment. This is a problem because we can't control the internal
buffer in the `bufio.Reader`. The code above demonstrates a sequence
which initiates an operation for which the code thinks there is no
active processing. The second call to `DataAsync()` therefore reuses the
existing instances instead of creating a new batch reader.
2024-02-21 18:54:17 +00:00
|
|
|
}
|
2024-08-20 17:04:57 +00:00
|
|
|
return tempBatchCheck.Writer, tempBatchCheck.Reader, tempBatchCheck.Close, nil
|
2020-12-17 14:00:47 +00:00
|
|
|
}
|
|
|
|
|
2024-02-25 13:05:23 +00:00
|
|
|
func (repo *Repository) Close() error {
|
2021-05-10 01:27:03 +00:00
|
|
|
if repo == nil {
|
2023-07-09 11:58:06 +00:00
|
|
|
return nil
|
2021-05-10 01:27:03 +00:00
|
|
|
}
|
2024-08-20 17:04:57 +00:00
|
|
|
if repo.batch != nil {
|
|
|
|
repo.batch.Close()
|
|
|
|
repo.batch = nil
|
Prevent double use of `git cat-file` session. (#29298)
Fixes the reason why #29101 is hard to replicate.
Related #29297
Create a repo with a file with minimum size 4097 bytes (I use 10000) and
execute the following code:
```go
gitRepo, err := gitrepo.OpenRepository(db.DefaultContext, <repo>)
assert.NoError(t, err)
commit, err := gitRepo.GetCommit(<sha>)
assert.NoError(t, err)
entry, err := commit.GetTreeEntryByPath(<file>)
assert.NoError(t, err)
b := entry.Blob()
// Create a reader
r, err := b.DataAsync()
assert.NoError(t, err)
defer r.Close()
// Create a second reader
r2, err := b.DataAsync()
assert.NoError(t, err) // Should be no error but is ErrNotExist
defer r2.Close()
```
The problem is the check in `CatFileBatch`:
https://github.com/go-gitea/gitea/blob/79217ea63c1f77de7ca79813ae45950724e63d02/modules/git/repo_base_nogogit.go#L81-L87
`Buffered() > 0` is used to check if there is a "operation" in progress
at the moment. This is a problem because we can't control the internal
buffer in the `bufio.Reader`. The code above demonstrates a sequence
which initiates an operation for which the code thinks there is no
active processing. The second call to `DataAsync()` therefore reuses the
existing instances instead of creating a new batch reader.
2024-02-21 18:54:17 +00:00
|
|
|
repo.batchInUse = false
|
2021-05-10 01:27:03 +00:00
|
|
|
}
|
2024-08-20 17:04:57 +00:00
|
|
|
if repo.check != nil {
|
|
|
|
repo.check.Close()
|
|
|
|
repo.check = nil
|
Prevent double use of `git cat-file` session. (#29298)
Fixes the reason why #29101 is hard to replicate.
Related #29297
Create a repo with a file with minimum size 4097 bytes (I use 10000) and
execute the following code:
```go
gitRepo, err := gitrepo.OpenRepository(db.DefaultContext, <repo>)
assert.NoError(t, err)
commit, err := gitRepo.GetCommit(<sha>)
assert.NoError(t, err)
entry, err := commit.GetTreeEntryByPath(<file>)
assert.NoError(t, err)
b := entry.Blob()
// Create a reader
r, err := b.DataAsync()
assert.NoError(t, err)
defer r.Close()
// Create a second reader
r2, err := b.DataAsync()
assert.NoError(t, err) // Should be no error but is ErrNotExist
defer r2.Close()
```
The problem is the check in `CatFileBatch`:
https://github.com/go-gitea/gitea/blob/79217ea63c1f77de7ca79813ae45950724e63d02/modules/git/repo_base_nogogit.go#L81-L87
`Buffered() > 0` is used to check if there is a "operation" in progress
at the moment. This is a problem because we can't control the internal
buffer in the `bufio.Reader`. The code above demonstrates a sequence
which initiates an operation for which the code thinks there is no
active processing. The second call to `DataAsync()` therefore reuses the
existing instances instead of creating a new batch reader.
2024-02-21 18:54:17 +00:00
|
|
|
repo.checkInUse = false
|
2021-05-10 01:27:03 +00:00
|
|
|
}
|
2022-07-25 15:39:42 +00:00
|
|
|
repo.LastCommitCache = nil
|
|
|
|
repo.tagCache = nil
|
2024-02-25 13:05:23 +00:00
|
|
|
return nil
|
2020-12-17 14:00:47 +00:00
|
|
|
}
|