* 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 conflictstags/v1.10.5
@@ -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 { |
@@ -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") | |||
} |
@@ -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) |
@@ -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 | |||
} | |||
}) | |||
} |
@@ -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) |
@@ -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 |
@@ -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, |
@@ -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) | |||
} | |||
@@ -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 | |||
} |
@@ -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") | |||
} |
@@ -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) | |||
} |
@@ -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)) | |||
} |
@@ -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 | |||
} |
@@ -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 | |||
} |
@@ -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) | |||
} | |||
@@ -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 | |||
} |
@@ -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, |
@@ -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)) |
@@ -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) | |||
} | |||
@@ -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, |
@@ -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 | |||
} | |||
} |
@@ -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 { |