导入仓库同步功能

go.sum

@@ -850,8 +850,9 @@ github.com/smartystreets/assertions v0.0.0-20190116191733-b6c0e53d7304/go.mod h1
 github.com/smartystreets/assertions v1.1.1 h1:T/YLemO5Yp7KPzS+lVtu+WsHn8yoSwTfItdAd1r3cck=
 github.com/smartystreets/assertions v1.1.1/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
 github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
-github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 h1:WN9BUFbdyOsSH/XohnWpXOlq9NBD5sGAB2FciQMUEe8=
 github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=

http_test/sync-v2.http

@@ -0,0 +1,106 @@
+
+### 1.pull-mirror-add
+POST http://0.0.0.0:3003/api/hat/repos/xxq2506/sss2/mirror-sync-v2
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "mirror-sync",
+  "mirror_address": "http://127.0.0.1:3003/xxq250/aaabbbccc.git",
+  "mirror_username": "xxq250",
+  "mirror_password": "12345678",
+  "interval": "0"
+}
+
+### 1.pull-mirror-add
+POST http://0.0.0.0:3003/api/hat/repos/xxq2506/sss2/mirror-sync-v2
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "push-mirror-add",
+  "mirror_address": "http://127.0.0.1:3003/xxq250/aaabbbccc.git",
+  "mirror_username": "xxq250",
+  "mirror_password": "12345678",
+  "interval": "0"
+}
+
+### 111.pull-mirror-add
+POST http://0.0.0.0:3003/api/hat/repos/xxq250/bbb180/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "pull-mirror-add",
+  "mirror_address": "https://www.gitlink.org.cn/xxq250/lfs-demo.git",
+  "mirror_username": "xxq250",
+  "mirror_password": "xxq123456789521",
+  "interval": "0"
+}
+
+### 2.pull-mirror-sync
+POST http://0.0.0.0:3003/api/v1/repos/xxq250/bbb180/mirror-sync
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "mirror-sync"
+}
+
+
+### 2.pull-mirror-sync
+POST http://0.0.0.0:3003/api/v1/repos/xxq2506/lfs-demo/mirror-sync
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "mirror-sync"
+}
+
+
+
+### 3.pull-mirror-remove
+POST http://0.0.0.0:3003/api/hat/repos/xxq2506/aaabbbccc/mirror-sync-v2
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "pull-mirror-remove"
+}
+
+
+### 4.push-mirror-add
+POST http://0.0.0.0:3003/api/hat/repos/xxq250/lfs-demo/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "push-mirror-add",
+  "mirror_address": "https://www.gitlink.org.cn/xxq250/lfs-demo.git",
+  "mirror_username": "xxq250",
+  "mirror_password": "xxq123456789521",
+  "interval": "0"
+}
+
+###  5.push_mirrors-sync
+POST http://0.0.0.0:3003/api/v1/repos/xxq250/lfs-demo/push_mirrors-sync
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+### 6.push-mirror-remove
+POST http://0.0.0.0:3003/api/hat/repos/xxq250/lfs-demo/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+
+
+

http_test/sync.http

@@ -0,0 +1,87 @@
+
+### 1.pull-mirror-add
+POST http://0.0.0.0:3003/api/hat/repos/xxq2506/lfs-demo/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "pull-mirror-add",
+  "mirror_address": "http://0.0.0.0:3003/xxq250/lfs-demo.git",
+  "mirror_username": "xxq250",
+  "mirror_password": "xxq123456789521",
+  "interval": "0"
+}
+
+### 111.pull-mirror-add
+POST http://0.0.0.0:3003/api/hat/repos/xxq250/bbb180/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "pull-mirror-add",
+  "mirror_address": "https://www.gitlink.org.cn/xxq250/lfs-demo.git",
+  "mirror_username": "xxq250",
+  "mirror_password": "xxq123456789521",
+  "interval": "0"
+}
+
+### 2.pull-mirror-sync
+POST http://0.0.0.0:3003/api/v1/repos/xxq250/bbb180/mirror-sync
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "mirror-sync"
+}
+
+
+### 2.pull-mirror-sync
+POST http://0.0.0.0:3003/api/v1/repos/xxq2506/lfs-demo/mirror-sync
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "mirror-sync"
+}
+
+
+
+### 3.pull-mirror-remove
+POST http://0.0.0.0:3003/api/hat/repos/xxq250/lfs-demo/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+### 4.push-mirror-add
+POST http://0.0.0.0:3003/api/hat/repos/xxq250/lfs-demo/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+{
+  "action": "push-mirror-add",
+  "mirror_address": "https://www.gitlink.org.cn/xxq250/lfs-demo.git",
+  "mirror_username": "xxq250",
+  "mirror_password": "xxq123456789521",
+  "interval": "0"
+}
+
+###  5.push_mirrors-sync
+POST http://0.0.0.0:3003/api/v1/repos/xxq250/lfs-demo/push_mirrors-sync
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+### 6.push-mirror-remove
+POST http://0.0.0.0:3003/api/hat/repos/xxq250/lfs-demo/settings
+authorization: Basic eHhxMjUwOjEyMzQ1Njc4
+accept: application/json
+Content-Type: application/json
+
+
+
+

main.go

@@ -22,7 +22,7 @@ import (
 )
 
 var (
-	Version     = "v2.7, by v1.21.0 "
+	Version     = "v2.8.8, by v1.21.0, 20260119 "
 	Tags        = ""
 	MakeVersion = ""
 )

models/actions/secret.go

@@ -0,0 +1,59 @@
+package actions
+
+import (
+	"context"
+	"strings"
+
+	"code.gitea.io/gitea/models/db"
+	secret_model "code.gitea.io/gitea/models/secret"
+	"xorm.io/builder"
+)
+
+type FindSecretsOptions struct {
+	db.ListOptions
+	OwnerID  int64
+	RepoID   int64
+	SecretID int64
+	Name     string
+}
+
+func (opts *FindSecretsOptions) toConds() builder.Cond {
+	cond := builder.NewCond()
+	if opts.OwnerID > 0 {
+		cond = cond.And(builder.Eq{"owner_id": opts.OwnerID})
+	}
+	if opts.RepoID > 0 {
+		cond = cond.And(builder.Eq{"repo_id": opts.RepoID})
+	}
+	if opts.SecretID != 0 {
+		cond = cond.And(builder.Eq{"id": opts.SecretID})
+	}
+	if opts.Name != "" {
+		cond = cond.And(builder.Eq{"name": strings.ToUpper(opts.Name)})
+	}
+
+	return cond
+}
+
+func FindSecrets(ctx context.Context, opts FindSecretsOptions) ([]*secret_model.Secret, error) {
+	var secrets []*secret_model.Secret
+	sess := db.GetEngine(ctx)
+	if opts.PageSize != 0 {
+		sess = db.SetSessionPagination(sess, &opts.ListOptions)
+	}
+	return secrets, sess.
+		Where(opts.toConds()).
+		OrderBy("created_unix desc").
+		Find(&secrets)
+}
+
+func CountSecrets(ctx context.Context, opts *FindSecretsOptions) (int64, error) {
+	return db.GetEngine(ctx).Where(opts.toConds()).Count(new(secret_model.Secret))
+}
+
+func DeleteSecret(ctx context.Context, secret *secret_model.Secret) error {
+	if _, err := db.DeleteByID(ctx, secret.ID, secret); err != nil {
+		return err
+	}
+	return nil
+}

models/actions/variables.go

@@ -0,0 +1,65 @@
+package actions
+
+import (
+	"context"
+	"strings"
+
+	gitea_actions "code.gitea.io/gitea/models/actions"
+	"code.gitea.io/gitea/models/db"
+	"xorm.io/builder"
+)
+
+type FindVariablesOpts struct {
+	db.ListOptions
+	IDs     []int64
+	RepoID  int64
+	OwnerID int64 // it will be ignored if RepoID is set
+	Name    string
+}
+
+func (opts FindVariablesOpts) ToConds() builder.Cond {
+	cond := builder.NewCond()
+	if len(opts.IDs) > 0 {
+		if len(opts.IDs) == 1 {
+			cond = cond.And(builder.Eq{"id": opts.IDs[0]})
+		} else {
+			cond = cond.And(builder.In("id", opts.IDs))
+		}
+	}
+
+	// Since we now support instance-level variables,
+	// there is no need to check for null values for `owner_id` and `repo_id`
+	cond = cond.And(builder.Eq{"repo_id": opts.RepoID})
+	if opts.RepoID != 0 { // if RepoID is set
+		// ignore OwnerID and treat it as 0
+		cond = cond.And(builder.Eq{"owner_id": 0})
+	} else {
+		cond = cond.And(builder.Eq{"owner_id": opts.OwnerID})
+	}
+
+	if opts.Name != "" {
+		cond = cond.And(builder.Eq{"name": strings.ToUpper(opts.Name)})
+	}
+	return cond
+}
+
+func FindVariables(ctx context.Context, opts FindVariablesOpts) ([]*gitea_actions.ActionVariable, error) {
+	var variables []*gitea_actions.ActionVariable
+	sess := db.GetEngine(ctx)
+	if opts.PageSize != 0 {
+		sess = db.SetSessionPagination(sess, &opts.ListOptions)
+	}
+	return variables, sess.Where(opts.ToConds()).OrderBy("created_unix desc").Find(&variables)
+}
+
+func CountVariables(ctx context.Context, opts FindVariablesOpts) (int64, error) {
+	sess := db.GetEngine(ctx)
+	return sess.Where(opts.ToConds()).Count(new(gitea_actions.ActionVariable))
+}
+
+func DeleteVariable(ctx context.Context, variable *gitea_actions.ActionVariable) error {
+	if _, err := db.DeleteByID(ctx, variable.ID, variable); err != nil {
+		return err
+	}
+	return nil
+}

modules/convert/convert.go

@@ -23,7 +23,7 @@ func ToTag(repo *repo.Repository, gitRepo *git.Repository, t *git.Tag) (tag *api
 		return &api.Tag{}, err
 	}
 	return &api.Tag{
-		Name:       t.Name,
+		Name:       strings.TrimPrefix(t.Name, "tags/"),
 		Message:    strings.TrimSpace(t.Message),
 		ID:         t.ID.String(),
 		Commit:     tagCommit,

modules/repository/branch.go

@@ -0,0 +1,204 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package repository
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
+	repo_model "code.gitea.io/gitea/models/repo"
+	user_model "code.gitea.io/gitea/models/user"
+	"code.gitea.io/gitea/modules/container"
+	"code.gitea.io/gitea/modules/git"
+	gitea_git "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/timeutil"
+	"code.gitea.io/gitea/modules/util"
+	repo_service "code.gitea.io/gitea/services/repository"
+)
+
+//// SyncRepoBranches synchronizes branch table with repository branches
+//func SyncRepoBranches(ctx context.Context, repoID, doerID int64) (int64, error) {
+//	repo, err := repo_model.GetRepositoryByID(ctx, repoID)
+//	if err != nil {
+//		return 0, err
+//	}
+//
+//	log.Debug("SyncRepoBranches: in Repo[%d:%s]", repo.ID, repo.FullName())
+//
+//	gitRepo, err := git.OpenRepository(ctx, repo.RepoPath())
+//	if err != nil {
+//		log.Error("OpenRepository[%s]: %w", repo.RepoPath(), err)
+//		return 0, err
+//	}
+//	defer gitRepo.Close()
+//
+//	return SyncRepoBranchesWithRepo(ctx, repo, gitRepo, doerID)
+//}
+
+func SyncRepoBranchesWithRepo(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, doerID int64, delOldBranches bool) (int64, error) {
+	allBranches := container.Set[string]{}
+	{
+		branches, _, err := gitRepo.GetBranchNames(0, 0)
+		if err != nil {
+			return 0, err
+		}
+		log.Trace("SyncRepoBranches[%s]: branches[%d]: %v", repo.FullName(), len(branches), branches)
+		for _, branch := range branches {
+			allBranches.Add(branch)
+		}
+	}
+
+	dbBranches := make(map[string]*git_model.Branch)
+	{
+		branches, err := git_model.FindBranches(ctx, git_model.FindBranchOptions{
+			ListOptions: db.ListOptions{
+				ListAll: true,
+			},
+			RepoID: repo.ID,
+		})
+		if err != nil {
+			return 0, err
+		}
+		for _, branch := range branches {
+			dbBranches[branch.Name] = branch
+		}
+	}
+
+	var toAdd []*git_model.Branch
+	var toUpdate []*git_model.Branch
+	var toRemove []int64
+	for branch := range allBranches {
+		dbb := dbBranches[branch]
+		commit, err := gitRepo.GetBranchCommit(branch)
+		if err != nil {
+			return 0, err
+		}
+		if dbb == nil {
+			toAdd = append(toAdd, &git_model.Branch{
+				RepoID:        repo.ID,
+				Name:          branch,
+				CommitID:      commit.ID.String(),
+				CommitMessage: commit.Summary(),
+				PusherID:      doerID,
+				CommitTime:    timeutil.TimeStamp(commit.Committer.When.Unix()),
+			})
+		} else if commit.ID.String() != dbb.CommitID {
+			toUpdate = append(toUpdate, &git_model.Branch{
+				ID:            dbb.ID,
+				RepoID:        repo.ID,
+				Name:          branch,
+				CommitID:      commit.ID.String(),
+				CommitMessage: commit.Summary(),
+				PusherID:      doerID,
+				CommitTime:    timeutil.TimeStamp(commit.Committer.When.Unix()),
+			})
+		}
+	}
+
+	for _, dbBranch := range dbBranches {
+		if !allBranches.Contains(dbBranch.Name) && !dbBranch.IsDeleted {
+			toRemove = append(toRemove, dbBranch.ID)
+		}
+	}
+
+	log.Trace("SyncRepoBranches[%s]: toAdd: %v, toUpdate: %v, toRemove: %v", repo.FullName(), toAdd, toUpdate, toRemove)
+
+	if len(toAdd) == 0 && len(toRemove) == 0 && len(toUpdate) == 0 {
+		return int64(len(allBranches)), nil
+	}
+
+	if err := db.WithTx(ctx, func(ctx context.Context) error {
+		if len(toAdd) > 0 {
+			if err := git_model.AddBranches(ctx, toAdd); err != nil {
+				return err
+			}
+		}
+
+		for _, b := range toUpdate {
+			if _, err := db.GetEngine(ctx).ID(b.ID).
+				Cols("commit_id, commit_message, pusher_id, commit_time, is_deleted").
+				Update(b); err != nil {
+				return err
+			}
+		}
+
+		if len(toRemove) > 0 {
+			if err := git_model.DeleteBranches(ctx, repo.ID, doerID, toRemove); err != nil {
+				return err
+			}
+			// default DeleteBranches after restore
+			if !delOldBranches {
+				_, err := RestoreDeleteBranches(ctx, repo.ID)
+				if err != nil {
+					log.Error("SyncMirrors RestoreDeleteBranches error", err)
+					return err
+				}
+			}
+		}
+
+		return nil
+	}); err != nil {
+		return 0, err
+	}
+	return int64(len(allBranches)), nil
+}
+
+func RestoreDeleteBranches(ctx context.Context, repoID int64) (int64, error) {
+	branches, err := git_model.FindBranches(ctx, git_model.FindBranchOptions{
+		ListOptions: db.ListOptions{
+			ListAll: true,
+		},
+		IsDeletedBranch: util.OptionalBoolTrue,
+		RepoID:          repoID,
+	})
+	if err != nil {
+		log.Error("GetBranches", err.Error())
+		return 0, err
+	}
+	log.Info("FindDeleteBranches len(branches)=========== %s", len(branches))
+	for i := range branches {
+		deletedBranch := branches[i]
+		repo, err := repo_model.GetRepositoryByID(ctx, repoID)
+		if err != nil {
+			return 0, err
+		}
+		doer, err := user_model.GetUserByID(ctx, repo.OwnerID)
+		if err != nil {
+			return 0, err
+		}
+		repo.Owner = doer
+		if err := gitea_git.Push(ctx, repo.RepoPath(), gitea_git.PushOptions{
+			Remote: repo.RepoPath(),
+			Branch: fmt.Sprintf("%s:%s%s", deletedBranch.CommitID, gitea_git.BranchPrefix, deletedBranch.Name),
+			Env:    repo_module.PushingEnvironment(repo.Owner, repo),
+		}); err != nil {
+			if strings.Contains(err.Error(), "already exists") {
+				log.Error("RestoreBranch: Can't restore branch '%s', since one with same name already exist", deletedBranch.Name)
+				return 0, err
+			}
+			log.Error("RestoreBranch: CreateBranch: %v", err.Error())
+			return 0, err
+		}
+
+		if err := repo_service.PushUpdate(
+			&repo_module.PushUpdateOptions{
+				RefFullName:  gitea_git.RefNameFromBranch(deletedBranch.Name),
+				OldCommitID:  gitea_git.EmptySHA,
+				NewCommitID:  deletedBranch.CommitID,
+				PusherID:     repo.Owner.ID,
+				PusherName:   repo.Owner.Name,
+				RepoUserName: repo.Owner.Name,
+				RepoName:     repo.Name,
+			}); err != nil {
+			log.Error("RestoreBranch: Update: %v", err.Error())
+			return 0, nil
+		}
+	}
+	return 0, nil
+}

modules/structs/secret.go

@@ -0,0 +1,34 @@
+package structs
+
+import "time"
+
+// CreateVariableOption the option when creating variable
+// swagger:model
+type CreateSecretOption struct {
+	// Value of the variable to create
+	//
+	// required: true
+	Data string `json:"data" binding:"Required"`
+}
+
+// UpdateVariableOption the option when updating variable
+// swagger:model
+type UpdateSecretOption struct {
+	// New name for the variable. If the field is empty, the variable name won't be updated.
+	Name string `json:"name"`
+	// Value of the variable to update
+	//
+	// required: true
+	Data string `json:"data" binding:"Required"`
+
+	// Description of the variable to update
+}
+
+// Secret represents a secret
+// swagger:model
+type Secret struct {
+	// the secret's name
+	Name string `json:"name"`
+	// swagger:strfmt date-time
+	Created time.Time `json:"created_at"`
+}

modules/structs/variable.go

@@ -0,0 +1,36 @@
+package structs
+
+// CreateVariableOption the option when creating variable
+// swagger:model
+type CreateVariableOption struct {
+	// Value of the variable to create
+	//
+	// required: true
+	Value string `json:"value" binding:"Required"`
+}
+
+// UpdateVariableOption the option when updating variable
+// swagger:model
+type UpdateVariableOption struct {
+	// New name for the variable. If the field is empty, the variable name won't be updated.
+	Name string `json:"name"`
+	// Value of the variable to update
+	//
+	// required: true
+	Value string `json:"value" binding:"Required"`
+
+	// Description of the variable to update
+}
+
+// ActionVariable return value of the query API
+// swagger:model
+type ActionVariable struct {
+	// the owner to which the variable belongs
+	OwnerID int64 `json:"owner_id"`
+	// the repository to which the variable belongs
+	RepoID int64 `json:"repo_id"`
+	// the name of the variable
+	Name string `json:"name"`
+	// the value of the variable
+	Data string `json:"data"`
+}

modules/util/util.go

@@ -0,0 +1,12 @@
+package util
+
+import "strings"
+
+func ReserveLineBreakForTextarea(input string) string {
+	// Since the content is from a form which is a textarea, the line endings are \r\n.
+	// It's a standard behavior of HTML.
+	// But we want to store them as \n like what GitHub does.
+	// And users are unlikely to really need to keep the \r.
+	// Other than this, we should respect the original content, even leading or trailing spaces.
+	return strings.ReplaceAll(input, "\r\n", "\n")
+}

routers/hat/hat.go

@@ -30,6 +30,7 @@ import (
 	"code.gitlink.org.cn/Gitlink/gitea_hat.git/routers/hat/org"
 	"code.gitlink.org.cn/Gitlink/gitea_hat.git/routers/hat/repo"
 	"code.gitlink.org.cn/Gitlink/gitea_hat.git/routers/hat/repo/actions"
+	"code.gitlink.org.cn/Gitlink/gitea_hat.git/routers/hat/repo/explore"
 	"code.gitlink.org.cn/Gitlink/gitea_hat.git/routers/hat/user"
 	"github.com/go-chi/cors"
 )
