Admin UI: replace gin with mux (#8420)

* Replace admin gin router with mux

* Update layout_templ.go

* Harden admin handlers

* Add login CSRF handling

* Fix filer copy naming conflict

* address comments

* address comments

weed/admin/dash/admin_data.go

@@ -6,7 +6,6 @@ import (
 	"sort"
 	"time"
 
-	"github.com/gin-gonic/gin"
 	"github.com/seaweedfs/seaweedfs/weed/cluster"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/iam"
@@ -185,28 +184,28 @@ func (s *AdminServer) GetAdminData(username string) (AdminData, error) {
 }
 
 // ShowAdmin displays the main admin page (now uses GetAdminData)
-func (s *AdminServer) ShowAdmin(c *gin.Context) {
-	username := c.GetString("username")
+func (s *AdminServer) ShowAdmin(w http.ResponseWriter, r *http.Request) {
+	username := UsernameFromContext(r.Context())
 
 	adminData, err := s.GetAdminData(username)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get admin data: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get admin data: "+err.Error())
 		return
 	}
 
 	// Return JSON for API calls
-	c.JSON(http.StatusOK, adminData)
+	writeJSON(w, http.StatusOK, adminData)
 }
 
 // ShowOverview displays cluster overview
-func (s *AdminServer) ShowOverview(c *gin.Context) {
+func (s *AdminServer) ShowOverview(w http.ResponseWriter, r *http.Request) {
 	topology, err := s.GetClusterTopology()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, topology)
+	writeJSON(w, http.StatusOK, topology)
 }
 
 // getMasterNodesStatus checks status of all master nodes

weed/admin/dash/admin_server.go

@@ -7,8 +7,6 @@ import (
 	"sort"
 	"strings"
 	"time"
-
-	"github.com/gin-gonic/gin"
 	"github.com/seaweedfs/seaweedfs/weed/admin/maintenance"
 	adminplugin "github.com/seaweedfs/seaweedfs/weed/admin/plugin"
 	"github.com/seaweedfs/seaweedfs/weed/cluster"
@@ -817,18 +815,18 @@ func (s *AdminServer) GetClusterBrokers() (*ClusterBrokersData, error) {
 // VacuumVolume method moved to volume_management.go
 
 // TriggerTopicRetentionPurgeAPI triggers topic retention purge via HTTP API
-func (as *AdminServer) TriggerTopicRetentionPurgeAPI(c *gin.Context) {
+func (as *AdminServer) TriggerTopicRetentionPurgeAPI(w http.ResponseWriter, r *http.Request) {
 	err := as.TriggerTopicRetentionPurge()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{"message": "Topic retention purge triggered successfully"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Topic retention purge triggered successfully"})
 }
 
 // GetConfigInfo returns information about the admin configuration
-func (as *AdminServer) GetConfigInfo(c *gin.Context) {
+func (as *AdminServer) GetConfigInfo(w http.ResponseWriter, r *http.Request) {
 	configInfo := as.configPersistence.GetConfigInfo()
 
 	// Add additional admin server info
@@ -846,7 +844,7 @@ func (as *AdminServer) GetConfigInfo(c *gin.Context) {
 		configInfo["maintenance_running"] = false
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"config_info": configInfo,
 		"title":       "Configuration Information",
 	})

weed/admin/dash/auth_middleware.go

@@ -4,81 +4,91 @@ import (
 	"crypto/subtle"
 	"net/http"
 
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/sessions"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 )
 
-// ShowLogin displays the login page
-func (s *AdminServer) ShowLogin(c *gin.Context) {
-	// If authentication is not required, redirect to admin
-	session := sessions.Default(c)
-	if session.Get("authenticated") == true {
-		c.Redirect(http.StatusSeeOther, "/admin")
-		return
-	}
-
-	// For now, return a simple login form as JSON
-	c.HTML(http.StatusOK, "login.html", gin.H{
-		"title": "SeaweedFS Admin Login",
-		"error": c.Query("error"),
-	})
+// ShowLogin displays the login page.
+func (s *AdminServer) ShowLogin(w http.ResponseWriter, r *http.Request) {
+	http.Redirect(w, r, "/login", http.StatusSeeOther)
 }
 
-// HandleLogin handles login form submission
-func (s *AdminServer) HandleLogin(adminUser, adminPassword, readOnlyUser, readOnlyPassword string) gin.HandlerFunc {
-	return func(c *gin.Context) {
-		loginUsername := c.PostForm("username")
-		loginPassword := c.PostForm("password")
+// HandleLogin handles login form submission.
+func (s *AdminServer) HandleLogin(store sessions.Store, adminUser, adminPassword, readOnlyUser, readOnlyPassword string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if err := r.ParseForm(); err != nil {
+			http.Redirect(w, r, "/login?error=Invalid form submission", http.StatusSeeOther)
+			return
+		}
+		session, err := store.Get(r, sessionName)
+		if err != nil {
+			http.Redirect(w, r, "/login?error=Unable to create session. Please try again or contact administrator.", http.StatusSeeOther)
+			return
+		}
+
+		if err := ValidateSessionCSRFToken(session, r); err != nil {
+			http.Redirect(w, r, "/login?error=Invalid CSRF token", http.StatusSeeOther)
+			return
+		}
+
+		loginUsername := r.FormValue("username")
+		loginPassword := r.FormValue("password")
 
 		var role string
 		var authenticated bool
 
-		// Check admin credentials
+		// Check admin credentials.
 		if adminPassword != "" && loginUsername == adminUser && subtle.ConstantTimeCompare([]byte(loginPassword), []byte(adminPassword)) == 1 {
 			role = "admin"
 			authenticated = true
 		} else if readOnlyPassword != "" && loginUsername == readOnlyUser && subtle.ConstantTimeCompare([]byte(loginPassword), []byte(readOnlyPassword)) == 1 {
-			// Check read-only credentials
+			// Check read-only credentials.
 			role = "readonly"
 			authenticated = true
 		}
 
 		if authenticated {
-			session := sessions.Default(c)
-			// Clear any existing invalid session data before setting new values
-			session.Clear()
-			session.Set("authenticated", true)
-			session.Set("username", loginUsername)
-			session.Set("role", role)
+			for key := range session.Values {
+				delete(session.Values, key)
+			}
+			session.Values["authenticated"] = true
+			session.Values["username"] = loginUsername
+			session.Values["role"] = role
 			csrfToken, err := generateCSRFToken()
 			if err != nil {
-				c.Redirect(http.StatusSeeOther, "/login?error=Unable to create session. Please try again or contact administrator.")
+				http.Redirect(w, r, "/login?error=Unable to create session. Please try again or contact administrator.", http.StatusSeeOther)
 				return
 			}
-			session.Set(sessionCSRFTokenKey, csrfToken)
-			if err := session.Save(); err != nil {
-				// Log the detailed error server-side for diagnostics
+			session.Values[sessionCSRFTokenKey] = csrfToken
+			if err := session.Save(r, w); err != nil {
+				// Log the detailed error server-side for diagnostics.
 				glog.Errorf("Failed to save session for user %s: %v", loginUsername, err)
-				c.Redirect(http.StatusSeeOther, "/login?error=Unable to create session. Please try again or contact administrator.")
+				http.Redirect(w, r, "/login?error=Unable to create session. Please try again or contact administrator.", http.StatusSeeOther)
 				return
 			}
 
-			c.Redirect(http.StatusSeeOther, "/admin")
+			http.Redirect(w, r, "/admin", http.StatusSeeOther)
 			return
 		}
 
-		// Authentication failed
-		c.Redirect(http.StatusSeeOther, "/login?error=Invalid credentials")
+		// Authentication failed.
+		http.Redirect(w, r, "/login?error=Invalid credentials", http.StatusSeeOther)
 	}
 }
 
-// HandleLogout handles user logout
-func (s *AdminServer) HandleLogout(c *gin.Context) {
-	session := sessions.Default(c)
-	session.Clear()
-	if err := session.Save(); err != nil {
+// HandleLogout handles user logout.
+func (s *AdminServer) HandleLogout(store sessions.Store, w http.ResponseWriter, r *http.Request) {
+	session, err := store.Get(r, sessionName)
+	if err != nil {
+		http.Redirect(w, r, "/login", http.StatusSeeOther)
+		return
+	}
+	for key := range session.Values {
+		delete(session.Values, key)
+	}
+	session.Options.MaxAge = -1
+	if err := session.Save(r, w); err != nil {
 		glog.Warningf("Failed to save session during logout: %v", err)
 	}
-	c.Redirect(http.StatusSeeOther, "/login")
+	http.Redirect(w, r, "/login", http.StatusSeeOther)
 }

weed/admin/dash/bucket_management.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
 	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
 	"github.com/seaweedfs/seaweedfs/weed/s3api"
 	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
@@ -29,7 +29,7 @@ type S3BucketsData struct {
 }
 
 type CreateBucketRequest struct {
-	Name                string `json:"name" binding:"required"`
+	Name                string `json:"name"` // validated manually in CreateBucket
 	Region              string `json:"region"`
 	QuotaSize           int64  `json:"quota_size"`            // Quota size in bytes
 	QuotaUnit           string `json:"quota_unit"`            // Unit: MB, GB, TB
@@ -45,47 +45,51 @@ type CreateBucketRequest struct {
 // S3 Bucket Management Handlers
 
 // ShowS3Buckets displays the Object Store buckets management page
-func (s *AdminServer) ShowS3Buckets(c *gin.Context) {
-	username := c.GetString("username")
+func (s *AdminServer) ShowS3Buckets(w http.ResponseWriter, r *http.Request) {
+	username := UsernameFromContext(r.Context())
 
 	data, err := s.GetS3BucketsData()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get Object Store buckets: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get Object Store buckets: "+err.Error())
 		return
 	}
 
 	data.Username = username
-	c.JSON(http.StatusOK, data)
+	writeJSON(w, http.StatusOK, data)
 }
 
 // ShowBucketDetails displays detailed information about a specific bucket
-func (s *AdminServer) ShowBucketDetails(c *gin.Context) {
-	bucketName := c.Param("bucket")
+func (s *AdminServer) ShowBucketDetails(w http.ResponseWriter, r *http.Request) {
+	bucketName := mux.Vars(r)["bucket"]
 	if bucketName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Bucket name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Bucket name is required")
 		return
 	}
 
 	details, err := s.GetBucketDetails(bucketName)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get bucket details: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get bucket details: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, details)
+	writeJSON(w, http.StatusOK, details)
 }
 
 // CreateBucket creates a new S3 bucket
-func (s *AdminServer) CreateBucket(c *gin.Context) {
+func (s *AdminServer) CreateBucket(w http.ResponseWriter, r *http.Request) {
 	var req CreateBucketRequest
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
+		return
+	}
+	if strings.TrimSpace(req.Name) == "" {
+		writeJSONError(w, http.StatusBadRequest, "Bucket name is required")
 		return
 	}
 
 	// Validate bucket name (basic validation)
 	if len(req.Name) < 3 || len(req.Name) > 63 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Bucket name must be between 3 and 63 characters"})
+		writeJSONError(w, http.StatusBadRequest, "Bucket name must be between 3 and 63 characters")
 		return
 	}
 
@@ -96,42 +100,47 @@ func (s *AdminServer) CreateBucket(c *gin.Context) {
 
 		// Validate object lock mode
 		if req.ObjectLockMode != "GOVERNANCE" && req.ObjectLockMode != "COMPLIANCE" {
-			c.JSON(http.StatusBadRequest, gin.H{"error": "Object lock mode must be either GOVERNANCE or COMPLIANCE"})
+			writeJSONError(w, http.StatusBadRequest, "Object lock mode must be either GOVERNANCE or COMPLIANCE")
 			return
 		}
 
 		// Validate retention duration if default retention is enabled
 		if req.SetDefaultRetention {
 			if req.ObjectLockDuration <= 0 {
-				c.JSON(http.StatusBadRequest, gin.H{"error": "Object lock duration must be greater than 0 days when default retention is enabled"})
+				writeJSONError(w, http.StatusBadRequest, "Object lock duration must be greater than 0 days when default retention is enabled")
 				return
 			}
 		}
 	}
 
-	// Convert quota to bytes
-	quotaBytes := convertQuotaToBytes(req.QuotaSize, req.QuotaUnit)
+	normalizedUnit, err := normalizeQuotaUnit(req.QuotaUnit)
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	req.QuotaUnit = normalizedUnit
+	quotaBytes := convertQuotaToBytes(req.QuotaSize, normalizedUnit)
 
 	// Validate quota: if enabled, size must be greater than 0
 	if req.QuotaEnabled && quotaBytes <= 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Quota size must be greater than 0 when quota is enabled"})
+		writeJSONError(w, http.StatusBadRequest, "Quota size must be greater than 0 when quota is enabled")
 		return
 	}
 
 	// Sanitize owner: trim whitespace and enforce max length
 	owner := strings.TrimSpace(req.Owner)
 	if len(owner) > MaxOwnerNameLength {
-		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Owner name must be %d characters or less", MaxOwnerNameLength)})
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("Owner name must be %d characters or less", MaxOwnerNameLength))
 		return
 	}
 
-	err := s.CreateS3BucketWithObjectLock(req.Name, quotaBytes, req.QuotaEnabled, req.VersioningEnabled, req.ObjectLockEnabled, req.ObjectLockMode, req.SetDefaultRetention, req.ObjectLockDuration, owner)
+	err = s.CreateS3BucketWithObjectLock(req.Name, quotaBytes, req.QuotaEnabled, req.VersioningEnabled, req.ObjectLockEnabled, req.ObjectLockMode, req.SetDefaultRetention, req.ObjectLockDuration, owner)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create bucket: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create bucket: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusCreated, gin.H{
+	writeJSON(w, http.StatusCreated, map[string]interface{}{
 		"message":              "Bucket created successfully",
 		"bucket":               req.Name,
 		"quota_size":           req.QuotaSize,
@@ -146,10 +155,10 @@ func (s *AdminServer) CreateBucket(c *gin.Context) {
 }
 
 // UpdateBucketQuota updates the quota settings for a bucket
-func (s *AdminServer) UpdateBucketQuota(c *gin.Context) {
-	bucketName := c.Param("bucket")
+func (s *AdminServer) UpdateBucketQuota(w http.ResponseWriter, r *http.Request) {
+	bucketName := mux.Vars(r)["bucket"]
 	if bucketName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Bucket name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Bucket name is required")
 		return
 	}
 
@@ -158,21 +167,32 @@ func (s *AdminServer) UpdateBucketQuota(c *gin.Context) {
 		QuotaUnit    string `json:"quota_unit"`
 		QuotaEnabled bool   `json:"quota_enabled"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 
-	// Convert quota to bytes
-	quotaBytes := convertQuotaToBytes(req.QuotaSize, req.QuotaUnit)
+	if req.QuotaEnabled && req.QuotaSize <= 0 {
+		writeJSONError(w, http.StatusBadRequest, "quota_size must be > 0 when quota_enabled is true")
+		return
+	}
 
-	err := s.SetBucketQuota(bucketName, quotaBytes, req.QuotaEnabled)
+	normalizedUnit, err := normalizeQuotaUnit(req.QuotaUnit)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update bucket quota: " + err.Error()})
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	req.QuotaUnit = normalizedUnit
+	// Convert quota to bytes
+	quotaBytes := convertQuotaToBytes(req.QuotaSize, normalizedUnit)
+
+	err = s.SetBucketQuota(bucketName, quotaBytes, req.QuotaEnabled)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to update bucket quota: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message":       "Bucket quota updated successfully",
 		"bucket":        bucketName,
 		"quota_size":    req.QuotaSize,
@@ -182,30 +202,30 @@ func (s *AdminServer) UpdateBucketQuota(c *gin.Context) {
 }
 
 // DeleteBucket deletes an S3 bucket
-func (s *AdminServer) DeleteBucket(c *gin.Context) {
-	bucketName := c.Param("bucket")
+func (s *AdminServer) DeleteBucket(w http.ResponseWriter, r *http.Request) {
+	bucketName := mux.Vars(r)["bucket"]
 	if bucketName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Bucket name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Bucket name is required")
 		return
 	}
 
 	err := s.DeleteS3Bucket(bucketName)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete bucket: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to delete bucket: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "Bucket deleted successfully",
 		"bucket":  bucketName,
 	})
 }
 
 // UpdateBucketOwner updates the owner of an S3 bucket
-func (s *AdminServer) UpdateBucketOwner(c *gin.Context) {
-	bucketName := c.Param("bucket")
+func (s *AdminServer) UpdateBucketOwner(w http.ResponseWriter, r *http.Request) {
+	bucketName := mux.Vars(r)["bucket"]
 	if bucketName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Bucket name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Bucket name is required")
 		return
 	}
 
@@ -213,31 +233,31 @@ func (s *AdminServer) UpdateBucketOwner(c *gin.Context) {
 	var req struct {
 		Owner *string `json:"owner"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 
 	// Require owner field to be explicitly provided
 	if req.Owner == nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Owner field is required (use empty string to clear owner)"})
+		writeJSONError(w, http.StatusBadRequest, "Owner field is required (use empty string to clear owner)")
 		return
 	}
 
 	// Trim and validate owner
 	owner := strings.TrimSpace(*req.Owner)
 	if len(owner) > MaxOwnerNameLength {
-		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Owner name must be %d characters or less", MaxOwnerNameLength)})
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("Owner name must be %d characters or less", MaxOwnerNameLength))
 		return
 	}
 
 	err := s.SetBucketOwner(bucketName, owner)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update bucket owner: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to update bucket owner: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "Bucket owner updated successfully",
 		"bucket":  bucketName,
 		"owner":   owner,
@@ -284,14 +304,14 @@ func (s *AdminServer) SetBucketOwner(bucketName string, owner string) error {
 }
 
 // ListBucketsAPI returns the list of buckets as JSON
-func (s *AdminServer) ListBucketsAPI(c *gin.Context) {
+func (s *AdminServer) ListBucketsAPI(w http.ResponseWriter, r *http.Request) {
 	buckets, err := s.GetS3Buckets()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get buckets: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get buckets: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"buckets": buckets,
 		"total":   len(buckets),
 	})
@@ -303,16 +323,32 @@ func convertQuotaToBytes(size int64, unit string) int64 {
 		return 0
 	}
 
-	switch strings.ToUpper(unit) {
+	switch unit {
 	case "TB":
 		return size * 1024 * 1024 * 1024 * 1024
 	case "GB":
 		return size * 1024 * 1024 * 1024
 	case "MB":
 		return size * 1024 * 1024
+	case "KB":
+		return size * 1024
+	case "B":
+		return size
 	default:
-		// Default to MB if unit is not recognized
-		return size * 1024 * 1024
+		return 0
+	}
+}
+
+func normalizeQuotaUnit(unit string) (string, error) {
+	normalized := strings.ToUpper(strings.TrimSpace(unit))
+	if normalized == "" {
+		return "MB", nil
+	}
+	switch normalized {
+	case "B", "KB", "MB", "GB", "TB":
+		return normalized, nil
+	default:
+		return "", fmt.Errorf("unsupported quota unit: %s", unit)
 	}
 }
 

weed/admin/dash/context.go

@@ -0,0 +1,58 @@
+package dash
+
+import "context"
+
+type contextKey string
+
+const (
+	contextUsernameKey contextKey = "admin.username"
+	contextRoleKey     contextKey = "admin.role"
+	contextCSRFKey     contextKey = "admin.csrf"
+)
+
+// WithAuthContext stores auth metadata on the request context.
+func WithAuthContext(ctx context.Context, username, role, csrfToken string) context.Context {
+	if username != "" {
+		ctx = context.WithValue(ctx, contextUsernameKey, username)
+	}
+	if role != "" {
+		ctx = context.WithValue(ctx, contextRoleKey, role)
+	}
+	if csrfToken != "" {
+		ctx = context.WithValue(ctx, contextCSRFKey, csrfToken)
+	}
+	return ctx
+}
+
+// UsernameFromContext retrieves the username from context.
+func UsernameFromContext(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	if value, ok := ctx.Value(contextUsernameKey).(string); ok {
+		return value
+	}
+	return ""
+}
+
+// RoleFromContext retrieves the role from context.
+func RoleFromContext(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	if value, ok := ctx.Value(contextRoleKey).(string); ok {
+		return value
+	}
+	return ""
+}
+
+// CSRFTokenFromContext retrieves the CSRF token from context.
+func CSRFTokenFromContext(ctx context.Context) string {
+	if ctx == nil {
+		return ""
+	}
+	if value, ok := ctx.Value(contextCSRFKey).(string); ok {
+		return value
+	}
+	return ""
+}

weed/admin/dash/csrf.go

@@ -4,10 +4,10 @@ import (
 	"crypto/rand"
 	"crypto/subtle"
 	"encoding/hex"
+	"fmt"
 	"net/http"
 
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/sessions"
 )
 
 const sessionCSRFTokenKey = "csrf_token"
@@ -20,41 +20,77 @@ func generateCSRFToken() (string, error) {
 	return hex.EncodeToString(tokenBytes), nil
 }
 
-func getOrCreateSessionCSRFToken(session sessions.Session) (string, error) {
-	if existing, ok := session.Get(sessionCSRFTokenKey).(string); ok && existing != "" {
+func getOrCreateSessionCSRFToken(session *sessions.Session, r *http.Request, w http.ResponseWriter) (string, error) {
+	if existing, ok := session.Values[sessionCSRFTokenKey].(string); ok && existing != "" {
 		return existing, nil
 	}
 	token, err := generateCSRFToken()
 	if err != nil {
 		return "", err
 	}
-	session.Set(sessionCSRFTokenKey, token)
-	if err := session.Save(); err != nil {
+	session.Values[sessionCSRFTokenKey] = token
+	if err := session.Save(r, w); err != nil {
 		return "", err
 	}
 	return token, nil
 }
 
-func requireSessionCSRFToken(c *gin.Context) bool {
-	session := sessions.Default(c)
-	if session.Get("authenticated") != true {
+func requireSessionCSRFToken(w http.ResponseWriter, r *http.Request) bool {
+	expectedToken := CSRFTokenFromContext(r.Context())
+	username := UsernameFromContext(r.Context())
+	if expectedToken == "" {
 		// Admin UI can run without auth; in that mode CSRF token checks are not applicable.
-		return true
-	}
-
-	expectedToken, ok := session.Get(sessionCSRFTokenKey).(string)
-	if !ok || expectedToken == "" {
-		c.JSON(http.StatusForbidden, gin.H{"error": "missing CSRF session token"})
+		if username == "" {
+			return true
+		}
+		writeJSONError(w, http.StatusForbidden, "missing CSRF session token")
 		return false
 	}
 
-	providedToken := c.GetHeader("X-CSRF-Token")
-	if providedToken == "" {
-		providedToken = c.PostForm("csrf_token")
+	providedToken, err := getProvidedCSRFToken(r)
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Failed to parse form: "+err.Error())
+		return false
 	}
 	if providedToken == "" || subtle.ConstantTimeCompare([]byte(expectedToken), []byte(providedToken)) != 1 {
-		c.JSON(http.StatusForbidden, gin.H{"error": "invalid CSRF token"})
+		writeJSONError(w, http.StatusForbidden, "invalid CSRF token")
 		return false
 	}
 	return true
 }
+
+func getProvidedCSRFToken(r *http.Request) (string, error) {
+	providedToken := r.Header.Get("X-CSRF-Token")
+	if providedToken != "" {
+		return providedToken, nil
+	}
+	if err := r.ParseForm(); err != nil {
+		return "", err
+	}
+	return r.FormValue("csrf_token"), nil
+}
+
+func EnsureSessionCSRFToken(session *sessions.Session, r *http.Request, w http.ResponseWriter) (string, error) {
+	if session == nil {
+		return "", fmt.Errorf("session is nil")
+	}
+	return getOrCreateSessionCSRFToken(session, r, w)
+}
+
+func ValidateSessionCSRFToken(session *sessions.Session, r *http.Request) error {
+	if session == nil {
+		return fmt.Errorf("session is nil")
+	}
+	expectedToken, _ := session.Values[sessionCSRFTokenKey].(string)
+	providedToken, err := getProvidedCSRFToken(r)
+	if err != nil {
+		return fmt.Errorf("failed to read CSRF token: %w", err)
+	}
+	if expectedToken == "" {
+		return fmt.Errorf("missing session CSRF token")
+	}
+	if providedToken == "" || subtle.ConstantTimeCompare([]byte(expectedToken), []byte(providedToken)) != 1 {
+		return fmt.Errorf("invalid CSRF token")
+	}
+	return nil
+}

weed/admin/dash/http_helpers.go

@@ -0,0 +1,24 @@
+package dash
+
+import (
+	"io"
+	"net/http"
+
+	"github.com/seaweedfs/seaweedfs/weed/admin/internal/httputil"
+)
+
+func writeJSON(w http.ResponseWriter, status int, payload interface{}) {
+	httputil.WriteJSON(w, status, payload)
+}
+
+func writeJSONError(w http.ResponseWriter, status int, message string) {
+	httputil.WriteJSONError(w, status, message)
+}
+
+func decodeJSONBody(r io.Reader, v interface{}) error {
+	return httputil.DecodeJSONBody(r, v)
+}
+
+func newJSONMaxReader(w http.ResponseWriter, r *http.Request) io.Reader {
+	return httputil.NewJSONMaxReader(w, r)
+}

weed/admin/dash/middleware.go

@@ -4,109 +4,129 @@ import (
 	"net/http"
 	"strings"
 
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
+	"github.com/gorilla/sessions"
 )
 
-// setAuthContext sets username and role in context for use in handlers
-func setAuthContext(c *gin.Context, username, role interface{}) {
-	c.Set("username", username)
-	if role != nil {
-		c.Set("role", role)
-	} else {
-		// Default to admin for backward compatibility
-		c.Set("role", "admin")
-	}
+const sessionName = "admin-session"
+
+// SessionName returns the cookie session name used by the admin UI.
+func SessionName() string {
+	return sessionName
 }
 
-// RequireAuth checks if user is authenticated
-func RequireAuth() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		session := sessions.Default(c)
-		authenticated := session.Get("authenticated")
-		username := session.Get("username")
-		role := session.Get("role")
+type sessionValidationErrorKind int
 
-		if authenticated != true || username == nil {
-			c.Redirect(http.StatusTemporaryRedirect, "/login")
-			c.Abort()
-			return
-		}
+const (
+	sessionValidationErrorKindUnauthenticated sessionValidationErrorKind = iota
+	sessionValidationErrorKindSessionInit
+)
 
-		csrfToken, err := getOrCreateSessionCSRFToken(session)
-		if err != nil {
-			c.Redirect(http.StatusTemporaryRedirect, "/login?error=Unable to initialize session")
-			c.Abort()
-			return
-		}
-
-		// Set username and role in context for use in handlers
-		setAuthContext(c, username, role)
-		c.Set("csrf_token", csrfToken)
-		c.Next()
-	}
+type sessionValidationError struct {
+	kind sessionValidationErrorKind
+	err  error
 }
 
-// RequireAuthAPI checks if user is authenticated for API endpoints
-// Returns JSON error instead of redirecting to login page
-func RequireAuthAPI() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		session := sessions.Default(c)
-		authenticated := session.Get("authenticated")
-		username := session.Get("username")
-		role := session.Get("role")
-
-		if authenticated != true || username == nil {
-			c.JSON(http.StatusUnauthorized, gin.H{
-				"error":   "Authentication required",
-				"message": "Please log in to access this endpoint",
-			})
-			c.Abort()
-			return
-		}
-
-		csrfToken, err := getOrCreateSessionCSRFToken(session)
-		if err != nil {
-			c.JSON(http.StatusInternalServerError, gin.H{
-				"error":   "Failed to initialize session",
-				"message": "Unable to initialize CSRF token",
-			})
-			c.Abort()
-			return
-		}
-
-		// Set username and role in context for use in handlers
-		setAuthContext(c, username, role)
-		c.Set("csrf_token", csrfToken)
-		c.Next()
+func (e *sessionValidationError) Error() string {
+	if e.err != nil {
+		return e.err.Error()
 	}
+	return "session validation failed"
 }
 
-// RequireWriteAccess checks if user has admin role (write access)
-// Returns JSON error for API endpoints, redirects for HTML endpoints
-func RequireWriteAccess() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		role, exists := c.Get("role")
-		if !exists {
-			role = "admin" // Default for backward compatibility
-		}
+func (e *sessionValidationError) Unwrap() error {
+	return e.err
+}
 
-		roleStr, ok := role.(string)
-		if !ok || roleStr != "admin" {
-			// Check if this is an API request (path starts with /api) or HTML request
-			path := c.Request.URL.Path
-			if strings.HasPrefix(path, "/api") {
-				c.JSON(http.StatusForbidden, gin.H{
-					"error":   "Insufficient permissions",
-					"message": "This operation requires admin access. Read-only users can only view data.",
-				})
-			} else {
-				c.Redirect(http.StatusSeeOther, "/admin?error=Insufficient permissions")
+func validateSession(store sessions.Store, w http.ResponseWriter, r *http.Request) (string, string, string, error) {
+	session, err := store.Get(r, sessionName)
+	if err != nil {
+		return "", "", "", &sessionValidationError{kind: sessionValidationErrorKindSessionInit, err: err}
+	}
+
+	authenticated, _ := session.Values["authenticated"].(bool)
+	username, _ := session.Values["username"].(string)
+	role, _ := session.Values["role"].(string)
+	if !authenticated || username == "" {
+		return "", "", "", &sessionValidationError{kind: sessionValidationErrorKindUnauthenticated}
+	}
+
+	csrfToken, err := getOrCreateSessionCSRFToken(session, r, w)
+	if err != nil {
+		return "", "", "", &sessionValidationError{kind: sessionValidationErrorKindSessionInit, err: err}
+	}
+
+	return username, role, csrfToken, nil
+}
+
+// RequireAuth checks if user is authenticated.
+func RequireAuth(store sessions.Store) mux.MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			username, role, csrfToken, err := validateSession(store, w, r)
+			if err != nil {
+				if verr, ok := err.(*sessionValidationError); ok && verr.kind == sessionValidationErrorKindUnauthenticated {
+					http.Redirect(w, r, "/login", http.StatusTemporaryRedirect)
+				} else {
+					http.Redirect(w, r, "/login?error=Unable to initialize session", http.StatusTemporaryRedirect)
+				}
+				return
 			}
-			c.Abort()
-			return
-		}
 
-		c.Next()
+			ctx := WithAuthContext(r.Context(), username, role, csrfToken)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
+
+// RequireAuthAPI checks if user is authenticated for API endpoints.
+// Returns JSON error instead of redirecting to login page.
+func RequireAuthAPI(store sessions.Store) mux.MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			username, role, csrfToken, err := validateSession(store, w, r)
+			if err != nil {
+				if verr, ok := err.(*sessionValidationError); ok && verr.kind == sessionValidationErrorKindUnauthenticated {
+					writeJSON(w, http.StatusUnauthorized, map[string]string{
+						"error":   "Authentication required",
+						"message": "Please log in to access this endpoint",
+					})
+				} else {
+					writeJSON(w, http.StatusInternalServerError, map[string]string{
+						"error":   "Failed to initialize session",
+						"message": "Unable to initialize session",
+					})
+				}
+				return
+			}
+
+			ctx := WithAuthContext(r.Context(), username, role, csrfToken)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}
+
+// RequireWriteAccess checks if user has admin role (write access).
+// Returns JSON error for API endpoints, redirects for HTML endpoints.
+func RequireWriteAccess() mux.MiddlewareFunc {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			role := RoleFromContext(r.Context())
+
+			if role != "admin" {
+				// Check if this is an API request (path starts with /api) or HTML request.
+				if strings.HasPrefix(r.URL.Path, "/api") {
+					writeJSON(w, http.StatusForbidden, map[string]string{
+						"error":   "Insufficient permissions",
+						"message": "This operation requires admin access. Read-only users can only view data.",
+					})
+				} else {
+					http.Redirect(w, r, "/admin?error=Insufficient permissions", http.StatusSeeOther)
+				}
+				return
+			}
+
+			next.ServeHTTP(w, r)
+		})
 	}
 }

weed/admin/dash/plugin_api.go

@@ -13,7 +13,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
 	"github.com/seaweedfs/seaweedfs/weed/admin/plugin"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
@@ -32,17 +32,17 @@ const (
 )
 
 // GetPluginStatusAPI returns plugin status.
-func (s *AdminServer) GetPluginStatusAPI(c *gin.Context) {
+func (s *AdminServer) GetPluginStatusAPI(w http.ResponseWriter, r *http.Request) {
 	plugin := s.GetPlugin()
 	if plugin == nil {
-		c.JSON(http.StatusOK, gin.H{
+		writeJSON(w, http.StatusOK, map[string]interface{}{
 			"enabled":          false,
 			"worker_grpc_port": s.GetWorkerGrpcPort(),
 		})
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"enabled":          true,
 		"configured":       plugin.IsConfigured(),
 		"base_dir":         plugin.BaseDir(),
@@ -52,101 +52,104 @@ func (s *AdminServer) GetPluginStatusAPI(c *gin.Context) {
 }
 
 // GetPluginWorkersAPI returns currently connected plugin workers.
-func (s *AdminServer) GetPluginWorkersAPI(c *gin.Context) {
+func (s *AdminServer) GetPluginWorkersAPI(w http.ResponseWriter, r *http.Request) {
 	workers := s.GetPluginWorkers()
 	if workers == nil {
-		c.JSON(http.StatusOK, []interface{}{})
+		writeJSON(w, http.StatusOK, []interface{}{})
 		return
 	}
-	c.JSON(http.StatusOK, workers)
+	writeJSON(w, http.StatusOK, workers)
 }
 
 // GetPluginJobTypesAPI returns known plugin job types from workers and persisted data.
-func (s *AdminServer) GetPluginJobTypesAPI(c *gin.Context) {
+func (s *AdminServer) GetPluginJobTypesAPI(w http.ResponseWriter, r *http.Request) {
 	jobTypes, err := s.ListPluginJobTypes()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 	if jobTypes == nil {
-		c.JSON(http.StatusOK, []interface{}{})
+		writeJSON(w, http.StatusOK, []interface{}{})
 		return
 	}
-	c.JSON(http.StatusOK, jobTypes)
+	writeJSON(w, http.StatusOK, jobTypes)
 }
 
 // GetPluginJobsAPI returns tracked jobs for monitoring.
-func (s *AdminServer) GetPluginJobsAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Query("job_type"))
-	state := strings.TrimSpace(c.Query("state"))
-	limit := parsePositiveInt(c.Query("limit"), 200)
+func (s *AdminServer) GetPluginJobsAPI(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	jobType := strings.TrimSpace(query.Get("job_type"))
+	state := strings.TrimSpace(query.Get("state"))
+	limit := parsePositiveInt(query.Get("limit"), 200)
 	jobs := s.ListPluginJobs(jobType, state, limit)
 	if jobs == nil {
-		c.JSON(http.StatusOK, []interface{}{})
+		writeJSON(w, http.StatusOK, []interface{}{})
 		return
 	}
-	c.JSON(http.StatusOK, jobs)
+	writeJSON(w, http.StatusOK, jobs)
 }
 
 // GetPluginJobAPI returns one tracked job.
-func (s *AdminServer) GetPluginJobAPI(c *gin.Context) {
-	jobID := strings.TrimSpace(c.Param("jobId"))
+func (s *AdminServer) GetPluginJobAPI(w http.ResponseWriter, r *http.Request) {
+	jobID := strings.TrimSpace(mux.Vars(r)["jobId"])
 	if jobID == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobId is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobId is required")
 		return
 	}
 
 	job, found := s.GetPluginJob(jobID)
 	if !found {
-		c.JSON(http.StatusNotFound, gin.H{"error": "job not found"})
+		writeJSONError(w, http.StatusNotFound, "job not found")
 		return
 	}
-	c.JSON(http.StatusOK, job)
+	writeJSON(w, http.StatusOK, job)
 }
 
 // GetPluginJobDetailAPI returns detailed information for one tracked plugin job.
-func (s *AdminServer) GetPluginJobDetailAPI(c *gin.Context) {
-	jobID := strings.TrimSpace(c.Param("jobId"))
+func (s *AdminServer) GetPluginJobDetailAPI(w http.ResponseWriter, r *http.Request) {
+	jobID := strings.TrimSpace(mux.Vars(r)["jobId"])
 	if jobID == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobId is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobId is required")
 		return
 	}
 
-	activityLimit := parsePositiveInt(c.Query("activity_limit"), 500)
-	relatedLimit := parsePositiveInt(c.Query("related_limit"), 20)
+	query := r.URL.Query()
+	activityLimit := parsePositiveInt(query.Get("activity_limit"), 500)
+	relatedLimit := parsePositiveInt(query.Get("related_limit"), 20)
 
 	detail, found, err := s.GetPluginJobDetail(jobID, activityLimit, relatedLimit)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 	if !found || detail == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "job detail not found"})
+		writeJSONError(w, http.StatusNotFound, "job detail not found")
 		return
 	}
 
-	c.JSON(http.StatusOK, detail)
+	writeJSON(w, http.StatusOK, detail)
 }
 
 // GetPluginActivitiesAPI returns recent plugin activities.
-func (s *AdminServer) GetPluginActivitiesAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Query("job_type"))
-	limit := parsePositiveInt(c.Query("limit"), 500)
+func (s *AdminServer) GetPluginActivitiesAPI(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	jobType := strings.TrimSpace(query.Get("job_type"))
+	limit := parsePositiveInt(query.Get("limit"), 500)
 	activities := s.ListPluginActivities(jobType, limit)
 	if activities == nil {
-		c.JSON(http.StatusOK, []interface{}{})
+		writeJSON(w, http.StatusOK, []interface{}{})
 		return
 	}
-	c.JSON(http.StatusOK, activities)
+	writeJSON(w, http.StatusOK, activities)
 }
 
 // GetPluginSchedulerStatesAPI returns per-job-type scheduler status for monitoring.
-func (s *AdminServer) GetPluginSchedulerStatesAPI(c *gin.Context) {
-	jobTypeFilter := strings.TrimSpace(c.Query("job_type"))
+func (s *AdminServer) GetPluginSchedulerStatesAPI(w http.ResponseWriter, r *http.Request) {
+	jobTypeFilter := strings.TrimSpace(r.URL.Query().Get("job_type"))
 
 	states, err := s.ListPluginSchedulerStates()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
@@ -157,71 +160,71 @@ func (s *AdminServer) GetPluginSchedulerStatesAPI(c *gin.Context) {
 				filtered = append(filtered, state)
 			}
 		}
-		c.JSON(http.StatusOK, filtered)
+		writeJSON(w, http.StatusOK, filtered)
 		return
 	}
 
 	if states == nil {
-		c.JSON(http.StatusOK, []interface{}{})
+		writeJSON(w, http.StatusOK, []interface{}{})
 		return
 	}
 
-	c.JSON(http.StatusOK, states)
+	writeJSON(w, http.StatusOK, states)
 }
 
 // RequestPluginJobTypeSchemaAPI asks a worker for one job type schema.
-func (s *AdminServer) RequestPluginJobTypeSchemaAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Param("jobType"))
+func (s *AdminServer) RequestPluginJobTypeSchemaAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
 	if jobType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobType is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
 		return
 	}
 
-	forceRefresh := c.DefaultQuery("force_refresh", "false") == "true"
+	forceRefresh := strings.EqualFold(r.URL.Query().Get("force_refresh"), "true")
 
-	ctx, cancel := context.WithTimeout(c.Request.Context(), defaultPluginDetectionTimeout)
+	ctx, cancel := context.WithTimeout(r.Context(), defaultPluginDetectionTimeout)
 	defer cancel()
 	descriptor, err := s.RequestPluginJobTypeDescriptor(ctx, jobType, forceRefresh)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	renderProtoJSON(c, http.StatusOK, descriptor)
+	renderProtoJSON(w, http.StatusOK, descriptor)
 }
 
 // GetPluginJobTypeDescriptorAPI returns persisted descriptor for a job type.
-func (s *AdminServer) GetPluginJobTypeDescriptorAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Param("jobType"))
+func (s *AdminServer) GetPluginJobTypeDescriptorAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
 	if jobType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobType is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
 		return
 	}
 
 	descriptor, err := s.LoadPluginJobTypeDescriptor(jobType)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 	if descriptor == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "descriptor not found"})
+		writeJSONError(w, http.StatusNotFound, "descriptor not found")
 		return
 	}
 
-	renderProtoJSON(c, http.StatusOK, descriptor)
+	renderProtoJSON(w, http.StatusOK, descriptor)
 }
 
 // GetPluginJobTypeConfigAPI loads persisted config for a job type.
-func (s *AdminServer) GetPluginJobTypeConfigAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Param("jobType"))
+func (s *AdminServer) GetPluginJobTypeConfigAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
 	if jobType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobType is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
 		return
 	}
 
 	config, err := s.LoadPluginJobTypeConfig(jobType)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 	if config == nil {
@@ -233,20 +236,20 @@ func (s *AdminServer) GetPluginJobTypeConfigAPI(c *gin.Context) {
 		}
 	}
 
-	renderProtoJSON(c, http.StatusOK, config)
+	renderProtoJSON(w, http.StatusOK, config)
 }
 
 // UpdatePluginJobTypeConfigAPI stores persisted config for a job type.
-func (s *AdminServer) UpdatePluginJobTypeConfigAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Param("jobType"))
+func (s *AdminServer) UpdatePluginJobTypeConfigAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
 	if jobType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobType is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
 		return
 	}
 
 	config := &plugin_pb.PersistedJobTypeConfig{}
-	if err := parseProtoJSONBody(c, config); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+	if err := parseProtoJSONBody(w, r, config); err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
@@ -264,35 +267,35 @@ func (s *AdminServer) UpdatePluginJobTypeConfigAPI(c *gin.Context) {
 		config.WorkerConfigValues = map[string]*plugin_pb.ConfigValue{}
 	}
 
-	username := c.GetString("username")
+	username := UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 	config.UpdatedBy = username
 
 	if err := s.SavePluginJobTypeConfig(config); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	renderProtoJSON(c, http.StatusOK, config)
+	renderProtoJSON(w, http.StatusOK, config)
 }
 
 // GetPluginRunHistoryAPI returns bounded run history for a job type.
-func (s *AdminServer) GetPluginRunHistoryAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Param("jobType"))
+func (s *AdminServer) GetPluginRunHistoryAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
 	if jobType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobType is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
 		return
 	}
 
 	history, err := s.GetPluginRunHistory(jobType)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 	if history == nil {
-		c.JSON(http.StatusOK, gin.H{
+		writeJSON(w, http.StatusOK, map[string]interface{}{
 			"job_type":          jobType,
 			"successful_runs":   []interface{}{},
 			"error_runs":        []interface{}{},
@@ -301,14 +304,14 @@ func (s *AdminServer) GetPluginRunHistoryAPI(c *gin.Context) {
 		return
 	}
 
-	c.JSON(http.StatusOK, history)
+	writeJSON(w, http.StatusOK, history)
 }
 
 // TriggerPluginDetectionAPI runs one detector for this job type and returns proposals.
-func (s *AdminServer) TriggerPluginDetectionAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Param("jobType"))
+func (s *AdminServer) TriggerPluginDetectionAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
 	if jobType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobType is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
 		return
 	}
 
@@ -318,19 +321,19 @@ func (s *AdminServer) TriggerPluginDetectionAPI(c *gin.Context) {
 		TimeoutSeconds int             `json:"timeout_seconds"`
 	}
 
-	if err := c.ShouldBindJSON(&req); err != nil && err != io.EOF {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil && err != io.EOF {
+		writeJSONError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
 		return
 	}
 
 	clusterContext, err := s.parseOrBuildClusterContext(req.ClusterContext)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
 	timeout := normalizeTimeout(req.TimeoutSeconds, defaultPluginDetectionTimeout, maxPluginDetectionTimeout)
-	ctx, cancel := context.WithTimeout(c.Request.Context(), timeout)
+	ctx, cancel := context.WithTimeout(r.Context(), timeout)
 	defer cancel()
 
 	report, err := s.RunPluginDetectionWithReport(ctx, jobType, clusterContext, req.MaxResults)
@@ -384,7 +387,7 @@ func (s *AdminServer) TriggerPluginDetectionAPI(c *gin.Context) {
 		}
 	}
 
-	response := gin.H{
+	response := map[string]interface{}{
 		"job_type":           jobType,
 		"request_id":         requestID,
 		"detector_worker_id": detectorWorkerID,
@@ -396,18 +399,18 @@ func (s *AdminServer) TriggerPluginDetectionAPI(c *gin.Context) {
 
 	if err != nil {
 		response["error"] = err.Error()
-		c.JSON(http.StatusInternalServerError, response)
+		writeJSON(w, http.StatusInternalServerError, response)
 		return
 	}
 
-	c.JSON(http.StatusOK, response)
+	writeJSON(w, http.StatusOK, response)
 }
 
 // RunPluginJobTypeAPI runs full workflow for one job type: detect then dispatch detected jobs.
-func (s *AdminServer) RunPluginJobTypeAPI(c *gin.Context) {
-	jobType := strings.TrimSpace(c.Param("jobType"))
+func (s *AdminServer) RunPluginJobTypeAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
 	if jobType == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "jobType is required"})
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
 		return
 	}
 
@@ -418,8 +421,8 @@ func (s *AdminServer) RunPluginJobTypeAPI(c *gin.Context) {
 		Attempt        int32           `json:"attempt"`
 	}
 
-	if err := c.ShouldBindJSON(&req); err != nil && err != io.EOF {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil && err != io.EOF {
+		writeJSONError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
 		return
 	}
 	if req.Attempt < 1 {
@@ -428,24 +431,24 @@ func (s *AdminServer) RunPluginJobTypeAPI(c *gin.Context) {
 
 	clusterContext, err := s.parseOrBuildClusterContext(req.ClusterContext)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
 	timeout := normalizeTimeout(req.TimeoutSeconds, defaultPluginRunTimeout, maxPluginRunTimeout)
-	ctx, cancel := context.WithTimeout(c.Request.Context(), timeout)
+	ctx, cancel := context.WithTimeout(r.Context(), timeout)
 	defer cancel()
 
 	proposals, err := s.RunPluginDetection(ctx, jobType, clusterContext, req.MaxResults)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 	detectedCount := len(proposals)
 
 	filteredProposals, skippedActiveCount, err := s.FilterPluginProposalsWithActiveJobs(jobType, proposals)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
@@ -485,7 +488,7 @@ func (s *AdminServer) RunPluginJobTypeAPI(c *gin.Context) {
 		results = append(results, result)
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"job_type":               jobType,
 		"detected_count":         detectedCount,
 		"ready_to_execute_count": len(filteredProposals),
@@ -498,7 +501,7 @@ func (s *AdminServer) RunPluginJobTypeAPI(c *gin.Context) {
 }
 
 // ExecutePluginJobAPI executes one job on a capable worker and waits for completion.
-func (s *AdminServer) ExecutePluginJobAPI(c *gin.Context) {
+func (s *AdminServer) ExecutePluginJobAPI(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		Job            json.RawMessage `json:"job"`
 		ClusterContext json.RawMessage `json:"cluster_context"`
@@ -506,24 +509,24 @@ func (s *AdminServer) ExecutePluginJobAPI(c *gin.Context) {
 		TimeoutSeconds int             `json:"timeout_seconds"`
 	}
 
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request body: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
 		return
 	}
 	if len(req.Job) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "job is required"})
+		writeJSONError(w, http.StatusBadRequest, "job is required")
 		return
 	}
 
 	job := &plugin_pb.JobSpec{}
 	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}).Unmarshal(req.Job, job); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid job payload: " + err.Error()})
+		writeJSONError(w, http.StatusBadRequest, "invalid job payload: "+err.Error())
 		return
 	}
 
 	clusterContext, err := s.parseOrBuildClusterContext(req.ClusterContext)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
@@ -532,7 +535,7 @@ func (s *AdminServer) ExecutePluginJobAPI(c *gin.Context) {
 	}
 
 	timeout := normalizeTimeout(req.TimeoutSeconds, defaultPluginExecutionTimeout, maxPluginExecutionTimeout)
-	ctx, cancel := context.WithTimeout(c.Request.Context(), timeout)
+	ctx, cancel := context.WithTimeout(r.Context(), timeout)
 	defer cancel()
 
 	completed, err := s.ExecutePluginJob(ctx, job, clusterContext, req.Attempt)
@@ -540,15 +543,15 @@ func (s *AdminServer) ExecutePluginJobAPI(c *gin.Context) {
 		if completed != nil {
 			payload, marshalErr := protoMessageToMap(completed)
 			if marshalErr == nil {
-				c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error(), "completion": payload})
+				writeJSON(w, http.StatusInternalServerError, map[string]interface{}{"error": err.Error(), "completion": payload})
 				return
 			}
 		}
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	renderProtoJSON(c, http.StatusOK, completed)
+	renderProtoJSON(w, http.StatusOK, completed)
 }
 
 func (s *AdminServer) parseOrBuildClusterContext(raw json.RawMessage) (*plugin_pb.ClusterContext, error) {
@@ -636,8 +639,8 @@ func (s *AdminServer) buildDefaultPluginClusterContext() *plugin_pb.ClusterConte
 
 const parseProtoJSONBodyMaxBytes = 1 << 20 // 1 MB
 
-func parseProtoJSONBody(c *gin.Context, message proto.Message) error {
-	limitedBody := http.MaxBytesReader(c.Writer, c.Request.Body, parseProtoJSONBodyMaxBytes)
+func parseProtoJSONBody(w http.ResponseWriter, r *http.Request, message proto.Message) error {
+	limitedBody := http.MaxBytesReader(w, r.Body, parseProtoJSONBodyMaxBytes)
 	data, err := io.ReadAll(limitedBody)
 	if err != nil {
 		return fmt.Errorf("failed to read request body: %w", err)
@@ -651,17 +654,19 @@ func parseProtoJSONBody(c *gin.Context, message proto.Message) error {
 	return nil
 }
 
-func renderProtoJSON(c *gin.Context, statusCode int, message proto.Message) {
+func renderProtoJSON(w http.ResponseWriter, statusCode int, message proto.Message) {
 	payload, err := protojson.MarshalOptions{
 		UseProtoNames:   true,
 		EmitUnpopulated: true,
 	}.Marshal(message)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to encode response: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "failed to encode response: "+err.Error())
 		return
 	}
 
-	c.Data(statusCode, "application/json", payload)
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(statusCode)
+	_, _ = w.Write(payload)
 }
 
 func protoMessageToMap(message proto.Message) (map[string]interface{}, error) {

weed/admin/dash/s3tables_management.go

@@ -12,7 +12,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gin-gonic/gin"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
 	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
@@ -67,10 +66,10 @@ func parseNamespaceInput(namespace string) ([]string, error) {
 	return s3tables.ParseNamespace(namespace)
 }
 
-func (s *AdminServer) parseNamespaceFromGin(c *gin.Context, namespace string) ([]string, bool) {
+func (s *AdminServer) parseNamespaceFromRequest(w http.ResponseWriter, namespace string) ([]string, bool) {
 	parts, err := parseNamespaceInput(namespace)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid namespace: " + err.Error()})
+		writeJSONError(w, http.StatusBadRequest, "Invalid namespace: "+err.Error())
 		return nil, false
 	}
 	return parts, true
@@ -569,58 +568,61 @@ func parseSummaryInt(summary map[string]string, keys ...string) (int64, bool) {
 
 // API handlers
 
-func (s *AdminServer) ListS3TablesBucketsAPI(c *gin.Context) {
-	data, err := s.GetS3TablesBucketsData(c.Request.Context())
+func (s *AdminServer) ListS3TablesBucketsAPI(w http.ResponseWriter, r *http.Request) {
+	data, err := s.GetS3TablesBucketsData(r.Context())
 	if err != nil {
-		writeS3TablesError(c, err)
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, data)
+	writeJSON(w, http.StatusOK, data)
 }
 
-func (s *AdminServer) CreateS3TablesBucket(c *gin.Context) {
+func (s *AdminServer) CreateS3TablesBucket(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
 	var req struct {
 		Name  string            `json:"name"`
 		Tags  map[string]string `json:"tags"`
 		Owner string            `json:"owner"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 	if req.Name == "" {
-		c.JSON(400, gin.H{"error": "Bucket name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Bucket name is required")
 		return
 	}
 	owner := strings.TrimSpace(req.Owner)
 	if len(owner) > MaxOwnerNameLength {
-		c.JSON(400, gin.H{"error": fmt.Sprintf("Owner name must be %d characters or less", MaxOwnerNameLength)})
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("Owner name must be %d characters or less", MaxOwnerNameLength))
 		return
 	}
 	if len(req.Tags) > 0 {
 		if err := s3tables.ValidateTags(req.Tags); err != nil {
-			c.JSON(400, gin.H{"error": "Invalid tags: " + err.Error()})
+			writeJSONError(w, http.StatusBadRequest, "Invalid tags: "+err.Error())
 			return
 		}
 	}
 	createReq := &s3tables.CreateTableBucketRequest{Name: req.Name, Tags: req.Tags}
 	var resp s3tables.CreateTableBucketResponse
-	if err := s.executeS3TablesOperation(c.Request.Context(), "CreateTableBucket", createReq, &resp); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "CreateTableBucket", createReq, &resp); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
 	if owner != "" {
-		if err := s.SetTableBucketOwner(c.Request.Context(), req.Name, owner); err != nil {
+		if err := s.SetTableBucketOwner(r.Context(), req.Name, owner); err != nil {
 			deleteReq := &s3tables.DeleteTableBucketRequest{TableBucketARN: resp.ARN}
-			if deleteErr := s.executeS3TablesOperation(c.Request.Context(), "DeleteTableBucket", deleteReq, nil); deleteErr != nil {
-				c.JSON(500, gin.H{"error": fmt.Sprintf("Failed to set table bucket owner: %v; rollback delete failed: %v", err, deleteErr)})
+			if deleteErr := s.executeS3TablesOperation(r.Context(), "DeleteTableBucket", deleteReq, nil); deleteErr != nil {
+				writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to set table bucket owner: %v; rollback delete failed: %v", err, deleteErr))
 				return
 			}
-			writeS3TablesError(c, err)
+			writeS3TablesError(w, err)
 			return
 		}
 	}
-	c.JSON(201, gin.H{"arn": resp.ARN})
+	writeJSON(w, http.StatusCreated, map[string]interface{}{"arn": resp.ARN})
 }
 
 func (s *AdminServer) SetTableBucketOwner(ctx context.Context, bucketName, owner string) error {
@@ -663,101 +665,107 @@ func (s *AdminServer) SetTableBucketOwner(ctx context.Context, bucketName, owner
 	})
 }
 
-func (s *AdminServer) DeleteS3TablesBucket(c *gin.Context) {
-	bucketArn := c.Query("bucket")
+func (s *AdminServer) DeleteS3TablesBucket(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
+	bucketArn := r.URL.Query().Get("bucket")
 	if bucketArn == "" {
-		c.JSON(400, gin.H{"error": "Bucket ARN is required"})
+		writeJSONError(w, http.StatusBadRequest, "Bucket ARN is required")
 		return
 	}
 	req := &s3tables.DeleteTableBucketRequest{TableBucketARN: bucketArn}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "DeleteTableBucket", req, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "DeleteTableBucket", req, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Bucket deleted"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Bucket deleted"})
 }
 
-func (s *AdminServer) ListS3TablesNamespacesAPI(c *gin.Context) {
-	bucketArn := c.Query("bucket")
+func (s *AdminServer) ListS3TablesNamespacesAPI(w http.ResponseWriter, r *http.Request) {
+	bucketArn := r.URL.Query().Get("bucket")
 	if bucketArn == "" {
-		c.JSON(400, gin.H{"error": "bucket query parameter is required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket query parameter is required")
 		return
 	}
-	data, err := s.GetS3TablesNamespacesData(c.Request.Context(), bucketArn)
+	data, err := s.GetS3TablesNamespacesData(r.Context(), bucketArn)
 	if err != nil {
-		writeS3TablesError(c, err)
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, data)
+	writeJSON(w, http.StatusOK, data)
 }
 
-func (s *AdminServer) CreateS3TablesNamespace(c *gin.Context) {
-	if !requireSessionCSRFToken(c) {
+func (s *AdminServer) CreateS3TablesNamespace(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
 		return
 	}
 	var req struct {
 		BucketARN string `json:"bucket_arn"`
 		Name      string `json:"name"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 	if req.BucketARN == "" || req.Name == "" {
-		c.JSON(400, gin.H{"error": "bucket_arn and name are required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket_arn and name are required")
 		return
 	}
-	namespaceParts, ok := s.parseNamespaceFromGin(c, req.Name)
+	namespaceParts, ok := s.parseNamespaceFromRequest(w, req.Name)
 	if !ok {
 		return
 	}
 	createReq := &s3tables.CreateNamespaceRequest{TableBucketARN: req.BucketARN, Namespace: namespaceParts}
 	var resp s3tables.CreateNamespaceResponse
-	if err := s.executeS3TablesOperation(c.Request.Context(), "CreateNamespace", createReq, &resp); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "CreateNamespace", createReq, &resp); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(201, gin.H{"namespace": resp.Namespace})
+	writeJSON(w, http.StatusCreated, map[string]interface{}{"namespace": resp.Namespace})
 }
 
-func (s *AdminServer) DeleteS3TablesNamespace(c *gin.Context) {
-	if !requireSessionCSRFToken(c) {
+func (s *AdminServer) DeleteS3TablesNamespace(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
 		return
 	}
-	bucketArn := c.Query("bucket")
-	namespace := c.Query("name")
+	bucketArn := r.URL.Query().Get("bucket")
+	namespace := r.URL.Query().Get("name")
 	if bucketArn == "" || namespace == "" {
-		c.JSON(400, gin.H{"error": "bucket and name query parameters are required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket and name query parameters are required")
 		return
 	}
-	namespaceParts, ok := s.parseNamespaceFromGin(c, namespace)
+	namespaceParts, ok := s.parseNamespaceFromRequest(w, namespace)
 	if !ok {
 		return
 	}
 	req := &s3tables.DeleteNamespaceRequest{TableBucketARN: bucketArn, Namespace: namespaceParts}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "DeleteNamespace", req, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "DeleteNamespace", req, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Namespace deleted"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Namespace deleted"})
 }
 
-func (s *AdminServer) ListS3TablesTablesAPI(c *gin.Context) {
-	bucketArn := c.Query("bucket")
+func (s *AdminServer) ListS3TablesTablesAPI(w http.ResponseWriter, r *http.Request) {
+	bucketArn := r.URL.Query().Get("bucket")
 	if bucketArn == "" {
-		c.JSON(400, gin.H{"error": "bucket query parameter is required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket query parameter is required")
 		return
 	}
-	namespace := c.Query("namespace")
-	data, err := s.GetS3TablesTablesData(c.Request.Context(), bucketArn, namespace)
+	namespace := r.URL.Query().Get("namespace")
+	data, err := s.GetS3TablesTablesData(r.Context(), bucketArn, namespace)
 	if err != nil {
-		writeS3TablesError(c, err)
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, data)
+	writeJSON(w, http.StatusOK, data)
 }
 
-func (s *AdminServer) CreateS3TablesTable(c *gin.Context) {
+func (s *AdminServer) CreateS3TablesTable(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
 	var req struct {
 		BucketARN string                  `json:"bucket_arn"`
 		Namespace string                  `json:"namespace"`
@@ -766,15 +774,15 @@ func (s *AdminServer) CreateS3TablesTable(c *gin.Context) {
 		Tags      map[string]string       `json:"tags"`
 		Metadata  *s3tables.TableMetadata `json:"metadata"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 	if req.BucketARN == "" || req.Namespace == "" || req.Name == "" {
-		c.JSON(400, gin.H{"error": "bucket_arn, namespace, and name are required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket_arn, namespace, and name are required")
 		return
 	}
-	namespaceParts, ok := s.parseNamespaceFromGin(c, req.Namespace)
+	namespaceParts, ok := s.parseNamespaceFromRequest(w, req.Namespace)
 	if !ok {
 		return
 	}
@@ -784,7 +792,7 @@ func (s *AdminServer) CreateS3TablesTable(c *gin.Context) {
 	}
 	if len(req.Tags) > 0 {
 		if err := s3tables.ValidateTags(req.Tags); err != nil {
-			c.JSON(400, gin.H{"error": "Invalid tags: " + err.Error()})
+			writeJSONError(w, http.StatusBadRequest, "Invalid tags: "+err.Error())
 			return
 		}
 	}
@@ -797,211 +805,232 @@ func (s *AdminServer) CreateS3TablesTable(c *gin.Context) {
 		Metadata:       req.Metadata,
 	}
 	var resp s3tables.CreateTableResponse
-	if err := s.executeS3TablesOperation(c.Request.Context(), "CreateTable", createReq, &resp); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "CreateTable", createReq, &resp); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(201, gin.H{"table_arn": resp.TableARN, "version_token": resp.VersionToken})
+	writeJSON(w, http.StatusCreated, map[string]interface{}{"table_arn": resp.TableARN, "version_token": resp.VersionToken})
 }
 
-func (s *AdminServer) DeleteS3TablesTable(c *gin.Context) {
-	bucketArn := c.Query("bucket")
-	namespace := c.Query("namespace")
-	name := c.Query("name")
-	version := c.Query("version")
-	if bucketArn == "" || namespace == "" || name == "" {
-		c.JSON(400, gin.H{"error": "bucket, namespace, and name query parameters are required"})
+func (s *AdminServer) DeleteS3TablesTable(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
 		return
 	}
-	namespaceParts, ok := s.parseNamespaceFromGin(c, namespace)
+	bucketArn := r.URL.Query().Get("bucket")
+	namespace := r.URL.Query().Get("namespace")
+	name := r.URL.Query().Get("name")
+	version := r.URL.Query().Get("version")
+	if bucketArn == "" || namespace == "" || name == "" {
+		writeJSONError(w, http.StatusBadRequest, "bucket, namespace, and name query parameters are required")
+		return
+	}
+	namespaceParts, ok := s.parseNamespaceFromRequest(w, namespace)
 	if !ok {
 		return
 	}
 	req := &s3tables.DeleteTableRequest{TableBucketARN: bucketArn, Namespace: namespaceParts, Name: name, VersionToken: version}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "DeleteTable", req, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "DeleteTable", req, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Table deleted"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Table deleted"})
 }
 
-func (s *AdminServer) PutS3TablesBucketPolicy(c *gin.Context) {
+func (s *AdminServer) PutS3TablesBucketPolicy(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
 	var req struct {
 		BucketARN string `json:"bucket_arn"`
 		Policy    string `json:"policy"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 	if req.BucketARN == "" || req.Policy == "" {
-		c.JSON(400, gin.H{"error": "bucket_arn and policy are required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket_arn and policy are required")
 		return
 	}
 	putReq := &s3tables.PutTableBucketPolicyRequest{TableBucketARN: req.BucketARN, ResourcePolicy: req.Policy}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "PutTableBucketPolicy", putReq, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "PutTableBucketPolicy", putReq, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Policy updated"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Policy updated"})
 }
 
-func (s *AdminServer) GetS3TablesBucketPolicy(c *gin.Context) {
-	bucketArn := c.Query("bucket")
+func (s *AdminServer) GetS3TablesBucketPolicy(w http.ResponseWriter, r *http.Request) {
+	bucketArn := r.URL.Query().Get("bucket")
 	if bucketArn == "" {
-		c.JSON(400, gin.H{"error": "bucket query parameter is required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket query parameter is required")
 		return
 	}
 	getReq := &s3tables.GetTableBucketPolicyRequest{TableBucketARN: bucketArn}
 	var resp s3tables.GetTableBucketPolicyResponse
-	if err := s.executeS3TablesOperation(c.Request.Context(), "GetTableBucketPolicy", getReq, &resp); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "GetTableBucketPolicy", getReq, &resp); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"policy": resp.ResourcePolicy})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"policy": resp.ResourcePolicy})
 }
 
-func (s *AdminServer) DeleteS3TablesBucketPolicy(c *gin.Context) {
-	bucketArn := c.Query("bucket")
+func (s *AdminServer) DeleteS3TablesBucketPolicy(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
+	bucketArn := r.URL.Query().Get("bucket")
 	if bucketArn == "" {
-		c.JSON(400, gin.H{"error": "bucket query parameter is required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket query parameter is required")
 		return
 	}
 	deleteReq := &s3tables.DeleteTableBucketPolicyRequest{TableBucketARN: bucketArn}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "DeleteTableBucketPolicy", deleteReq, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "DeleteTableBucketPolicy", deleteReq, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Policy deleted"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Policy deleted"})
 }
 
-func (s *AdminServer) PutS3TablesTablePolicy(c *gin.Context) {
+func (s *AdminServer) PutS3TablesTablePolicy(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
 	var req struct {
 		BucketARN string `json:"bucket_arn"`
 		Namespace string `json:"namespace"`
 		Name      string `json:"name"`
 		Policy    string `json:"policy"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 	if req.BucketARN == "" || req.Namespace == "" || req.Name == "" || req.Policy == "" {
-		c.JSON(400, gin.H{"error": "bucket_arn, namespace, name, and policy are required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket_arn, namespace, name, and policy are required")
 		return
 	}
-	namespaceParts, ok := s.parseNamespaceFromGin(c, req.Namespace)
+	namespaceParts, ok := s.parseNamespaceFromRequest(w, req.Namespace)
 	if !ok {
 		return
 	}
 	putReq := &s3tables.PutTablePolicyRequest{TableBucketARN: req.BucketARN, Namespace: namespaceParts, Name: req.Name, ResourcePolicy: req.Policy}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "PutTablePolicy", putReq, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "PutTablePolicy", putReq, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Policy updated"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Policy updated"})
 }
 
-func (s *AdminServer) GetS3TablesTablePolicy(c *gin.Context) {
-	bucketArn := c.Query("bucket")
-	namespace := c.Query("namespace")
-	name := c.Query("name")
+func (s *AdminServer) GetS3TablesTablePolicy(w http.ResponseWriter, r *http.Request) {
+	bucketArn := r.URL.Query().Get("bucket")
+	namespace := r.URL.Query().Get("namespace")
+	name := r.URL.Query().Get("name")
 	if bucketArn == "" || namespace == "" || name == "" {
-		c.JSON(400, gin.H{"error": "bucket, namespace, and name query parameters are required"})
+		writeJSONError(w, http.StatusBadRequest, "bucket, namespace, and name query parameters are required")
 		return
 	}
-	namespaceParts, ok := s.parseNamespaceFromGin(c, namespace)
+	namespaceParts, ok := s.parseNamespaceFromRequest(w, namespace)
 	if !ok {
 		return
 	}
 	getReq := &s3tables.GetTablePolicyRequest{TableBucketARN: bucketArn, Namespace: namespaceParts, Name: name}
 	var resp s3tables.GetTablePolicyResponse
-	if err := s.executeS3TablesOperation(c.Request.Context(), "GetTablePolicy", getReq, &resp); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "GetTablePolicy", getReq, &resp); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"policy": resp.ResourcePolicy})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"policy": resp.ResourcePolicy})
 }
 
-func (s *AdminServer) DeleteS3TablesTablePolicy(c *gin.Context) {
-	bucketArn := c.Query("bucket")
-	namespace := c.Query("namespace")
-	name := c.Query("name")
-	if bucketArn == "" || namespace == "" || name == "" {
-		c.JSON(400, gin.H{"error": "bucket, namespace, and name query parameters are required"})
+func (s *AdminServer) DeleteS3TablesTablePolicy(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
 		return
 	}
-	namespaceParts, ok := s.parseNamespaceFromGin(c, namespace)
+	bucketArn := r.URL.Query().Get("bucket")
+	namespace := r.URL.Query().Get("namespace")
+	name := r.URL.Query().Get("name")
+	if bucketArn == "" || namespace == "" || name == "" {
+		writeJSONError(w, http.StatusBadRequest, "bucket, namespace, and name query parameters are required")
+		return
+	}
+	namespaceParts, ok := s.parseNamespaceFromRequest(w, namespace)
 	if !ok {
 		return
 	}
 	deleteReq := &s3tables.DeleteTablePolicyRequest{TableBucketARN: bucketArn, Namespace: namespaceParts, Name: name}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "DeleteTablePolicy", deleteReq, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "DeleteTablePolicy", deleteReq, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Policy deleted"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Policy deleted"})
 }
 
-func (s *AdminServer) TagS3TablesResource(c *gin.Context) {
+func (s *AdminServer) TagS3TablesResource(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
 	var req struct {
 		ResourceARN string            `json:"resource_arn"`
 		Tags        map[string]string `json:"tags"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 	if req.ResourceARN == "" || len(req.Tags) == 0 {
-		c.JSON(400, gin.H{"error": "resource_arn and tags are required"})
+		writeJSONError(w, http.StatusBadRequest, "resource_arn and tags are required")
 		return
 	}
 	if err := s3tables.ValidateTags(req.Tags); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid tags: " + err.Error()})
+		writeJSONError(w, http.StatusBadRequest, "Invalid tags: "+err.Error())
 		return
 	}
 	tagReq := &s3tables.TagResourceRequest{ResourceARN: req.ResourceARN, Tags: req.Tags}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "TagResource", tagReq, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "TagResource", tagReq, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Tags updated"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Tags updated"})
 }
 
-func (s *AdminServer) ListS3TablesTags(c *gin.Context) {
-	resourceArn := c.Query("arn")
+func (s *AdminServer) ListS3TablesTags(w http.ResponseWriter, r *http.Request) {
+	resourceArn := r.URL.Query().Get("arn")
 	if resourceArn == "" {
-		c.JSON(400, gin.H{"error": "arn query parameter is required"})
+		writeJSONError(w, http.StatusBadRequest, "arn query parameter is required")
 		return
 	}
 	listReq := &s3tables.ListTagsForResourceRequest{ResourceARN: resourceArn}
 	var resp s3tables.ListTagsForResourceResponse
-	if err := s.executeS3TablesOperation(c.Request.Context(), "ListTagsForResource", listReq, &resp); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "ListTagsForResource", listReq, &resp); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, resp)
+	writeJSON(w, http.StatusOK, resp)
 }
 
-func (s *AdminServer) UntagS3TablesResource(c *gin.Context) {
+func (s *AdminServer) UntagS3TablesResource(w http.ResponseWriter, r *http.Request) {
+	if !requireSessionCSRFToken(w, r) {
+		return
+	}
 	var req struct {
 		ResourceARN string   `json:"resource_arn"`
 		TagKeys     []string `json:"tag_keys"`
 	}
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 	if req.ResourceARN == "" || len(req.TagKeys) == 0 {
-		c.JSON(400, gin.H{"error": "resource_arn and tag_keys are required"})
+		writeJSONError(w, http.StatusBadRequest, "resource_arn and tag_keys are required")
 		return
 	}
 	untagReq := &s3tables.UntagResourceRequest{ResourceARN: req.ResourceARN, TagKeys: req.TagKeys}
-	if err := s.executeS3TablesOperation(c.Request.Context(), "UntagResource", untagReq, nil); err != nil {
-		writeS3TablesError(c, err)
+	if err := s.executeS3TablesOperation(r.Context(), "UntagResource", untagReq, nil); err != nil {
+		writeS3TablesError(w, err)
 		return
 	}
-	c.JSON(200, gin.H{"message": "Tags removed"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Tags removed"})
 }
 
 func parseS3TablesErrorMessage(err error) string {
@@ -1018,8 +1047,8 @@ func parseS3TablesErrorMessage(err error) string {
 	return err.Error()
 }
 
-func writeS3TablesError(c *gin.Context, err error) {
-	c.JSON(s3TablesErrorStatus(err), gin.H{"error": parseS3TablesErrorMessage(err)})
+func writeS3TablesError(w http.ResponseWriter, err error) {
+	writeJSONError(w, s3TablesErrorStatus(err), parseS3TablesErrorMessage(err))
 }
 
 func s3TablesErrorStatus(err error) int {