Hi… I am well aware that this diff view is very suboptimal. It will be fixed when the refactored server comes along!
Rename httpRouter
// SPDX-License-Identifier: AGPL-3.0-only // SPDX-FileContributor: Runxi Yu <https://runxiyu.org> package main import ( "errors" "fmt" "net/http" "strconv" "strings" "github.com/jackc/pgx/v5" "go.lindenii.runxiyu.org/lindenii-common/clog" )
type httpRouter struct{}
type forgeHTTPRouter struct{}
func (router *httpRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
func (router *forgeHTTPRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
clog.Info("Incoming HTTP: " + r.RemoteAddr + " " + r.Method + " " + r.RequestURI)
var segments []string
var err error
var contentfulSegmentsLen int
var sepIndex int
params := make(map[string]any)
if segments, _, err = parseReqURI(r.RequestURI); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
contentfulSegmentsLen = len(segments)
if segments[len(segments)-1] == "" {
contentfulSegmentsLen--
}
if segments[0] == ":" {
if len(segments) < 2 {
http.Error(w, "Blank system endpoint", http.StatusNotFound)
return
} else if len(segments) == 2 && redirectDir(w, r) {
return
}
switch segments[1] {
case "static":
staticHandler.ServeHTTP(w, r)
return
case "source":
sourceHandler.ServeHTTP(w, r)
return
}
}
params["url_segments"] = segments
params["global"] = globalData
var userID int // 0 for none
userID, params["username"], err = getUserFromRequest(r)
params["user_id"] = userID
if errors.Is(err, http.ErrNoCookie) {
} else if errors.Is(err, pgx.ErrNoRows) {
} else if err != nil {
http.Error(w, "Error getting user info from request: "+err.Error(), http.StatusInternalServerError)
return
}
if userID == 0 {
params["user_id_string"] = ""
} else {
params["user_id_string"] = strconv.Itoa(userID)
}
if segments[0] == ":" {
switch segments[1] {
case "login":
httpHandleLogin(w, r, params)
return
case "users":
httpHandleUsers(w, r, params)
return
case "gc":
httpHandleGC(w, r, params)
return
default:
http.Error(w, fmt.Sprintf("Unknown system module type: %s", segments[1]), http.StatusNotFound)
return
}
}
sepIndex = -1
for i, part := range segments {
if part == ":" {
sepIndex = i
break
}
}
params["separator_index"] = sepIndex
var groupPath []string
var moduleType string
var moduleName string
if sepIndex > 0 {
groupPath = segments[:sepIndex]
} else {
groupPath = segments[:len(segments)-1]
}
params["group_path"] = groupPath
switch {
case contentfulSegmentsLen == 0:
httpHandleIndex(w, r, params)
case sepIndex == -1:
if redirectDir(w, r) {
return
}
httpHandleGroupIndex(w, r, params)
case contentfulSegmentsLen == sepIndex+1:
http.Error(w, "Illegal path 1", http.StatusNotImplemented)
return
case contentfulSegmentsLen == sepIndex+2:
http.Error(w, "Illegal path 2", http.StatusNotImplemented)
return
default:
moduleType = segments[sepIndex+1]
moduleName = segments[sepIndex+2]
switch moduleType {
case "repos":
params["repo_name"] = moduleName
if contentfulSegmentsLen > sepIndex+3 {
switch segments[sepIndex+3] {
case "info":
if err = httpHandleRepoInfo(w, r, params); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
return
case "git-upload-pack":
if err = httpHandleUploadPack(w, r, params); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
return
}
}
if params["ref_type"], params["ref_name"], err = getParamRefTypeName(r); err != nil {
if errors.Is(err, errNoRefSpec) {
params["ref_type"] = ""
} else {
http.Error(w, "Error querying ref type: "+err.Error(), http.StatusInternalServerError)
return
}
}
// TODO: subgroups
if params["repo"], params["repo_description"], params["repo_id"], err = openRepo(r.Context(), groupPath, moduleName); err != nil {
http.Error(w, "Error opening repo: "+err.Error(), http.StatusInternalServerError)
return
}
if contentfulSegmentsLen == sepIndex+3 {
if redirectDir(w, r) {
return
}
httpHandleRepoIndex(w, r, params)
return
}
repoFeature := segments[sepIndex+3]
switch repoFeature {
case "tree":
params["rest"] = strings.Join(segments[sepIndex+4:], "/")
if len(segments) < sepIndex+5 && redirectDir(w, r) {
return
}
httpHandleRepoTree(w, r, params)
case "raw":
params["rest"] = strings.Join(segments[sepIndex+4:], "/")
if len(segments) < sepIndex+5 && redirectDir(w, r) {
return
}
httpHandleRepoRaw(w, r, params)
case "log":
if contentfulSegmentsLen > sepIndex+4 {
http.Error(w, "Too many parameters", http.StatusBadRequest)
return
}
if redirectDir(w, r) {
return
}
httpHandleRepoLog(w, r, params)
case "commit":
if redirectNoDir(w, r) {
return
}
params["commit_id"] = segments[sepIndex+4]
httpHandleRepoCommit(w, r, params)
case "contrib":
if redirectDir(w, r) {
return
}
switch contentfulSegmentsLen {
case sepIndex + 4:
httpHandleRepoContribIndex(w, r, params)
case sepIndex + 5:
params["mr_id"] = segments[sepIndex+4]
httpHandleRepoContribOne(w, r, params)
default:
http.Error(w, "Too many parameters", http.StatusBadRequest)
}
default:
http.Error(w, fmt.Sprintf("Unknown repo feature: %s", repoFeature), http.StatusNotFound)
}
default:
http.Error(w, fmt.Sprintf("Unknown module type: %s", moduleType), http.StatusNotFound)
}
}
}
// SPDX-License-Identifier: AGPL-3.0-only
// SPDX-FileContributor: Runxi Yu <https://runxiyu.org>
package main
import (
"errors"
"flag"
"net"
"net/http"
"syscall"
"go.lindenii.runxiyu.org/lindenii-common/clog"
_ "net/http/pprof"
)
func main() {
configPath := flag.String(
"config",
"/etc/lindenii/forge.scfg",
"path to configuration file",
)
flag.Parse()
if err := loadConfig(*configPath); err != nil {
clog.Fatal(1, "Loading configuration: "+err.Error())
}
if err := deployHooks(); err != nil {
clog.Fatal(1, "Deploying hooks to filesystem: "+err.Error())
}
if err := loadTemplates(); err != nil {
clog.Fatal(1, "Loading templates: "+err.Error())
}
// UNIX socket listener for hooks
var hooksListener net.Listener
var err error
hooksListener, err = net.Listen("unix", config.Hooks.Socket)
if errors.Is(err, syscall.EADDRINUSE) {
clog.Warn("Removing stale socket " + config.Hooks.Socket)
if err = syscall.Unlink(config.Hooks.Socket); err != nil {
clog.Fatal(1, "Removing stale socket: "+err.Error())
}
if hooksListener, err = net.Listen("unix", config.Hooks.Socket); err != nil {
clog.Fatal(1, "Listening hooks: "+err.Error())
}
} else if err != nil {
clog.Fatal(1, "Listening hooks: "+err.Error())
}
clog.Info("Listening hooks on unix " + config.Hooks.Socket)
go func() {
if err = serveGitHooks(hooksListener); err != nil {
clog.Fatal(1, "Serving hooks: "+err.Error())
}
}()
// SSH listener
sshListener, err := net.Listen(config.SSH.Net, config.SSH.Addr)
if errors.Is(err, syscall.EADDRINUSE) && config.SSH.Net == "unix" {
clog.Warn("Removing stale socket " + config.SSH.Addr)
if err = syscall.Unlink(config.SSH.Addr); err != nil {
clog.Fatal(1, "Removing stale socket: "+err.Error())
}
if sshListener, err = net.Listen(config.SSH.Net, config.SSH.Addr); err != nil {
clog.Fatal(1, "Listening SSH: "+err.Error())
}
} else if err != nil {
clog.Fatal(1, "Listening SSH: "+err.Error())
}
clog.Info("Listening SSH on " + config.SSH.Net + " " + config.SSH.Addr)
go func() {
if err = serveSSH(sshListener); err != nil {
clog.Fatal(1, "Serving SSH: "+err.Error())
}
}()
// HTTP listener
httpListener, err := net.Listen(config.HTTP.Net, config.HTTP.Addr)
if errors.Is(err, syscall.EADDRINUSE) && config.HTTP.Net == "unix" {
clog.Warn("Removing stale socket " + config.HTTP.Addr)
if err = syscall.Unlink(config.HTTP.Addr); err != nil {
clog.Fatal(1, "Removing stale socket: "+err.Error())
}
if httpListener, err = net.Listen(config.HTTP.Net, config.HTTP.Addr); err != nil {
clog.Fatal(1, "Listening HTTP: "+err.Error())
}
} else if err != nil {
clog.Fatal(1, "Listening HTTP: "+err.Error())
}
clog.Info("Listening HTTP on " + config.HTTP.Net + " " + config.HTTP.Addr)
go func() {
if err = http.Serve(httpListener, &httpRouter{}); err != nil {
if err = http.Serve(httpListener, &forgeHTTPRouter{}); err != nil {
clog.Fatal(1, "Serving HTTP: "+err.Error())
}
}()
// Pprof listener
pprofListener, err := net.Listen("tcp", "localhost:6060")
if err != nil {
clog.Fatal(1, "Listening pprof: "+err.Error())
}
clog.Info("Listening pprof on tcp localhost:6060")
go func() {
if err = http.Serve(pprofListener, nil); err != nil {
clog.Fatal(1, "Serving pprof: "+err.Error())
}
}()
select {}
}