@@ -121,10 +122,32 @@ func Routers() *web.Route {
 	m.Group("", func() {
 		m.Get("/version", misc.Version)
 		m.Post("/create_pr_version", bind(gitea_api.PullRequestPayload{}), repo.CreatePrVersion)
+		m.Post("/create_repo_size_limit_hook", bind(gitea_api.RepositoryPayload{}), repo.CreateRepoSizeLimitHook)
+		m.Post("/update_hook_arm", bind(gitea_api.RepositoryPayload{}), repo.UpdateHookArm)
+		m.Post("/update_repo_size_limit_hook", bind(gitea_api.RepositoryPayload{}), repo.UpdateRepoSizeLimitHook)
 		m.Group("/repos", func() {
+			if setting.Indexer.RepoIndexerEnabled {
+				m.Get("/explore/code", explore.Code)
+			}
 			m.Group("/{username}/{reponame}", func() {
+				m.Get("/code", context.ReferencesGitRepo(), reqRepoReader(unit.TypeCode), repo.Code)
 				m.Combo("").Delete(reqToken(), reqOwner(), repo.Delete)
 				m.Group("/actions", func() {
+					m.Group("/secrets", func() {
+						m.Get("", reqToken(), reqAdmin(), actions.ListActionsSecrets)
+						m.Combo("/{secretname}").
+							Delete(reqToken(), reqAdmin(), actions.DeleteActionsSecret).
+							Post(reqToken(), reqAdmin(), bind(hat_api.CreateSecretOption{}), actions.CreateActionsSecret).
+							Put(reqToken(), reqAdmin(), bind(hat_api.UpdateSecretOption{}), actions.UpdateActionsSecret)
+					})
+					m.Group("/variables", func() {
+						m.Get("", reqToken(), reqAdmin(), actions.ListVariables)
+						m.Combo("/{variablename}").
+							Get(reqToken(), reqAdmin(), actions.GetVariable).
+							Delete(reqToken(), reqAdmin(), actions.DeleteVariable).
+							Post(reqToken(), reqAdmin(), bind(hat_api.CreateVariableOption{}), actions.CreateVariable).
+							Put(reqToken(), reqAdmin(), bind(hat_api.UpdateVariableOption{}), actions.UpdateVariable)
+					})
 					m.Get("", context.ReferencesGitRepo(), actions.ListActions)
 					m.Post("/disable", reqAdmin(), actions.DisableWorkflowFile)
 					m.Post("/enable", reqAdmin(), actions.EnableWorkflowFile)
@@ -132,6 +155,7 @@ func Routers() *web.Route {
 					m.Post("/runs/{run}/jobs/{job}/rerun", reqRepoWriter(unit_model.TypeActions), actions.Rerun)
 					m.Get("/runs/{run}/jobs/{job}/logs", actions.Logs)
 					m.Post("/runs/{run}/rerun", reqRepoWriter(unit_model.TypeActions), actions.Rerun)
+					m.Post("/runs/{run}/cancel", reqRepoWriter(unit_model.TypeActions), actions.Cancel)
 					m.Post("/runs", context.ReferencesGitRepo(), reqRepoWriter(unit_model.TypeActions), actions.Run)
 				}, reqRepoReader(unit_model.TypeActions))
 				m.Post("/transfer", reqOwner(), bind(gitea_api.TransferRepoOption{}), repo.Transfer)
@@ -156,6 +180,7 @@ func Routers() *web.Route {
 				}, reqRepoReader(unit_model.TypeCode), context.ReferencesGitRepo(true))
 				m.Group("/wiki", func() {
 					m.Get("/page_names", repo.ListWikiPageNames)
+					m.Get("/revisions/{pageName}/{revision}", repo.ShowRevision)
 				})
 				m.Group("/readme", func() {
 					m.Get("", repo.GetReadmeContents)
@@ -184,6 +209,7 @@ func Routers() *web.Route {
 							m.Get("", repo.ListPullRequestVersions)
 							m.Get("/{versionId}/diff", context.ReferencesGitRepo(), repo.GetPullRequestVersionDiff)
 						})
+						m.Get("/change_status", repo.ChangePullRequestCloseStatus)
 					})
 				}, mustAllowPulls, reqRepoReader(unit_model.TypeCode), context.ReferencesGitRepo())
 				m.Group("/releases", func() {
@@ -227,6 +253,7 @@ func Routers() *web.Route {
 				}, context.ReferencesGitRepo(), reqRepoReader(unit.TypeCode))
 				m.Get("/blame", context.ReferencesGitRepo(), repo.GetRepoRefBlame)
 				m.Get("/code_stats", context.ReferencesGitRepo(), repo.ListCodeStats)
+				m.Post("/mirror-sync-v2", bind(repo.RepoSyncFormNew{}), repo.MirrorSyncV2)
 			}, repoAssignment())
 		})
 		m.Group("/users", func() {
@@ -235,11 +262,29 @@ func Routers() *web.Route {
 				if setting.Service.EnableUserHeatmap {
 					m.Get("/heatmap", user.GetUserHeatmapData)
 				}
+				m.Get("/code", user.Code)
 			}, context_service.UserAssignmentAPI())
 		})
 		m.Post("/orgs", reqToken(), bind(gitea_api.CreateOrgOption{}), org.Create)
 		m.Group("/orgs/{org}", func() {
 			m.Combo("").Patch(reqToken(), reqOrgOwnership(), bind(hat_api.EditOrgOption{}), org.Edit)
+			m.Group("/actions", func() {
+				m.Group("/secrets", func() {
+					m.Get("", reqToken(), reqAdmin(), org.ListActionsSecrets)
+					m.Combo("/{secretname}").
+						Delete(reqToken(), reqAdmin(), org.DeleteActionsSecret).
+						Post(reqToken(), reqAdmin(), bind(hat_api.CreateSecretOption{}), org.CreateActionsSecret).
+						Put(reqToken(), reqAdmin(), bind(hat_api.UpdateSecretOption{}), org.UpdateActionsSecret)
+				})
+				m.Group("/variables", func() {
+					m.Get("", reqToken(), reqOrgOwnership(), org.ListVariables)
+					m.Combo("/{variablename}").
+						Get(reqToken(), reqOrgOwnership(), org.GetVariable).
+						Delete(reqToken(), reqOrgOwnership(), org.DeleteVariable).
+						Post(reqToken(), reqOrgOwnership(), bind(hat_api.CreateVariableOption{}), org.CreateVariable).
+						Put(reqToken(), reqOrgOwnership(), bind(hat_api.UpdateVariableOption{}), org.UpdateVariable)
+				})
+			})
 		}, orgAssignment(true))
 
 		m.Group("/teams/{teamid}", func() {

routers/hat/org/action.go

@@ -0,0 +1,261 @@
+package org
+
+import (
+	"errors"
+	"net/http"
+
+	"code.gitea.io/gitea/modules/context"
+	api "code.gitea.io/gitea/modules/structs"
+	"code.gitea.io/gitea/modules/util"
+	"code.gitea.io/gitea/modules/web"
+	"code.gitea.io/gitea/routers/api/v1/utils"
+
+	hat_actions_model "code.gitlink.org.cn/Gitlink/gitea_hat.git/models/actions"
+	hat_api "code.gitlink.org.cn/Gitlink/gitea_hat.git/modules/structs"
+	hat_actions_service "code.gitlink.org.cn/Gitlink/gitea_hat.git/services/actions"
+)
+
+func DeleteActionsSecret(ctx *context.APIContext) {
+	if err := hat_actions_service.DeleteSecretByName(ctx, ctx.Org.Organization.ID, 0, ctx.Params("secretname")); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "DeleteSecretByName", err)
+		} else if errors.Is(err, util.ErrNotExist) {
+			ctx.NotFound(err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
+func CreateActionsSecret(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.CreateSecretOption)
+	ownerID := ctx.Org.Organization.ID
+	secretName := ctx.Params("secretname")
+
+	v, err := hat_actions_service.GetSecret(ctx, hat_actions_model.FindSecretsOptions{
+		OwnerID: ownerID,
+		Name:    secretName,
+	})
+	if err != nil && !errors.Is(err, util.ErrNotExist) {
+		ctx.InternalServerError(err)
+		return
+	}
+	if v != nil && v.ID > 0 {
+		ctx.Error(http.StatusConflict, "", util.NewAlreadyExistErrorf("secret name %s already exists", secretName))
+		return
+	}
+	if _, err := hat_actions_service.CreateSecret(ctx, ownerID, 0, secretName, opt.Data); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "CreateSecret", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+	ctx.Status(http.StatusCreated)
+}
+
+func UpdateActionsSecret(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.UpdateSecretOption)
+
+	_, err := hat_actions_service.GetSecret(ctx, hat_actions_model.FindSecretsOptions{
+		OwnerID: ctx.Org.Organization.ID,
+		Name:    ctx.Params("secretname"),
+	})
+	if err != nil {
+		if errors.Is(err, util.ErrNotExist) {
+			ctx.Error(http.StatusNotFound, "GetSecret", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	if opt.Name == "" {
+		opt.Name = ctx.Params("secretname")
+	}
+
+	_, err = hat_actions_service.UpdateSecret(ctx, ctx.Org.Organization.ID, 0, opt.Name, opt.Data)
+	if err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "UpdateSecret", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+
+}
+
+func ListActionsSecrets(ctx *context.APIContext) {
+	opts := &hat_actions_model.FindSecretsOptions{
+		OwnerID:     ctx.Org.Organization.ID,
+		ListOptions: utils.GetListOptions(ctx),
+	}
+
+	count, err := hat_actions_model.CountSecrets(ctx, opts)
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	secrets, err := hat_actions_model.FindSecrets(ctx, *opts)
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	apiSecrets := make([]*api.Secret, len(secrets))
+	for k, v := range secrets {
+		apiSecrets[k] = &api.Secret{
+			Name:    v.Name,
+			Created: v.CreatedUnix.AsTime(),
+		}
+	}
+
+	ctx.SetTotalCountHeader(count)
+	ctx.JSON(http.StatusOK, apiSecrets)
+}
+
+func GetVariable(ctx *context.APIContext) {
+	v, err := hat_actions_service.GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		OwnerID: ctx.Org.Organization.ID,
+		Name:    ctx.Params("variablename"),
+	})
+	if err != nil {
+		if errors.Is(err, util.ErrNotExist) {
+			ctx.NotFound(err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	variable := &hat_api.ActionVariable{
+		OwnerID: v.OwnerID,
+		RepoID:  v.RepoID,
+		Name:    v.Name,
+		Data:    v.Data,
+	}
+
+	ctx.JSON(http.StatusOK, variable)
+}
+
+func DeleteVariable(ctx *context.APIContext) {
+	if err := hat_actions_service.DeleteVariableByName(ctx, ctx.Org.Organization.ID, 0, ctx.Params("variablename")); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "DeleteVariableByName", err)
+		} else if errors.Is(err, util.ErrNotExist) {
+			ctx.NotFound(err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
+func CreateVariable(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.CreateVariableOption)
+	ownerID := ctx.Org.Organization.ID
+	variableName := ctx.Params("variablename")
+
+	v, err := hat_actions_service.GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		OwnerID: ownerID,
+		Name:    variableName,
+	})
+	if err != nil && !errors.Is(err, util.ErrNotExist) {
+		ctx.InternalServerError(err)
+		return
+	}
+	if v != nil && v.ID > 0 {
+		ctx.Error(http.StatusConflict, "", util.NewAlreadyExistErrorf("variable name %s already exists", variableName))
+		return
+	}
+
+	if _, err := hat_actions_service.CreateVariable(ctx, ownerID, 0, variableName, opt.Value); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "CreateVariable", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusCreated)
+}
+
+func UpdateVariable(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.UpdateVariableOption)
+
+	v, err := hat_actions_service.GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		OwnerID: ctx.Org.Organization.ID,
+		Name:    ctx.Params("variablename"),
+	})
+	if err != nil {
+		if errors.Is(err, util.ErrNotExist) {
+			ctx.Error(http.StatusNotFound, "GetVariable", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	if opt.Name == "" {
+		opt.Name = ctx.Params("variablename")
+	}
+
+	v.Name = opt.Name
+	v.Data = opt.Value
+
+	if _, err := hat_actions_service.UpdateVariableNameData(ctx, v); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "UpdateVariableNameData", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
+func ListVariables(ctx *context.APIContext) {
+	opts := hat_actions_model.FindVariablesOpts{
+		OwnerID:     ctx.Org.Organization.ID,
+		ListOptions: utils.GetListOptions(ctx),
+	}
+
+	vars, err := hat_actions_model.FindVariables(ctx, opts)
+
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	count, err := hat_actions_model.CountVariables(ctx, opts)
+
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	variables := make([]*hat_api.ActionVariable, len(vars))
+	for i, v := range vars {
+		variables[i] = &hat_api.ActionVariable{
+			OwnerID: v.OwnerID,
+			RepoID:  v.RepoID,
+			Name:    v.Name,
+			Data:    v.Data,
+		}
+	}
+
+	ctx.SetTotalCountHeader(count)
+	ctx.JSON(http.StatusOK, variables)
+}

routers/hat/repo/actions/actions.go

@@ -8,6 +8,8 @@ import (
 	"strings"
 	"time"
 
+	"code.gitea.io/gitea/modules/timeutil"
+
 	stdCtx "context"
 
 	actions_model "code.gitea.io/gitea/models/actions"
@@ -21,17 +23,265 @@ import (
 	"code.gitea.io/gitea/modules/container"
 	"code.gitea.io/gitea/modules/context"
 	"code.gitea.io/gitea/modules/git"
+	api "code.gitea.io/gitea/modules/structs"
 	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/modules/web"
+	"code.gitea.io/gitea/routers/api/v1/utils"
 	"code.gitea.io/gitea/routers/web/repo"
 	actions_service "code.gitea.io/gitea/services/actions"
 	"code.gitea.io/gitea/services/convert"
 	hat_actions_model "code.gitlink.org.cn/Gitlink/gitea_hat.git/models/actions"
+	hat_api "code.gitlink.org.cn/Gitlink/gitea_hat.git/modules/structs"
+	hat_actions_service "code.gitlink.org.cn/Gitlink/gitea_hat.git/services/actions"
 	jobparser "github.com/nektos/act/pkg/jobparser"
 	"github.com/nektos/act/pkg/model"
 	"xorm.io/builder"
 )
 
+func DeleteActionsSecret(ctx *context.APIContext) {
+	if err := hat_actions_service.DeleteSecretByName(ctx, 0, ctx.Repo.Repository.ID, ctx.Params("secretname")); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "DeleteSecretByName", err)
+		} else if errors.Is(err, util.ErrNotExist) {
+			ctx.NotFound(err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
+func CreateActionsSecret(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.CreateSecretOption)
+	repoID := ctx.Repo.Repository.ID
+	secretName := ctx.Params("secretname")
+
+	v, err := hat_actions_service.GetSecret(ctx, hat_actions_model.FindSecretsOptions{
+		RepoID: repoID,
+		Name:   secretName,
+	})
+	if err != nil && !errors.Is(err, util.ErrNotExist) {
+		ctx.InternalServerError(err)
+		return
+	}
+	if v != nil && v.ID > 0 {
+		ctx.Error(http.StatusConflict, "", util.NewAlreadyExistErrorf("secret name %s already exists", secretName))
+		return
+	}
+	if _, err := hat_actions_service.CreateSecret(ctx, 0, repoID, secretName, opt.Data); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "CreateSecret", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+	ctx.Status(http.StatusCreated)
+}
+
+func UpdateActionsSecret(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.UpdateSecretOption)
+
+	_, err := hat_actions_service.GetSecret(ctx, hat_actions_model.FindSecretsOptions{
+		RepoID: ctx.Repo.Repository.ID,
+		Name:   ctx.Params("secretname"),
+	})
+	if err != nil {
+		if errors.Is(err, util.ErrNotExist) {
+			ctx.Error(http.StatusNotFound, "GetSecret", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	if opt.Name == "" {
+		opt.Name = ctx.Params("secretname")
+	}
+
+	_, err = hat_actions_service.UpdateSecret(ctx, 0, ctx.Repo.Repository.ID, opt.Name, opt.Data)
+	if err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "UpdateSecret", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+
+}
+
+func ListActionsSecrets(ctx *context.APIContext) {
+	opts := &hat_actions_model.FindSecretsOptions{
+		RepoID:      ctx.Repo.Repository.ID,
+		ListOptions: utils.GetListOptions(ctx),
+	}
+
+	count, err := hat_actions_model.CountSecrets(ctx, opts)
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	secrets, err := hat_actions_model.FindSecrets(ctx, *opts)
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	apiSecrets := make([]*api.Secret, len(secrets))
+	for k, v := range secrets {
+		apiSecrets[k] = &api.Secret{
+			Name:    v.Name,
+			Created: v.CreatedUnix.AsTime(),
+		}
+	}
+
+	ctx.SetTotalCountHeader(count)
+	ctx.JSON(http.StatusOK, apiSecrets)
+}
+
+func GetVariable(ctx *context.APIContext) {
+	v, err := hat_actions_service.GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		RepoID: ctx.Repo.Repository.ID,
+		Name:   ctx.Params("variablename"),
+	})
+	if err != nil {
+		if errors.Is(err, util.ErrNotExist) {
+			ctx.NotFound(err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	variable := &hat_api.ActionVariable{
+		OwnerID: v.OwnerID,
+		RepoID:  v.RepoID,
+		Name:    v.Name,
+		Data:    v.Data,
+	}
+
+	ctx.JSON(http.StatusOK, variable)
+}
+
+func DeleteVariable(ctx *context.APIContext) {
+	if err := hat_actions_service.DeleteVariableByName(ctx, 0, ctx.Repo.Repository.ID, ctx.Params("variablename")); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "DeleteVariableByName", err)
+		} else if errors.Is(err, util.ErrNotExist) {
+			ctx.NotFound(err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
+func CreateVariable(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.CreateVariableOption)
+	repoID := ctx.Repo.Repository.ID
+	variableName := ctx.Params("variablename")
+
+	v, err := hat_actions_service.GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		RepoID: repoID,
+		Name:   variableName,
+	})
+	if err != nil && !errors.Is(err, util.ErrNotExist) {
+		ctx.InternalServerError(err)
+		return
+	}
+	if v != nil && v.ID > 0 {
+		ctx.Error(http.StatusConflict, "", util.NewAlreadyExistErrorf("variable name %s already exists", variableName))
+		return
+	}
+
+	if _, err := hat_actions_service.CreateVariable(ctx, 0, repoID, variableName, opt.Value); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "CreateVariable", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusCreated)
+}
+
+func UpdateVariable(ctx *context.APIContext) {
+	opt := web.GetForm(ctx).(*hat_api.UpdateVariableOption)
+
+	v, err := hat_actions_service.GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		RepoID: ctx.Repo.Repository.ID,
+		Name:   ctx.Params("variablename"),
+	})
+	if err != nil {
+		if errors.Is(err, util.ErrNotExist) {
+			ctx.Error(http.StatusNotFound, "GetVariable", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	if opt.Name == "" {
+		opt.Name = ctx.Params("variablename")
+	}
+
+	v.Name = opt.Name
+	v.Data = opt.Value
+
+	if _, err := hat_actions_service.UpdateVariableNameData(ctx, v); err != nil {
+		if errors.Is(err, util.ErrInvalidArgument) {
+			ctx.Error(http.StatusBadRequest, "UpdateVariableNameData", err)
+		} else {
+			ctx.InternalServerError(err)
+		}
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
+func ListVariables(ctx *context.APIContext) {
+	opts := hat_actions_model.FindVariablesOpts{
+		RepoID:      ctx.Repo.Repository.ID,
+		ListOptions: utils.GetListOptions(ctx),
+	}
+	vars, err := hat_actions_model.FindVariables(ctx, opts)
+
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	count, err := hat_actions_model.CountVariables(ctx, opts)
+
+	if err != nil {
+		ctx.InternalServerError(err)
+		return
+	}
+
+	variables := make([]*hat_api.ActionVariable, len(vars))
+	for i, v := range vars {
+		variables[i] = &hat_api.ActionVariable{
+			OwnerID: v.OwnerID,
+			RepoID:  v.RepoID,
+			Name:    v.Name,
+			Data:    v.Data,
+		}
+	}
+
+	ctx.SetTotalCountHeader(count)
+	ctx.JSON(http.StatusOK, variables)
+}
+
 func Run(ctx *context.APIContext) {
 	workflow := ctx.FormString("workflow")
 	ref := ctx.FormString("ref")
@@ -131,6 +381,11 @@ type Workflow struct {
 	ErrMsg string
 }
 
+type DetailStatus struct {
+	RunID  int64
+	Status []actions_model.Status
+}
+
 type ResponseAction struct {
 	Workflows                    []Workflow
 	CurWorkflow                  string
@@ -143,6 +398,7 @@ type ResponseAction struct {
 	Runs                         actions_model.RunList
 	Actors                       []*user.User
 	StatusInfoList               []actions_model.StatusInfo
+	DetailStatusList             []DetailStatus
 }
 
 func ListActions(ctx *context.APIContext) {
@@ -261,7 +517,20 @@ func ListActions(ctx *context.APIContext) {
 	}
 
 	for _, run := range runs {
+		var detailStatuses []actions_model.Status
+		jobs, err := actions_model.GetRunJobsByRunID(ctx, run.ID)
+		if err != nil {
+			ctx.Error(http.StatusInternalServerError, "actions_model.GetRunJobsByRunID", err.Error())
+			return
+		}
+		for _, j := range jobs {
+			detailStatuses = append(detailStatuses, j.Status)
+		}
 		run.Repo = ctx.Repo.Repository
+		responseAction.DetailStatusList = append(responseAction.DetailStatusList, DetailStatus{
+			RunID:  run.ID,
+			Status: detailStatuses,
+		})
 	}
 
 	if err := runs.LoadTriggerUser(ctx); err != nil {
@@ -684,3 +953,44 @@ func disableOrEnableWorkflowFile(ctx *context.APIContext, isEnable bool) {
 
 	ctx.Status(http.StatusNoContent)
 }
+
+func Cancel(ctx *context.APIContext) {
+	runIndex := ctx.ParamsInt64("run")
+
+	_, jobs := getRunJobs(ctx, runIndex, -1)
+	if ctx.Written() {
+		return
+	}
+
+	if err := db.WithTx(ctx, func(ctx stdCtx.Context) error {
+		for _, job := range jobs {
+			status := job.Status
+			if status.IsDone() {
+				continue
+			}
+			if job.TaskID == 0 {
+				job.Status = actions_model.StatusCancelled
+				job.Stopped = timeutil.TimeStampNow()
+				n, err := actions_model.UpdateRunJob(ctx, job, builder.Eq{"task_id": 0}, "status", "stopped")
+				if err != nil {
+					return err
+				}
+				if n == 0 {
+					return fmt.Errorf("job has changed, try again")
+				}
+				continue
+			}
+			if err := actions_model.StopTask(ctx, job.TaskID, actions_model.StatusCancelled); err != nil {
+				return err
+			}
+		}
+		return nil
+	}); err != nil {
+		ctx.Error(http.StatusInternalServerError, "runs Cancel", err.Error())
+		return
+	}
+
+	actions_service.CreateCommitStatus(ctx, jobs...)
+
+	ctx.JSON(http.StatusOK, struct{}{})
+}

routers/hat/repo/explore/code.go

@@ -0,0 +1,119 @@
+package explore
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+	"strconv"
+
+	repo_model "code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/modules/context"
+	code_indexer "code.gitea.io/gitea/modules/indexer/code"
+	"code.gitea.io/gitea/modules/setting"
+)
+
+func Code(ctx *context.APIContext) {
+	language := ctx.FormString("language")
+	keyword := ctx.FormString("keyword")
+	queryType := ctx.FormString("query_type")
+	isMatch := queryType == "match"
+
+	page := ctx.FormInt("page")
+	if page <= 0 {
+		page = 1
+	}
+
+	var (
+		repoIDs []int64
+		err     error
+		isAdmin bool
+	)
+
+	if ctx.Doer != nil {
+		isAdmin = ctx.Doer.IsAdmin
+	}
+
+	if ctx.Doer == nil || !isAdmin {
+		repoIDs, err = repo_model.FindUserCodeAccessibleRepoIDs(ctx, ctx.Doer)
+		if err != nil {
+			ctx.Error(http.StatusInternalServerError, "FindUserCodeAccessibleRepoIDs", err)
+			return
+		}
+	}
+
+	var (
+		total                 int
+		searchResults         []*code_indexer.Result
+		searchResultLanguages []*code_indexer.SearchResultLanguages
+	)
+
+	var codeIndexerUnavailable bool
+	var repoMaps map[int64]*repo_model.Repository
+	if (len(repoIDs) > 0) || isAdmin {
+		total, searchResults, searchResultLanguages, err = code_indexer.PerformSearch(ctx, repoIDs, language, keyword, page, setting.UI.RepoSearchPagingNum, isMatch)
+		if err != nil {
+			if code_indexer.IsAvailable(ctx) {
+				ctx.Error(http.StatusInternalServerError, "SearchResults", err)
+				return
+			}
+			codeIndexerUnavailable = true
+		} else {
+			codeIndexerUnavailable = !code_indexer.IsAvailable(ctx)
+		}
+
+		loadRepoIDs := make([]int64, 0, len(searchResults))
+		for _, result := range searchResults {
+			var find bool
+			for _, id := range loadRepoIDs {
+				if id == result.RepoID {
+					find = true
+					break
+				}
+			}
+			if !find {
+				loadRepoIDs = append(loadRepoIDs, result.RepoID)
+			}
+		}
+
+		repoMaps, err := repo_model.GetRepositoriesMapByIDs(loadRepoIDs)
+		if err != nil {
+			ctx.Error(http.StatusInternalServerError, "GetRepositoriesMapByIDs", err)
+			return
+		}
+
+		repoMaps = repoMaps
+
+		if len(loadRepoIDs) != len(repoMaps) {
+			// Remove deleted repos from search results
+			cleanedSearchResults := make([]*code_indexer.Result, 0, len(repoMaps))
+			for _, sr := range searchResults {
+				if _, found := repoMaps[sr.RepoID]; found {
+					cleanedSearchResults = append(cleanedSearchResults, sr)
+				}
+			}
+
+			searchResults = cleanedSearchResults
+		}
+	}
+
+	pageCount := int(math.Ceil(float64(total) / float64(setting.UI.RepoSearchPagingNum)))
+	ctx.Resp.Header().Set("X-Page", strconv.Itoa(page))
+	ctx.Resp.Header().Set("X-PerPage", strconv.Itoa(setting.UI.RepoSearchPagingNum))
+	ctx.Resp.Header().Set("X-Total", strconv.FormatInt(int64(total), 10))
+	ctx.Resp.Header().Set("X-PageCount", strconv.Itoa(pageCount))
+	ctx.Resp.Header().Set("X-HasMore", strconv.FormatBool(page < pageCount))
+
+	ctx.SetLinkHeader(int(total), setting.UI.RepoSearchPagingNum)
+	ctx.Resp.Header().Set("X-Total-Count", fmt.Sprintf("%d", total))
+	ctx.JSON(http.StatusOK, struct {
+		CodeIndexerUnavailable bool
+		RepoMaps               map[int64]*repo_model.Repository
+		SearchResults          []*code_indexer.Result
+		SearchResultLanguages  []*code_indexer.SearchResultLanguages
+	}{
+		CodeIndexerUnavailable: codeIndexerUnavailable,
+		RepoMaps:               repoMaps,
+		SearchResults:          searchResults,
+		SearchResultLanguages:  searchResultLanguages,
+	})
+}

routers/hat/repo/pull.go

@@ -35,6 +35,41 @@ import (
 	hat_pull_service "code.gitlink.org.cn/Gitlink/gitea_hat.git/services/pull"
 )
 
+func ChangePullRequestCloseStatus(ctx *context.APIContext) {
+	pr, err := issues_model.GetPullRequestByIndex(ctx, ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
+	if err != nil {
+		if issues_model.IsErrPullRequestNotExist(err) {
+			ctx.NotFound()
+		} else {
+			ctx.Error(http.StatusInternalServerError, "GetPullRequestByIndex", err)
+		}
+		return
+	}
+	changeStatus := ctx.FormBool("is_closed")
+	_, err = issues_model.ChangeIssueStatus(ctx, pr.Issue, ctx.Doer, changeStatus)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "ChangeIssueStatus", err)
+	}
+
+	if err = pull_service.TestPatch(pr); err != nil {
+		ctx.Error(http.StatusInternalServerError, "TestPatch", err)
+	}
+
+	// Update Commit Divergence
+	divergence, err := pull_service.GetDiverging(ctx, pr)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "GetDiverging", err)
+	}
+	pr.CommitsAhead = divergence.Ahead
+	pr.CommitsBehind = divergence.Behind
+
+	if err := pr.UpdateColsIfNotMerged(ctx, "merge_base", "status", "conflicted_files", "changed_protected_files", "base_branch", "commits_ahead", "commits_behind"); err != nil {
+		ctx.Error(http.StatusInternalServerError, "UpdateColsIfNotMerged", err)
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
 func CreatePrVersion(ctx *context.APIContext) {
 	form := web.GetForm(ctx).(*gitea_api.PullRequestPayload)
 	hat_pull_service.AddToTaskQueue(&issues_model.PullRequest{ID: form.PullRequest.ID}, string(form.Action))

routers/hat/repo/repo_sync.go

@@ -0,0 +1,387 @@
+package repo
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"code.gitea.io/gitea/models"
+	repo_model "code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/modules/context"
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/lfs"
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/timeutil"
+	"code.gitea.io/gitea/modules/util"
+	"code.gitea.io/gitea/modules/web"
+	"code.gitea.io/gitea/services/forms"
+	"code.gitea.io/gitea/services/migrations"
+
+	hat_mirror_service "code.gitlink.org.cn/Gitlink/gitea_hat.git/services/mirror"
+)
+
+// RepoSettingForm form for changing repository settings
+type RepoSyncFormNew struct {
+	//RepoName               string `binding:"Required;AlphaDashDot;MaxSize(100)"`
+	//Description            string `binding:"MaxSize(2048)"`
+	//Website                string `binding:"ValidUrl;MaxSize(1024)"`
+	Action         string `json:"action"`
+	Interval       string `json:"interval"`
+	MirrorAddress  string `json:"mirror_address"`
+	MirrorUsername string `json:"mirror_username"`
+	MirrorPassword string `json:"mirror_password"`
+	LFS            bool   `json:"mirror_lfs"`
+	LFSEndpoint    string `json:"mirror_lfs_endpoint"`
+	DelOldBranches bool   `json:"del_old_branches"`
+	//PushMirrorID           string `json:"push_mirror_id"`
+	//PushMirrorAddress      string `json:"push_mirror_address"`
+	//PushMirrorUsername     string `json:"push_mirror_username"`
+	//PushMirrorPassword     string `json:"push_mirror_password"`
+	MirrorSyncOnCommit bool `json:"mirror_sync_on_commit"`
+	//PushMirrorInterval     string `json:"push_mirror_interval"`
+	//Private                bool   `json:"private"`
+	//Template               bool   `json:"Template"`
+	EnablePrune bool `json:"enable_prune"`
+}
+
+func PullMirrorAdd(ctx *context.APIContext, form *RepoSyncFormNew, repo *repo_model.Repository) {
+	mirrorModel := repo_model.Mirror{
+		RepoID:         repo.ID,
+		Interval:       setting.Mirror.DefaultInterval,
+		EnablePrune:    true,
+		NextUpdateUnix: timeutil.TimeStampNow().AddDuration(setting.Mirror.DefaultInterval),
+		LFS:            false,
+		RemoteAddress:  form.MirrorAddress,
+	}
+
+	parsedInterval, err := time.ParseDuration(form.Interval)
+	if err != nil {
+		log.Error("Failed to set Interval: %v", err)
+		ctx.Error(http.StatusInternalServerError, "Err_Interval", err)
+		return
+	}
+	if parsedInterval == 0 {
+		mirrorModel.Interval = 0
+		mirrorModel.NextUpdateUnix = 0
+	} else if parsedInterval < setting.Mirror.MinInterval {
+		err := fmt.Errorf("interval %s is set below Minimum Interval of %s", parsedInterval, setting.Mirror.MinInterval)
+		log.Error("Interval: %s is too frequent", form.Interval)
+		ctx.Error(http.StatusInternalServerError, "Err_Interval too max", err)
+		return
+	} else {
+		mirrorModel.Interval = parsedInterval
+		mirrorModel.NextUpdateUnix = timeutil.TimeStampNow().AddDuration(parsedInterval)
+	}
+
+	if err = repo_model.InsertMirror(ctx, &mirrorModel); err != nil {
+		ctx.Error(http.StatusInternalServerError, "mirrorAdd_err", err)
+		return
+	}
+	repoPath := repo_model.RepoPath(repo.OwnerName, repo.Name)
+	// this is necessary for sync local tags from remote
+	configName := fmt.Sprintf("remote.%s.fetch", mirrorModel.GetRemoteName())
+	_, _, err = git.NewCommand(ctx, "remote", "rm").AddDynamicArguments(mirrorModel.GetRemoteName()).RunStdString(&git.RunOpts{Dir: repoPath})
+
+	cmd := git.NewCommand(ctx, "remote", "add").AddDynamicArguments(mirrorModel.GetRemoteName()).AddArguments("--mirror=fetch").AddDynamicArguments(mirrorModel.RemoteAddress)
+	if strings.Contains(mirrorModel.RemoteAddress, "://") && strings.Contains(mirrorModel.RemoteAddress, "@") {
+		cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=fetch %s [repo_path: %s]", mirrorModel.GetRemoteName(), util.SanitizeCredentialURLs(mirrorModel.RemoteAddress), repoPath))
+	} else {
+		cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=fetch %s [repo_path: %s]", mirrorModel.GetRemoteName(), mirrorModel.RemoteAddress, repoPath))
+	}
+	_, _, err = cmd.RunStdString(&git.RunOpts{Dir: repoPath})
+	if err != nil && !strings.HasPrefix(err.Error(), "exit status 128 - fatal: No such remote ") {
+		ctx.Error(http.StatusInternalServerError, "error in MigrateRepositoryGitData(git config --add <remote> +refs/tags/*:refs/tags/*): %w", err)
+		return
+	}
+	if stdout, _, err := git.NewCommand(ctx, "config").AddOptionValues("--add", configName, `+refs/tags/*:refs/tags/*`).
+		RunStdString(&git.RunOpts{Dir: repoPath}); err != nil {
+		log.Error("MigrateRepositoryGitData(git config --add <remote> +refs/tags/*:refs/tags/*) in %v: Stdout: %s\nError: %v", repo, stdout, err)
+		ctx.Error(http.StatusInternalServerError, "error in MigrateRepositoryGitData(git config --add <remote> +refs/tags/*:refs/tags/*): %w", err)
+		return
+	}
+
+}
+
+func PullMirrorUpdate(ctx *context.APIContext, form *RepoSyncFormNew, repo *repo_model.Repository) {
+	pullMirror, err := repo_model.GetMirrorByRepoID(ctx, ctx.Repo.Repository.ID)
+	if err == repo_model.ErrMirrorNotExist {
+		ctx.NotFound("", nil)
+		return
+	}
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "GetMirrorByRepoID", err)
+		return
+	}
+
+	interval, err := time.ParseDuration(form.Interval)
+	if err != nil || (interval != 0 && interval < setting.Mirror.MinInterval) {
+		ctx.Data["Err_Interval"] = true
+		ctx.Error(http.StatusInternalServerError, "Err_Interval", err)
+		return
+	}
+
+	pullMirror.EnablePrune = form.EnablePrune
+	pullMirror.Interval = interval
+	pullMirror.ScheduleNextUpdate()
+	if err := repo_model.UpdateMirror(ctx, pullMirror); err != nil {
+		ctx.Error(http.StatusInternalServerError, "UpdateMirror", err)
+		return
+	}
+
+	u, err := git.GetRemoteURL(ctx, ctx.Repo.Repository.RepoPath(), pullMirror.GetRemoteName())
+	if err != nil {
+		ctx.Data["Err_MirrorAddress"] = true
+		ctx.Error(http.StatusInternalServerError, "repo.Err_MirrorAddress", err)
+		return
+	}
+	if u.User != nil && form.MirrorPassword == "" && form.MirrorUsername == u.User.Username() {
+		form.MirrorPassword, _ = u.User.Password()
+	}
+
+	address, err := forms.ParseRemoteAddr(form.MirrorAddress, form.MirrorUsername, form.MirrorPassword)
+	if err == nil {
+		err = migrations.IsMigrateURLAllowed(address, ctx.Doer)
+	}
+	if err != nil {
+		ctx.Data["Err_MirrorAddress"] = true
+		ctx.Error(http.StatusInternalServerError, "Err_MirrorAddress", err)
+		return
+	}
+
+	if err := hat_mirror_service.UpdateAddress(ctx, pullMirror, address); err != nil {
+		ctx.Error(http.StatusInternalServerError, "UpdateAddress", err)
+		return
+	}
+
+	remoteAddress, err := util.SanitizeURL(form.MirrorAddress)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "SanitizeURL", err)
+		return
+	}
+	pullMirror.RemoteAddress = remoteAddress
+
+	form.LFS = form.LFS && setting.LFS.StartServer
+
+	if len(form.LFSEndpoint) > 0 {
+		ep := lfs.DetermineEndpoint("", form.LFSEndpoint)
+		if ep == nil {
+			ctx.Data["Err_LFSEndpoint"] = true
+			ctx.Error(http.StatusInternalServerError, "Err_LFSEndpoint", err)
+			return
+		}
+		err = migrations.IsMigrateURLAllowed(ep.String(), ctx.Doer)
+		if err != nil {
+			ctx.Data["Err_LFSEndpoint"] = true
+			ctx.Error(http.StatusInternalServerError, "Err_LFSEndpoint", err)
+			return
+		}
+	}
+
+	pullMirror.LFS = form.LFS
+	pullMirror.LFSEndpoint = form.LFSEndpoint
+	if err := repo_model.UpdateMirror(ctx, pullMirror); err != nil {
+		ctx.Error(http.StatusInternalServerError, "UpdateMirror", err)
+		return
+	}
+	ctx.JSON(http.StatusOK, map[string]any{"ok": true})
+}
+
+func PullMirrorRemove(ctx *context.APIContext, form *RepoSyncFormNew, repo *repo_model.Repository) {
+	_, err1 := repo_model.GetMirrorByRepoID(ctx, ctx.Repo.Repository.ID)
+	if err1 != nil {
+		ctx.Error(http.StatusInternalServerError, "pullMirror already exists, repoId:", strconv.FormatInt(ctx.Repo.Repository.ID, 10))
+		return
+	}
+	if err := repo_model.DeleteMirrorByRepoID(ctx, ctx.Repo.Repository.ID); err != nil {
+		ctx.Error(http.StatusInternalServerError, "DeleteMirrorByRepoID", err)
+		return
+	}
+	repoPath := repo_model.RepoPath(repo.OwnerName, repo.Name)
+	_, _, err := git.NewCommand(ctx, "remote", "rm", "origin").RunStdString(&git.RunOpts{Dir: repoPath})
+	if err != nil && !strings.HasPrefix(err.Error(), "exit status 128 - fatal: No such remote ") {
+		ctx.Error(http.StatusInternalServerError, "DeleteMirrorConfig", err)
+		return
+	}
+	ctx.JSON(http.StatusOK, map[string]any{"ok": true})
+}
+
+func PushMirrorUpdate(ctx *context.APIContext, form *RepoSyncFormNew, repo *repo_model.Repository) {
+	interval, err := time.ParseDuration(form.Interval)
+	if err != nil || (interval != 0 && interval < setting.Mirror.MinInterval) {
+		ctx.Error(http.StatusInternalServerError, "mirror_interval_invalid", err)
+		return
+	}
+	pushMirror, err := repo_model.GetPushMirror(ctx, repo_model.PushMirrorOptions{RepoID: ctx.Repo.Repository.ID})
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "GetPushMirror", err)
+		return
+	}
+	m := &repo_model.PushMirror{
+		ID:       pushMirror.ID,
+		Interval: interval,
+	}
+
+	if err := repo_model.UpdatePushMirrorInterval(ctx, m); err != nil {
+		ctx.Error(http.StatusInternalServerError, "UpdatePushMirror Interval", err)
+		return
+	}
+	// Background why we are adding it to Queue
+	// If we observed its implementation in the context of `push-mirror-sync` where it
+	// is evident that pushing to the queue is necessary for updates.
+	// So, there are updates within the given interval, it is necessary to update the queue accordingly.
+	hat_mirror_service.AddPushMirrorToQueue(m.ID)
+	ctx.JSON(http.StatusOK, map[string]any{"ok": true})
+}
+
+func PushMirrorAdd(ctx *context.APIContext, form *RepoSyncFormNew, repo *repo_model.Repository) {
+	pushMirror, err := repo_model.GetPushMirror(ctx, repo_model.PushMirrorOptions{RepoID: ctx.Repo.Repository.ID})
+	if err == nil && pushMirror != nil {
+		ctx.Error(http.StatusInternalServerError, "pushMirror already exists, repoId:", strconv.FormatInt(ctx.Repo.Repository.ID, 10))
+		return
+	}
+
+	// This section doesn't require repo_name/RepoName to be set in the form, don't show it
+	// as an error on the UI for this action
+	ctx.Data["Err_RepoName"] = nil
+
+	interval, err := time.ParseDuration(form.Interval)
+	if err != nil || (interval != 0 && interval < setting.Mirror.MinInterval) {
+		ctx.Data["Err_PushMirror Interval"] = true
+		ctx.Error(http.StatusInternalServerError, "Err_PushMirror Interval", err)
+		return
+	}
+
+	address, err := forms.ParseRemoteAddr(form.MirrorAddress, form.MirrorUsername, form.MirrorPassword)
+	if err == nil {
+		err = migrations.IsMigrateURLAllowed(address, ctx.Doer)
+	}
+	if err != nil {
+		ctx.Data["Err_PushMirrorAddress"] = true
+		ctx.Error(http.StatusInternalServerError, "Err_PushMirrorAddress", err)
+		return
+	}
+
+	remoteSuffix, err := util.CryptoRandomString(10)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "RandomString", err)
+		return
+	}
+
+	remoteAddress, err := util.SanitizeURL(form.MirrorAddress)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "SanitizeURL", err)
+		return
+	}
+
+	m := &repo_model.PushMirror{
+		RepoID:        repo.ID,
+		Repo:          repo,
+		RemoteName:    fmt.Sprintf("remote_mirror_%s", remoteSuffix),
+		SyncOnCommit:  form.MirrorSyncOnCommit,
+		Interval:      interval,
+		RemoteAddress: remoteAddress,
+	}
+	if err := repo_model.InsertPushMirror(ctx, m); err != nil {
+		ctx.Error(http.StatusInternalServerError, "InsertPushMirror", err)
+		return
+	}
+
+	if err := hat_mirror_service.AddPushMirrorRemote(ctx, m, address); err != nil {
+		if err := repo_model.DeletePushMirrors(ctx, repo_model.PushMirrorOptions{ID: m.ID, RepoID: m.RepoID}); err != nil {
+			log.Error("DeletePushMirrors %v", err)
+		}
+		ctx.Error(http.StatusInternalServerError, "AddPushMirrorRemote", err)
+		return
+	}
+
+	ctx.JSON(http.StatusOK, map[string]any{"ok": true})
+}
+
+func PushMirrorRemove(ctx *context.APIContext, form *RepoSyncFormNew, repo *repo_model.Repository) {
+	pushMirror, err := repo_model.GetPushMirror(ctx, repo_model.PushMirrorOptions{RepoID: ctx.Repo.Repository.ID})
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "GetPushMirror", err)
+		return
+	}
+
+	if err = hat_mirror_service.RemovePushMirrorRemote(ctx, pushMirror); err != nil {
+		ctx.Error(http.StatusInternalServerError, "RemovePushMirrorRemote", err)
+		return
+	}
+
+	if err = repo_model.DeletePushMirrors(ctx, repo_model.PushMirrorOptions{ID: pushMirror.ID, RepoID: pushMirror.RepoID}); err != nil {
+		ctx.Error(http.StatusInternalServerError, "DeletePushMirrorByID", err)
+		return
+	}
+	ctx.JSON(http.StatusOK, map[string]any{"ok": true})
+}
+
+func MirrorSyncV2(ctx *context.APIContext) {
+	form := web.GetForm(ctx).(*RepoSyncFormNew)
+	repo := ctx.Repo.Repository
+	if form.Action == "mirror-sync" || form.Action == "push-mirror-update" || form.Action == "push-mirror-update" {
+		remoteAddr, err := forms.ParseRemoteAddr(form.MirrorAddress, form.MirrorUsername, form.MirrorPassword)
+		if err == nil {
+			err = migrations.IsMigrateURLAllowed(remoteAddr, ctx.Doer)
+		}
+		if err != nil {
+			handleRemoteAddrError(ctx, err)
+			return
+		}
+		form.MirrorAddress = remoteAddr
+	}
+	switch form.Action {
+	case "mirror-sync":
+		_, err := repo_model.GetMirrorByRepoID(ctx, ctx.Repo.Repository.ID)
+		//  检测pullMirror不存在,增加
+		if err != nil {
+			if errors.Is(err, repo_model.ErrMirrorNotExist) {
+				PullMirrorAdd(ctx, form, repo)
+			} else {
+				ctx.Error(http.StatusInternalServerError, "MirrorSync", err)
+				return
+			}
+		}
+		// 开始同步加入队列
+		hat_mirror_service.AddPullMirrorToQueue(repo.ID, form.DelOldBranches)
+		ctx.JSON(http.StatusOK, map[string]any{"ok": true})
+	case "pull-mirror-update":
+		PullMirrorUpdate(ctx, form, repo)
+	case "pull-mirror-remove":
+		PullMirrorRemove(ctx, form, repo)
+	case "push-mirror-update":
+		PushMirrorUpdate(ctx, form, repo)
+	case "push-mirror-add":
+		PushMirrorAdd(ctx, form, repo)
+	case "push-mirror-remove":
+		PushMirrorRemove(ctx, form, repo)
+	default:
+		ctx.NotFound("", nil)
+	}
+}
+
+func handleRemoteAddrError(ctx *context.APIContext, err error) {
+	if models.IsErrInvalidCloneAddr(err) {
+		addrErr := err.(*models.ErrInvalidCloneAddr)
+		switch {
+		case addrErr.IsURLError:
+			ctx.Error(http.StatusUnprocessableEntity, "", err)
+		case addrErr.IsPermissionDenied:
+			if addrErr.LocalPath {
+				ctx.Error(http.StatusUnprocessableEntity, "", "You are not allowed to import local repositories.")
+			} else {
+				ctx.Error(http.StatusUnprocessableEntity, "", "You can not import from disallowed hosts.")
+			}
+		case addrErr.IsInvalidPath:
+			ctx.Error(http.StatusUnprocessableEntity, "", "Invalid local path, it does not exist or not a directory.")
+		default:
+			ctx.Error(http.StatusInternalServerError, "ParseRemoteAddr", "Unknown error type (ErrInvalidCloneAddr): "+err.Error())
+		}
+	} else {
+		ctx.Error(http.StatusInternalServerError, "ParseRemoteAddr", err)
+	}
+}

