Add tunnel batch-size knob to embed; rename to Performance

proxy/internal/debug/client.go

@@ -284,32 +284,21 @@ func (c *Client) printLogLevelResult(data map[string]any) {
 	}
 }
 
-// WGTuneGet fetches the current WireGuard pool cap.
-func (c *Client) WGTuneGet(ctx context.Context) error {
-	return c.fetchAndPrint(ctx, "/debug/wgtune", c.printWGTuneGet)
+// PerfSet live-retunes the tunnel buffer pool cap on all running embedded
+// clients. Batch size is not live-tunable; configure it at proxy startup.
+func (c *Client) PerfSet(ctx context.Context, value uint32) error {
+	path := fmt.Sprintf("/debug/perf?value=%d", value)
+	return c.fetchAndPrint(ctx, path, c.printPerfSet)
 }
 
-// WGTuneSet updates the WireGuard pool cap on the global default and all live clients.
-func (c *Client) WGTuneSet(ctx context.Context, value uint32) error {
-	path := fmt.Sprintf("/debug/wgtune?value=%d", value)
-	return c.fetchAndPrint(ctx, path, c.printWGTuneSet)
-}
-
-func (c *Client) printWGTuneGet(data map[string]any) {
-	def, _ := data["default"].(float64)
-	batch, _ := data["batch_size"].(float64)
-	_, _ = fmt.Fprintf(c.out, "Default:    %d\n", uint32(def))
-	_, _ = fmt.Fprintf(c.out, "Batch size: %d (0 = unset)\n", uint32(batch))
-}
-
-func (c *Client) printWGTuneSet(data map[string]any) {
+func (c *Client) printPerfSet(data map[string]any) {
 	if errMsg, ok := data["error"].(string); ok && errMsg != "" {
 		c.printError(data)
 		return
 	}
-	def, _ := data["default"].(float64)
+	val, _ := data["value"].(float64)
 	applied, _ := data["applied"].(float64)
-	_, _ = fmt.Fprintf(c.out, "Default set to: %d\n", uint32(def))
+	_, _ = fmt.Fprintf(c.out, "Pool cap set to: %d\n", uint32(val))
 	_, _ = fmt.Fprintf(c.out, "Applied to %d live clients\n", int(applied))
 	if failed, ok := data["failed"].(map[string]any); ok && len(failed) > 0 {
 		_, _ = fmt.Fprintln(c.out, "Failed:")

proxy/internal/debug/handler.go

@@ -143,8 +143,8 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		h.handleListClients(w, r, wantJSON)
 	case "/debug/health":
 		h.handleHealth(w, r, wantJSON)
-	case "/debug/wgtune":
-		h.handleWGTune(w, r)
+	case "/debug/perf":
+		h.handlePerf(w, r)
 	case "/debug/runtime":
 		h.handleRuntime(w, r)
 	default:
@@ -650,33 +650,23 @@ func (h *Handler) handleClientStop(w http.ResponseWriter, r *http.Request, accou
 	})
 }
 
-func (h *Handler) handleWGTune(w http.ResponseWriter, r *http.Request) {
-	values, ok := r.URL.Query()["value"]
-	if !ok {
-		h.writeJSON(w, map[string]any{
-			"default":    nbembed.WGDefaultPreallocatedBuffersPerPool(),
-			"batch_size": nbembed.WGDefaultMaxBatchSize(),
-		})
+func (h *Handler) handlePerf(w http.ResponseWriter, r *http.Request) {
+	raw := r.URL.Query().Get("value")
+	if raw == "" {
+		http.Error(w, "value parameter is required", http.StatusBadRequest)
 		return
 	}
-	if len(values) == 0 || values[0] == "" {
-		http.Error(w, "value parameter must not be empty", http.StatusBadRequest)
-		return
-	}
-	raw := values[0]
-
 	n, err := strconv.ParseUint(raw, 10, 32)
 	if err != nil {
 		http.Error(w, fmt.Sprintf("invalid value %q: %v", raw, err), http.StatusBadRequest)
 		return
 	}
-	nbembed.SetWGDefaultPreallocatedBuffersPerPool(uint32(n))
 
+	capN := uint32(n)
 	applied := 0
 	failed := map[string]string{}
 	for accountID, client := range h.provider.ListClientsForStartup() {
-		capN := uint32(n)
-		if err := client.SetWGTuning(nbembed.WGTuning{PreallocatedBuffersPerPool: &capN}); err != nil {
+		if err := client.SetPerformance(nbembed.Performance{PreallocatedBuffersPerPool: &capN}); err != nil {
 			failed[string(accountID)] = err.Error()
 			continue
 		}
@@ -684,10 +674,9 @@ func (h *Handler) handleWGTune(w http.ResponseWriter, r *http.Request) {
 	}
 
 	resp := map[string]any{
-		"success":    true,
-		"default":    uint32(n),
-		"batch_size": nbembed.WGDefaultMaxBatchSize(),
-		"applied":    applied,
+		"success": true,
+		"value":   capN,
+		"applied": applied,
 	}
 	if len(failed) > 0 {
 		resp["failed"] = failed