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

@@ -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 {
+func InitalizeLabels(ctx DBContext, repoID int64, labelTemplate string) error {
-	return initalizeLabels(x, repoID, labelTemplate)
+	return initalizeLabels(ctx.e, repoID, labelTemplate)
 }
 
 func newLabel(e Engine, label *Label) error {

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")
-}

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 {
+func (repo *Repository) UpdateSize(ctx DBContext) error {
-	return repo.updateSize(x)
+	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 {
+func CopyLFS(ctx DBContext, newRepo, oldRepo *Repository) error {
-	return copyLFS(x, newRepo, oldRepo)
-}
-
-func copyLFS(e Engine, 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)

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
-		}
-	})
-}

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)

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

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,

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)
 	}
 

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
+}

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")
+}

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)
+}

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))
+}

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
+}

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
+}

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)
 	}
 

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
+}

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,

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))

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)
 	}
 

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,

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
 			}
 		}

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 {