routers/hat/repo/search.go

@@ -0,0 +1,68 @@
+package repo
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+	"strconv"
+
+	repo_model "code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/modules/context"
+	code_indexer "code.gitea.io/gitea/modules/indexer/code"
+
+	"code.gitea.io/gitea/modules/setting"
+)
+
+func Code(ctx *context.APIContext) {
+	language := ctx.FormString("language")
+	keyword := ctx.FormString("keyword")
+	queryType := ctx.FormString("query_type")
+	isMatch := queryType == "match"
+
+	page := ctx.FormInt("page")
+	if page <= 0 {
+		page = 1
+	}
+
+	var (
+		total                 int
+		searchResults         []*code_indexer.Result
+		searchResultLanguages []*code_indexer.SearchResultLanguages
+	)
+
+	var codeIndexerUnavailable bool
+	var repoMaps map[int64]*repo_model.Repository
+
+	total, searchResults, searchResultLanguages, err := code_indexer.PerformSearch(ctx, []int64{ctx.Repo.Repository.ID},
+		language, keyword, page, setting.UI.RepoSearchPagingNum, isMatch)
+	if err != nil {
+		if code_indexer.IsAvailable(ctx) {
+			ctx.Error(http.StatusInternalServerError, "SearchResults", err)
+			return
+		}
+		codeIndexerUnavailable = true
+	} else {
+		codeIndexerUnavailable = !code_indexer.IsAvailable(ctx)
+	}
+
+	pageCount := int(math.Ceil(float64(total) / float64(setting.UI.RepoSearchPagingNum)))
+	ctx.Resp.Header().Set("X-Page", strconv.Itoa(page))
+	ctx.Resp.Header().Set("X-PerPage", strconv.Itoa(setting.UI.RepoSearchPagingNum))
+	ctx.Resp.Header().Set("X-Total", strconv.FormatInt(int64(total), 10))
+	ctx.Resp.Header().Set("X-PageCount", strconv.Itoa(pageCount))
+	ctx.Resp.Header().Set("X-HasMore", strconv.FormatBool(page < pageCount))
+
+	ctx.SetLinkHeader(int(total), setting.UI.RepoSearchPagingNum)
+	ctx.Resp.Header().Set("X-Total-Count", fmt.Sprintf("%d", total))
+	ctx.JSON(http.StatusOK, struct {
+		CodeIndexerUnavailable bool
+		RepoMaps               map[int64]*repo_model.Repository
+		SearchResults          []*code_indexer.Result
+		SearchResultLanguages  []*code_indexer.SearchResultLanguages
+	}{
+		CodeIndexerUnavailable: codeIndexerUnavailable,
+		RepoMaps:               repoMaps,
+		SearchResults:          searchResults,
+		SearchResultLanguages:  searchResultLanguages,
+	})
+}

