refactor: private endpoints (#38964) (#38965)

backport #38964

cmd/manager_logging.go

@@ -5,60 +5,14 @@ package cmd
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"os"
 
-	"gitea.dev/modules/log"
 	"gitea.dev/modules/private"
 
 	"github.com/urfave/cli/v3"
 )
 
-func defaultLoggingFlags() []cli.Flag {
-	return []cli.Flag{
-		&cli.StringFlag{
-			Name:  "logger",
-			Usage: `Logger name - will default to "default"`,
-		},
-		&cli.StringFlag{
-			Name:  "writer",
-			Usage: "Name of the log writer - will default to mode",
-		},
-		&cli.StringFlag{
-			Name:  "level",
-			Usage: "Logging level for the new logger",
-		},
-		&cli.StringFlag{
-			Name:    "stacktrace-level",
-			Aliases: []string{"L"},
-			Usage:   "Stacktrace logging level",
-		},
-		&cli.StringFlag{
-			Name:    "flags",
-			Aliases: []string{"F"},
-			Usage:   "Flags for the logger",
-		},
-		&cli.StringFlag{
-			Name:    "expression",
-			Aliases: []string{"e"},
-			Usage:   "Matching expression for the logger",
-		},
-		&cli.StringFlag{
-			Name:    "prefix",
-			Aliases: []string{"p"},
-			Usage:   "Prefix for the logger",
-		},
-		&cli.BoolFlag{
-			Name:  "color",
-			Usage: "Use color in the logs",
-		},
-		&cli.BoolFlag{
-			Name: "debug",
-		},
-	}
-}
-
 func newLoggingCommand() *cli.Command {
 	return &cli.Command{
 		Name:  "logging",
@@ -91,92 +45,6 @@ func newLoggingCommand() *cli.Command {
 					},
 				},
 				Action: runReleaseReopenLogging,
-			}, {
-				Name:      "remove",
-				Usage:     "Remove a logger",
-				ArgsUsage: "[name] Name of logger to remove",
-				Flags: []cli.Flag{
-					&cli.BoolFlag{
-						Name: "debug",
-					}, &cli.StringFlag{
-						Name:  "logger",
-						Usage: `Logger name - will default to "default"`,
-					},
-				},
-				Action: runRemoveLogger,
-			}, {
-				Name:  "add",
-				Usage: "Add a logger",
-				Commands: []*cli.Command{
-					{
-						Name:  "file",
-						Usage: "Add a file logger",
-						Flags: append(defaultLoggingFlags(), []cli.Flag{
-							&cli.StringFlag{
-								Name:    "filename",
-								Aliases: []string{"f"},
-								Usage:   "Filename for the logger - this must be set.",
-							},
-							&cli.BoolFlag{
-								Name:    "rotate",
-								Aliases: []string{"r"},
-								Usage:   "Rotate logs",
-							},
-							&cli.Int64Flag{
-								Name:    "max-size",
-								Aliases: []string{"s"},
-								Usage:   "Maximum size in bytes before rotation",
-							},
-							&cli.BoolFlag{
-								Name:    "daily",
-								Aliases: []string{"d"},
-								Usage:   "Rotate logs daily",
-							},
-							&cli.IntFlag{
-								Name:    "max-days",
-								Aliases: []string{"D"},
-								Usage:   "Maximum number of daily logs to keep",
-							},
-							&cli.BoolFlag{
-								Name:    "compress",
-								Aliases: []string{"z"},
-								Usage:   "Compress rotated logs",
-							},
-							&cli.IntFlag{
-								Name:    "compression-level",
-								Aliases: []string{"Z"},
-								Usage:   "Compression level to use",
-							},
-						}...),
-						Action: runAddFileLogger,
-					}, {
-						Name:  "conn",
-						Usage: "Add a net conn logger",
-						Flags: append(defaultLoggingFlags(), []cli.Flag{
-							&cli.BoolFlag{
-								Name:    "reconnect-on-message",
-								Aliases: []string{"R"},
-								Usage:   "Reconnect to host for every message",
-							},
-							&cli.BoolFlag{
-								Name:    "reconnect",
-								Aliases: []string{"r"},
-								Usage:   "Reconnect to host when connection is dropped",
-							},
-							&cli.StringFlag{
-								Name:    "protocol",
-								Aliases: []string{"P"},
-								Usage:   "Set protocol to use: tcp, unix, or udp (defaults to tcp)",
-							},
-							&cli.StringFlag{
-								Name:    "address",
-								Aliases: []string{"a"},
-								Usage:   "Host address and port to connect to (defaults to :7020)",
-							},
-						}...),
-						Action: runAddConnLogger,
-					},
-				},
 			}, {
 				Name:  "log-sql",
 				Usage: "Set LogSQL",
@@ -195,107 +63,6 @@ func newLoggingCommand() *cli.Command {
 	}
 }
 
