refactor: fix legacy problems in cmd/serv.go (#38505)

1. use var names "reqOwnerName, reqRepoName", because these values are
from request and should not be really used for path construction
2. simplify enable-pprof logic, don't "log.Fatal"
3. don't make runServe command to guess the repo storage path, instead,
let server return RepoStoragePath
4. don't process lfs verbs when the repo is a wiki
5. construct the request URI path correctly for the lfs transfer backend
(moved to the caller)
6. don't call "owner, err := user_model.GetUserByName", the "owner
rename redirection" has been done before
7. fix incorrect "repo.OwnerName = ownerName", the real owner might have
been "redirected"
8. fix incorrect "inactive owner" check, it should be checked even if
the repo is redirected


Use general error functions to handle responses, error handling code is
hugely simplified.

modules/lfstransfer/backend/backend.go

@@ -40,13 +40,12 @@ type GiteaBackend struct {
 	logger       transfer.Logger
 }
 
-func New(ctx context.Context, repo, op, token string, logger transfer.Logger) (transfer.Backend, error) {
-	// runServ guarantees repo will be in form [owner]/[name].git
+func New(ctx context.Context, reqPath, op, token string, logger transfer.Logger) (transfer.Backend, error) {
 	server, err := url.Parse(setting.LocalURL)
 	if err != nil {
 		return nil, err
 	}
-	server = server.JoinPath("api/internal/repo", repo, "info/lfs")
+	server = server.JoinPath(reqPath)
 	return &GiteaBackend{ctx: ctx, server: server, op: op, authToken: token, internalAuth: "Bearer " + setting.InternalToken, logger: logger}, nil
 }
 

modules/lfstransfer/main.go

@@ -6,6 +6,7 @@ package lfstransfer
 import (
 	"context"
 	"fmt"
+	"net/url"
 	"os"
 
 	"gitea.dev/modules/lfstransfer/backend"
@@ -13,23 +14,24 @@ import (
 	"github.com/charmbracelet/git-lfs-transfer/transfer"
 )
 
-func Main(ctx context.Context, repo, verb, token string) error {
+func Main(ctx context.Context, ownerName, repoName, verb, token string) error {
 	logger := newLogger()
-	pktline := transfer.NewPktline(os.Stdin, os.Stdout, logger)
-	giteaBackend, err := backend.New(ctx, repo, verb, token, logger)
+	backendReqPath := fmt.Sprintf("api/internal/repo/%s/%s.git/info/lfs", url.PathEscape(ownerName), url.PathEscape(repoName))
+	giteaBackend, err := backend.New(ctx, backendReqPath, verb, token, logger)
 	if err != nil {
 		return err
 	}
 
+	pktLine := transfer.NewPktline(os.Stdin, os.Stdout, logger)
 	for _, cap := range backend.Capabilities {
-		if err := pktline.WritePacketText(cap); err != nil {
+		if err := pktLine.WritePacketText(cap); err != nil {
 			logger.Log("error sending capability due to error:", err)
 		}
 	}
-	if err := pktline.WriteFlush(); err != nil {
+	if err := pktLine.WriteFlush(); err != nil {
 		logger.Log("error flushing capabilities:", err)
 	}
-	p := transfer.NewProcessor(pktline, giteaBackend, logger)
+	p := transfer.NewProcessor(pktLine, giteaBackend, logger)
 	defer logger.Log("done processing commands")
 	switch verb {
 	case "upload":

modules/pprof/pprof.go

@@ -6,15 +6,15 @@ package pprof
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 	"runtime"
 	"runtime/pprof"
 
 	"gitea.dev/modules/log"
 )
 
-// DumpMemProfileForUsername dumps a memory profile at pprofDataPath as memprofile_<username>_<temporary id>
-func DumpMemProfileForUsername(pprofDataPath, username string) error {
-	f, err := os.CreateTemp(pprofDataPath, fmt.Sprintf("memprofile_%s_", username))
+func dumpMemProfileForUsername(pprofDataPath, subName string) error {
+	f, err := os.CreateTemp(pprofDataPath, fmt.Sprintf("pprof_mem_%s_", filepath.Clean(subName)))
 	if err != nil {
 		return err
 	}
@@ -23,23 +23,30 @@ func DumpMemProfileForUsername(pprofDataPath, username string) error {
 	return pprof.WriteHeapProfile(f)
 }
 
-// DumpCPUProfileForUsername dumps a CPU profile at pprofDataPath as cpuprofile_<username>_<temporary id>
-// the stop function it returns stops, writes and closes the CPU profile file
-func DumpCPUProfileForUsername(pprofDataPath, username string) (func(), error) {
-	f, err := os.CreateTemp(pprofDataPath, fmt.Sprintf("cpuprofile_%s_", username))
+func DumpPprofForUsername(pprofDataPath, subName string) (func(), error) {
+	if err := os.MkdirAll(pprofDataPath, os.ModePerm); err != nil {
+		return nil, fmt.Errorf(`os.MkdirAll(pprofDataPath) failed: %v`, err)
+	}
+
+	f, err := os.CreateTemp(pprofDataPath, fmt.Sprintf("pprof_cpu_%s_", filepath.Clean(subName)))
 	if err != nil {
 		return nil, err
 	}
 
 	err = pprof.StartCPUProfile(f)
 	if err != nil {
-		log.Fatal("StartCPUProfile: %v", err)
+		_ = f.Close()
+		return nil, fmt.Errorf("StartCPUProfile: %w", err)
 	}
 	return func() {
 		pprof.StopCPUProfile()
 		err = f.Close()
 		if err != nil {
-			log.Fatal("StopCPUProfile Close: %v", err)
+			log.Error("StopCPUProfile Close: %v", err)
+		}
+		err = dumpMemProfileForUsername(pprofDataPath, subName)
+		if err != nil {
+			log.Error("DumpMemProfile: %v", err)
 		}
 	}, nil
 }

modules/private/serv.go

@@ -43,6 +43,8 @@ type ServCommandResults struct {
 	OwnerName   string
 	RepoName    string
 	RepoID      int64
+
+	RepoStoragePath string
 }
 
 // ServCommand preps for a serv call