routers/hat/repo/size_limit.go

@@ -0,0 +1,385 @@
+package repo
+
+import (
+	repo_model "code.gitea.io/gitea/models/repo"
+	user_model "code.gitea.io/gitea/models/user"
+	"code.gitea.io/gitea/modules/context"
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/setting"
+	gitea_api "code.gitea.io/gitea/modules/structs"
+	"code.gitea.io/gitea/modules/util"
+	"code.gitea.io/gitea/modules/web"
+	"fmt"
+	"github.com/unknwon/com"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+const (
+	SIZE_LIMIT_SCRIPT_NAME = "size_limit"
+)
+
+type UpdateRepoSizeLimit struct {
+	OwnerName string `json:"owner_name"`
+	RepoName  string `json:"repo_name"`
+	LimitSize int    `json:"limit_size"`
+}
+
+func CreateRepoSizeLimitHook(ctx *context.APIContext) {
+	form := web.GetForm(ctx).(*gitea_api.RepositoryPayload)
+	limitMb := ctx.FormInt("limit_size")
+	if limitMb < 30 {
+		limitMb = 512
+	}
+	eventName := string(form.Action)
+	if eventName == "deleted" {
+		ctx.Status(http.StatusOK)
+		return
+	}
+	getAssignmentRepo(ctx, form.Repository.ID)
+	hookDir := filepath.Join(ctx.Repo.Repository.RepoPath(), "hooks")
+	hookName := "pre-receive"
+	//results := make([]string, 0, 10)
+	sizeLimitTpls := []string{
+		fmt.Sprintf("#!/usr/bin/env %s\n\n\nset -o pipefail\n\nreadonly DEFAULT_FILE_MAXSIZE_MB=\"30\" \nreadonly CONFIG_NAME=\"hooks.maxfilesize\"\nreadonly NULLSHA=\"0000000000000000000000000000000000000000\"\nreadonly EXIT_SUCCESS=0\nreadonly EXIT_FAILURE=1\nreadonly DEFAULT_REPO_MAXSIZE_MB=\"1024\" \nreadonly CHECK_FLAG_ON=1\n\n\nPUSH_SIZE_CHECK_FLAG=1\nREPO_MAX_FILE_SIZE=1024\nREPO_MAX_SIZE=%d\nREPO_CURRENT_SIZE=$(du -sk \"${PWD}\" | cut -f1)\nsize_in_mb=$(($REPO_CURRENT_SIZE / 1024))\nstatus=\"$EXIT_SUCCESS\"\n\n# skip this hook entirely if shell check is not open\ncheck_flag=${PUSH_SIZE_CHECK_FLAG}\nif [[ $check_flag != $CHECK_FLAG_ON ]]; then\nexit $EXIT_SUCCESS\nfi\n\n\n#######################################\n# check the file max size limit\n#######################################\n\n# get maximum filesize (from repository-specific config)\nmaxsize_mb=\"${REPO_MAX_FILE_SIZE}\"\n\nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\necho \"failed to get ${CONFIG_NAME} from config\"\nexit \"$EXIT_FAILURE\"\nfi\n\npush_size=\"0\"\n# read lines from stdin (format: \"<oldref> <newref> <refname>\\n\")\nwhile read oldref newref refname; do\n# skip branch deletions\nif [[ \"$newref\" == \"$NULLSHA\" ]]; then\n  continue\nfi\n\n# find large objects\n# check all objects from $oldref (possible $NULLSHA) to $newref, but\n# skip all objects that have already been accepted (i.e. are referenced by\n# another branch or tag).\n\nnew_branch_flag=0\nif [[ \"$oldref\" == \"$NULLSHA\" ]]; then\n  target=\"$newref\"\n  new_branch_flag=1\n  echo \"You are creating a new remote branch,openI will check all files in commit history to find oversize files\"\nelse\n  target=\"${oldref}..${newref}\"\nfi\nmaxsize=`expr $maxsize_mb \\* 1048576` \n\n# find objects in this push_size\n# print like:\n# 08da8e2ab9ae4095bf94dd71ac913132b880b463 commit 214\n# 43e993b768ede5740e8c65de2ed6edec25053ea1 tree 185\n# 4476971d76569039df7569af1b8d03c288f6b193 blob 20167318 b0417e6593a1.zip\nfiles=\"$(git rev-list --objects \"$target\" | \\\n  git cat-file $'--batch-check=%%(objectname) %%(objecttype) %%(objectsize) %%(rest)' | \\\n      awk -F ' ' -v maxbytes=\"$maxsize\" 'BEGIN {totalIn=0} {if( $3 > maxbytes && $2 == \"blob\") { totalIn+=$3; print $4} else { totalIn+=$3}} END { printf (\"totalIn=\\t%%s\",totalIn)}' )\"\n  \nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\n  echo \"failed to check for large files in ref ${refname}\"\n  continue\nfi\n\nIFS=$'\\n'\n# rewrite IFS to seperate line in $files\nfor file in $files; do\n  # if don't unset IFS,temp_array=(${file}) will get error answer\n \n  if [[ ${file} == totalIn=* ]]; then\n\tIFS=$'\\t'\n\ttemp_array=(${file})\n\tpush_size=${temp_array[1]}\n\tcontinue\n  fi\n\tunset IFS\n  if [[ \"$status\" == $EXIT_SUCCESS ]]; then\n\t\techo -e \"Error: Your push was rejected because it contains files larger than $(numfmt --to=iec \"$maxsize_mb\") Mb\"\n\t\techo \"help document -- ...\"\n\t\techo \"oversize files:\"\n\t\tstatus=\"$EXIT_FAILURE\"\t\n  fi\n  echo -e \"\\033[31m- ${file}\\033[0m \"\ndone\n\nif [[ \"$status\" != $EXIT_SUCCESS ]]; then\n\texit \"$status\"\nfi\n\ndone\n\n#######################################\n# check the repo max size limit\n#######################################\nif [[ $push_size -eq \"0\" ]]; then\n\texit $EXIT_SUCCESS\nfi\n\n# if create new branch or tag,use count-objects -v to get pack size\nif [[ $new_branch_flag -eq 1 ]]; then\n    size_kb=`git count-objects -v | grep 'size-pack' | sed  's/.*\\(size-pack:\\).//'`\n    size_pack_kb=`git count-objects -v | grep 'size:' | sed  's/.*\\(size:\\).//'`\n\ttotal_kb=`expr $size_kb + $size_pack_kb`\n\tlet push_size=$total_kb*1024\nfi\n\nsizelimit_mb=\"${REPO_MAX_SIZE}\"\nlet sizelimit_b=$sizelimit_mb*1024*1024\n\n# repo size at here means the size of repo directory in server \nreposize_b=${REPO_CURRENT_SIZE}\n\nlet total=$REPO_CURRENT_SIZE*1024\n\nif [ $total -gt $sizelimit_b ]; then\n    echo \"Error: Your push was rejected because the repository size is large than $sizelimit_mb Mb\"\n    echo \"Error: 推送被拒绝，文件或目录大小大于 $sizelimit_mb Mb\"\n    exit $EXIT_FAILURE\nfi\n\n\nexit $EXIT_SUCCESS", setting.ScriptType, limitMb),
+		fmt.Sprintf(""),
+		fmt.Sprintf(""),
+	}
+
+	oldHookPath := filepath.Join(hookDir, hookName+".d", SIZE_LIMIT_SCRIPT_NAME)
+	if !com.IsExist(oldHookPath) {
+		//if err := checkHookFile(generateHookScriptPath(hookDir, hookName, SIZE_LIMIT_SCRIPT_NAME), sizeLimitTpls[0], results); err != nil {
+		//		ctx.Error(http.StatusInternalServerError, "CreateSizeLimitHook checkHookFile", err)
+		//		ctx.NotFound()
+		//		return
+		//}
+
+		if err := writeHookTpl(generateHookScriptPath(hookDir, hookName, SIZE_LIMIT_SCRIPT_NAME), sizeLimitTpls[0]); err != nil {
+			ctx.Error(http.StatusInternalServerError, "CreateSizeLimitHook checkHookFile", err)
+			ctx.NotFound()
+			return
+		}
+	}
+	ctx.Status(http.StatusOK)
+}
+
+// 更新arm架构中事件失效问题
+func UpdateHookArm(ctx *context.APIContext) {
+	form := web.GetForm(ctx).(*gitea_api.RepositoryPayload)
+	eventName := string(form.Action)
+	if eventName == "deleted" {
+		ctx.Status(http.StatusOK)
+		return
+	}
+	getAssignmentRepo(ctx, form.Repository.ID)
+	if err := UpdateDelegateHooks(ctx.Repo.Repository.RepoPath()); err != nil {
+		fmt.Errorf("Unable to recreate delegate hooks for %-v. ERROR: %w", ctx.Repo, err)
+		ctx.Error(http.StatusInternalServerError, "", "Unable to recreate delegate hooks.")
+		return
+	}
+	ctx.Status(http.StatusOK)
+}
+
+// 更新仓库限制大小
+func UpdateRepoSizeLimitHook(ctx *context.APIContext) {
+	form := web.GetForm(ctx).(*UpdateRepoSizeLimit)
+	ownerName := string(form.OwnerName)
+	repoName := string(form.RepoName)
+	LimitSize := form.LimitSize
+
+	getAssignmentRepoByName(ctx, ownerName, repoName)
+
+	hookDir := filepath.Join(ctx.Repo.Repository.RepoPath(), "hooks")
+	hookName := "pre-receive"
+	//results := make([]string, 0, 10)
+	sizeLimitTpls := []string{
+		//fmt.Sprintf("#!/usr/bin/env %s\n\n\nset -o pipefail\n\nreadonly DEFAULT_FILE_MAXSIZE_MB=\"30\" \nreadonly CONFIG_NAME=\"hooks.maxfilesize\"\nreadonly NULLSHA=\"0000000000000000000000000000000000000000\"\nreadonly EXIT_SUCCESS=0\nreadonly EXIT_FAILURE=1\nreadonly DEFAULT_REPO_MAXSIZE_MB=\"1024\" \nreadonly CHECK_FLAG_ON=1\n\n\nstatus=\"$EXIT_SUCCESS\"\n\n# skip this hook entirely if shell check is not open\ncheck_flag=${PUSH_SIZE_CHECK_FLAG}\nif [[ $check_flag != $CHECK_FLAG_ON ]]; then\nexit $EXIT_SUCCESS\nfi\n\n\n#######################################\n# check the file max size limit\n#######################################\n\n# get maximum filesize (from repository-specific config)\nmaxsize_mb=\"${REPO_MAX_FILE_SIZE}\"\n\nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\necho \"failed to get ${CONFIG_NAME} from config\"\nexit \"$EXIT_FAILURE\"\nfi\n\npush_size=\"0\"\n# read lines from stdin (format: \"<oldref> <newref> <refname>\\n\")\nwhile read oldref newref refname; do\n# skip branch deletions\nif [[ \"$newref\" == \"$NULLSHA\" ]]; then\n  continue\nfi\n\n# find large objects\n# check all objects from $oldref (possible $NULLSHA) to $newref, but\n# skip all objects that have already been accepted (i.e. are referenced by\n# another branch or tag).\n\nnew_branch_flag=0\nif [[ \"$oldref\" == \"$NULLSHA\" ]]; then\n  target=\"$newref\"\n  new_branch_flag=1\n  echo \"You are creating a new remote branch,openI will check all files in commit history to find oversize files\"\nelse\n  target=\"${oldref}..${newref}\"\nfi\nmaxsize=`expr $maxsize_mb \\* 1048576` \n\n# find objects in this push_size\n# print like:\n# 08da8e2ab9ae4095bf94dd71ac913132b880b463 commit 214\n# 43e993b768ede5740e8c65de2ed6edec25053ea1 tree 185\n# 4476971d76569039df7569af1b8d03c288f6b193 blob 20167318 b0417e6593a1.zip\nfiles=\"$(git rev-list --objects \"$target\" | \\\n  git cat-file $'--batch-check=%%(objectname) %%(objecttype) %%(objectsize) %%(rest)' | \\\n      awk -F ' ' -v maxbytes=\"$maxsize\" 'BEGIN {totalIn=0} {if( $3 > maxbytes && $2 == \"blob\") { totalIn+=$3; print $4} else { totalIn+=$3}} END { printf (\"totalIn=\\t%%s\",totalIn)}' )\"\n  \nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\n  echo \"failed to check for large files in ref ${refname}\"\n  continue\nfi\n\nIFS=$'\\n'\n# rewrite IFS to seperate line in $files\nfor file in $files; do\n  # if don't unset IFS,temp_array=(${file}) will get error answer\n \n  if [[ ${file} == totalIn=* ]]; then\n\tIFS=$'\\t'\n\ttemp_array=(${file})\n\tpush_size=${temp_array[1]}\n\tcontinue\n  fi\n\tunset IFS\n  if [[ \"$status\" == $EXIT_SUCCESS ]]; then\n\t\techo -e \"Error: Your push was rejected because it contains files larger than $(numfmt --to=iec \"$maxsize_mb\") Mb\"\n\t\techo \"help document -- https://openi.pcl.ac.cn/zeizei/OpenI_Learning/src/branch/master/docs/git/repository_capacity_help.md\"\n\t\techo \"oversize files:\"\n\t\tstatus=\"$EXIT_FAILURE\"\t\n  fi\n  echo -e \"\\033[31m- ${file}\\033[0m \"\ndone\n\nif [[ \"$status\" != $EXIT_SUCCESS ]]; then\n\texit \"$status\"\nfi\n\ndone\n\n#######################################\n# check the repo max size limit\n#######################################\nif [[ $push_size -eq \"0\" ]]; then\n\texit $EXIT_SUCCESS\nfi\n\n# if create new branch or tag,use count-objects -v to get pack size\nif [[ $new_branch_flag -eq 1 ]]; then\n    size_kb=`git count-objects -v | grep 'size-pack' | sed  's/.*\\(size-pack:\\).//'`\n    size_pack_kb=`git count-objects -v | grep 'size:' | sed  's/.*\\(size:\\).//'`\n\ttotal_kb=`expr $size_kb + $size_pack_kb`\n\tlet push_size=$total_kb*1024\nfi\n\nsizelimit_mb=\"${REPO_MAX_SIZE}\"\nlet sizelimit_b=$sizelimit_mb*1024*1024\n\n# repo size at here means the size of repo directory in server \nreposize_b=${REPO_CURRENT_SIZE}\n\ntotal=`expr $push_size + $reposize_b`\n\nif [ $total -gt $sizelimit_b ]; then\n    echo \"Error: Your push was rejected because the repository size is large than $sizelimit_mb Mb\"\n    echo \"see the help document--https://openi.pcl.ac.cn/zeizei/OpenI_Learning/src/branch/master/docs/git/repository_capacity_help.md\"\n    exit $EXIT_FAILURE\nfi\n\n\nexit $EXIT_SUCCESS", setting.ScriptType, LimitSize),
+		fmt.Sprintf("#!/usr/bin/env %s\n\n\nset -o pipefail\n\nreadonly DEFAULT_FILE_MAXSIZE_MB=\"30\" \nreadonly CONFIG_NAME=\"hooks.maxfilesize\"\nreadonly NULLSHA=\"0000000000000000000000000000000000000000\"\nreadonly EXIT_SUCCESS=0\nreadonly EXIT_FAILURE=1\nreadonly DEFAULT_REPO_MAXSIZE_MB=\"1024\" \nreadonly CHECK_FLAG_ON=1\n\n\nPUSH_SIZE_CHECK_FLAG=1\nREPO_MAX_FILE_SIZE=1024\nREPO_MAX_SIZE=%d\nREPO_CURRENT_SIZE=$(du -sk \"${PWD}\" | cut -f1)\nsize_in_mb=$(($REPO_CURRENT_SIZE / 1024))\nstatus=\"$EXIT_SUCCESS\"\n\n# skip this hook entirely if shell check is not open\ncheck_flag=${PUSH_SIZE_CHECK_FLAG}\nif [[ $check_flag != $CHECK_FLAG_ON ]]; then\nexit $EXIT_SUCCESS\nfi\n\n\n#######################################\n# check the file max size limit\n#######################################\n\n# get maximum filesize (from repository-specific config)\nmaxsize_mb=\"${REPO_MAX_FILE_SIZE}\"\n\nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\necho \"failed to get ${CONFIG_NAME} from config\"\nexit \"$EXIT_FAILURE\"\nfi\n\npush_size=\"0\"\n# read lines from stdin (format: \"<oldref> <newref> <refname>\\n\")\nwhile read oldref newref refname; do\n# skip branch deletions\nif [[ \"$newref\" == \"$NULLSHA\" ]]; then\n  continue\nfi\n\n# find large objects\n# check all objects from $oldref (possible $NULLSHA) to $newref, but\n# skip all objects that have already been accepted (i.e. are referenced by\n# another branch or tag).\n\nnew_branch_flag=0\nif [[ \"$oldref\" == \"$NULLSHA\" ]]; then\n  target=\"$newref\"\n  new_branch_flag=1\n  echo \"You are creating a new remote branch,openI will check all files in commit history to find oversize files\"\nelse\n  target=\"${oldref}..${newref}\"\nfi\nmaxsize=`expr $maxsize_mb \\* 1048576` \n\n# find objects in this push_size\n# print like:\n# 08da8e2ab9ae4095bf94dd71ac913132b880b463 commit 214\n# 43e993b768ede5740e8c65de2ed6edec25053ea1 tree 185\n# 4476971d76569039df7569af1b8d03c288f6b193 blob 20167318 b0417e6593a1.zip\nfiles=\"$(git rev-list --objects \"$target\" | \\\n  git cat-file $'--batch-check=%%(objectname) %%(objecttype) %%(objectsize) %%(rest)' | \\\n      awk -F ' ' -v maxbytes=\"$maxsize\" 'BEGIN {totalIn=0} {if( $3 > maxbytes && $2 == \"blob\") { totalIn+=$3; print $4} else { totalIn+=$3}} END { printf (\"totalIn=\\t%%s\",totalIn)}' )\"\n  \nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\n  echo \"failed to check for large files in ref ${refname}\"\n  continue\nfi\n\nIFS=$'\\n'\n# rewrite IFS to seperate line in $files\nfor file in $files; do\n  # if don't unset IFS,temp_array=(${file}) will get error answer\n \n  if [[ ${file} == totalIn=* ]]; then\n\tIFS=$'\\t'\n\ttemp_array=(${file})\n\tpush_size=${temp_array[1]}\n\tcontinue\n  fi\n\tunset IFS\n  if [[ \"$status\" == $EXIT_SUCCESS ]]; then\n\t\techo -e \"Error: Your push was rejected because it contains files larger than $(numfmt --to=iec \"$maxsize_mb\") Mb\"\n\t\techo \"help document -- ...\"\n\t\techo \"oversize files:\"\n\t\tstatus=\"$EXIT_FAILURE\"\t\n  fi\n  echo -e \"\\033[31m- ${file}\\033[0m \"\ndone\n\nif [[ \"$status\" != $EXIT_SUCCESS ]]; then\n\texit \"$status\"\nfi\n\ndone\n\n#######################################\n# check the repo max size limit\n#######################################\nif [[ $push_size -eq \"0\" ]]; then\n\texit $EXIT_SUCCESS\nfi\n\n# if create new branch or tag,use count-objects -v to get pack size\nif [[ $new_branch_flag -eq 1 ]]; then\n    size_kb=`git count-objects -v | grep 'size-pack' | sed  's/.*\\(size-pack:\\).//'`\n    size_pack_kb=`git count-objects -v | grep 'size:' | sed  's/.*\\(size:\\).//'`\n\ttotal_kb=`expr $size_kb + $size_pack_kb`\n\tlet push_size=$total_kb*1024\nfi\n\nsizelimit_mb=\"${REPO_MAX_SIZE}\"\nlet sizelimit_b=$sizelimit_mb*1024*1024\n\n# repo size at here means the size of repo directory in server \nreposize_b=${REPO_CURRENT_SIZE}\n\nlet total=$REPO_CURRENT_SIZE*1024\n\nif [ $total -gt $sizelimit_b ]; then\n    echo \"Error: Your push was rejected because the repository size is large than $sizelimit_mb Mb\"\n    echo \"Error: 推送被拒绝，文件或目录大小大于 $sizelimit_mb Mb\"\n    exit $EXIT_FAILURE\nfi\n\n\nexit $EXIT_SUCCESS", setting.ScriptType, LimitSize),
+
+		fmt.Sprintf(""),
+		fmt.Sprintf(""),
+	}
+
+	oldHookPath := filepath.Join(hookDir, hookName+".d", SIZE_LIMIT_SCRIPT_NAME)
+	if !com.IsExist(oldHookPath) {
+		//if err := checkHookFile(generateHookScriptPath(hookDir, hookName, SIZE_LIMIT_SCRIPT_NAME), sizeLimitTpls[0], results); err != nil {
+		//		ctx.Error(http.StatusInternalServerError, "CreateSizeLimitHook checkHookFile", err)
+		//		ctx.NotFound()
+		//		return
+		//}
+
+		if err := writeHookTpl(generateHookScriptPath(hookDir, hookName, SIZE_LIMIT_SCRIPT_NAME), sizeLimitTpls[0]); err != nil {
+			ctx.Error(http.StatusInternalServerError, "CreateSizeLimitHook checkHookFile", err)
+			ctx.NotFound()
+			return
+		}
+	}
+	ctx.Status(http.StatusOK)
+}
+
+func resetRepoSizeLimitHook(ctx *context.APIContext) {
+	form := web.GetForm(ctx).(*gitea_api.RepositoryPayload)
+	eventName := string(form.Action)
+	if eventName == "deleted" {
+		ctx.Status(http.StatusOK)
+		return
+	}
+	getAssignmentRepo(ctx, form.Repository.ID)
+	hookDir := filepath.Join(ctx.Repo.Repository.RepoPath(), "hooks")
+	hookName := "pre-receive"
+	//results := make([]string, 0, 10)
+	sizeLimitTpls := []string{
+		fmt.Sprintf("#!/usr/bin/env %s\n\n\nset -o pipefail\n\nreadonly DEFAULT_FILE_MAXSIZE_MB=\"30\" \nreadonly CONFIG_NAME=\"hooks.maxfilesize\"\nreadonly NULLSHA=\"0000000000000000000000000000000000000000\"\nreadonly EXIT_SUCCESS=0\nreadonly EXIT_FAILURE=1\nreadonly DEFAULT_REPO_MAXSIZE_MB=\"1024\" \nreadonly CHECK_FLAG_ON=1\n\n\nstatus=\"$EXIT_SUCCESS\"\n\n# skip this hook entirely if shell check is not open\ncheck_flag=${PUSH_SIZE_CHECK_FLAG}\nif [[ $check_flag != $CHECK_FLAG_ON ]]; then\nexit $EXIT_SUCCESS\nfi\n\n\n#######################################\n# check the file max size limit\n#######################################\n\n# get maximum filesize (from repository-specific config)\nmaxsize_mb=\"${REPO_MAX_FILE_SIZE}\"\n\nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\necho \"failed to get ${CONFIG_NAME} from config\"\nexit \"$EXIT_FAILURE\"\nfi\n\npush_size=\"0\"\n# read lines from stdin (format: \"<oldref> <newref> <refname>\\n\")\nwhile read oldref newref refname; do\n# skip branch deletions\nif [[ \"$newref\" == \"$NULLSHA\" ]]; then\n  continue\nfi\n\n# find large objects\n# check all objects from $oldref (possible $NULLSHA) to $newref, but\n# skip all objects that have already been accepted (i.e. are referenced by\n# another branch or tag).\n\nnew_branch_flag=0\nif [[ \"$oldref\" == \"$NULLSHA\" ]]; then\n  target=\"$newref\"\n  new_branch_flag=1\n  echo \"You are creating a new remote branch,openI will check all files in commit history to find oversize files\"\nelse\n  target=\"${oldref}..${newref}\"\nfi\nmaxsize=`expr $maxsize_mb \\* 1048576` \n\n# find objects in this push_size\n# print like:\n# 08da8e2ab9ae4095bf94dd71ac913132b880b463 commit 214\n# 43e993b768ede5740e8c65de2ed6edec25053ea1 tree 185\n# 4476971d76569039df7569af1b8d03c288f6b193 blob 20167318 b0417e6593a1.zip\nfiles=\"$(git rev-list --objects \"$target\" | \\\n  git cat-file $'--batch-check=%%(objectname) %%(objecttype) %%(objectsize) %%(rest)' | \\\n      awk -F ' ' -v maxbytes=\"$maxsize\" 'BEGIN {totalIn=0} {if( $3 > maxbytes && $2 == \"blob\") { totalIn+=$3; print $4} else { totalIn+=$3}} END { printf (\"totalIn=\\t%%s\",totalIn)}' )\"\n  \nif [[ \"$?\" != $EXIT_SUCCESS ]]; then\n  echo \"failed to check for large files in ref ${refname}\"\n  continue\nfi\n\nIFS=$'\\n'\n# rewrite IFS to seperate line in $files\nfor file in $files; do\n  # if don't unset IFS,temp_array=(${file}) will get error answer\n \n  if [[ ${file} == totalIn=* ]]; then\n\tIFS=$'\\t'\n\ttemp_array=(${file})\n\tpush_size=${temp_array[1]}\n\tcontinue\n  fi\n\tunset IFS\n  if [[ \"$status\" == $EXIT_SUCCESS ]]; then\n\t\techo -e \"Error: Your push was rejected because it contains files larger than $(numfmt --to=iec \"$maxsize_mb\") Mb\"\n\t\techo \"help document -- https://openi.pcl.ac.cn/zeizei/OpenI_Learning/src/branch/master/docs/git/repository_capacity_help.md\"\n\t\techo \"oversize files:\"\n\t\tstatus=\"$EXIT_FAILURE\"\t\n  fi\n  echo -e \"\\033[31m- ${file}\\033[0m \"\ndone\n\nif [[ \"$status\" != $EXIT_SUCCESS ]]; then\n\texit \"$status\"\nfi\n\ndone\n\n#######################################\n# check the repo max size limit\n#######################################\nif [[ $push_size -eq \"0\" ]]; then\n\texit $EXIT_SUCCESS\nfi\n\n# if create new branch or tag,use count-objects -v to get pack size\nif [[ $new_branch_flag -eq 1 ]]; then\n    size_kb=`git count-objects -v | grep 'size-pack' | sed  's/.*\\(size-pack:\\).//'`\n    size_pack_kb=`git count-objects -v | grep 'size:' | sed  's/.*\\(size:\\).//'`\n\ttotal_kb=`expr $size_kb + $size_pack_kb`\n\tlet push_size=$total_kb*1024\nfi\n\nsizelimit_mb=\"${REPO_MAX_SIZE}\"\nlet sizelimit_b=$sizelimit_mb*1024*1024\n\n# repo size at here means the size of repo directory in server \nreposize_b=${REPO_CURRENT_SIZE}\n\ntotal=`expr $push_size + $reposize_b`\n\nif [ $total -gt $sizelimit_b ]; then\n    echo \"Error: Your push was rejected because the repository size is large than $sizelimit_mb Mb\"\n    echo \"see the help document--https://openi.pcl.ac.cn/zeizei/OpenI_Learning/src/branch/master/docs/git/repository_capacity_help.md\"\n    exit $EXIT_FAILURE\nfi\n\n\nexit $EXIT_SUCCESS", setting.ScriptType),
+		fmt.Sprintf(""),
+		fmt.Sprintf(""),
+	}
+
+	oldHookPath := filepath.Join(hookDir, hookName+".d", SIZE_LIMIT_SCRIPT_NAME)
+	if !com.IsExist(oldHookPath) {
+		//if err := checkHookFile(generateHookScriptPath(hookDir, hookName, SIZE_LIMIT_SCRIPT_NAME), sizeLimitTpls[0], results); err != nil {
+		//		ctx.Error(http.StatusInternalServerError, "CreateSizeLimitHook checkHookFile", err)
+		//		ctx.NotFound()
+		//		return
+		//}
+
+		if err := writeHookTpl(generateHookScriptPath(hookDir, hookName, SIZE_LIMIT_SCRIPT_NAME), sizeLimitTpls[0]); err != nil {
+			ctx.Error(http.StatusInternalServerError, "CreateSizeLimitHook checkHookFile", err)
+			ctx.NotFound()
+			return
+		}
+	}
+	ctx.Status(http.StatusOK)
+}
+
+func getAssignmentRepo(ctx *context.APIContext, id int64) {
+	// Get repository.
+	repo, err := repo_model.GetRepositoryByID(ctx, id)
+	if err != nil {
+		if repo_model.IsErrRepoNotExist(err) {
+			redirectRepoID, err := repo_model.LookupRedirect(repo.OwnerID, repo.Name)
+			if err == nil {
+				context.RedirectToRepo(ctx.Base, redirectRepoID)
+			} else if repo_model.IsErrRedirectNotExist(err) {
+				ctx.NotFound(ctx.Tr("repo.RepoNotFound", repo.OwnerID))
+			} else {
+				ctx.Error(http.StatusInternalServerError, "LookupRepoRedirect", err)
+			}
+		} else {
+			ctx.Error(http.StatusInternalServerError, "GetRepositoryByID", err)
+		}
+		return
+	}
+	ctx.Repo.Repository = repo
+}
+
+func getAssignmentRepoByName(ctx *context.APIContext, ownerName string, repoName string) {
+	// Get repository.
+	owner, err := user_model.GetUserByName(ctx, ownerName)
+	repo, err := repo_model.GetRepositoryByName(owner.ID, repoName)
+	if err != nil {
+		if repo_model.IsErrRepoNotExist(err) {
+			redirectRepoID, err := repo_model.LookupRedirect(repo.OwnerID, repo.Name)
+			if err == nil {
+				context.RedirectToRepo(ctx.Base, redirectRepoID)
+			} else if repo_model.IsErrRedirectNotExist(err) {
+				ctx.NotFound(ctx.Tr("repo.RepoNotFound", repo.OwnerID))
+			} else {
+				ctx.Error(http.StatusInternalServerError, "LookupRepoRedirect", err)
+			}
+		} else {
+			ctx.Error(http.StatusInternalServerError, "GetRepositoryByID", err)
+		}
+		return
+	}
+	ctx.Repo.Repository = repo
+}
+
+// UpdateDelegateHooks creates all the hooks scripts for the repo
+func UpdateDelegateHooks(repoPath string) (err error) {
+	hookNames, hookTpls, giteaHookTpls := getHookTemplates()
+	hookDir := filepath.Join(repoPath, "hooks")
+
+	for i, hookName := range hookNames {
+		oldHookPath := filepath.Join(hookDir, hookName)
+		newHookPath := filepath.Join(hookDir, hookName+".d", "gitea")
+
+		if err := os.MkdirAll(filepath.Join(hookDir, hookName+".d"), os.ModePerm); err != nil {
+			return fmt.Errorf("create hooks dir '%s': %w", filepath.Join(hookDir, hookName+".d"), err)
+		}
+
+		// WARNING: This will override all old server-side hooks
+		if err = util.Remove(oldHookPath); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("unable to pre-remove old hook file '%s' prior to rewriting: %w ", oldHookPath, err)
+		}
+		if err = os.WriteFile(oldHookPath, []byte(hookTpls[i]), 0o777); err != nil {
+			return fmt.Errorf("write old hook file '%s': %w", oldHookPath, err)
+		}
+
+		if err = ensureExecutable(oldHookPath); err != nil {
+			return fmt.Errorf("Unable to set %s executable. Error %w", oldHookPath, err)
+		}
+
+		if err = util.Remove(newHookPath); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("unable to pre-remove new hook file '%s' prior to rewriting: %w", newHookPath, err)
+		}
+		if err = os.WriteFile(newHookPath, []byte(giteaHookTpls[i]), 0o777); err != nil {
+			return fmt.Errorf("write new hook file '%s': %w", newHookPath, err)
+		}
+
+		if err = ensureExecutable(newHookPath); err != nil {
+			return fmt.Errorf("Unable to set %s executable. Error %w", oldHookPath, err)
+		}
+	}
+
+	return nil
+}
+
+func getHookTemplates() (hookNames, hookTpls, giteaHookTpls []string) {
+	hookNames = []string{"pre-receive", "update", "post-receive"}
+	hookTpls = []string{
+		// for pre-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+data=$(cat)
+exitcodes=""
+hookname=$(basename $0)
+GIT_DIR=${GIT_DIR:-$(dirname $0)/..}
+
+for hook in ${GIT_DIR}/hooks/${hookname}.d/*; do
+  test -x "${hook}" && test -f "${hook}"
+  echo "${data}" | "${hook}"
+  exitcodes="${exitcodes} $?"
+done
+
+for i in ${exitcodes}; do
+  [ ${i} -eq 0 ] || exit ${i}
+done
+`, setting.ScriptType),
+
+		// for update
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+exitcodes=""
+hookname=$(basename $0)
+GIT_DIR=${GIT_DIR:-$(dirname $0/..)}
+
+for hook in ${GIT_DIR}/hooks/${hookname}.d/*; do
+  test -x "${hook}" && test -f "${hook}"
+  "${hook}" $1 $2 $3
+  exitcodes="${exitcodes} $?"
+done
+
+for i in ${exitcodes}; do
+  [ ${i} -eq 0 ] || exit ${i}
+done
+`, setting.ScriptType),
+
+		// for post-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+data=$(cat)
+exitcodes=""
+hookname=$(basename $0)
+GIT_DIR=${GIT_DIR:-$(dirname $0)/..}
+
+for hook in ${GIT_DIR}/hooks/${hookname}.d/*; do
+  test -x "${hook}" && test -f "${hook}"
+  echo "${data}" | "${hook}"
+  exitcodes="${exitcodes} $?"
+done
+
+for i in ${exitcodes}; do
+  [ ${i} -eq 0 ] || exit ${i}
+done
+`, setting.ScriptType),
+	}
+
+	giteaHookTpls = []string{
+		// for pre-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s pre-receive
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)),
+
+		// for update
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s update $1 $2 $3
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)),
+
+		// for post-receive
+		fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s post-receive
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)),
+	}
+
+	if git.SupportProcReceive {
+		hookNames = append(hookNames, "proc-receive")
+		hookTpls = append(hookTpls,
+			fmt.Sprintf(`#!/usr/bin/env %s
+# AUTO GENERATED BY GITEA, DO NOT MODIFY
+%s hook --config=%s proc-receive
+`, setting.ScriptType, util.ShellEscape(setting.AppPath), util.ShellEscape(setting.CustomConf)))
+		giteaHookTpls = append(giteaHookTpls, "")
+	}
+
+	return hookNames, hookTpls, giteaHookTpls
+}
+
+func generateHookScriptPath(hookDir, hookName, fileName string) string {
+	return filepath.Join(hookDir, hookName+".d", fileName)
+}
+
+func checkHookFile(filePath, tpl string, results []string) error {
+	if tpl == "" {
+		return nil
+	}
+	contents, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return err
+	}
+	if string(contents) != tpl {
+		results = append(results, fmt.Sprintf("old hook file %s is out of date", filePath))
+	}
+	if !checkExecutable(filePath) {
+		results = append(results, fmt.Sprintf("old hook file %s is not executable", filePath))
+	}
+	return nil
+}
+
+func writeHookTpl(hookPath, content string) error {
+	if content == "" {
+		return nil
+	}
+	if err := ioutil.WriteFile(hookPath, []byte(content), 0777); err != nil {
+		return fmt.Errorf("write new hook file '%s': %v", hookPath, err)
+	}
+
+	if err := ensureExecutable(hookPath); err != nil {
+		return fmt.Errorf("Unable to set %s executable. Error %v", hookPath, err)
+	}
+	return nil
+}
+
+func checkExecutable(filename string) bool {
+	fileInfo, err := os.Stat(filename)
+	if err != nil {
+		return false
+	}
+	return (fileInfo.Mode() & 0100) > 0
+}
+
+func ensureExecutable(filename string) error {
+	fileInfo, err := os.Stat(filename)
+	if err != nil {
+		return err
+	}
+	if (fileInfo.Mode() & 0100) > 0 {
+		return nil
+	}
+	mode := fileInfo.Mode() | 0100
+	return os.Chmod(filename, mode)
+}

routers/hat/repo/wiki.go

@@ -2,12 +2,15 @@ package repo
 
 import (
 	"net/http"
+	"net/url"
 
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/modules/context"
 	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/setting"
 	api "code.gitea.io/gitea/modules/structs"
 	util "code.gitea.io/gitea/modules/util"
+	"code.gitea.io/gitea/services/convert"
 	wiki_service "code.gitea.io/gitea/services/wiki"
 )
 
@@ -73,3 +76,110 @@ func ListWikiPageNames(ctx *context.APIContext) {
 	ctx.SetTotalCountHeader(int64(len(entries)))
 	ctx.JSON(http.StatusOK, pages)
 }
+
+func ShowRevision(ctx *context.APIContext) {
+	wikiRepo, err := git.OpenRepository(ctx, ctx.Repo.Repository.WikiPath())
+	if err != nil {
+		if git.IsErrNotExist(err) || err.Error() == "no such file or directory" {
+			ctx.NotFound(err)
+		} else {
+			ctx.Error(http.StatusInternalServerError, "OpenRepository", err)
+		}
+		return
+	}
+
+	if wikiRepo != nil {
+
+		defer wikiRepo.Close()
+	}
+
+	// get requested pagename
+	pageName := wiki_service.WebPathFromRequest(ctx.PathParamRaw(":pageName"))
+	if len(pageName) == 0 {
+		pageName = "Home"
+	}
+
+	revision := ctx.PathParamRaw(":revision")
+
+	commit, err := wikiRepo.GetCommit(revision)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "GetCommit", err)
+		return
+	}
+
+	content, pageFilename := wikiContentsByName(ctx, commit, pageName, false)
+
+	sidebarContent, _ := wikiContentsByName(ctx, commit, "_Sidebar", true)
+
+	footerContent, _ := wikiContentsByName(ctx, commit, "_Footer", true)
+
+	// get commit count - wiki revisions
+	commitsCount, _ := wikiRepo.FileCommitsCount("master", pageFilename)
+
+	// Get last change information.
+	lastCommit, err := wikiRepo.GetCommitByPath(pageFilename)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "GetCommitByPath", err)
+		return
+	}
+
+	ctx.JSON(http.StatusOK, &api.WikiPage{
+		WikiPageMetaData: convert.ToWikiPageMetaData(pageName, lastCommit, ctx.Repo.Repository),
+		ContentBase64:    content,
+		CommitCount:      commitsCount,
+		Sidebar:          sidebarContent,
+		Footer:           footerContent,
+	})
+
+}
+
+// findEntryForFile finds the tree entry for a target filepath.
+func findEntryForFile(commit *git.Commit, target string) (*git.TreeEntry, error) {
+	entry, err := commit.GetTreeEntryByPath(target)
+	if err != nil {
+		return nil, err
+	}
+	if entry != nil {
+		return entry, nil
+	}
+
+	// Then the unescaped, shortest alternative
+	var unescapedTarget string
+	if unescapedTarget, err = url.QueryUnescape(target); err != nil {
+		return nil, err
+	}
+	return commit.GetTreeEntryByPath(unescapedTarget)
+}
+
+// wikiContentsByEntry returns the contents of the wiki page referenced by the
+// given tree entry, encoded with base64. Writes to ctx if an error occurs.
+func wikiContentsByEntry(ctx *context.APIContext, entry *git.TreeEntry) string {
+	blob := entry.Blob()
+	if blob.Size() > setting.API.DefaultMaxBlobSize {
+		return ""
+	}
+	content, err := blob.GetBlobContentBase64()
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "GetBlobContentBase64", err)
+		return ""
+	}
+	return content
+}
+
+// wikiContentsByName returns the contents of a wiki page, along with a boolean
+// indicating whether the page exists. Writes to ctx if an error occurs.
+func wikiContentsByName(ctx *context.APIContext, commit *git.Commit, wikiName wiki_service.WebPath, isSidebarOrFooter bool) (string, string) {
+	gitFilename := wiki_service.WebPathToGitPath(wikiName)
+	entry, err := findEntryForFile(commit, gitFilename)
+	if err != nil {
+		if git.IsErrNotExist(err) {
+			if !isSidebarOrFooter {
+				ctx.NotFound()
+			}
+		} else {
+			ctx.ServerError("findEntryForFile", err)
+		}
+		return "", ""
+	}
+	return wikiContentsByEntry(ctx, entry), gitFilename
+}

routers/hat/user/user.go

@@ -1,10 +1,18 @@
 package user
 
 import (
+	"fmt"
+	"math"
 	"net/http"
+	"strconv"
+
+	repo_model "code.gitea.io/gitea/models/repo"
 
 	"code.gitea.io/gitea/modules/context"
+	code_indexer "code.gitea.io/gitea/modules/indexer/code"
+	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/timeutil"
+
 	hat_activities_models "code.gitlink.org.cn/Gitlink/gitea_hat.git/models/activities"
 )
 
@@ -25,3 +33,91 @@ func GetUserHeatmapData(ctx *context.APIContext) {
 	ctx.JSON(http.StatusOK, heatmap)
 
 }
+
+func Code(ctx *context.APIContext) {
+	language := ctx.FormString("language")
+	keyword := ctx.FormString("keyword")
+	queryType := ctx.FormString("query_type")
+	isMatch := queryType == "match"
+
+	page := ctx.FormInt("page")
+	if page <= 0 {
+		page = 1
+	}
+
+	var (
+		repoIDs []int64
+		err     error
+	)
+
+	repoIDs, err = repo_model.FindUserCodeAccessibleOwnerRepoIDs(ctx, ctx.ContextUser.ID, ctx.Doer)
+	if err != nil {
+		ctx.Error(http.StatusInternalServerError, "FindUserCodeAccessibleOwnerRepoIDs", err)
+		return
+	}
+
+	var (
+		total                 int
+		searchResults         []*code_indexer.Result
+		searchResultLanguages []*code_indexer.SearchResultLanguages
+	)
+
+	var codeIndexerUnavailable bool
+	var repoMaps map[int64]*repo_model.Repository
+
+	if len(repoIDs) > 0 {
+		total, searchResults, searchResultLanguages, err = code_indexer.PerformSearch(ctx, repoIDs, language, keyword, page, setting.UI.RepoSearchPagingNum, isMatch)
+		if err != nil {
+			if code_indexer.IsAvailable(ctx) {
+				ctx.Error(http.StatusInternalServerError, "SearchResults", err)
+				return
+			}
+			codeIndexerUnavailable = true
+		} else {
+			codeIndexerUnavailable = !code_indexer.IsAvailable(ctx)
+		}
+
+		loadRepoIDs := make([]int64, 0, len(searchResults))
+		for _, result := range searchResults {
+			var find bool
+			for _, id := range loadRepoIDs {
+				if id == result.RepoID {
+					find = true
+					break
+				}
+			}
+			if !find {
+				loadRepoIDs = append(loadRepoIDs, result.RepoID)
+			}
+		}
+
+		repoMaps, err := repo_model.GetRepositoriesMapByIDs(loadRepoIDs)
+		if err != nil {
+			ctx.Error(http.StatusInternalServerError, "GetRepositoriesMapByIDs", err)
+			return
+		}
+
+		repoMaps = repoMaps
+	}
+
+	pageCount := int(math.Ceil(float64(total) / float64(setting.UI.RepoSearchPagingNum)))
+	ctx.Resp.Header().Set("X-Page", strconv.Itoa(page))
+	ctx.Resp.Header().Set("X-PerPage", strconv.Itoa(setting.UI.RepoSearchPagingNum))
+	ctx.Resp.Header().Set("X-Total", strconv.FormatInt(int64(total), 10))
+	ctx.Resp.Header().Set("X-PageCount", strconv.Itoa(pageCount))
+	ctx.Resp.Header().Set("X-HasMore", strconv.FormatBool(page < pageCount))
+
+	ctx.SetLinkHeader(int(total), setting.UI.RepoSearchPagingNum)
+	ctx.Resp.Header().Set("X-Total-Count", fmt.Sprintf("%d", total))
+	ctx.JSON(http.StatusOK, struct {
+		CodeIndexerUnavailable bool
+		RepoMaps               map[int64]*repo_model.Repository
+		SearchResults          []*code_indexer.Result
+		SearchResultLanguages  []*code_indexer.SearchResultLanguages
+	}{
+		CodeIndexerUnavailable: codeIndexerUnavailable,
+		RepoMaps:               repoMaps,
+		SearchResults:          searchResults,
+		SearchResultLanguages:  searchResultLanguages,
+	})
+}

routers/hat/web/web.go

@@ -282,8 +282,10 @@ func registerRoutes(m *web.Route) {
 	reqSignIn := verifyAuthWithOptions(&common.VerifyOptions{SignInRequired: true})
 	reqSignOut := verifyAuthWithOptions(&common.VerifyOptions{SignOutRequired: true})
 	// TODO: rename them to "optSignIn", which means that the "sign-in" could be optional, depends on the VerifyOptions (RequireSignInView)
-	ignSignIn := verifyAuthWithOptions(&common.VerifyOptions{SignInRequired: setting.Service.RequireSignInView})
+	//ignSignIn := verifyAuthWithOptions(&common.VerifyOptions{SignInRequired: setting.Service.RequireSignInView})
+	ignSignIn := verifyAuthWithOptions(&common.VerifyOptions{SignInRequired: setting.Service.Explore.RequireSigninView})
 	ignExploreSignIn := verifyAuthWithOptions(&common.VerifyOptions{SignInRequired: setting.Service.RequireSignInView || setting.Service.Explore.RequireSigninView})
+	//ignExploreSignIn := verifyAuthWithOptions(&common.VerifyOptions{SignInRequired: true})
 
 	validation.AddBindingRules()
 

routers/init.go

@@ -21,6 +21,7 @@ import (
 	"code.gitlink.org.cn/Gitlink/gitea_hat.git/models/migrations"
 	api_hat "code.gitlink.org.cn/Gitlink/gitea_hat.git/routers/hat"
 	web_routers "code.gitlink.org.cn/Gitlink/gitea_hat.git/routers/hat/web"
+	hat_mirror_service "code.gitlink.org.cn/Gitlink/gitea_hat.git/services/mirror"
 	hat_pull_service "code.gitlink.org.cn/Gitlink/gitea_hat.git/services/pull"
 )
 
@@ -45,7 +46,7 @@ func mustInitCtx(ctx context.Context, fn func(ctx context.Context) error) {
 func GlobalInitInstalled(ctx context.Context) {
 	mustInitCtx(ctx, InitDBEngine)
 	mustInit(hat_pull_service.Init)
-
+	mustInit(hat_mirror_service.InitSyncMirrors)
 }
 
 func InitDBEngine(ctx context.Context) (err error) {

services/actions/secrets.go

@@ -0,0 +1,105 @@
+package actions
+
+import (
+	"context"
+	"regexp"
+	"strings"
+	"sync"
+
+	secret_model "code.gitea.io/gitea/models/secret"
+	hat_actions_model "code.gitlink.org.cn/Gitlink/gitea_hat.git/models/actions"
+
+	"code.gitea.io/gitea/modules/util"
+)
+
+var globalVars = sync.OnceValue(func() (ret struct {
+	namePattern, forbiddenPrefixPattern *regexp.Regexp
+},
+) {
+	ret.namePattern = regexp.MustCompile("(?i)^[A-Z_][A-Z0-9_]*$")
+	ret.forbiddenPrefixPattern = regexp.MustCompile("(?i)^GIT(EA|HUB)_")
+	return ret
+})
+
+func ValidateName(name string) error {
+	vars := globalVars()
+	if !vars.namePattern.MatchString(name) ||
+		vars.forbiddenPrefixPattern.MatchString(name) ||
+		strings.EqualFold(name, "CI") /* CI is always set to true in GitHub Actions*/ {
+		return util.NewInvalidArgumentErrorf("invalid variable or secret name")
+	}
+	return nil
+}
+
+func CreateSecret(ctx context.Context, ownerID, repoID int64, name, data string) (*secret_model.Secret, error) {
+	if err := ValidateName(name); err != nil {
+		return nil, err
+	}
+
+	s, err := secret_model.InsertEncryptedSecret(ctx, ownerID, repoID, name, data)
+	if err != nil {
+		return nil, err
+	}
+
+	return s, nil
+}
+
+func UpdateSecret(ctx context.Context, ownerID, repoID int64, name, data string) (bool, error) {
+	if err := ValidateName(name); err != nil {
+		return false, err
+	}
+
+	s, err := GetSecret(ctx, hat_actions_model.FindSecretsOptions{
+		OwnerID: ownerID,
+		RepoID:  repoID,
+		Name:    name,
+	})
+	if err != nil {
+		return false, err
+	}
+
+	if s == nil {
+		return false, util.NewNotExistErrorf("secret not found")
+	}
+
+	err = secret_model.UpdateSecret(ctx, s.ID, data)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+func GetSecret(ctx context.Context, opts hat_actions_model.FindSecretsOptions) (*secret_model.Secret, error) {
+	vars, err := hat_actions_model.FindSecrets(ctx, opts)
+	if err != nil {
+		return nil, err
+	}
+	if len(vars) != 1 {
+		return nil, util.NewNotExistErrorf("variable not found")
+	}
+	return vars[0], nil
+}
+
+func DeleteSecretByName(ctx context.Context, ownerID, repoID int64, name string) error {
+	s, err := GetSecret(ctx, hat_actions_model.FindSecretsOptions{
+		OwnerID: ownerID,
+		RepoID:  repoID,
+		Name:    name,
+	})
+	if err != nil {
+		return err
+	}
+
+	return hat_actions_model.DeleteSecret(ctx, s)
+}
+
+func DeleteSecretByID(ctx context.Context, secretID int64) error {
+	s, err := GetSecret(ctx, hat_actions_model.FindSecretsOptions{
+		SecretID: secretID,
+	})
+	if err != nil {
+		return err
+	}
+	return hat_actions_model.DeleteSecret(ctx, s)
+}

services/actions/variables.go

@@ -0,0 +1,69 @@
+package actions
+
+import (
+	"context"
+
+	actions_model "code.gitea.io/gitea/models/actions"
+	"code.gitea.io/gitea/modules/util"
+
+	secret_service "code.gitea.io/gitea/services/secrets"
+	hat_actions_model "code.gitlink.org.cn/Gitlink/gitea_hat.git/models/actions"
+	hat_util "code.gitlink.org.cn/Gitlink/gitea_hat.git/modules/util"
+)
+
+func CreateVariable(ctx context.Context, ownerID, repoID int64, name, data string) (*actions_model.ActionVariable, error) {
+	if err := secret_service.ValidateName(name); err != nil {
+		return nil, err
+	}
+
+	v, err := actions_model.InsertVariable(ctx, ownerID, repoID, name, hat_util.ReserveLineBreakForTextarea(data))
+	if err != nil {
+		return nil, err
+	}
+
+	return v, nil
+}
+
+func UpdateVariableNameData(ctx context.Context, variable *actions_model.ActionVariable) (bool, error) {
+	if err := secret_service.ValidateName(variable.Name); err != nil {
+		return false, err
+	}
+
+	variable.Data = hat_util.ReserveLineBreakForTextarea(variable.Data)
+
+	return actions_model.UpdateVariable(ctx, variable)
+}
+
+func DeleteVariableByID(ctx context.Context, variableID int64) error {
+	v, err := GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		IDs: []int64{variableID},
+	})
+	if err != nil {
+		return err
+	}
+	return hat_actions_model.DeleteVariable(ctx, v)
+}
+
+func DeleteVariableByName(ctx context.Context, ownerID, repoID int64, name string) error {
+	v, err := GetVariable(ctx, hat_actions_model.FindVariablesOpts{
+		OwnerID: ownerID,
+		RepoID:  repoID,
+		Name:    name,
+	})
+	if err != nil {
+		return err
+	}
+
+	return hat_actions_model.DeleteVariable(ctx, v)
+}
+
+func GetVariable(ctx context.Context, opts hat_actions_model.FindVariablesOpts) (*actions_model.ActionVariable, error) {
+	vars, err := hat_actions_model.FindVariables(ctx, opts)
+	if err != nil {
+		return nil, err
+	}
+	if len(vars) != 1 {
+		return nil, util.NewNotExistErrorf("variable not found")
+	}
+	return vars[0], nil
+}