-func runRemoveLogger(ctx context.Context, c *cli.Command) error {
-	setup(ctx, c.Bool("debug"))
-	logger := c.String("logger")
-	if len(logger) == 0 {
-		logger = log.DEFAULT
-	}
-	writer := c.Args().First()
-
-	extra := private.RemoveLogger(ctx, logger, writer)
-	return handleCliResponseExtra(extra)
-}
-
-func runAddConnLogger(ctx context.Context, c *cli.Command) error {
-	setup(ctx, c.Bool("debug"))
-	vals := map[string]any{}
-	mode := "conn"
-	vals["net"] = "tcp"
-	if c.IsSet("protocol") {
-		switch c.String("protocol") {
-		case "udp":
-			vals["net"] = "udp"
-		case "unix":
-			vals["net"] = "unix"
-		}
-	}
-	if c.IsSet("address") {
-		vals["address"] = c.String("address")
-	} else {
-		vals["address"] = ":7020"
-	}
-	if c.IsSet("reconnect") {
-		vals["reconnect"] = c.Bool("reconnect")
-	}
-	if c.IsSet("reconnect-on-message") {
-		vals["reconnectOnMsg"] = c.Bool("reconnect-on-message")
-	}
-	return commonAddLogger(ctx, c, mode, vals)
-}
-
-func runAddFileLogger(ctx context.Context, c *cli.Command) error {
-	setup(ctx, c.Bool("debug"))
-	vals := map[string]any{}
-	mode := "file"
-	if c.IsSet("filename") {
-		vals["filename"] = c.String("filename")
-	} else {
-		return errors.New("filename must be set when creating a file logger")
-	}
-	if c.IsSet("rotate") {
-		vals["rotate"] = c.Bool("rotate")
-	}
-	if c.IsSet("max-size") {
-		vals["maxsize"] = c.Int64("max-size")
-	}
-	if c.IsSet("daily") {
-		vals["daily"] = c.Bool("daily")
-	}
-	if c.IsSet("max-days") {
-		vals["maxdays"] = c.Int("max-days")
-	}
-	if c.IsSet("compress") {
-		vals["compress"] = c.Bool("compress")
-	}
-	if c.IsSet("compression-level") {
-		vals["compressionLevel"] = c.Int("compression-level")
-	}
-	return commonAddLogger(ctx, c, mode, vals)
-}
-
-func commonAddLogger(ctx context.Context, c *cli.Command, mode string, vals map[string]any) error {
-	if len(c.String("level")) > 0 {
-		vals["level"] = log.LevelFromString(c.String("level")).String()
-	}
-	if len(c.String("stacktrace-level")) > 0 {
-		vals["stacktraceLevel"] = log.LevelFromString(c.String("stacktrace-level")).String()
-	}
-	if len(c.String("expression")) > 0 {
-		vals["expression"] = c.String("expression")
-	}
-	if len(c.String("prefix")) > 0 {
-		vals["prefix"] = c.String("prefix")
-	}
-	if len(c.String("flags")) > 0 {
-		vals["flags"] = log.FlagsFromString(c.String("flags"))
-	}
-	if c.IsSet("color") {
-		vals["colorize"] = c.Bool("color")
-	}
-	logger := log.DEFAULT
-	if c.IsSet("logger") {
-		logger = c.String("logger")
-	}
-	writer := mode
-	if c.IsSet("writer") {
-		writer = c.String("writer")
-	}
-
-	extra := private.AddLogger(ctx, logger, writer, mode, vals)
-	return handleCliResponseExtra(extra)
-}
-
 func runPauseLogging(ctx context.Context, c *cli.Command) error {
 	setup(ctx, c.Bool("debug"))
 	userMsg := private.PauseLogging(ctx)

modules/private/hook.go

@@ -109,18 +109,6 @@ func HookProcReceive(ctx context.Context, ownerName, repoName string, opts HookO
 	return requestJSONResp(req, &HookProcReceiveResult{})
 }
 
-// SetDefaultBranch will set the default branch to the provided branch for the provided repository
-func SetDefaultBranch(ctx context.Context, ownerName, repoName, branch string) ResponseExtra {
-	reqURL := setting.LocalURL + fmt.Sprintf("api/internal/hook/set-default-branch/%s/%s/%s",
-		url.PathEscape(ownerName),
-		url.PathEscape(repoName),
-		url.PathEscape(branch),
-	)
-	req := newInternalRequestAPI(ctx, reqURL, "POST")
-	_, extra := requestJSONResp(req, &ResponseText{})
-	return extra
-}
-
 // SSHLog sends ssh error log response
 func SSHLog(ctx context.Context, isErr bool, msg string) error {
 	reqURL := setting.LocalURL + "api/internal/ssh/log"

modules/private/manager.go

@@ -88,25 +88,6 @@ type LoggerOptions struct {
 	Config map[string]any
 }
 
-// AddLogger adds a logger
-func AddLogger(ctx context.Context, logger, writer, mode string, config map[string]any) ResponseExtra {
-	reqURL := setting.LocalURL + "api/internal/manager/add-logger"
-	req := newInternalRequestAPI(ctx, reqURL, "POST", LoggerOptions{
-		Logger: logger,
-		Writer: writer,
-		Mode:   mode,
-		Config: config,
-	})
-	return requestJSONClientMsg(req, "Added")
-}
-
-// RemoveLogger removes a logger
-func RemoveLogger(ctx context.Context, logger, writer string) ResponseExtra {
-	reqURL := setting.LocalURL + fmt.Sprintf("api/internal/manager/remove-logger/%s/%s", url.PathEscape(logger), url.PathEscape(writer))
-	req := newInternalRequestAPI(ctx, reqURL, "POST")
-	return requestJSONClientMsg(req, "Removed")
-}
-
 // Processes return the current processes from this gitea instance
 func Processes(ctx context.Context, out io.Writer, flat, noSystem, stacktraces, json bool, cancel string) ResponseExtra {
 	reqURL := setting.LocalURL + fmt.Sprintf("api/internal/manager/processes?flat=%t&no-system=%t&stacktraces=%t&json=%t&cancel-pid=%s", flat, noSystem, stacktraces, json, url.QueryEscape(cancel))

routers/private/default_branch.go

@@ -1,48 +0,0 @@
-// Copyright 2021 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
-
-package private
-
-import (
-	"fmt"
-	"net/http"
-
-	repo_model "gitea.dev/models/repo"
-	"gitea.dev/modules/gitrepo"
-	"gitea.dev/modules/private"
-	gitea_context "gitea.dev/services/context"
-	repo_service "gitea.dev/services/repository"
-)
-
-// SetDefaultBranch updates the default branch
-func SetDefaultBranch(ctx *gitea_context.PrivateContext) {
-	ownerName := ctx.PathParam("owner")
-	repoName := ctx.PathParam("repo")
-	branch := ctx.PathParam("branch")
-
-	ctx.Repo.Repository.DefaultBranch = branch
-	if err := gitrepo.SetDefaultBranch(ctx, ctx.Repo.Repository, ctx.Repo.Repository.DefaultBranch); err != nil {
-		ctx.JSON(http.StatusInternalServerError, private.Response{
-			Err: fmt.Sprintf("Unable to set default branch on repository: %s/%s Error: %v", ownerName, repoName, err),
-		})
-		return
-	}
-
-	if err := repo_model.UpdateDefaultBranch(ctx, ctx.Repo.Repository); err != nil {
-		ctx.JSON(http.StatusInternalServerError, private.Response{
-			Err: fmt.Sprintf("Unable to set default branch on repository: %s/%s Error: %v", ownerName, repoName, err),
-		})
-		return
-	}
-
-	if err := repo_service.AddRepoToLicenseUpdaterQueue(&repo_service.LicenseUpdaterOptions{
-		RepoID: ctx.Repo.Repository.ID,
-	}); err != nil {
-		ctx.JSON(http.StatusInternalServerError, private.Response{
-			Err: fmt.Sprintf("Unable to set default branch on repository: %s/%s Error: %v", ownerName, repoName, err),
-		})
-		return
-	}
-
-	ctx.PlainText(http.StatusOK, "success")
-}

routers/private/internal.go

@@ -79,7 +79,6 @@ func Routes() *web.Router {
 	r.Post("/hook/pre-receive/{owner}/{repo}", RepoAssignment, bind(private.HookOptions{}), HookPreReceive)
 	r.Post("/hook/post-receive/{owner}/{repo}", context.OverrideContext(), bind(private.HookOptions{}), HookPostReceive)
 	r.Post("/hook/proc-receive/{owner}/{repo}", context.OverrideContext(), RepoAssignment, bind(private.HookOptions{}), HookProcReceive)
-	r.Post("/hook/set-default-branch/{owner}/{repo}/{branch}", RepoAssignment, SetDefaultBranch)
 	r.Get("/serv/none/{keyid}", ServNoCommand)
 	r.Get("/serv/command/{keyid}/{owner}/{repo}", ServCommand)
 	r.Post("/manager/shutdown", Shutdown)
@@ -90,8 +89,6 @@ func Routes() *web.Router {
 	r.Post("/manager/resume-logging", ResumeLogging)
 	r.Post("/manager/release-and-reopen-logging", ReleaseReopenLogging)
 	r.Post("/manager/set-log-sql", SetLogSQL)
-	r.Post("/manager/add-logger", bind(private.LoggerOptions{}), AddLogger)
-	r.Post("/manager/remove-logger/{logger}/{writer}", RemoveLogger)
 	r.Get("/manager/processes", Processes)
 	r.Post("/mail/send", SendEmail)
 	r.Post("/restore_repo", RestoreRepo)

routers/private/manager.go

@@ -13,7 +13,6 @@ import (
 	"gitea.dev/modules/log"
 	"gitea.dev/modules/private"
 	"gitea.dev/modules/queue"
-	"gitea.dev/modules/setting"
 	"gitea.dev/modules/templates"
 	"gitea.dev/modules/web"
 	"gitea.dev/services/context"
@@ -85,111 +84,3 @@ func SetLogSQL(ctx *context.PrivateContext) {
 	db.SetLogSQL(ctx, ctx.FormBool("on"))
 	ctx.PlainText(http.StatusOK, "success")
 }
-
-// RemoveLogger removes a logger
-func RemoveLogger(ctx *context.PrivateContext) {
-	logger := ctx.PathParam("logger")
-	writer := ctx.PathParam("writer")
-	err := log.GetManager().GetLogger(logger).RemoveWriter(writer)
-	if err != nil {
-		ctx.JSON(http.StatusInternalServerError, private.Response{
-			Err: fmt.Sprintf("Failed to remove log writer: %s %s %v", logger, writer, err),
-		})
-		return
-	}
-	ctx.PlainText(http.StatusOK, fmt.Sprintf("Removed %s %s", logger, writer))
-}
-
-// AddLogger adds a logger
-func AddLogger(ctx *context.PrivateContext) {
-	opts := web.GetForm(ctx).(*private.LoggerOptions)
-
-	if len(opts.Logger) == 0 {
-		opts.Logger = log.DEFAULT
-	}
-
-	writerMode := log.WriterMode{}
-	writerType := opts.Mode
-
-	var flags string
-	var ok bool
-	if flags, ok = opts.Config["flags"].(string); !ok {
-		switch opts.Logger {
-		case "access":
-			flags = ""
-		case "router":
-			flags = "date,time"
-		default:
-			flags = "stdflags"
-		}
-	}
-	writerMode.Flags = log.FlagsFromString(flags)
-
-	if writerMode.Colorize, ok = opts.Config["colorize"].(bool); !ok && opts.Mode == "console" {
-		if _, ok := opts.Config["stderr"]; ok {
-			writerMode.Colorize = log.CanColorStderr
-		} else {
-			writerMode.Colorize = log.CanColorStdout
-		}
-	}
-
-	writerMode.Level = setting.Log.Level
-	if level, ok := opts.Config["level"].(string); ok {
-		writerMode.Level = log.LevelFromString(level)
-	}
-
-	writerMode.StacktraceLevel = setting.Log.StacktraceLogLevel
-	if stacktraceLevel, ok := opts.Config["level"].(string); ok {
-		writerMode.StacktraceLevel = log.LevelFromString(stacktraceLevel)
-	}
-
-	writerMode.Prefix, _ = opts.Config["prefix"].(string)
-	writerMode.Expression, _ = opts.Config["expression"].(string)
-
-	switch writerType {
-	case "console":
-		writerOption := log.WriterConsoleOption{}
-		writerOption.Stderr, _ = opts.Config["stderr"].(bool)
-		writerMode.WriterOption = writerOption
-	case "file":
-		writerOption := log.WriterFileOption{}
-		fileName, _ := opts.Config["filename"].(string)
-		writerOption.FileName = setting.LogPrepareFilenameForWriter(fileName, opts.Writer+".log")
-		writerOption.LogRotate, _ = opts.Config["rotate"].(bool)
-		maxSizeShift, _ := opts.Config["maxsize"].(int)
-		if maxSizeShift == 0 {
-			maxSizeShift = 28
-		}
-		writerOption.MaxSize = 1 << maxSizeShift
-		writerOption.DailyRotate, _ = opts.Config["daily"].(bool)
-		writerOption.MaxDays, _ = opts.Config["maxdays"].(int)
-		if writerOption.MaxDays == 0 {
-			writerOption.MaxDays = 7
-		}
-		writerOption.Compress, _ = opts.Config["compress"].(bool)
-		writerOption.CompressionLevel, _ = opts.Config["compressionLevel"].(int)
-		if writerOption.CompressionLevel == 0 {
-			writerOption.CompressionLevel = -1
-		}
-		writerMode.WriterOption = writerOption
-	case "conn":
-		writerOption := log.WriterConnOption{}
-		writerOption.ReconnectOnMsg, _ = opts.Config["reconnectOnMsg"].(bool)
-		writerOption.Reconnect, _ = opts.Config["reconnect"].(bool)
-		writerOption.Protocol, _ = opts.Config["net"].(string)
-		writerOption.Addr, _ = opts.Config["address"].(string)
-		writerMode.WriterOption = writerOption
-	default:
-		panic("invalid log writer mode: " + writerType)
-	}
-	writer, err := log.NewEventWriter(opts.Writer, writerType, writerMode)
-	if err != nil {
-		log.Error("Failed to create new log writer: %v", err)
-		ctx.JSON(http.StatusInternalServerError, private.Response{
-			Err: fmt.Sprintf("Failed to create new log writer: %v", err),
-		})
-		return
-	}
-	log.GetManager().GetLogger(opts.Logger).AddWriters(writer)
-	ctx.PlainText(http.StatusOK, "success")
-}