AI: Refine project structure.

Author: ossrs-ai

Makefile

@@ -4,20 +4,20 @@ all: build
 
 build: fmt ./srs-proxy
 
-./srs-proxy: *.go
-	go build -o srs-proxy .
+./srs-proxy: cmd/proxy-go/*.go internal/**/*.go
+	go build -o srs-proxy ./cmd/proxy-go
 
 test:
 	go test ./...
 
 fmt: ./.go-formarted
 
-./.go-formarted: *.go
+./.go-formarted: cmd/proxy-go/*.go internal/**/*.go
 	touch .go-formarted
 	go fmt ./...
 
 clean:
 	rm -f srs-proxy .go-formarted
 
 run: fmt
-	go run .
+	go run ./cmd/proxy-go

main.go renamed to cmd/proxy-go/main.go

@@ -7,17 +7,24 @@ import (
 	"context"
 	"os"
 
-	"srs-proxy/errors"
-	"srs-proxy/logger"
+	"srs-proxy/internal/debug"
+	"srs-proxy/internal/env"
+	"srs-proxy/internal/errors"
+	"srs-proxy/internal/lb"
+	"srs-proxy/internal/logger"
+	"srs-proxy/internal/protocol"
+	"srs-proxy/internal/signal"
+	"srs-proxy/internal/utils"
+	"srs-proxy/internal/version"
 )
 
 func main() {
 	ctx := logger.WithContext(context.Background())
-	logger.Df(ctx, "%v/%v started", Signature(), Version())
+	logger.Df(ctx, "%v/%v started", version.Signature(), version.Version())
 
 	// Install signals.
 	ctx, cancel := context.WithCancel(ctx)
-	installSignals(ctx, cancel)
+	signal.InstallSignals(ctx, cancel)
 
 	// Start the main loop, ignore the user cancel error.
 	err := doMain(ctx)
@@ -26,90 +33,102 @@ func main() {
 		os.Exit(-1)
 	}
 
-	logger.Df(ctx, "%v done", Signature())
+	logger.Df(ctx, "%v done", version.Signature())
 }
 
 func doMain(ctx context.Context) error {
 	// Setup the environment variables.
-	if err := loadEnvFile(ctx); err != nil {
+	if err := env.LoadEnvFile(ctx); err != nil {
 		return errors.Wrapf(err, "load env")
 	}
 
-	buildDefaultEnvironmentVariables(ctx)
+	env.BuildDefaultEnvironmentVariables(ctx)
 
 	// When cancelled, the program is forced to exit due to a timeout. Normally, this doesn't occur
 	// because the main thread exits after the context is cancelled. However, sometimes the main thread
 	// may be blocked for some reason, so a forced exit is necessary to ensure the program terminates.
-	if err := installForceQuit(ctx); err != nil {
+	if err := signal.InstallForceQuit(ctx); err != nil {
 		return errors.Wrapf(err, "install force quit")
 	}
 
 	// Start the Go pprof if enabled.
-	handleGoPprof(ctx)
+	debug.HandleGoPprof(ctx)
 
-	// Initialize SRS load balancers.
-	switch lbType := envLoadBalancerType(); lbType {
-	case "memory":
-		srsLoadBalancer = NewMemoryLoadBalancer()
+	// Initialize the load balancer.
+	switch env.EnvLoadBalancerType() {
 	case "redis":
-		srsLoadBalancer = NewRedisLoadBalancer()
+		lb.SrsLoadBalancer = lb.NewRedisLoadBalancer(
+			env.EnvRedisHost,
+			env.EnvRedisPort,
+			env.EnvRedisPassword,
+			env.EnvRedisDB,
+			env.EnvDefaultBackendEnabled,
+			env.EnvDefaultBackendIP,
+			env.EnvDefaultBackendRTMP,
+			env.EnvDefaultBackendHttp,
+			env.EnvDefaultBackendAPI,
+			env.EnvDefaultBackendRTC,
+			env.EnvDefaultBackendSRT,
+		)
 	default:
-		return errors.Errorf("invalid load balancer %v", lbType)
+		lb.SrsLoadBalancer = lb.NewMemoryLoadBalancer(
+			env.EnvDefaultBackendEnabled,
+			env.EnvDefaultBackendIP,
+			env.EnvDefaultBackendRTMP,
+			env.EnvDefaultBackendHttp,
+			env.EnvDefaultBackendAPI,
+			env.EnvDefaultBackendRTC,
+			env.EnvDefaultBackendSRT,
+		)
 	}
 
-	if err := srsLoadBalancer.Initialize(ctx); err != nil {
+	if err := lb.SrsLoadBalancer.Initialize(ctx); err != nil {
 		return errors.Wrapf(err, "initialize srs load balancer")
 	}
 
 	// Parse the gracefully quit timeout.
-	gracefulQuitTimeout, err := parseGracefullyQuitTimeout()
+	gracefulQuitTimeout, err := utils.ParseGracefullyQuitTimeout()
 	if err != nil {
 		return errors.Wrapf(err, "parse gracefully quit timeout")
 	}
 
 	// Start the RTMP server.
-	srsRTMPServer := NewSRSRTMPServer()
+	srsRTMPServer := protocol.NewSRSRTMPServer()
 	defer srsRTMPServer.Close()
 	if err := srsRTMPServer.Run(ctx); err != nil {
 		return errors.Wrapf(err, "rtmp server")
 	}
 
 	// Start the WebRTC server.
-	srsWebRTCServer := NewSRSWebRTCServer()
+	srsWebRTCServer := protocol.NewSRSWebRTCServer()
 	defer srsWebRTCServer.Close()
 	if err := srsWebRTCServer.Run(ctx); err != nil {
 		return errors.Wrapf(err, "rtc server")
 	}
 
 	// Start the HTTP API server.
-	srsHTTPAPIServer := NewSRSHTTPAPIServer(func(server *srsHTTPAPIServer) {
-		server.gracefulQuitTimeout, server.rtc = gracefulQuitTimeout, srsWebRTCServer
-	})
+	srsHTTPAPIServer := protocol.NewSRSHTTPAPIServer(gracefulQuitTimeout, srsWebRTCServer)
 	defer srsHTTPAPIServer.Close()
 	if err := srsHTTPAPIServer.Run(ctx); err != nil {
 		return errors.Wrapf(err, "http api server")
 	}
 
 	// Start the SRT server.
-	srsSRTServer := NewSRSSRTServer()
+	srsSRTServer := protocol.NewSRSSRTServer()
 	defer srsSRTServer.Close()
 	if err := srsSRTServer.Run(ctx); err != nil {
 		return errors.Wrapf(err, "srt server")
 	}
 
 	// Start the System API server.
-	systemAPI := NewSystemAPI(func(server *systemAPI) {
-		server.gracefulQuitTimeout = gracefulQuitTimeout
-	})
+	systemAPI := protocol.NewSystemAPI(gracefulQuitTimeout)
 	defer systemAPI.Close()
 	if err := systemAPI.Run(ctx); err != nil {
 		return errors.Wrapf(err, "system api server")
 	}
 
 	// Start the HTTP web server.
-	srsHTTPStreamServer := NewSRSHTTPStreamServer(func(server *srsHTTPStreamServer) {
-		server.gracefulQuitTimeout = gracefulQuitTimeout
-	})
+	srsHTTPStreamServer := protocol.NewSRSHTTPStreamServer(gracefulQuitTimeout)
 	defer srsHTTPStreamServer.Close()
 	if err := srsHTTPStreamServer.Run(ctx); err != nil {
 		return errors.Wrapf(err, "http server")

doc/files.md

@@ -0,0 +1,67 @@
+# Codebase Structure
+
+This document provides an overview of the proxy-go codebase organization.
+
+## Directory Structure
+
+```
+proxy-go/
+├── cmd/proxy-go/
+│   └── main.go                 # Application entry point
+└── internal/
+    ├── debug/                  # Go profiling support
+    ├── env/                    # Configuration management
+    ├── errors/                 # Error handling with stack traces
+    ├── lb/                     # Load balancer (memory/Redis)
+    ├── logger/                 # Logging and request tracing
+    ├── protocol/               # Protocol servers (RTMP, HTTP, WebRTC, SRT, API)
+    ├── rtmp/                   # RTMP protocol implementation
+    ├── signal/                 # Graceful shutdown handling
+    ├── sync/                   # Concurrency utilities
+    ├── utils/                  # Common utilities
+    └── version/                # Version information
+```
+
+## Internal Packages
+
+### debug
+Go profiling support via pprof, controlled by `GO_PPROF` environment variable.
+
+### env
+Configuration management using environment variables. Loads `.env` file and provides defaults for all server settings.
+
+### errors
+Enhanced error handling with stack traces. Provides error wrapping and root cause extraction.
+
+### lb
+Load balancer system supporting both single-proxy (memory-based) and multi-proxy (Redis-based) deployments.
+- `lb.go` - Core interfaces and types
+- `mem.go` - Memory-based load balancer
+- `redis.go` - Redis-based load balancer
+- `debug.go` - Default backend for testing
+
+### logger
+Structured logging with context-based request tracing. Provides log levels: Verbose, Debug, Warning, Error.
+
+### protocol
+Protocol server implementations for all supported streaming protocols:
+- `rtmp.go` - RTMP proxy server
+- `http.go` - HTTP streaming (HLS, HTTP-FLV, HTTP-TS)
+- `rtc.go` - WebRTC server (WHIP/WHEP)
+- `srt.go` - SRT server
+- `api.go` - HTTP API server
+
+### rtmp
+Low-level RTMP protocol implementation including handshake and AMF0 serialization.
+
+### signal
+Graceful shutdown coordination. Catches SIGINT/SIGTERM and implements timeout-based shutdown.
+
+### sync
+Thread-safe generic Map wrapper around `sync.Map` for connection tracking and caching.
+
+### utils
+Common utility functions for HTTP responses, JSON marshaling, and parsing.
+
+### version
+Version information and server identification.