services/mirror/mirror.go

@@ -0,0 +1,133 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package mirror
+
+import (
+	"context"
+	"fmt"
+
+	repo_model "code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/modules/graceful"
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/queue"
+	"code.gitea.io/gitea/modules/setting"
+)
+
+// doMirrorSync causes this request to mirror itself
+func doMirrorSync(ctx context.Context, req *SyncRequest) {
+	if req.ReferenceID == 0 {
+		log.Warn("Skipping mirror sync request, no mirror ID was specified")
+		return
+	}
+	switch req.Type {
+	case PushMirrorType:
+		_ = SyncPushMirror(ctx, req.ReferenceID)
+	case PullMirrorType:
+		_ = SyncPullMirror(ctx, req.ReferenceID, req.DelOldBranches)
+	default:
+		log.Error("Unknown Request type in queue: %v for MirrorID[%d]", req.Type, req.ReferenceID)
+	}
+}
+
+var errLimit = fmt.Errorf("reached limit")
+
+// Update checks and updates mirror repositories.
+func Update(ctx context.Context, pullLimit, pushLimit int) error {
+	if !setting.Mirror.Enabled {
+		log.Warn("Mirror feature disabled, but cron job enabled: skip update")
+		return nil
+	}
+	log.Trace("Doing: Update")
+
+	handler := func(idx int, bean any) error {
+		var repo *repo_model.Repository
+		var mirrorType SyncType
+		var referenceID int64
+
+		if m, ok := bean.(*repo_model.Mirror); ok {
+			if m.GetRepository(ctx) == nil {
+				log.Error("Disconnected mirror found: %d", m.ID)
+				return nil
+			}
+			repo = m.Repo
+			mirrorType = PullMirrorType
+			referenceID = m.RepoID
+		} else if m, ok := bean.(*repo_model.PushMirror); ok {
+			if m.GetRepository() == nil {
+				log.Error("Disconnected push-mirror found: %d", m.ID)
+				return nil
+			}
+			repo = m.Repo
+			mirrorType = PushMirrorType
+			referenceID = m.ID
+		} else {
+			log.Error("Unknown bean: %v", bean)
+			return nil
+		}
+
+		// Check we've not been cancelled
+		select {
+		case <-ctx.Done():
+			return fmt.Errorf("aborted")
+		default:
+		}
+
+		// Push to the Queue
+		if err := PushToQueue(mirrorType, referenceID, (mirrorType == PullMirrorType)); err != nil {
+			if err == queue.ErrAlreadyInQueue {
+				if mirrorType == PushMirrorType {
+					log.Trace("PushMirrors for %-v already queued for sync", repo)
+				} else {
+					log.Trace("PullMirrors for %-v already queued for sync", repo)
+				}
+				return nil
+			}
+			return err
+		}
+		return nil
+	}
+
+	pullMirrorsRequested := 0
+	if pullLimit != 0 {
+		if err := repo_model.MirrorsIterate(ctx, pullLimit, func(idx int, bean any) error {
+			if err := handler(idx, bean); err != nil {
+				return err
+			}
+			pullMirrorsRequested++
+			return nil
+		}); err != nil && err != errLimit {
+			log.Error("MirrorsIterate: %v", err)
+			return err
+		}
+	}
+
+	pushMirrorsRequested := 0
+	if pushLimit != 0 {
+		if err := repo_model.PushMirrorsIterate(ctx, pushLimit, func(idx int, bean any) error {
+			if err := handler(idx, bean); err != nil {
+				return err
+			}
+			pushMirrorsRequested++
+			return nil
+		}); err != nil && err != errLimit {
+			log.Error("PushMirrorsIterate: %v", err)
+			return err
+		}
+	}
+	log.Trace("Finished: Update: %d pull mirrors and %d push mirrors queued", pullMirrorsRequested, pushMirrorsRequested)
+	return nil
+}
+
+func queueHandler(items ...*SyncRequest) []*SyncRequest {
+	for _, req := range items {
+		doMirrorSync(graceful.GetManager().ShutdownContext(), req)
+	}
+	return nil
+}
+
+// InitSyncMirrors initializes a go routine to sync the mirrors
+func InitSyncMirrors() error {
+	StartSyncMirrors(queueHandler)
+	return nil
+}

