From b465d0d78793da6e67890a7cb9d3ae1b807c53ca Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Sun, 12 Jan 2020 20:11:17 +0800
Subject: [PATCH] Move create/fork repository from models to modules/repository
(#9489)
* Move create/fork repository from models to modules/repository
* fix wrong reference
* fix test
* fix test
* fix lint
* Fix DBContext
* remove duplicated TestMain
* fix lint
* fix conflicts
---
models/issue_label.go | 8 +-
models/org_team_test.go | 133 ----------
models/repo.go | 400 +++---------------------------
models/repo_generate.go | 219 ----------------
models/repo_test.go | 13 -
models/task.go | 53 +---
modules/migrations/gitea.go | 3 +-
modules/repofiles/update.go | 4 +-
modules/repository/create.go | 77 ++++++
modules/repository/create_test.go | 145 +++++++++++
modules/repository/fork.go | 87 +++++++
modules/repository/fork_test.go | 25 ++
modules/repository/generate.go | 230 +++++++++++++++++
modules/repository/init.go | 214 ++++++++++++++++
modules/repository/repo.go | 2 +-
modules/task/task.go | 51 +++-
routers/api/v1/repo/repo.go | 8 +-
routers/repo/issue_label.go | 2 +-
services/mirror/mirror.go | 2 +-
services/mirror/mirror_test.go | 2 +-
services/repository/generate.go | 5 +-
services/repository/repository.go | 5 +-
22 files changed, 894 insertions(+), 794 deletions(-)
create mode 100644 modules/repository/create.go
create mode 100644 modules/repository/create_test.go
create mode 100644 modules/repository/fork.go
create mode 100644 modules/repository/fork_test.go
create mode 100644 modules/repository/generate.go
create mode 100644 modules/repository/init.go
diff --git a/models/issue_label.go b/models/issue_label.go
index d96152d463..66f93f4f48 100644
--- a/models/issue_label.go
+++ b/models/issue_label.go
@@ -22,9 +22,9 @@ var labelColorPattern = regexp.MustCompile("#([a-fA-F0-9]{6})")
// GetLabelTemplateFile loads the label template file by given name,
// then parses and returns a list of name-color pairs and optionally description.
func GetLabelTemplateFile(name string) ([][3]string, error) {
- data, err := getRepoInitFile("label", name)
+ data, err := GetRepoInitFile("label", name)
if err != nil {
- return nil, fmt.Errorf("getRepoInitFile: %v", err)
+ return nil, fmt.Errorf("GetRepoInitFile: %v", err)
}
lines := strings.Split(string(data), "\n")
@@ -175,8 +175,8 @@ func initalizeLabels(e Engine, repoID int64, labelTemplate string) error {
}
// InitalizeLabels adds a label set to a repository using a template
-func InitalizeLabels(repoID int64, labelTemplate string) error {
- return initalizeLabels(x, repoID, labelTemplate)
+func InitalizeLabels(ctx DBContext, repoID int64, labelTemplate string) error {
+ return initalizeLabels(ctx.e, repoID, labelTemplate)
}
func newLabel(e Engine, label *Label) error {
diff --git a/models/org_team_test.go b/models/org_team_test.go
index b7e2ef113d..249e50b072 100644
--- a/models/org_team_test.go
+++ b/models/org_team_test.go
@@ -5,12 +5,9 @@
package models
import (
- "fmt"
"strings"
"testing"
- "code.gitea.io/gitea/modules/structs"
-
"github.com/stretchr/testify/assert"
)
@@ -377,133 +374,3 @@ func TestUsersInTeamsCount(t *testing.T) {
test([]int64{1, 2, 3, 4, 5}, []int64{2, 5}, 2) // userid 2,4
test([]int64{1, 2, 3, 4, 5}, []int64{2, 3, 5}, 3) // userid 2,4,5
}
-
-func TestIncludesAllRepositoriesTeams(t *testing.T) {
- assert.NoError(t, PrepareTestDatabase())
-
- testTeamRepositories := func(teamID int64, repoIds []int64) {
- team := AssertExistsAndLoadBean(t, &Team{ID: teamID}).(*Team)
- assert.NoError(t, team.GetRepositories(), "%s: GetRepositories", team.Name)
- assert.Len(t, team.Repos, team.NumRepos, "%s: len repo", team.Name)
- assert.Equal(t, len(repoIds), len(team.Repos), "%s: repo count", team.Name)
- for i, rid := range repoIds {
- if rid > 0 {
- assert.True(t, team.HasRepository(rid), "%s: HasRepository(%d) %d", rid, i)
- }
- }
- }
-
- // Get an admin user.
- user, err := GetUserByID(1)
- assert.NoError(t, err, "GetUserByID")
-
- // Create org.
- org := &User{
- Name: "All repo",
- IsActive: true,
- Type: UserTypeOrganization,
- Visibility: structs.VisibleTypePublic,
- }
- assert.NoError(t, CreateOrganization(org, user), "CreateOrganization")
-
- // Check Owner team.
- ownerTeam, err := org.GetOwnerTeam()
- assert.NoError(t, err, "GetOwnerTeam")
- assert.True(t, ownerTeam.IncludesAllRepositories, "Owner team includes all repositories")
-
- // Create repos.
- repoIds := make([]int64, 0)
- for i := 0; i < 3; i++ {
- r, err := CreateRepository(user, org, CreateRepoOptions{Name: fmt.Sprintf("repo-%d", i)})
- assert.NoError(t, err, "CreateRepository %d", i)
- if r != nil {
- repoIds = append(repoIds, r.ID)
- }
- }
- // Get fresh copy of Owner team after creating repos.
- ownerTeam, err = org.GetOwnerTeam()
- assert.NoError(t, err, "GetOwnerTeam")
-
- // Create teams and check repositories.
- teams := []*Team{
- ownerTeam,
- {
- OrgID: org.ID,
- Name: "team one",
- Authorize: AccessModeRead,
- IncludesAllRepositories: true,
- },
- {
- OrgID: org.ID,
- Name: "team 2",
- Authorize: AccessModeRead,
- IncludesAllRepositories: false,
- },
- {
- OrgID: org.ID,
- Name: "team three",
- Authorize: AccessModeWrite,
- IncludesAllRepositories: true,
- },
- {
- OrgID: org.ID,
- Name: "team 4",
- Authorize: AccessModeWrite,
- IncludesAllRepositories: false,
- },
- }
- teamRepos := [][]int64{
- repoIds,
- repoIds,
- {},
- repoIds,
- {},
- }
- for i, team := range teams {
- if i > 0 { // first team is Owner.
- assert.NoError(t, NewTeam(team), "%s: NewTeam", team.Name)
- }
- testTeamRepositories(team.ID, teamRepos[i])
- }
-
- // Update teams and check repositories.
- teams[3].IncludesAllRepositories = false
- teams[4].IncludesAllRepositories = true
- teamRepos[4] = repoIds
- for i, team := range teams {
- assert.NoError(t, UpdateTeam(team, false, true), "%s: UpdateTeam", team.Name)
- testTeamRepositories(team.ID, teamRepos[i])
- }
-
- // Create repo and check teams repositories.
- org.Teams = nil // Reset teams to allow their reloading.
- r, err := CreateRepository(user, org, CreateRepoOptions{Name: "repo-last"})
- assert.NoError(t, err, "CreateRepository last")
- if r != nil {
- repoIds = append(repoIds, r.ID)
- }
- teamRepos[0] = repoIds
- teamRepos[1] = repoIds
- teamRepos[4] = repoIds
- for i, team := range teams {
- testTeamRepositories(team.ID, teamRepos[i])
- }
-
- // Remove repo and check teams repositories.
- assert.NoError(t, DeleteRepository(user, org.ID, repoIds[0]), "DeleteRepository")
- teamRepos[0] = repoIds[1:]
- teamRepos[1] = repoIds[1:]
- teamRepos[3] = repoIds[1:3]
- teamRepos[4] = repoIds[1:]
- for i, team := range teams {
- testTeamRepositories(team.ID, teamRepos[i])
- }
-
- // Wipe created items.
- for i, rid := range repoIds {
- if i > 0 { // first repo already deleted.
- assert.NoError(t, DeleteRepository(user, org.ID, rid), "DeleteRepository %d", i)
- }
- }
- assert.NoError(t, DeleteOrganization(org), "DeleteOrganization")
-}
diff --git a/models/repo.go b/models/repo.go
index e15c22e822..ee9e6a504b 100644
--- a/models/repo.go
+++ b/models/repo.go
@@ -6,7 +6,6 @@
package models
import (
- "bytes"
"context"
"crypto/md5"
"errors"
@@ -38,7 +37,6 @@ import (
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
- "github.com/mcuadros/go-version"
"github.com/unknwon/com"
"xorm.io/builder"
)
@@ -715,7 +713,7 @@ func (repo *Repository) IsOwnedBy(userID int64) bool {
func (repo *Repository) updateSize(e Engine) error {
size, err := util.GetDirectorySize(repo.RepoPath())
if err != nil {
- return fmt.Errorf("UpdateSize: %v", err)
+ return fmt.Errorf("updateSize: %v", err)
}
repo.Size = size
@@ -724,8 +722,8 @@ func (repo *Repository) updateSize(e Engine) error {
}
// UpdateSize updates the repository size, calculating it using util.GetDirectorySize
-func (repo *Repository) UpdateSize() error {
- return repo.updateSize(x)
+func (repo *Repository) UpdateSize(ctx DBContext) error {
+ return repo.updateSize(ctx.e)
}
// CanUserFork returns true if specified user can fork repository.
@@ -966,64 +964,6 @@ func createDelegateHooks(repoPath string) (err error) {
return nil
}
-// initRepoCommit temporarily changes with work directory.
-func initRepoCommit(tmpPath string, repo *Repository, u *User) (err error) {
- commitTimeStr := time.Now().Format(time.RFC3339)
-
- sig := u.NewGitSig()
- // Because this may call hooks we should pass in the environment
- env := append(os.Environ(),
- "GIT_AUTHOR_NAME="+sig.Name,
- "GIT_AUTHOR_EMAIL="+sig.Email,
- "GIT_AUTHOR_DATE="+commitTimeStr,
- "GIT_COMMITTER_NAME="+sig.Name,
- "GIT_COMMITTER_EMAIL="+sig.Email,
- "GIT_COMMITTER_DATE="+commitTimeStr,
- )
-
- if stdout, err := git.NewCommand("add", "--all").
- SetDescription(fmt.Sprintf("initRepoCommit (git add): %s", tmpPath)).
- RunInDir(tmpPath); err != nil {
- log.Error("git add --all failed: Stdout: %s\nError: %v", stdout, err)
- return fmt.Errorf("git add --all: %v", err)
- }
-
- binVersion, err := git.BinVersion()
- if err != nil {
- return fmt.Errorf("Unable to get git version: %v", err)
- }
-
- args := []string{
- "commit", fmt.Sprintf("--author='%s <%s>'", sig.Name, sig.Email),
- "-m", "Initial commit",
- }
-
- if version.Compare(binVersion, "1.7.9", ">=") {
- sign, keyID := SignInitialCommit(tmpPath, u)
- if sign {
- args = append(args, "-S"+keyID)
- } else if version.Compare(binVersion, "2.0.0", ">=") {
- args = append(args, "--no-gpg-sign")
- }
- }
-
- if stdout, err := git.NewCommand(args...).
- SetDescription(fmt.Sprintf("initRepoCommit (git commit): %s", tmpPath)).
- RunInDirWithEnv(tmpPath, env); err != nil {
- log.Error("Failed to commit: %v: Stdout: %s\nError: %v", args, stdout, err)
- return fmt.Errorf("git commit: %v", err)
- }
-
- if stdout, err := git.NewCommand("push", "origin", "master").
- SetDescription(fmt.Sprintf("initRepoCommit (git push): %s", tmpPath)).
- RunInDirWithEnv(tmpPath, InternalPushingEnvironment(u, repo)); err != nil {
- log.Error("Failed to push back to master: Stdout: %s\nError: %v", stdout, err)
- return fmt.Errorf("git push: %v", err)
- }
-
- return nil
-}
-
// CreateRepoOptions contains the create repository options
type CreateRepoOptions struct {
Name string
@@ -1040,7 +980,8 @@ type CreateRepoOptions struct {
Status RepositoryStatus
}
-func getRepoInitFile(tp, name string) ([]byte, error) {
+// GetRepoInitFile returns repository init files
+func GetRepoInitFile(tp, name string) ([]byte, error) {
cleanedName := strings.TrimLeft(path.Clean("/"+name), "/")
relPath := path.Join("options", tp, cleanedName)
@@ -1064,140 +1005,6 @@ func getRepoInitFile(tp, name string) ([]byte, error) {
}
}
-func prepareRepoCommit(e Engine, repo *Repository, tmpDir, repoPath string, opts CreateRepoOptions) error {
- commitTimeStr := time.Now().Format(time.RFC3339)
- authorSig := repo.Owner.NewGitSig()
-
- // Because this may call hooks we should pass in the environment
- env := append(os.Environ(),
- "GIT_AUTHOR_NAME="+authorSig.Name,
- "GIT_AUTHOR_EMAIL="+authorSig.Email,
- "GIT_AUTHOR_DATE="+commitTimeStr,
- "GIT_COMMITTER_NAME="+authorSig.Name,
- "GIT_COMMITTER_EMAIL="+authorSig.Email,
- "GIT_COMMITTER_DATE="+commitTimeStr,
- )
-
- // Clone to temporary path and do the init commit.
- if stdout, err := git.NewCommand("clone", repoPath, tmpDir).
- SetDescription(fmt.Sprintf("initRepository (git clone): %s to %s", repoPath, tmpDir)).
- RunInDirWithEnv("", env); err != nil {
- log.Error("Failed to clone from %v into %s: stdout: %s\nError: %v", repo, tmpDir, stdout, err)
- return fmt.Errorf("git clone: %v", err)
- }
-
- // README
- data, err := getRepoInitFile("readme", opts.Readme)
- if err != nil {
- return fmt.Errorf("getRepoInitFile[%s]: %v", opts.Readme, err)
- }
-
- cloneLink := repo.cloneLink(false)
- match := map[string]string{
- "Name": repo.Name,
- "Description": repo.Description,
- "CloneURL.SSH": cloneLink.SSH,
- "CloneURL.HTTPS": cloneLink.HTTPS,
- }
- if err = ioutil.WriteFile(filepath.Join(tmpDir, "README.md"),
- []byte(com.Expand(string(data), match)), 0644); err != nil {
- return fmt.Errorf("write README.md: %v", err)
- }
-
- // .gitignore
- if len(opts.Gitignores) > 0 {
- var buf bytes.Buffer
- names := strings.Split(opts.Gitignores, ",")
- for _, name := range names {
- data, err = getRepoInitFile("gitignore", name)
- if err != nil {
- return fmt.Errorf("getRepoInitFile[%s]: %v", name, err)
- }
- buf.WriteString("# ---> " + name + "\n")
- buf.Write(data)
- buf.WriteString("\n")
- }
-
- if buf.Len() > 0 {
- if err = ioutil.WriteFile(filepath.Join(tmpDir, ".gitignore"), buf.Bytes(), 0644); err != nil {
- return fmt.Errorf("write .gitignore: %v", err)
- }
- }
- }
-
- // LICENSE
- if len(opts.License) > 0 {
- data, err = getRepoInitFile("license", opts.License)
- if err != nil {
- return fmt.Errorf("getRepoInitFile[%s]: %v", opts.License, err)
- }
-
- if err = ioutil.WriteFile(filepath.Join(tmpDir, "LICENSE"), data, 0644); err != nil {
- return fmt.Errorf("write LICENSE: %v", err)
- }
- }
-
- return nil
-}
-
-func checkInitRepository(repoPath string) (err error) {
- // Somehow the directory could exist.
- if com.IsExist(repoPath) {
- return fmt.Errorf("initRepository: path already exists: %s", repoPath)
- }
-
- // Init git bare new repository.
- if err = git.InitRepository(repoPath, true); err != nil {
- return fmt.Errorf("InitRepository: %v", err)
- } else if err = createDelegateHooks(repoPath); err != nil {
- return fmt.Errorf("createDelegateHooks: %v", err)
- }
- return nil
-}
-
-// InitRepository initializes README and .gitignore if needed.
-func initRepository(e Engine, repoPath string, u *User, repo *Repository, opts CreateRepoOptions) (err error) {
- if err = checkInitRepository(repoPath); err != nil {
- return err
- }
-
- // Initialize repository according to user's choice.
- if opts.AutoInit {
- tmpDir, err := ioutil.TempDir(os.TempDir(), "gitea-"+repo.Name)
- if err != nil {
- return fmt.Errorf("Failed to create temp dir for repository %s: %v", repo.RepoPath(), err)
- }
-
- defer os.RemoveAll(tmpDir)
-
- if err = prepareRepoCommit(e, repo, tmpDir, repoPath, opts); err != nil {
- return fmt.Errorf("prepareRepoCommit: %v", err)
- }
-
- // Apply changes and commit.
- if err = initRepoCommit(tmpDir, repo, u); err != nil {
- return fmt.Errorf("initRepoCommit: %v", err)
- }
- }
-
- // Re-fetch the repository from database before updating it (else it would
- // override changes that were done earlier with sql)
- if repo, err = getRepositoryByID(e, repo.ID); err != nil {
- return fmt.Errorf("getRepositoryByID: %v", err)
- }
-
- if !opts.AutoInit {
- repo.IsEmpty = true
- }
-
- repo.DefaultBranch = "master"
- if err = updateRepository(e, repo, false); err != nil {
- return fmt.Errorf("updateRepository: %v", err)
- }
-
- return nil
-}
-
var (
reservedRepoNames = []string{".", ".."}
reservedRepoPatterns = []string{"*.git", "*.wiki"}
@@ -1208,22 +1015,23 @@ func IsUsableRepoName(name string) error {
return isUsableName(reservedRepoNames, reservedRepoPatterns, name)
}
-func createRepository(e Engine, doer, u *User, repo *Repository) (err error) {
+// CreateRepository creates a repository for the user/organization.
+func CreateRepository(ctx DBContext, doer, u *User, repo *Repository) (err error) {
if err = IsUsableRepoName(repo.Name); err != nil {
return err
}
- has, err := isRepositoryExist(e, u, repo.Name)
+ has, err := isRepositoryExist(ctx.e, u, repo.Name)
if err != nil {
return fmt.Errorf("IsRepositoryExist: %v", err)
} else if has {
return ErrRepoAlreadyExist{u.Name, repo.Name}
}
- if _, err = e.Insert(repo); err != nil {
+ if _, err = ctx.e.Insert(repo); err != nil {
return err
}
- if err = deleteRepoRedirect(e, u.ID, repo.Name); err != nil {
+ if err = deleteRepoRedirect(ctx.e, u.ID, repo.Name); err != nil {
return err
}
@@ -1252,20 +1060,19 @@ func createRepository(e Engine, doer, u *User, repo *Repository) (err error) {
Type: tp,
})
}
-
}
- if _, err = e.Insert(&units); err != nil {
+ if _, err = ctx.e.Insert(&units); err != nil {
return err
}
// Remember visibility preference.
u.LastRepoVisibility = repo.IsPrivate
- if err = updateUserCols(e, u, "last_repo_visibility"); err != nil {
+ if err = updateUserCols(ctx.e, u, "last_repo_visibility"); err != nil {
return fmt.Errorf("updateUser: %v", err)
}
- if _, err = e.Incr("num_repos").ID(u.ID).Update(new(User)); err != nil {
+ if _, err = ctx.e.Incr("num_repos").ID(u.ID).Update(new(User)); err != nil {
return fmt.Errorf("increment user total_repos: %v", err)
}
u.NumRepos++
@@ -1277,107 +1084,41 @@ func createRepository(e Engine, doer, u *User, repo *Repository) (err error) {
}
for _, t := range u.Teams {
if t.IncludesAllRepositories {
- if err := t.addRepository(e, repo); err != nil {
+ if err := t.addRepository(ctx.e, repo); err != nil {
return fmt.Errorf("addRepository: %v", err)
}
}
}
- if isAdmin, err := isUserRepoAdmin(e, repo, doer); err != nil {
+ if isAdmin, err := isUserRepoAdmin(ctx.e, repo, doer); err != nil {
return fmt.Errorf("isUserRepoAdmin: %v", err)
} else if !isAdmin {
// Make creator repo admin if it wan't assigned automatically
- if err = repo.addCollaborator(e, doer); err != nil {
+ if err = repo.addCollaborator(ctx.e, doer); err != nil {
return fmt.Errorf("AddCollaborator: %v", err)
}
- if err = repo.changeCollaborationAccessMode(e, doer.ID, AccessModeAdmin); err != nil {
+ if err = repo.changeCollaborationAccessMode(ctx.e, doer.ID, AccessModeAdmin); err != nil {
return fmt.Errorf("ChangeCollaborationAccessMode: %v", err)
}
}
- } else if err = repo.recalculateAccesses(e); err != nil {
+ } else if err = repo.recalculateAccesses(ctx.e); err != nil {
// Organization automatically called this in addRepository method.
return fmt.Errorf("recalculateAccesses: %v", err)
}
if setting.Service.AutoWatchNewRepos {
- if err = watchRepo(e, doer.ID, repo.ID, true); err != nil {
+ if err = watchRepo(ctx.e, doer.ID, repo.ID, true); err != nil {
return fmt.Errorf("watchRepo: %v", err)
}
}
- if err = copyDefaultWebhooksToRepo(e, repo.ID); err != nil {
+ if err = copyDefaultWebhooksToRepo(ctx.e, repo.ID); err != nil {
return fmt.Errorf("copyDefaultWebhooksToRepo: %v", err)
}
return nil
}
-// CreateRepository creates a repository for the user/organization.
-func CreateRepository(doer, u *User, opts CreateRepoOptions) (_ *Repository, err error) {
- if !doer.IsAdmin && !u.CanCreateRepo() {
- return nil, ErrReachLimitOfRepo{u.MaxRepoCreation}
- }
-
- repo := &Repository{
- OwnerID: u.ID,
- Owner: u,
- OwnerName: u.Name,
- Name: opts.Name,
- LowerName: strings.ToLower(opts.Name),
- Description: opts.Description,
- OriginalURL: opts.OriginalURL,
- OriginalServiceType: opts.GitServiceType,
- IsPrivate: opts.IsPrivate,
- IsFsckEnabled: !opts.IsMirror,
- CloseIssuesViaCommitInAnyBranch: setting.Repository.DefaultCloseIssuesViaCommitsInAnyBranch,
- Status: opts.Status,
- IsEmpty: !opts.AutoInit,
- }
-
- sess := x.NewSession()
- defer sess.Close()
- if err = sess.Begin(); err != nil {
- return nil, err
- }
-
- if err = createRepository(sess, doer, u, repo); err != nil {
- return nil, err
- }
-
- // No need for init mirror.
- if !opts.IsMirror {
- repoPath := RepoPath(u.Name, repo.Name)
- if err = initRepository(sess, repoPath, u, repo, opts); err != nil {
- if err2 := os.RemoveAll(repoPath); err2 != nil {
- log.Error("initRepository: %v", err)
- return nil, fmt.Errorf(
- "delete repo directory %s/%s failed(2): %v", u.Name, repo.Name, err2)
- }
- return nil, fmt.Errorf("initRepository: %v", err)
- }
-
- // Initialize Issue Labels if selected
- if len(opts.IssueLabels) > 0 {
- if err = initalizeLabels(sess, repo.ID, opts.IssueLabels); err != nil {
- return nil, fmt.Errorf("initalizeLabels: %v", err)
- }
- }
-
- if stdout, err := git.NewCommand("update-server-info").
- SetDescription(fmt.Sprintf("CreateRepository(git update-server-info): %s", repoPath)).
- RunInDir(repoPath); err != nil {
- log.Error("CreateRepitory(git update-server-info) in %v: Stdout: %s\nError: %v", repo, stdout, err)
- return nil, fmt.Errorf("CreateRepository(git update-server-info): %v", err)
- }
- }
-
- if err = sess.Commit(); err != nil {
- return nil, err
- }
-
- return repo, err
-}
-
func countRepositories(userID int64, private bool) int64 {
sess := x.Where("id > 0")
@@ -1414,6 +1155,12 @@ func RepoPath(userName, repoName string) string {
return filepath.Join(UserPath(userName), strings.ToLower(repoName)+".git")
}
+// IncrementRepoForkNum increment repository fork number
+func IncrementRepoForkNum(ctx DBContext, repoID int64) error {
+ _, err := ctx.e.Exec("UPDATE `repository` SET num_forks=num_forks+1 WHERE id=?", repoID)
+ return err
+}
+
// TransferOwnership transfers all corresponding setting from old user to new one.
func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error {
newOwner, err := GetUserByName(newOwnerName)
@@ -1672,6 +1419,11 @@ func updateRepository(e Engine, repo *Repository, visibilityChanged bool) (err e
return nil
}
+// UpdateRepositoryCtx updates a repository with db context
+func UpdateRepositoryCtx(ctx DBContext, repo *Repository, visibilityChanged bool) error {
+ return updateRepository(ctx.e, repo, visibilityChanged)
+}
+
// UpdateRepository updates a repository
func UpdateRepository(repo *Repository, visibilityChanged bool) (err error) {
sess := x.NewSession()
@@ -1987,6 +1739,11 @@ func GetRepositoryByID(id int64) (*Repository, error) {
return getRepositoryByID(x, id)
}
+// GetRepositoryByIDCtx returns the repository by given id if exists.
+func GetRepositoryByIDCtx(ctx DBContext, id int64) (*Repository, error) {
+ return getRepositoryByID(ctx.e, id)
+}
+
// GetRepositoriesMapByIDs returns the repositories by given id slice.
func GetRepositoriesMapByIDs(ids []int64) (map[int64]*Repository, error) {
var repos = make(map[int64]*Repository, len(ids))
@@ -2436,20 +2193,16 @@ func HasForkedRepo(ownerID, repoID int64) (*Repository, bool) {
}
// CopyLFS copies LFS data from one repo to another
-func CopyLFS(newRepo, oldRepo *Repository) error {
- return copyLFS(x, newRepo, oldRepo)
-}
-
-func copyLFS(e Engine, newRepo, oldRepo *Repository) error {
+func CopyLFS(ctx DBContext, newRepo, oldRepo *Repository) error {
var lfsObjects []*LFSMetaObject
- if err := e.Where("repository_id=?", oldRepo.ID).Find(&lfsObjects); err != nil {
+ if err := ctx.e.Where("repository_id=?", oldRepo.ID).Find(&lfsObjects); err != nil {
return err
}
for _, v := range lfsObjects {
v.ID = 0
v.RepositoryID = newRepo.ID
- if _, err := e.Insert(v); err != nil {
+ if _, err := ctx.e.Insert(v); err != nil {
return err
}
}
@@ -2457,81 +2210,6 @@ func copyLFS(e Engine, newRepo, oldRepo *Repository) error {
return nil
}
-// ForkRepository forks a repository
-func ForkRepository(doer, owner *User, oldRepo *Repository, name, desc string) (_ *Repository, err error) {
- forkedRepo, err := oldRepo.GetUserFork(owner.ID)
- if err != nil {
- return nil, err
- }
- if forkedRepo != nil {
- return nil, ErrForkAlreadyExist{
- Uname: owner.Name,
- RepoName: oldRepo.FullName(),
- ForkName: forkedRepo.FullName(),
- }
- }
-
- repo := &Repository{
- OwnerID: owner.ID,
- Owner: owner,
- OwnerName: owner.Name,
- Name: name,
- LowerName: strings.ToLower(name),
- Description: desc,
- DefaultBranch: oldRepo.DefaultBranch,
- IsPrivate: oldRepo.IsPrivate,
- IsEmpty: oldRepo.IsEmpty,
- IsFork: true,
- ForkID: oldRepo.ID,
- }
-
- sess := x.NewSession()
- defer sess.Close()
- if err = sess.Begin(); err != nil {
- return nil, err
- }
-
- if err = createRepository(sess, doer, owner, repo); err != nil {
- return nil, err
- }
-
- if _, err = sess.Exec("UPDATE `repository` SET num_forks=num_forks+1 WHERE id=?", oldRepo.ID); err != nil {
- return nil, err
- }
-
- repoPath := RepoPath(owner.Name, repo.Name)
- if stdout, err := git.NewCommand(
- "clone", "--bare", oldRepo.RepoPath(), repoPath).
- SetDescription(fmt.Sprintf("ForkRepository(git clone): %s to %s", oldRepo.FullName(), repo.FullName())).
- RunInDirTimeout(10*time.Minute, ""); err != nil {
- log.Error("Fork Repository (git clone) Failed for %v (from %v):\nStdout: %s\nError: %v", repo, oldRepo, stdout, err)
- return nil, fmt.Errorf("git clone: %v", err)
- }
-
- if stdout, err := git.NewCommand("update-server-info").
- SetDescription(fmt.Sprintf("ForkRepository(git update-server-info): %s", repo.FullName())).
- RunInDir(repoPath); err != nil {
- log.Error("Fork Repository (git update-server-info) failed for %v:\nStdout: %s\nError: %v", repo, stdout, err)
- return nil, fmt.Errorf("git update-server-info: %v", err)
- }
-
- if err = createDelegateHooks(repoPath); err != nil {
- return nil, fmt.Errorf("createDelegateHooks: %v", err)
- }
-
- //Commit repo to get Fork ID
- err = sess.Commit()
- if err != nil {
- return nil, err
- }
-
- if err = repo.UpdateSize(); err != nil {
- log.Error("Failed to update size for repository: %v", err)
- }
-
- return repo, CopyLFS(repo, oldRepo)
-}
-
// GetForks returns all the forks of the repository
func (repo *Repository) GetForks() ([]*Repository, error) {
forks := make([]*Repository, 0, repo.NumForks)
diff --git a/models/repo_generate.go b/models/repo_generate.go
index 6761c1ce41..b3230acd06 100644
--- a/models/repo_generate.go
+++ b/models/repo_generate.go
@@ -5,14 +5,8 @@
package models
import (
- "fmt"
- "io/ioutil"
- "os"
- "path"
- "path/filepath"
"strconv"
"strings"
- "time"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
@@ -71,186 +65,6 @@ func (gt GiteaTemplate) Globs() []glob.Glob {
return gt.globs
}
-func checkGiteaTemplate(tmpDir string) (*GiteaTemplate, error) {
- gtPath := filepath.Join(tmpDir, ".gitea", "template")
- if _, err := os.Stat(gtPath); os.IsNotExist(err) {
- return nil, nil
- } else if err != nil {
- return nil, err
- }
-
- content, err := ioutil.ReadFile(gtPath)
- if err != nil {
- return nil, err
- }
-
- gt := &GiteaTemplate{
- Path: gtPath,
- Content: content,
- }
-
- return gt, nil
-}
-
-func generateRepoCommit(e Engine, repo, templateRepo, generateRepo *Repository, tmpDir string) error {
- commitTimeStr := time.Now().Format(time.RFC3339)
- authorSig := repo.Owner.NewGitSig()
-
- // Because this may call hooks we should pass in the environment
- env := append(os.Environ(),
- "GIT_AUTHOR_NAME="+authorSig.Name,
- "GIT_AUTHOR_EMAIL="+authorSig.Email,
- "GIT_AUTHOR_DATE="+commitTimeStr,
- "GIT_COMMITTER_NAME="+authorSig.Name,
- "GIT_COMMITTER_EMAIL="+authorSig.Email,
- "GIT_COMMITTER_DATE="+commitTimeStr,
- )
-
- // Clone to temporary path and do the init commit.
- templateRepoPath := templateRepo.RepoPath()
- if err := git.Clone(templateRepoPath, tmpDir, git.CloneRepoOptions{
- Depth: 1,
- }); err != nil {
- return fmt.Errorf("git clone: %v", err)
- }
-
- if err := os.RemoveAll(path.Join(tmpDir, ".git")); err != nil {
- return fmt.Errorf("remove git dir: %v", err)
- }
-
- // Variable expansion
- gt, err := checkGiteaTemplate(tmpDir)
- if err != nil {
- return fmt.Errorf("checkGiteaTemplate: %v", err)
- }
-
- if gt != nil {
- if err := os.Remove(gt.Path); err != nil {
- return fmt.Errorf("remove .giteatemplate: %v", err)
- }
-
- // Avoid walking tree if there are no globs
- if len(gt.Globs()) > 0 {
- tmpDirSlash := strings.TrimSuffix(filepath.ToSlash(tmpDir), "/") + "/"
- if err := filepath.Walk(tmpDirSlash, func(path string, info os.FileInfo, walkErr error) error {
- if walkErr != nil {
- return walkErr
- }
-
- if info.IsDir() {
- return nil
- }
-
- base := strings.TrimPrefix(filepath.ToSlash(path), tmpDirSlash)
- for _, g := range gt.Globs() {
- if g.Match(base) {
- content, err := ioutil.ReadFile(path)
- if err != nil {
- return err
- }
-
- if err := ioutil.WriteFile(path,
- []byte(generateExpansion(string(content), templateRepo, generateRepo)),
- 0644); err != nil {
- return err
- }
- break
- }
- }
- return nil
- }); err != nil {
- return err
- }
- }
- }
-
- if err := git.InitRepository(tmpDir, false); err != nil {
- return err
- }
-
- repoPath := repo.RepoPath()
- if stdout, err := git.NewCommand("remote", "add", "origin", repoPath).
- SetDescription(fmt.Sprintf("generateRepoCommit (git remote add): %s to %s", templateRepoPath, tmpDir)).
- RunInDirWithEnv(tmpDir, env); err != nil {
- log.Error("Unable to add %v as remote origin to temporary repo to %s: stdout %s\nError: %v", repo, tmpDir, stdout, err)
- return fmt.Errorf("git remote add: %v", err)
- }
-
- return initRepoCommit(tmpDir, repo, repo.Owner)
-}
-
-// generateRepository initializes repository from template
-func generateRepository(e Engine, repo, templateRepo, generateRepo *Repository) (err error) {
- tmpDir, err := ioutil.TempDir(os.TempDir(), "gitea-"+repo.Name)
- if err != nil {
- return fmt.Errorf("Failed to create temp dir for repository %s: %v", repo.RepoPath(), err)
- }
-
- defer func() {
- if err := os.RemoveAll(tmpDir); err != nil {
- log.Error("RemoveAll: %v", err)
- }
- }()
-
- if err = generateRepoCommit(e, repo, templateRepo, generateRepo, tmpDir); err != nil {
- return fmt.Errorf("generateRepoCommit: %v", err)
- }
-
- // re-fetch repo
- if repo, err = getRepositoryByID(e, repo.ID); err != nil {
- return fmt.Errorf("getRepositoryByID: %v", err)
- }
-
- repo.DefaultBranch = "master"
- if err = updateRepository(e, repo, false); err != nil {
- return fmt.Errorf("updateRepository: %v", err)
- }
-
- return nil
-}
-
-// GenerateRepository generates a repository from a template
-func GenerateRepository(ctx DBContext, doer, owner *User, templateRepo *Repository, opts GenerateRepoOptions) (_ *Repository, err error) {
- generateRepo := &Repository{
- OwnerID: owner.ID,
- Owner: owner,
- Name: opts.Name,
- LowerName: strings.ToLower(opts.Name),
- Description: opts.Description,
- IsPrivate: opts.Private,
- IsEmpty: !opts.GitContent || templateRepo.IsEmpty,
- IsFsckEnabled: templateRepo.IsFsckEnabled,
- TemplateID: templateRepo.ID,
- }
-
- if err = createRepository(ctx.e, doer, owner, generateRepo); err != nil {
- return nil, err
- }
-
- repoPath := RepoPath(owner.Name, generateRepo.Name)
- if err = checkInitRepository(repoPath); err != nil {
- return generateRepo, err
- }
-
- return generateRepo, nil
-}
-
-// GenerateGitContent generates git content from a template repository
-func GenerateGitContent(ctx DBContext, templateRepo, generateRepo *Repository) error {
- if err := generateRepository(ctx.e, generateRepo, templateRepo, generateRepo); err != nil {
- return err
- }
-
- if err := generateRepo.updateSize(ctx.e); err != nil {
- return fmt.Errorf("failed to update size for repository: %v", err)
- }
-
- if err := copyLFS(ctx.e, generateRepo, templateRepo); err != nil {
- return fmt.Errorf("failed to copy LFS: %v", err)
- }
- return nil
-}
-
// GenerateTopics generates topics from a template repository
func GenerateTopics(ctx DBContext, templateRepo, generateRepo *Repository) error {
for _, topic := range templateRepo.Topics {
@@ -352,36 +166,3 @@ func GenerateIssueLabels(ctx DBContext, templateRepo, generateRepo *Repository)
}
return nil
}
-
-func generateExpansion(src string, templateRepo, generateRepo *Repository) string {
- return os.Expand(src, func(key string) string {
- switch key {
- case "REPO_NAME":
- return generateRepo.Name
- case "TEMPLATE_NAME":
- return templateRepo.Name
- case "REPO_DESCRIPTION":
- return generateRepo.Description
- case "TEMPLATE_DESCRIPTION":
- return templateRepo.Description
- case "REPO_OWNER":
- return generateRepo.OwnerName
- case "TEMPLATE_OWNER":
- return templateRepo.OwnerName
- case "REPO_LINK":
- return generateRepo.Link()
- case "TEMPLATE_LINK":
- return templateRepo.Link()
- case "REPO_HTTPS_URL":
- return generateRepo.CloneLink().HTTPS
- case "TEMPLATE_HTTPS_URL":
- return templateRepo.CloneLink().HTTPS
- case "REPO_SSH_URL":
- return generateRepo.CloneLink().SSH
- case "TEMPLATE_SSH_URL":
- return templateRepo.CloneLink().SSH
- default:
- return key
- }
- })
-}
diff --git a/models/repo_test.go b/models/repo_test.go
index 3a6555c766..20da43fbbf 100644
--- a/models/repo_test.go
+++ b/models/repo_test.go
@@ -133,19 +133,6 @@ func TestGetUserFork(t *testing.T) {
assert.Nil(t, repo)
}
-func TestForkRepository(t *testing.T) {
- assert.NoError(t, PrepareTestDatabase())
-
- // user 13 has already forked repo10
- user := AssertExistsAndLoadBean(t, &User{ID: 13}).(*User)
- repo := AssertExistsAndLoadBean(t, &Repository{ID: 10}).(*Repository)
-
- fork, err := ForkRepository(user, user, repo, "test", "test")
- assert.Nil(t, fork)
- assert.Error(t, err)
- assert.True(t, IsErrForkAlreadyExist(err))
-}
-
func TestRepoAPIURL(t *testing.T) {
assert.NoError(t, PrepareTestDatabase())
repo := AssertExistsAndLoadBean(t, &Repository{ID: 10}).(*Repository)
diff --git a/models/task.go b/models/task.go
index e1d751bc3c..f4fce058c0 100644
--- a/models/task.go
+++ b/models/task.go
@@ -8,8 +8,6 @@ import (
"encoding/json"
"fmt"
- "code.gitea.io/gitea/modules/log"
- "code.gitea.io/gitea/modules/migrations/base"
"code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/modules/timeutil"
@@ -169,57 +167,16 @@ func FindTasks(opts FindTaskOptions) ([]*Task, error) {
return tasks, err
}
+// CreateTask creates a task on database
+func CreateTask(task *Task) error {
+ return createTask(x, task)
+}
+
func createTask(e Engine, task *Task) error {
_, err := e.Insert(task)
return err
}
-// CreateMigrateTask creates a migrate task
-func CreateMigrateTask(doer, u *User, opts base.MigrateOptions) (*Task, error) {
- bs, err := json.Marshal(&opts)
- if err != nil {
- return nil, err
- }
-
- var task = Task{
- DoerID: doer.ID,
- OwnerID: u.ID,
- Type: structs.TaskTypeMigrateRepo,
- Status: structs.TaskStatusQueue,
- PayloadContent: string(bs),
- }
-
- if err := createTask(x, &task); err != nil {
- return nil, err
- }
-
- repo, err := CreateRepository(doer, u, CreateRepoOptions{
- Name: opts.RepoName,
- Description: opts.Description,
- OriginalURL: opts.OriginalURL,
- GitServiceType: opts.GitServiceType,
- IsPrivate: opts.Private,
- IsMirror: opts.Mirror,
- Status: RepositoryBeingMigrated,
- })
- if err != nil {
- task.EndTime = timeutil.TimeStampNow()
- task.Status = structs.TaskStatusFailed
- err2 := task.UpdateCols("end_time", "status")
- if err2 != nil {
- log.Error("UpdateCols Failed: %v", err2.Error())
- }
- return nil, err
- }
-
- task.RepoID = repo.ID
- if err = task.UpdateCols("repo_id"); err != nil {
- return nil, err
- }
-
- return &task, nil
-}
-
// FinishMigrateTask updates database when migrate task finished
func FinishMigrateTask(task *Task) error {
task.Status = structs.TaskStatusFinished
diff --git a/modules/migrations/gitea.go b/modules/migrations/gitea.go
index 94e81bd9a5..88414e6cad 100644
--- a/modules/migrations/gitea.go
+++ b/modules/migrations/gitea.go
@@ -23,6 +23,7 @@ import (
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/migrations/base"
"code.gitea.io/gitea/modules/repository"
+ repo_module "code.gitea.io/gitea/modules/repository"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/modules/timeutil"
@@ -100,7 +101,7 @@ func (g *GiteaLocalUploader) CreateRepo(repo *base.Repository, opts base.Migrate
var r *models.Repository
if opts.MigrateToRepoID <= 0 {
- r, err = models.CreateRepository(g.doer, owner, models.CreateRepoOptions{
+ r, err = repo_module.CreateRepository(g.doer, owner, models.CreateRepoOptions{
Name: g.repoName,
Description: repo.Description,
OriginalURL: repo.OriginalURL,
diff --git a/modules/repofiles/update.go b/modules/repofiles/update.go
index 3a0ba668c1..812649af36 100644
--- a/modules/repofiles/update.go
+++ b/modules/repofiles/update.go
@@ -458,7 +458,7 @@ func PushUpdate(repo *models.Repository, branch string, opts PushUpdateOptions)
}
defer gitRepo.Close()
- if err = repo.UpdateSize(); err != nil {
+ if err = repo.UpdateSize(models.DefaultDBContext()); err != nil {
log.Error("Failed to update size for repository: %v", err)
}
@@ -498,7 +498,7 @@ func PushUpdates(repo *models.Repository, optsList []*PushUpdateOptions) error {
if err != nil {
return fmt.Errorf("OpenRepository: %v", err)
}
- if err = repo.UpdateSize(); err != nil {
+ if err = repo.UpdateSize(models.DefaultDBContext()); err != nil {
log.Error("Failed to update size for repository: %v", err)
}
diff --git a/modules/repository/create.go b/modules/repository/create.go
new file mode 100644
index 0000000000..dc96b856d9
--- /dev/null
+++ b/modules/repository/create.go
@@ -0,0 +1,77 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package repository
+
+import (
+ "fmt"
+ "os"
+ "strings"
+
+ "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/modules/git"
+ "code.gitea.io/gitea/modules/log"
+ "code.gitea.io/gitea/modules/setting"
+)
+
+// CreateRepository creates a repository for the user/organization.
+func CreateRepository(doer, u *models.User, opts models.CreateRepoOptions) (_ *models.Repository, err error) {
+ if !doer.IsAdmin && !u.CanCreateRepo() {
+ return nil, models.ErrReachLimitOfRepo{
+ Limit: u.MaxRepoCreation,
+ }
+ }
+
+ repo := &models.Repository{
+ OwnerID: u.ID,
+ Owner: u,
+ OwnerName: u.Name,
+ Name: opts.Name,
+ LowerName: strings.ToLower(opts.Name),
+ Description: opts.Description,
+ OriginalURL: opts.OriginalURL,
+ OriginalServiceType: opts.GitServiceType,
+ IsPrivate: opts.IsPrivate,
+ IsFsckEnabled: !opts.IsMirror,
+ CloseIssuesViaCommitInAnyBranch: setting.Repository.DefaultCloseIssuesViaCommitsInAnyBranch,
+ Status: opts.Status,
+ IsEmpty: !opts.AutoInit,
+ }
+
+ err = models.WithTx(func(ctx models.DBContext) error {
+ if err = models.CreateRepository(ctx, doer, u, repo); err != nil {
+ return err
+ }
+
+ // No need for init mirror.
+ if !opts.IsMirror {
+ repoPath := models.RepoPath(u.Name, repo.Name)
+ if err = initRepository(ctx, repoPath, u, repo, opts); err != nil {
+ if err2 := os.RemoveAll(repoPath); err2 != nil {
+ log.Error("initRepository: %v", err)
+ return fmt.Errorf(
+ "delete repo directory %s/%s failed(2): %v", u.Name, repo.Name, err2)
+ }
+ return fmt.Errorf("initRepository: %v", err)
+ }
+
+ // Initialize Issue Labels if selected
+ if len(opts.IssueLabels) > 0 {
+ if err = models.InitalizeLabels(ctx, repo.ID, opts.IssueLabels); err != nil {
+ return fmt.Errorf("initalizeLabels: %v", err)
+ }
+ }
+
+ if stdout, err := git.NewCommand("update-server-info").
+ SetDescription(fmt.Sprintf("CreateRepository(git update-server-info): %s", repoPath)).
+ RunInDir(repoPath); err != nil {
+ log.Error("CreateRepitory(git update-server-info) in %v: Stdout: %s\nError: %v", repo, stdout, err)
+ return fmt.Errorf("CreateRepository(git update-server-info): %v", err)
+ }
+ }
+ return nil
+ })
+
+ return repo, err
+}
diff --git a/modules/repository/create_test.go b/modules/repository/create_test.go
new file mode 100644
index 0000000000..53c0b0f305
--- /dev/null
+++ b/modules/repository/create_test.go
@@ -0,0 +1,145 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package repository
+
+import (
+ "fmt"
+ "testing"
+
+ "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/modules/structs"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestIncludesAllRepositoriesTeams(t *testing.T) {
+ assert.NoError(t, models.PrepareTestDatabase())
+
+ testTeamRepositories := func(teamID int64, repoIds []int64) {
+ team := models.AssertExistsAndLoadBean(t, &models.Team{ID: teamID}).(*models.Team)
+ assert.NoError(t, team.GetRepositories(), "%s: GetRepositories", team.Name)
+ assert.Len(t, team.Repos, team.NumRepos, "%s: len repo", team.Name)
+ assert.Equal(t, len(repoIds), len(team.Repos), "%s: repo count", team.Name)
+ for i, rid := range repoIds {
+ if rid > 0 {
+ assert.True(t, team.HasRepository(rid), "%s: HasRepository(%d) %d", rid, i)
+ }
+ }
+ }
+
+ // Get an admin user.
+ user, err := models.GetUserByID(1)
+ assert.NoError(t, err, "GetUserByID")
+
+ // Create org.
+ org := &models.User{
+ Name: "All repo",
+ IsActive: true,
+ Type: models.UserTypeOrganization,
+ Visibility: structs.VisibleTypePublic,
+ }
+ assert.NoError(t, models.CreateOrganization(org, user), "CreateOrganization")
+
+ // Check Owner team.
+ ownerTeam, err := org.GetOwnerTeam()
+ assert.NoError(t, err, "GetOwnerTeam")
+ assert.True(t, ownerTeam.IncludesAllRepositories, "Owner team includes all repositories")
+
+ // Create repos.
+ repoIds := make([]int64, 0)
+ for i := 0; i < 3; i++ {
+ r, err := CreateRepository(user, org, models.CreateRepoOptions{Name: fmt.Sprintf("repo-%d", i)})
+ assert.NoError(t, err, "CreateRepository %d", i)
+ if r != nil {
+ repoIds = append(repoIds, r.ID)
+ }
+ }
+ // Get fresh copy of Owner team after creating repos.
+ ownerTeam, err = org.GetOwnerTeam()
+ assert.NoError(t, err, "GetOwnerTeam")
+
+ // Create teams and check repositories.
+ teams := []*models.Team{
+ ownerTeam,
+ {
+ OrgID: org.ID,
+ Name: "team one",
+ Authorize: models.AccessModeRead,
+ IncludesAllRepositories: true,
+ },
+ {
+ OrgID: org.ID,
+ Name: "team 2",
+ Authorize: models.AccessModeRead,
+ IncludesAllRepositories: false,
+ },
+ {
+ OrgID: org.ID,
+ Name: "team three",
+ Authorize: models.AccessModeWrite,
+ IncludesAllRepositories: true,
+ },
+ {
+ OrgID: org.ID,
+ Name: "team 4",
+ Authorize: models.AccessModeWrite,
+ IncludesAllRepositories: false,
+ },
+ }
+ teamRepos := [][]int64{
+ repoIds,
+ repoIds,
+ {},
+ repoIds,
+ {},
+ }
+ for i, team := range teams {
+ if i > 0 { // first team is Owner.
+ assert.NoError(t, models.NewTeam(team), "%s: NewTeam", team.Name)
+ }
+ testTeamRepositories(team.ID, teamRepos[i])
+ }
+
+ // Update teams and check repositories.
+ teams[3].IncludesAllRepositories = false
+ teams[4].IncludesAllRepositories = true
+ teamRepos[4] = repoIds
+ for i, team := range teams {
+ assert.NoError(t, models.UpdateTeam(team, false, true), "%s: UpdateTeam", team.Name)
+ testTeamRepositories(team.ID, teamRepos[i])
+ }
+
+ // Create repo and check teams repositories.
+ org.Teams = nil // Reset teams to allow their reloading.
+ r, err := CreateRepository(user, org, models.CreateRepoOptions{Name: "repo-last"})
+ assert.NoError(t, err, "CreateRepository last")
+ if r != nil {
+ repoIds = append(repoIds, r.ID)
+ }
+ teamRepos[0] = repoIds
+ teamRepos[1] = repoIds
+ teamRepos[4] = repoIds
+ for i, team := range teams {
+ testTeamRepositories(team.ID, teamRepos[i])
+ }
+
+ // Remove repo and check teams repositories.
+ assert.NoError(t, models.DeleteRepository(user, org.ID, repoIds[0]), "DeleteRepository")
+ teamRepos[0] = repoIds[1:]
+ teamRepos[1] = repoIds[1:]
+ teamRepos[3] = repoIds[1:3]
+ teamRepos[4] = repoIds[1:]
+ for i, team := range teams {
+ testTeamRepositories(team.ID, teamRepos[i])
+ }
+
+ // Wipe created items.
+ for i, rid := range repoIds {
+ if i > 0 { // first repo already deleted.
+ assert.NoError(t, models.DeleteRepository(user, org.ID, rid), "DeleteRepository %d", i)
+ }
+ }
+ assert.NoError(t, models.DeleteOrganization(org), "DeleteOrganization")
+}
diff --git a/modules/repository/fork.go b/modules/repository/fork.go
new file mode 100644
index 0000000000..8953ce9ba4
--- /dev/null
+++ b/modules/repository/fork.go
@@ -0,0 +1,87 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package repository
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/modules/git"
+ "code.gitea.io/gitea/modules/log"
+)
+
+// ForkRepository forks a repository
+func ForkRepository(doer, owner *models.User, oldRepo *models.Repository, name, desc string) (_ *models.Repository, err error) {
+ forkedRepo, err := oldRepo.GetUserFork(owner.ID)
+ if err != nil {
+ return nil, err
+ }
+ if forkedRepo != nil {
+ return nil, models.ErrForkAlreadyExist{
+ Uname: owner.Name,
+ RepoName: oldRepo.FullName(),
+ ForkName: forkedRepo.FullName(),
+ }
+ }
+
+ repo := &models.Repository{
+ OwnerID: owner.ID,
+ Owner: owner,
+ OwnerName: owner.Name,
+ Name: name,
+ LowerName: strings.ToLower(name),
+ Description: desc,
+ DefaultBranch: oldRepo.DefaultBranch,
+ IsPrivate: oldRepo.IsPrivate,
+ IsEmpty: oldRepo.IsEmpty,
+ IsFork: true,
+ ForkID: oldRepo.ID,
+ }
+
+ oldRepoPath := oldRepo.RepoPath()
+
+ err = models.WithTx(func(ctx models.DBContext) error {
+ if err = models.CreateRepository(ctx, doer, owner, repo); err != nil {
+ return err
+ }
+
+ if err = models.IncrementRepoForkNum(ctx, oldRepo.ID); err != nil {
+ return err
+ }
+
+ repoPath := models.RepoPath(owner.Name, repo.Name)
+ if stdout, err := git.NewCommand(
+ "clone", "--bare", oldRepoPath, repoPath).
+ SetDescription(fmt.Sprintf("ForkRepository(git clone): %s to %s", oldRepo.FullName(), repo.FullName())).
+ RunInDirTimeout(10*time.Minute, ""); err != nil {
+ log.Error("Fork Repository (git clone) Failed for %v (from %v):\nStdout: %s\nError: %v", repo, oldRepo, stdout, err)
+ return fmt.Errorf("git clone: %v", err)
+ }
+
+ if stdout, err := git.NewCommand("update-server-info").
+ SetDescription(fmt.Sprintf("ForkRepository(git update-server-info): %s", repo.FullName())).
+ RunInDir(repoPath); err != nil {
+ log.Error("Fork Repository (git update-server-info) failed for %v:\nStdout: %s\nError: %v", repo, stdout, err)
+ return fmt.Errorf("git update-server-info: %v", err)
+ }
+
+ if err = models.CreateDelegateHooks(repoPath); err != nil {
+ return fmt.Errorf("createDelegateHooks: %v", err)
+ }
+ return nil
+ })
+ if err != nil {
+ return nil, err
+ }
+
+ ctx := models.DefaultDBContext()
+ if err = repo.UpdateSize(ctx); err != nil {
+ log.Error("Failed to update size for repository: %v", err)
+ }
+
+ return repo, models.CopyLFS(ctx, repo, oldRepo)
+}
diff --git a/modules/repository/fork_test.go b/modules/repository/fork_test.go
new file mode 100644
index 0000000000..cb3526bccf
--- /dev/null
+++ b/modules/repository/fork_test.go
@@ -0,0 +1,25 @@
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package repository
+
+import (
+ "testing"
+
+ "code.gitea.io/gitea/models"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestForkRepository(t *testing.T) {
+ assert.NoError(t, models.PrepareTestDatabase())
+
+ // user 13 has already forked repo10
+ user := models.AssertExistsAndLoadBean(t, &models.User{ID: 13}).(*models.User)
+ repo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 10}).(*models.Repository)
+
+ fork, err := ForkRepository(user, user, repo, "test", "test")
+ assert.Nil(t, fork)
+ assert.Error(t, err)
+ assert.True(t, models.IsErrForkAlreadyExist(err))
+}
diff --git a/modules/repository/generate.go b/modules/repository/generate.go
new file mode 100644
index 0000000000..96ce25e59f
--- /dev/null
+++ b/modules/repository/generate.go
@@ -0,0 +1,230 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package repository
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path"
+ "path/filepath"
+ "strings"
+ "time"
+
+ "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/modules/git"
+ "code.gitea.io/gitea/modules/log"
+)
+
+func generateExpansion(src string, templateRepo, generateRepo *models.Repository) string {
+ return os.Expand(src, func(key string) string {
+ switch key {
+ case "REPO_NAME":
+ return generateRepo.Name
+ case "TEMPLATE_NAME":
+ return templateRepo.Name
+ case "REPO_DESCRIPTION":
+ return generateRepo.Description
+ case "TEMPLATE_DESCRIPTION":
+ return templateRepo.Description
+ case "REPO_OWNER":
+ return generateRepo.OwnerName
+ case "TEMPLATE_OWNER":
+ return templateRepo.OwnerName
+ case "REPO_LINK":
+ return generateRepo.Link()
+ case "TEMPLATE_LINK":
+ return templateRepo.Link()
+ case "REPO_HTTPS_URL":
+ return generateRepo.CloneLink().HTTPS
+ case "TEMPLATE_HTTPS_URL":
+ return templateRepo.CloneLink().HTTPS
+ case "REPO_SSH_URL":
+ return generateRepo.CloneLink().SSH
+ case "TEMPLATE_SSH_URL":
+ return templateRepo.CloneLink().SSH
+ default:
+ return key
+ }
+ })
+}
+
+func checkGiteaTemplate(tmpDir string) (*models.GiteaTemplate, error) {
+ gtPath := filepath.Join(tmpDir, ".gitea", "template")
+ if _, err := os.Stat(gtPath); os.IsNotExist(err) {
+ return nil, nil
+ } else if err != nil {
+ return nil, err
+ }
+
+ content, err := ioutil.ReadFile(gtPath)
+ if err != nil {
+ return nil, err
+ }
+
+ gt := &models.GiteaTemplate{
+ Path: gtPath,
+ Content: content,
+ }
+
+ return gt, nil
+}
+
+func generateRepoCommit(repo, templateRepo, generateRepo *models.Repository, tmpDir string) error {
+ commitTimeStr := time.Now().Format(time.RFC3339)
+ authorSig := repo.Owner.NewGitSig()
+
+ // Because this may call hooks we should pass in the environment
+ env := append(os.Environ(),
+ "GIT_AUTHOR_NAME="+authorSig.Name,
+ "GIT_AUTHOR_EMAIL="+authorSig.Email,
+ "GIT_AUTHOR_DATE="+commitTimeStr,
+ "GIT_COMMITTER_NAME="+authorSig.Name,
+ "GIT_COMMITTER_EMAIL="+authorSig.Email,
+ "GIT_COMMITTER_DATE="+commitTimeStr,
+ )
+
+ // Clone to temporary path and do the init commit.
+ templateRepoPath := templateRepo.RepoPath()
+ if err := git.Clone(templateRepoPath, tmpDir, git.CloneRepoOptions{
+ Depth: 1,
+ }); err != nil {
+ return fmt.Errorf("git clone: %v", err)
+ }
+
+ if err := os.RemoveAll(path.Join(tmpDir, ".git")); err != nil {
+ return fmt.Errorf("remove git dir: %v", err)
+ }
+
+ // Variable expansion
+ gt, err := checkGiteaTemplate(tmpDir)
+ if err != nil {
+ return fmt.Errorf("checkGiteaTemplate: %v", err)
+ }
+
+ if err := os.Remove(gt.Path); err != nil {
+ return fmt.Errorf("remove .giteatemplate: %v", err)
+ }
+
+ // Avoid walking tree if there are no globs
+ if len(gt.Globs()) > 0 {
+ tmpDirSlash := strings.TrimSuffix(filepath.ToSlash(tmpDir), "/") + "/"
+ if err := filepath.Walk(tmpDirSlash, func(path string, info os.FileInfo, walkErr error) error {
+ if walkErr != nil {
+ return walkErr
+ }
+
+ if info.IsDir() {
+ return nil
+ }
+
+ base := strings.TrimPrefix(filepath.ToSlash(path), tmpDirSlash)
+ for _, g := range gt.Globs() {
+ if g.Match(base) {
+ content, err := ioutil.ReadFile(path)
+ if err != nil {
+ return err
+ }
+
+ if err := ioutil.WriteFile(path,
+ []byte(generateExpansion(string(content), templateRepo, generateRepo)),
+ 0644); err != nil {
+ return err
+ }
+ break
+ }
+ }
+ return nil
+ }); err != nil {
+ return err
+ }
+ }
+
+ if err := git.InitRepository(tmpDir, false); err != nil {
+ return err
+ }
+
+ repoPath := repo.RepoPath()
+ if stdout, err := git.NewCommand("remote", "add", "origin", repoPath).
+ SetDescription(fmt.Sprintf("generateRepoCommit (git remote add): %s to %s", templateRepoPath, tmpDir)).
+ RunInDirWithEnv(tmpDir, env); err != nil {
+ log.Error("Unable to add %v as remote origin to temporary repo to %s: stdout %s\nError: %v", repo, tmpDir, stdout, err)
+ return fmt.Errorf("git remote add: %v", err)
+ }
+
+ return initRepoCommit(tmpDir, repo, repo.Owner)
+}
+
+func generateGitContent(ctx models.DBContext, repo, templateRepo, generateRepo *models.Repository) (err error) {
+ tmpDir, err := ioutil.TempDir(os.TempDir(), "gitea-"+repo.Name)
+ if err != nil {
+ return fmt.Errorf("Failed to create temp dir for repository %s: %v", repo.RepoPath(), err)
+ }
+
+ defer func() {
+ if err := os.RemoveAll(tmpDir); err != nil {
+ log.Error("RemoveAll: %v", err)
+ }
+ }()
+
+ if err = generateRepoCommit(repo, templateRepo, generateRepo, tmpDir); err != nil {
+ return fmt.Errorf("generateRepoCommit: %v", err)
+ }
+
+ // re-fetch repo
+ if repo, err = models.GetRepositoryByIDCtx(ctx, repo.ID); err != nil {
+ return fmt.Errorf("getRepositoryByID: %v", err)
+ }
+
+ repo.DefaultBranch = "master"
+ if err = models.UpdateRepositoryCtx(ctx, repo, false); err != nil {
+ return fmt.Errorf("updateRepository: %v", err)
+ }
+
+ return nil
+}
+
+// GenerateGitContent generates git content from a template repository
+func GenerateGitContent(ctx models.DBContext, templateRepo, generateRepo *models.Repository) error {
+ if err := generateGitContent(ctx, generateRepo, templateRepo, generateRepo); err != nil {
+ return err
+ }
+
+ if err := generateRepo.UpdateSize(ctx); err != nil {
+ return fmt.Errorf("failed to update size for repository: %v", err)
+ }
+
+ if err := models.CopyLFS(ctx, generateRepo, templateRepo); err != nil {
+ return fmt.Errorf("failed to copy LFS: %v", err)
+ }
+ return nil
+}
+
+// GenerateRepository generates a repository from a template
+func GenerateRepository(ctx models.DBContext, doer, owner *models.User, templateRepo *models.Repository, opts models.GenerateRepoOptions) (_ *models.Repository, err error) {
+ generateRepo := &models.Repository{
+ OwnerID: owner.ID,
+ Owner: owner,
+ OwnerName: owner.Name,
+ Name: opts.Name,
+ LowerName: strings.ToLower(opts.Name),
+ Description: opts.Description,
+ IsPrivate: opts.Private,
+ IsEmpty: !opts.GitContent || templateRepo.IsEmpty,
+ IsFsckEnabled: templateRepo.IsFsckEnabled,
+ TemplateID: templateRepo.ID,
+ }
+
+ if err = models.CreateRepository(ctx, doer, owner, generateRepo); err != nil {
+ return nil, err
+ }
+
+ repoPath := models.RepoPath(owner.Name, generateRepo.Name)
+ if err = checkInitRepository(repoPath); err != nil {
+ return generateRepo, err
+ }
+
+ return generateRepo, nil
+}
diff --git a/modules/repository/init.go b/modules/repository/init.go
new file mode 100644
index 0000000000..a65b335174
--- /dev/null
+++ b/modules/repository/init.go
@@ -0,0 +1,214 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package repository
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+ "time"
+
+ "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/modules/git"
+ "code.gitea.io/gitea/modules/log"
+
+ "github.com/mcuadros/go-version"
+ "github.com/unknwon/com"
+)
+
+func prepareRepoCommit(ctx models.DBContext, repo *models.Repository, tmpDir, repoPath string, opts models.CreateRepoOptions) error {
+ commitTimeStr := time.Now().Format(time.RFC3339)
+ authorSig := repo.Owner.NewGitSig()
+
+ // Because this may call hooks we should pass in the environment
+ env := append(os.Environ(),
+ "GIT_AUTHOR_NAME="+authorSig.Name,
+ "GIT_AUTHOR_EMAIL="+authorSig.Email,
+ "GIT_AUTHOR_DATE="+commitTimeStr,
+ "GIT_COMMITTER_NAME="+authorSig.Name,
+ "GIT_COMMITTER_EMAIL="+authorSig.Email,
+ "GIT_COMMITTER_DATE="+commitTimeStr,
+ )
+
+ // Clone to temporary path and do the init commit.
+ if stdout, err := git.NewCommand("clone", repoPath, tmpDir).
+ SetDescription(fmt.Sprintf("prepareRepoCommit (git clone): %s to %s", repoPath, tmpDir)).
+ RunInDirWithEnv("", env); err != nil {
+ log.Error("Failed to clone from %v into %s: stdout: %s\nError: %v", repo, tmpDir, stdout, err)
+ return fmt.Errorf("git clone: %v", err)
+ }
+
+ // README
+ data, err := models.GetRepoInitFile("readme", opts.Readme)
+ if err != nil {
+ return fmt.Errorf("GetRepoInitFile[%s]: %v", opts.Readme, err)
+ }
+
+ cloneLink := repo.CloneLink()
+ match := map[string]string{
+ "Name": repo.Name,
+ "Description": repo.Description,
+ "CloneURL.SSH": cloneLink.SSH,
+ "CloneURL.HTTPS": cloneLink.HTTPS,
+ }
+ if err = ioutil.WriteFile(filepath.Join(tmpDir, "README.md"),
+ []byte(com.Expand(string(data), match)), 0644); err != nil {
+ return fmt.Errorf("write README.md: %v", err)
+ }
+
+ // .gitignore
+ if len(opts.Gitignores) > 0 {
+ var buf bytes.Buffer
+ names := strings.Split(opts.Gitignores, ",")
+ for _, name := range names {
+ data, err = models.GetRepoInitFile("gitignore", name)
+ if err != nil {
+ return fmt.Errorf("GetRepoInitFile[%s]: %v", name, err)
+ }
+ buf.WriteString("# ---> " + name + "\n")
+ buf.Write(data)
+ buf.WriteString("\n")
+ }
+
+ if buf.Len() > 0 {
+ if err = ioutil.WriteFile(filepath.Join(tmpDir, ".gitignore"), buf.Bytes(), 0644); err != nil {
+ return fmt.Errorf("write .gitignore: %v", err)
+ }
+ }
+ }
+
+ // LICENSE
+ if len(opts.License) > 0 {
+ data, err = models.GetRepoInitFile("license", opts.License)
+ if err != nil {
+ return fmt.Errorf("GetRepoInitFile[%s]: %v", opts.License, err)
+ }
+
+ if err = ioutil.WriteFile(filepath.Join(tmpDir, "LICENSE"), data, 0644); err != nil {
+ return fmt.Errorf("write LICENSE: %v", err)
+ }
+ }
+
+ return nil
+}
+
+// initRepoCommit temporarily changes with work directory.
+func initRepoCommit(tmpPath string, repo *models.Repository, u *models.User) (err error) {
+ commitTimeStr := time.Now().Format(time.RFC3339)
+
+ sig := u.NewGitSig()
+ // Because this may call hooks we should pass in the environment
+ env := append(os.Environ(),
+ "GIT_AUTHOR_NAME="+sig.Name,
+ "GIT_AUTHOR_EMAIL="+sig.Email,
+ "GIT_AUTHOR_DATE="+commitTimeStr,
+ "GIT_COMMITTER_NAME="+sig.Name,
+ "GIT_COMMITTER_EMAIL="+sig.Email,
+ "GIT_COMMITTER_DATE="+commitTimeStr,
+ )
+
+ if stdout, err := git.NewCommand("add", "--all").
+ SetDescription(fmt.Sprintf("initRepoCommit (git add): %s", tmpPath)).
+ RunInDir(tmpPath); err != nil {
+ log.Error("git add --all failed: Stdout: %s\nError: %v", stdout, err)
+ return fmt.Errorf("git add --all: %v", err)
+ }
+
+ binVersion, err := git.BinVersion()
+ if err != nil {
+ return fmt.Errorf("Unable to get git version: %v", err)
+ }
+
+ args := []string{
+ "commit", fmt.Sprintf("--author='%s <%s>'", sig.Name, sig.Email),
+ "-m", "Initial commit",
+ }
+
+ if version.Compare(binVersion, "1.7.9", ">=") {
+ sign, keyID := models.SignInitialCommit(tmpPath, u)
+ if sign {
+ args = append(args, "-S"+keyID)
+ } else if version.Compare(binVersion, "2.0.0", ">=") {
+ args = append(args, "--no-gpg-sign")
+ }
+ }
+
+ if stdout, err := git.NewCommand(args...).
+ SetDescription(fmt.Sprintf("initRepoCommit (git commit): %s", tmpPath)).
+ RunInDirWithEnv(tmpPath, env); err != nil {
+ log.Error("Failed to commit: %v: Stdout: %s\nError: %v", args, stdout, err)
+ return fmt.Errorf("git commit: %v", err)
+ }
+
+ if stdout, err := git.NewCommand("push", "origin", "master").
+ SetDescription(fmt.Sprintf("initRepoCommit (git push): %s", tmpPath)).
+ RunInDirWithEnv(tmpPath, models.InternalPushingEnvironment(u, repo)); err != nil {
+ log.Error("Failed to push back to master: Stdout: %s\nError: %v", stdout, err)
+ return fmt.Errorf("git push: %v", err)
+ }
+
+ return nil
+}
+
+func checkInitRepository(repoPath string) (err error) {
+ // Somehow the directory could exist.
+ if com.IsExist(repoPath) {
+ return fmt.Errorf("checkInitRepository: path already exists: %s", repoPath)
+ }
+
+ // Init git bare new repository.
+ if err = git.InitRepository(repoPath, true); err != nil {
+ return fmt.Errorf("git.InitRepository: %v", err)
+ } else if err = models.CreateDelegateHooks(repoPath); err != nil {
+ return fmt.Errorf("createDelegateHooks: %v", err)
+ }
+ return nil
+}
+
+// InitRepository initializes README and .gitignore if needed.
+func initRepository(ctx models.DBContext, repoPath string, u *models.User, repo *models.Repository, opts models.CreateRepoOptions) (err error) {
+ if err = checkInitRepository(repoPath); err != nil {
+ return err
+ }
+
+ // Initialize repository according to user's choice.
+ if opts.AutoInit {
+ tmpDir, err := ioutil.TempDir(os.TempDir(), "gitea-"+repo.Name)
+ if err != nil {
+ return fmt.Errorf("Failed to create temp dir for repository %s: %v", repo.RepoPath(), err)
+ }
+
+ defer os.RemoveAll(tmpDir)
+
+ if err = prepareRepoCommit(ctx, repo, tmpDir, repoPath, opts); err != nil {
+ return fmt.Errorf("prepareRepoCommit: %v", err)
+ }
+
+ // Apply changes and commit.
+ if err = initRepoCommit(tmpDir, repo, u); err != nil {
+ return fmt.Errorf("initRepoCommit: %v", err)
+ }
+ }
+
+ // Re-fetch the repository from database before updating it (else it would
+ // override changes that were done earlier with sql)
+ if repo, err = models.GetRepositoryByIDCtx(ctx, repo.ID); err != nil {
+ return fmt.Errorf("getRepositoryByID: %v", err)
+ }
+
+ if !opts.AutoInit {
+ repo.IsEmpty = true
+ }
+
+ repo.DefaultBranch = "master"
+ if err = models.UpdateRepositoryCtx(ctx, repo, false); err != nil {
+ return fmt.Errorf("updateRepository: %v", err)
+ }
+
+ return nil
+}
diff --git a/modules/repository/repo.go b/modules/repository/repo.go
index b0b118e038..bb8cceeadc 100644
--- a/modules/repository/repo.go
+++ b/modules/repository/repo.go
@@ -116,7 +116,7 @@ func MigrateRepositoryGitData(doer, u *models.User, repo *models.Repository, opt
}
}
- if err = repo.UpdateSize(); err != nil {
+ if err = repo.UpdateSize(models.DefaultDBContext()); err != nil {
log.Error("Failed to update size for repository: %v", err)
}
diff --git a/modules/task/task.go b/modules/task/task.go
index 416f0c696a..72f111ecc7 100644
--- a/modules/task/task.go
+++ b/modules/task/task.go
@@ -5,6 +5,7 @@
package task
import (
+ "encoding/json"
"fmt"
"code.gitea.io/gitea/models"
@@ -12,7 +13,9 @@ import (
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/migrations/base"
"code.gitea.io/gitea/modules/queue"
+ repo_module "code.gitea.io/gitea/modules/repository"
"code.gitea.io/gitea/modules/structs"
+ "code.gitea.io/gitea/modules/timeutil"
)
// taskQueue is a global queue of tasks
@@ -52,10 +55,56 @@ func handle(data ...queue.Data) {
// MigrateRepository add migration repository to task
func MigrateRepository(doer, u *models.User, opts base.MigrateOptions) error {
- task, err := models.CreateMigrateTask(doer, u, opts)
+ task, err := CreateMigrateTask(doer, u, opts)
if err != nil {
return err
}
return taskQueue.Push(task)
}
+
+// CreateMigrateTask creates a migrate task
+func CreateMigrateTask(doer, u *models.User, opts base.MigrateOptions) (*models.Task, error) {
+ bs, err := json.Marshal(&opts)
+ if err != nil {
+ return nil, err
+ }
+
+ var task = models.Task{
+ DoerID: doer.ID,
+ OwnerID: u.ID,
+ Type: structs.TaskTypeMigrateRepo,
+ Status: structs.TaskStatusQueue,
+ PayloadContent: string(bs),
+ }
+
+ if err := models.CreateTask(&task); err != nil {
+ return nil, err
+ }
+
+ repo, err := repo_module.CreateRepository(doer, u, models.CreateRepoOptions{
+ Name: opts.RepoName,
+ Description: opts.Description,
+ OriginalURL: opts.OriginalURL,
+ GitServiceType: opts.GitServiceType,
+ IsPrivate: opts.Private,
+ IsMirror: opts.Mirror,
+ Status: models.RepositoryBeingMigrated,
+ })
+ if err != nil {
+ task.EndTime = timeutil.TimeStampNow()
+ task.Status = structs.TaskStatusFailed
+ err2 := task.UpdateCols("end_time", "status")
+ if err2 != nil {
+ log.Error("UpdateCols Failed: %v", err2.Error())
+ }
+ return nil, err
+ }
+
+ task.RepoID = repo.ID
+ if err = task.UpdateCols("repo_id"); err != nil {
+ return nil, err
+ }
+
+ return &task, nil
+}
diff --git a/routers/api/v1/repo/repo.go b/routers/api/v1/repo/repo.go
index 2990ccd276..c7959c6db9 100644
--- a/routers/api/v1/repo/repo.go
+++ b/routers/api/v1/repo/repo.go
@@ -22,8 +22,8 @@ import (
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/migrations"
"code.gitea.io/gitea/modules/notification"
+ repo_module "code.gitea.io/gitea/modules/repository"
"code.gitea.io/gitea/modules/setting"
- "code.gitea.io/gitea/modules/structs"
api "code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/modules/util"
"code.gitea.io/gitea/modules/validation"
@@ -451,10 +451,10 @@ func Migrate(ctx *context.APIContext, form auth.MigrateRepoForm) {
return
}
- var gitServiceType = structs.PlainGitService
+ var gitServiceType = api.PlainGitService
u, err := url.Parse(remoteAddr)
if err == nil && strings.EqualFold(u.Host, "github.com") {
- gitServiceType = structs.GithubService
+ gitServiceType = api.GithubService
}
var opts = migrations.MigrateOptions{
@@ -483,7 +483,7 @@ func Migrate(ctx *context.APIContext, form auth.MigrateRepoForm) {
opts.Releases = false
}
- repo, err := models.CreateRepository(ctx.User, ctxUser, models.CreateRepoOptions{
+ repo, err := repo_module.CreateRepository(ctx.User, ctxUser, models.CreateRepoOptions{
Name: opts.RepoName,
Description: opts.Description,
OriginalURL: form.CloneAddr,
diff --git a/routers/repo/issue_label.go b/routers/repo/issue_label.go
index 02568f77a6..98f2dded31 100644
--- a/routers/repo/issue_label.go
+++ b/routers/repo/issue_label.go
@@ -35,7 +35,7 @@ func InitializeLabels(ctx *context.Context, form auth.InitializeLabelsForm) {
return
}
- if err := models.InitalizeLabels(ctx.Repo.Repository.ID, form.TemplateName); err != nil {
+ if err := models.InitalizeLabels(models.DefaultDBContext(), ctx.Repo.Repository.ID, form.TemplateName); err != nil {
if models.IsErrIssueLabelTemplateLoad(err) {
originalErr := err.(models.ErrIssueLabelTemplateLoad).OriginalError
ctx.Flash.Error(ctx.Tr("repo.issues.label_templates.fail_to_load_file", form.TemplateName, originalErr))
diff --git a/services/mirror/mirror.go b/services/mirror/mirror.go
index d4f97c2600..0c7f3ae3c7 100644
--- a/services/mirror/mirror.go
+++ b/services/mirror/mirror.go
@@ -217,7 +217,7 @@ func runSync(m *models.Mirror) ([]*mirrorSyncResult, bool) {
}
gitRepo.Close()
- if err := m.Repo.UpdateSize(); err != nil {
+ if err := m.Repo.UpdateSize(models.DefaultDBContext()); err != nil {
log.Error("Failed to update size for mirror repository: %v", err)
}
diff --git a/services/mirror/mirror_test.go b/services/mirror/mirror_test.go
index 816ef230fd..25e499ad78 100644
--- a/services/mirror/mirror_test.go
+++ b/services/mirror/mirror_test.go
@@ -38,7 +38,7 @@ func TestRelease_MirrorDelete(t *testing.T) {
Releases: false,
}
- mirrorRepo, err := models.CreateRepository(user, user, models.CreateRepoOptions{
+ mirrorRepo, err := repository.CreateRepository(user, user, models.CreateRepoOptions{
Name: opts.RepoName,
Description: opts.Description,
IsPrivate: opts.Private,
diff --git a/services/repository/generate.go b/services/repository/generate.go
index f7e8ebd8c4..95e5cdc6c2 100644
--- a/services/repository/generate.go
+++ b/services/repository/generate.go
@@ -8,20 +8,21 @@ import (
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/notification"
+ repo_module "code.gitea.io/gitea/modules/repository"
)
// GenerateRepository generates a repository from a template
func GenerateRepository(doer, owner *models.User, templateRepo *models.Repository, opts models.GenerateRepoOptions) (_ *models.Repository, err error) {
var generateRepo *models.Repository
if err = models.WithTx(func(ctx models.DBContext) error {
- generateRepo, err = models.GenerateRepository(ctx, doer, owner, templateRepo, opts)
+ generateRepo, err = repo_module.GenerateRepository(ctx, doer, owner, templateRepo, opts)
if err != nil {
return err
}
// Git Content
if opts.GitContent && !templateRepo.IsEmpty {
- if err = models.GenerateGitContent(ctx, templateRepo, generateRepo); err != nil {
+ if err = repo_module.GenerateGitContent(ctx, templateRepo, generateRepo); err != nil {
return err
}
}
diff --git a/services/repository/repository.go b/services/repository/repository.go
index 2fb45bb617..eea8b352b4 100644
--- a/services/repository/repository.go
+++ b/services/repository/repository.go
@@ -10,11 +10,12 @@ import (
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/notification"
+ repo_module "code.gitea.io/gitea/modules/repository"
)
// CreateRepository creates a repository for the user/organization.
func CreateRepository(doer, owner *models.User, opts models.CreateRepoOptions) (*models.Repository, error) {
- repo, err := models.CreateRepository(doer, owner, opts)
+ repo, err := repo_module.CreateRepository(doer, owner, opts)
if err != nil {
if repo != nil {
if errDelete := models.DeleteRepository(doer, owner.ID, repo.ID); errDelete != nil {
@@ -31,7 +32,7 @@ func CreateRepository(doer, owner *models.User, opts models.CreateRepoOptions) (
// ForkRepository forks a repository
func ForkRepository(doer, u *models.User, oldRepo *models.Repository, name, desc string) (*models.Repository, error) {
- repo, err := models.ForkRepository(doer, u, oldRepo, name, desc)
+ repo, err := repo_module.ForkRepository(doer, u, oldRepo, name, desc)
if err != nil {
if repo != nil {
if errDelete := models.DeleteRepository(doer, u.ID, repo.ID); errDelete != nil {