Merge pull request 'Revert "avoid superfluous synchronized pull_request run when opening a PR"' (#2848) from earl-warren/forgejo:wip-revert-bad-race-fix into forgejo

Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/2848
Reviewed-by: oliverpool <oliverpool@noreply.codeberg.org>

models/issues/issue_index.go

@@ -9,14 +9,6 @@ import (
 	"code.gitea.io/gitea/models/db"
 )
 
-func GetMaxIssueIndexForRepo(ctx context.Context, repoID int64) (int64, error) {
-	var max int64
-	if _, err := db.GetEngine(ctx).Select("MAX(`index`)").Table("issue").Where("repo_id=?", repoID).Get(&max); err != nil {
-		return 0, err
-	}
-	return max, nil
-}
-
 // RecalculateIssueIndexForRepo create issue_index for repo if not exist and
 // update it based on highest index of existing issues assigned to a repo
 func RecalculateIssueIndexForRepo(ctx context.Context, repoID int64) error {
@@ -26,8 +18,8 @@ func RecalculateIssueIndexForRepo(ctx context.Context, repoID int64) error {
 	}
 	defer committer.Close()
 
-	max, err := GetMaxIssueIndexForRepo(ctx, repoID)
+	var max int64
-	if err != nil {
+	if _, err = db.GetEngine(ctx).Select(" MAX(`index`)").Table("issue").Where("repo_id=?", repoID).Get(&max); err != nil {
 		return err
 	}
 

models/issues/issue_index_test.go

@@ -1,38 +0,0 @@
-// Copyright 2024 The Forgejo Authors
-// SPDX-License-Identifier: MIT
-
-package issues_test
-
-import (
-	"testing"
-
-	"code.gitea.io/gitea/models/db"
-	issues_model "code.gitea.io/gitea/models/issues"
-	repo_model "code.gitea.io/gitea/models/repo"
-	"code.gitea.io/gitea/models/unittest"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetMaxIssueIndexForRepo(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-
-	maxPR, err := issues_model.GetMaxIssueIndexForRepo(db.DefaultContext, repo.ID)
-	assert.NoError(t, err)
-
-	issue := testCreateIssue(t, repo.ID, repo.OwnerID, "title1", "content1", false)
-	assert.Greater(t, issue.Index, maxPR)
-
-	maxPR, err = issues_model.GetMaxIssueIndexForRepo(db.DefaultContext, repo.ID)
-	assert.NoError(t, err)
-
-	pull := testCreateIssue(t, repo.ID, repo.OwnerID, "title2", "content2", true)
-	assert.Greater(t, pull.Index, maxPR)
-
-	maxPR, err = issues_model.GetMaxIssueIndexForRepo(db.DefaultContext, repo.ID)
-	assert.NoError(t, err)
-
-	assert.Equal(t, maxPR, pull.Index)
-}

models/issues/pull_list.go

@@ -47,14 +47,6 @@ func listPullRequestStatement(ctx context.Context, baseRepoID int64, opts *PullR
 	return sess, nil
 }
 
-func GetUnmergedPullRequestsByHeadInfoMax(ctx context.Context, repoID, maxIndex int64, branch string) ([]*PullRequest, error) {
-	prs := make([]*PullRequest, 0, 2)
-	sess := db.GetEngine(ctx).
-		Join("INNER", "issue", "issue.id = `pull_request`.issue_id").
-		Where("`pull_request`.head_repo_id = ? AND `pull_request`.head_branch = ? AND `pull_request`.has_merged = ? AND `issue`.is_closed = ? AND `pull_request`.flow = ? AND `issue`.`index` <= ?", repoID, branch, false, false, PullRequestFlowGithub, maxIndex)
-	return prs, sess.Find(&prs)
-}
-
 // GetUnmergedPullRequestsByHeadInfo returns all pull requests that are open and has not been merged
 func GetUnmergedPullRequestsByHeadInfo(ctx context.Context, repoID int64, branch string) ([]*PullRequest, error) {
 	prs := make([]*PullRequest, 0, 2)

models/issues/pull_test.go

@@ -4,7 +4,6 @@
 package issues_test
 
 import (
-	"fmt"
 	"testing"
 
 	"code.gitea.io/gitea/models/db"
@@ -157,91 +156,6 @@ func TestGetUnmergedPullRequestsByHeadInfo(t *testing.T) {
 	}
 }
 
-func TestGetUnmergedPullRequestsByHeadInfoMax(t *testing.T) {
-	assert.NoError(t, unittest.PrepareTestDatabase())
-
-	repoID := int64(1)
-	maxPR := int64(0)
-	prs, err := issues_model.GetUnmergedPullRequestsByHeadInfoMax(db.DefaultContext, repoID, maxPR, "branch2")
-	assert.NoError(t, err)
-	assert.Len(t, prs, 0)
-	maxPR, err = issues_model.GetMaxIssueIndexForRepo(db.DefaultContext, repoID)
-	assert.NoError(t, err)
-	prs, err = issues_model.GetUnmergedPullRequestsByHeadInfoMax(db.DefaultContext, repoID, maxPR, "branch2")
-	assert.NoError(t, err)
-	assert.Len(t, prs, 1)
-	for _, pr := range prs {
-		assert.Equal(t, int64(1), pr.HeadRepoID)
-		assert.Equal(t, "branch2", pr.HeadBranch)
-	}
-	pr := prs[0]
-
-	for _, testCase := range []struct {
-		table   string
-		field   string
-		id      int64
-		match   any
-		nomatch any
-	}{
-		{
-			table:   "issue",
-			field:   "is_closed",
-			id:      pr.IssueID,
-			match:   false,
-			nomatch: true,
-		},
-		{
-			table:   "pull_request",
-			field:   "flow",
-			id:      pr.ID,
-			match:   issues_model.PullRequestFlowGithub,
-			nomatch: issues_model.PullRequestFlowAGit,
-		},
-		{
-			table:   "pull_request",
-			field:   "head_repo_id",
-			id:      pr.ID,
-			match:   pr.HeadRepoID,
-			nomatch: 0,
-		},
-		{
-			table:   "pull_request",
-			field:   "head_branch",
-			id:      pr.ID,
-			match:   pr.HeadBranch,
-			nomatch: "something else",
-		},
-		{
-			table:   "pull_request",
-			field:   "has_merged",
-			id:      pr.ID,
-			match:   false,
-			nomatch: true,
-		},
-	} {
-		t.Run(testCase.field, func(t *testing.T) {
-			update := fmt.Sprintf("UPDATE `%s` SET `%s` = ? WHERE `id` = ?", testCase.table, testCase.field)
-
-			// expect no match
-			_, err = db.GetEngine(db.DefaultContext).Exec(update, testCase.nomatch, testCase.id)
-			assert.NoError(t, err)
-			prs, err = issues_model.GetUnmergedPullRequestsByHeadInfoMax(db.DefaultContext, repoID, maxPR, "branch2")
-			assert.NoError(t, err)
-			assert.Len(t, prs, 0)
-
-			// expect one match
-			_, err = db.GetEngine(db.DefaultContext).Exec(update, testCase.match, testCase.id)
-			assert.NoError(t, err)
-			prs, err = issues_model.GetUnmergedPullRequestsByHeadInfoMax(db.DefaultContext, repoID, maxPR, "branch2")
-			assert.NoError(t, err)
-			assert.Len(t, prs, 1)
-
-			// identical to the known PR
-			assert.Equal(t, pr.ID, prs[0].ID)
-		})
-	}
-}
-
 func TestGetUnmergedPullRequestsByBaseInfo(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	prs, err := issues_model.GetUnmergedPullRequestsByBaseInfo(db.DefaultContext, 1, "master")

services/pull/merge.go

@@ -187,7 +187,7 @@ func Merge(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.U
 	}
 
 	defer func() {
-		AddTestPullRequestTask(ctx, doer, pr.BaseRepo.ID, pr.BaseBranch, false, "", "")
+		go AddTestPullRequestTask(doer, pr.BaseRepo.ID, pr.BaseBranch, false, "", "")
 	}()
 
 	pr.MergedCommitID, err = doMergeAndPush(ctx, pr, doer, mergeStyle, expectedHeadCommitID, message)

services/pull/pull.go

@@ -292,129 +292,113 @@ func checkForInvalidation(ctx context.Context, requests issues_model.PullRequest
 
 // AddTestPullRequestTask adds new test tasks by given head/base repository and head/base branch,
 // and generate new patch for testing as needed.
-func AddTestPullRequestTask(ctx context.Context, doer *user_model.User, repoID int64, branch string, isSync bool, oldCommitID, newCommitID string) {
+func AddTestPullRequestTask(doer *user_model.User, repoID int64, branch string, isSync bool, oldCommitID, newCommitID string) {
-	// When TestPullRequest runs it must ignore any PR with an index > maxPR because they
+	log.Trace("AddTestPullRequestTask [head_repo_id: %d, head_branch: %s]: finding pull requests", repoID, branch)
-	// would have been created after the goroutine started. They are in the future.
+	graceful.GetManager().RunWithShutdownContext(func(ctx context.Context) {
-	// This guards the following race:
-	// * commit A is pushed
-	// * goroutine starts but does not run TestPullRequest yet
-	// * a pull request with commit A as the head is created
-	// * goroutine continues and runs TestPullRequest
-	maxPR, err := issues_model.GetMaxIssueIndexForRepo(ctx, repoID)
-	if err != nil {
-		log.Error("AddTestPullRequestTask GetMaxIssueIndexForRepo(%d): %v", repoID, err)
-		return
-	}
-	log.Trace("AddTestPullRequestTask [head_repo_id: %d, head_branch: %s]: only pull requests with index <= %d will be considered", repoID, branch, maxPR)
-	go graceful.GetManager().RunWithShutdownContext(func(ctx context.Context) {
 		// There is no sensible way to shut this down ":-("
 		// If you don't let it run all the way then you will lose data
-		// TODO: graceful: TestPullRequest needs to become a queue!
+		// TODO: graceful: AddTestPullRequestTask needs to become a queue!
 
-		TestPullRequest(ctx, doer, repoID, maxPR, branch, isSync, oldCommitID, newCommitID)
+		// GetUnmergedPullRequestsByHeadInfo() only return open and unmerged PR.
-	})
+		prs, err := issues_model.GetUnmergedPullRequestsByHeadInfo(ctx, repoID, branch)
-}
+		if err != nil {
+			log.Error("Find pull requests [head_repo_id: %d, head_branch: %s]: %v", repoID, branch, err)
+			return
+		}
 
-func TestPullRequest(ctx context.Context, doer *user_model.User, repoID, maxPR int64, branch string, isSync bool, oldCommitID, newCommitID string) {
+		for _, pr := range prs {
-	// GetUnmergedPullRequestsByHeadInfo() only return open and unmerged PR.
+			log.Trace("Updating PR[%d]: composing new test task", pr.ID)
-	prs, err := issues_model.GetUnmergedPullRequestsByHeadInfoMax(ctx, repoID, maxPR, branch)
+			if pr.Flow == issues_model.PullRequestFlowGithub {
-	if err != nil {
+				if err := PushToBaseRepo(ctx, pr); err != nil {
-		log.Error("Find pull requests [head_repo_id: %d, head_branch: %s]: %v", repoID, branch, err)
+					log.Error("PushToBaseRepo: %v", err)
-		return
+					continue
-	}
+				}
-
+			} else {
-	for _, pr := range prs {
-		log.Trace("Updating PR[id=%d,index=%d]: composing new test task", pr.ID, pr.Index)
-		if pr.Flow == issues_model.PullRequestFlowGithub {
-			if err := PushToBaseRepo(ctx, pr); err != nil {
-				log.Error("PushToBaseRepo: %v", err)
 				continue
 			}
-		} else {
+
-			continue
+			AddToTaskQueue(ctx, pr)
+			comment, err := CreatePushPullComment(ctx, doer, pr, oldCommitID, newCommitID)
+			if err == nil && comment != nil {
+				notify_service.PullRequestPushCommits(ctx, doer, pr, comment)
+			}
 		}
 
-		AddToTaskQueue(ctx, pr)
+		if isSync {
-		comment, err := CreatePushPullComment(ctx, doer, pr, oldCommitID, newCommitID)
+			requests := issues_model.PullRequestList(prs)
-		if err == nil && comment != nil {
+			if err = requests.LoadAttributes(ctx); err != nil {
-			notify_service.PullRequestPushCommits(ctx, doer, pr, comment)
+				log.Error("PullRequestList.LoadAttributes: %v", err)
-		}
+			}
-	}
+			if invalidationErr := checkForInvalidation(ctx, requests, repoID, doer, branch); invalidationErr != nil {
-
+				log.Error("checkForInvalidation: %v", invalidationErr)
-	if isSync {
+			}
-		requests := issues_model.PullRequestList(prs)
+			if err == nil {
-		if err = requests.LoadAttributes(ctx); err != nil {
+				for _, pr := range prs {
-			log.Error("PullRequestList.LoadAttributes: %v", err)
+					objectFormat := git.ObjectFormatFromName(pr.BaseRepo.ObjectFormatName)
-		}
+					if newCommitID != "" && newCommitID != objectFormat.EmptyObjectID().String() {
-		if invalidationErr := checkForInvalidation(ctx, requests, repoID, doer, branch); invalidationErr != nil {
+						changed, err := checkIfPRContentChanged(ctx, pr, oldCommitID, newCommitID)
-			log.Error("checkForInvalidation: %v", invalidationErr)
-		}
-		if err == nil {
-			for _, pr := range prs {
-				objectFormat := git.ObjectFormatFromName(pr.BaseRepo.ObjectFormatName)
-				if newCommitID != "" && newCommitID != objectFormat.EmptyObjectID().String() {
-					changed, err := checkIfPRContentChanged(ctx, pr, oldCommitID, newCommitID)
-					if err != nil {
-						log.Error("checkIfPRContentChanged: %v", err)
-					}
-					if changed {
-						// Mark old reviews as stale if diff to mergebase has changed
-						if err := issues_model.MarkReviewsAsStale(ctx, pr.IssueID); err != nil {
-							log.Error("MarkReviewsAsStale: %v", err)
-						}
-
-						// dismiss all approval reviews if protected branch rule item enabled.
-						pb, err := git_model.GetFirstMatchProtectedBranchRule(ctx, pr.BaseRepoID, pr.BaseBranch)
 						if err != nil {
-							log.Error("GetFirstMatchProtectedBranchRule: %v", err)
+							log.Error("checkIfPRContentChanged: %v", err)
 						}
-						if pb != nil && pb.DismissStaleApprovals {
+						if changed {
-							if err := DismissApprovalReviews(ctx, doer, pr); err != nil {
+							// Mark old reviews as stale if diff to mergebase has changed
-								log.Error("DismissApprovalReviews: %v", err)
+							if err := issues_model.MarkReviewsAsStale(ctx, pr.IssueID); err != nil {
+								log.Error("MarkReviewsAsStale: %v", err)
+							}
+
+							// dismiss all approval reviews if protected branch rule item enabled.
+							pb, err := git_model.GetFirstMatchProtectedBranchRule(ctx, pr.BaseRepoID, pr.BaseBranch)
+							if err != nil {
+								log.Error("GetFirstMatchProtectedBranchRule: %v", err)
+							}
+							if pb != nil && pb.DismissStaleApprovals {
+								if err := DismissApprovalReviews(ctx, doer, pr); err != nil {
+									log.Error("DismissApprovalReviews: %v", err)
+								}
+							}
+						}
+						if err := issues_model.MarkReviewsAsNotStale(ctx, pr.IssueID, newCommitID); err != nil {
+							log.Error("MarkReviewsAsNotStale: %v", err)
+						}
+						divergence, err := GetDiverging(ctx, pr)
+						if err != nil {
+							log.Error("GetDiverging: %v", err)
+						} else {
+							err = pr.UpdateCommitDivergence(ctx, divergence.Ahead, divergence.Behind)
+							if err != nil {
+								log.Error("UpdateCommitDivergence: %v", err)
 							}
 						}
 					}
-					if err := issues_model.MarkReviewsAsNotStale(ctx, pr.IssueID, newCommitID); err != nil {
+
-						log.Error("MarkReviewsAsNotStale: %v", err)
+					notify_service.PullRequestSynchronized(ctx, doer, pr)
-					}
-					divergence, err := GetDiverging(ctx, pr)
-					if err != nil {
-						log.Error("GetDiverging: %v", err)
-					} else {
-						err = pr.UpdateCommitDivergence(ctx, divergence.Ahead, divergence.Behind)
-						if err != nil {
-							log.Error("UpdateCommitDivergence: %v", err)
-						}
-					}
 				}
-
-				notify_service.PullRequestSynchronized(ctx, doer, pr)
 			}
 		}
-	}
 
-	log.Trace("TestPullRequest [base_repo_id: %d, base_branch: %s]: finding pull requests", repoID, branch)
+		log.Trace("AddTestPullRequestTask [base_repo_id: %d, base_branch: %s]: finding pull requests", repoID, branch)
-	prs, err = issues_model.GetUnmergedPullRequestsByBaseInfo(ctx, repoID, branch)
+		prs, err = issues_model.GetUnmergedPullRequestsByBaseInfo(ctx, repoID, branch)
-	if err != nil {
-		log.Error("Find pull requests [base_repo_id: %d, base_branch: %s]: %v", repoID, branch, err)
-		return
-	}
-	for _, pr := range prs {
-		divergence, err := GetDiverging(ctx, pr)
 		if err != nil {
-			if git_model.IsErrBranchNotExist(err) && !git.IsBranchExist(ctx, pr.HeadRepo.RepoPath(), pr.HeadBranch) {
+			log.Error("Find pull requests [base_repo_id: %d, base_branch: %s]: %v", repoID, branch, err)
-				log.Warn("Cannot test PR %s/%d: head_branch %s no longer exists", pr.BaseRepo.Name, pr.IssueID, pr.HeadBranch)
+			return
-			} else {
-				log.Error("GetDiverging: %v", err)
-			}
-		} else {
-			err = pr.UpdateCommitDivergence(ctx, divergence.Ahead, divergence.Behind)
-			if err != nil {
-				log.Error("UpdateCommitDivergence: %v", err)
-			}
 		}
-		AddToTaskQueue(ctx, pr)
+		for _, pr := range prs {
-	}
+			divergence, err := GetDiverging(ctx, pr)
+			if err != nil {
+				if git_model.IsErrBranchNotExist(err) && !git.IsBranchExist(ctx, pr.HeadRepo.RepoPath(), pr.HeadBranch) {
+					log.Warn("Cannot test PR %s/%d: head_branch %s no longer exists", pr.BaseRepo.Name, pr.IssueID, pr.HeadBranch)
+				} else {
+					log.Error("GetDiverging: %v", err)
+				}
+			} else {
+				err = pr.UpdateCommitDivergence(ctx, divergence.Ahead, divergence.Behind)
+				if err != nil {
+					log.Error("UpdateCommitDivergence: %v", err)
+				}
+			}
+			AddToTaskQueue(ctx, pr)
+		}
+	})
 }
 
 // checkIfPRContentChanged checks if diff to target branch has changed by push

services/pull/update.go

@@ -36,7 +36,7 @@ func Update(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.
 
 	if rebase {
 		defer func() {
-			AddTestPullRequestTask(ctx, doer, pr.BaseRepo.ID, pr.BaseBranch, false, "", "")
+			go AddTestPullRequestTask(doer, pr.BaseRepo.ID, pr.BaseBranch, false, "", "")
 		}()
 
 		return updateHeadByRebaseOnToBase(ctx, pr, doer, message)
@@ -75,7 +75,7 @@ func Update(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.
 	_, err = doMergeAndPush(ctx, reversePR, doer, repo_model.MergeStyleMerge, "", message)
 
 	defer func() {
-		AddTestPullRequestTask(ctx, doer, reversePR.HeadRepo.ID, reversePR.HeadBranch, false, "", "")
+		go AddTestPullRequestTask(doer, reversePR.HeadRepo.ID, reversePR.HeadBranch, false, "", "")
 	}()
 
 	return err

services/repository/push.go

@@ -166,7 +166,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
 			branch := opts.RefFullName.BranchName()
 			if !opts.IsDelRef() {
 				log.Trace("TriggerTask '%s/%s' by %s", repo.Name, branch, pusher.Name)
-				pull_service.AddTestPullRequestTask(ctx, pusher, repo.ID, branch, true, opts.OldCommitID, opts.NewCommitID)
+				go pull_service.AddTestPullRequestTask(pusher, repo.ID, branch, true, opts.OldCommitID, opts.NewCommitID)
 
 				newCommit, err := gitRepo.GetCommit(opts.NewCommitID)
 				if err != nil {

tests/integration/pull_request_task_test.go

@@ -1,86 +0,0 @@
-// Copyright 2024 The Forgejo Authors
-// SPDX-License-Identifier: MIT
-
-package integration
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	issues_model "code.gitea.io/gitea/models/issues"
-	repo_model "code.gitea.io/gitea/models/repo"
-	"code.gitea.io/gitea/models/unittest"
-	user_model "code.gitea.io/gitea/models/user"
-	"code.gitea.io/gitea/modules/git"
-	"code.gitea.io/gitea/modules/log"
-	repo_module "code.gitea.io/gitea/modules/repository"
-	"code.gitea.io/gitea/modules/test"
-	pull_service "code.gitea.io/gitea/services/pull"
-	repo_service "code.gitea.io/gitea/services/repository"
-	"code.gitea.io/gitea/tests"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestPullRequestSynchronized(t *testing.T) {
-	defer tests.PrepareTestEnv(t)()
-
-	// unmerged pull request of user2/repo1 from branch2 to master
-	pull := unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: 2})
-	// tip of tests/gitea-repositories-meta/user2/repo1 branch2
-	pull.HeadCommitID = "985f0301dba5e7b34be866819cd15ad3d8f508ee"
-
-	require.Equal(t, pull.HeadRepoID, pull.BaseRepoID)
-	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: pull.HeadRepoID})
-	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
-
-	t.Run("AddTestPullRequestTask", func(t *testing.T) {
-		logChecker, cleanup := test.NewLogChecker(log.DEFAULT, log.TRACE)
-		logChecker.Filter("Updating PR").StopMark("TestPullRequest ")
-		defer cleanup()
-
-		opt := &repo_module.PushUpdateOptions{
-			PusherID:     owner.ID,
-			PusherName:   owner.Name,
-			RepoUserName: owner.Name,
-			RepoName:     repo.Name,
-			RefFullName:  git.RefName("refs/heads/branch2"),
-			OldCommitID:  pull.HeadCommitID,
-			NewCommitID:  pull.HeadCommitID,
-		}
-		require.NoError(t, repo_service.PushUpdate(opt))
-		logFiltered, logStopped := logChecker.Check(5 * time.Second)
-		assert.True(t, logStopped)
-		assert.True(t, logFiltered[0])
-	})
-
-	for _, testCase := range []struct {
-		name     string
-		maxPR    int64
-		expected bool
-	}{
-		{
-			name:     "TestPullRequest process PR",
-			maxPR:    pull.Index,
-			expected: true,
-		},
-		{
-			name:     "TestPullRequest skip PR",
-			maxPR:    pull.Index - 1,
-			expected: false,
-		},
-	} {
-		t.Run(testCase.name, func(t *testing.T) {
-			logChecker, cleanup := test.NewLogChecker(log.DEFAULT, log.TRACE)
-			logChecker.Filter("Updating PR").StopMark("TestPullRequest ")
-			defer cleanup()
-
-			pull_service.TestPullRequest(context.Background(), owner, repo.ID, testCase.maxPR, "branch2", true, pull.HeadCommitID, pull.HeadCommitID)
-			logFiltered, logStopped := logChecker.Check(5 * time.Second)
-			assert.True(t, logStopped)
-			assert.Equal(t, testCase.expected, logFiltered[0])
-		})
-	}
-}