services/mirror/mirror_pull.go

@@ -0,0 +1,615 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package mirror
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"code.gitea.io/gitea/models/db"
+	repo_model "code.gitea.io/gitea/models/repo"
+	system_model "code.gitea.io/gitea/models/system"
+	"code.gitea.io/gitea/modules/cache"
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/lfs"
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/process"
+	"code.gitea.io/gitea/modules/proxy"
+	repo_module "code.gitea.io/gitea/modules/repository"
+	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/timeutil"
+	"code.gitea.io/gitea/modules/util"
+	notify_service "code.gitea.io/gitea/services/notify"
+	hat_repo_module "code.gitlink.org.cn/Gitlink/gitea_hat.git/modules/repository"
+)
+
+// gitShortEmptySha Git short empty SHA
+const gitShortEmptySha = "0000000"
+
+// UpdateAddress writes new address to Git repository and database
+func UpdateAddress(ctx context.Context, m *repo_model.Mirror, addr string) error {
+	remoteName := m.GetRemoteName()
+	repoPath := m.GetRepository(ctx).RepoPath()
+	// Remove old remote
+	_, _, err := git.NewCommand(ctx, "remote", "rm").AddDynamicArguments(remoteName).RunStdString(&git.RunOpts{Dir: repoPath})
+	if err != nil && !strings.HasPrefix(err.Error(), "exit status 128 - fatal: No such remote ") {
+		return err
+	}
+
+	cmd := git.NewCommand(ctx, "remote", "add").AddDynamicArguments(remoteName).AddArguments("--mirror=fetch").AddDynamicArguments(addr)
+	if strings.Contains(addr, "://") && strings.Contains(addr, "@") {
+		cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=fetch %s [repo_path: %s]", remoteName, util.SanitizeCredentialURLs(addr), repoPath))
+	} else {
+		cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=fetch %s [repo_path: %s]", remoteName, addr, repoPath))
+	}
+	_, _, err = cmd.RunStdString(&git.RunOpts{Dir: repoPath})
+	if err != nil && !strings.HasPrefix(err.Error(), "exit status 128 - fatal: No such remote ") {
+		return err
+	}
+
+	if m.Repo.HasWiki() {
+		wikiPath := m.Repo.WikiPath()
+		wikiRemotePath := repo_module.WikiRemoteURL(ctx, addr)
+		// Remove old remote of wiki
+		_, _, err = git.NewCommand(ctx, "remote", "rm").AddDynamicArguments(remoteName).RunStdString(&git.RunOpts{Dir: wikiPath})
+		if err != nil && !strings.HasPrefix(err.Error(), "exit status 128 - fatal: No such remote ") {
+			return err
+		}
+
+		cmd = git.NewCommand(ctx, "remote", "add").AddDynamicArguments(remoteName).AddArguments("--mirror=fetch").AddDynamicArguments(wikiRemotePath)
+		if strings.Contains(wikiRemotePath, "://") && strings.Contains(wikiRemotePath, "@") {
+			cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=fetch %s [repo_path: %s]", remoteName, util.SanitizeCredentialURLs(wikiRemotePath), wikiPath))
+		} else {
+			cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=fetch %s [repo_path: %s]", remoteName, wikiRemotePath, wikiPath))
+		}
+		_, _, err = cmd.RunStdString(&git.RunOpts{Dir: wikiPath})
+		if err != nil && !strings.HasPrefix(err.Error(), "exit status 128 - fatal: No such remote ") {
+			return err
+		}
+	}
+
+	m.Repo.OriginalURL = addr
+	return repo_model.UpdateRepositoryCols(ctx, m.Repo, "original_url")
+}
+
+// mirrorSyncResult contains information of a updated reference.
+// If the oldCommitID is "0000000", it means a new reference, the value of newCommitID is empty.
+// If the newCommitID is "0000000", it means the reference is deleted, the value of oldCommitID is empty.
+type mirrorSyncResult struct {
+	refName     git.RefName
+	oldCommitID string
+	newCommitID string
+}
+
+// parseRemoteUpdateOutput detects create, update and delete operations of references from upstream.
+// possible output example:
+/*
+// * [new tag]         v0.1.8     -> v0.1.8
+// * [new branch]      master     -> origin/master
+// - [deleted]         (none)     -> origin/test // delete a branch
+// - [deleted]         (none)     -> 1 // delete a tag
+//   957a993..a87ba5f  test       -> origin/test
+// + f895a1e...957a993 test       -> origin/test  (forced update)
+*/
+// TODO: return whether it's a force update
+func parseRemoteUpdateOutput(output, remoteName string) []*mirrorSyncResult {
+	results := make([]*mirrorSyncResult, 0, 3)
+	lines := strings.Split(output, "\n")
+	for i := range lines {
+		// Make sure reference name is presented before continue
+		idx := strings.Index(lines[i], "-> ")
+		if idx == -1 {
+			continue
+		}
+
+		refName := strings.TrimSpace(lines[i][idx+3:])
+
+		switch {
+		case strings.HasPrefix(lines[i], " * [new tag]"): // new tag
+			results = append(results, &mirrorSyncResult{
+				refName:     git.RefNameFromTag(refName),
+				oldCommitID: gitShortEmptySha,
+			})
+		case strings.HasPrefix(lines[i], " * [new branch]"): // new branch
+			refName = strings.TrimPrefix(refName, remoteName+"/")
+			results = append(results, &mirrorSyncResult{
+				refName:     git.RefNameFromBranch(refName),
+				oldCommitID: gitShortEmptySha,
+			})
+		case strings.HasPrefix(lines[i], " - "): // Delete reference
+			isTag := !strings.HasPrefix(refName, remoteName+"/")
+			var refFullName git.RefName
+			if isTag {
+				refFullName = git.RefNameFromTag(refName)
+			} else {
+				refFullName = git.RefNameFromBranch(strings.TrimPrefix(refName, remoteName+"/"))
+			}
+			results = append(results, &mirrorSyncResult{
+				refName:     refFullName,
+				newCommitID: gitShortEmptySha,
+			})
+		case strings.HasPrefix(lines[i], " + "): // Force update
+			if idx := strings.Index(refName, " "); idx > -1 {
+				refName = refName[:idx]
+			}
+			delimIdx := strings.Index(lines[i][3:], " ")
+			if delimIdx == -1 {
+				log.Error("SHA delimiter not found: %q", lines[i])
+				continue
+			}
+			shas := strings.Split(lines[i][3:delimIdx+3], "...")
+			if len(shas) != 2 {
+				log.Error("Expect two SHAs but not what found: %q", lines[i])
+				continue
+			}
+			results = append(results, &mirrorSyncResult{
+				refName:     git.RefNameFromBranch(strings.TrimPrefix(refName, remoteName+"/")),
+				oldCommitID: shas[0],
+				newCommitID: shas[1],
+			})
+		case strings.HasPrefix(lines[i], "   "): // New commits of a reference
+			delimIdx := strings.Index(lines[i][3:], " ")
+			if delimIdx == -1 {
+				log.Error("SHA delimiter not found: %q", lines[i])
+				continue
+			}
+			shas := strings.Split(lines[i][3:delimIdx+3], "..")
+			if len(shas) != 2 {
+				log.Error("Expect two SHAs but not what found: %q", lines[i])
+				continue
+			}
+			results = append(results, &mirrorSyncResult{
+				refName:     git.RefNameFromBranch(strings.TrimPrefix(refName, remoteName+"/")),
+				oldCommitID: shas[0],
+				newCommitID: shas[1],
+			})
+
+		default:
+			log.Warn("parseRemoteUpdateOutput: unexpected update line %q", lines[i])
+		}
+	}
+	return results
+}
+
+func pruneBrokenReferences(ctx context.Context,
+	m *repo_model.Mirror,
+	repoPath string,
+	timeout time.Duration,
+	stdoutBuilder, stderrBuilder *strings.Builder,
+	isWiki bool,
+) error {
+	wiki := ""
+	if isWiki {
+		wiki = "Wiki "
+	}
+
+	stderrBuilder.Reset()
+	stdoutBuilder.Reset()
+	pruneErr := git.NewCommand(ctx, "remote", "prune").AddDynamicArguments(m.GetRemoteName()).
+		SetDescription(fmt.Sprintf("Mirror.runSync %ssPrune references: %s ", wiki, m.Repo.FullName())).
+		Run(&git.RunOpts{
+			Timeout: timeout,
+			Dir:     repoPath,
+			Stdout:  stdoutBuilder,
+			Stderr:  stderrBuilder,
+		})
+	if pruneErr != nil {
+		stdout := stdoutBuilder.String()
+		stderr := stderrBuilder.String()
+
+		// sanitize the output, since it may contain the remote address, which may
+		// contain a password
+		stderrMessage := util.SanitizeCredentialURLs(stderr)
+		stdoutMessage := util.SanitizeCredentialURLs(stdout)
+
+		log.Error("Failed to prune mirror repository %s%-v references:\nStdout: %s\nStderr: %s\nErr: %v", wiki, m.Repo, stdoutMessage, stderrMessage, pruneErr)
+		desc := fmt.Sprintf("Failed to prune mirror repository %s'%s' references: %s", wiki, repoPath, stderrMessage)
+		if err := system_model.CreateRepositoryNotice(desc); err != nil {
+			log.Error("CreateRepositoryNotice: %v", err)
+		}
+		// this if will only be reached on a successful prune so try to get the mirror again
+	}
+	return pruneErr
+}
+
+// runSync returns true if sync finished without error.
+func runSync(ctx context.Context, m *repo_model.Mirror, delOldBranches bool) ([]*mirrorSyncResult, bool) {
+	repoPath := m.Repo.RepoPath()
+	wikiPath := m.Repo.WikiPath()
+	timeout := time.Duration(setting.Git.Timeout.Mirror) * time.Second
+
+	log.Trace("SyncMirrors [repo: %-v]: running git remote update...", m.Repo)
+
+	// use fetch but not remote update because git fetch support --tags but remote update doesn't
+	cmd := git.NewCommand(ctx, "fetch")
+	if m.EnablePrune {
+		cmd.AddArguments("--prune")
+	}
+	cmd.AddArguments("--tags").AddDynamicArguments(m.GetRemoteName())
+
+	remoteURL, remoteErr := git.GetRemoteURL(ctx, repoPath, m.GetRemoteName())
+	if remoteErr != nil {
+		log.Error("SyncMirrors [repo: %-v]: GetRemoteAddress Error %v", m.Repo, remoteErr)
+		return nil, false
+	}
+
+	envs := proxy.EnvWithProxy(remoteURL.URL)
+
+	stdoutBuilder := strings.Builder{}
+	stderrBuilder := strings.Builder{}
+	if err := cmd.
+		SetDescription(fmt.Sprintf("Mirror.runSync: %s", m.Repo.FullName())).
+		Run(&git.RunOpts{
+			Timeout: timeout,
+			Dir:     repoPath,
+			Env:     envs,
+			Stdout:  &stdoutBuilder,
+			Stderr:  &stderrBuilder,
+		}); err != nil {
+		stdout := stdoutBuilder.String()
+		stderr := stderrBuilder.String()
+
+		// sanitize the output, since it may contain the remote address, which may contain a password
+		stderrMessage := util.SanitizeCredentialURLs(stderr)
+		stdoutMessage := util.SanitizeCredentialURLs(stdout)
+
+		// Now check if the error is a resolve reference due to broken reference
+		if strings.Contains(stderr, "unable to resolve reference") && strings.Contains(stderr, "reference broken") {
+			log.Warn("SyncMirrors [repo: %-v]: failed to update mirror repository due to broken references:\nStdout: %s\nStderr: %s\nErr: %v\nAttempting Prune", m.Repo, stdoutMessage, stderrMessage, err)
+			err = nil
+
+			// Attempt prune
+			pruneErr := pruneBrokenReferences(ctx, m, repoPath, timeout, &stdoutBuilder, &stderrBuilder, false)
+			if pruneErr == nil {
+				// Successful prune - reattempt mirror
+				stderrBuilder.Reset()
+				stdoutBuilder.Reset()
+				if err = cmd.
+					SetDescription(fmt.Sprintf("Mirror.runSync: %s", m.Repo.FullName())).
+					Run(&git.RunOpts{
+						Timeout: timeout,
+						Dir:     repoPath,
+						Stdout:  &stdoutBuilder,
+						Stderr:  &stderrBuilder,
+					}); err != nil {
+					stdout := stdoutBuilder.String()
+					stderr := stderrBuilder.String()
+
+					// sanitize the output, since it may contain the remote address, which may
+					// contain a password
+					stderrMessage = util.SanitizeCredentialURLs(stderr)
+					stdoutMessage = util.SanitizeCredentialURLs(stdout)
+				}
+			}
+		}
+
+		// If there is still an error (or there always was an error)
+		if err != nil {
+			log.Error("SyncMirrors [repo: %-v]: failed to update mirror repository:\nStdout: %s\nStderr: %s\nErr: %v", m.Repo, stdoutMessage, stderrMessage, err)
+			desc := fmt.Sprintf("Failed to update mirror repository '%s': %s", repoPath, stderrMessage)
+			if err = system_model.CreateRepositoryNotice(desc); err != nil {
+				log.Error("CreateRepositoryNotice: %v", err)
+			}
+			return nil, false
+		}
+	}
+	output := stderrBuilder.String()
+
+	if err := git.WriteCommitGraph(ctx, repoPath); err != nil {
+		log.Error("SyncMirrors [repo: %-v]: %v", m.Repo, err)
+	}
+
+	gitRepo, err := git.OpenRepository(ctx, repoPath)
+	if err != nil {
+		log.Error("SyncMirrors [repo: %-v]: failed to OpenRepository: %v", m.Repo, err)
+		return nil, false
+	}
+
+	log.Trace("SyncMirrors [repo: %-v]: syncing branches...", m.Repo)
+	if _, err = hat_repo_module.SyncRepoBranchesWithRepo(ctx, m.Repo, gitRepo, 0, delOldBranches); err != nil {
+		log.Error("SyncMirrors [repo: %-v]: failed to synchronize branches: %v", m.Repo, err)
+	}
+
+	log.Trace("SyncMirrors [repo: %-v]: syncing releases with tags...", m.Repo)
+	if err = repo_module.SyncReleasesWithTags(ctx, m.Repo, gitRepo); err != nil {
+		log.Error("SyncMirrors [repo: %-v]: failed to synchronize tags to releases: %v", m.Repo, err)
+	}
+
+	if m.LFS && setting.LFS.StartServer {
+		log.Trace("SyncMirrors [repo: %-v]: syncing LFS objects...", m.Repo)
+		endpoint := lfs.DetermineEndpoint(remoteURL.String(), m.LFSEndpoint)
+		lfsClient := lfs.NewClient(endpoint, nil)
+		if err = repo_module.StoreMissingLfsObjectsInRepository(ctx, m.Repo, gitRepo, lfsClient); err != nil {
+			log.Error("SyncMirrors [repo: %-v]: failed to synchronize LFS objects for repository: %v", m.Repo, err)
+		}
+	}
+	gitRepo.Close()
+
+	log.Trace("SyncMirrors [repo: %-v]: updating size of repository", m.Repo)
+	if err := repo_module.UpdateRepoSize(ctx, m.Repo); err != nil {
+		log.Error("SyncMirrors [repo: %-v]: failed to update size for mirror repository: %v", m.Repo, err)
+	}
+
+	if m.Repo.HasWiki() {
+		log.Trace("SyncMirrors [repo: %-v Wiki]: running git remote update...", m.Repo)
+		stderrBuilder.Reset()
+		stdoutBuilder.Reset()
+		if err := git.NewCommand(ctx, "remote", "update", "--prune").AddDynamicArguments(m.GetRemoteName()).
+			SetDescription(fmt.Sprintf("Mirror.runSync Wiki: %s ", m.Repo.FullName())).
+			Run(&git.RunOpts{
+				Timeout: timeout,
+				Dir:     wikiPath,
+				Stdout:  &stdoutBuilder,
+				Stderr:  &stderrBuilder,
+			}); err != nil {
+			stdout := stdoutBuilder.String()
+			stderr := stderrBuilder.String()
+
+			// sanitize the output, since it may contain the remote address, which may contain a password
+			stderrMessage := util.SanitizeCredentialURLs(stderr)
+			stdoutMessage := util.SanitizeCredentialURLs(stdout)
+
+			// Now check if the error is a resolve reference due to broken reference
+			if strings.Contains(stderrMessage, "unable to resolve reference") && strings.Contains(stderrMessage, "reference broken") {
+				log.Warn("SyncMirrors [repo: %-v Wiki]: failed to update mirror wiki repository due to broken references:\nStdout: %s\nStderr: %s\nErr: %v\nAttempting Prune", m.Repo, stdoutMessage, stderrMessage, err)
+				err = nil
+
+				// Attempt prune
+				pruneErr := pruneBrokenReferences(ctx, m, repoPath, timeout, &stdoutBuilder, &stderrBuilder, true)
+				if pruneErr == nil {
+					// Successful prune - reattempt mirror
+					stderrBuilder.Reset()
+					stdoutBuilder.Reset()
+
+					if err = git.NewCommand(ctx, "remote", "update", "--prune").AddDynamicArguments(m.GetRemoteName()).
+						SetDescription(fmt.Sprintf("Mirror.runSync Wiki: %s ", m.Repo.FullName())).
+						Run(&git.RunOpts{
+							Timeout: timeout,
+							Dir:     wikiPath,
+							Stdout:  &stdoutBuilder,
+							Stderr:  &stderrBuilder,
+						}); err != nil {
+						stdout := stdoutBuilder.String()
+						stderr := stderrBuilder.String()
+						stderrMessage = util.SanitizeCredentialURLs(stderr)
+						stdoutMessage = util.SanitizeCredentialURLs(stdout)
+					}
+				}
+			}
+
+			// If there is still an error (or there always was an error)
+			if err != nil {
+				log.Error("SyncMirrors [repo: %-v Wiki]: failed to update mirror repository wiki:\nStdout: %s\nStderr: %s\nErr: %v", m.Repo, stdoutMessage, stderrMessage, err)
+				desc := fmt.Sprintf("Failed to update mirror repository wiki '%s': %s", wikiPath, stderrMessage)
+				if err = system_model.CreateRepositoryNotice(desc); err != nil {
+					log.Error("CreateRepositoryNotice: %v", err)
+				}
+				return nil, false
+			}
+
+			if err := git.WriteCommitGraph(ctx, wikiPath); err != nil {
+				log.Error("SyncMirrors [repo: %-v]: %v", m.Repo, err)
+			}
+		}
+		log.Trace("SyncMirrors [repo: %-v Wiki]: git remote update complete", m.Repo)
+	}
+
+	log.Trace("SyncMirrors [repo: %-v]: invalidating mirror branch caches...", m.Repo)
+	branches, _, err := git.GetBranchesByPath(ctx, m.Repo.RepoPath(), 0, 0)
+	if err != nil {
+		log.Error("SyncMirrors [repo: %-v]: failed to GetBranches: %v", m.Repo, err)
+		return nil, false
+	}
+
+	for _, branch := range branches {
+		cache.Remove(m.Repo.GetCommitsCountCacheKey(branch.Name, true))
+	}
+
+	m.UpdatedUnix = timeutil.TimeStampNow()
+	return parseRemoteUpdateOutput(output, m.GetRemoteName()), true
+}
+
+// SyncPullMirror starts the sync of the pull mirror and schedules the next run.
+func SyncPullMirror(ctx context.Context, repoID int64, delOldBranches bool) bool {
+	log.Trace("SyncMirrors [repo_id: %v]", repoID)
+	defer func() {
+		err := recover()
+		if err == nil {
+			return
+		}
+		// There was a panic whilst syncMirrors...
+		log.Error("PANIC whilst SyncMirrors[repo_id: %d] Panic: %v\nStacktrace: %s", repoID, err, log.Stack(2))
+	}()
+
+	m, err := repo_model.GetMirrorByRepoID(ctx, repoID)
+	if err != nil {
+		log.Error("SyncMirrors [repo_id: %v]: unable to GetMirrorByRepoID: %v", repoID, err)
+		return false
+	}
+	_ = m.GetRepository(ctx) // force load repository of mirror
+
+	ctx, _, finished := process.GetManager().AddContext(ctx, fmt.Sprintf("Syncing Mirror %s/%s", m.Repo.OwnerName, m.Repo.Name))
+	defer finished()
+
+	log.Trace("SyncMirrors [repo: %-v]: Running Sync", m.Repo)
+	results, ok := runSync(ctx, m, delOldBranches)
+	if !ok {
+		if err = repo_model.TouchMirror(ctx, m); err != nil {
+			log.Error("SyncMirrors [repo: %-v]: failed to TouchMirror: %v", m.Repo, err)
+		}
+		return false
+	}
+
+	log.Trace("SyncMirrors [repo: %-v]: Scheduling next update", m.Repo)
+	m.ScheduleNextUpdate()
+	if err = repo_model.UpdateMirror(ctx, m); err != nil {
+		log.Error("SyncMirrors [repo: %-v]: failed to UpdateMirror with next update date: %v", m.Repo, err)
+		return false
+	}
+
+	var gitRepo *git.Repository
+	if len(results) == 0 {
+		log.Trace("SyncMirrors [repo: %-v]: no branches updated", m.Repo)
+	} else {
+		log.Trace("SyncMirrors [repo: %-v]: %d branches updated", m.Repo, len(results))
+		gitRepo, err = git.OpenRepository(ctx, m.Repo.RepoPath())
+		if err != nil {
+			log.Error("SyncMirrors [repo: %-v]: unable to OpenRepository: %v", m.Repo, err)
+			return false
+		}
+		defer gitRepo.Close()
+
+		if ok := checkAndUpdateEmptyRepository(m, gitRepo, results); !ok {
+			return false
+		}
+	}
+
+	for _, result := range results {
+		// Discard GitHub pull requests, i.e. refs/pull/*
+		if result.refName.IsPull() {
+			continue
+		}
+
+		// Create reference
+		if result.oldCommitID == gitShortEmptySha {
+			commitID, err := gitRepo.GetRefCommitID(result.refName.String())
+			if err != nil {
+				log.Error("SyncMirrors [repo: %-v]: unable to GetRefCommitID [ref_name: %s]: %v", m.Repo, result.refName, err)
+				continue
+			}
+			notify_service.SyncPushCommits(ctx, m.Repo.MustOwner(ctx), m.Repo, &repo_module.PushUpdateOptions{
+				RefFullName: result.refName,
+				OldCommitID: git.EmptySHA,
+				NewCommitID: commitID,
+			}, repo_module.NewPushCommits())
+			notify_service.SyncCreateRef(ctx, m.Repo.MustOwner(ctx), m.Repo, result.refName, commitID)
+			continue
+		}
+
+		// Delete reference
+		if result.newCommitID == gitShortEmptySha {
+			notify_service.SyncDeleteRef(ctx, m.Repo.MustOwner(ctx), m.Repo, result.refName)
+			continue
+		}
+
+		// Push commits
+		oldCommitID, err := git.GetFullCommitID(gitRepo.Ctx, gitRepo.Path, result.oldCommitID)
+		if err != nil {
+			log.Error("SyncMirrors [repo: %-v]: unable to get GetFullCommitID[%s]: %v", m.Repo, result.oldCommitID, err)
+			continue
+		}
+		newCommitID, err := git.GetFullCommitID(gitRepo.Ctx, gitRepo.Path, result.newCommitID)
+		if err != nil {
+			log.Error("SyncMirrors [repo: %-v]: unable to get GetFullCommitID [%s]: %v", m.Repo, result.newCommitID, err)
+			continue
+		}
+		commits, err := gitRepo.CommitsBetweenIDs(newCommitID, oldCommitID)
+		if err != nil {
+			log.Error("SyncMirrors [repo: %-v]: unable to get CommitsBetweenIDs [new_commit_id: %s, old_commit_id: %s]: %v", m.Repo, newCommitID, oldCommitID, err)
+			continue
+		}
+
+		theCommits := repo_module.GitToPushCommits(commits)
+		if len(theCommits.Commits) > setting.UI.FeedMaxCommitNum {
+			theCommits.Commits = theCommits.Commits[:setting.UI.FeedMaxCommitNum]
+		}
+
+		if newCommit, err := gitRepo.GetCommit(newCommitID); err != nil {
+			log.Error("SyncMirrors [repo: %-v]: unable to get commit %s: %v", m.Repo, newCommitID, err)
+			continue
+		} else {
+			theCommits.HeadCommit = repo_module.CommitToPushCommit(newCommit)
+		}
+
+		theCommits.CompareURL = m.Repo.ComposeCompareURL(oldCommitID, newCommitID)
+
+		notify_service.SyncPushCommits(ctx, m.Repo.MustOwner(ctx), m.Repo, &repo_module.PushUpdateOptions{
+			RefFullName: result.refName,
+			OldCommitID: oldCommitID,
+			NewCommitID: newCommitID,
+		}, theCommits)
+	}
+	log.Trace("SyncMirrors [repo: %-v]: done notifying updated branches/tags - now updating last commit time", m.Repo)
+
+	// Get latest commit date and update to current repository updated time
+	commitDate, err := git.GetLatestCommitTime(ctx, m.Repo.RepoPath())
+	if err != nil {
+		log.Error("SyncMirrors [repo: %-v]: unable to GetLatestCommitDate: %v", m.Repo, err)
+		return false
+	}
+
+	if err = repo_model.UpdateRepositoryUpdatedTime(ctx, m.RepoID, commitDate); err != nil {
+		log.Error("SyncMirrors [repo: %-v]: unable to update repository 'updated_unix': %v", m.Repo, err)
+		return false
+	}
+
+	log.Trace("SyncMirrors [repo: %-v]: Successfully updated", m.Repo)
+
+	return true
+}
+
+func checkAndUpdateEmptyRepository(m *repo_model.Mirror, gitRepo *git.Repository, results []*mirrorSyncResult) bool {
+	if !m.Repo.IsEmpty {
+		return true
+	}
+
+	hasDefault := false
+	hasMaster := false
+	hasMain := false
+	defaultBranchName := m.Repo.DefaultBranch
+	if len(defaultBranchName) == 0 {
+		defaultBranchName = setting.Repository.DefaultBranch
+	}
+	firstName := ""
+	for _, result := range results {
+		if !result.refName.IsBranch() {
+			continue
+		}
+
+		name := result.refName.BranchName()
+		if len(firstName) == 0 {
+			firstName = name
+		}
+
+		hasDefault = hasDefault || name == defaultBranchName
+		hasMaster = hasMaster || name == "master"
+		hasMain = hasMain || name == "main"
+	}
+
+	if len(firstName) > 0 {
+		if hasDefault {
+			m.Repo.DefaultBranch = defaultBranchName
+		} else if hasMaster {
+			m.Repo.DefaultBranch = "master"
+		} else if hasMain {
+			m.Repo.DefaultBranch = "main"
+		} else {
+			m.Repo.DefaultBranch = firstName
+		}
+		// Update the git repository default branch
+		if err := gitRepo.SetDefaultBranch(m.Repo.DefaultBranch); err != nil {
+			if !git.IsErrUnsupportedVersion(err) {
+				log.Error("Failed to update default branch of underlying git repository %-v. Error: %v", m.Repo, err)
+				desc := fmt.Sprintf("Failed to uupdate default branch of underlying git repository '%s': %v", m.Repo.RepoPath(), err)
+				if err = system_model.CreateRepositoryNotice(desc); err != nil {
+					log.Error("CreateRepositoryNotice: %v", err)
+				}
+				return false
+			}
+		}
+		m.Repo.IsEmpty = false
+		// Update the is empty and default_branch columns
+		if err := repo_model.UpdateRepositoryCols(db.DefaultContext, m.Repo, "default_branch", "is_empty"); err != nil {
+			log.Error("Failed to update default branch of repository %-v. Error: %v", m.Repo, err)
+			desc := fmt.Sprintf("Failed to uupdate default branch of repository '%s': %v", m.Repo.RepoPath(), err)
+			if err = system_model.CreateRepositoryNotice(desc); err != nil {
+				log.Error("CreateRepositoryNotice: %v", err)
+			}
+			return false
+		}
+	}
+	return true
+}

