feat(nginx): performance optimization #850

internal/nginx/config_info.go

@@ -1,7 +1,7 @@
 package nginx
 
 import (
-	"os/exec"
+	"os"
 	"regexp"
 	"runtime"
 	"strconv"
@@ -10,29 +10,51 @@ import (
 )
 
 type NginxConfigInfo struct {
-	WorkerProcesses   int    `json:"worker_processes"`
-	WorkerConnections int    `json:"worker_connections"`
-	ProcessMode       string `json:"process_mode"`
+	WorkerProcesses           int    `json:"worker_processes"`
+	WorkerConnections         int    `json:"worker_connections"`
+	ProcessMode               string `json:"process_mode"`
+	KeepaliveTimeout          int    `json:"keepalive_timeout"`
+	Gzip                      string `json:"gzip"`
+	GzipMinLength             int    `json:"gzip_min_length"`
+	GzipCompLevel             int    `json:"gzip_comp_level"`
+	ClientMaxBodySize         string `json:"client_max_body_size"` // with unit
+	ServerNamesHashBucketSize int    `json:"server_names_hash_bucket_size"`
+	ClientHeaderBufferSize    string `json:"client_header_buffer_size"` // with unit
+	ClientBodyBufferSize      string `json:"client_body_buffer_size"`   // with unit
 }
 
 // GetNginxWorkerConfigInfo Get Nginx config info of worker_processes and worker_connections
 func GetNginxWorkerConfigInfo() (*NginxConfigInfo, error) {
 	result := &NginxConfigInfo{
-		WorkerProcesses:   1,
-		WorkerConnections: 1024,
-		ProcessMode:       "manual",
+		WorkerProcesses:           1,
+		WorkerConnections:         1024,
+		ProcessMode:               "manual",
+		KeepaliveTimeout:          65,
+		Gzip:                      "off",
+		GzipMinLength:             1,
+		GzipCompLevel:             1,
+		ClientMaxBodySize:         "1m",
+		ServerNamesHashBucketSize: 32,
+		ClientHeaderBufferSize:    "1k",
+		ClientBodyBufferSize:      "8k",
 	}
 
-	// Get worker_processes config
-	cmd := exec.Command("nginx", "-T")
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		return result, errors.Wrap(err, "failed to get nginx config")
+	confPath := GetConfPath("nginx.conf")
+	if confPath == "" {
+		return nil, errors.New("failed to get nginx.conf path")
 	}
 
+	// Read the current configuration
+	content, err := os.ReadFile(confPath)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to read nginx.conf")
+	}
+
+	outputStr := string(content)
+
 	// Parse worker_processes
 	wpRe := regexp.MustCompile(`worker_processes\s+(\d+|auto);`)
-	if matches := wpRe.FindStringSubmatch(string(output)); len(matches) > 1 {
+	if matches := wpRe.FindStringSubmatch(outputStr); len(matches) > 1 {
 		if matches[1] == "auto" {
 			result.WorkerProcesses = runtime.NumCPU()
 			result.ProcessMode = "auto"
@@ -44,9 +66,57 @@ func GetNginxWorkerConfigInfo() (*NginxConfigInfo, error) {
 
 	// Parse worker_connections
 	wcRe := regexp.MustCompile(`worker_connections\s+(\d+);`)
-	if matches := wcRe.FindStringSubmatch(string(output)); len(matches) > 1 {
+	if matches := wcRe.FindStringSubmatch(outputStr); len(matches) > 1 {
 		result.WorkerConnections, _ = strconv.Atoi(matches[1])
 	}
 
+	// Parse keepalive_timeout
+	ktRe := regexp.MustCompile(`keepalive_timeout\s+(\d+);`)
+	if matches := ktRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.KeepaliveTimeout, _ = strconv.Atoi(matches[1])
+	}
+
+	// Parse gzip
+	gzipRe := regexp.MustCompile(`gzip\s+(on|off);`)
+	if matches := gzipRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.Gzip = matches[1]
+	}
+
+	// Parse gzip_min_length
+	gzipMinRe := regexp.MustCompile(`gzip_min_length\s+(\d+);`)
+	if matches := gzipMinRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.GzipMinLength, _ = strconv.Atoi(matches[1])
+	}
+
+	// Parse gzip_comp_level
+	gzipCompRe := regexp.MustCompile(`gzip_comp_level\s+(\d+);`)
+	if matches := gzipCompRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.GzipCompLevel, _ = strconv.Atoi(matches[1])
+	}
+
+	// Parse client_max_body_size with any unit (k, m, g)
+	cmaxRe := regexp.MustCompile(`client_max_body_size\s+(\d+[kmg]?);`)
+	if matches := cmaxRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.ClientMaxBodySize = matches[1]
+	}
+
+	// Parse server_names_hash_bucket_size
+	hashRe := regexp.MustCompile(`server_names_hash_bucket_size\s+(\d+);`)
+	if matches := hashRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.ServerNamesHashBucketSize, _ = strconv.Atoi(matches[1])
+	}
+
+	// Parse client_header_buffer_size with any unit (k, m, g)
+	headerRe := regexp.MustCompile(`client_header_buffer_size\s+(\d+[kmg]?);`)
+	if matches := headerRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.ClientHeaderBufferSize = matches[1]
+	}
+
+	// Parse client_body_buffer_size with any unit (k, m, g)
+	bodyRe := regexp.MustCompile(`client_body_buffer_size\s+(\d+[kmg]?);`)
+	if matches := bodyRe.FindStringSubmatch(outputStr); len(matches) > 1 {
+		result.ClientBodyBufferSize = matches[1]
+	}
+
 	return result, nil
 }