tdsds.com/gitea
tdsds.com/gitea
1
1
Fork 0
mirror of https://github.com/go-gitea/gitea synced 2025-03-10 12:44:28 +00:00
Code Releases Activity

Decouple context from repository related structs (#33823)

Browse Source 
Calls that required context implicitly are made to pass it as argument
This commit is contained in:
TheFox0x7 2025-03-08 22:12:46 +01:00 committed by GitHub
parent 4ed71eb754
commit 4c4c56c7cd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
11 changed files with 118 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
models/activities/action.go
View File

@ -529,8 +529,8 @@ func ActivityQueryCondition(ctx context.Context, opts GetFeedsOptions) (builder.
} }
if opts.RequestedTeam != nil { if opts.RequestedTeam != nil {
env := repo_model.AccessibleTeamReposEnv(ctx, organization.OrgFromUser(opts.RequestedUser), opts.RequestedTeam) env := repo_model.AccessibleTeamReposEnv(organization.OrgFromUser(opts.RequestedUser), opts.RequestedTeam)
teamRepoIDs, err := env.RepoIDs(1, opts.RequestedUser.NumRepos) teamRepoIDs, err := env.RepoIDs(ctx, 1, opts.RequestedUser.NumRepos)
if err != nil { if err != nil {
return nil, fmt.Errorf("GetTeamRepositories: %w", err) return nil, fmt.Errorf("GetTeamRepositories: %w", err)
} }

8
models/organization/org_test.go
View File

@ -320,7 +320,7 @@ func TestAccessibleReposEnv_CountRepos(t *testing.T) {
testSuccess := func(userID, expectedCount int64) { testSuccess := func(userID, expectedCount int64) {
env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID) env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID)
assert.NoError(t, err) assert.NoError(t, err)
count, err := env.CountRepos() count, err := env.CountRepos(db.DefaultContext)
assert.NoError(t, err) assert.NoError(t, err)
assert.EqualValues(t, expectedCount, count) assert.EqualValues(t, expectedCount, count)
} }
@ -334,7 +334,7 @@ func TestAccessibleReposEnv_RepoIDs(t *testing.T) {
testSuccess := func(userID int64, expectedRepoIDs []int64) { testSuccess := func(userID int64, expectedRepoIDs []int64) {
env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID) env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID)
assert.NoError(t, err) assert.NoError(t, err)
repoIDs, err := env.RepoIDs(1, 100) repoIDs, err := env.RepoIDs(db.DefaultContext, 1, 100)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, expectedRepoIDs, repoIDs) assert.Equal(t, expectedRepoIDs, repoIDs)
} }
@ -348,7 +348,7 @@ func TestAccessibleReposEnv_Repos(t *testing.T) {
testSuccess := func(userID int64, expectedRepoIDs []int64) { testSuccess := func(userID int64, expectedRepoIDs []int64) {
env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID) env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID)
assert.NoError(t, err) assert.NoError(t, err)
repos, err := env.Repos(1, 100) repos, err := env.Repos(db.DefaultContext, 1, 100)
assert.NoError(t, err) assert.NoError(t, err)
expectedRepos := make(repo_model.RepositoryList, len(expectedRepoIDs)) expectedRepos := make(repo_model.RepositoryList, len(expectedRepoIDs))
for i, repoID := range expectedRepoIDs { for i, repoID := range expectedRepoIDs {
@ -367,7 +367,7 @@ func TestAccessibleReposEnv_MirrorRepos(t *testing.T) {
testSuccess := func(userID int64, expectedRepoIDs []int64) { testSuccess := func(userID int64, expectedRepoIDs []int64) {
env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID) env, err := repo_model.AccessibleReposEnv(db.DefaultContext, org, userID)
assert.NoError(t, err) assert.NoError(t, err)
repos, err := env.MirrorRepos() repos, err := env.MirrorRepos(db.DefaultContext)
assert.NoError(t, err) assert.NoError(t, err)
expectedRepos := make(repo_model.RepositoryList, len(expectedRepoIDs)) expectedRepos := make(repo_model.RepositoryList, len(expectedRepoIDs))
for i, repoID := range expectedRepoIDs { for i, repoID := range expectedRepoIDs {

37
models/repo/org_repo.go
View File

@ -47,10 +47,10 @@ func GetTeamRepositories(ctx context.Context, opts *SearchTeamRepoOptions) (Repo
// AccessibleReposEnvironment operations involving the repositories that are // AccessibleReposEnvironment operations involving the repositories that are
// accessible to a particular user // accessible to a particular user
type AccessibleReposEnvironment interface { type AccessibleReposEnvironment interface {
CountRepos() (int64, error) CountRepos(ctx context.Context) (int64, error)
RepoIDs(page, pageSize int) ([]int64, error) RepoIDs(ctx context.Context, page, pageSize int) ([]int64, error)
Repos(page, pageSize int) (RepositoryList, error) Repos(ctx context.Context, page, pageSize int) (RepositoryList, error)
MirrorRepos() (RepositoryList, error) MirrorRepos(ctx context.Context) (RepositoryList, error)
AddKeyword(keyword string) AddKeyword(keyword string)
SetSort(db.SearchOrderBy) SetSort(db.SearchOrderBy)
} }
@ -60,7 +60,6 @@ type accessibleReposEnv struct {
user *user_model.User user *user_model.User
team *org_model.Team team *org_model.Team
teamIDs []int64 teamIDs []int64
ctx context.Context
keyword string keyword string
orderBy db.SearchOrderBy orderBy db.SearchOrderBy
} }
@ -86,18 +85,16 @@ func AccessibleReposEnv(ctx context.Context, org *org_model.Organization, userID
org: org, org: org,
user: user, user: user,
teamIDs: teamIDs, teamIDs: teamIDs,
ctx: ctx,
orderBy: db.SearchOrderByRecentUpdated, orderBy: db.SearchOrderByRecentUpdated,
}, nil }, nil
} }
// AccessibleTeamReposEnv an AccessibleReposEnvironment for the repositories in `org` // AccessibleTeamReposEnv an AccessibleReposEnvironment for the repositories in `org`
// that are accessible to the specified team. // that are accessible to the specified team.
func AccessibleTeamReposEnv(ctx context.Context, org *org_model.Organization, team *org_model.Team) AccessibleReposEnvironment { func AccessibleTeamReposEnv(org *org_model.Organization, team *org_model.Team) AccessibleReposEnvironment {
return &accessibleReposEnv{ return &accessibleReposEnv{
org: org, org: org,
team: team, team: team,
ctx: ctx,
orderBy: db.SearchOrderByRecentUpdated, orderBy: db.SearchOrderByRecentUpdated,
} }
} }
@ -123,8 +120,8 @@ func (env *accessibleReposEnv) cond() builder.Cond {
return cond return cond
} }
func (env *accessibleReposEnv) CountRepos() (int64, error) { func (env *accessibleReposEnv) CountRepos(ctx context.Context) (int64, error) {
repoCount, err := db.GetEngine(env.ctx). repoCount, err := db.GetEngine(ctx).
Join("INNER", "team_repo", "`team_repo`.repo_id=`repository`.id"). Join("INNER", "team_repo", "`team_repo`.repo_id=`repository`.id").
Where(env.cond()). Where(env.cond()).
Distinct("`repository`.id"). Distinct("`repository`.id").
@ -135,13 +132,13 @@ func (env *accessibleReposEnv) CountRepos() (int64, error) {
return repoCount, nil return repoCount, nil
} }
func (env *accessibleReposEnv) RepoIDs(page, pageSize int) ([]int64, error) { func (env *accessibleReposEnv) RepoIDs(ctx context.Context, page, pageSize int) ([]int64, error) {
if page <= 0 { if page <= 0 {
page = 1 page = 1
} }
repoIDs := make([]int64, 0, pageSize) repoIDs := make([]int64, 0, pageSize)
return repoIDs, db.GetEngine(env.ctx). return repoIDs, db.GetEngine(ctx).
Table("repository"). Table("repository").
Join("INNER", "team_repo", "`team_repo`.repo_id=`repository`.id"). Join("INNER", "team_repo", "`team_repo`.repo_id=`repository`.id").
Where(env.cond()). Where(env.cond()).
@ -152,8 +149,8 @@ func (env *accessibleReposEnv) RepoIDs(page, pageSize int) ([]int64, error) {
Find(&repoIDs) Find(&repoIDs)
} }
func (env *accessibleReposEnv) Repos(page, pageSize int) (RepositoryList, error) { func (env *accessibleReposEnv) Repos(ctx context.Context, page, pageSize int) (RepositoryList, error) {
repoIDs, err := env.RepoIDs(page, pageSize) repoIDs, err := env.RepoIDs(ctx, page, pageSize)
if err != nil { if err != nil {
return nil, fmt.Errorf("GetUserRepositoryIDs: %w", err) return nil, fmt.Errorf("GetUserRepositoryIDs: %w", err)
} }
@ -163,15 +160,15 @@ func (env *accessibleReposEnv) Repos(page, pageSize int) (RepositoryList, error)
return repos, nil return repos, nil
} }
return repos, db.GetEngine(env.ctx). return repos, db.GetEngine(ctx).
In("`repository`.id", repoIDs). In("`repository`.id", repoIDs).
OrderBy(string(env.orderBy)). OrderBy(string(env.orderBy)).
Find(&repos) Find(&repos)
} }
func (env *accessibleReposEnv) MirrorRepoIDs() ([]int64, error) { func (env *accessibleReposEnv) MirrorRepoIDs(ctx context.Context) ([]int64, error) {
repoIDs := make([]int64, 0, 10) repoIDs := make([]int64, 0, 10)
return repoIDs, db.GetEngine(env.ctx). return repoIDs, db.GetEngine(ctx).
Table("repository"). Table("repository").
Join("INNER", "team_repo", "`team_repo`.repo_id=`repository`.id AND `repository`.is_mirror=?", true). Join("INNER", "team_repo", "`team_repo`.repo_id=`repository`.id AND `repository`.is_mirror=?", true).
Where(env.cond()). Where(env.cond()).
@ -181,8 +178,8 @@ func (env *accessibleReposEnv) MirrorRepoIDs() ([]int64, error) {
Find(&repoIDs) Find(&repoIDs)
} }
func (env *accessibleReposEnv) MirrorRepos() (RepositoryList, error) { func (env *accessibleReposEnv) MirrorRepos(ctx context.Context) (RepositoryList, error) {
repoIDs, err := env.MirrorRepoIDs() repoIDs, err := env.MirrorRepoIDs(ctx)
if err != nil { if err != nil {
return nil, fmt.Errorf("MirrorRepoIDs: %w", err) return nil, fmt.Errorf("MirrorRepoIDs: %w", err)
} }
@ -192,7 +189,7 @@ func (env *accessibleReposEnv) MirrorRepos() (RepositoryList, error) {
return repos, nil return repos, nil
} }
return repos, db.GetEngine(env.ctx). return repos, db.GetEngine(ctx).
In("`repository`.id", repoIDs). In("`repository`.id", repoIDs).
Find(&repos) Find(&repos)
} }

2
services/org/user.go
View File

@ -64,7 +64,7 @@ func RemoveOrgUser(ctx context.Context, org *organization.Organization, user *us
if err != nil { if err != nil {
return fmt.Errorf("AccessibleReposEnv: %w", err) return fmt.Errorf("AccessibleReposEnv: %w", err)
} }
repoIDs, err := env.RepoIDs(1, org.NumRepos) repoIDs, err := env.RepoIDs(ctx, 1, org.NumRepos)
if err != nil { if err != nil {
return fmt.Errorf("GetUserRepositories [%d]: %w", user.ID, err) return fmt.Errorf("GetUserRepositories [%d]: %w", user.ID, err)
} }

28
services/packages/cargo/index.go
View File

@ -78,7 +78,7 @@ func RebuildIndex(ctx context.Context, doer, owner *user_model.User) error {
"Rebuild Cargo Index", "Rebuild Cargo Index",
func(t *files_service.TemporaryUploadRepository) error { func(t *files_service.TemporaryUploadRepository) error {
// Remove all existing content but the Cargo config // Remove all existing content but the Cargo config
files, err := t.LsFiles() files, err := t.LsFiles(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -89,7 +89,7 @@ func RebuildIndex(ctx context.Context, doer, owner *user_model.User) error {
break break
} }
} }
if err := t.RemoveFilesFromIndex(files...); err != nil { if err := t.RemoveFilesFromIndex(ctx, files...); err != nil {
return err return err
} }
@ -204,7 +204,7 @@ func addOrUpdatePackageIndex(ctx context.Context, t *files_service.TemporaryUplo
return nil return nil
} }
return writeObjectToIndex(t, BuildPackagePath(p.LowerName), b) return writeObjectToIndex(ctx, t, BuildPackagePath(p.LowerName), b)
} }
func getOrCreateIndexRepository(ctx context.Context, doer, owner *user_model.User) (*repo_model.Repository, error) { func getOrCreateIndexRepository(ctx context.Context, doer, owner *user_model.User) (*repo_model.Repository, error) {
@ -252,29 +252,29 @@ func createOrUpdateConfigFile(ctx context.Context, repo *repo_model.Repository,
return err return err
} }
return writeObjectToIndex(t, ConfigFileName, &b) return writeObjectToIndex(ctx, t, ConfigFileName, &b)
}, },
) )
} }
// This is a shorter version of CreateOrUpdateRepoFile which allows to perform multiple actions on a git repository // This is a shorter version of CreateOrUpdateRepoFile which allows to perform multiple actions on a git repository
func alterRepositoryContent(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, commitMessage string, fn func(*files_service.TemporaryUploadRepository) error) error { func alterRepositoryContent(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, commitMessage string, fn func(*files_service.TemporaryUploadRepository) error) error {
t, err := files_service.NewTemporaryUploadRepository(ctx, repo) t, err := files_service.NewTemporaryUploadRepository(repo)
if err != nil { if err != nil {
return err return err
} }
defer t.Close() defer t.Close()
var lastCommitID string var lastCommitID string
if err := t.Clone(repo.DefaultBranch, true); err != nil { if err := t.Clone(ctx, repo.DefaultBranch, true); err != nil {
if !git.IsErrBranchNotExist(err) || !repo.IsEmpty { if !git.IsErrBranchNotExist(err) || !repo.IsEmpty {
return err return err
} }
if err := t.Init(repo.ObjectFormatName); err != nil { if err := t.Init(ctx, repo.ObjectFormatName); err != nil {
return err return err
} }
} else { } else {
if err := t.SetDefaultIndex(); err != nil { if err := t.SetDefaultIndex(ctx); err != nil {
return err return err
} }
@ -290,7 +290,7 @@ func alterRepositoryContent(ctx context.Context, doer *user_model.User, repo *re
return err return err
} }
treeHash, err := t.WriteTree() treeHash, err := t.WriteTree(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -301,19 +301,19 @@ func alterRepositoryContent(ctx context.Context, doer *user_model.User, repo *re
CommitMessage: commitMessage, CommitMessage: commitMessage,
DoerUser: doer, DoerUser: doer,
} }
commitHash, err := t.CommitTree(commitOpts) commitHash, err := t.CommitTree(ctx, commitOpts)
if err != nil { if err != nil {
return err return err
} }
return t.Push(doer, commitHash, repo.DefaultBranch) return t.Push(ctx, doer, commitHash, repo.DefaultBranch)
} }
func writeObjectToIndex(t *files_service.TemporaryUploadRepository, path string, r io.Reader) error { func writeObjectToIndex(ctx context.Context, t *files_service.TemporaryUploadRepository, path string, r io.Reader) error {
hash, err := t.HashObject(r) hash, err := t.HashObject(ctx, r)
if err != nil { if err != nil {
return err return err
} }
return t.AddObjectToIndex("100644", hash, path) return t.AddObjectToIndex(ctx, "100644", hash, path)
} }

14
services/repository/files/cherry_pick.go
View File

@ -39,18 +39,18 @@ func CherryPick(ctx context.Context, repo *repo_model.Repository, doer *user_mod
} }
message := strings.TrimSpace(opts.Message) message := strings.TrimSpace(opts.Message)
t, err := NewTemporaryUploadRepository(ctx, repo) t, err := NewTemporaryUploadRepository(repo)
if err != nil { if err != nil {
log.Error("NewTemporaryUploadRepository failed: %v", err) log.Error("NewTemporaryUploadRepository failed: %v", err)
} }
defer t.Close() defer t.Close()
if err := t.Clone(opts.OldBranch, false); err != nil { if err := t.Clone(ctx, opts.OldBranch, false); err != nil {
return nil, err return nil, err
} }
if err := t.SetDefaultIndex(); err != nil { if err := t.SetDefaultIndex(ctx); err != nil {
return nil, err return nil, err
} }
if err := t.RefreshIndex(); err != nil { if err := t.RefreshIndex(ctx); err != nil {
return nil, err return nil, err
} }
@ -103,7 +103,7 @@ func CherryPick(ctx context.Context, repo *repo_model.Repository, doer *user_mod
return nil, fmt.Errorf("failed to merge due to conflicts") return nil, fmt.Errorf("failed to merge due to conflicts")
} }
treeHash, err := t.WriteTree() treeHash, err := t.WriteTree(ctx)
if err != nil { if err != nil {
// likely non-sensical tree due to merge conflicts... // likely non-sensical tree due to merge conflicts...
return nil, err return nil, err
@ -124,13 +124,13 @@ func CherryPick(ctx context.Context, repo *repo_model.Repository, doer *user_mod
if opts.Dates != nil { if opts.Dates != nil {
commitOpts.AuthorTime, commitOpts.CommitterTime = &opts.Dates.Author, &opts.Dates.Committer commitOpts.AuthorTime, commitOpts.CommitterTime = &opts.Dates.Author, &opts.Dates.Committer
} }
commitHash, err := t.CommitTree(commitOpts) commitHash, err := t.CommitTree(ctx, commitOpts)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Then push this tree to NewBranch // Then push this tree to NewBranch
if err := t.Push(doer, commitHash, opts.NewBranch); err != nil { if err := t.Push(ctx, doer, commitHash, opts.NewBranch); err != nil {
return nil, err return nil, err
} }

12
services/repository/files/diff.go
View File

@ -16,27 +16,27 @@ func GetDiffPreview(ctx context.Context, repo *repo_model.Repository, branch, tr
if branch == "" { if branch == "" {
branch = repo.DefaultBranch branch = repo.DefaultBranch
} }
t, err := NewTemporaryUploadRepository(ctx, repo) t, err := NewTemporaryUploadRepository(repo)
if err != nil { if err != nil {
return nil, err return nil, err
} }
defer t.Close() defer t.Close()
if err := t.Clone(branch, true); err != nil { if err := t.Clone(ctx, branch, true); err != nil {
return nil, err return nil, err
} }
if err := t.SetDefaultIndex(); err != nil { if err := t.SetDefaultIndex(ctx); err != nil {
return nil, err return nil, err
} }
// Add the object to the database // Add the object to the database
objectHash, err := t.HashObject(strings.NewReader(content)) objectHash, err := t.HashObject(ctx, strings.NewReader(content))
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Add the object to the index // Add the object to the index
if err := t.AddObjectToIndex("100644", objectHash, treePath); err != nil { if err := t.AddObjectToIndex(ctx, "100644", objectHash, treePath); err != nil {
return nil, err return nil, err
} }
return t.DiffIndex() return t.DiffIndex(ctx)
} }

12
services/repository/files/patch.go
View File

@ -126,15 +126,15 @@ func ApplyDiffPatch(ctx context.Context, repo *repo_model.Repository, doer *user
message := strings.TrimSpace(opts.Message) message := strings.TrimSpace(opts.Message)
t, err := NewTemporaryUploadRepository(ctx, repo) t, err := NewTemporaryUploadRepository(repo)
if err != nil { if err != nil {
log.Error("NewTemporaryUploadRepository failed: %v", err) log.Error("NewTemporaryUploadRepository failed: %v", err)
} }
defer t.Close() defer t.Close()
if err := t.Clone(opts.OldBranch, true); err != nil { if err := t.Clone(ctx, opts.OldBranch, true); err != nil {
return nil, err return nil, err
} }
if err := t.SetDefaultIndex(); err != nil { if err := t.SetDefaultIndex(ctx); err != nil {
return nil, err return nil, err
} }
@ -179,7 +179,7 @@ func ApplyDiffPatch(ctx context.Context, repo *repo_model.Repository, doer *user
} }
// Now write the tree // Now write the tree
treeHash, err := t.WriteTree() treeHash, err := t.WriteTree(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -199,13 +199,13 @@ func ApplyDiffPatch(ctx context.Context, repo *repo_model.Repository, doer *user
if opts.Dates != nil { if opts.Dates != nil {
commitOpts.AuthorTime, commitOpts.CommitterTime = &opts.Dates.Author, &opts.Dates.Committer commitOpts.AuthorTime, commitOpts.CommitterTime = &opts.Dates.Author, &opts.Dates.Committer
} }
commitHash, err := t.CommitTree(commitOpts) commitHash, err := t.CommitTree(ctx, commitOpts)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Then push this tree to NewBranch // Then push this tree to NewBranch
if err := t.Push(doer, commitHash, opts.NewBranch); err != nil { if err := t.Push(ctx, doer, commitHash, opts.NewBranch); err != nil {
return nil, err return nil, err
} }

71
services/repository/files/temp_repo.go
View File

@ -26,19 +26,18 @@ import (
// TemporaryUploadRepository is a type to wrap our upload repositories as a shallow clone // TemporaryUploadRepository is a type to wrap our upload repositories as a shallow clone
type TemporaryUploadRepository struct { type TemporaryUploadRepository struct {
ctx context.Context
repo *repo_model.Repository repo *repo_model.Repository
gitRepo *git.Repository gitRepo *git.Repository
basePath string basePath string
} }
// NewTemporaryUploadRepository creates a new temporary upload repository // NewTemporaryUploadRepository creates a new temporary upload repository
func NewTemporaryUploadRepository(ctx context.Context, repo *repo_model.Repository) (*TemporaryUploadRepository, error) { func NewTemporaryUploadRepository(repo *repo_model.Repository) (*TemporaryUploadRepository, error) {
basePath, err := repo_module.CreateTemporaryPath("upload") basePath, err := repo_module.CreateTemporaryPath("upload")
if err != nil { if err != nil {
return nil, err return nil, err
} }
t := &TemporaryUploadRepository{ctx: ctx, repo: repo, basePath: basePath} t := &TemporaryUploadRepository{repo: repo, basePath: basePath}
return t, nil return t, nil
} }
@ -51,13 +50,13 @@ func (t *TemporaryUploadRepository) Close() {
} }
// Clone the base repository to our path and set branch as the HEAD // Clone the base repository to our path and set branch as the HEAD
func (t *TemporaryUploadRepository) Clone(branch string, bare bool) error { func (t *TemporaryUploadRepository) Clone(ctx context.Context, branch string, bare bool) error {
cmd := git.NewCommand("clone", "-s", "-b").AddDynamicArguments(branch, t.repo.RepoPath(), t.basePath) cmd := git.NewCommand("clone", "-s", "-b").AddDynamicArguments(branch, t.repo.RepoPath(), t.basePath)
if bare { if bare {
cmd.AddArguments("--bare") cmd.AddArguments("--bare")
} }
if _, _, err := cmd.RunStdString(t.ctx, nil); err != nil { if _, _, err := cmd.RunStdString(ctx, nil); err != nil {
stderr := err.Error() stderr := err.Error()
if matched, _ := regexp.MatchString(".*Remote branch .* not found in upstream origin.*", stderr); matched { if matched, _ := regexp.MatchString(".*Remote branch .* not found in upstream origin.*", stderr); matched {
return git.ErrBranchNotExist{ return git.ErrBranchNotExist{
@ -73,7 +72,7 @@ func (t *TemporaryUploadRepository) Clone(branch string, bare bool) error {
} }
return fmt.Errorf("Clone: %w %s", err, stderr) return fmt.Errorf("Clone: %w %s", err, stderr)
} }
gitRepo, err := git.OpenRepository(t.ctx, t.basePath) gitRepo, err := git.OpenRepository(ctx, t.basePath)
if err != nil { if err != nil {
return err return err
} }
@ -82,11 +81,11 @@ func (t *TemporaryUploadRepository) Clone(branch string, bare bool) error {
} }
// Init the repository // Init the repository
func (t *TemporaryUploadRepository) Init(objectFormatName string) error { func (t *TemporaryUploadRepository) Init(ctx context.Context, objectFormatName string) error {
if err := git.InitRepository(t.ctx, t.basePath, false, objectFormatName); err != nil { if err := git.InitRepository(ctx, t.basePath, false, objectFormatName); err != nil {
return err return err
} }
gitRepo, err := git.OpenRepository(t.ctx, t.basePath) gitRepo, err := git.OpenRepository(ctx, t.basePath)
if err != nil { if err != nil {
return err return err
} }
@ -95,28 +94,28 @@ func (t *TemporaryUploadRepository) Init(objectFormatName string) error {
} }
// SetDefaultIndex sets the git index to our HEAD // SetDefaultIndex sets the git index to our HEAD
func (t *TemporaryUploadRepository) SetDefaultIndex() error { func (t *TemporaryUploadRepository) SetDefaultIndex(ctx context.Context) error {
if _, _, err := git.NewCommand("read-tree", "HEAD").RunStdString(t.ctx, &git.RunOpts{Dir: t.basePath}); err != nil { if _, _, err := git.NewCommand("read-tree", "HEAD").RunStdString(ctx, &git.RunOpts{Dir: t.basePath}); err != nil {
return fmt.Errorf("SetDefaultIndex: %w", err) return fmt.Errorf("SetDefaultIndex: %w", err)
} }
return nil return nil
} }
// RefreshIndex looks at the current index and checks to see if merges or updates are needed by checking stat() information. // RefreshIndex looks at the current index and checks to see if merges or updates are needed by checking stat() information.
func (t *TemporaryUploadRepository) RefreshIndex() error { func (t *TemporaryUploadRepository) RefreshIndex(ctx context.Context) error {
if _, _, err := git.NewCommand("update-index", "--refresh").RunStdString(t.ctx, &git.RunOpts{Dir: t.basePath}); err != nil { if _, _, err := git.NewCommand("update-index", "--refresh").RunStdString(ctx, &git.RunOpts{Dir: t.basePath}); err != nil {
return fmt.Errorf("RefreshIndex: %w", err) return fmt.Errorf("RefreshIndex: %w", err)
} }
return nil return nil
} }
// LsFiles checks if the given filename arguments are in the index // LsFiles checks if the given filename arguments are in the index
func (t *TemporaryUploadRepository) LsFiles(filenames ...string) ([]string, error) { func (t *TemporaryUploadRepository) LsFiles(ctx context.Context, filenames ...string) ([]string, error) {
stdOut := new(bytes.Buffer) stdOut := new(bytes.Buffer)
stdErr := new(bytes.Buffer) stdErr := new(bytes.Buffer)
if err := git.NewCommand("ls-files", "-z").AddDashesAndList(filenames...). if err := git.NewCommand("ls-files", "-z").AddDashesAndList(filenames...).
Run(t.ctx, &git.RunOpts{ Run(ctx, &git.RunOpts{
Dir: t.basePath, Dir: t.basePath,
Stdout: stdOut, Stdout: stdOut,
Stderr: stdErr, Stderr: stdErr,
@ -135,7 +134,7 @@ func (t *TemporaryUploadRepository) LsFiles(filenames ...string) ([]string, erro
} }
// RemoveFilesFromIndex removes the given files from the index // RemoveFilesFromIndex removes the given files from the index
func (t *TemporaryUploadRepository) RemoveFilesFromIndex(filenames ...string) error { func (t *TemporaryUploadRepository) RemoveFilesFromIndex(ctx context.Context, filenames ...string) error {
objFmt, err := t.gitRepo.GetObjectFormat() objFmt, err := t.gitRepo.GetObjectFormat()
if err != nil { if err != nil {
return fmt.Errorf("unable to get object format for temporary repo: %q, error: %w", t.repo.FullName(), err) return fmt.Errorf("unable to get object format for temporary repo: %q, error: %w", t.repo.FullName(), err)
@ -152,7 +151,7 @@ func (t *TemporaryUploadRepository) RemoveFilesFromIndex(filenames ...string) er
} }
if err := git.NewCommand("update-index", "--remove", "-z", "--index-info"). if err := git.NewCommand("update-index", "--remove", "-z", "--index-info").
Run(t.ctx, &git.RunOpts{ Run(ctx, &git.RunOpts{
Dir: t.basePath, Dir: t.basePath,
Stdin: stdIn, Stdin: stdIn,
Stdout: stdOut, Stdout: stdOut,
@ -164,12 +163,12 @@ func (t *TemporaryUploadRepository) RemoveFilesFromIndex(filenames ...string) er
} }
// HashObject writes the provided content to the object db and returns its hash // HashObject writes the provided content to the object db and returns its hash
func (t *TemporaryUploadRepository) HashObject(content io.Reader) (string, error) { func (t *TemporaryUploadRepository) HashObject(ctx context.Context, content io.Reader) (string, error) {
stdOut := new(bytes.Buffer) stdOut := new(bytes.Buffer)
stdErr := new(bytes.Buffer) stdErr := new(bytes.Buffer)
if err := git.NewCommand("hash-object", "-w", "--stdin"). if err := git.NewCommand("hash-object", "-w", "--stdin").
Run(t.ctx, &git.RunOpts{ Run(ctx, &git.RunOpts{
Dir: t.basePath, Dir: t.basePath,
Stdin: content, Stdin: content,
Stdout: stdOut, Stdout: stdOut,
@ -183,8 +182,8 @@ func (t *TemporaryUploadRepository) HashObject(content io.Reader) (string, error
} }
// AddObjectToIndex adds the provided object hash to the index with the provided mode and path // AddObjectToIndex adds the provided object hash to the index with the provided mode and path
func (t *TemporaryUploadRepository) AddObjectToIndex(mode, objectHash, objectPath string) error { func (t *TemporaryUploadRepository) AddObjectToIndex(ctx context.Context, mode, objectHash, objectPath string) error {
if _, _, err := git.NewCommand("update-index", "--add", "--replace", "--cacheinfo").AddDynamicArguments(mode, objectHash, objectPath).RunStdString(t.ctx, &git.RunOpts{Dir: t.basePath}); err != nil { if _, _, err := git.NewCommand("update-index", "--add", "--replace", "--cacheinfo").AddDynamicArguments(mode, objectHash, objectPath).RunStdString(ctx, &git.RunOpts{Dir: t.basePath}); err != nil {
stderr := err.Error() stderr := err.Error()
if matched, _ := regexp.MatchString(".*Invalid path '.*", stderr); matched { if matched, _ := regexp.MatchString(".*Invalid path '.*", stderr); matched {
return ErrFilePathInvalid{ return ErrFilePathInvalid{
@ -199,8 +198,8 @@ func (t *TemporaryUploadRepository) AddObjectToIndex(mode, objectHash, objectPat
} }
// WriteTree writes the current index as a tree to the object db and returns its hash // WriteTree writes the current index as a tree to the object db and returns its hash
func (t *TemporaryUploadRepository) WriteTree() (string, error) { func (t *TemporaryUploadRepository) WriteTree(ctx context.Context) (string, error) {
stdout, _, err := git.NewCommand("write-tree").RunStdString(t.ctx, &git.RunOpts{Dir: t.basePath}) stdout, _, err := git.NewCommand("write-tree").RunStdString(ctx, &git.RunOpts{Dir: t.basePath})
if err != nil { if err != nil {
log.Error("Unable to write tree in temporary repo: %s(%s): Error: %v", t.repo.FullName(), t.basePath, err) log.Error("Unable to write tree in temporary repo: %s(%s): Error: %v", t.repo.FullName(), t.basePath, err)
return "", fmt.Errorf("Unable to write-tree in temporary repo for: %s Error: %w", t.repo.FullName(), err) return "", fmt.Errorf("Unable to write-tree in temporary repo for: %s Error: %w", t.repo.FullName(), err)
@ -209,16 +208,16 @@ func (t *TemporaryUploadRepository) WriteTree() (string, error) {
} }
// GetLastCommit gets the last commit ID SHA of the repo // GetLastCommit gets the last commit ID SHA of the repo
func (t *TemporaryUploadRepository) GetLastCommit() (string, error) { func (t *TemporaryUploadRepository) GetLastCommit(ctx context.Context) (string, error) {
return t.GetLastCommitByRef("HEAD") return t.GetLastCommitByRef(ctx, "HEAD")
} }
// GetLastCommitByRef gets the last commit ID SHA of the repo by ref // GetLastCommitByRef gets the last commit ID SHA of the repo by ref
func (t *TemporaryUploadRepository) GetLastCommitByRef(ref string) (string, error) { func (t *TemporaryUploadRepository) GetLastCommitByRef(ctx context.Context, ref string) (string, error) {
if ref == "" { if ref == "" {
ref = "HEAD" ref = "HEAD"
} }
stdout, _, err := git.NewCommand("rev-parse").AddDynamicArguments(ref).RunStdString(t.ctx, &git.RunOpts{Dir: t.basePath}) stdout, _, err := git.NewCommand("rev-parse").AddDynamicArguments(ref).RunStdString(ctx, &git.RunOpts{Dir: t.basePath})
if err != nil { if err != nil {
log.Error("Unable to get last ref for %s in temporary repo: %s(%s): Error: %v", ref, t.repo.FullName(), t.basePath, err) log.Error("Unable to get last ref for %s in temporary repo: %s(%s): Error: %v", ref, t.repo.FullName(), t.basePath, err)
return "", fmt.Errorf("Unable to rev-parse %s in temporary repo for: %s Error: %w", ref, t.repo.FullName(), err) return "", fmt.Errorf("Unable to rev-parse %s in temporary repo for: %s Error: %w", ref, t.repo.FullName(), err)
@ -259,7 +258,7 @@ func makeGitUserSignature(doer *user_model.User, identity, other *IdentityOption
} }
// CommitTree creates a commit from a given tree for the user with provided message // CommitTree creates a commit from a given tree for the user with provided message
func (t *TemporaryUploadRepository) CommitTree(opts *CommitTreeUserOptions) (string, error) { func (t *TemporaryUploadRepository) CommitTree(ctx context.Context, opts *CommitTreeUserOptions) (string, error) {
authorSig := makeGitUserSignature(opts.DoerUser, opts.AuthorIdentity, opts.CommitterIdentity) authorSig := makeGitUserSignature(opts.DoerUser, opts.AuthorIdentity, opts.CommitterIdentity)
committerSig := makeGitUserSignature(opts.DoerUser, opts.CommitterIdentity, opts.AuthorIdentity) committerSig := makeGitUserSignature(opts.DoerUser, opts.CommitterIdentity, opts.AuthorIdentity)
@ -295,9 +294,9 @@ func (t *TemporaryUploadRepository) CommitTree(opts *CommitTreeUserOptions) (str
var keyID string var keyID string
var signer *git.Signature var signer *git.Signature
if opts.ParentCommitID != "" { if opts.ParentCommitID != "" {
sign, keyID, signer, _ = asymkey_service.SignCRUDAction(t.ctx, t.repo.RepoPath(), opts.DoerUser, t.basePath, opts.ParentCommitID) sign, keyID, signer, _ = asymkey_service.SignCRUDAction(ctx, t.repo.RepoPath(), opts.DoerUser, t.basePath, opts.ParentCommitID)
} else { } else {
sign, keyID, signer, _ = asymkey_service.SignInitialCommit(t.ctx, t.repo.RepoPath(), opts.DoerUser) sign, keyID, signer, _ = asymkey_service.SignInitialCommit(ctx, t.repo.RepoPath(), opts.DoerUser)
} }
if sign { if sign {
cmdCommitTree.AddOptionFormat("-S%s", keyID) cmdCommitTree.AddOptionFormat("-S%s", keyID)
@ -333,7 +332,7 @@ func (t *TemporaryUploadRepository) CommitTree(opts *CommitTreeUserOptions) (str
stdout := new(bytes.Buffer) stdout := new(bytes.Buffer)
stderr := new(bytes.Buffer) stderr := new(bytes.Buffer)
if err := cmdCommitTree. if err := cmdCommitTree.
Run(t.ctx, &git.RunOpts{ Run(ctx, &git.RunOpts{
Env: env, Env: env,
Dir: t.basePath, Dir: t.basePath,
Stdin: messageBytes, Stdin: messageBytes,
@ -349,10 +348,10 @@ func (t *TemporaryUploadRepository) CommitTree(opts *CommitTreeUserOptions) (str
} }
// Push the provided commitHash to the repository branch by the provided user // Push the provided commitHash to the repository branch by the provided user
func (t *TemporaryUploadRepository) Push(doer *user_model.User, commitHash, branch string) error { func (t *TemporaryUploadRepository) Push(ctx context.Context, doer *user_model.User, commitHash, branch string) error {
// Because calls hooks we need to pass in the environment // Because calls hooks we need to pass in the environment
env := repo_module.PushingEnvironment(doer, t.repo) env := repo_module.PushingEnvironment(doer, t.repo)
if err := git.Push(t.ctx, t.basePath, git.PushOptions{ if err := git.Push(ctx, t.basePath, git.PushOptions{
Remote: t.repo.RepoPath(), Remote: t.repo.RepoPath(),
Branch: strings.TrimSpace(commitHash) + ":" + git.BranchPrefix + strings.TrimSpace(branch), Branch: strings.TrimSpace(commitHash) + ":" + git.BranchPrefix + strings.TrimSpace(branch),
Env: env, Env: env,
@ -374,7 +373,7 @@ func (t *TemporaryUploadRepository) Push(doer *user_model.User, commitHash, bran
} }
// DiffIndex returns a Diff of the current index to the head // DiffIndex returns a Diff of the current index to the head
func (t *TemporaryUploadRepository) DiffIndex() (*gitdiff.Diff, error) { func (t *TemporaryUploadRepository) DiffIndex(ctx context.Context) (*gitdiff.Diff, error) {
stdoutReader, stdoutWriter, err := os.Pipe() stdoutReader, stdoutWriter, err := os.Pipe()
if err != nil { if err != nil {
return nil, fmt.Errorf("unable to open stdout pipe: %w", err) return nil, fmt.Errorf("unable to open stdout pipe: %w", err)
@ -386,7 +385,7 @@ func (t *TemporaryUploadRepository) DiffIndex() (*gitdiff.Diff, error) {
stderr := new(bytes.Buffer) stderr := new(bytes.Buffer)
var diff *gitdiff.Diff var diff *gitdiff.Diff
err = git.NewCommand("diff-index", "--src-prefix=\\a/", "--dst-prefix=\\b/", "--cached", "-p", "HEAD"). err = git.NewCommand("diff-index", "--src-prefix=\\a/", "--dst-prefix=\\b/", "--cached", "-p", "HEAD").
Run(t.ctx, &git.RunOpts{ Run(ctx, &git.RunOpts{
Timeout: 30 * time.Second, Timeout: 30 * time.Second,
Dir: t.basePath, Dir: t.basePath,
Stdout: stdoutWriter, Stdout: stdoutWriter,
@ -395,7 +394,7 @@ func (t *TemporaryUploadRepository) DiffIndex() (*gitdiff.Diff, error) {
_ = stdoutWriter.Close() _ = stdoutWriter.Close()
defer cancel() defer cancel()
var diffErr error var diffErr error
diff, diffErr = gitdiff.ParsePatch(t.ctx, setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, stdoutReader, "") diff, diffErr = gitdiff.ParsePatch(ctx, setting.Git.MaxGitDiffLines, setting.Git.MaxGitDiffLineCharacters, setting.Git.MaxGitDiffFiles, stdoutReader, "")
_ = stdoutReader.Close() _ = stdoutReader.Close()
if diffErr != nil { if diffErr != nil {
// if the diffErr is not nil, it will be returned as the error of "Run()" // if the diffErr is not nil, it will be returned as the error of "Run()"

28
services/repository/files/update.go
View File

@ -160,13 +160,13 @@ func ChangeRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
message := strings.TrimSpace(opts.Message) message := strings.TrimSpace(opts.Message)
t, err := NewTemporaryUploadRepository(ctx, repo) t, err := NewTemporaryUploadRepository(repo)
if err != nil { if err != nil {
log.Error("NewTemporaryUploadRepository failed: %v", err) log.Error("NewTemporaryUploadRepository failed: %v", err)
} }
defer t.Close() defer t.Close()
hasOldBranch := true hasOldBranch := true
if err := t.Clone(opts.OldBranch, true); err != nil { if err := t.Clone(ctx, opts.OldBranch, true); err != nil {
for _, file := range opts.Files { for _, file := range opts.Files {
if file.Operation == "delete" { if file.Operation == "delete" {
return nil, err return nil, err
@ -175,14 +175,14 @@ func ChangeRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
if !git.IsErrBranchNotExist(err) || !repo.IsEmpty { if !git.IsErrBranchNotExist(err) || !repo.IsEmpty {
return nil, err return nil, err
} }
if err := t.Init(repo.ObjectFormatName); err != nil { if err := t.Init(ctx, repo.ObjectFormatName); err != nil {
return nil, err return nil, err
} }
hasOldBranch = false hasOldBranch = false
opts.LastCommitID = "" opts.LastCommitID = ""
} }
if hasOldBranch { if hasOldBranch {
if err := t.SetDefaultIndex(); err != nil { if err := t.SetDefaultIndex(ctx); err != nil {
return nil, err return nil, err
} }
} }
@ -190,7 +190,7 @@ func ChangeRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
for _, file := range opts.Files { for _, file := range opts.Files {
if file.Operation == "delete" { if file.Operation == "delete" {
// Get the files in the index // Get the files in the index
filesInIndex, err := t.LsFiles(file.TreePath) filesInIndex, err := t.LsFiles(ctx, file.TreePath)
if err != nil { if err != nil {
return nil, fmt.Errorf("DeleteRepoFile: %w", err) return nil, fmt.Errorf("DeleteRepoFile: %w", err)
} }
@ -245,7 +245,7 @@ func ChangeRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
} }
case "delete": case "delete":
// Remove the file from the index // Remove the file from the index
if err := t.RemoveFilesFromIndex(file.TreePath); err != nil { if err := t.RemoveFilesFromIndex(ctx, file.TreePath); err != nil {
return nil, err return nil, err
} }
default: default:
@ -254,7 +254,7 @@ func ChangeRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
} }
// Now write the tree // Now write the tree
treeHash, err := t.WriteTree() treeHash, err := t.WriteTree(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -274,13 +274,13 @@ func ChangeRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
if opts.Dates != nil { if opts.Dates != nil {
commitOpts.AuthorTime, commitOpts.CommitterTime = &opts.Dates.Author, &opts.Dates.Committer commitOpts.AuthorTime, commitOpts.CommitterTime = &opts.Dates.Author, &opts.Dates.Committer
} }
commitHash, err := t.CommitTree(commitOpts) commitHash, err := t.CommitTree(ctx, commitOpts)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Then push this tree to NewBranch // Then push this tree to NewBranch
if err := t.Push(doer, commitHash, opts.NewBranch); err != nil { if err := t.Push(ctx, doer, commitHash, opts.NewBranch); err != nil {
log.Error("%T %v", err, err) log.Error("%T %v", err, err)
return nil, err return nil, err
} }
@ -453,7 +453,7 @@ func handleCheckErrors(file *ChangeRepoFile, commit *git.Commit, opts *ChangeRep
// CreateOrUpdateFile handles creating or updating a file for ChangeRepoFiles // CreateOrUpdateFile handles creating or updating a file for ChangeRepoFiles
func CreateOrUpdateFile(ctx context.Context, t *TemporaryUploadRepository, file *ChangeRepoFile, contentStore *lfs.ContentStore, repoID int64, hasOldBranch bool) error { func CreateOrUpdateFile(ctx context.Context, t *TemporaryUploadRepository, file *ChangeRepoFile, contentStore *lfs.ContentStore, repoID int64, hasOldBranch bool) error {
// Get the two paths (might be the same if not moving) from the index if they exist // Get the two paths (might be the same if not moving) from the index if they exist
filesInIndex, err := t.LsFiles(file.TreePath, file.FromTreePath) filesInIndex, err := t.LsFiles(ctx, file.TreePath, file.FromTreePath)
if err != nil { if err != nil {
return fmt.Errorf("UpdateRepoFile: %w", err) return fmt.Errorf("UpdateRepoFile: %w", err)
} }
@ -472,7 +472,7 @@ func CreateOrUpdateFile(ctx context.Context, t *TemporaryUploadRepository, file
if file.Options.fromTreePath != file.Options.treePath && len(filesInIndex) > 0 { if file.Options.fromTreePath != file.Options.treePath && len(filesInIndex) > 0 {
for _, indexFile := range filesInIndex { for _, indexFile := range filesInIndex {
if indexFile == file.Options.fromTreePath { if indexFile == file.Options.fromTreePath {
if err := t.RemoveFilesFromIndex(file.FromTreePath); err != nil { if err := t.RemoveFilesFromIndex(ctx, file.FromTreePath); err != nil {
return err return err
} }
} }
@ -504,18 +504,18 @@ func CreateOrUpdateFile(ctx context.Context, t *TemporaryUploadRepository, file
} }
// Add the object to the database // Add the object to the database
objectHash, err := t.HashObject(treeObjectContentReader) objectHash, err := t.HashObject(ctx, treeObjectContentReader)
if err != nil { if err != nil {
return err return err
} }
// Add the object to the index // Add the object to the index
if file.Options.executable { if file.Options.executable {
if err := t.AddObjectToIndex("100755", objectHash, file.Options.treePath); err != nil { if err := t.AddObjectToIndex(ctx, "100755", objectHash, file.Options.treePath); err != nil {
return err return err
} }
} else { } else {
if err := t.AddObjectToIndex("100644", objectHash, file.Options.treePath); err != nil { if err := t.AddObjectToIndex(ctx, "100644", objectHash, file.Options.treePath); err != nil {
return err return err
} }
} }

24
services/repository/files/upload.go
View File

@ -82,25 +82,25 @@ func UploadRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
infos[i] = uploadInfo{upload: upload} infos[i] = uploadInfo{upload: upload}
} }
t, err := NewTemporaryUploadRepository(ctx, repo) t, err := NewTemporaryUploadRepository(repo)
if err != nil { if err != nil {
return err return err
} }
defer t.Close() defer t.Close()
hasOldBranch := true hasOldBranch := true
if err = t.Clone(opts.OldBranch, true); err != nil { if err = t.Clone(ctx, opts.OldBranch, true); err != nil {
if !git.IsErrBranchNotExist(err) || !repo.IsEmpty { if !git.IsErrBranchNotExist(err) || !repo.IsEmpty {
return err return err
} }
if err = t.Init(repo.ObjectFormatName); err != nil { if err = t.Init(ctx, repo.ObjectFormatName); err != nil {
return err return err
} }
hasOldBranch = false hasOldBranch = false
opts.LastCommitID = "" opts.LastCommitID = ""
} }
if hasOldBranch { if hasOldBranch {
if err = t.SetDefaultIndex(); err != nil { if err = t.SetDefaultIndex(ctx); err != nil {
return err return err
} }
} }
@ -119,13 +119,13 @@ func UploadRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
// Copy uploaded files into repository. // Copy uploaded files into repository.
for i := range infos { for i := range infos {
if err := copyUploadedLFSFileIntoRepository(&infos[i], filename2attribute2info, t, opts.TreePath); err != nil { if err := copyUploadedLFSFileIntoRepository(ctx, &infos[i], filename2attribute2info, t, opts.TreePath); err != nil {
return err return err
} }
} }
// Now write the tree // Now write the tree
treeHash, err := t.WriteTree() treeHash, err := t.WriteTree(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -140,7 +140,7 @@ func UploadRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
AuthorIdentity: opts.Author, AuthorIdentity: opts.Author,
CommitterIdentity: opts.Committer, CommitterIdentity: opts.Committer,
} }
commitHash, err := t.CommitTree(commitOpts) commitHash, err := t.CommitTree(ctx, commitOpts)
if err != nil { if err != nil {
return err return err
} }
@ -169,14 +169,14 @@ func UploadRepoFiles(ctx context.Context, repo *repo_model.Repository, doer *use
} }
// Then push this tree to NewBranch // Then push this tree to NewBranch
if err := t.Push(doer, commitHash, opts.NewBranch); err != nil { if err := t.Push(ctx, doer, commitHash, opts.NewBranch); err != nil {
return err return err
} }
return repo_model.DeleteUploads(ctx, uploads...) return repo_model.DeleteUploads(ctx, uploads...)
} }
func copyUploadedLFSFileIntoRepository(info *uploadInfo, filename2attribute2info map[string]map[string]string, t *TemporaryUploadRepository, treePath string) error { func copyUploadedLFSFileIntoRepository(ctx context.Context, info *uploadInfo, filename2attribute2info map[string]map[string]string, t *TemporaryUploadRepository, treePath string) error {
file, err := os.Open(info.upload.LocalPath()) file, err := os.Open(info.upload.LocalPath())
if err != nil { if err != nil {
return err return err
@ -194,15 +194,15 @@ func copyUploadedLFSFileIntoRepository(info *uploadInfo, filename2attribute2info
info.lfsMetaObject = &git_model.LFSMetaObject{Pointer: pointer, RepositoryID: t.repo.ID} info.lfsMetaObject = &git_model.LFSMetaObject{Pointer: pointer, RepositoryID: t.repo.ID}
if objectHash, err = t.HashObject(strings.NewReader(pointer.StringContent())); err != nil { if objectHash, err = t.HashObject(ctx, strings.NewReader(pointer.StringContent())); err != nil {
return err return err
} }
} else if objectHash, err = t.HashObject(file); err != nil { } else if objectHash, err = t.HashObject(ctx, file); err != nil {
return err return err
} }
// Add the object to the index // Add the object to the index
return t.AddObjectToIndex("100644", objectHash, path.Join(treePath, info.upload.Name)) return t.AddObjectToIndex(ctx, "100644", objectHash, path.Join(treePath, info.upload.Name))
} }
func uploadToLFSContentStore(info uploadInfo, contentStore *lfs.ContentStore) error { func uploadToLFSContentStore(info uploadInfo, contentStore *lfs.ContentStore) error {