services/mirror/mirror_push.go

@@ -0,0 +1,267 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package mirror
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"regexp"
+	"strings"
+	"time"
+
+	repo_model "code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/lfs"
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/process"
+	"code.gitea.io/gitea/modules/repository"
+	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/timeutil"
+	"code.gitea.io/gitea/modules/util"
+)
+
+var stripExitStatus = regexp.MustCompile(`exit status \d+ - `)
+
+// AddPushMirrorRemote registers the push mirror remote.
+func AddPushMirrorRemote(ctx context.Context, m *repo_model.PushMirror, addr string) error {
+	addRemoteAndConfig := func(addr, path string) error {
+		cmd := git.NewCommand(ctx, "remote", "add", "--mirror=push").AddDynamicArguments(m.RemoteName, addr)
+		if strings.Contains(addr, "://") && strings.Contains(addr, "@") {
+			cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=push %s [repo_path: %s]", m.RemoteName, util.SanitizeCredentialURLs(addr), path))
+		} else {
+			cmd.SetDescription(fmt.Sprintf("remote add %s --mirror=push %s [repo_path: %s]", m.RemoteName, addr, path))
+		}
+		if _, _, err := cmd.RunStdString(&git.RunOpts{Dir: path}); err != nil {
+			return err
+		}
+		if _, _, err := git.NewCommand(ctx, "config", "--add").AddDynamicArguments("remote."+m.RemoteName+".push", "+refs/heads/*:refs/heads/*").RunStdString(&git.RunOpts{Dir: path}); err != nil {
+			return err
+		}
+		if _, _, err := git.NewCommand(ctx, "config", "--add").AddDynamicArguments("remote."+m.RemoteName+".push", "+refs/tags/*:refs/tags/*").RunStdString(&git.RunOpts{Dir: path}); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	if err := addRemoteAndConfig(addr, m.Repo.RepoPath()); err != nil {
+		return err
+	}
+
+	if m.Repo.HasWiki() {
+		wikiRemoteURL := repository.WikiRemoteURL(ctx, addr)
+		if len(wikiRemoteURL) > 0 {
+			if err := addRemoteAndConfig(wikiRemoteURL, m.Repo.WikiPath()); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+// RemovePushMirrorRemote removes the push mirror remote.
+func RemovePushMirrorRemote(ctx context.Context, m *repo_model.PushMirror) error {
+	cmd := git.NewCommand(ctx, "remote", "rm").AddDynamicArguments(m.RemoteName)
+	_ = m.GetRepository()
+
+	if _, _, err := cmd.RunStdString(&git.RunOpts{Dir: m.Repo.RepoPath()}); err != nil {
+		return err
+	}
+
+	if m.Repo.HasWiki() {
+		if _, _, err := cmd.RunStdString(&git.RunOpts{Dir: m.Repo.WikiPath()}); err != nil {
+			// The wiki remote may not exist
+			log.Warn("Wiki Remote[%d] could not be removed: %v", m.ID, err)
+		}
+	}
+
+	return nil
+}
+
+// SyncPushMirror starts the sync of the push mirror and schedules the next run.
+func SyncPushMirror(ctx context.Context, mirrorID int64) bool {
+	log.Trace("SyncPushMirror [mirror: %d]", mirrorID)
+	defer func() {
+		err := recover()
+		if err == nil {
+			return
+		}
+		// There was a panic whilst syncPushMirror...
+		log.Error("PANIC whilst syncPushMirror[%d] Panic: %v\nStacktrace: %s", mirrorID, err, log.Stack(2))
+	}()
+
+	m, err := repo_model.GetPushMirror(ctx, repo_model.PushMirrorOptions{ID: mirrorID})
+	if err != nil {
+		log.Error("GetPushMirrorByID [%d]: %v", mirrorID, err)
+		return false
+	}
+
+	_ = m.GetRepository()
+
+	m.LastError = ""
+
+	ctx, _, finished := process.GetManager().AddContext(ctx, fmt.Sprintf("Syncing PushMirror %s/%s to %s", m.Repo.OwnerName, m.Repo.Name, m.RemoteName))
+	defer finished()
+
+	log.Trace("SyncPushMirror [mirror: %d][repo: %-v]: Running Sync", m.ID, m.Repo)
+	err = runPushSync(ctx, m)
+	if err != nil {
+		log.Error("SyncPushMirror [mirror: %d][repo: %-v]: %v", m.ID, m.Repo, err)
+		m.LastError = stripExitStatus.ReplaceAllLiteralString(err.Error(), "")
+	}
+
+	m.LastUpdateUnix = timeutil.TimeStampNow()
+
+	if err := repo_model.UpdatePushMirror(ctx, m); err != nil {
+		log.Error("UpdatePushMirror [%d]: %v", m.ID, err)
+
+		return false
+	}
+
+	log.Trace("SyncPushMirror [mirror: %d][repo: %-v]: Finished", m.ID, m.Repo)
+
+	return err == nil
+}
+
+func runPushSync(ctx context.Context, m *repo_model.PushMirror) error {
+	timeout := time.Duration(setting.Git.Timeout.Mirror) * time.Second
+
+	performPush := func(path string) error {
+		remoteURL, err := git.GetRemoteURL(ctx, path, m.RemoteName)
+		if err != nil {
+			log.Error("GetRemoteAddress(%s) Error %v", path, err)
+			return errors.New("Unexpected error")
+		}
+
+		if setting.LFS.StartServer {
+			log.Trace("SyncMirrors [repo: %-v]: syncing LFS objects...", m.Repo)
+
+			gitRepo, err := git.OpenRepository(ctx, path)
+			if err != nil {
+				log.Error("OpenRepository: %v", err)
+				return errors.New("Unexpected error")
+			}
+			defer gitRepo.Close()
+
+			endpoint := lfs.DetermineEndpoint(remoteURL.String(), "")
+			lfsClient := lfs.NewClient(endpoint, nil)
+			if err := pushAllLFSObjects(ctx, gitRepo, lfsClient); err != nil {
+				return util.SanitizeErrorCredentialURLs(err)
+			}
+		}
+
+		log.Trace("Pushing %s mirror[%d] remote %s", path, m.ID, m.RemoteName)
+
+		if err := git.Push(ctx, path, git.PushOptions{
+			Remote:  m.RemoteName,
+			Force:   true,
+			Mirror:  true,
+			Timeout: timeout,
+		}); err != nil {
+			log.Error("Error pushing %s mirror[%d] remote %s: %v", path, m.ID, m.RemoteName, err)
+
+			return util.SanitizeErrorCredentialURLs(err)
+		}
+
+		return nil
+	}
+
+	err := performPush(m.Repo.RepoPath())
+	if err != nil {
+		return err
+	}
+
+	if m.Repo.HasWiki() {
+		wikiPath := m.Repo.WikiPath()
+		_, err := git.GetRemoteAddress(ctx, wikiPath, m.RemoteName)
+		if err == nil {
+			err := performPush(wikiPath)
+			if err != nil {
+				return err
+			}
+		} else {
+			log.Trace("Skipping wiki: No remote configured")
+		}
+	}
+
+	return nil
+}
+
+func pushAllLFSObjects(ctx context.Context, gitRepo *git.Repository, lfsClient lfs.Client) error {
+	contentStore := lfs.NewContentStore()
+
+	pointerChan := make(chan lfs.PointerBlob)
+	errChan := make(chan error, 1)
+	go lfs.SearchPointerBlobs(ctx, gitRepo, pointerChan, errChan)
+
+	uploadObjects := func(pointers []lfs.Pointer) error {
+		err := lfsClient.Upload(ctx, pointers, func(p lfs.Pointer, objectError error) (io.ReadCloser, error) {
+			if objectError != nil {
+				return nil, objectError
+			}
+
+			content, err := contentStore.Get(p)
+			if err != nil {
+				log.Error("Error reading LFS object %v: %v", p, err)
+			}
+			return content, err
+		})
+		if err != nil {
+			select {
+			case <-ctx.Done():
+				return nil
+			default:
+			}
+		}
+		return err
+	}
+
+	var batch []lfs.Pointer
+	for pointerBlob := range pointerChan {
+		exists, err := contentStore.Exists(pointerBlob.Pointer)
+		if err != nil {
+			log.Error("Error checking if LFS object %v exists: %v", pointerBlob.Pointer, err)
+			return err
+		}
+		if !exists {
+			log.Trace("Skipping missing LFS object %v", pointerBlob.Pointer)
+			continue
+		}
+
+		batch = append(batch, pointerBlob.Pointer)
+		if len(batch) >= lfsClient.BatchSize() {
+			if err := uploadObjects(batch); err != nil {
+				return err
+			}
+			batch = nil
+		}
+	}
+	if len(batch) > 0 {
+		if err := uploadObjects(batch); err != nil {
+			return err
+		}
+	}
+
+	err, has := <-errChan
+	if has {
+		log.Error("Error enumerating LFS objects for repository: %v", err)
+		return err
+	}
+
+	return nil
+}
+
+func syncPushMirrorWithSyncOnCommit(ctx context.Context, repoID int64) {
+	pushMirrors, err := repo_model.GetPushMirrorsSyncedOnCommit(ctx, repoID)
+	if err != nil {
+		log.Error("repo_model.GetPushMirrorsSyncedOnCommit failed: %v", err)
+		return
+	}
+
+	for _, mirror := range pushMirrors {
+		AddPushMirrorToQueue(mirror.ID)
+	}
+}

services/mirror/notifier.go

@@ -0,0 +1,31 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package mirror
+
+import (
+	"context"
+
+	repo_model "code.gitea.io/gitea/models/repo"
+	user_model "code.gitea.io/gitea/models/user"
+	"code.gitea.io/gitea/modules/repository"
+	notify_service "code.gitea.io/gitea/services/notify"
+)
+
+func init() {
+	notify_service.RegisterNotifier(&mirrorNotifier{})
+}
+
+type mirrorNotifier struct {
+	notify_service.NullNotifier
+}
+
+var _ notify_service.Notifier = &mirrorNotifier{}
+
+func (m *mirrorNotifier) PushCommits(ctx context.Context, _ *user_model.User, repo *repo_model.Repository, _ *repository.PushUpdateOptions, _ *repository.PushCommits) {
+	syncPushMirrorWithSyncOnCommit(ctx, repo.ID)
+}
+
+func (m *mirrorNotifier) SyncPushCommits(ctx context.Context, _ *user_model.User, repo *repo_model.Repository, _ *repository.PushUpdateOptions, _ *repository.PushCommits) {
+	syncPushMirrorWithSyncOnCommit(ctx, repo.ID)
+}

services/mirror/queue.go

@@ -0,0 +1,72 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package mirror
+
+import (
+	"code.gitea.io/gitea/modules/graceful"
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/queue"
+	"code.gitea.io/gitea/modules/setting"
+)
+
+var mirrorQueue *queue.WorkerPoolQueue[*SyncRequest]
+
+// SyncType type of sync request
+type SyncType int
+
+const (
+	// PullMirrorType for pull mirrors
+	PullMirrorType SyncType = iota
+	// PushMirrorType for push mirrors
+	PushMirrorType
+)
+
+// SyncRequest for the mirror queue
+type SyncRequest struct {
+	Type           SyncType
+	ReferenceID    int64 // RepoID for pull mirror, MirrorID for push mirror
+	DelOldBranches bool  // RepoID for pull mirror, MirrorID for push mirror
+}
+
+// StartSyncMirrors starts a go routine to sync the mirrors
+func StartSyncMirrors(queueHandle func(data ...*SyncRequest) []*SyncRequest) {
+	if !setting.Mirror.Enabled {
+		return
+	}
+	mirrorQueue = queue.CreateUniqueQueue(graceful.GetManager().ShutdownContext(), "mirror-new", queueHandle)
+	if mirrorQueue == nil {
+		log.Fatal("Unable to create mirror queue")
+	}
+	go graceful.GetManager().RunWithCancel(mirrorQueue)
+}
+
+// AddPullMirrorToQueue adds repoID to mirror queue
+func AddPullMirrorToQueue(repoID int64, delOldBranches bool) {
+	addMirrorToQueue(PullMirrorType, repoID, delOldBranches)
+}
+
+// AddPushMirrorToQueue adds the push mirror to the queue
+func AddPushMirrorToQueue(mirrorID int64) {
+	addMirrorToQueue(PushMirrorType, mirrorID, false)
+}
+
+func addMirrorToQueue(syncType SyncType, referenceID int64, delOldBranches bool) {
+	if !setting.Mirror.Enabled {
+		return
+	}
+	go func() {
+		if err := PushToQueue(syncType, referenceID, delOldBranches); err != nil {
+			log.Error("Unable to push sync request for to the queue for pull mirror repo[%d]. Error: %v", referenceID, err)
+		}
+	}()
+}
+
+// PushToQueue adds the sync request to the queue
+func PushToQueue(mirrorType SyncType, referenceID int64, delOldBranches bool) error {
+	return mirrorQueue.Push(&SyncRequest{
+		Type:           mirrorType,
+		ReferenceID:    referenceID,
+		DelOldBranches: delOldBranches,
+	})
+}