Merge branch 'main' into fix-rerun-failed-job-workflow-run-status

Author: GiteaBot

models/repo/repo.go

@@ -229,10 +229,6 @@ func RelativePath(ownerName, repoName string) string {
 return strings.ToLower(ownerName) + "/" + strings.ToLower(repoName) + ".git"
 }
 
-func RelativeWikiPath(ownerName, repoName string) string {
-return strings.ToLower(ownerName) + "/" + strings.ToLower(repoName) + ".wiki.git"
-}
-
 // RelativePath should be an unix style path like username/reponame.git
 func (repo *Repository) RelativePath() string {
 return RelativePath(repo.OwnerName, repo.Name)
@@ -245,12 +241,6 @@ func (sr StorageRepo) RelativePath() string {
 return string(sr)
 }
 
-// WikiStorageRepo returns the storage repo for the wiki
-// The wiki repository should have the same object format as the code repository
-func (repo *Repository) WikiStorageRepo() StorageRepo {
-return StorageRepo(RelativeWikiPath(repo.OwnerName, repo.Name))
-}
-
 // SanitizedOriginalURL returns a sanitized OriginalURL
 func (repo *Repository) SanitizedOriginalURL() string {
 if repo.OriginalURL == "" {

models/repo/wiki.go

@@ -7,7 +7,6 @@ package repo
 import (
 "context"
 "fmt"
-"path/filepath"
 "strings"
 
 user_model "code.gitea.io/gitea/models/user"
@@ -76,12 +75,12 @@ func (repo *Repository) WikiCloneLink(ctx context.Context, doer *user_model.User
 return repo.cloneLink(ctx, doer, repo.Name+".wiki")
 }
 
-// WikiPath returns wiki data path by given user and repository name.
-func WikiPath(userName, repoName string) string {
-return filepath.Join(user_model.UserPath(userName), strings.ToLower(repoName)+".wiki.git")
+func RelativeWikiPath(ownerName, repoName string) string {
+return strings.ToLower(ownerName) + "/" + strings.ToLower(repoName) + ".wiki.git"
 }
 
-// WikiPath returns wiki data path for given repository.
-func (repo *Repository) WikiPath() string {
-return WikiPath(repo.OwnerName, repo.Name)
+// WikiStorageRepo returns the storage repo for the wiki
+// The wiki repository should have the same object format as the code repository
+func (repo *Repository) WikiStorageRepo() StorageRepo {
+return StorageRepo(RelativeWikiPath(repo.OwnerName, repo.Name))
 }

models/repo/wiki_test.go

@@ -4,12 +4,10 @@
 package repo_test
 
 import (
-"path/filepath"
 "testing"
 
 repo_model "code.gitea.io/gitea/models/repo"
 "code.gitea.io/gitea/models/unittest"
-"code.gitea.io/gitea/modules/setting"
 
 "github.com/stretchr/testify/assert"
 )
@@ -23,15 +21,10 @@ func TestRepository_WikiCloneLink(t *testing.T) {
 assert.Equal(t, "https://try.gitea.io/user2/repo1.wiki.git", cloneLink.HTTPS)
 }
 
-func TestWikiPath(t *testing.T) {
+func TestRepository_RelativeWikiPath(t *testing.T) {
 assert.NoError(t, unittest.PrepareTestDatabase())
-expected := filepath.Join(setting.RepoRootPath, "user2/repo1.wiki.git")
-assert.Equal(t, expected, repo_model.WikiPath("user2", "repo1"))
-}
 
-func TestRepository_WikiPath(t *testing.T) {
-assert.NoError(t, unittest.PrepareTestDatabase())
 repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-expected := filepath.Join(setting.RepoRootPath, "user2/repo1.wiki.git")
-assert.Equal(t, expected, repo.WikiPath())
+assert.Equal(t, "user2/repo1.wiki.git", repo_model.RelativeWikiPath(repo.OwnerName, repo.Name))
+assert.Equal(t, "user2/repo1.wiki.git", repo.WikiStorageRepo().RelativePath())
 }

modules/git/key.go

@@ -3,7 +3,13 @@
 
 package git
 
-import "code.gitea.io/gitea/modules/setting"
+import (
+"context"
+"strings"
+
+"code.gitea.io/gitea/modules/git/gitcmd"
+"code.gitea.io/gitea/modules/setting"
+)
 
 // Based on https://git-scm.com/docs/git-config#Documentation/git-config.txt-gpgformat
 const (
@@ -24,3 +30,48 @@ func (s *SigningKey) String() string {
 setting.PanicInDevOrTesting("don't call SigningKey.String() - it exposes the KeyID which might be a local file path")
 return "SigningKey:" + s.Format
 }
+
+// GetSigningKey returns the KeyID and git Signature for the repo
+func GetSigningKey(ctx context.Context, repoPath string) (*SigningKey, *Signature) {
+if setting.Repository.Signing.SigningKey == "none" {
+return nil, nil
+}
+
+if setting.Repository.Signing.SigningKey == "default" || setting.Repository.Signing.SigningKey == "" {
+// Can ignore the error here as it means that commit.gpgsign is not set
+value, _, _ := gitcmd.NewCommand("config", "--get", "commit.gpgsign").WithDir(repoPath).RunStdString(ctx)
+sign, valid := ParseBool(strings.TrimSpace(value))
+if !sign || !valid {
+return nil, nil
+}
+
+format, _, _ := gitcmd.NewCommand("config", "--default", SigningKeyFormatOpenPGP, "--get", "gpg.format").WithDir(repoPath).RunStdString(ctx)
+signingKey, _, _ := gitcmd.NewCommand("config", "--get", "user.signingkey").WithDir(repoPath).RunStdString(ctx)
+signingName, _, _ := gitcmd.NewCommand("config", "--get", "user.name").WithDir(repoPath).RunStdString(ctx)
+signingEmail, _, _ := gitcmd.NewCommand("config", "--get", "user.email").WithDir(repoPath).RunStdString(ctx)
+
+if strings.TrimSpace(signingKey) == "" {
+return nil, nil
+}
+
+return &SigningKey{
+KeyID: strings.TrimSpace(signingKey),
+Format: strings.TrimSpace(format),
+}, &Signature{
+Name: strings.TrimSpace(signingName),
+Email: strings.TrimSpace(signingEmail),
+}
+}
+
+if setting.Repository.Signing.SigningKey == "" {
+return nil, nil
+}
+
+return &SigningKey{
+KeyID: setting.Repository.Signing.SigningKey,
+Format: setting.Repository.Signing.SigningFormat,
+}, &Signature{
+Name: setting.Repository.Signing.SigningName,
+Email: setting.Repository.Signing.SigningEmail,
+}
+}

modules/gitrepo/clone.go

@@ -0,0 +1,20 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+"context"
+
+"code.gitea.io/gitea/modules/git"
+)
+
+// CloneExternalRepo clones an external repository to the managed repository.
+func CloneExternalRepo(ctx context.Context, fromRemoteURL string, toRepo Repository, opts git.CloneRepoOptions) error {
+return git.Clone(ctx, fromRemoteURL, repoPath(toRepo), opts)
+}
+
+// CloneRepoToLocal clones a managed repository to a local path.
+func CloneRepoToLocal(ctx context.Context, fromRepo Repository, toLocalPath string, opts git.CloneRepoOptions) error {
+return git.Clone(ctx, repoPath(fromRepo), toLocalPath, opts)
+}

modules/gitrepo/commitgraph.go

@@ -0,0 +1,14 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+"context"
+
+"code.gitea.io/gitea/modules/git"
+)
+
+func WriteCommitGraph(ctx context.Context, repo Repository) error {
+return git.WriteCommitGraph(ctx, repoPath(repo))
+}

modules/gitrepo/gitrepo.go

@@ -7,9 +7,12 @@ import (
 "context"
 "fmt"
 "io"
+"io/fs"
+"os"
 "path/filepath"
 
 "code.gitea.io/gitea/modules/git"
+"code.gitea.io/gitea/modules/git/gitcmd"
 "code.gitea.io/gitea/modules/reqctx"
 "code.gitea.io/gitea/modules/setting"
 "code.gitea.io/gitea/modules/util"
@@ -86,3 +89,12 @@ func RenameRepository(ctx context.Context, repo, newRepo Repository) error {
 func InitRepository(ctx context.Context, repo Repository, objectFormatName string) error {
 return git.InitRepository(ctx, repoPath(repo), true, objectFormatName)
 }
+
+func UpdateServerInfo(ctx context.Context, repo Repository) error {
+_, _, err := RunCmdBytes(ctx, repo, gitcmd.NewCommand("update-server-info"))
+return err
+}
+
+func GetRepoFS(repo Repository) fs.FS {
+return os.DirFS(repoPath(repo))
+}

modules/gitrepo/push.go

@@ -0,0 +1,14 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+"context"
+
+"code.gitea.io/gitea/modules/git"
+)
+
+func Push(ctx context.Context, repo Repository, opts git.PushOptions) error {
+return git.Push(ctx, repoPath(repo), opts)
+}

modules/gitrepo/signing.go

@@ -0,0 +1,14 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package gitrepo
+
+import (
+"context"
+
+"code.gitea.io/gitea/modules/git"
+)
+
+func GetSigningKey(ctx context.Context, repo Repository) (*git.SigningKey, *git.Signature) {
+return git.GetSigningKey(ctx, repoPath(repo))
+}

routers/web/repo/githttp.go

@@ -7,11 +7,10 @@ package repo
 import (
 "bytes"
 "compress/gzip"
-gocontext "context"
 "fmt"
 "net/http"
 "os"
-"path/filepath"
+"path"
 "regexp"
 "slices"
 "strconv"
@@ -27,6 +26,7 @@ import (
 "code.gitea.io/gitea/models/unit"
 "code.gitea.io/gitea/modules/git"
 "code.gitea.io/gitea/modules/git/gitcmd"
+"code.gitea.io/gitea/modules/gitrepo"
 "code.gitea.io/gitea/modules/log"
 repo_module "code.gitea.io/gitea/modules/repository"
 "code.gitea.io/gitea/modules/setting"
@@ -342,11 +342,11 @@ type serviceHandler struct {
 environ []string
 }
 
-func (h *serviceHandler) getRepoDir() string {
+func (h *serviceHandler) getStorageRepo() gitrepo.Repository {
 if h.isWiki {
-return h.repo.WikiPath()
+return h.repo.WikiStorageRepo()
 }
-return h.repo.RepoPath()
+return h.repo
 }
 
 func setHeaderNoCache(ctx *context.Context) {
@@ -378,19 +378,10 @@ func (h *serviceHandler) sendFile(ctx *context.Context, contentType, file string
 ctx.Resp.WriteHeader(http.StatusBadRequest)
 return
 }
-reqFile := filepath.Join(h.getRepoDir(), filepath.Clean(file))
-
-fi, err := os.Stat(reqFile)
-if os.IsNotExist(err) {
-ctx.Resp.WriteHeader(http.StatusNotFound)
-return
-}
 
+fs := gitrepo.GetRepoFS(h.getStorageRepo())
 ctx.Resp.Header().Set("Content-Type", contentType)
-ctx.Resp.Header().Set("Content-Length", strconv.FormatInt(fi.Size(), 10))
-// http.TimeFormat required a UTC time, refer to https://pkg.go.dev/net/http#TimeFormat
-ctx.Resp.Header().Set("Last-Modified", fi.ModTime().UTC().Format(http.TimeFormat))
-http.ServeFile(ctx.Resp, ctx.Req, reqFile)
+http.ServeFileFS(ctx.Resp, ctx.Req, fs, path.Clean(file))
 }
 
 // one or more key=value pairs separated by colons
@@ -416,13 +407,15 @@ func serviceRPC(ctx *context.Context, h *serviceHandler, service string) {
 expectedContentType := fmt.Sprintf("application/x-git-%s-request", service)
 if ctx.Req.Header.Get("Content-Type") != expectedContentType {
 log.Error("Content-Type (%q) doesn't match expected: %q", ctx.Req.Header.Get("Content-Type"), expectedContentType)
+// FIXME: why it's 401 if the content type is unexpected?
 ctx.Resp.WriteHeader(http.StatusUnauthorized)
 return
 }
 
 cmd, err := prepareGitCmdWithAllowedService(service)
 if err != nil {
 log.Error("Failed to prepareGitCmdWithService: %v", err)
+// FIXME: why it's 401 if the service type doesn't supported?
 ctx.Resp.WriteHeader(http.StatusUnauthorized)
 return
 }
@@ -449,17 +442,14 @@ func serviceRPC(ctx *context.Context, h *serviceHandler, service string) {
 }
 
 var stderr bytes.Buffer
-if err := cmd.AddArguments("--stateless-rpc").
-AddDynamicArguments(h.getRepoDir()).
-WithDir(h.getRepoDir()).
+if err := gitrepo.RunCmd(ctx, h.getStorageRepo(), cmd.AddArguments("--stateless-rpc", ".").
 WithEnv(append(os.Environ(), h.environ...)).
 WithStderr(&stderr).
 WithStdin(reqBody).
 WithStdout(ctx.Resp).
-WithUseContextTimeout(true).
-Run(ctx); err != nil {
+WithUseContextTimeout(true)); err != nil {
 if !git.IsErrCanceledOrKilled(err) {
-log.Error("Fail to serve RPC(%s) in %s: %v - %s", service, h.getRepoDir(), err, stderr.String())
+log.Error("Fail to serve RPC(%s) in %s: %v - %s", service, h.getStorageRepo().RelativePath(), err, stderr.String())
 }
 return
 }
@@ -496,14 +486,6 @@ func getServiceType(ctx *context.Context) string {
 return ""
 }
 
-func updateServerInfo(ctx gocontext.Context, dir string) []byte {
-out, _, err := gitcmd.NewCommand("update-server-info").WithDir(dir).RunStdBytes(ctx)
-if err != nil {
-log.Error(fmt.Sprintf("%v - %s", err, string(out)))
-}
-return out
-}
-
 func packetWrite(str string) []byte {
 s := strconv.FormatInt(int64(len(str)+4), 16)
 if len(s)%4 != 0 {
@@ -527,10 +509,8 @@ func GetInfoRefs(ctx *context.Context) {
 }
 h.environ = append(os.Environ(), h.environ...)
 
-refs, _, err := cmd.AddArguments("--stateless-rpc", "--advertise-refs", ".").
-WithEnv(h.environ).
-WithDir(h.getRepoDir()).
-RunStdBytes(ctx)
+refs, _, err := gitrepo.RunCmdBytes(ctx, h.getStorageRepo(), cmd.AddArguments("--stateless-rpc", "--advertise-refs", ".").
+WithEnv(h.environ))
 if err != nil {
 log.Error(fmt.Sprintf("%v - %s", err, string(refs)))
 }
@@ -541,7 +521,9 @@ func GetInfoRefs(ctx *context.Context) {
 _, _ = ctx.Resp.Write([]byte("0000"))
 _, _ = ctx.Resp.Write(refs)
 } else {
-updateServerInfo(ctx, h.getRepoDir())
+if err := gitrepo.UpdateServerInfo(ctx, h.getStorageRepo()); err != nil {
+log.Error("Failed to update server info: %v", err)
+}
 h.sendFile(ctx, "text/plain; charset=utf-8", "info/refs")
 }
 }