s3api: order ListObjectVersions newest-first

* fix(admin): release mutex before disk I/O in maintenance queue

saveTaskState performs synchronous BoltDB writes. Calling it while
holding mq.mutex.Lock() in AddTask, GetNextTask, and CompleteTask
blocks all readers (GetTasks via RLock) for the full disk write
duration on every task state change.

During a maintenance scan AddTasksFromResults calls AddTask for every
volume — potentially hundreds of times — meaning the write lock is
held almost continuously. The HTTP handler for /maintenance calls
GetTasks which blocks on RLock, exceeding the 30s timeout and
returning 408 to the browser.

Fix: update in-memory state (mq.tasks, mq.pendingTasks) under the
lock as before, then unlock before calling saveTaskState. In-memory
state is the authoritative source; persistence is crash-recovery only
and does not require lock protection during the write.

* fix(admin): add mutex to ConfigPersistence to synchronize tasks/ filesystem ops

saveTaskState is now called outside mq.mutex, meaning SaveTaskState,
LoadAllTaskStates, DeleteTaskState, and CleanupCompletedTasks can be
invoked concurrently from multiple goroutines. ConfigPersistence had no
internal synchronization, creating races on the tasks/ directory:

- concurrent os.WriteFile + os.ReadFile on the same .pb file could
  yield a partial read and unmarshal error
- LoadAllTaskStates (ReadDir + per-file ReadFile) could see a
  directory entry for a file being written or deleted concurrently
- CleanupCompletedTasks (LoadAllTaskStates + DeleteTaskState) could
  race with SaveTaskState on the same file

Fix: add tasksMu sync.Mutex to ConfigPersistence, acquired at the top
of SaveTaskState, LoadTaskState, LoadAllTaskStates, DeleteTaskState,
and CleanupCompletedTasks. Extract private Locked helpers so that
CleanupCompletedTasks (which holds tasksMu) can call them internally
without deadlocking.

---------

Co-authored-by: Anton Ustyugov <anton@devops>

.github/workflows/depsreview.yml

@@ -11,4 +11,4 @@ jobs:
       - name: 'Checkout Repository'
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
       - name: 'Dependency Review'
-        uses: actions/dependency-review-action@3c4e3dcb1aa7874d2c16be7d79418e9b7efd6261
+        uses: actions/dependency-review-action@05fe4576374b728f0c523d6a13d64c25081e0803

.github/workflows/helm_ci.yml

@@ -119,7 +119,7 @@ jobs:
           echo "✅ All template rendering tests passed!"
 
       - name: Create kind cluster
-        uses: helm/kind-action@v1.13.0
+        uses: helm/kind-action@v1.14.0
 
       - name: Run chart-testing (install)
         run: ct install --target-branch ${{ github.event.repository.default_branch }} --all --chart-dirs k8s/charts

.github/workflows/s3-example-integration-tests.yml

@@ -39,6 +39,14 @@ jobs:
           echo "=== Running S3 Integration Tests ==="
           go test -v -timeout=60s -run TestS3Integration ./...
 
+      - name: Run S3 DeleteBucketNotEmpty Tests
+        timeout-minutes: 15
+        working-directory: test/s3/normal
+        run: |
+          set -x
+          echo "=== Running S3 DeleteBucketNotEmpty Tests ==="
+          go test -v -timeout=60s -run TestS3DeleteBucketNotEmpty ./...
+
       - name: Run IAM Integration Tests
         timeout-minutes: 15
         working-directory: test/s3/normal

Makefile

@@ -1,4 +1,4 @@
-.PHONY: test admin-generate admin-build admin-clean admin-dev admin-run admin-test admin-fmt admin-help
+.PHONY: test admin-generate admin-build admin-clean admin-dev admin-run admin-test admin-fmt admin-help weed-commands
 
 BINARY = weed
 ADMIN_DIR = weed/admin
@@ -11,6 +11,9 @@ all: install
 install: admin-generate
 	cd weed; go install
 
+weed-commands:
+	cd weed && $(MAKE) weed-db weed-sql
+
 warp_install:
 	go install github.com/minio/warp@v0.7.6
 
@@ -40,7 +43,7 @@ test: admin-generate
 # Admin component targets
 admin-generate:
 	@echo "Generating admin component templates..."
-	@templ generate
+	@cd $(ADMIN_DIR) && templ generate ./view
 
 admin-build: admin-generate
 	@echo "Building admin component..."

cmd/weed-db/dbcmd.go

@@ -1,10 +1,11 @@
-package command
+package main
 
 import (
 	"context"
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"os/signal"
 	"strings"
@@ -13,43 +14,12 @@ import (
 
 	"github.com/seaweedfs/seaweedfs/weed/server/postgres"
 	"github.com/seaweedfs/seaweedfs/weed/util"
+	flag "github.com/seaweedfs/seaweedfs/weed/util/fla9"
 )
 
-var (
-	dbOptions DBOptions
-)
+const usageLine = "weed-db -port=5432 -master=<master_server>"
 
-type DBOptions struct {
-	host        *string
-	port        *int
-	masterAddr  *string
-	authMethod  *string
-	users       *string
-	database    *string
-	maxConns    *int
-	idleTimeout *string
-	tlsCert     *string
-	tlsKey      *string
-}
-
-func init() {
-	cmdDB.Run = runDB // break init cycle
-	dbOptions.host = cmdDB.Flag.String("host", "localhost", "Database server host")
-	dbOptions.port = cmdDB.Flag.Int("port", 5432, "Database server port")
-	dbOptions.masterAddr = cmdDB.Flag.String("master", "localhost:9333", "SeaweedFS master server address")
-	dbOptions.authMethod = cmdDB.Flag.String("auth", "trust", "Authentication method: trust, password, md5")
-	dbOptions.users = cmdDB.Flag.String("users", "", "User credentials for auth (JSON format '{\"user1\":\"pass1\",\"user2\":\"pass2\"}' or file '@/path/to/users.json')")
-	dbOptions.database = cmdDB.Flag.String("database", "default", "Default database name")
-	dbOptions.maxConns = cmdDB.Flag.Int("max-connections", 100, "Maximum concurrent connections per server")
-	dbOptions.idleTimeout = cmdDB.Flag.String("idle-timeout", "1h", "Connection idle timeout")
-	dbOptions.tlsCert = cmdDB.Flag.String("tls-cert", "", "TLS certificate file path")
-	dbOptions.tlsKey = cmdDB.Flag.String("tls-key", "", "TLS private key file path")
-}
-
-var cmdDB = &Command{
-	UsageLine: "db -port=5432 -master=<master_server>",
-	Short:     "start a PostgreSQL-compatible database server for SQL queries",
-	Long: `Start a PostgreSQL wire protocol compatible database server that provides SQL query access to SeaweedFS.
+const longHelp = `Start a PostgreSQL wire protocol compatible database server that provides SQL query access to SeaweedFS.
 
 This database server enables any PostgreSQL client, tool, or application to connect to SeaweedFS
 and execute SQL queries against MQ topics. It implements the PostgreSQL wire protocol for maximum
@@ -58,25 +28,25 @@ compatibility with the existing PostgreSQL ecosystem.
 Examples:
 
 	# Start database server on default port 5432
-	weed db
+	weed-db
 	
 	# Start with MD5 authentication using JSON format (recommended)
-	weed db -auth=md5 -users='{"admin":"secret","readonly":"view123"}'
+	weed-db -auth=md5 -users='{"admin":"secret","readonly":"view123"}'
 	
 	# Start with complex passwords using JSON format
-	weed db -auth=md5 -users='{"admin":"pass;with;semicolons","user":"password:with:colons"}'
+	weed-db -auth=md5 -users='{"admin":"pass;with;semicolons","user":"password:with:colons"}'
 	
 	# Start with credentials from JSON file (most secure)
-	weed db -auth=md5 -users="@/etc/seaweedfs/users.json"
+	weed-db -auth=md5 -users="@/etc/seaweedfs/users.json"
 	
 	# Start with custom port and master
-	weed db -port=5433 -master=master1:9333
+	weed-db -port=5433 -master=master1:9333
 	
 	# Allow connections from any host
-	weed db -host=0.0.0.0 -port=5432
+	weed-db -host=0.0.0.0 -port=5432
 	
 	# Start with TLS encryption
-	weed db -tls-cert=server.crt -tls-key=server.key
+	weed-db -tls-cert=server.crt -tls-key=server.key
 
 Client Connection Examples:
 
@@ -95,7 +65,7 @@ Programming Language Examples:
 	# Python (psycopg2)
 	import psycopg2
 	conn = psycopg2.connect(
-		host="localhost", port=5432, 
+		host="localhost", port=5432,
 		user="seaweedfs", database="default"
 	)
 	
@@ -116,7 +86,7 @@ Supported SQL Operations:
 	- SELECT queries on MQ topics
 	- DESCRIBE/DESC table_name commands
 	- EXPLAIN query execution plans
-	- SHOW DATABASES/TABLES commands  
+	- SHOW DATABASES/TABLES commands
 	- Aggregation functions (COUNT, SUM, AVG, MIN, MAX)
 	- WHERE clauses with filtering
 	- System columns (_timestamp_ns, _key, _source)
@@ -149,50 +119,95 @@ Performance Features:
 	- PostgreSQL wire protocol
 	- Query result streaming
 
-`,
+`
+
+type Options struct {
+	Host        string
+	Port        int
+	MasterAddr  string
+	AuthMethod  string
+	Users       string
+	Database    string
+	MaxConns    int
+	IdleTimeout string
+	TLSCert     string
+	TLSKey      string
 }
 
-func runDB(cmd *Command, args []string) bool {
+// Run executes the weed-db CLI.
+func Run(args []string) int {
+	fs := flag.NewFlagSet("weed-db", flag.ContinueOnError)
+	usageWriter := io.Writer(os.Stderr)
+	fs.SetOutput(usageWriter)
 
+	var opts Options
+	fs.StringVar(&opts.Host, "host", "localhost", "Database server host")
+	fs.IntVar(&opts.Port, "port", 5432, "Database server port")
+	fs.StringVar(&opts.MasterAddr, "master", "localhost:9333", "SeaweedFS master server address")
+	fs.StringVar(&opts.AuthMethod, "auth", "trust", "Authentication method: trust, password, md5")
+	fs.StringVar(&opts.Users, "users", "", "User credentials for auth (JSON format '{\"user1\":\"pass1\",\"user2\":\"pass2\"}' or file '@/path/to/users.json')")
+	fs.StringVar(&opts.Database, "database", "default", "Default database name")
+	fs.IntVar(&opts.MaxConns, "max-connections", 100, "Maximum concurrent connections per server")
+	fs.StringVar(&opts.IdleTimeout, "idle-timeout", "1h", "Connection idle timeout")
+	fs.StringVar(&opts.TLSCert, "tls-cert", "", "TLS certificate file path")
+	fs.StringVar(&opts.TLSKey, "tls-key", "", "TLS private key file path")
+
+	fs.Usage = func() {
+		fmt.Fprintf(usageWriter, "Usage: %s\n\n%s\n", usageLine, longHelp)
+		fmt.Fprintln(usageWriter, "Default Parameters:")
+		fs.PrintDefaults()
+	}
+
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+
+	if !runWithOptions(&opts) {
+		return 1
+	}
+	return 0
+}
+
+func runWithOptions(opts *Options) bool {
 	util.LoadConfiguration("security", false)
 
-	// Validate options
-	if *dbOptions.masterAddr == "" {
+	// Validate options.
+	if opts.MasterAddr == "" {
 		fmt.Fprintf(os.Stderr, "Error: master address is required\n")
 		return false
 	}
 
-	// Parse authentication method
-	authMethod, err := parseAuthMethod(*dbOptions.authMethod)
+	// Parse authentication method.
+	authMethod, err := parseAuthMethod(opts.AuthMethod)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		return false
 	}
 
-	// Parse user credentials
-	users, err := parseUsers(*dbOptions.users, authMethod)
+	// Parse user credentials.
+	users, err := parseUsers(opts.Users, authMethod)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		return false
 	}
 
-	// Parse idle timeout
-	idleTimeout, err := time.ParseDuration(*dbOptions.idleTimeout)
+	// Parse idle timeout.
+	idleTimeout, err := time.ParseDuration(opts.IdleTimeout)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error parsing idle timeout: %v\n", err)
 		return false
 	}
 
-	// Validate port number
-	if err := validatePortNumber(*dbOptions.port); err != nil {
+	// Validate port number.
+	if err := validatePortNumber(opts.Port); err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 		return false
 	}
 
-	// Setup TLS if requested
+	// Setup TLS if requested.
 	var tlsConfig *tls.Config
-	if *dbOptions.tlsCert != "" && *dbOptions.tlsKey != "" {
-		cert, err := tls.LoadX509KeyPair(*dbOptions.tlsCert, *dbOptions.tlsKey)
+	if opts.TLSCert != "" && opts.TLSKey != "" {
+		cert, err := tls.LoadX509KeyPair(opts.TLSCert, opts.TLSKey)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error loading TLS certificates: %v\n", err)
 			return false
@@ -202,34 +217,34 @@ func runDB(cmd *Command, args []string) bool {
 		}
 	}
 
-	// Create server configuration
+	// Create server configuration.
 	config := &postgres.PostgreSQLServerConfig{
-		Host:        *dbOptions.host,
-		Port:        *dbOptions.port,
+		Host:        opts.Host,
+		Port:        opts.Port,
 		AuthMethod:  authMethod,
 		Users:       users,
-		Database:    *dbOptions.database,
-		MaxConns:    *dbOptions.maxConns,
+		Database:    opts.Database,
+		MaxConns:    opts.MaxConns,
 		IdleTimeout: idleTimeout,
 		TLSConfig:   tlsConfig,
 	}
 
-	// Create database server
-	dbServer, err := postgres.NewPostgreSQLServer(config, *dbOptions.masterAddr)
+	// Create database server.
+	dbServer, err := postgres.NewPostgreSQLServer(config, opts.MasterAddr)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error creating database server: %v\n", err)
 		return false
 	}
 
-	// Print startup information
+	// Print startup information.
 	fmt.Printf("Starting SeaweedFS Database Server...\n")
-	fmt.Printf("Host: %s\n", *dbOptions.host)
-	fmt.Printf("Port: %d\n", *dbOptions.port)
-	fmt.Printf("Master: %s\n", *dbOptions.masterAddr)
-	fmt.Printf("Database: %s\n", *dbOptions.database)
-	fmt.Printf("Auth Method: %s\n", *dbOptions.authMethod)
-	fmt.Printf("Max Connections: %d\n", *dbOptions.maxConns)
-	fmt.Printf("Idle Timeout: %s\n", *dbOptions.idleTimeout)
+	fmt.Printf("Host: %s\n", opts.Host)
+	fmt.Printf("Port: %d\n", opts.Port)
+	fmt.Printf("Master: %s\n", opts.MasterAddr)
+	fmt.Printf("Database: %s\n", opts.Database)
+	fmt.Printf("Auth Method: %s\n", opts.AuthMethod)
+	fmt.Printf("Max Connections: %d\n", opts.MaxConns)
+	fmt.Printf("Idle Timeout: %s\n", opts.IdleTimeout)
 	if tlsConfig != nil {
 		fmt.Printf("TLS: Enabled\n")
 	} else {
@@ -240,15 +255,15 @@ func runDB(cmd *Command, args []string) bool {
 	}
 
 	fmt.Printf("\nDatabase Connection Examples:\n")
-	fmt.Printf("  psql -h %s -p %d -U seaweedfs -d %s\n", *dbOptions.host, *dbOptions.port, *dbOptions.database)
+	fmt.Printf("  psql -h %s -p %d -U seaweedfs -d %s\n", opts.Host, opts.Port, opts.Database)
 	if len(users) > 0 {
-		// Show first user as example
+		// Show first user as example.
 		for username := range users {
-			fmt.Printf("  psql -h %s -p %d -U %s -d %s\n", *dbOptions.host, *dbOptions.port, username, *dbOptions.database)
+			fmt.Printf("  psql -h %s -p %d -U %s -d %s\n", opts.Host, opts.Port, username, opts.Database)
 			break
 		}
 	}
-	fmt.Printf("  postgresql://%s:%d/%s\n", *dbOptions.host, *dbOptions.port, *dbOptions.database)
+	fmt.Printf("  postgresql://%s:%d/%s\n", opts.Host, opts.Port, opts.Database)
 
 	fmt.Printf("\nSupported Operations:\n")
 	fmt.Printf("  - SELECT queries on MQ topics\n")
@@ -261,26 +276,26 @@ func runDB(cmd *Command, args []string) bool {
 
 	fmt.Printf("\nReady for database connections!\n\n")
 
-	// Start the server
+	// Start the server.
 	err = dbServer.Start()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error starting database server: %v\n", err)
 		return false
 	}
 
-	// Set up signal handling for graceful shutdown
+	// Set up signal handling for graceful shutdown.
 	sigChan := make(chan os.Signal, 1)
 	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 
-	// Wait for shutdown signal
+	// Wait for shutdown signal.
 	<-sigChan
 	fmt.Printf("\nReceived shutdown signal, stopping database server...\n")
 
-	// Create context with timeout for graceful shutdown
+	// Create context with timeout for graceful shutdown.
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	// Stop the server with timeout
+	// Stop the server with timeout.
 	done := make(chan error, 1)
 	go func() {
 		done <- dbServer.Stop()
@@ -301,7 +316,7 @@ func runDB(cmd *Command, args []string) bool {
 	return true
 }
 
-// parseAuthMethod parses the authentication method string
+// parseAuthMethod parses the authentication method string.
 func parseAuthMethod(method string) (postgres.AuthMethod, error) {
 	switch strings.ToLower(method) {
 	case "trust":
@@ -315,7 +330,7 @@ func parseAuthMethod(method string) (postgres.AuthMethod, error) {
 	}
 }
 
-// parseUsers parses the user credentials string with support for secure formats only
+// parseUsers parses the user credentials string with support for secure formats only.
 // Supported formats:
 // 1. JSON format: {"username":"password","username2":"password2"}
 // 2. File format: /path/to/users.json or @/path/to/users.json
@@ -323,41 +338,41 @@ func parseUsers(usersStr string, authMethod postgres.AuthMethod) (map[string]str
 	users := make(map[string]string)
 
 	if usersStr == "" {
-		// No users specified
+		// No users specified.
 		if authMethod != postgres.AuthTrust {
 			return nil, fmt.Errorf("users must be specified when auth method is not 'trust'")
 		}
 		return users, nil
 	}
 
-	// Trim whitespace
+	// Trim whitespace.
 	usersStr = strings.TrimSpace(usersStr)
 
-	// Determine format and parse accordingly
+	// Determine format and parse accordingly.
 	if strings.HasPrefix(usersStr, "{") && strings.HasSuffix(usersStr, "}") {
-		// JSON format
+		// JSON format.
 		return parseUsersJSON(usersStr, authMethod)
 	}
 
-	// Check if it's a file path (with or without @ prefix) before declaring invalid format
+	// Check if it's a file path (with or without @ prefix) before declaring invalid format.
 	filePath := strings.TrimPrefix(usersStr, "@")
 	if _, err := os.Stat(filePath); err == nil {
-		// File format
-		return parseUsersFile(usersStr, authMethod) // Pass original string to preserve @ handling
+		// File format.
+		return parseUsersFile(usersStr, authMethod) // Pass original string to preserve @ handling.
 	}
 
-	// Invalid format
+	// Invalid format.
 	return nil, fmt.Errorf("invalid user credentials format. Use JSON format '{\"user\":\"pass\"}' or file format '@/path/to/users.json' or 'path/to/users.json'. Legacy semicolon-separated format is no longer supported")
 }
 
-// parseUsersJSON parses user credentials from JSON format
+// parseUsersJSON parses user credentials from JSON format.
 func parseUsersJSON(jsonStr string, authMethod postgres.AuthMethod) (map[string]string, error) {
 	var users map[string]string
 	if err := json.Unmarshal([]byte(jsonStr), &users); err != nil {
 		return nil, fmt.Errorf("invalid JSON format for users: %v", err)
 	}
 
-	// Validate users
+	// Validate users.
 	for username, password := range users {
 		if username == "" {
 			return nil, fmt.Errorf("empty username in JSON user specification")
@@ -370,12 +385,12 @@ func parseUsersJSON(jsonStr string, authMethod postgres.AuthMethod) (map[string]
 	return users, nil
 }
 
-// parseUsersFile parses user credentials from a JSON file
+// parseUsersFile parses user credentials from a JSON file.
 func parseUsersFile(filePath string, authMethod postgres.AuthMethod) (map[string]string, error) {
-	// Remove @ prefix if present
+	// Remove @ prefix if present.
 	filePath = strings.TrimPrefix(filePath, "@")
 
-	// Read file content
+	// Read file content.
 	content, err := os.ReadFile(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read users file '%s': %v", filePath, err)
@@ -383,16 +398,16 @@ func parseUsersFile(filePath string, authMethod postgres.AuthMethod) (map[string
 
 	contentStr := strings.TrimSpace(string(content))
 
-	// File must contain JSON format
+	// File must contain JSON format.
 	if !strings.HasPrefix(contentStr, "{") || !strings.HasSuffix(contentStr, "}") {
 		return nil, fmt.Errorf("users file '%s' must contain JSON format: {\"user\":\"pass\"}. Legacy formats are no longer supported", filePath)
 	}
 
-	// Parse as JSON
+	// Parse as JSON.
 	return parseUsersJSON(contentStr, authMethod)
 }
 
-// validatePortNumber validates that the port number is reasonable
+// validatePortNumber validates that the port number is reasonable.
 func validatePortNumber(port int) error {
 	if port < 1 || port > 65535 {
 		return fmt.Errorf("port number must be between 1 and 65535, got %d", port)

cmd/weed-db/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "os"
+
+func main() {
+	os.Exit(Run(os.Args[1:]))
+}

cmd/weed-sql/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "os"
+
+func main() {
+	os.Exit(Run(os.Args[1:]))
+}

cmd/weed-sql/sqlcmd.go

@@ -1,4 +1,4 @@
-package command
+package main
 
 import (
 	"context"
@@ -13,28 +13,24 @@ import (
 
 	"github.com/peterh/liner"
 	"github.com/seaweedfs/seaweedfs/weed/query/engine"
+	flag "github.com/seaweedfs/seaweedfs/weed/util/fla9"
 	"github.com/seaweedfs/seaweedfs/weed/util/grace"
 	"github.com/seaweedfs/seaweedfs/weed/util/sqlutil"
 )
 
-func init() {
-	cmdSql.Run = runSql
-}
+const usageLine = "weed-sql [-master=localhost:9333] [-interactive] [-file=query.sql] [-output=table|json|csv] [-database=dbname] [-query=\"SQL\"]"
 
-var cmdSql = &Command{
-	UsageLine: "sql [-master=localhost:9333] [-interactive] [-file=query.sql] [-output=table|json|csv] [-database=dbname] [-query=\"SQL\"]",
-	Short:     "advanced SQL query interface for SeaweedFS MQ topics with multiple execution modes",
-	Long: `Enhanced SQL interface for SeaweedFS Message Queue topics with multiple execution modes.
+const longHelp = `Enhanced SQL interface for SeaweedFS Message Queue topics with multiple execution modes.
 
 Execution Modes:
-- Interactive shell (default): weed sql -interactive
-- Single query: weed sql -query "SELECT * FROM user_events"  
-- Batch from file: weed sql -file queries.sql
-- Context switching: weed sql -database analytics -interactive
+- Interactive shell (default): weed-sql -interactive
+- Single query: weed-sql -query "SELECT * FROM user_events"
+- Batch from file: weed-sql -file queries.sql
+- Context switching: weed-sql -database analytics -interactive
 
 Output Formats:
 - table: ASCII table format (default for interactive)
-- json: JSON format (default for non-interactive) 
+- json: JSON format (default for non-interactive)
 - csv: Comma-separated values
 
 Features:
@@ -45,24 +41,23 @@ Features:
 - Database context switching
 
 Examples:
-  weed sql -interactive
-  weed sql -query "SHOW DATABASES" -output json
-  weed sql -file batch_queries.sql -output csv
-  weed sql -database analytics -query "SELECT COUNT(*) FROM metrics"
-  weed sql -master broker1:9333 -interactive
-`,
+  weed-sql -interactive
+  weed-sql -query "SHOW DATABASES" -output json
+  weed-sql -file batch_queries.sql -output csv
+  weed-sql -database analytics -query "SELECT COUNT(*) FROM metrics"
+  weed-sql -master broker1:9333 -interactive
+`
+
+type Options struct {
+	Master      string
+	Interactive bool
+	File        string
+	Output      string
+	Database    string
+	Query       string
 }
 
-var (
-	sqlMaster      = cmdSql.Flag.String("master", "localhost:9333", "SeaweedFS master server HTTP address")
-	sqlInteractive = cmdSql.Flag.Bool("interactive", false, "start interactive shell mode")
-	sqlFile        = cmdSql.Flag.String("file", "", "execute SQL queries from file")
-	sqlOutput      = cmdSql.Flag.String("output", "", "output format: table, json, csv (auto-detected if not specified)")
-	sqlDatabase    = cmdSql.Flag.String("database", "", "default database context")
-	sqlQuery       = cmdSql.Flag.String("query", "", "execute single SQL query")
-)
-
-// OutputFormat represents different output formatting options
+// OutputFormat represents different output formatting options.
 type OutputFormat string
 
 const (
@@ -71,50 +66,82 @@ const (
 	OutputCSV   OutputFormat = "csv"
 )
 
-// SQLContext holds the execution context for SQL operations
+// SQLContext holds the execution context for SQL operations.
 type SQLContext struct {
 	engine          *engine.SQLEngine
 	currentDatabase string
 	outputFormat    OutputFormat
 	interactive     bool
+	master          string
 }
 
-func runSql(command *Command, args []string) bool {
-	// Initialize SQL engine with master address for service discovery
-	sqlEngine := engine.NewSQLEngine(*sqlMaster)
+// Run executes the weed-sql CLI.
+func Run(args []string) int {
+	fs := flag.NewFlagSet("weed-sql", flag.ContinueOnError)
+	usageWriter := io.Writer(os.Stderr)
+	fs.SetOutput(usageWriter)
 
-	// Determine execution mode and output format
-	interactive := *sqlInteractive || (*sqlQuery == "" && *sqlFile == "")
-	outputFormat := determineOutputFormat(*sqlOutput, interactive)
+	var opts Options
+	fs.StringVar(&opts.Master, "master", "localhost:9333", "SeaweedFS master server HTTP address")
+	fs.BoolVar(&opts.Interactive, "interactive", false, "start interactive shell mode")
+	fs.StringVar(&opts.File, "file", "", "execute SQL queries from file")
+	fs.StringVar(&opts.Output, "output", "", "output format: table, json, csv (auto-detected if not specified)")
+	fs.StringVar(&opts.Database, "database", "", "default database context")
+	fs.StringVar(&opts.Query, "query", "", "execute single SQL query")
 
-	// Create SQL context
+	fs.Usage = func() {
+		fmt.Fprintf(usageWriter, "Usage: %s\n\n%s\n", usageLine, longHelp)
+		fmt.Fprintln(usageWriter, "Default Parameters:")
+		fs.PrintDefaults()
+	}
+
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+
+	if !runWithOptions(&opts) {
+		return 1
+	}
+	return 0
+}
+
+func runWithOptions(opts *Options) bool {
+	// Initialize SQL engine with master address for service discovery.
+	sqlEngine := engine.NewSQLEngine(opts.Master)
+
+	// Determine execution mode and output format.
+	interactive := opts.Interactive || (opts.Query == "" && opts.File == "")
+	outputFormat := determineOutputFormat(opts.Output, interactive)
+
+	// Create SQL context.
 	ctx := &SQLContext{
 		engine:          sqlEngine,
-		currentDatabase: *sqlDatabase,
+		currentDatabase: opts.Database,
 		outputFormat:    outputFormat,
 		interactive:     interactive,
+		master:          opts.Master,
 	}
 
-	// Set current database in SQL engine if specified via command line
-	if *sqlDatabase != "" {
-		ctx.engine.GetCatalog().SetCurrentDatabase(*sqlDatabase)
+	// Set current database in SQL engine if specified via command line.
+	if opts.Database != "" {
+		ctx.engine.GetCatalog().SetCurrentDatabase(opts.Database)
 	}
 
-	// Execute based on mode
+	// Execute based on mode.
 	switch {
-	case *sqlQuery != "":
-		// Single query mode
-		return executeSingleQuery(ctx, *sqlQuery)
-	case *sqlFile != "":
-		// Batch file mode
-		return executeFileQueries(ctx, *sqlFile)
+	case opts.Query != "":
+		// Single query mode.
+		return executeSingleQuery(ctx, opts.Query)
+	case opts.File != "":
+		// Batch file mode.
+		return executeFileQueries(ctx, opts.File)
 	default:
-		// Interactive mode
+		// Interactive mode.
 		return runInteractiveShell(ctx)
 	}
 }
 
-// determineOutputFormat selects the appropriate output format
+// determineOutputFormat selects the appropriate output format.
 func determineOutputFormat(specified string, interactive bool) OutputFormat {
 	switch strings.ToLower(specified) {
 	case "table":
@@ -124,7 +151,7 @@ func determineOutputFormat(specified string, interactive bool) OutputFormat {
 	case "csv":
 		return OutputCSV
 	default:
-		// Auto-detect based on mode
+		// Auto-detect based on mode.
 		if interactive {
 			return OutputTable
 		}
@@ -132,18 +159,18 @@ func determineOutputFormat(specified string, interactive bool) OutputFormat {
 	}
 }
 
-// executeSingleQuery executes a single query and outputs the result
+// executeSingleQuery executes a single query and outputs the result.
 func executeSingleQuery(ctx *SQLContext, query string) bool {
 	if ctx.outputFormat != OutputTable {
-		// Suppress banner for non-interactive output
+		// Suppress banner for non-interactive output.
 		return executeAndDisplay(ctx, query, false)
 	}
 
-	fmt.Printf("Executing query against %s...\n", *sqlMaster)
+	fmt.Printf("Executing query against %s...\n", ctx.master)
 	return executeAndDisplay(ctx, query, true)
 }
 
-// executeFileQueries processes SQL queries from a file
+// executeFileQueries processes SQL queries from a file.
 func executeFileQueries(ctx *SQLContext, filename string) bool {
 	content, err := os.ReadFile(filename)
 	if err != nil {
@@ -152,10 +179,10 @@ func executeFileQueries(ctx *SQLContext, filename string) bool {
 	}
 
 	if ctx.outputFormat == OutputTable && ctx.interactive {
-		fmt.Printf("Executing queries from %s against %s...\n", filename, *sqlMaster)
+		fmt.Printf("Executing queries from %s against %s...\n", filename, ctx.master)
 	}
 
-	// Split file content into individual queries (robust approach)
+	// Split file content into individual queries (robust approach).
 	queries := sqlutil.SplitStatements(string(content))
 
 	for i, query := range queries {
@@ -176,11 +203,11 @@ func executeFileQueries(ctx *SQLContext, filename string) bool {
 	return true
 }
 
-// runInteractiveShell starts the enhanced interactive shell with readline support
+// runInteractiveShell starts the enhanced interactive shell with readline support.
 func runInteractiveShell(ctx *SQLContext) bool {
 	fmt.Println("SeaweedFS Enhanced SQL Interface")
 	fmt.Println("Type 'help;' for help, 'exit;' to quit")
-	fmt.Printf("Connected to master: %s\n", *sqlMaster)
+	fmt.Printf("Connected to master: %s\n", ctx.master)
 	if ctx.currentDatabase != "" {
 		fmt.Printf("Current database: %s\n", ctx.currentDatabase)
 	}
@@ -188,24 +215,24 @@ func runInteractiveShell(ctx *SQLContext) bool {
 	fmt.Println("Use up/down arrows for command history")
 	fmt.Println()
 
-	// Initialize liner for readline functionality
+	// Initialize liner for readline functionality.
 	line := liner.NewLiner()
 	defer line.Close()
 
-	// Handle Ctrl+C gracefully
+	// Handle Ctrl+C gracefully.
 	line.SetCtrlCAborts(true)
 	grace.OnInterrupt(func() {
 		line.Close()
 	})
 
-	// Load command history
+	// Load command history.
 	historyPath := path.Join(os.TempDir(), "weed-sql-history")
 	if f, err := os.Open(historyPath); err == nil {
 		line.ReadHistory(f)
 		f.Close()
 	}
 
-	// Save history on exit
+	// Save history on exit.
 	defer func() {
 		if f, err := os.Create(historyPath); err == nil {
 			line.WriteHistory(f)
@@ -216,7 +243,7 @@ func runInteractiveShell(ctx *SQLContext) bool {
 	var queryBuffer strings.Builder
 
 	for {
-		// Show prompt with current database context
+		// Show prompt with current database context.
 		var prompt string
 		if queryBuffer.Len() == 0 {
 			if ctx.currentDatabase != "" {
@@ -225,10 +252,10 @@ func runInteractiveShell(ctx *SQLContext) bool {
 				prompt = "seaweedfs> "
 			}
 		} else {
-			prompt = "    -> " // Continuation prompt
+			prompt = "    -> " // Continuation prompt.
 		}
 
-		// Read line with readline support
+		// Read line with readline support.
 		input, err := line.Prompt(prompt)
 		if err != nil {
 			if err == liner.ErrPromptAborted {
@@ -244,30 +271,30 @@ func runInteractiveShell(ctx *SQLContext) bool {
 
 		lineStr := strings.TrimSpace(input)
 
-		// Handle empty lines
+		// Handle empty lines.
 		if lineStr == "" {
 			continue
 		}
 
-		// Accumulate lines in query buffer
+		// Accumulate lines in query buffer.
 		if queryBuffer.Len() > 0 {
 			queryBuffer.WriteString(" ")
 		}
 		queryBuffer.WriteString(lineStr)
 
-		// Check if we have a complete statement (ends with semicolon or special command)
+		// Check if we have a complete statement (ends with semicolon or special command).
 		fullQuery := strings.TrimSpace(queryBuffer.String())
 		isComplete := strings.HasSuffix(lineStr, ";") ||
 			isSpecialCommand(fullQuery)
 
 		if !isComplete {
-			continue // Continue reading more lines
+			continue // Continue reading more lines.
 		}
 
-		// Add completed command to history
+		// Add completed command to history.
 		line.AppendHistory(fullQuery)
 
-		// Handle special commands (with or without semicolon)
+		// Handle special commands (with or without semicolon).
 		cleanQuery := strings.TrimSuffix(fullQuery, ";")
 		cleanQuery = strings.TrimSpace(cleanQuery)
 
@@ -282,19 +309,19 @@ func runInteractiveShell(ctx *SQLContext) bool {
 			continue
 		}
 
-		// Handle database switching - use proper SQL parser instead of manual parsing
+		// Handle database switching - use proper SQL parser instead of manual parsing.
 		if strings.HasPrefix(strings.ToUpper(cleanQuery), "USE ") {
-			// Execute USE statement through the SQL engine for proper parsing
+			// Execute USE statement through the SQL engine for proper parsing.
 			result, err := ctx.engine.ExecuteSQL(context.Background(), cleanQuery)
 			if err != nil {
 				fmt.Printf("Error: %v\n\n", err)
 			} else if result.Error != nil {
 				fmt.Printf("Error: %v\n\n", result.Error)
 			} else {
-				// Extract the database name from the result message for CLI context
+				// Extract the database name from the result message for CLI context.
 				if len(result.Rows) > 0 && len(result.Rows[0]) > 0 {
 					message := result.Rows[0][0].ToString()
-					// Extract database name from "Database changed to: dbname"
+					// Extract database name from "Database changed to: dbname".
 					if strings.HasPrefix(message, "Database changed to: ") {
 						ctx.currentDatabase = strings.TrimPrefix(message, "Database changed to: ")
 					}
@@ -305,7 +332,7 @@ func runInteractiveShell(ctx *SQLContext) bool {
 			continue
 		}
 
-		// Handle output format switching
+		// Handle output format switching.
 		if strings.HasPrefix(strings.ToUpper(cleanQuery), "\\FORMAT ") {
 			format := strings.TrimSpace(strings.TrimPrefix(strings.ToUpper(cleanQuery), "\\FORMAT "))
 			switch format {
@@ -325,22 +352,22 @@ func runInteractiveShell(ctx *SQLContext) bool {
 			continue
 		}
 
-		// Execute SQL query (without semicolon)
+		// Execute SQL query (without semicolon).
 		executeAndDisplay(ctx, cleanQuery, true)
 
-		// Reset buffer for next query
+		// Reset buffer for next query.
 		queryBuffer.Reset()
 	}
 
 	return true
 }
 
-// isSpecialCommand checks if a command is a special command that doesn't require semicolon
+// isSpecialCommand checks if a command is a special command that doesn't require semicolon.
 func isSpecialCommand(query string) bool {
 	cleanQuery := strings.TrimSuffix(strings.TrimSpace(query), ";")
 	cleanQuery = strings.ToLower(cleanQuery)
 
-	// Special commands that work with or without semicolon
+	// Special commands that work with or without semicolon.
 	specialCommands := []string{
 		"exit", "quit", "\\q", "help",
 	}
@@ -351,7 +378,7 @@ func isSpecialCommand(query string) bool {
 		}
 	}
 
-	// Commands that are exactly specific commands (not just prefixes)
+	// Commands that are exactly specific commands (not just prefixes).
 	parts := strings.Fields(strings.ToUpper(cleanQuery))
 	if len(parts) == 0 {
 		return false
@@ -360,11 +387,11 @@ func isSpecialCommand(query string) bool {
 		strings.HasPrefix(strings.ToUpper(cleanQuery), "\\FORMAT ")
 }
 
-// executeAndDisplay executes a query and displays the result in the specified format
+// executeAndDisplay executes a query and displays the result in the specified format.
 func executeAndDisplay(ctx *SQLContext, query string, showTiming bool) bool {
 	startTime := time.Now()
 
-	// Execute the query
+	// Execute the query.
 	execCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
@@ -397,7 +424,7 @@ func executeAndDisplay(ctx *SQLContext, query string, showTiming bool) bool {
 		return false
 	}
 
-	// Display results in the specified format
+	// Display results in the specified format.
 	switch ctx.outputFormat {
 	case OutputTable:
 		displayTableResult(result)
@@ -407,8 +434,8 @@ func executeAndDisplay(ctx *SQLContext, query string, showTiming bool) bool {
 		displayCSVResult(result)
 	}
 
-	// Show execution time for interactive/table mode
-	// Only show timing if there are columns or if result is truly empty
+	// Show execution time for interactive/table mode.
+	// Only show timing if there are columns or if result is truly empty.
 	if showTiming && ctx.outputFormat == OutputTable && (len(result.Columns) > 0 || len(result.Rows) == 0) {
 		elapsed := time.Since(startTime)
 		fmt.Printf("\n(%d rows in set, %.3f sec)\n\n", len(result.Rows), elapsed.Seconds())
@@ -417,20 +444,20 @@ func executeAndDisplay(ctx *SQLContext, query string, showTiming bool) bool {
 	return true
 }
 
-// displayTableResult formats and displays query results in ASCII table format
+// displayTableResult formats and displays query results in ASCII table format.
 func displayTableResult(result *engine.QueryResult) {
 	if len(result.Columns) == 0 {
 		fmt.Println("Empty result set")
 		return
 	}
 
-	// Calculate column widths for formatting
+	// Calculate column widths for formatting.
 	colWidths := make([]int, len(result.Columns))
 	for i, col := range result.Columns {
 		colWidths[i] = len(col)
 	}
 
-	// Check data for wider columns
+	// Check data for wider columns.
 	for _, row := range result.Rows {
 		for i, val := range row {
 			if i < len(colWidths) {
@@ -442,28 +469,28 @@ func displayTableResult(result *engine.QueryResult) {
 		}
 	}
 
-	// Print header separator
+	// Print header separator.
 	fmt.Print("+")
 	for _, width := range colWidths {
 		fmt.Print(strings.Repeat("-", width+2) + "+")
 	}
 	fmt.Println()
 
-	// Print column headers
+	// Print column headers.
 	fmt.Print("|")
 	for i, col := range result.Columns {
 		fmt.Printf(" %-*s |", colWidths[i], col)
 	}
 	fmt.Println()
 
-	// Print separator
+	// Print separator.
 	fmt.Print("+")
 	for _, width := range colWidths {
 		fmt.Print(strings.Repeat("-", width+2) + "+")
 	}
 	fmt.Println()
 
-	// Print data rows
+	// Print data rows.
 	for _, row := range result.Rows {
 		fmt.Print("|")
 		for i, val := range row {
@@ -474,7 +501,7 @@ func displayTableResult(result *engine.QueryResult) {
 		fmt.Println()
 	}
 
-	// Print bottom separator
+	// Print bottom separator.
 	fmt.Print("+")
 	for _, width := range colWidths {
 		fmt.Print(strings.Repeat("-", width+2) + "+")
@@ -482,16 +509,16 @@ func displayTableResult(result *engine.QueryResult) {
 	fmt.Println()
 }
 
-// displayJSONResult outputs query results in JSON format
+// displayJSONResult outputs query results in JSON format.
 func displayJSONResult(result *engine.QueryResult) {
-	// Convert result to JSON-friendly format
+	// Convert result to JSON-friendly format.
 	jsonResult := map[string]interface{}{
 		"columns": result.Columns,
 		"rows":    make([]map[string]interface{}, len(result.Rows)),
 		"count":   len(result.Rows),
 	}
 
-	// Convert rows to JSON objects
+	// Convert rows to JSON objects.
 	for i, row := range result.Rows {
 		rowObj := make(map[string]interface{})
 		for j, val := range row {
@@ -502,7 +529,7 @@ func displayJSONResult(result *engine.QueryResult) {
 		jsonResult["rows"].([]map[string]interface{})[i] = rowObj
 	}
 
-	// Marshal and print JSON
+	// Marshal and print JSON.
 	jsonBytes, err := json.MarshalIndent(jsonResult, "", "  ")
 	if err != nil {
 		fmt.Printf("Error formatting JSON: %v\n", err)
@@ -512,11 +539,11 @@ func displayJSONResult(result *engine.QueryResult) {
 	fmt.Println(string(jsonBytes))
 }
 
-// displayCSVResult outputs query results in CSV format
+// displayCSVResult outputs query results in CSV format.
 func displayCSVResult(result *engine.QueryResult) {
-	// Handle execution plan results specially to avoid CSV quoting issues
+	// Handle execution plan results specially to avoid CSV quoting issues.
 	if len(result.Columns) == 1 && result.Columns[0] == "Query Execution Plan" {
-		// For execution plans, output directly without CSV encoding to avoid quotes
+		// For execution plans, output directly without CSV encoding to avoid quotes.
 		for _, row := range result.Rows {
 			if len(row) > 0 {
 				fmt.Println(row[0].ToString())
@@ -525,17 +552,17 @@ func displayCSVResult(result *engine.QueryResult) {
 		return
 	}
 
-	// Standard CSV output for regular query results
+	// Standard CSV output for regular query results.
 	writer := csv.NewWriter(os.Stdout)
 	defer writer.Flush()
 
-	// Write headers
+	// Write headers.
 	if err := writer.Write(result.Columns); err != nil {
 		fmt.Printf("Error writing CSV headers: %v\n", err)
 		return
 	}
 
-	// Write data rows
+	// Write data rows.
 	for _, row := range result.Rows {
 		csvRow := make([]string, len(row))
 		for i, val := range row {
@@ -553,7 +580,7 @@ func showEnhancedHelp() {
 
 METADATA OPERATIONS:
   SHOW DATABASES;              - List all MQ namespaces
-  SHOW TABLES;                 - List all topics in current namespace  
+  SHOW TABLES;                 - List all topics in current namespace
   SHOW TABLES FROM database;   - List topics in specific namespace
   DESCRIBE table_name;         - Show table schema
 
@@ -581,7 +608,7 @@ SPECIAL COMMANDS:
 
 EXTENDED WHERE OPERATORS:
   =, <, >, <=, >=             - Comparison operators
-  !=, <>                      - Not equal operators  
+  !=, <>                      - Not equal operators
   LIKE 'pattern%'             - Pattern matching (% = any chars, _ = single char)
   IN (value1, value2, ...)    - Multi-value matching
   AND, OR                     - Logical operators

docker/entrypoint.sh

@@ -20,13 +20,17 @@ if [ "$(id -u)" = "0" ]; then
   
   DATA_UID=$(stat -c '%u' /data 2>/dev/null)
   DATA_GID=$(stat -c '%g' /data 2>/dev/null)
-  
-  # Only run chown -R if ownership doesn't match (much faster for subsequent starts)
+
+  # Only run chown -R if ownership doesn't already match (avoids expensive
+  # recursive chown on subsequent starts, and is a no-op on OpenShift when
+  # fsGroup has already set correct ownership on the PVC).
+  if [ "$DATA_UID" != "$SEAWEED_UID" ] || [ "$DATA_GID" != "$SEAWEED_GID" ]; then
     echo "Fixing /data ownership for seaweed user (uid=$SEAWEED_UID, gid=$SEAWEED_GID)"
     if ! chown -R seaweed:seaweed /data; then
       echo "Warning: Failed to change ownership of /data. This may cause permission errors." >&2
       echo "If /data is read-only or has mount issues, the application may fail to start." >&2
     fi
+  fi
   
   # Use su-exec to drop privileges and run as seaweed user
   exec su-exec seaweed "$0" "$@"

docker/seaweedfs-dev-compose.yml

@@ -42,3 +42,12 @@ services:
       - master
       - volume
       - filer
+  admin:
+    image: chrislusf/seaweedfs:dev # use a remote dev image
+    ports:
+      - 23646:23646
+    command: 'admin -master=master:9333'
+    depends_on:
+      - master
+      - volume
+      - filer

go.mod

@@ -94,7 +94,7 @@ require (
 	gocloud.dev/pubsub/rabbitpubsub v0.44.0
 	golang.org/x/crypto v0.48.0
 	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546
-	golang.org/x/image v0.35.0
+	golang.org/x/image v0.36.0
 	golang.org/x/net v0.49.0
 	golang.org/x/oauth2 v0.34.0
 	golang.org/x/sys v0.41.0
@@ -109,7 +109,7 @@ require (
 	modernc.org/b v1.0.0 // indirect
 	modernc.org/mathutil v1.7.1
 	modernc.org/memory v1.11.0 // indirect
-	modernc.org/sqlite v1.44.3
+	modernc.org/sqlite v1.46.1
 	modernc.org/strutil v1.2.1
 )
 
@@ -131,8 +131,6 @@ require (
 	github.com/cognusion/imaging v1.0.2
 	github.com/fluent/fluent-logger-golang v1.10.1
 	github.com/getsentry/sentry-go v0.42.0
-	github.com/gin-contrib/sessions v1.0.4
-	github.com/gin-gonic/gin v1.11.0
 	github.com/go-ldap/ldap/v3 v3.4.12
 	github.com/golang-jwt/jwt/v5 v5.3.1
 	github.com/google/flatbuffers/go v0.0.0-20230108230133-3b8644d32c50
@@ -148,7 +146,7 @@ require (
 	github.com/parquet-go/parquet-go v0.26.4
 	github.com/pkg/sftp v1.13.10
 	github.com/rabbitmq/amqp091-go v1.10.0
-	github.com/rclone/rclone v1.72.1
+	github.com/rclone/rclone v1.73.1
 	github.com/rdleal/intervalst v1.5.0
 	github.com/redis/go-redis/v9 v9.18.0
 	github.com/schollz/progressbar/v3 v3.19.0
@@ -180,6 +178,7 @@ require (
 	github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect
 	github.com/Azure/go-autorest v14.2.0+incompatible // indirect
 	github.com/Azure/go-autorest/autorest/to v0.4.1 // indirect
+	github.com/FilenCloudDienste/filen-sdk-go v0.0.37 // indirect
 	github.com/a1ex3/zstd-seekable-format-go/pkg v0.10.0 // indirect
 	github.com/anchore/go-lzo v0.1.0 // indirect
 	github.com/antlr4-go/antlr/v4 v4.13.1 // indirect
@@ -212,6 +211,8 @@ require (
 	github.com/docker/docker v28.5.0+incompatible // indirect
 	github.com/docker/go-connections v0.6.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
+	github.com/dromara/dongle v1.0.1 // indirect
+	github.com/gin-gonic/gin v1.11.0 // indirect
 	github.com/go-asn1-ber/asn1-ber v1.5.8-0.20250403174932-29230038a667 // indirect
 	github.com/go-git/go-billy/v5 v5.6.2 // indirect
 	github.com/goccy/go-yaml v1.18.0 // indirect
@@ -226,6 +227,7 @@ require (
 	github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 // indirect
 	github.com/hashicorp/go-sockaddr v1.0.7 // indirect
 	github.com/hashicorp/hcl v1.0.1-vault-7 // indirect
+	github.com/internxt/rclone-adapter v0.0.0-20260213125353-6f59c89fcb7c // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
 	github.com/jackc/puddle/v2 v2.2.2 // indirect
@@ -257,8 +259,9 @@ require (
 	github.com/pierrre/geohash v1.0.0 // indirect
 	github.com/pquerna/otp v1.5.0 // indirect
 	github.com/pterm/pterm v0.12.81 // indirect
-	github.com/quic-go/qpack v0.6.0 // indirect
 	github.com/quic-go/quic-go v0.57.0 // indirect
+	github.com/rclone/Proton-API-Bridge v1.0.1-0.20260127174007-77f974840d11 // indirect
+	github.com/rclone/go-proton-api v1.0.1-0.20260127173028-eb465cac3b18 // indirect
 	github.com/rogpeppe/go-internal v1.14.1 // indirect
 	github.com/ryanuber/go-glob v1.0.0 // indirect
 	github.com/sasha-s/go-deadlock v0.3.1 // indirect
@@ -269,6 +272,7 @@ require (
 	github.com/substrait-io/substrait-protobuf/go v0.71.0 // indirect
 	github.com/twpayne/go-geom v1.4.1 // indirect
 	github.com/twpayne/go-kml v1.5.2 // indirect
+	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
 	github.com/ulikunitz/xz v0.5.15 // indirect
 	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
@@ -279,6 +283,7 @@ require (
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.37.0 // indirect
 	go.opentelemetry.io/otel/exporters/zipkin v1.36.0 // indirect
 	go.opentelemetry.io/proto/otlp v1.7.0 // indirect
+	go.uber.org/mock v0.5.2 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/mod v0.32.0 // indirect
@@ -293,7 +298,7 @@ require (
 	cloud.google.com/go/compute/metadata v0.9.0 // indirect
 	cloud.google.com/go/iam v1.5.3 // indirect
 	cloud.google.com/go/monitoring v1.24.2 // indirect
-	filippo.io/edwards25519 v1.1.0 // indirect
+	filippo.io/edwards25519 v1.1.1 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.21.0
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.1
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect
@@ -341,15 +346,12 @@ require (
 	github.com/bradenaw/juniper v0.15.3 // indirect
 	github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 // indirect
 	github.com/buengese/sgzip v0.1.1 // indirect
-	github.com/bytedance/sonic v1.14.0 // indirect
-	github.com/bytedance/sonic/loader v0.3.0 // indirect
 	github.com/calebcase/tmpfile v1.0.3 // indirect
 	github.com/chilts/sid v0.0.0-20190607042430-660e94789ec9 // indirect
 	github.com/cloudflare/circl v1.6.1 // indirect
 	github.com/cloudinary/cloudinary-go/v2 v2.13.0 // indirect
 	github.com/cloudsoda/go-smb2 v0.0.0-20250228001242-d4c70e6251cc // indirect
 	github.com/cloudsoda/sddl v0.0.0-20250224235906-926454e91efc // indirect
-	github.com/cloudwego/base64x v0.1.6 // indirect
 	github.com/cncf/xds/go v0.0.0-20251022180443-0feb69152e9f // indirect
 	github.com/colinmarc/hdfs/v2 v2.4.0 // indirect
 	github.com/creasty/defaults v1.8.0 // indirect
@@ -369,8 +371,7 @@ require (
 	github.com/flynn/noise v1.1.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.11 // indirect
 	github.com/geoffgarside/ber v1.2.0 // indirect
-	github.com/gin-contrib/sse v1.1.0 // indirect
-	github.com/go-chi/chi/v5 v5.2.3 // indirect
+	github.com/go-chi/chi/v5 v5.2.5 // indirect
 	github.com/go-darwin/apfs v0.0.0-20211011131704-f84b94dbf348 // indirect
 	github.com/go-jose/go-jose/v4 v4.1.3 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
@@ -389,10 +390,9 @@ require (
 	github.com/golang-jwt/jwt/v4 v4.5.2 // indirect
 	github.com/google/s2a-go v0.1.9 // indirect
 	github.com/googleapis/enterprise-certificate-proxy v0.3.7 // indirect
-	github.com/gorilla/context v1.1.2 // indirect
 	github.com/gorilla/schema v1.4.1 // indirect
 	github.com/gorilla/securecookie v1.1.2 // indirect
-	github.com/gorilla/sessions v1.4.0 // indirect
+	github.com/gorilla/sessions v1.4.0
 	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 // indirect
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
@@ -402,8 +402,6 @@ require (
 	github.com/hashicorp/go-msgpack/v2 v2.1.2 // indirect
 	github.com/hashicorp/go-retryablehttp v0.7.8 // indirect
 	github.com/hashicorp/golang-lru v0.6.0 // indirect
-	github.com/henrybear327/Proton-API-Bridge v1.0.0 // indirect
-	github.com/henrybear327/go-proton-api v1.0.0 // indirect
 	github.com/jcmturner/aescts/v2 v2.0.0 // indirect
 	github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect
 	github.com/jcmturner/goidentity/v6 v6.0.1 // indirect
@@ -445,7 +443,7 @@ require (
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
 	github.com/pengsrc/go-shared v0.2.1-0.20190131101655-1999055a4a14 // indirect
 	github.com/philhofer/fwd v1.2.0 // indirect
-	github.com/pierrec/lz4/v4 v4.1.22
+	github.com/pierrec/lz4/v4 v4.1.25
 	github.com/pingcap/errors v0.11.5-0.20211224045212-9687c2b0f87c // indirect
 	github.com/pingcap/failpoint v0.0.0-20220801062533-2eaa32854a6c // indirect
 	github.com/pingcap/kvproto v0.0.0-20230403051650-e166ae588106 // indirect
@@ -476,9 +474,7 @@ require (
 	github.com/tinylib/msgp v1.5.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.16 // indirect
 	github.com/tklauser/numcpus v0.11.0 // indirect
-	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/twmb/murmur3 v1.1.8 // indirect
-	github.com/ugorji/go/codec v1.3.0 // indirect
 	github.com/unknwon/goconfig v1.0.0 // indirect
 	github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
@@ -504,7 +500,6 @@ require (
 	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.27.1 // indirect
-	golang.org/x/arch v0.20.0 // indirect
 	golang.org/x/term v0.40.0 // indirect
 	golang.org/x/time v0.14.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20251124214823-79d6a2a48846 // indirect

go.sum

@@ -547,8 +547,8 @@ cloud.google.com/go/workflows v1.10.0/go.mod h1:fZ8LmRmZQWacon9UCX1r/g/DfAXx5VcP
 dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
-filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+filippo.io/edwards25519 v1.1.1 h1:YpjwWWlNmGIDyXOn8zLzqiD+9TyIlPhGFG96P39uBpw=
+filippo.io/edwards25519 v1.1.1/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
 gioui.org v0.0.0-20210308172011-57750fc8a0a6/go.mod h1:RSH6KIUZ0p2xy5zHDxgAM4zumjgTw83q2ge/PI+yyw8=
 git.sr.ht/~sbinet/gg v0.3.1/go.mod h1:KGYtlADtqsqANL9ueOFkWymvzUvLMQllU5Ixo+8v3pc=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk=
@@ -596,6 +596,8 @@ github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3
 github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
 github.com/DefangLabs/secret-detector v0.0.0-20250403165618-22662109213e h1:rd4bOvKmDIx0WeTv9Qz+hghsgyjikFiPrseXHlKepO0=
 github.com/DefangLabs/secret-detector v0.0.0-20250403165618-22662109213e/go.mod h1:blbwPQh4DTlCZEfk1BLU4oMIhLda2U+A840Uag9DsZw=
+github.com/FilenCloudDienste/filen-sdk-go v0.0.37 h1:W8S9TrAyZ4//3PXsU6+Bi+fe/6uIL986GyS7PVzIDL4=
+github.com/FilenCloudDienste/filen-sdk-go v0.0.37/go.mod h1:0cBhKXQg49XbKZZfk5TCDa3sVLP+xMxZTWL+7KY0XR0=
 github.com/Files-com/files-sdk-go/v3 v3.2.264 h1:lMHTplAYI9FtmCo/QOcpRxmPA5REVAct1r2riQmDQKw=
 github.com/Files-com/files-sdk-go/v3 v3.2.264/go.mod h1:wGqkOzRu/ClJibvDgcfuJNAqI2nLhe8g91tPlDKRCdE=
 github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0 h1:sBEjpZlNHzK1voKq9695PJSX2o5NEXl7/OL3coiIY0c=
@@ -962,6 +964,8 @@ github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDD
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
+github.com/dromara/dongle v1.0.1 h1:si/7UP/EXxnFVZok1cNos70GiMGxInAYMilHQFP5dJs=
+github.com/dromara/dongle v1.0.1/go.mod h1:ebFhTaDgxaDIKppycENTWlBsxz8mWCPWOLnsEgDpMv4=
 github.com/dropbox/dropbox-sdk-go-unofficial/v6 v6.0.5 h1:FT+t0UEDykcor4y3dMVKXIiWJETBpRgERYTGlmMd7HU=
 github.com/dropbox/dropbox-sdk-go-unofficial/v6 v6.0.5/go.mod h1:rSS3kM9XMzSQ6pw91Qgd6yB5jdt70N4OdtrAf74As5M=
 github.com/dsnet/try v0.0.3 h1:ptR59SsrcFUYbT/FhAbKTV6iLkeD6O18qfIWRml2fqI=
@@ -989,6 +993,7 @@ github.com/emersion/go-vcard v0.0.0-20241024213814-c9703dde27ff h1:4N8wnS3f1hNHS
 github.com/emersion/go-vcard v0.0.0-20241024213814-c9703dde27ff/go.mod h1:HMJKR5wlh/ziNp+sHEDV2ltblO4JD2+IdDOWtGcQBTM=
 github.com/emicklei/go-restful/v3 v3.11.0 h1:rAQeMHw1c7zTmncogyy8VvRZwtkmkZ4FxERmMY4rD+g=
 github.com/emicklei/go-restful/v3 v3.11.0/go.mod h1:6n3XBCmQQb25CM2LCACGz8ukIrRry+4bhvbpWn3mrbc=
+github.com/emmansun/gmsm v0.15.5/go.mod h1:2m4jygryohSWkaSduFErgCwQKab5BNjURoFrn2DNwyU=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -1056,16 +1061,14 @@ github.com/geoffgarside/ber v1.2.0/go.mod h1:jVPKeCbj6MvQZhwLYsGwaGI52oUorHoHKNe
 github.com/getsentry/sentry-go v0.42.0 h1:eeFMACuZTbUQf90RE8dE4tXeSe4CZyfvR1MBL7RLEt8=
 github.com/getsentry/sentry-go v0.42.0/go.mod h1:eRXCoh3uvmjQLY6qu63BjUZnaBu5L5WhMV1RwYO8W5s=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/gin-contrib/sessions v1.0.4 h1:ha6CNdpYiTOK/hTp05miJLbpTSNfOnFg5Jm2kbcqy8U=
-github.com/gin-contrib/sessions v1.0.4/go.mod h1:ccmkrb2z6iU2osiAHZG3x3J4suJK+OU27oqzlWOqQgs=
 github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
 github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
 github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
 github.com/gin-gonic/gin v1.11.0/go.mod h1:+iq/FyxlGzII0KHiBGjuNn4UNENUlKbGlNmc+W50Dls=
 github.com/go-asn1-ber/asn1-ber v1.5.8-0.20250403174932-29230038a667 h1:BP4M0CvQ4S3TGls2FvczZtj5Re/2ZzkV9VwqPHH/3Bo=
 github.com/go-asn1-ber/asn1-ber v1.5.8-0.20250403174932-29230038a667/go.mod h1:hEBeB/ic+5LoWskz+yKT7vGhhPYkProFKoKdwZRWMe0=
-github.com/go-chi/chi/v5 v5.2.3 h1:WQIt9uxdsAbgIYgid+BpYc+liqQZGMHRaUwp0JUcvdE=
-github.com/go-chi/chi/v5 v5.2.3/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
+github.com/go-chi/chi/v5 v5.2.5 h1:Eg4myHZBjyvJmAFjFvWgrqDTXFyOzjj7YIm3L3mu6Ug=
+github.com/go-chi/chi/v5 v5.2.5/go.mod h1:X7Gx4mteadT3eDOMTsXzmI4/rwUpOwBHLpAfupzFJP0=
 github.com/go-darwin/apfs v0.0.0-20211011131704-f84b94dbf348 h1:JnrjqG5iR07/8k7NqrLNilRsl3s1EPRQEGvbPyOce68=
 github.com/go-darwin/apfs v0.0.0-20211011131704-f84b94dbf348/go.mod h1:Czxo/d1g948LtrALAZdL04TL/HnkopquAjxYUuI02bo=
 github.com/go-errors/errors v1.5.1 h1:ZwEMSLRCapFLflTpT7NKaAc7ukJ8ZPEjzlxt8rPN8bk=
@@ -1309,8 +1312,6 @@ github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
 github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
 github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
 github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k=
-github.com/gorilla/context v1.1.2 h1:WRkNAv2uoa03QNIc1A6u4O7DAGMUVoopZhkiXWA2V1o=
-github.com/gorilla/context v1.1.2/go.mod h1:KDPwT9i/MeWHiLl90fuTgrt4/wPcv75vFAZLaOOcbxM=
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/gorilla/schema v1.4.1 h1:jUg5hUjCSDZpNGLuXQOgIWGdlgrIdYvgQ0wZtdK1M3E=
@@ -1390,10 +1391,6 @@ github.com/hashicorp/raft-boltdb/v2 v2.3.1 h1:ackhdCNPKblmOhjEU9+4lHSJYFkJd6Jqyv
 github.com/hashicorp/raft-boltdb/v2 v2.3.1/go.mod h1:n4S+g43dXF1tqDT+yzcXHhXM6y7MrlUd3TTwGRcUvQE=
 github.com/hashicorp/vault/api v1.22.0 h1:+HYFquE35/B74fHoIeXlZIP2YADVboaPjaSicHEZiH0=
 github.com/hashicorp/vault/api v1.22.0/go.mod h1:IUZA2cDvr4Ok3+NtK2Oq/r+lJeXkeCrHRmqdyWfpmGM=
-github.com/henrybear327/Proton-API-Bridge v1.0.0 h1:gjKAaWfKu++77WsZTHg6FUyPC5W0LTKWQciUm8PMZb0=
-github.com/henrybear327/Proton-API-Bridge v1.0.0/go.mod h1:gunH16hf6U74W2b9CGDaWRadiLICsoJ6KRkSt53zLts=
-github.com/henrybear327/go-proton-api v1.0.0 h1:zYi/IbjLwFAW7ltCeqXneUGJey0TN//Xo851a/BgLXw=
-github.com/henrybear327/go-proton-api v1.0.0/go.mod h1:w63MZuzufKcIZ93pwRgiOtxMXYafI8H74D77AxytOBc=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
@@ -1410,6 +1407,8 @@ github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/inhies/go-bytesize v0.0.0-20220417184213-4913239db9cf h1:FtEj8sfIcaaBfAKrE1Cwb61YDtYq9JxChK1c7AKce7s=
 github.com/inhies/go-bytesize v0.0.0-20220417184213-4913239db9cf/go.mod h1:yrqSXGoD/4EKfF26AOGzscPOgTTJcyAwM2rpixWT+t4=
+github.com/internxt/rclone-adapter v0.0.0-20260213125353-6f59c89fcb7c h1:r+KtxPyrhsYeNbsfeqTfEM8xRdwgV6LuNhLZxpXecb4=
+github.com/internxt/rclone-adapter v0.0.0-20260213125353-6f59c89fcb7c/go.mod h1:vdPya4AIcDjvng4ViaAzqjegJf0VHYpYHQguFx5xBp0=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
@@ -1714,8 +1713,8 @@ github.com/phpdave11/gofpdf v1.4.2/go.mod h1:zpO6xFn9yxo3YLyMvW8HcKWVdbNqgIfOOp2
 github.com/phpdave11/gofpdi v1.0.12/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
 github.com/phpdave11/gofpdi v1.0.13/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
 github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU=
-github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pierrec/lz4/v4 v4.1.25 h1:kocOqRffaIbU5djlIBr7Wh+cx82C0vtFb0fOurZHqD0=
+github.com/pierrec/lz4/v4 v4.1.25/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
 github.com/pierrre/compare v1.0.2 h1:k4IUsHgh+dbcAOIWCfxVa/7G6STjADH2qmhomv+1quc=
 github.com/pierrre/compare v1.0.2/go.mod h1:8UvyRHH+9HS8Pczdd2z5x/wvv67krDwVxoOndaIIDVU=
 github.com/pierrre/geohash v1.0.0 h1:f/zfjdV4rVofTCz1FhP07T+EMQAvcMM2ioGZVt+zqjI=
@@ -1808,8 +1807,12 @@ github.com/r3labs/sse v0.0.0-20210224172625-26fe804710bc h1:zAsgcP8MhzAbhMnB1QQ2
 github.com/r3labs/sse v0.0.0-20210224172625-26fe804710bc/go.mod h1:S8xSOnV3CgpNrWd0GQ/OoQfMtlg2uPRSuTzcSGrzwK8=
 github.com/rabbitmq/amqp091-go v1.10.0 h1:STpn5XsHlHGcecLmMFCtg7mqq0RnD+zFr4uzukfVhBw=
 github.com/rabbitmq/amqp091-go v1.10.0/go.mod h1:Hy4jKW5kQART1u+JkDTF9YYOQUHXqMuhrgxOEeS7G4o=
-github.com/rclone/rclone v1.72.1 h1:Cc/NshKd3/TP3CC0cx9Jg9nTLG8YQ8yLYMTm6Z/LdHk=
-github.com/rclone/rclone v1.72.1/go.mod h1:QjmSgz98CjQZZJhROIeYHYjpN5kN7rTA+jtChj/+3Do=
+github.com/rclone/Proton-API-Bridge v1.0.1-0.20260127174007-77f974840d11 h1:4MI2alxM/Ye2gIRBlYf28JGWTipZ4Zz7yAziPKrttjs=
+github.com/rclone/Proton-API-Bridge v1.0.1-0.20260127174007-77f974840d11/go.mod h1:3HLX7dwZgvB7nt+Yl/xdzVPcargQ1yBmJEUg3n+jMKM=
+github.com/rclone/go-proton-api v1.0.1-0.20260127173028-eb465cac3b18 h1:Lc+d3ISfQaMJKWZOE7z4ZSY4RVmdzbn1B0IM8xN18qM=
+github.com/rclone/go-proton-api v1.0.1-0.20260127173028-eb465cac3b18/go.mod h1:LB2kCEaZMzNn3ocdz+qYfxXmuLxxN0ka62KJd2x53Bc=
+github.com/rclone/rclone v1.73.1 h1:FCGZUd7sXO8+nIpbuXGPkd+f23o/ZACefrHtRGDAiDM=
+github.com/rclone/rclone v1.73.1/go.mod h1:T9HeSXv/SI9qJFkYLqsjY/5ljIFWJTVmTrG7H/4JrPY=
 github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM=
 github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/rdleal/intervalst v1.5.0 h1:SEB9bCFz5IqD1yhfH1Wv8IBnY/JQxDplwkxHjT6hamU=
@@ -2011,6 +2014,8 @@ github.com/twpayne/go-kml v1.5.2 h1:rFMw2/EwgkVssGS2MT6YfWSPZz6BgcJkLxQ53jnE8rQ=
 github.com/twpayne/go-kml v1.5.2/go.mod h1:kz8jAiIz6FIdU2Zjce9qGlVtgFYES9vt7BTPBHf5jl4=
 github.com/twpayne/go-polyline v1.0.0/go.mod h1:ICh24bcLYBX8CknfvNPKqoTbe+eg+MX1NPyJmSBo7pU=
 github.com/twpayne/go-waypoint v0.0.0-20200706203930-b263a7f6e4e8/go.mod h1:qj5pHncxKhu9gxtZEYWypA/z097sxhFlbTyOyt9gcnU=
+github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
+github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
 github.com/tylertreat/BoomFilters v0.0.0-20210315201527-1a82519a3e43 h1:QEePdg0ty2r0t1+qwfZmQ4OOl/MB2UXIeJSpIZv56lg=
 github.com/tylertreat/BoomFilters v0.0.0-20210315201527-1a82519a3e43/go.mod h1:OYRfF6eb5wY9VRFkXJH8FFBi3plw2v+giaIu7P054pM=
 github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
@@ -2221,6 +2226,7 @@ golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80=
 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
 golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
 golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
@@ -2260,8 +2266,8 @@ golang.org/x/image v0.0.0-20210607152325-775e3b0c77b9/go.mod h1:023OzeP/+EPmXeap
 golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
 golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
 golang.org/x/image v0.0.0-20220302094943-723b81ca9867/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
-golang.org/x/image v0.35.0 h1:LKjiHdgMtO8z7Fh18nGY6KDcoEtVfsgLDPeLyguqb7I=
-golang.org/x/image v0.35.0/go.mod h1:MwPLTVgvxSASsxdLzKrl8BRFuyqMyGhLwmC+TO1Sybk=
+golang.org/x/image v0.36.0 h1:Iknbfm1afbgtwPTmHnS2gTM/6PPZfH+z2EFuOkSbqwc=
+golang.org/x/image v0.36.0/go.mod h1:YsWD2TyyGKiIX1kZlu9QfKIsQ4nAAK9bdgdrIsE7xy4=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -3047,8 +3053,8 @@ modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
 modernc.org/sqlite v1.18.1/go.mod h1:6ho+Gow7oX5V+OiOQ6Tr4xeqbx13UZ6t+Fw9IRUG4d4=
-modernc.org/sqlite v1.44.3 h1:+39JvV/HWMcYslAwRxHb8067w+2zowvFOUrOWIy9PjY=
-modernc.org/sqlite v1.44.3/go.mod h1:CzbrU2lSB1DKUusvwGz7rqEKIq+NUd8GWuBBZDs9/nA=
+modernc.org/sqlite v1.46.1 h1:eFJ2ShBLIEnUWlLy12raN0Z1plqmFX9Qe3rjQTKt6sU=
+modernc.org/sqlite v1.46.1/go.mod h1:CzbrU2lSB1DKUusvwGz7rqEKIq+NUd8GWuBBZDs9/nA=
 modernc.org/strutil v1.1.0/go.mod h1:lstksw84oURvj9y3tn8lGvRxyRC1S2+g5uuIzNfIOBs=
 modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw=
 modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw=

k8s/charts/seaweedfs/README.md

@@ -212,8 +212,9 @@ To enable workers, add the following to your values.yaml:
 worker:
   enabled: true
   replicas: 2  # Scale based on workload
-  capabilities: "vacuum,balance,erasure_coding"  # Tasks this worker can handle
-  maxConcurrent: 3  # Maximum concurrent tasks per worker
+  jobType: "vacuum,volume_balance,erasure_coding"  # Job types this worker can handle
+  maxDetect: 1  # Maximum concurrent detection requests
+  maxExecute: 4  # Maximum concurrent execution jobs per worker
   
   # Working directory for task execution
   # Default: "/tmp/seaweedfs-worker"
@@ -248,14 +249,14 @@ worker:
       memory: "2Gi"
 ```
 
-### Worker Capabilities
+### Worker Job Types
 
-Workers can be configured with different capabilities:
+Workers can be configured with different job types:
 - **vacuum**: Reclaim deleted file space
-- **balance**: Balance volumes across volume servers
+- **volume_balance**: Balance volumes across volume servers
 - **erasure_coding**: Handle erasure coding operations
 
-You can configure workers with all capabilities or create specialized worker pools with specific capabilities.
+You can configure workers with all job types or create specialized worker pools with specific job types.
 
 ### Worker Deployment Strategy
 
@@ -264,11 +265,11 @@ For production deployments, consider:
 1. **Multiple Workers**: Deploy 2+ worker replicas for high availability
 2. **Resource Allocation**: Workers need sufficient CPU/memory for maintenance tasks
 3. **Storage**: Workers need temporary storage for vacuum and balance operations (size depends on volume size)
-4. **Specialized Workers**: Create separate worker deployments for different capabilities if needed
+4. **Specialized Workers**: Create separate worker deployments for different job types if needed
 
 Example specialized worker configuration:
 
-For specialized worker pools, deploy separate Helm releases with different capabilities:
+For specialized worker pools, deploy separate Helm releases with different job types:
 
 **values-worker-vacuum.yaml** (for vacuum operations):
 ```yaml
@@ -287,8 +288,8 @@ admin:
 worker:
   enabled: true
   replicas: 2
-  capabilities: "vacuum"
-  maxConcurrent: 2
+  jobType: "vacuum"
+  maxExecute: 2
   # REQUIRED: Point to the admin service of your main SeaweedFS release
   # Replace <namespace> with the namespace where your main seaweedfs is deployed
   # Example: If deploying in namespace "production":
@@ -313,8 +314,8 @@ admin:
 worker:
   enabled: true
   replicas: 1
-  capabilities: "balance"
-  maxConcurrent: 1
+  jobType: "volume_balance"
+  maxExecute: 1
   # REQUIRED: Point to the admin service of your main SeaweedFS release
   # Replace <namespace> with the namespace where your main seaweedfs is deployed
   # Example: If deploying in namespace "production":
@@ -323,6 +324,7 @@ worker:
 ```
 
 Deploy the specialized workers as separate releases:
+### Specialized Worker Deployment
 ```bash
 # Deploy vacuum workers
 helm install seaweedfs-worker-vacuum seaweedfs/seaweedfs -f values-worker-vacuum.yaml
@@ -331,6 +333,22 @@ helm install seaweedfs-worker-vacuum seaweedfs/seaweedfs -f values-worker-vacuum
 helm install seaweedfs-worker-balance seaweedfs/seaweedfs -f values-worker-balance.yaml
 ```
 
+## OpenShift Support
+
+SeaweedFS can be deployed on OpenShift or any cluster enforcing the Kubernetes "restricted" Pod Security Standard. By default, OpenShift blocks containers that run as root or use `hostPath` volumes.
+
+To deploy on OpenShift, use the provided `openshift-values.yaml` which overrides the default configuration to:
+1. Use `PersistentVolumeClaims` instead of `hostPath`.
+2. Enable `runAsNonRoot` and omit hardcoded UIDs to allow OpenShift to assign valid UIDs automatically.
+3. Apply appropriate `seccompProfile` and drop capabilities.
+
+Usage:
+```bash
+helm install seaweedfs seaweedfs/seaweedfs \
+  -n seaweedfs --create-namespace \
+  -f openshift-values.yaml
+```
+
 ## Enterprise
 
 For enterprise users, please visit [seaweedfs.com](https://seaweedfs.com) for the SeaweedFS Enterprise Edition, 

k8s/charts/seaweedfs/openshift-values.yaml

@@ -0,0 +1,116 @@
+# openshift-values.yaml
+#
+# Example overrides for deploying SeaweedFS on OpenShift (or any cluster
+# enforcing the Kubernetes "restricted" Pod Security Standard).
+#
+# OpenShift's default "restricted" SCC blocks containers that:
+#   - Run as UID 0 (root)
+#   - Request privilege escalation
+#   - Use hostPath volumes
+#   - Omit a seccompProfile
+#
+# These overrides satisfy all four requirements by:
+#   1. Replacing hostPath volumes with PersistentVolumeClaims (or emptyDir for logs)
+#   2. Enabling runAsNonRoot: true. By omitting runAsUser, OpenShift will
+#      automatically assign a valid UID from the namespace's allocated range.
+#   3. Dropping all Linux capabilities and setting allowPrivilegeEscalation: false
+#   4. Enabling RuntimeDefault seccompProfile
+#
+# Usage:
+#   helm install seaweedfs seaweedfs/seaweedfs \
+#     -n seaweedfs --create-namespace \
+#     -f openshift-values.yaml
+#
+# Adjust storageClass and sizes to match your cluster's available StorageClasses.
+# On OpenShift you can discover them with: oc get storageclass
+
+master:
+  data:
+    type: "persistentVolumeClaim"
+    size: "10Gi"
+    storageClass: ""        # leave empty to use the cluster default StorageClass
+
+  logs:
+    type: "emptyDir"        # avoids hostPath; use persistentVolumeClaim if you need log persistence
+
+  podSecurityContext:
+    enabled: true
+    # On OpenShift, we omit runAsUser/runAsGroup/fsGroup to let the admission
+    # controller assign them automatically based on the namespace's SCC.
+    runAsNonRoot: true
+
+  containerSecurityContext:
+    enabled: true
+    allowPrivilegeEscalation: false
+    capabilities:
+      drop: ["ALL"]
+    runAsNonRoot: true
+    seccompProfile:
+      type: RuntimeDefault
+
+volume:
+  dataDirs:
+    - name: data1
+      type: "persistentVolumeClaim"
+      size: "100Gi"
+      storageClass: ""      # leave empty to use the cluster default StorageClass
+      maxVolumes: 0
+
+  logs:
+    type: "emptyDir"
+
+  podSecurityContext:
+    enabled: true
+    # On OpenShift, we omit runAsUser/runAsGroup/fsGroup to let the admission
+    # controller assign them automatically based on the namespace's SCC.
+    runAsNonRoot: true
+
+  containerSecurityContext:
+    enabled: true
+    allowPrivilegeEscalation: false
+    capabilities:
+      drop: ["ALL"]
+    runAsNonRoot: true
+    seccompProfile:
+      type: RuntimeDefault
+
+filer:
+  data:
+    type: "persistentVolumeClaim"
+    size: "25Gi"
+    storageClass: ""        # leave empty to use the cluster default StorageClass
+
+  logs:
+    type: "emptyDir"
+
+  podSecurityContext:
+    enabled: true
+    # On OpenShift, we omit runAsUser/runAsGroup/fsGroup to let the admission
+    # controller assign them automatically based on the namespace's SCC.
+    runAsNonRoot: true
+
+  containerSecurityContext:
+    enabled: true
+    allowPrivilegeEscalation: false
+    capabilities:
+      drop: ["ALL"]
+    runAsNonRoot: true
+    seccompProfile:
+      type: RuntimeDefault
+
+# S3 gateway (if enabled)
+s3:
+  podSecurityContext:
+    enabled: true
+    # On OpenShift, we omit runAsUser/runAsGroup/fsGroup to let the admission
+    # controller assign them automatically based on the namespace's SCC.
+    runAsNonRoot: true
+
+  containerSecurityContext:
+    enabled: true
+    allowPrivilegeEscalation: false
+    capabilities:
+      drop: ["ALL"]
+    runAsNonRoot: true
+    seccompProfile:
+      type: RuntimeDefault

k8s/charts/seaweedfs/templates/s3/s3-secret.yaml

@@ -10,10 +10,21 @@
 {{- if and .Values.s3.reuseLegacySecret $existingSecret }}
 {{- $reuse = true }}
 {{- end }}
-{{- $access_key_admin := include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "admin_access_key_id" "length" 20 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
-{{- $secret_key_admin := include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "admin_secret_access_key" "length" 40 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
-{{- $access_key_read := include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "read_access_key_id" "length" 20 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
-{{- $secret_key_read := include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "read_secret_access_key" "length" 40 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
+{{- $creds := .Values.s3.credentials | default dict -}}
+{{- $adminCreds := $creds.admin | default dict -}}
+{{- $access_key_admin := $adminCreds.accessKey -}}
+{{- $secret_key_admin := $adminCreds.secretKey -}}
+{{- if not (and $access_key_admin $secret_key_admin) -}}
+  {{- $access_key_admin = include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "admin_access_key_id" "length" 20 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
+  {{- $secret_key_admin = include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "admin_secret_access_key" "length" 40 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
+{{- end -}}
+{{- $readCreds := $creds.read | default dict -}}
+{{- $access_key_read := $readCreds.accessKey -}}
+{{- $secret_key_read := $readCreds.secretKey -}}
+{{- if not (and $access_key_read $secret_key_read) -}}
+  {{- $access_key_read = include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "read_access_key_id" "length" 20 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
+  {{- $secret_key_read = include "getOrGeneratePassword" (dict "namespace" .Release.Namespace "secretName" $secretName "key" "read_secret_access_key" "length" 40 "existingSecret" (ternary $existingSecret nil $reuse)) -}}
+{{- end -}}
 apiVersion: v1
 kind: Secret
 type: Opaque
@@ -43,4 +54,4 @@ stringData:
   s3_auditLogConfig.json: |
     {{ toJson .Values.s3.auditLogConfig | nindent 4 }}
   {{- end }}
-{{- end }}
+{{- end }}

k8s/charts/seaweedfs/templates/sftp/sftp-service.yaml

@@ -6,6 +6,7 @@ metadata:
   namespace: {{ .Release.Namespace }}
   labels:
     app.kubernetes.io/name: {{ template "seaweedfs.name" . }}
+    app.kubernetes.io/instance: {{ .Release.Name }}
     app.kubernetes.io/component: sftp
     helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
     app.kubernetes.io/managed-by: {{ .Release.Service }}

k8s/charts/seaweedfs/templates/shared/_helpers.tpl

@@ -135,7 +135,9 @@ Inject extra environment vars in the format key:value, if populated
 {{- $repositoryName := default .Values.image.repository .Values.global.repository | toString -}}
 {{- $name := .Values.global.imageName | toString -}}
 {{- $tag := default .Chart.AppVersion .Values.image.tag  | toString -}}
-{{- if $repositoryName -}}
+{{- if .Values.image.repository -}}
+{{-   $name = $repositoryName -}}
+{{- else if $repositoryName -}}
 {{-   $name = printf "%s/%s" (trimSuffix "/" $repositoryName) (base $name) -}}
 {{- end -}}
 {{- if $registryName -}}

k8s/charts/seaweedfs/templates/shared/service-account.yaml

@@ -3,6 +3,10 @@ kind: ServiceAccount
 metadata:
   name: {{ include "seaweedfs.serviceAccountName" . }}
   namespace: {{ .Release.Namespace }}
+  {{- with .Values.global.serviceAccountAnnotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
   labels:
     app.kubernetes.io/name: {{ template "seaweedfs.name" . }}
     helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}

k8s/charts/seaweedfs/templates/volume/volume-service.yaml

@@ -12,6 +12,7 @@ metadata:
   namespace: {{ $.Release.Namespace }}
   labels:
     app.kubernetes.io/name: {{ template "seaweedfs.name" $ }}
+    app.kubernetes.io/instance: {{ $.Release.Name }}
     app.kubernetes.io/component: {{ $volumeName }}
     helm.sh/chart: {{ $.Chart.Name }}-{{ $.Chart.Version | replace "+" "_" }}
     app.kubernetes.io/managed-by: {{ $.Release.Service }}

k8s/charts/seaweedfs/templates/worker/worker-deployment.yaml

@@ -136,11 +136,15 @@ spec:
               {{- else }}
               -admin={{ template "seaweedfs.fullname" . }}-admin.{{ .Release.Namespace }}:{{ .Values.admin.port }}{{ if .Values.admin.grpcPort }}.{{ .Values.admin.grpcPort }}{{ end }} \
               {{- end }}
-              -capabilities={{ .Values.worker.capabilities }} \
-              -maxConcurrent={{ .Values.worker.maxConcurrent }} \
-              -workingDir={{ .Values.worker.workingDir }}{{- if or .Values.worker.metricsPort .Values.worker.extraArgs }} \{{ end }}
+              -jobType={{ .Values.worker.jobType }} \
+              -maxDetect={{ .Values.worker.maxDetect }} \
+              -maxExecute={{ .Values.worker.maxExecute }} \
+              -workingDir={{ .Values.worker.workingDir }}{{- if or .Values.worker.metricsPort .Values.worker.metricsIp .Values.worker.extraArgs }} \{{ end }}
               {{- if .Values.worker.metricsPort }}
-              -metricsPort={{ .Values.worker.metricsPort }}{{- if .Values.worker.extraArgs }} \{{ end }}
+              -metricsPort={{ .Values.worker.metricsPort }}{{- if or .Values.worker.metricsIp .Values.worker.extraArgs }} \{{ end }}
+              {{- end }}
+              {{- if .Values.worker.metricsIp }}
+              -metricsIp={{ .Values.worker.metricsIp }}{{- if .Values.worker.extraArgs }} \{{ end }}
               {{- end }}
               {{- range $index, $arg := .Values.worker.extraArgs }}
               {{ $arg }}{{- if lt $index (sub (len $.Values.worker.extraArgs) 1) }} \{{ end }}

k8s/charts/seaweedfs/values.yaml

@@ -20,6 +20,7 @@ global:
       filerRead: false
   # we will use this serviceAccountName for all ClusterRoles/ClusterRoleBindings
   serviceAccountName: "seaweedfs"
+  serviceAccountAnnotations: {}
   automountServiceAccountToken: true
   certificates:
     duration: 87600h
@@ -890,6 +891,10 @@ filer:
     # set to the name of an existing kubernetes Secret with the s3 json config file
     # should have a secret key called seaweedfs_s3_config with an inline json configure
     existingConfigSecret: null
+    # To provide explicit credentials for the S3 gateway, set them under
+    # the top-level s3.credentials key (not filer.s3.credentials).
+    # The s3-secret.yaml template only reads from .Values.s3.credentials.
+    # See: s3.credentials.admin.accessKey, s3.credentials.read.accessKey
     auditLogConfig: {}
     # You may specify buckets to be created during the install or upgrade process.
     # Buckets may be exposed publicly by setting `anonymousRead` to `true`
@@ -918,6 +923,16 @@ s3:
   # set to the name of an existing kubernetes Secret with the s3 json config file
   # should have a secret key called seaweedfs_s3_config with an inline json config
   existingConfigSecret: null
+  # Optionally provide explicit credentials for the S3 gateway.
+  # When set, these are used in the generated s3 secret instead of
+  # auto-generating random credentials.
+  # credentials:
+  #   admin:
+  #     accessKey: ""
+  #     secretKey: ""
+  #   read:
+  #     accessKey: ""
+  #     secretKey: ""
   auditLogConfig: {}
   # You may specify buckets to be created during the install or upgrade process.
   # Buckets may be exposed publicly by setting `anonymousRead` to `true`
@@ -1270,17 +1285,20 @@ worker:
   replicas: 1
   loggingOverrideLevel: null
   metricsPort: 9327
+  metricsIp: ""  # If empty, defaults to 0.0.0.0
 
   # Admin server to connect to
   adminServer: ""
 
-  # Worker capabilities - comma-separated list
-  # Available: vacuum, balance, erasure_coding
-  # Default: "vacuum,balance,erasure_coding" (all capabilities)
-  capabilities: "vacuum,balance,erasure_coding"
+  # Worker job types - comma-separated list
+  # Available: vacuum, volume_balance, erasure_coding
+  jobType: "vacuum,volume_balance,erasure_coding"
 
-  # Maximum number of concurrent tasks
-  maxConcurrent: 3
+  # Maximum number of concurrent detection requests
+  maxDetect: 1
+
+  # Maximum number of concurrent execution jobs
+  maxExecute: 4
 
   # Working directory for task execution
   workingDir: "/tmp/seaweedfs-worker"
@@ -1418,6 +1436,10 @@ allInOne:
     # Set to the name of an existing kubernetes Secret with the s3 json config file
     # should have a secret key called seaweedfs_s3_config with an inline json config
     existingConfigSecret: null
+    # To provide explicit credentials for the S3 gateway, set them under
+    # the top-level s3.credentials key (not allInOne.s3.credentials).
+    # The s3-secret.yaml template only reads from .Values.s3.credentials.
+    # See: s3.credentials.admin.accessKey, s3.credentials.read.accessKey
     auditLogConfig: null  # S3 audit log configuration (null inherits from s3.auditLogConfig)
     # You may specify buckets to be created during the install process.
     # Buckets may be exposed publicly by setting `anonymousRead` to `true`

test/erasure_coding/admin_dockertest/ec_integration_test.go

@@ -2,13 +2,11 @@ package admin_dockertest
 
 import (
 	"bytes"
+	crand "crypto/rand"
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
-	"math/rand"
 	"net/http"
-	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -161,129 +159,95 @@ func TestEcEndToEnd(t *testing.T) {
 
 	client := &http.Client{}
 
-	// 1. Configure Global Maintenance (Scan Interval = 1s) via API
-	t.Log("Configuring Global Maintenance via API...")
+	// 1. Configure plugin job types for fast EC detection/execution.
+	t.Log("Configuring plugin job types via API...")
 
-	// 1.1 Fetch current config
-	req, _ := http.NewRequest("GET", AdminUrl+"/api/maintenance/config", nil)
+	// Disable volume balance to reduce interference for this EC-focused test.
+	balanceConfig := map[string]interface{}{
+		"job_type": "volume_balance",
+		"admin_runtime": map[string]interface{}{
+			"enabled": false,
+		},
+	}
+	jsonBody, err := json.Marshal(balanceConfig)
+	if err != nil {
+		t.Fatalf("Failed to marshal volume_balance config: %v", err)
+	}
+	req, err := http.NewRequest("PUT", AdminUrl+"/api/plugin/job-types/volume_balance/config", bytes.NewBuffer(jsonBody))
+	if err != nil {
+		t.Fatalf("Failed to create volume_balance config request: %v", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
 	resp, err := client.Do(req)
 	if err != nil {
-		t.Fatalf("Failed to get global config: %v", err)
+		t.Fatalf("Failed to update volume_balance config: %v", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		body, _ := io.ReadAll(resp.Body)
-		t.Fatalf("Failed to get global config (status %d): %s", resp.StatusCode, string(body))
-	}
-
-	var globalConfig map[string]interface{}
-	if err := json.NewDecoder(resp.Body).Decode(&globalConfig); err != nil {
-		t.Fatalf("Failed to decode global config: %v", err)
+		t.Fatalf("Failed to update volume_balance config (status %d): %s", resp.StatusCode, string(body))
 	}
 	resp.Body.Close()
 
-	// 1.2 Modify config
-	globalConfig["enabled"] = true
-	globalConfig["scan_interval_seconds"] = 1
-
-	// Ensure policy structure exists
-	if globalConfig["policy"] == nil {
-		globalConfig["policy"] = map[string]interface{}{}
+	ecConfig := map[string]interface{}{
+		"job_type": "erasure_coding",
+		"admin_runtime": map[string]interface{}{
+			"enabled":                          true,
+			"detection_interval_seconds":       1,
+			"global_execution_concurrency":     4,
+			"per_worker_execution_concurrency": 4,
+			"max_jobs_per_detection":           100,
+		},
+		"worker_config_values": map[string]interface{}{
+			"quiet_for_seconds": map[string]interface{}{
+				"int64_value": "1",
+			},
+			"min_interval_seconds": map[string]interface{}{
+				"int64_value": "1",
+			},
+			"min_size_mb": map[string]interface{}{
+				"int64_value": "1",
+			},
+			"fullness_ratio": map[string]interface{}{
+				"double_value": 0.0001,
+			},
+		},
 	}
-	policy, _ := globalConfig["policy"].(map[string]interface{})
-
-	// Ensure task_policies structure exists
-	if policy["task_policies"] == nil {
-		policy["task_policies"] = map[string]interface{}{}
+	jsonBody, err = json.Marshal(ecConfig)
+	if err != nil {
+		t.Fatalf("Failed to marshal erasure_coding config: %v", err)
 	}
-	taskPolicies, _ := policy["task_policies"].(map[string]interface{})
-
-	// Disable balance tasks to avoid interference with EC test
-	if taskPolicies["balance"] == nil {
-		taskPolicies["balance"] = map[string]interface{}{}
+	req, err = http.NewRequest("PUT", AdminUrl+"/api/plugin/job-types/erasure_coding/config", bytes.NewBuffer(jsonBody))
+	if err != nil {
+		t.Fatalf("Failed to create erasure_coding config request: %v", err)
 	}
-	balancePolicy, _ := taskPolicies["balance"].(map[string]interface{})
-	balancePolicy["enabled"] = false
-
-	// Set global max concurrent
-	policy["global_max_concurrent"] = 4
-	globalConfig["policy"] = policy
-
-	// Explicitly set required fields
-	requiredFields := map[string]float64{
-		"worker_timeout_seconds":   300,
-		"task_timeout_seconds":     7200,
-		"retry_delay_seconds":      900,
-		"cleanup_interval_seconds": 86400,
-		"task_retention_seconds":   604800,
-		"max_retries":              3,
-	}
-	for field, val := range requiredFields {
-		if _, ok := globalConfig[field]; !ok || globalConfig[field] == 0 {
-			globalConfig[field] = val
-		}
-	}
-
-	// 1.3 Update config
-	jsonBody, _ := json.Marshal(globalConfig)
-	req, _ = http.NewRequest("PUT", AdminUrl+"/api/maintenance/config", bytes.NewBuffer(jsonBody))
 	req.Header.Set("Content-Type", "application/json")
 	resp, err = client.Do(req)
 	if err != nil {
-		t.Fatalf("Failed to update global config: %v", err)
+		t.Fatalf("Failed to update erasure_coding config: %v", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		body, _ := io.ReadAll(resp.Body)
-		t.Fatalf("Failed to update global config (status %d): %s", resp.StatusCode, string(body))
+		t.Fatalf("Failed to update erasure_coding config (status %d): %s", resp.StatusCode, string(body))
 	}
 	resp.Body.Close()
 
-	// 2. Configure EC Task (Short intervals) via Form API
-	t.Log("Configuring EC Task via Form API...")
-	formData := url.Values{}
-	formData.Set("enabled", "true")
-	formData.Set("scan_interval_seconds", "1")
-	formData.Set("repeat_interval_seconds", "1")
-	formData.Set("check_interval_seconds", "1")
-	formData.Set("max_concurrent", "4")
-	formData.Set("quiet_for_seconds_value", "1")
-	formData.Set("quiet_for_seconds_unit", "seconds")
-	formData.Set("min_size_mb", "1")
-	formData.Set("fullness_ratio", "0.0001")
-
-	req, _ = http.NewRequest("POST", AdminUrl+"/maintenance/config/erasure_coding", strings.NewReader(formData.Encode()))
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	resp, err = client.Do(req)
-	if err != nil {
-		t.Fatalf("Failed to update EC config: %v", err)
-	}
-	if resp.StatusCode != 200 && resp.StatusCode != 303 {
-		body, _ := io.ReadAll(resp.Body)
-		t.Fatalf("Failed to update EC config (status %d): %s", resp.StatusCode, string(body))
-	}
-	resp.Body.Close()
-	t.Log("EC Task Configuration updated")
-
-	// 3. Restart Admin to pick up Global Config (Scan Interval)
-	if len(runningCmds) > 0 {
-		adminCmd := runningCmds[len(runningCmds)-1]
-		t.Log("Restarting Admin Server to apply configuration...")
-		stopWeed(t, adminCmd)
-		time.Sleep(10 * time.Second)
-		startWeed(t, "admin_restarted", "admin", "-master=localhost:9333", "-port=23646", "-port.grpc=33646", "-dataDir=./tmp/admin")
-		waitForUrl(t, AdminUrl+"/health", 60)
-	}
-
-	// 4. Upload a file
+	// 2. Upload a file
 	fileSize := 5 * 1024 * 1024
 	data := make([]byte, fileSize)
-	rand.Read(data)
+	crand.Read(data)
 	fileName := fmt.Sprintf("ec_test_file_%d", time.Now().Unix())
 	t.Logf("Uploading %d bytes file %s to Filer...", fileSize, fileName)
 	uploadUrl := FilerUrl + "/" + fileName
 
 	var uploadErr error
 	for i := 0; i < 10; i++ {
-		req, _ := http.NewRequest("PUT", uploadUrl, bytes.NewBuffer(data))
+		req, err := http.NewRequest("PUT", uploadUrl, bytes.NewBuffer(data))
+		if err != nil {
+			uploadErr = err
+			t.Logf("Upload attempt %d failed to create request: %v", i+1, err)
+			time.Sleep(2 * time.Second)
+			continue
+		}
 		resp, err := client.Do(req)
 		if err == nil {
 			if resp.StatusCode == 201 {
@@ -306,17 +270,17 @@ func TestEcEndToEnd(t *testing.T) {
 	}
 	t.Log("Upload successful")
 
-	// 5. Verify EC Encoding
+	// 3. Verify EC Encoding
 	t.Log("Waiting for EC encoding (checking Master topology)...")
 	startTime := time.Now()
 	ecVerified := false
 	var lastBody []byte
 
 	for time.Since(startTime) < 300*time.Second {
-		// 5.1 Check Master Topology
+		// 3.1 Check Master Topology
 		resp, err := http.Get(MasterUrl + "/dir/status")
 		if err == nil {
-			lastBody, _ = ioutil.ReadAll(resp.Body)
+			lastBody, _ = io.ReadAll(resp.Body)
 			resp.Body.Close()
 
 			// Check total EC shards
@@ -336,8 +300,8 @@ func TestEcEndToEnd(t *testing.T) {
 			}
 		}
 
-		// 5.2 Debug: Check workers and tasks
-		wResp, wErr := http.Get(AdminUrl + "/api/maintenance/workers")
+		// 3.2 Debug: Check workers and jobs
+		wResp, wErr := http.Get(AdminUrl + "/api/plugin/workers")
 		workerCount := 0
 		if wErr == nil {
 			var workers []interface{}
@@ -346,7 +310,7 @@ func TestEcEndToEnd(t *testing.T) {
 			workerCount = len(workers)
 		}
 
-		tResp, tErr := http.Get(AdminUrl + "/api/maintenance/tasks")
+		tResp, tErr := http.Get(AdminUrl + "/api/plugin/jobs?limit=1000")
 		taskCount := 0
 		if tErr == nil {
 			var tasks []interface{}

test/foundationdb/foundationdb_concurrent_test.go

@@ -1,5 +1,4 @@
 //go:build foundationdb
-// +build foundationdb
 
 package foundationdb
 

test/foundationdb/foundationdb_integration_test.go

@@ -1,5 +1,4 @@
 //go:build foundationdb
-// +build foundationdb
 
 package foundationdb
 

test/kafka/Dockerfile.kafka-gateway

@@ -16,8 +16,9 @@ RUN go mod download
 # Copy source code
 COPY . .
 
-# Build the weed binary with Kafka gateway support
+# Build the weed binaries with Kafka gateway support
 RUN CGO_ENABLED=1 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o weed ./weed
+RUN CGO_ENABLED=1 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -o weed-sql ./cmd/weed-sql
 
 # Final stage
 FROM alpine:latest
@@ -32,8 +33,9 @@ RUN addgroup -g 1000 seaweedfs && \
 # Set working directory
 WORKDIR /usr/bin
 
-# Copy binary from builder
+# Copy binaries from builder
 COPY --from=builder /app/weed .
+COPY --from=builder /app/weed-sql .
 
 # Create data directory
 RUN mkdir -p /data && chown seaweedfs:seaweedfs /data

test/kafka/test_json_timestamp.sh

@@ -14,8 +14,7 @@ sleep 2
 
 echo "Querying messages..."
 cd /Users/chrislu/go/src/github.com/seaweedfs/seaweedfs/test/kafka/kafka-client-loadtest
-docker compose exec kafka-gateway /usr/local/bin/weed sql \
+docker compose exec kafka-gateway /usr/bin/weed-sql \
   -master=seaweedfs-master:9333 \
   -database=kafka \
   -query="SELECT id, timestamp, producer_id, counter, user_id, event_type FROM \"test-json-topic\" LIMIT 5;"
-

test/postgres/Dockerfile.seaweedfs

@@ -13,8 +13,9 @@ RUN go mod download
 # Copy source code
 COPY . .
 
-# Build the weed binary without CGO
+# Build the weed binaries without CGO
 RUN CGO_ENABLED=0 GOOS=linux go build -ldflags "-s -w" -o weed ./weed/
+RUN CGO_ENABLED=0 GOOS=linux go build -ldflags "-s -w" -o weed-db ./cmd/weed-db
 
 # Final stage - minimal runtime image
 FROM alpine:latest
@@ -24,11 +25,12 @@ RUN apk --no-cache add ca-certificates netcat-openbsd curl
 
 WORKDIR /root/
 
-# Copy the weed binary from builder stage
+# Copy the binaries from builder stage
 COPY --from=builder /app/weed .
+COPY --from=builder /app/weed-db .
 
 # Make it executable
-RUN chmod +x ./weed
+RUN chmod +x ./weed ./weed-db
 
 # Expose ports
 EXPOSE 9333 8888 8333 8085 9533 5432

test/postgres/SETUP_OVERVIEW.md

@@ -280,7 +280,7 @@ This test setup proves:
 - Comprehensive error handling
 
 ### ✅ Performance and Scalability
-- Direct SQL engine integration (same as `weed sql`)
+- Direct SQL engine integration (same as `weed-sql`)
 - No translation overhead for real queries
 - Efficient data access from stored formats
 - Scalable architecture with service discovery

test/postgres/docker-compose.yml

@@ -54,7 +54,7 @@ services:
       seaweedfs:
         condition: service_healthy
     command: >
-      ./weed db
+      ./weed-db
       -host=0.0.0.0
       -port=5432
       -master=seaweedfs:9333

test/s3/iam/s3_iam_admin_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -202,6 +203,116 @@ func TestIAMPolicyManagement(t *testing.T) {
 		})
 	})
 
+	t.Run("managed_policy_crud_lifecycle", func(t *testing.T) {
+		policyDoc := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"s3:GetObject","Resource":"arn:aws:s3:::*"}]}`
+
+		policyNames := []string{"test-managed-policy-lifecycle-a", "test-managed-policy-lifecycle-b"}
+		policyArns := make([]*string, 0, len(policyNames))
+		for _, policyName := range policyNames {
+			createResp, err := iamClient.CreatePolicy(&iam.CreatePolicyInput{
+				PolicyName:     aws.String(policyName),
+				PolicyDocument: aws.String(policyDoc),
+			})
+			require.NoError(t, err)
+			policyArns = append(policyArns, createResp.Policy.Arn)
+		}
+
+		t.Cleanup(func() {
+			for _, policyArn := range policyArns {
+				_, _ = iamClient.DeletePolicy(&iam.DeletePolicyInput{PolicyArn: policyArn})
+			}
+		})
+
+		listResp, err := iamClient.ListPolicies(&iam.ListPoliciesInput{})
+		require.NoError(t, err)
+
+		foundByName := map[string]bool{}
+		for _, policy := range listResp.Policies {
+			if policy.PolicyName != nil {
+				foundByName[*policy.PolicyName] = true
+			}
+		}
+		for _, policyName := range policyNames {
+			assert.True(t, foundByName[policyName], "policy %s should be listed", policyName)
+		}
+
+		getResp, err := iamClient.GetPolicy(&iam.GetPolicyInput{PolicyArn: policyArns[0]})
+		require.NoError(t, err)
+		require.NotNil(t, getResp.Policy)
+		assert.Equal(t, policyNames[0], aws.StringValue(getResp.Policy.PolicyName))
+		assert.Equal(t, aws.StringValue(policyArns[0]), aws.StringValue(getResp.Policy.Arn))
+
+		_, err = iamClient.DeletePolicy(&iam.DeletePolicyInput{PolicyArn: policyArns[0]})
+		require.NoError(t, err)
+
+		_, err = iamClient.GetPolicy(&iam.GetPolicyInput{PolicyArn: policyArns[0]})
+		require.Error(t, err)
+		awsErr, ok := err.(awserr.Error)
+		require.True(t, ok)
+		assert.Equal(t, iam.ErrCodeNoSuchEntityException, awsErr.Code())
+
+		listAfterDeleteResp, err := iamClient.ListPolicies(&iam.ListPoliciesInput{})
+		require.NoError(t, err)
+		deletedPolicyFound := false
+		remainingPolicyFound := false
+		for _, policy := range listAfterDeleteResp.Policies {
+			if policy.PolicyName == nil {
+				continue
+			}
+			if *policy.PolicyName == policyNames[0] {
+				deletedPolicyFound = true
+			}
+			if *policy.PolicyName == policyNames[1] {
+				remainingPolicyFound = true
+			}
+		}
+		assert.False(t, deletedPolicyFound, "deleted policy should no longer be listed")
+		assert.True(t, remainingPolicyFound, "remaining policy should still be listed")
+
+		policyArns[0] = nil
+	})
+
+	t.Run("managed_policy_versions", func(t *testing.T) {
+		policyName := "test-managed-policy-version"
+		policyDoc := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"s3:ListBucket","Resource":"*"}]}`
+
+		createResp, err := iamClient.CreatePolicy(&iam.CreatePolicyInput{
+			PolicyName:     aws.String(policyName),
+			PolicyDocument: aws.String(policyDoc),
+		})
+		require.NoError(t, err)
+
+		t.Cleanup(func() {
+			_, _ = iamClient.DeletePolicy(&iam.DeletePolicyInput{PolicyArn: createResp.Policy.Arn})
+		})
+
+		listVersionsResp, err := iamClient.ListPolicyVersions(&iam.ListPolicyVersionsInput{
+			PolicyArn: createResp.Policy.Arn,
+		})
+		require.NoError(t, err)
+		require.NotEmpty(t, listVersionsResp.Versions)
+		assert.Equal(t, "v1", aws.StringValue(listVersionsResp.Versions[0].VersionId))
+		assert.Equal(t, true, aws.BoolValue(listVersionsResp.Versions[0].IsDefaultVersion))
+
+		getVersionResp, err := iamClient.GetPolicyVersion(&iam.GetPolicyVersionInput{
+			PolicyArn:  createResp.Policy.Arn,
+			VersionId:  aws.String("v1"),
+		})
+		require.NoError(t, err)
+		require.NotNil(t, getVersionResp.PolicyVersion)
+		assert.Equal(t, "v1", aws.StringValue(getVersionResp.PolicyVersion.VersionId))
+		assert.Contains(t, aws.StringValue(getVersionResp.PolicyVersion.Document), "s3:ListBucket")
+
+		_, err = iamClient.GetPolicyVersion(&iam.GetPolicyVersionInput{
+			PolicyArn: createResp.Policy.Arn,
+			VersionId: aws.String("v2"),
+		})
+		require.Error(t, err)
+		awsErr, ok := err.(awserr.Error)
+		require.True(t, ok)
+		assert.Equal(t, iam.ErrCodeNoSuchEntityException, awsErr.Code())
+	})
+
 	t.Run("user_inline_policy", func(t *testing.T) {
 		userName := "test-user-policy"
 		_, err := iamClient.CreateUser(&iam.CreateUserInput{

test/s3/normal/s3_integration_test.go

@@ -3,6 +3,8 @@ package example
 import (
 	"bytes"
 	"context"
+	"crypto/md5"
+	"encoding/base64"
 	"fmt"
 	"math/rand"
 	"net"
@@ -15,6 +17,7 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
 	"github.com/aws/aws-sdk-go/aws/credentials"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/s3"
@@ -68,6 +71,22 @@ func TestS3Integration(t *testing.T) {
 		testPutObject(t, cluster)
 	})
 
+	t.Run("UploadPart", func(t *testing.T) {
+		testPutPartWithChecksum(t, cluster)
+	})
+
+	t.Run("PutObjectWithChecksum", func(t *testing.T) {
+		testPutObjectWithChecksum(t, cluster)
+	})
+
+	t.Run("UploadPartWithChecksum", func(t *testing.T) {
+		testUploadPartWithChecksum(t, cluster)
+	})
+
+	t.Run("PutObjectWithChecksumAndSSEC", func(t *testing.T) {
+		testPutObjectWithChecksumAndSSEC(t, cluster)
+	})
+
 	t.Run("GetObject", func(t *testing.T) {
 		testGetObject(t, cluster)
 	})
@@ -97,8 +116,9 @@ func findAvailablePort() (int, error) {
 	return addr.Port, nil
 }
 
-// startMiniCluster starts a weed mini instance directly without exec
-func startMiniCluster(t *testing.T) (*TestCluster, error) {
+// startMiniCluster starts a weed mini instance directly without exec.
+// Extra flags (e.g. "-s3.allowDeleteBucketNotEmpty=false") can be appended via extraArgs.
+func startMiniCluster(t *testing.T, extraArgs ...string) (*TestCluster, error) {
 	// Find available ports
 	masterPort, err := findAvailablePort()
 	if err != nil {
@@ -173,7 +193,7 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 		// Configure args for mini command
 		// Note: When running via 'go test', os.Args[0] is the test binary
 		// We need to make it look like we're running 'weed mini'
-		os.Args = []string{
+		os.Args = append([]string{
 			"weed",
 			"-dir=" + testDir,
 			"-master.port=" + strconv.Itoa(masterPort),
@@ -186,7 +206,7 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 			"-ip=127.0.0.1",
 			"-master.peers=none",     // Faster startup
 			"-s3.iam.readOnly=false", // Enable IAM write operations for tests
-		}
+		}, extraArgs...)
 
 		// Suppress most logging during tests
 		glog.MaxSize = 1024 * 1024
@@ -344,6 +364,282 @@ func testPutObject(t *testing.T, cluster *TestCluster) {
 	t.Logf("✓ Put object: %s/%s (%d bytes)", bucketName, objectKey, len(objectData))
 }
 
+func createTestBucket(t *testing.T, cluster *TestCluster, prefix string) string {
+	bucketName := prefix + randomString(8)
+	_, err := cluster.s3Client.CreateBucket(&s3.CreateBucketInput{
+		Bucket: aws.String(bucketName),
+	})
+	require.NoError(t, err)
+	time.Sleep(100 * time.Millisecond)
+	return bucketName
+}
+
+// generateSSECKey returns a 32-byte key as a raw string (what the SDK expects
+// for SSECustomerKey) and its base64-encoded MD5 (for SSECustomerKeyMD5).
+func generateSSECKey() (keyRaw, keyMD5B64 string) {
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+	key := make([]byte, 32)
+	for i := range key {
+		key[i] = byte(rng.Intn(256))
+	}
+	keyRaw = string(key)
+	keyHash := md5.Sum(key)
+	keyMD5B64 = base64.StdEncoding.EncodeToString(keyHash[:])
+	return
+}
+
+func testPutObjectWithChecksum(t *testing.T, cluster *TestCluster) {
+	bucketName := createTestBucket(t, cluster, "test-put-checksum-")
+	objectKey := "test-checksummed-object.txt"
+	objectData := "Hello, SeaweedFS S3!"
+
+	correctMD5 := calculateMd5(objectData)
+	incorrectMD5 := calculateMd5(objectData + "incorrect")
+
+	// Put object with incorrect MD5 should be rejected
+	_, err := cluster.s3Client.PutObject(&s3.PutObjectInput{
+		Bucket:     aws.String(bucketName),
+		Key:        aws.String(objectKey),
+		Body:       bytes.NewReader([]byte(objectData)),
+		ContentMD5: aws.String(incorrectMD5),
+	})
+	assertBadDigestError(t, err, "PutObject should fail with incorrect MD5")
+
+	t.Logf("✓ Put object with incorrect MD5 rejected: %s/%s", bucketName, objectKey)
+
+	// Put object with correct MD5 should succeed
+	_, err = cluster.s3Client.PutObject(&s3.PutObjectInput{
+		Bucket:     aws.String(bucketName),
+		Key:        aws.String(objectKey),
+		Body:       bytes.NewReader([]byte(objectData)),
+		ContentMD5: aws.String(correctMD5),
+	})
+	require.NoError(t, err, "Failed to put object")
+
+	// Verify object exists
+	headResp, err := cluster.s3Client.HeadObject(&s3.HeadObjectInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+	})
+	require.NoError(t, err)
+	assert.NotNil(t, headResp.ContentLength)
+	assert.Equal(t, int64(len(objectData)), aws.Int64Value(headResp.ContentLength))
+
+	t.Logf("✓ Put object with correct MD5: %s/%s (%d bytes)", bucketName, objectKey, len(objectData))
+}
+
+// putObjectSSEC sends a PutObject request with SSE-C headers over HTTP.
+// The AWS SDK v1 refuses to send SSE-C keys over plain HTTP, so we use the
+// low-level Request API and clear the Validate handlers to bypass that check.
+// We use Clear() because the specific validator is internal and not easily removable by name.
+func putObjectSSEC(client *s3.S3, input *s3.PutObjectInput) (*s3.PutObjectOutput, error) {
+	req, output := client.PutObjectRequest(input)
+	req.Handlers.Validate.Clear()
+	err := req.Send()
+	return output, err
+}
+
+func headObjectSSEC(client *s3.S3, input *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) {
+	req, output := client.HeadObjectRequest(input)
+	req.Handlers.Validate.Clear()
+	err := req.Send()
+	return output, err
+}
+
+func testPutObjectWithChecksumAndSSEC(t *testing.T, cluster *TestCluster) {
+	bucketName := createTestBucket(t, cluster, "test-put-checksum-ssec-")
+	objectKey := "test-checksummed-ssec-object.txt"
+	objectData := "Hello, SeaweedFS S3 with SSE-C!"
+
+	correctMD5 := calculateMd5(objectData)
+	incorrectMD5 := calculateMd5(objectData + "incorrect")
+	keyRaw, keyMD5B64 := generateSSECKey()
+
+	// Put object with SSE-C and incorrect MD5 should be rejected
+	_, err := putObjectSSEC(cluster.s3Client, &s3.PutObjectInput{
+		Bucket:               aws.String(bucketName),
+		Key:                  aws.String(objectKey),
+		Body:                 bytes.NewReader([]byte(objectData)),
+		ContentMD5:           aws.String(incorrectMD5),
+		SSECustomerAlgorithm: aws.String("AES256"),
+		SSECustomerKey:       aws.String(keyRaw),
+		SSECustomerKeyMD5:    aws.String(keyMD5B64),
+	})
+	assertBadDigestError(t, err, "PutObject with SSE-C should fail with incorrect MD5")
+
+	t.Logf("Put object with SSE-C and incorrect MD5 rejected: %s/%s", bucketName, objectKey)
+
+	// Put object with SSE-C and correct MD5 should succeed
+	_, err = putObjectSSEC(cluster.s3Client, &s3.PutObjectInput{
+		Bucket:               aws.String(bucketName),
+		Key:                  aws.String(objectKey),
+		Body:                 bytes.NewReader([]byte(objectData)),
+		ContentMD5:           aws.String(correctMD5),
+		SSECustomerAlgorithm: aws.String("AES256"),
+		SSECustomerKey:       aws.String(keyRaw),
+		SSECustomerKeyMD5:    aws.String(keyMD5B64),
+	})
+	require.NoError(t, err, "Failed to put object with SSE-C and correct MD5")
+
+	// Verify object exists (SSE-C requires the key for HeadObject too)
+	headResp, err := headObjectSSEC(cluster.s3Client, &s3.HeadObjectInput{
+		Bucket:               aws.String(bucketName),
+		Key:                  aws.String(objectKey),
+		SSECustomerAlgorithm: aws.String("AES256"),
+		SSECustomerKey:       aws.String(keyRaw),
+		SSECustomerKeyMD5:    aws.String(keyMD5B64),
+	})
+	require.NoError(t, err)
+	assert.NotNil(t, headResp.ContentLength)
+	assert.Equal(t, int64(len(objectData)), aws.Int64Value(headResp.ContentLength))
+
+	t.Logf("Put object with SSE-C and correct MD5: %s/%s (%d bytes)", bucketName, objectKey, len(objectData))
+}
+
+func testUploadPartWithChecksum(t *testing.T, cluster *TestCluster) {
+	bucketName := createTestBucket(t, cluster, "test-upload-part-checksum-")
+	objectKey := "test-multipart-checksum.txt"
+	objectData := "Hello, SeaweedFS S3 Multipart!"
+
+	// Initiate multipart upload
+	initResp, err := cluster.s3Client.CreateMultipartUpload(&s3.CreateMultipartUploadInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+	})
+	require.NoError(t, err)
+	uploadID := initResp.UploadId
+
+	correctMD5 := calculateMd5(objectData)
+	incorrectMD5 := calculateMd5(objectData + "incorrect")
+
+	// Upload part with incorrect MD5
+	_, err = cluster.s3Client.UploadPart(&s3.UploadPartInput{
+		Bucket:     aws.String(bucketName),
+		Key:        aws.String(objectKey),
+		PartNumber: aws.Int64(1),
+		UploadId:   uploadID,
+		Body:       bytes.NewReader([]byte(objectData)),
+		ContentMD5: aws.String(incorrectMD5),
+	})
+	assertBadDigestError(t, err, "UploadPart should fail with incorrect MD5")
+
+	// Upload part with correct MD5
+	partResp, err := cluster.s3Client.UploadPart(&s3.UploadPartInput{
+		Bucket:     aws.String(bucketName),
+		Key:        aws.String(objectKey),
+		PartNumber: aws.Int64(1),
+		UploadId:   uploadID,
+		Body:       bytes.NewReader([]byte(objectData)),
+		ContentMD5: aws.String(correctMD5),
+	})
+	require.NoError(t, err, "Failed to upload part with correct MD5")
+
+	// Complete multipart upload
+	_, err = cluster.s3Client.CompleteMultipartUpload(&s3.CompleteMultipartUploadInput{
+		Bucket:   aws.String(bucketName),
+		Key:      aws.String(objectKey),
+		UploadId: uploadID,
+		MultipartUpload: &s3.CompletedMultipartUpload{
+			Parts: []*s3.CompletedPart{
+				{
+					ETag:       partResp.ETag,
+					PartNumber: aws.Int64(1),
+				},
+			},
+		},
+	})
+	require.NoError(t, err, "Failed to complete multipart upload")
+
+	// Verify object exists
+	headResp, err := cluster.s3Client.HeadObject(&s3.HeadObjectInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+	})
+	require.NoError(t, err)
+	assert.Equal(t, int64(len(objectData)), aws.Int64Value(headResp.ContentLength))
+
+	t.Logf("✓ Multipart upload with checksum successful: %s/%s", bucketName, objectKey)
+}
+
+func testPutPartWithChecksum(t *testing.T, cluster *TestCluster) {
+	bucketName := createTestBucket(t, cluster, "test-put-checksum-")
+	objectKey := "test-checksummed-part.txt"
+
+	partData := "Hello, SeaweedFS S3!"
+
+	correctMD5 := calculateMd5(partData)
+	incorrectMD5 := calculateMd5(partData + "incorrect")
+
+	createResp, err := cluster.s3Client.CreateMultipartUpload(&s3.CreateMultipartUploadInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+	})
+	require.NoError(t, err)
+
+	uploadID := createResp.UploadId
+
+	partBody := []byte(partData)
+
+	_, err = cluster.s3Client.UploadPart(&s3.UploadPartInput{
+		Bucket:     aws.String(bucketName),
+		Key:        aws.String(objectKey),
+		UploadId:   uploadID,
+		PartNumber: aws.Int64(1),
+		Body:       bytes.NewReader(partBody),
+		ContentMD5: aws.String(incorrectMD5),
+	})
+	assertBadDigestError(t, err, "UploadPart should fail with incorrect MD5")
+
+	uploadResp, err := cluster.s3Client.UploadPart(&s3.UploadPartInput{
+		Bucket:     aws.String(bucketName),
+		Key:        aws.String(objectKey),
+		UploadId:   uploadID,
+		PartNumber: aws.Int64(1),
+		Body:       bytes.NewReader(partBody),
+		ContentMD5: aws.String(correctMD5),
+	})
+	require.NoError(t, err)
+
+	_, err = cluster.s3Client.CompleteMultipartUpload(&s3.CompleteMultipartUploadInput{
+		Bucket:   aws.String(bucketName),
+		Key:      aws.String(objectKey),
+		UploadId: uploadID,
+		MultipartUpload: &s3.CompletedMultipartUpload{
+			Parts: []*s3.CompletedPart{
+				{
+					ETag:       uploadResp.ETag,
+					PartNumber: aws.Int64(1),
+				},
+			},
+		},
+	})
+	require.NoError(t, err, "Failed to complete multipart upload")
+
+	// Verify object exists
+	headResp, err := cluster.s3Client.HeadObject(&s3.HeadObjectInput{
+		Bucket: aws.String(bucketName),
+		Key:    aws.String(objectKey),
+	})
+	require.NoError(t, err)
+	assert.Equal(t, int64(len(partData)), aws.Int64Value(headResp.ContentLength))
+
+	t.Logf("✓ UploadPart with MD5 validation: %s/%s", bucketName, objectKey)
+}
+
+func calculateMd5(objectData string) string {
+	dataBytes := []byte(objectData)
+	hash := md5.Sum(dataBytes)
+	return base64.StdEncoding.EncodeToString(hash[:])
+}
+
+func assertBadDigestError(t *testing.T, err error, description string) {
+	require.Error(t, err, description)
+
+	var awsErr awserr.Error
+	require.ErrorAs(t, err, &awsErr)
+	assert.Equal(t, "BadDigest", awsErr.Code())
+}
+
 func testGetObject(t *testing.T, cluster *TestCluster) {
 	bucketName := "test-get-" + randomString(8)
 	objectKey := "test-data.txt"
@@ -484,6 +780,49 @@ func testDeleteBucket(t *testing.T, cluster *TestCluster) {
 	t.Logf("✓ Deleted bucket: %s", bucketName)
 }
 
+func TestS3DeleteBucketNotEmpty(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	cluster, err := startMiniCluster(t, "-s3.allowDeleteBucketNotEmpty=false")
+	require.NoError(t, err)
+	defer cluster.Stop()
+
+	t.Run("DeleteNonEmptyBucketFails", func(t *testing.T) {
+		bucketName := createTestBucket(t, cluster, "test-notempty-")
+		objectKey := "keep-me.txt"
+
+		// Put an object so the bucket is non-empty
+		_, err := cluster.s3Client.PutObject(&s3.PutObjectInput{
+			Bucket: aws.String(bucketName),
+			Key:    aws.String(objectKey),
+			Body:   bytes.NewReader([]byte("data")),
+		})
+		require.NoError(t, err)
+
+		// Attempt to delete the non-empty bucket — must fail with BucketNotEmpty (409)
+		_, err = cluster.s3Client.DeleteBucket(&s3.DeleteBucketInput{
+			Bucket: aws.String(bucketName),
+		})
+		require.Error(t, err, "deleting a non-empty bucket should fail")
+		var awsErr awserr.Error
+		require.ErrorAs(t, err, &awsErr)
+		assert.Equal(t, "BucketNotEmpty", awsErr.Code(),
+			"expected BucketNotEmpty error code, got %s: %s", awsErr.Code(), awsErr.Message())
+	})
+
+	t.Run("DeleteEmptyBucketSucceeds", func(t *testing.T) {
+		bucketName := createTestBucket(t, cluster, "test-empty-")
+
+		// Delete the empty bucket — should succeed even with the flag
+		_, err := cluster.s3Client.DeleteBucket(&s3.DeleteBucketInput{
+			Bucket: aws.String(bucketName),
+		})
+		require.NoError(t, err, "deleting an empty bucket should succeed")
+	})
+}
+
 // randomString generates a random string for unique naming
 func randomString(length int) string {
 	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"

test/s3/policy/policy_test.go

@@ -2,6 +2,7 @@ package policy
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"net"
 	"net/http"
@@ -14,6 +15,11 @@ import (
 	"testing"
 	"time"
 
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/iam"
 	"github.com/seaweedfs/seaweedfs/weed/command"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/pb"
@@ -130,6 +136,151 @@ func TestS3PolicyShellRevised(t *testing.T) {
 	}
 }
 
+func TestS3IAMAttachDetachUserPolicy(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	cluster, err := startMiniCluster(t)
+	require.NoError(t, err)
+	defer cluster.Stop()
+
+	time.Sleep(500 * time.Millisecond)
+
+	policyName := uniqueName("managed-policy")
+	policyArn := fmt.Sprintf("arn:aws:iam:::policy/%s", policyName)
+	policyContent := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"*","Resource":"*"}]}`
+	tmpPolicyFile, err := os.CreateTemp("", "test_policy_attach_*.json")
+	require.NoError(t, err)
+	defer os.Remove(tmpPolicyFile.Name())
+	_, err = tmpPolicyFile.WriteString(policyContent)
+	require.NoError(t, err)
+	require.NoError(t, tmpPolicyFile.Close())
+
+	weedCmd := "weed"
+	masterAddr := string(pb.NewServerAddress("127.0.0.1", cluster.masterPort, cluster.masterGrpcPort))
+	filerAddr := string(pb.NewServerAddress("127.0.0.1", cluster.filerPort, cluster.filerGrpcPort))
+	execShell(t, weedCmd, masterAddr, filerAddr, fmt.Sprintf("s3.policy -put -name=%s -file=%s", policyName, tmpPolicyFile.Name()))
+
+	iamClient := newIAMClient(t, cluster.s3Endpoint)
+
+	userName := uniqueName("iam-user")
+	_, err = iamClient.CreateUser(&iam.CreateUserInput{UserName: aws.String(userName)})
+	require.NoError(t, err)
+
+	_, err = iamClient.AttachUserPolicy(&iam.AttachUserPolicyInput{
+		UserName:  aws.String(userName),
+		PolicyArn: aws.String(policyArn),
+	})
+	require.NoError(t, err)
+
+	listOut, err := iamClient.ListAttachedUserPolicies(&iam.ListAttachedUserPoliciesInput{
+		UserName: aws.String(userName),
+	})
+	require.NoError(t, err)
+	require.True(t, attachedPolicyContains(listOut.AttachedPolicies, policyName))
+
+	_, err = iamClient.DetachUserPolicy(&iam.DetachUserPolicyInput{
+		UserName:  aws.String(userName),
+		PolicyArn: aws.String(policyArn),
+	})
+	require.NoError(t, err)
+
+	listOut, err = iamClient.ListAttachedUserPolicies(&iam.ListAttachedUserPoliciesInput{
+		UserName: aws.String(userName),
+	})
+	require.NoError(t, err)
+	require.False(t, attachedPolicyContains(listOut.AttachedPolicies, policyName))
+
+	_, err = iamClient.AttachUserPolicy(&iam.AttachUserPolicyInput{
+		UserName:  aws.String(userName),
+		PolicyArn: aws.String("arn:aws:iam:::policy/does-not-exist"),
+	})
+	require.Error(t, err)
+	if awsErr, ok := err.(awserr.Error); ok {
+		require.Equal(t, iam.ErrCodeNoSuchEntityException, awsErr.Code())
+	}
+}
+
+func TestS3IAMListPoliciesAndGetPolicy(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	cluster, err := startMiniCluster(t)
+	require.NoError(t, err)
+	defer cluster.Stop()
+
+	time.Sleep(500 * time.Millisecond)
+
+	policyName := uniqueName("managed-policy")
+	policyArn := fmt.Sprintf("arn:aws:iam:::policy/%s", policyName)
+	policyContent := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"s3:ListAllMyBuckets","Resource":"*"}]}`
+
+	iamClient := newIAMClient(t, cluster.s3Endpoint)
+	_, err = iamClient.CreatePolicy(&iam.CreatePolicyInput{
+		PolicyName:     aws.String(policyName),
+		PolicyDocument: aws.String(policyContent),
+	})
+	require.NoError(t, err)
+
+	listOut, err := iamClient.ListPolicies(&iam.ListPoliciesInput{})
+	require.NoError(t, err)
+	require.True(t, managedPolicyContains(listOut.Policies, policyName))
+
+	getOut, err := iamClient.GetPolicy(&iam.GetPolicyInput{PolicyArn: aws.String(policyArn)})
+	require.NoError(t, err)
+	require.NotNil(t, getOut.Policy)
+	require.NotNil(t, getOut.Policy.PolicyName)
+	require.Equal(t, policyName, *getOut.Policy.PolicyName)
+
+	missingArn := fmt.Sprintf("arn:aws:iam:::policy/%s", uniqueName("missing"))
+	_, err = iamClient.GetPolicy(&iam.GetPolicyInput{PolicyArn: aws.String(missingArn)})
+	require.Error(t, err)
+	var awsErr awserr.Error
+	require.True(t, errors.As(err, &awsErr))
+	require.Equal(t, iam.ErrCodeNoSuchEntityException, awsErr.Code())
+}
+
+func TestS3IAMDeletePolicyInUse(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping integration test in short mode")
+	}
+
+	cluster, err := startMiniCluster(t)
+	require.NoError(t, err)
+	defer cluster.Stop()
+
+	time.Sleep(500 * time.Millisecond)
+
+	policyName := uniqueName("managed-delete-policy")
+	policyArn := fmt.Sprintf("arn:aws:iam:::policy/%s", policyName)
+	policyContent := `{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"s3:*","Resource":"*"}]}`
+
+	iamClient := newIAMClient(t, cluster.s3Endpoint)
+	_, err = iamClient.CreatePolicy(&iam.CreatePolicyInput{
+		PolicyName:     aws.String(policyName),
+		PolicyDocument: aws.String(policyContent),
+	})
+	require.NoError(t, err)
+
+	userName := uniqueName("iam-user-delete-policy")
+	_, err = iamClient.CreateUser(&iam.CreateUserInput{UserName: aws.String(userName)})
+	require.NoError(t, err)
+
+	_, err = iamClient.AttachUserPolicy(&iam.AttachUserPolicyInput{
+		UserName:  aws.String(userName),
+		PolicyArn: aws.String(policyArn),
+	})
+	require.NoError(t, err)
+
+	_, err = iamClient.DeletePolicy(&iam.DeletePolicyInput{PolicyArn: aws.String(policyArn)})
+	require.Error(t, err)
+	var awsErr awserr.Error
+	require.True(t, errors.As(err, &awsErr))
+	require.Equal(t, iam.ErrCodeDeleteConflictException, awsErr.Code())
+}
+
 func execShell(t *testing.T, weedCmd, master, filer, shellCmd string) string {
 	// weed shell -master=... -filer=...
 	args := []string{"shell", "-master=" + master, "-filer=" + filer}
@@ -145,6 +296,52 @@ func execShell(t *testing.T, weedCmd, master, filer, shellCmd string) string {
 	return string(out)
 }
 
+func newIAMClient(t *testing.T, endpoint string) *iam.IAM {
+	t.Helper()
+
+	accessKey := os.Getenv("AWS_ACCESS_KEY_ID")
+	secretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
+	if accessKey == "" {
+		accessKey = "admin"
+	}
+	if secretKey == "" {
+		secretKey = "admin"
+	}
+
+	sess, err := session.NewSession(&aws.Config{
+		Region:           aws.String("us-east-1"),
+		Endpoint:         aws.String(endpoint),
+		DisableSSL:       aws.Bool(true),
+		S3ForcePathStyle: aws.Bool(true),
+		Credentials:      credentials.NewStaticCredentials(accessKey, secretKey, ""),
+	})
+	require.NoError(t, err)
+
+	return iam.New(sess)
+}
+
+func attachedPolicyContains(policies []*iam.AttachedPolicy, policyName string) bool {
+	for _, policy := range policies {
+		if policy.PolicyName != nil && *policy.PolicyName == policyName {
+			return true
+		}
+	}
+	return false
+}
+
+func managedPolicyContains(policies []*iam.Policy, policyName string) bool {
+	for _, policy := range policies {
+		if policy.PolicyName != nil && *policy.PolicyName == policyName {
+			return true
+		}
+	}
+	return false
+}
+
+func uniqueName(prefix string) string {
+	return fmt.Sprintf("%s-%s", prefix, strconv.FormatInt(time.Now().UnixNano(), 36))
+}
+
 // --- Test setup helpers ---
 
 func findAvailablePort() (int, error) {
@@ -250,6 +447,7 @@ enabled = true
 			"-master.volumeSizeLimitMB=32",
 			"-ip=127.0.0.1",
 			"-master.peers=none",
+			"-s3.iam.readOnly=false",
 		}
 		glog.MaxSize = 1024 * 1024
 		for _, cmd := range command.Commands {

test/s3/sse/s3_volume_encryption_test.go

@@ -1,5 +1,4 @@
 //go:build integration
-// +build integration
 
 package sse
 

test/s3tables/catalog/iceberg_catalog_test.go

@@ -6,6 +6,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"flag"
 	"fmt"
 	"io"
 	"net"
@@ -18,6 +19,37 @@ import (
 	"time"
 )
 
+// sharedEnv is the single TestEnvironment shared across all tests in this package.
+var sharedEnv *TestEnvironment
+
+// TestMain starts one weed mini instance for the whole package and tears it down
+// after all tests have run.
+func TestMain(m *testing.M) {
+	flag.Parse()
+	if os.Getenv("SHORT") != "" || testing.Short() {
+		// Let tests self-skip when run with -short.
+		os.Exit(m.Run())
+	}
+
+	env, err := newTestEnvironmentForMain()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "SKIP: setup failed: %v\n", err)
+		os.Exit(0) // Skip all tests rather than fail
+	}
+	sharedEnv = env
+
+	if startErr := sharedEnv.startSeaweedFSForMain(); startErr != nil {
+		fmt.Fprintf(os.Stderr, "SKIP: weed mini failed to start: %v\n", startErr)
+		sharedEnv.cleanupForMain()
+		os.Exit(0)
+	}
+
+	code := m.Run()
+
+	sharedEnv.cleanupForMain()
+	os.Exit(code)
+}
+
 // TestEnvironment contains the test environment configuration
 type TestEnvironment struct {
 	seaweedDir      string
@@ -54,17 +86,15 @@ func getFreePort() (int, net.Listener, error) {
 	return addr.Port, listener, nil
 }
 
-// NewTestEnvironment creates a new test environment
-func NewTestEnvironment(t *testing.T) *TestEnvironment {
-	t.Helper()
-
+// newTestEnvironmentForMain creates a TestEnvironment without calling t.Fatalf so it
+// can be used from TestMain (which has no *testing.T).
+func newTestEnvironmentForMain() (*TestEnvironment, error) {
 	// Find the SeaweedFS root directory
 	wd, err := os.Getwd()
 	if err != nil {
-		t.Fatalf("Failed to get working directory: %v", err)
+		return nil, fmt.Errorf("get working directory: %w", err)
 	}
 
-	// Navigate up to find the SeaweedFS root (contains go.mod)
 	seaweedDir := wd
 	for i := 0; i < 5; i++ {
 		if _, err := os.Stat(filepath.Join(seaweedDir, "go.mod")); err == nil {
@@ -76,82 +106,93 @@ func NewTestEnvironment(t *testing.T) *TestEnvironment {
 	// Check for weed binary
 	weedBinary := filepath.Join(seaweedDir, "weed", "weed")
 	if _, err := os.Stat(weedBinary); os.IsNotExist(err) {
-		// Try system PATH
 		weedBinary = "weed"
 		if _, err := exec.LookPath(weedBinary); err != nil {
-			t.Skip("weed binary not found, skipping integration test")
+			return nil, fmt.Errorf("weed binary not found")
 		}
 	}
 
 	// Create temporary data directory
 	dataDir, err := os.MkdirTemp("", "seaweed-iceberg-test-*")
 	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
+		return nil, fmt.Errorf("create temp dir: %w", err)
 	}
 
 	// Allocate free ephemeral ports for each service
 	var listeners []net.Listener
-	defer func() {
+	closeListeners := func() {
 		for _, l := range listeners {
 			l.Close()
 		}
-	}()
+	}
 
 	var l net.Listener
 	s3Port, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for S3: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for S3: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	icebergPort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for Iceberg: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for Iceberg: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	s3GrpcPort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for S3 gRPC: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for S3 gRPC: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	masterPort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for Master: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for Master: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	masterGrpcPort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for Master gRPC: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for Master gRPC: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	filerPort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for Filer: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for Filer: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	filerGrpcPort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for Filer gRPC: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for Filer gRPC: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	volumePort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for Volume: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for Volume: %w", err)
 	}
 	listeners = append(listeners, l)
 
 	volumeGrpcPort, l, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for Volume gRPC: %v", err)
+		closeListeners()
+		return nil, fmt.Errorf("get free port for Volume gRPC: %w", err)
 	}
 	listeners = append(listeners, l)
 
+	// Release the port reservations so weed mini can bind to them
+	closeListeners()
+
 	return &TestEnvironment{
 		seaweedDir:      seaweedDir,
 		weedBinary:      weedBinary,
@@ -166,13 +207,11 @@ func NewTestEnvironment(t *testing.T) *TestEnvironment {
 		volumePort:      volumePort,
 		volumeGrpcPort:  volumeGrpcPort,
 		dockerAvailable: hasDocker(),
-	}
+	}, nil
 }
 
-// StartSeaweedFS starts a SeaweedFS mini cluster
-func (env *TestEnvironment) StartSeaweedFS(t *testing.T) {
-	t.Helper()
-
+// startSeaweedFSForMain starts weed mini without a *testing.T (for use in TestMain).
+func (env *TestEnvironment) startSeaweedFSForMain() error {
 	ctx, cancel := context.WithCancel(context.Background())
 	env.weedCancel = cancel
 
@@ -182,7 +221,8 @@ func (env *TestEnvironment) StartSeaweedFS(t *testing.T) {
 
 	for _, dir := range []string{masterDir, filerDir, volumeDir} {
 		if err := os.MkdirAll(dir, 0755); err != nil {
-			t.Fatalf("Failed to create directory %s: %v", dir, err)
+			cancel()
+			return fmt.Errorf("create directory %s: %w", dir, err)
 		}
 	}
 
@@ -203,13 +243,30 @@ func (env *TestEnvironment) StartSeaweedFS(t *testing.T) {
 	cmd.Stderr = os.Stderr
 
 	if err := cmd.Start(); err != nil {
-		t.Fatalf("Failed to start SeaweedFS: %v", err)
+		cancel()
+		return fmt.Errorf("start SeaweedFS: %w", err)
 	}
 	env.weedProcess = cmd
 
-	// Wait for services to be ready
 	if !env.waitForService(fmt.Sprintf("http://127.0.0.1:%d/v1/config", env.icebergPort), 30*time.Second) {
-		t.Fatalf("Iceberg REST API did not become ready")
+		cancel()
+		cmd.Wait()
+		return fmt.Errorf("Iceberg REST API did not become ready")
+	}
+	return nil
+}
+
+// cleanupForMain stops SeaweedFS and cleans up resources (no *testing.T needed).
+func (env *TestEnvironment) cleanupForMain() {
+	if env.weedCancel != nil {
+		env.weedCancel()
+	}
+	if env.weedProcess != nil {
+		time.Sleep(2 * time.Second)
+		env.weedProcess.Wait()
+	}
+	if env.dataDir != "" {
+		os.RemoveAll(env.dataDir)
 	}
 }
 
@@ -230,25 +287,6 @@ func (env *TestEnvironment) waitForService(url string, timeout time.Duration) bo
 	return false
 }
 
-// Cleanup stops SeaweedFS and cleans up resources
-func (env *TestEnvironment) Cleanup(t *testing.T) {
-	t.Helper()
-
-	if env.weedCancel != nil {
-		env.weedCancel()
-	}
-
-	if env.weedProcess != nil {
-		// Give process time to shut down gracefully
-		time.Sleep(2 * time.Second)
-		env.weedProcess.Wait()
-	}
-
-	if env.dataDir != "" {
-		os.RemoveAll(env.dataDir)
-	}
-}
-
 // IcebergURL returns the Iceberg REST Catalog URL
 func (env *TestEnvironment) IcebergURL() string {
 	return fmt.Sprintf("http://127.0.0.1:%d", env.icebergPort)
@@ -260,10 +298,7 @@ func TestIcebergConfig(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	env := NewTestEnvironment(t)
-	defer env.Cleanup(t)
-
-	env.StartSeaweedFS(t)
+	env := sharedEnv
 
 	// Test GET /v1/config
 	resp, err := http.Get(env.IcebergURL() + "/v1/config")
@@ -294,16 +329,14 @@ func TestIcebergNamespaces(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	env := NewTestEnvironment(t)
-	defer env.Cleanup(t)
-
-	env.StartSeaweedFS(t)
+	env := sharedEnv
 
 	// Create the default table bucket first via S3
-	createTableBucket(t, env, "warehouse")
+	bucketName := "warehouse-ns-" + randomSuffix()
+	createTableBucket(t, env, bucketName)
 
 	// Test GET /v1/namespaces (should return empty list initially)
-	resp, err := http.Get(env.IcebergURL() + "/v1/namespaces")
+	resp, err := http.Get(env.IcebergURL() + icebergPath(bucketName, "/v1/namespaces"))
 	if err != nil {
 		t.Fatalf("Failed to list namespaces: %v", err)
 	}
@@ -321,16 +354,14 @@ func TestStageCreateAndFinalizeFlow(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	env := NewTestEnvironment(t)
-	defer env.Cleanup(t)
+	env := sharedEnv
+	bucketName := "warehouse-stage-" + randomSuffix()
+	createTableBucket(t, env, bucketName)
 
-	env.StartSeaweedFS(t)
-	createTableBucket(t, env, "warehouse")
-
-	namespace := "stage_ns"
+	namespace := "stage_ns_" + randomSuffix()
 	tableName := "orders"
 
-	status, _, err := doIcebergJSONRequest(env, http.MethodPost, "/v1/namespaces", map[string]any{
+	status, _, err := doIcebergJSONRequest(env, http.MethodPost, icebergPath(bucketName, "/v1/namespaces"), map[string]any{
 		"namespace": []string{namespace},
 	})
 	if err != nil {
@@ -340,7 +371,7 @@ func TestStageCreateAndFinalizeFlow(t *testing.T) {
 		t.Fatalf("Create namespace status = %d, want 200 or 409", status)
 	}
 
-	status, badReqResp, err := doIcebergJSONRequest(env, http.MethodPost, fmt.Sprintf("/v1/namespaces/%s/tables", namespace), map[string]any{
+	status, badReqResp, err := doIcebergJSONRequest(env, http.MethodPost, icebergPath(bucketName, fmt.Sprintf("/v1/namespaces/%s/tables", namespace)), map[string]any{
 		"stage-create": true,
 	})
 	if err != nil {
@@ -358,7 +389,7 @@ func TestStageCreateAndFinalizeFlow(t *testing.T) {
 		t.Fatalf("error.message = %v, want it to include %q", errorObj["message"], "table name is required")
 	}
 
-	status, stageResp, err := doIcebergJSONRequest(env, http.MethodPost, fmt.Sprintf("/v1/namespaces/%s/tables", namespace), map[string]any{
+	status, stageResp, err := doIcebergJSONRequest(env, http.MethodPost, icebergPath(bucketName, fmt.Sprintf("/v1/namespaces/%s/tables", namespace)), map[string]any{
 		"name":         tableName,
 		"stage-create": true,
 	})
@@ -373,7 +404,7 @@ func TestStageCreateAndFinalizeFlow(t *testing.T) {
 		t.Fatalf("stage metadata-location = %q, want suffix /metadata/v1.metadata.json", stageLocation)
 	}
 
-	status, _, err = doIcebergJSONRequest(env, http.MethodGet, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName), nil)
+	status, _, err = doIcebergJSONRequest(env, http.MethodGet, icebergPath(bucketName, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName)), nil)
 	if err != nil {
 		t.Fatalf("Load staged table request failed: %v", err)
 	}
@@ -381,7 +412,7 @@ func TestStageCreateAndFinalizeFlow(t *testing.T) {
 		t.Fatalf("Load staged table status = %d, want 404", status)
 	}
 
-	status, commitResp, err := doIcebergJSONRequest(env, http.MethodPost, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName), map[string]any{
+	status, commitResp, err := doIcebergJSONRequest(env, http.MethodPost, icebergPath(bucketName, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName)), map[string]any{
 		"requirements": []map[string]any{
 			{"type": "assert-create"},
 		},
@@ -398,7 +429,7 @@ func TestStageCreateAndFinalizeFlow(t *testing.T) {
 		t.Fatalf("final metadata-location = %q, want suffix /metadata/v1.metadata.json", commitLocation)
 	}
 
-	status, loadResp, err := doIcebergJSONRequest(env, http.MethodGet, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName), nil)
+	status, loadResp, err := doIcebergJSONRequest(env, http.MethodGet, icebergPath(bucketName, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName)), nil)
 	if err != nil {
 		t.Fatalf("Load finalized table request failed: %v", err)
 	}
@@ -417,16 +448,14 @@ func TestCommitMissingTableWithoutAssertCreate(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	env := NewTestEnvironment(t)
-	defer env.Cleanup(t)
+	env := sharedEnv
+	bucketName := "warehouse-missing-" + randomSuffix()
+	createTableBucket(t, env, bucketName)
 
-	env.StartSeaweedFS(t)
-	createTableBucket(t, env, "warehouse")
-
-	namespace := "stage_missing_assert_ns"
+	namespace := "stage_missing_assert_ns_" + randomSuffix()
 	tableName := "missing_table"
 
-	status, _, err := doIcebergJSONRequest(env, http.MethodPost, "/v1/namespaces", map[string]any{
+	status, _, err := doIcebergJSONRequest(env, http.MethodPost, icebergPath(bucketName, "/v1/namespaces"), map[string]any{
 		"namespace": []string{namespace},
 	})
 	if err != nil {
@@ -436,7 +465,7 @@ func TestCommitMissingTableWithoutAssertCreate(t *testing.T) {
 		t.Fatalf("Create namespace status = %d, want 200 or 409", status)
 	}
 
-	status, _, err = doIcebergJSONRequest(env, http.MethodPost, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName), map[string]any{
+	status, _, err = doIcebergJSONRequest(env, http.MethodPost, icebergPath(bucketName, fmt.Sprintf("/v1/namespaces/%s/tables/%s", namespace, tableName)), map[string]any{
 		"requirements": []any{},
 		"updates":      []any{},
 	})
@@ -491,6 +520,21 @@ func doIcebergJSONRequest(env *TestEnvironment, method, path string, payload any
 	return resp.StatusCode, decoded, nil
 }
 
+// icebergPath inserts the table bucket prefix into Iceberg REST API paths.
+// For example, "/v1/namespaces" with prefix "my-bucket" becomes
+// "/v1/my-bucket/namespaces".
+func icebergPath(prefix, path string) string {
+	if prefix == "" {
+		return path
+	}
+	const base = "/v1/"
+	if !strings.HasPrefix(path, base) {
+		return path
+	}
+	withPrefix := base + prefix + "/" + strings.TrimPrefix(path, base)
+	return withPrefix
+}
+
 // createTableBucket creates a table bucket via the S3Tables REST API
 func createTableBucket(t *testing.T, env *TestEnvironment, bucketName string) {
 	t.Helper()
@@ -520,6 +564,11 @@ func createTableBucket(t *testing.T, env *TestEnvironment, bucketName string) {
 	t.Logf("Created table bucket %s", bucketName)
 }
 
+// randomSuffix returns a short random hex suffix for unique resource naming.
+func randomSuffix() string {
+	return fmt.Sprintf("%x", time.Now().UnixNano()&0xffffffff)
+}
+
 // TestDuckDBIntegration tests Iceberg catalog operations using DuckDB
 // This test requires Docker to be available
 func TestDuckDBIntegration(t *testing.T) {
@@ -527,15 +576,12 @@ func TestDuckDBIntegration(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	env := NewTestEnvironment(t)
-	defer env.Cleanup(t)
+	env := sharedEnv
 
 	if !env.dockerAvailable {
 		t.Skip("Docker not available, skipping DuckDB integration test")
 	}
 
-	env.StartSeaweedFS(t)
-
 	// Create a temporary SQL file for DuckDB to execute
 	sqlFile := filepath.Join(env.dataDir, "test.sql")
 	sqlContent := fmt.Sprintf(`

test/s3tables/catalog/pyiceberg_test.go

@@ -26,17 +26,14 @@ func TestPyIcebergRestCatalog(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	env := NewTestEnvironment(t)
-	defer env.Cleanup(t)
+	env := sharedEnv
 
 	if !env.dockerAvailable {
 		t.Skip("Docker not available, skipping PyIceberg integration test")
 	}
 
-	env.StartSeaweedFS(t)
-
 	// Create the test bucket first
-	bucketName := "pyiceberg-compat-test"
+	bucketName := "pyiceberg-compat-test-" + randomSuffix()
 	createTableBucket(t, env, bucketName)
 
 	// Build the test working directory path
@@ -84,8 +81,7 @@ func TestPyIcebergRestCatalogAuthenticated(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	env := NewTestEnvironment(t)
-	defer env.Cleanup(t)
+	env := sharedEnv
 
 	if !env.dockerAvailable {
 		t.Skip("Docker not available, skipping PyIceberg integration test")
@@ -95,11 +91,8 @@ func TestPyIcebergRestCatalogAuthenticated(t *testing.T) {
 	testAccessKey := "admin"
 	testSecretKey := "admin"
 
-	// Start SeaweedFS (it will use default admin credentials from environment if set)
-	env.StartSeaweedFS(t)
-
 	// Create the test bucket first (using unauthenticated request, which works with DefaultAllow)
-	bucketName := "pyiceberg-auth-test"
+	bucketName := "pyiceberg-auth-test-" + randomSuffix()
 	createTableBucket(t, env, bucketName)
 
 	// Build the test working directory path

test/s3tables/catalog_trino/trino_catalog_test.go

@@ -40,6 +40,7 @@ type TestEnvironment struct {
 	dockerAvailable bool
 	accessKey       string
 	secretKey       string
+	closers         []io.Closer
 }
 
 func TestTrinoIcebergCatalog(t *testing.T) {
@@ -118,30 +119,66 @@ func NewTestEnvironment(t *testing.T) *TestEnvironment {
 
 	bindIP := testutil.FindBindIP()
 
-	masterPort, masterGrpcPort := mustFreePortPair(t, "Master")
-	volumePort, volumeGrpcPort := mustFreePortPair(t, "Volume")
-	filerPort, filerGrpcPort := mustFreePortPair(t, "Filer")
-	s3Port, s3GrpcPort := mustFreePortPair(t, "S3")
-	icebergPort := mustFreePort(t, "Iceberg")
-
-	return &TestEnvironment{
-		seaweedDir:      seaweedDir,
-		weedBinary:      weedBinary,
-		dataDir:         dataDir,
-		bindIP:          bindIP,
-		s3Port:          s3Port,
-		s3GrpcPort:      s3GrpcPort,
-		icebergPort:     icebergPort,
-		masterPort:      masterPort,
-		masterGrpcPort:  masterGrpcPort,
-		filerPort:       filerPort,
-		filerGrpcPort:   filerGrpcPort,
-		volumePort:      volumePort,
-		volumeGrpcPort:  volumeGrpcPort,
-		dockerAvailable: hasDocker(),
-		accessKey:       "AKIAIOSFODNN7EXAMPLE",
-		secretKey:       "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+	env := &TestEnvironment{
+		seaweedDir: seaweedDir,
+		weedBinary: weedBinary,
+		dataDir:    dataDir,
+		bindIP:     bindIP,
+		closers:    []io.Closer{},
 	}
+
+	env.masterPort, env.masterGrpcPort = env.mustFreePortPair("Master")
+	env.volumePort, env.volumeGrpcPort = env.mustFreePortPair("Volume")
+	env.filerPort, env.filerGrpcPort = env.mustFreePortPair("Filer")
+	env.s3Port, env.s3GrpcPort = env.mustFreePortPair("S3")
+	env.icebergPort = env.mustFreePort("Iceberg")
+
+	env.dockerAvailable = hasDocker()
+	env.accessKey = "AKIAIOSFODNN7EXAMPLE"
+	env.secretKey = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+
+	return env
+}
+
+func (env *TestEnvironment) mustFreePort(name string) int {
+	port, closer, err := getFreePort()
+	if err != nil {
+		panic(fmt.Sprintf("Failed to get free port for %s: %v", name, err))
+	}
+	env.closers = append(env.closers, closer)
+	return port
+}
+
+func (env *TestEnvironment) mustFreePortPair(name string) (int, int) {
+	httpPort, httpCloser, grpcPort, grpcCloser, err := findAvailablePortPair()
+	if err != nil {
+		panic(fmt.Sprintf("Failed to get free port pair for %s: %v", name, err))
+	}
+	env.closers = append(env.closers, httpCloser, grpcCloser)
+	return httpPort, grpcPort
+}
+
+func mustFreePort(t *testing.T, name string) int {
+	t.Helper()
+
+	port, closer, err := getFreePort()
+	if err != nil {
+		t.Fatalf("Failed to get free port for %s: %v", name, err)
+	}
+	closer.Close()
+	return port
+}
+
+func mustFreePortPair(t *testing.T, name string) (int, int) {
+	t.Helper()
+
+	httpPort, httpCloser, grpcPort, grpcCloser, err := findAvailablePortPair()
+	if err != nil {
+		t.Fatalf("Failed to get free port pair for %s: %v", name, err)
+	}
+	httpCloser.Close()
+	grpcCloser.Close()
+	return httpPort, grpcPort
 }
 
 func (env *TestEnvironment) StartSeaweedFS(t *testing.T) {
@@ -161,6 +198,12 @@ func (env *TestEnvironment) StartSeaweedFS(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	env.weedCancel = cancel
 
+	// Close all port listeners right before starting the weed process
+	for _, closer := range env.closers {
+		closer.Close()
+	}
+	env.closers = nil
+
 	cmd := exec.CommandContext(ctx, env.weedBinary, "mini",
 		"-master.port", fmt.Sprintf("%d", env.masterPort),
 		"-master.port.grpc", fmt.Sprintf("%d", env.masterGrpcPort),
@@ -471,47 +514,27 @@ func hasDocker() bool {
 	return cmd.Run() == nil
 }
 
-func mustFreePort(t *testing.T, name string) int {
-	t.Helper()
-
-	port, err := getFreePort()
+func findAvailablePortPair() (int, io.Closer, int, io.Closer, error) {
+	httpPort, httpCloser, err := getFreePort()
 	if err != nil {
-		t.Fatalf("Failed to get free port for %s: %v", name, err)
+		return 0, nil, 0, nil, err
 	}
-	return port
+	grpcPort, grpcCloser, err := getFreePort()
+	if err != nil {
+		httpCloser.Close()
+		return 0, nil, 0, nil, err
+	}
+	return httpPort, httpCloser, grpcPort, grpcCloser, nil
 }
 
-func mustFreePortPair(t *testing.T, name string) (int, int) {
-	t.Helper()
-
-	httpPort, grpcPort, err := findAvailablePortPair()
-	if err != nil {
-		t.Fatalf("Failed to get free port pair for %s: %v", name, err)
-	}
-	return httpPort, grpcPort
-}
-
-func findAvailablePortPair() (int, int, error) {
-	httpPort, err := getFreePort()
-	if err != nil {
-		return 0, 0, err
-	}
-	grpcPort, err := getFreePort()
-	if err != nil {
-		return 0, 0, err
-	}
-	return httpPort, grpcPort, nil
-}
-
-func getFreePort() (int, error) {
+func getFreePort() (int, io.Closer, error) {
 	listener, err := net.Listen("tcp", "0.0.0.0:0")
 	if err != nil {
-		return 0, err
+		return 0, nil, err
 	}
-	defer listener.Close()
 
 	addr := listener.Addr().(*net.TCPAddr)
-	return addr.Port, nil
+	return addr.Port, listener, nil
 }
 
 func randomString(length int) string {

test/s3tables/table-buckets/s3tables_integration_test.go

@@ -12,33 +12,57 @@ import (
 	"time"
 
 	cryptorand "crypto/rand"
-	"sync"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"flag"
+
 	"github.com/seaweedfs/seaweedfs/weed/command"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/s3api/s3tables"
-	flag "github.com/seaweedfs/seaweedfs/weed/util/fla9"
 )
 
-var (
-	miniClusterMutex sync.Mutex
-)
+// TestMain starts a single default weed mini cluster for the whole package and
+// tears it down after all tests have completed. Tests that require a different
+// cluster configuration (e.g. TestS3TablesCreateBucketIAMPolicy) start their
+// own cluster independently.
+func TestMain(m *testing.M) {
+	flag.Parse()
+	if testing.Short() {
+		// Tests self-skip with t.Skip when -short is set; no cluster needed.
+		os.Exit(m.Run())
+	}
+
+	// Create a temporary T-less context so we can use t.TempDir-equivalent.
+	testDir, err := os.MkdirTemp("", "seaweed-s3tables-shared-*")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "SKIP: failed to create shared temp dir: %v\n", err)
+		os.Exit(0)
+	}
+
+	cluster, err := startMiniClusterInDir(testDir, nil)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "SKIP: failed to start shared weed mini cluster: %v\n", err)
+		os.RemoveAll(testDir)
+		os.Exit(0)
+	}
+	sharedCluster = cluster
+
+	code := m.Run()
+
+	sharedCluster.Stop()
+	os.RemoveAll(testDir)
+	os.Exit(code)
+}
 
 func TestS3TablesIntegration(t *testing.T) {
 	if testing.Short() {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	// Create and start test cluster
-	cluster, err := startMiniCluster(t)
-	require.NoError(t, err)
-	defer cluster.Stop()
-
-	// Create S3 Tables client
-	client := NewS3TablesClient(cluster.s3Endpoint, testRegion, testAccessKey, testSecretKey)
+	// Re-use the shared cluster started by TestMain.
+	client := NewS3TablesClient(sharedCluster.s3Endpoint, testRegion, testAccessKey, testSecretKey)
 
 	// Run test suite
 	t.Run("TableBucketLifecycle", func(t *testing.T) {
@@ -70,6 +94,92 @@ func TestS3TablesIntegration(t *testing.T) {
 	})
 }
 
+func TestS3TablesCreateBucketIAMPolicy(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping IAM integration test in short mode")
+	}
+
+	t.Setenv("AWS_ACCESS_KEY_ID", "env-admin")
+	t.Setenv("AWS_SECRET_ACCESS_KEY", "env-secret")
+
+	allowedBucket := "tables-allowed"
+	deniedBucket := "tables-denied"
+	iamConfigDir := t.TempDir()
+	iamConfigPath := filepath.Join(iamConfigDir, "iam_config.json")
+	iamConfig := fmt.Sprintf(`{
+  "sts": {
+    "tokenDuration": "1h",
+    "maxSessionLength": "12h",
+    "issuer": "seaweedfs-sts",
+    "signingKey": "%s"
+  },
+  "accounts": [
+    {
+      "id": "%s",
+      "displayName": "tables-integration"
+    }
+  ],
+  "identities": [
+    {
+      "name": "admin",
+      "credentials": [
+        {
+          "accessKey": "%s",
+          "secretKey": "%s"
+        }
+      ],
+      "account": {
+        "id": "%s",
+        "displayName": "tables-integration"
+      },
+      "policyNames": ["S3TablesBucketPolicy"]
+    }
+  ],
+  "policy": {
+    "defaultEffect": "Deny",
+    "storeType": "memory"
+  },
+  "policies": [
+    {
+      "name": "S3TablesBucketPolicy",
+      "document": {
+        "Version": "2012-10-17",
+        "Statement": [
+          {
+            "Effect": "Allow",
+            "Action": ["s3tables:CreateTableBucket"],
+            "Resource": [
+              "arn:aws:s3tables:*:*:bucket/%s",
+              "arn:aws:s3:::%s"
+            ]
+          }
+        ]
+      }
+    }
+  ]
+}`, testIAMSigningKey, testAccountID, testAccessKey, testSecretKey, testAccountID, allowedBucket, allowedBucket)
+	require.NoError(t, os.WriteFile(iamConfigPath, []byte(iamConfig), 0644))
+
+	cluster, err := startMiniClusterWithExtraArgs(t, []string{
+		"-s3.config=" + iamConfigPath,
+		"-s3.iam.config=" + iamConfigPath,
+	})
+	require.NoError(t, err, "failed to start cluster with IAM config")
+	defer cluster.Stop()
+
+	client := NewS3TablesClient(cluster.s3Endpoint, testRegion, testAccessKey, testSecretKey)
+
+	_, err = client.CreateTableBucket(deniedBucket, nil)
+	require.Error(t, err, "denied bucket creation should fail")
+	assert.Contains(t, err.Error(), "AccessDenied")
+
+	allowedResp, err := client.CreateTableBucket(allowedBucket, nil)
+	require.NoError(t, err, "allowed bucket creation should succeed")
+	defer func() {
+		_ = client.DeleteTableBucket(allowedResp.ARN)
+	}()
+}
+
 func testTableBucketLifecycle(t *testing.T, client *S3TablesClient) {
 	bucketName := "test-bucket-" + randomString(8)
 
@@ -508,11 +618,12 @@ func findAvailablePorts(n int) ([]int, error) {
 	return ports, nil
 }
 
-// startMiniCluster starts a weed mini instance directly without exec
-func startMiniCluster(t *testing.T) (*TestCluster, error) {
-	// Find available ports
-	// We need 8 unique ports: Master(2), Volume(2), Filer(2), S3(2)
-	ports, err := findAvailablePorts(8)
+// startMiniClusterInDir starts a weed mini instance using testDir as the data
+// directory. It does not require a *testing.T so it can be called from TestMain.
+// extraArgs are appended to the default mini command flags.
+func startMiniClusterInDir(testDir string, extraArgs []string) (*TestCluster, error) {
+	// We need 10 unique ports: Master(2), Volume(2), Filer(2), S3(2), Admin(2)
+	ports, err := findAvailablePorts(10)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find available ports: %v", err)
 	}
@@ -525,8 +636,8 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 	filerGrpcPort := ports[5]
 	s3Port := ports[6]
 	s3GrpcPort := ports[7]
-	// Create temporary directory for test data
-	testDir := t.TempDir()
+	adminPort := ports[8]
+	adminGrpcPort := ports[9]
 
 	// Ensure no configuration file from previous runs
 	configFile := filepath.Join(testDir, "mini.options")
@@ -537,7 +648,6 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 
 	s3Endpoint := fmt.Sprintf("http://127.0.0.1:%d", s3Port)
 	cluster := &TestCluster{
-		t:          t,
 		dataDir:    testDir,
 		ctx:        ctx,
 		cancel:     cancel,
@@ -550,18 +660,17 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 
 	// Create empty security.toml to disable JWT authentication in tests
 	securityToml := filepath.Join(testDir, "security.toml")
-	err = os.WriteFile(securityToml, []byte("# Empty security config for testing\n"), 0644)
-	if err != nil {
+	if err = os.WriteFile(securityToml, []byte("# Empty security config for testing\n"), 0644); err != nil {
 		cancel()
 		return nil, fmt.Errorf("failed to create security.toml: %v", err)
 	}
 
-	// Set environment variables for admin credentials safely for this test
+	// Ensure AWS credentials are set (don't use t.Setenv here — we are in TestMain).
 	if os.Getenv("AWS_ACCESS_KEY_ID") == "" {
-		t.Setenv("AWS_ACCESS_KEY_ID", "admin")
+		os.Setenv("AWS_ACCESS_KEY_ID", "admin")
 	}
 	if os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
-		t.Setenv("AWS_SECRET_ACCESS_KEY", "admin")
+		os.Setenv("AWS_SECRET_ACCESS_KEY", "admin")
 	}
 
 	// Start weed mini in a goroutine by calling the command directly
@@ -569,11 +678,7 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 	go func() {
 		defer cluster.wg.Done()
 
-		// Protect global state mutation with a mutex
-		miniClusterMutex.Lock()
-		defer miniClusterMutex.Unlock()
-
-		// Save current directory and args
+		// Save current directory and args, restore on exit.
 		oldDir, _ := os.Getwd()
 		oldArgs := os.Args
 		defer func() {
@@ -581,21 +686,24 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 			os.Args = oldArgs
 		}()
 
-		// Change to test directory so mini picks up security.toml
+		// Change to test directory so mini picks up security.toml.
 		os.Chdir(testDir)
 
-		// Configure args for mini command
-		os.Args = []string{
-			"weed",
+		baseArgs := []string{
 			"-dir=" + testDir,
+			"-master.dir=" + testDir,
 			"-master.port=" + strconv.Itoa(masterPort),
 			"-master.port.grpc=" + strconv.Itoa(masterGrpcPort),
 			"-volume.port=" + strconv.Itoa(volumePort),
 			"-volume.port.grpc=" + strconv.Itoa(volumeGrpcPort),
+			"-volume.port.public=" + strconv.Itoa(volumePort),
+			"-volume.publicUrl=127.0.0.1:" + strconv.Itoa(volumePort),
 			"-filer.port=" + strconv.Itoa(filerPort),
 			"-filer.port.grpc=" + strconv.Itoa(filerGrpcPort),
 			"-s3.port=" + strconv.Itoa(s3Port),
 			"-s3.port.grpc=" + strconv.Itoa(s3GrpcPort),
+			"-admin.port=" + strconv.Itoa(adminPort),
+			"-admin.port.grpc=" + strconv.Itoa(adminGrpcPort),
 			"-webdav.port=0",               // Disable WebDAV
 			"-admin.ui=false",              // Disable admin UI
 			"-master.volumeSizeLimitMB=32", // Small volumes for testing
@@ -603,6 +711,10 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 			"-master.peers=none",     // Faster startup
 			"-s3.iam.readOnly=false", // Enable IAM write operations for tests
 		}
+		if len(extraArgs) > 0 {
+			baseArgs = append(baseArgs, extraArgs...)
+		}
+		os.Args = append([]string{"weed"}, baseArgs...)
 
 		// Suppress most logging during tests
 		glog.MaxSize = 1024 * 1024
@@ -621,14 +733,34 @@ func startMiniCluster(t *testing.T) (*TestCluster, error) {
 	}()
 
 	// Wait for S3 service to be ready
-	err = waitForS3Ready(cluster.s3Endpoint, 30*time.Second)
-	if err != nil {
+	if err = waitForS3Ready(cluster.s3Endpoint, 30*time.Second); err != nil {
 		cancel()
 		return nil, fmt.Errorf("S3 service failed to start: %v", err)
 	}
 
 	cluster.isRunning = true
+	return cluster, nil
+}
 
+// startMiniClusterWithExtraArgs starts a weed mini instance for a single test.
+// It uses t.TempDir() for data isolation and t.Setenv for credential scoping.
+func startMiniClusterWithExtraArgs(t *testing.T, extraArgs []string) (*TestCluster, error) {
+	t.Helper()
+	testDir := t.TempDir()
+
+	// Scope credentials to the test so they are restored after test completion.
+	if os.Getenv("AWS_ACCESS_KEY_ID") == "" {
+		t.Setenv("AWS_ACCESS_KEY_ID", "admin")
+	}
+	if os.Getenv("AWS_SECRET_ACCESS_KEY") == "" {
+		t.Setenv("AWS_SECRET_ACCESS_KEY", "admin")
+	}
+
+	cluster, err := startMiniClusterInDir(testDir, extraArgs)
+	if err != nil {
+		return nil, err
+	}
+	cluster.t = t
 	t.Logf("Test cluster started successfully at %s", cluster.s3Endpoint)
 	return cluster, nil
 }
@@ -654,22 +786,15 @@ func (c *TestCluster) Stop() {
 	case <-done:
 		// Goroutine finished
 	case <-timer.C:
-		// Timeout - goroutine doesn't respond to context cancel
-		// This may indicate the mini cluster didn't shut down cleanly
-		c.t.Log("Warning: Test cluster shutdown timed out after 2 seconds")
-	}
-
-	// Reset the global cmdMini flags to prevent state leakage to other tests
-	for _, cmd := range command.Commands {
-		if cmd.Name() == "mini" {
-			// Reset flags to defaults
-			cmd.Flag.VisitAll(func(f *flag.Flag) {
-				// Reset to default value
-				f.Value.Set(f.DefValue)
-			})
-			break
+		// Timeout - goroutine doesn't respond to context cancel.
+		// This may indicate the mini cluster didn't shut down cleanly.
+		if c.t != nil {
+			c.t.Log("Warning: Test cluster shutdown timed out after 2 seconds")
+		} else {
+			fmt.Println("Warning: Test cluster shutdown timed out after 2 seconds")
 		}
 	}
+
 }
 
 // waitForS3Ready waits for the S3 service to be ready

test/s3tables/table-buckets/setup.go

@@ -8,6 +8,11 @@ import (
 	"time"
 )
 
+// sharedCluster is the single default TestCluster shared across all tests
+// that do not require a specialised cluster configuration.
+// It is initialised by TestMain and must not be modified by individual tests.
+var sharedCluster *TestCluster
+
 // TestCluster manages the weed mini instance for integration testing
 type TestCluster struct {
 	t          *testing.T
@@ -46,8 +51,9 @@ func NewS3TablesClient(endpoint, region, accessKey, secretKey string) *S3TablesC
 
 // Test configuration constants
 const (
-	testRegion    = "us-west-2"
-	testAccessKey = "admin"
-	testSecretKey = "admin"
-	testAccountID = "111122223333"
+	testRegion        = "us-west-2"
+	testAccessKey     = "admin"
+	testSecretKey     = "admin"
+	testAccountID     = "111122223333"
+	testIAMSigningKey = "dGVzdC1zaWduaW5nLWtleS1mb3Itc3RzLWludGVncmF0aW9uLXRlc3Rz"
 )

test/volume_server/framework/cluster_dual.go

@@ -33,7 +33,7 @@ type DualVolumeCluster struct {
 	volumeGrpcPort1 int
 	volumePubPort1  int
 
-	masterCmd *exec.Cmd
+	masterCmd  *exec.Cmd
 	volumeCmd0 *exec.Cmd
 	volumeCmd1 *exec.Cmd
 
@@ -79,21 +79,21 @@ func StartDualVolumeCluster(t testing.TB, profile matrix.Profile) *DualVolumeClu
 	}
 
 	c := &DualVolumeCluster{
-		testingTB:      t,
-		profile:        profile,
-		weedBinary:     weedBinary,
-		baseDir:        baseDir,
-		configDir:      configDir,
-		logsDir:        logsDir,
-		keepLogs:       keepLogs,
-		masterPort:     masterPort,
-		masterGrpcPort: masterGrpcPort,
-		volumePort0:    ports[0],
+		testingTB:       t,
+		profile:         profile,
+		weedBinary:      weedBinary,
+		baseDir:         baseDir,
+		configDir:       configDir,
+		logsDir:         logsDir,
+		keepLogs:        keepLogs,
+		masterPort:      masterPort,
+		masterGrpcPort:  masterGrpcPort,
+		volumePort0:     ports[0],
 		volumeGrpcPort0: ports[1],
-		volumePubPort0: ports[0],
-		volumePort1:    ports[2],
+		volumePubPort0:  ports[0],
+		volumePort1:     ports[2],
 		volumeGrpcPort1: ports[3],
-		volumePubPort1: ports[2],
+		volumePubPort1:  ports[2],
 	}
 	if profile.SplitPublicPort {
 		c.volumePubPort0 = ports[4]

unmaintained/disk/disk_status.go

@@ -1,5 +1,4 @@
 //go:build !windows && !openbsd && !netbsd && !plan9 && !solaris
-// +build !windows,!openbsd,!netbsd,!plan9,!solaris
 
 package main
 

unmaintained/stress/ec_stress_runner.go

@@ -0,0 +1,515 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	mrand "math/rand"
+	"net/http"
+	"net/url"
+	"os/signal"
+	"path"
+	"sort"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb"
+	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
+	"github.com/seaweedfs/seaweedfs/weed/pb/volume_server_pb"
+	"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+type config struct {
+	MasterAddresses    []string
+	FilerURL           string
+	PathPrefix         string
+	Collection         string
+	FileSizeBytes      int64
+	BatchSize          int
+	WriteInterval      time.Duration
+	CleanupInterval    time.Duration
+	EcMinAge           time.Duration
+	MaxCleanupPerCycle int
+	RequestTimeout     time.Duration
+	MaxRuntime         time.Duration
+	DryRun             bool
+}
+
+type runner struct {
+	cfg config
+
+	httpClient     *http.Client
+	grpcDialOption grpc.DialOption
+
+	mu            sync.Mutex
+	sequence      int64
+	ecFirstSeenAt map[uint32]time.Time
+	rng           *mrand.Rand
+}
+
+type ecVolumeInfo struct {
+	Collection string
+	NodeShards map[pb.ServerAddress][]uint32
+}
+
+type ecCleanupCandidate struct {
+	VolumeID    uint32
+	FirstSeenAt time.Time
+	Info        *ecVolumeInfo
+}
+
+func main() {
+	cfg, err := loadConfig()
+	if err != nil {
+		log.Fatalf("invalid flags: %v", err)
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	if cfg.MaxRuntime > 0 {
+		runCtx, cancel := context.WithTimeout(ctx, cfg.MaxRuntime)
+		defer cancel()
+		ctx = runCtx
+	}
+
+	r := &runner{
+		cfg:            cfg,
+		httpClient:     &http.Client{Timeout: cfg.RequestTimeout},
+		grpcDialOption: grpc.WithTransportCredentials(insecure.NewCredentials()),
+		ecFirstSeenAt:  make(map[uint32]time.Time),
+		rng:            mrand.New(mrand.NewSource(time.Now().UnixNano())),
+	}
+
+	log.Printf(
+		"starting EC stress runner: masters=%s filer=%s prefix=%s collection=%s file_size=%d batch=%d write_interval=%s cleanup_interval=%s ec_min_age=%s max_cleanup=%d dry_run=%v",
+		strings.Join(cfg.MasterAddresses, ","),
+		cfg.FilerURL,
+		cfg.PathPrefix,
+		cfg.Collection,
+		cfg.FileSizeBytes,
+		cfg.BatchSize,
+		cfg.WriteInterval,
+		cfg.CleanupInterval,
+		cfg.EcMinAge,
+		cfg.MaxCleanupPerCycle,
+		cfg.DryRun,
+	)
+
+	if err := r.run(ctx); err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, context.DeadlineExceeded) {
+		log.Fatalf("runner stopped with error: %v", err)
+	}
+
+	log.Printf("runner stopped")
+}
+
+func loadConfig() (config, error) {
+	var masters string
+	cfg := config{}
+
+	flag.StringVar(&masters, "masters", "127.0.0.1:9333", "comma-separated master server addresses")
+	flag.StringVar(&cfg.FilerURL, "filer", "http://127.0.0.1:8888", "filer base URL")
+	flag.StringVar(&cfg.PathPrefix, "path_prefix", "/tmp/ec-stress", "filer path prefix for generated files")
+	flag.StringVar(&cfg.Collection, "collection", "ec_stress", "target collection for stress data")
+
+	fileSizeMB := flag.Int("file_size_mb", 8, "size per generated file in MB")
+	flag.IntVar(&cfg.BatchSize, "batch_size", 4, "files generated per write cycle")
+	flag.DurationVar(&cfg.WriteInterval, "write_interval", 5*time.Second, "interval between write cycles")
+	flag.DurationVar(&cfg.CleanupInterval, "cleanup_interval", 2*time.Minute, "interval between EC cleanup cycles")
+	flag.DurationVar(&cfg.EcMinAge, "ec_min_age", 30*time.Minute, "minimum observed EC age before deletion")
+	flag.IntVar(&cfg.MaxCleanupPerCycle, "max_cleanup_per_cycle", 4, "maximum EC volumes deleted per cleanup cycle")
+	flag.DurationVar(&cfg.RequestTimeout, "request_timeout", 20*time.Second, "HTTP/gRPC request timeout")
+	flag.DurationVar(&cfg.MaxRuntime, "max_runtime", 0, "maximum run duration; 0 means run until interrupted")
+	flag.BoolVar(&cfg.DryRun, "dry_run", false, "log actions without deleting EC shards")
+	flag.Parse()
+
+	cfg.MasterAddresses = splitNonEmpty(masters)
+	cfg.FileSizeBytes = int64(*fileSizeMB) * 1024 * 1024
+
+	if len(cfg.MasterAddresses) == 0 {
+		return cfg, fmt.Errorf("at least one master is required")
+	}
+	if cfg.FileSizeBytes <= 0 {
+		return cfg, fmt.Errorf("file_size_mb must be positive")
+	}
+	if cfg.BatchSize <= 0 {
+		return cfg, fmt.Errorf("batch_size must be positive")
+	}
+	if cfg.WriteInterval <= 0 {
+		return cfg, fmt.Errorf("write_interval must be positive")
+	}
+	if cfg.CleanupInterval <= 0 {
+		return cfg, fmt.Errorf("cleanup_interval must be positive")
+	}
+	if cfg.EcMinAge < 0 {
+		return cfg, fmt.Errorf("ec_min_age must be zero or positive")
+	}
+	// Note: EcMinAge == 0 intentionally disables the age guard, making EC volumes eligible for cleanup immediately.
+	if cfg.MaxCleanupPerCycle <= 0 {
+		return cfg, fmt.Errorf("max_cleanup_per_cycle must be positive")
+	}
+	if cfg.RequestTimeout <= 0 {
+		return cfg, fmt.Errorf("request_timeout must be positive")
+	}
+
+	cfg.PathPrefix = ensureLeadingSlash(strings.TrimSpace(cfg.PathPrefix))
+	cfg.Collection = strings.TrimSpace(cfg.Collection)
+
+	cfg.FilerURL = strings.TrimRight(strings.TrimSpace(cfg.FilerURL), "/")
+	if cfg.FilerURL == "" {
+		return cfg, fmt.Errorf("filer URL is required")
+	}
+
+	if _, err := url.ParseRequestURI(cfg.FilerURL); err != nil {
+		return cfg, fmt.Errorf("invalid filer URL %q: %w", cfg.FilerURL, err)
+	}
+
+	return cfg, nil
+}
+
+func (r *runner) run(ctx context.Context) error {
+	writeTicker := time.NewTicker(r.cfg.WriteInterval)
+	defer writeTicker.Stop()
+
+	cleanupTicker := time.NewTicker(r.cfg.CleanupInterval)
+	defer cleanupTicker.Stop()
+
+	r.runWriteCycle(ctx)
+	r.runCleanupCycle(ctx)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-writeTicker.C:
+			r.runWriteCycle(ctx)
+		case <-cleanupTicker.C:
+			r.runCleanupCycle(ctx)
+		}
+	}
+}
+
+func (r *runner) runWriteCycle(ctx context.Context) {
+	for i := 0; i < r.cfg.BatchSize; i++ {
+		if ctx.Err() != nil {
+			return
+		}
+		if err := r.uploadOneFile(ctx); err != nil {
+			log.Printf("upload failed: %v", err)
+		}
+	}
+}
+
+func (r *runner) uploadOneFile(ctx context.Context) error {
+	sequence := r.nextSequence()
+	filePath := path.Join(r.cfg.PathPrefix, fmt.Sprintf("ec-stress-%d-%d.bin", time.Now().UnixNano(), sequence))
+	fileURL := r.cfg.FilerURL + filePath
+	if r.cfg.Collection != "" {
+		fileURL += "?collection=" + url.QueryEscape(r.cfg.Collection)
+	}
+
+	uploadCtx, cancel := context.WithTimeout(ctx, r.cfg.RequestTimeout)
+	defer cancel()
+
+	body := io.LimitReader(r.rng, r.cfg.FileSizeBytes)
+	request, err := http.NewRequestWithContext(uploadCtx, http.MethodPut, fileURL, body)
+	if err != nil {
+		return err
+	}
+	request.ContentLength = r.cfg.FileSizeBytes
+	request.Header.Set("Content-Type", "application/octet-stream")
+
+	response, err := r.httpClient.Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+
+	io.Copy(io.Discard, response.Body)
+	if response.StatusCode < http.StatusOK || response.StatusCode >= http.StatusMultipleChoices {
+		return fmt.Errorf("upload %s returned %s", filePath, response.Status)
+	}
+
+	log.Printf("uploaded %s size=%d", filePath, r.cfg.FileSizeBytes)
+	return nil
+}
+
+func (r *runner) runCleanupCycle(ctx context.Context) {
+	volumeList, err := r.fetchVolumeList(ctx)
+	if err != nil {
+		log.Printf("cleanup skipped: fetch volume list failed: %v", err)
+		return
+	}
+	if volumeList == nil || volumeList.TopologyInfo == nil {
+		log.Printf("cleanup skipped: topology is empty")
+		return
+	}
+
+	ecVolumes := collectEcVolumes(volumeList.TopologyInfo, r.cfg.Collection)
+	candidates := r.selectCleanupCandidates(ecVolumes)
+	if len(candidates) == 0 {
+		log.Printf("cleanup: no EC volume candidate aged >= %s in collection=%q", r.cfg.EcMinAge, r.cfg.Collection)
+		return
+	}
+
+	log.Printf("cleanup: deleting up to %d EC volumes (found=%d)", r.cfg.MaxCleanupPerCycle, len(candidates))
+	deleted := 0
+	for _, candidate := range candidates {
+		if ctx.Err() != nil {
+			return
+		}
+
+		if r.cfg.DryRun {
+			log.Printf(
+				"cleanup dry-run: would delete EC volume=%d collection=%q seen_for=%s nodes=%d",
+				candidate.VolumeID,
+				candidate.Info.Collection,
+				time.Since(candidate.FirstSeenAt).Round(time.Second),
+				len(candidate.Info.NodeShards),
+			)
+			continue
+		}
+
+		if err := r.deleteEcVolume(ctx, candidate.VolumeID, candidate.Info); err != nil {
+			log.Printf("cleanup volume=%d failed: %v", candidate.VolumeID, err)
+			continue
+		}
+
+		deleted++
+		r.mu.Lock()
+		delete(r.ecFirstSeenAt, candidate.VolumeID)
+		r.mu.Unlock()
+		log.Printf("cleanup volume=%d completed", candidate.VolumeID)
+	}
+
+	log.Printf("cleanup finished: deleted=%d attempted=%d", deleted, len(candidates))
+}
+
+func (r *runner) fetchVolumeList(ctx context.Context) (*master_pb.VolumeListResponse, error) {
+	var lastErr error
+	for _, master := range r.cfg.MasterAddresses {
+		masterAddress := strings.TrimSpace(master)
+		if masterAddress == "" {
+			continue
+		}
+
+		var response *master_pb.VolumeListResponse
+		err := pb.WithMasterClient(false, pb.ServerAddress(masterAddress), r.grpcDialOption, false, func(client master_pb.SeaweedClient) error {
+			callCtx, cancel := context.WithTimeout(ctx, r.cfg.RequestTimeout)
+			defer cancel()
+
+			resp, callErr := client.VolumeList(callCtx, &master_pb.VolumeListRequest{})
+			if callErr != nil {
+				return callErr
+			}
+			response = resp
+			return nil
+		})
+		if err == nil {
+			return response, nil
+		}
+
+		lastErr = err
+	}
+
+	if lastErr == nil {
+		lastErr = fmt.Errorf("no valid master address")
+	}
+	return nil, lastErr
+}
+
+func collectEcVolumes(topology *master_pb.TopologyInfo, collection string) map[uint32]*ecVolumeInfo {
+	normalizedCollection := strings.TrimSpace(collection)
+	volumeShardSets := make(map[uint32]map[pb.ServerAddress]map[uint32]struct{})
+	volumeCollection := make(map[uint32]string)
+
+	for _, dc := range topology.GetDataCenterInfos() {
+		for _, rack := range dc.GetRackInfos() {
+			for _, node := range rack.GetDataNodeInfos() {
+				server := pb.NewServerAddressFromDataNode(node)
+				for _, disk := range node.GetDiskInfos() {
+					for _, shardInfo := range disk.GetEcShardInfos() {
+						if shardInfo == nil || shardInfo.Id == 0 {
+							continue
+						}
+						if normalizedCollection != "" && strings.TrimSpace(shardInfo.Collection) != normalizedCollection {
+							continue
+						}
+
+						shards := erasure_coding.ShardsInfoFromVolumeEcShardInformationMessage(shardInfo).IdsUint32()
+						if len(shards) == 0 {
+							continue
+						}
+
+						perVolume := volumeShardSets[shardInfo.Id]
+						if perVolume == nil {
+							perVolume = make(map[pb.ServerAddress]map[uint32]struct{})
+							volumeShardSets[shardInfo.Id] = perVolume
+						}
+						perNode := perVolume[server]
+						if perNode == nil {
+							perNode = make(map[uint32]struct{})
+							perVolume[server] = perNode
+						}
+						for _, shardID := range shards {
+							perNode[shardID] = struct{}{}
+						}
+						volumeCollection[shardInfo.Id] = shardInfo.Collection
+					}
+				}
+			}
+		}
+	}
+
+	result := make(map[uint32]*ecVolumeInfo, len(volumeShardSets))
+	for volumeID, perNode := range volumeShardSets {
+		info := &ecVolumeInfo{
+			Collection: volumeCollection[volumeID],
+			NodeShards: make(map[pb.ServerAddress][]uint32, len(perNode)),
+		}
+		for server, shardSet := range perNode {
+			shardIDs := make([]uint32, 0, len(shardSet))
+			for shardID := range shardSet {
+				shardIDs = append(shardIDs, shardID)
+			}
+			sort.Slice(shardIDs, func(i, j int) bool { return shardIDs[i] < shardIDs[j] })
+			info.NodeShards[server] = shardIDs
+		}
+		result[volumeID] = info
+	}
+
+	return result
+}
+
+func (r *runner) selectCleanupCandidates(ecVolumes map[uint32]*ecVolumeInfo) []ecCleanupCandidate {
+	now := time.Now()
+
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	for volumeID := range ecVolumes {
+		if _, exists := r.ecFirstSeenAt[volumeID]; !exists {
+			r.ecFirstSeenAt[volumeID] = now
+		}
+	}
+	for volumeID := range r.ecFirstSeenAt {
+		if _, exists := ecVolumes[volumeID]; !exists {
+			delete(r.ecFirstSeenAt, volumeID)
+		}
+	}
+
+	candidates := make([]ecCleanupCandidate, 0, len(ecVolumes))
+	for volumeID, info := range ecVolumes {
+		firstSeenAt := r.ecFirstSeenAt[volumeID]
+		if r.cfg.EcMinAge > 0 && now.Sub(firstSeenAt) < r.cfg.EcMinAge {
+			continue
+		}
+		candidates = append(candidates, ecCleanupCandidate{
+			VolumeID:    volumeID,
+			FirstSeenAt: firstSeenAt,
+			Info:        info,
+		})
+	}
+
+	sort.Slice(candidates, func(i, j int) bool {
+		if candidates[i].FirstSeenAt.Equal(candidates[j].FirstSeenAt) {
+			return candidates[i].VolumeID < candidates[j].VolumeID
+		}
+		return candidates[i].FirstSeenAt.Before(candidates[j].FirstSeenAt)
+	})
+
+	if len(candidates) > r.cfg.MaxCleanupPerCycle {
+		candidates = candidates[:r.cfg.MaxCleanupPerCycle]
+	}
+	return candidates
+}
+
+func (r *runner) deleteEcVolume(ctx context.Context, volumeID uint32, info *ecVolumeInfo) error {
+	if info == nil {
+		return fmt.Errorf("ec volume %d has no topology info", volumeID)
+	}
+
+	failureCount := 0
+	for server, shardIDs := range info.NodeShards {
+		err := pb.WithVolumeServerClient(false, server, r.grpcDialOption, func(client volume_server_pb.VolumeServerClient) error {
+			unmountCtx, unmountCancel := context.WithTimeout(ctx, r.cfg.RequestTimeout)
+			defer unmountCancel()
+			if _, err := client.VolumeEcShardsUnmount(unmountCtx, &volume_server_pb.VolumeEcShardsUnmountRequest{
+				VolumeId: volumeID,
+				ShardIds: shardIDs,
+			}); err != nil {
+				log.Printf("volume %d ec shards unmount on %s failed: %v", volumeID, server, err)
+			}
+
+			if len(shardIDs) > 0 {
+				deleteCtx, deleteCancel := context.WithTimeout(ctx, r.cfg.RequestTimeout)
+				defer deleteCancel()
+				if _, err := client.VolumeEcShardsDelete(deleteCtx, &volume_server_pb.VolumeEcShardsDeleteRequest{
+					VolumeId:   volumeID,
+					Collection: r.cfg.Collection,
+					ShardIds:   shardIDs,
+				}); err != nil {
+					return err
+				}
+			}
+
+			finalDeleteCtx, finalDeleteCancel := context.WithTimeout(ctx, r.cfg.RequestTimeout)
+			defer finalDeleteCancel()
+			if _, err := client.VolumeDelete(finalDeleteCtx, &volume_server_pb.VolumeDeleteRequest{
+				VolumeId: volumeID,
+			}); err != nil {
+				log.Printf("volume %d delete on %s failed: %v", volumeID, server, err)
+			}
+			return nil
+		})
+
+		if err != nil {
+			failureCount++
+			log.Printf("cleanup volume=%d server=%s shards=%v failed: %v", volumeID, server, shardIDs, err)
+		}
+	}
+
+	if failureCount == len(info.NodeShards) && failureCount > 0 {
+		return fmt.Errorf("all shard deletions failed for volume %d", volumeID)
+	}
+	if failureCount > 0 {
+		return fmt.Errorf("partial shard deletion failure for volume %d", volumeID)
+	}
+	return nil
+}
+
+func (r *runner) nextSequence() int64 {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.sequence++
+	return r.sequence
+}
+
+func splitNonEmpty(value string) []string {
+	parts := strings.Split(value, ",")
+	result := make([]string, 0, len(parts))
+	for _, part := range parts {
+		trimmed := strings.TrimSpace(part)
+		if trimmed != "" {
+			result = append(result, trimmed)
+		}
+	}
+	return result
+}
+
+func ensureLeadingSlash(value string) string {
+	if value == "" {
+		return "/"
+	}
+	if strings.HasPrefix(value, "/") {
+		return value
+	}
+	return "/" + value
+}

weed/Makefile

@@ -9,6 +9,14 @@ all: install
 install:
 	go install -ldflags="-s -w"
 
+.PHONY: weed-db weed-sql
+
+weed-db:
+	go build -ldflags="-s -w" -o weed-db ./cmd/weed-db
+
+weed-sql:
+	go build -ldflags="-s -w" -o weed-sql ./cmd/weed-sql
+
 build_docker:
 	CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w"
 

weed/admin/Makefile

@@ -23,7 +23,7 @@ install-templ:
 .PHONY: generate
 generate: install-templ
 	@echo "Generating templ files..."
-	@cd $(BUILD_DIR) && templ generate
+	@templ generate ./view
 	@echo "Generated: $(TEMPL_GO_FILES)"
 
 # Clean generated files

weed/admin/dash/admin_data.go

@@ -6,10 +6,10 @@ 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"
+	"github.com/seaweedfs/seaweedfs/weed/pb"
 	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
 )
 
@@ -184,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
@@ -233,7 +233,7 @@ func (s *AdminServer) getMasterNodesStatus() []MasterNode {
 	currentMaster := s.masterClient.GetMaster(context.Background())
 	if currentMaster != "" {
 		masterNodes = append(masterNodes, MasterNode{
-			Address:  string(currentMaster),
+			Address:  pb.ServerAddress(currentMaster).ToHttpAddress(),
 			IsLeader: isLeader,
 		})
 	}

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/config_persistence.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/seaweedfs/seaweedfs/weed/admin/maintenance"
@@ -87,6 +88,11 @@ func isValidTaskID(taskID string) bool {
 // ConfigPersistence handles saving and loading configuration files
 type ConfigPersistence struct {
 	dataDir string
+	// tasksMu serializes all filesystem operations on the tasks/ directory.
+	// SaveTaskState, LoadTaskState, LoadAllTaskStates, DeleteTaskState, and
+	// CleanupCompletedTasks are called from multiple goroutines concurrently
+	// after saveTaskState was moved outside mq.mutex in the maintenance queue.
+	tasksMu sync.Mutex
 }
 
 // NewConfigPersistence creates a new configuration persistence manager
@@ -937,6 +943,8 @@ func (cp *ConfigPersistence) ListTaskDetails() ([]string, error) {
 
 // CleanupCompletedTasks removes old completed tasks beyond the retention limit
 func (cp *ConfigPersistence) CleanupCompletedTasks() error {
+	cp.tasksMu.Lock()
+	defer cp.tasksMu.Unlock()
 	if cp.dataDir == "" {
 		return fmt.Errorf("no data directory specified, cannot cleanup completed tasks")
 	}
@@ -946,8 +954,8 @@ func (cp *ConfigPersistence) CleanupCompletedTasks() error {
 		return nil // No tasks directory, nothing to cleanup
 	}
 
-	// Load all tasks and find completed/failed ones
-	allTasks, err := cp.LoadAllTaskStates()
+	// Use unlocked helpers to avoid deadlock (tasksMu is already held)
+	allTasks, err := cp.loadAllTaskStatesLocked()
 	if err != nil {
 		return fmt.Errorf("failed to load tasks for cleanup: %w", err)
 	}
@@ -998,7 +1006,7 @@ func (cp *ConfigPersistence) CleanupCompletedTasks() error {
 	if len(completedTasks) > MaxCompletedTasks {
 		tasksToDelete := completedTasks[MaxCompletedTasks:]
 		for _, task := range tasksToDelete {
-			if err := cp.DeleteTaskState(task.ID); err != nil {
+			if err := cp.deleteTaskStateLocked(task.ID); err != nil {
 				glog.Warningf("Failed to delete old completed task %s: %v", task.ID, err)
 			} else {
 				glog.V(2).Infof("Cleaned up old completed task %s (completed: %v)", task.ID, task.CompletedAt)
@@ -1012,6 +1020,8 @@ func (cp *ConfigPersistence) CleanupCompletedTasks() error {
 
 // SaveTaskState saves a task state to protobuf file
 func (cp *ConfigPersistence) SaveTaskState(task *maintenance.MaintenanceTask) error {
+	cp.tasksMu.Lock()
+	defer cp.tasksMu.Unlock()
 	if cp.dataDir == "" {
 		return fmt.Errorf("no data directory specified, cannot save task state")
 	}
@@ -1051,6 +1061,13 @@ func (cp *ConfigPersistence) SaveTaskState(task *maintenance.MaintenanceTask) er
 
 // LoadTaskState loads a task state from protobuf file
 func (cp *ConfigPersistence) LoadTaskState(taskID string) (*maintenance.MaintenanceTask, error) {
+	cp.tasksMu.Lock()
+	defer cp.tasksMu.Unlock()
+	return cp.loadTaskStateLocked(taskID)
+}
+
+// loadTaskStateLocked loads a single task state. Must be called with tasksMu held.
+func (cp *ConfigPersistence) loadTaskStateLocked(taskID string) (*maintenance.MaintenanceTask, error) {
 	if cp.dataDir == "" {
 		return nil, fmt.Errorf("no data directory specified, cannot load task state")
 	}
@@ -1084,6 +1101,13 @@ func (cp *ConfigPersistence) LoadTaskState(taskID string) (*maintenance.Maintena
 
 // LoadAllTaskStates loads all task states from disk
 func (cp *ConfigPersistence) LoadAllTaskStates() ([]*maintenance.MaintenanceTask, error) {
+	cp.tasksMu.Lock()
+	defer cp.tasksMu.Unlock()
+	return cp.loadAllTaskStatesLocked()
+}
+
+// loadAllTaskStatesLocked loads all task states from disk. Must be called with tasksMu held.
+func (cp *ConfigPersistence) loadAllTaskStatesLocked() ([]*maintenance.MaintenanceTask, error) {
 	if cp.dataDir == "" {
 		return []*maintenance.MaintenanceTask{}, nil
 	}
@@ -1102,7 +1126,7 @@ func (cp *ConfigPersistence) LoadAllTaskStates() ([]*maintenance.MaintenanceTask
 	for _, entry := range entries {
 		if !entry.IsDir() && filepath.Ext(entry.Name()) == ".pb" {
 			taskID := entry.Name()[:len(entry.Name())-3] // Remove .pb extension
-			task, err := cp.LoadTaskState(taskID)
+			task, err := cp.loadTaskStateLocked(taskID)
 			if err != nil {
 				glog.Warningf("Failed to load task state for %s: %v", taskID, err)
 				continue
@@ -1117,6 +1141,13 @@ func (cp *ConfigPersistence) LoadAllTaskStates() ([]*maintenance.MaintenanceTask
 
 // DeleteTaskState removes a task state file from disk
 func (cp *ConfigPersistence) DeleteTaskState(taskID string) error {
+	cp.tasksMu.Lock()
+	defer cp.tasksMu.Unlock()
+	return cp.deleteTaskStateLocked(taskID)
+}
+
+// deleteTaskStateLocked removes a task state file. Must be called with tasksMu held.
+func (cp *ConfigPersistence) deleteTaskStateLocked(taskID string) error {
 	if cp.dataDir == "" {
 		return fmt.Errorf("no data directory specified, cannot delete task state")
 	}

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/ec_shard_management.go

@@ -6,10 +6,7 @@ import (
 	"sort"
 	"time"
 
-	"github.com/seaweedfs/seaweedfs/weed/glog"
-	"github.com/seaweedfs/seaweedfs/weed/pb"
 	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
-	"github.com/seaweedfs/seaweedfs/weed/pb/volume_server_pb"
 	"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding"
 )
 
@@ -333,10 +330,19 @@ func (s *AdminServer) GetClusterEcVolumes(page int, pageSize int, sortBy string,
 
 								// Process each shard this server has for this volume
 								shardBits := ecShardInfo.EcIndexBits
+								shardSizes := ecShardInfo.ShardSizes
+								sizeIndex := 0
 								for shardId := 0; shardId < erasure_coding.MaxShardCount; shardId++ {
 									if (shardBits & (1 << uint(shardId))) != 0 {
 										// Record shard location
 										volume.ShardLocations[shardId] = node.Id
+										if sizeIndex < len(shardSizes) {
+											size := shardSizes[sizeIndex]
+											if size >= 0 {
+												volume.ShardSizes[shardId] = size
+											}
+										}
+										sizeIndex++
 										totalShards++
 									}
 								}
@@ -354,38 +360,6 @@ func (s *AdminServer) GetClusterEcVolumes(page int, pageSize int, sortBy string,
 		return nil, err
 	}
 
-	// Collect shard size information from volume servers
-	for volumeId, volume := range volumeData {
-		// Group servers by volume to minimize gRPC calls
-		serverHasVolume := make(map[string]bool)
-		for _, server := range volume.Servers {
-			serverHasVolume[server] = true
-		}
-
-		// Query each server for shard sizes
-		for server := range serverHasVolume {
-			err := s.WithVolumeServerClient(pb.ServerAddress(server), func(client volume_server_pb.VolumeServerClient) error {
-				resp, err := client.VolumeEcShardsInfo(context.Background(), &volume_server_pb.VolumeEcShardsInfoRequest{
-					VolumeId: volumeId,
-				})
-				if err != nil {
-					glog.V(1).Infof("Failed to get EC shard info from %s for volume %d: %v", server, volumeId, err)
-					return nil // Continue with other servers, don't fail the entire request
-				}
-
-				// Update shard sizes
-				for _, shardInfo := range resp.EcShardInfos {
-					volume.ShardSizes[int(shardInfo.ShardId)] = shardInfo.Size
-				}
-
-				return nil
-			})
-			if err != nil {
-				glog.V(1).Infof("Failed to connect to volume server %s: %v", server, err)
-			}
-		}
-	}
-
 	// Calculate completeness for each volume
 	completeVolumes := 0
 	incompleteVolumes := 0
@@ -616,13 +590,23 @@ func (s *AdminServer) GetEcVolumeDetails(volumeID uint32, sortBy string, sortOrd
 
 									// Create individual shard entries for each shard this server has
 									shardBits := ecShardInfo.EcIndexBits
+									shardSizes := ecShardInfo.ShardSizes
+									sizeIndex := 0
 									for shardId := 0; shardId < erasure_coding.MaxShardCount; shardId++ {
 										if (shardBits & (1 << uint(shardId))) != 0 {
+											var shardSize uint64
+											if sizeIndex < len(shardSizes) {
+												size := shardSizes[sizeIndex]
+												if size >= 0 {
+													shardSize = uint64(size)
+												}
+											}
+											sizeIndex++
 											ecShard := EcShardWithInfo{
 												VolumeID:     ecShardInfo.Id,
 												ShardID:      uint32(shardId),
 												Collection:   ecShardInfo.Collection,
-												Size:         0, // EC shards don't have individual size in the API response
+												Size:         shardSize,
 												Server:       node.Id,
 												DataCenter:   dc.Id,
 												Rack:         rack.Id,
@@ -653,46 +637,6 @@ func (s *AdminServer) GetEcVolumeDetails(volumeID uint32, sortBy string, sortOrd
 		return nil, fmt.Errorf("EC volume %d not found", volumeID)
 	}
 
-	// Collect shard size information from volume servers
-	shardSizeMap := make(map[string]map[uint32]uint64) // server -> shardId -> size
-	for _, shard := range shards {
-		server := shard.Server
-		if _, exists := shardSizeMap[server]; !exists {
-			// Query this server for shard sizes
-			err := s.WithVolumeServerClient(pb.ServerAddress(server), func(client volume_server_pb.VolumeServerClient) error {
-				resp, err := client.VolumeEcShardsInfo(context.Background(), &volume_server_pb.VolumeEcShardsInfoRequest{
-					VolumeId: volumeID,
-				})
-				if err != nil {
-					glog.V(1).Infof("Failed to get EC shard info from %s for volume %d: %v", server, volumeID, err)
-					return nil // Continue with other servers, don't fail the entire request
-				}
-
-				// Store shard sizes for this server
-				shardSizeMap[server] = make(map[uint32]uint64)
-				for _, shardInfo := range resp.EcShardInfos {
-					shardSizeMap[server][shardInfo.ShardId] = uint64(shardInfo.Size)
-				}
-
-				return nil
-			})
-			if err != nil {
-				glog.V(1).Infof("Failed to connect to volume server %s: %v", server, err)
-			}
-		}
-	}
-
-	// Update shard sizes in the shards array
-	for i := range shards {
-		server := shards[i].Server
-		shardId := shards[i].ShardID
-		if serverSizes, exists := shardSizeMap[server]; exists {
-			if size, exists := serverSizes[shardId]; exists {
-				shards[i].Size = size
-			}
-		}
-	}
-
 	// Calculate completeness based on unique shard IDs
 	foundShards := make(map[int]bool)
 	for _, shard := range shards {

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

@@ -0,0 +1,740 @@
+package dash
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"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"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+const (
+	defaultPluginDetectionTimeout = 45 * time.Second
+	defaultPluginExecutionTimeout = 90 * time.Second
+	maxPluginDetectionTimeout     = 5 * time.Minute
+	maxPluginExecutionTimeout     = 10 * time.Minute
+	defaultPluginRunTimeout       = 5 * time.Minute
+	maxPluginRunTimeout           = 30 * time.Minute
+)
+
+// GetPluginStatusAPI returns plugin status.
+func (s *AdminServer) GetPluginStatusAPI(w http.ResponseWriter, r *http.Request) {
+	plugin := s.GetPlugin()
+	if plugin == nil {
+		writeJSON(w, http.StatusOK, map[string]interface{}{
+			"enabled":          false,
+			"worker_grpc_port": s.GetWorkerGrpcPort(),
+		})
+		return
+	}
+
+	writeJSON(w, http.StatusOK, map[string]interface{}{
+		"enabled":          true,
+		"configured":       plugin.IsConfigured(),
+		"base_dir":         plugin.BaseDir(),
+		"worker_count":     len(plugin.ListWorkers()),
+		"worker_grpc_port": s.GetWorkerGrpcPort(),
+	})
+}
+
+// GetPluginWorkersAPI returns currently connected plugin workers.
+func (s *AdminServer) GetPluginWorkersAPI(w http.ResponseWriter, r *http.Request) {
+	workers := s.GetPluginWorkers()
+	if workers == nil {
+		writeJSON(w, http.StatusOK, []interface{}{})
+		return
+	}
+	writeJSON(w, http.StatusOK, workers)
+}
+
+// GetPluginJobTypesAPI returns known plugin job types from workers and persisted data.
+func (s *AdminServer) GetPluginJobTypesAPI(w http.ResponseWriter, r *http.Request) {
+	jobTypes, err := s.ListPluginJobTypes()
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if jobTypes == nil {
+		writeJSON(w, http.StatusOK, []interface{}{})
+		return
+	}
+	writeJSON(w, http.StatusOK, jobTypes)
+}
+
+// GetPluginJobsAPI returns tracked jobs for monitoring.
+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 {
+		writeJSON(w, http.StatusOK, []interface{}{})
+		return
+	}
+	writeJSON(w, http.StatusOK, jobs)
+}
+
+// GetPluginJobAPI returns one tracked job.
+func (s *AdminServer) GetPluginJobAPI(w http.ResponseWriter, r *http.Request) {
+	jobID := strings.TrimSpace(mux.Vars(r)["jobId"])
+	if jobID == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobId is required")
+		return
+	}
+
+	job, found := s.GetPluginJob(jobID)
+	if !found {
+		writeJSONError(w, http.StatusNotFound, "job not found")
+		return
+	}
+	writeJSON(w, http.StatusOK, job)
+}
+
+// GetPluginJobDetailAPI returns detailed information for one tracked plugin job.
+func (s *AdminServer) GetPluginJobDetailAPI(w http.ResponseWriter, r *http.Request) {
+	jobID := strings.TrimSpace(mux.Vars(r)["jobId"])
+	if jobID == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobId is required")
+		return
+	}
+
+	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 {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if !found || detail == nil {
+		writeJSONError(w, http.StatusNotFound, "job detail not found")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, detail)
+}
+
+// GetPluginActivitiesAPI returns recent plugin activities.
+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 {
+		writeJSON(w, http.StatusOK, []interface{}{})
+		return
+	}
+	writeJSON(w, http.StatusOK, activities)
+}
+
+// GetPluginSchedulerStatesAPI returns per-job-type scheduler status for monitoring.
+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 {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	if jobTypeFilter != "" {
+		filtered := make([]interface{}, 0, len(states))
+		for _, state := range states {
+			if state.JobType == jobTypeFilter {
+				filtered = append(filtered, state)
+			}
+		}
+		writeJSON(w, http.StatusOK, filtered)
+		return
+	}
+
+	if states == nil {
+		writeJSON(w, http.StatusOK, []interface{}{})
+		return
+	}
+
+	writeJSON(w, http.StatusOK, states)
+}
+
+// RequestPluginJobTypeSchemaAPI asks a worker for one job type schema.
+func (s *AdminServer) RequestPluginJobTypeSchemaAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
+	if jobType == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
+		return
+	}
+
+	forceRefresh := strings.EqualFold(r.URL.Query().Get("force_refresh"), "true")
+
+	ctx, cancel := context.WithTimeout(r.Context(), defaultPluginDetectionTimeout)
+	defer cancel()
+	descriptor, err := s.RequestPluginJobTypeDescriptor(ctx, jobType, forceRefresh)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	renderProtoJSON(w, http.StatusOK, descriptor)
+}
+
+// GetPluginJobTypeDescriptorAPI returns persisted descriptor for a job type.
+func (s *AdminServer) GetPluginJobTypeDescriptorAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
+	if jobType == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
+		return
+	}
+
+	descriptor, err := s.LoadPluginJobTypeDescriptor(jobType)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if descriptor == nil {
+		writeJSONError(w, http.StatusNotFound, "descriptor not found")
+		return
+	}
+
+	renderProtoJSON(w, http.StatusOK, descriptor)
+}
+
+// GetPluginJobTypeConfigAPI loads persisted config for a job type.
+func (s *AdminServer) GetPluginJobTypeConfigAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
+	if jobType == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
+		return
+	}
+
+	config, err := s.LoadPluginJobTypeConfig(jobType)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if config == nil {
+		config = &plugin_pb.PersistedJobTypeConfig{
+			JobType:            jobType,
+			AdminConfigValues:  map[string]*plugin_pb.ConfigValue{},
+			WorkerConfigValues: map[string]*plugin_pb.ConfigValue{},
+			AdminRuntime:       &plugin_pb.AdminRuntimeConfig{},
+		}
+	}
+
+	renderProtoJSON(w, http.StatusOK, config)
+}
+
+// UpdatePluginJobTypeConfigAPI stores persisted config for a job type.
+func (s *AdminServer) UpdatePluginJobTypeConfigAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
+	if jobType == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
+		return
+	}
+
+	config := &plugin_pb.PersistedJobTypeConfig{}
+	if err := parseProtoJSONBody(w, r, config); err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	config.JobType = jobType
+	if config.UpdatedAt == nil {
+		config.UpdatedAt = timestamppb.Now()
+	}
+	if config.AdminRuntime == nil {
+		config.AdminRuntime = &plugin_pb.AdminRuntimeConfig{}
+	}
+	if config.AdminConfigValues == nil {
+		config.AdminConfigValues = map[string]*plugin_pb.ConfigValue{}
+	}
+	if config.WorkerConfigValues == nil {
+		config.WorkerConfigValues = map[string]*plugin_pb.ConfigValue{}
+	}
+
+	username := UsernameFromContext(r.Context())
+	if username == "" {
+		username = "admin"
+	}
+	config.UpdatedBy = username
+
+	if err := s.SavePluginJobTypeConfig(config); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	renderProtoJSON(w, http.StatusOK, config)
+}
+
+// GetPluginRunHistoryAPI returns bounded run history for a job type.
+func (s *AdminServer) GetPluginRunHistoryAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
+	if jobType == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
+		return
+	}
+
+	history, err := s.GetPluginRunHistory(jobType)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	if history == nil {
+		writeJSON(w, http.StatusOK, map[string]interface{}{
+			"job_type":          jobType,
+			"successful_runs":   []interface{}{},
+			"error_runs":        []interface{}{},
+			"last_updated_time": nil,
+		})
+		return
+	}
+
+	writeJSON(w, http.StatusOK, history)
+}
+
+// TriggerPluginDetectionAPI runs one detector for this job type and returns proposals.
+func (s *AdminServer) TriggerPluginDetectionAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
+	if jobType == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
+		return
+	}
+
+	var req struct {
+		ClusterContext json.RawMessage `json:"cluster_context"`
+		MaxResults     int32           `json:"max_results"`
+		TimeoutSeconds int             `json:"timeout_seconds"`
+	}
+
+	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 {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	timeout := normalizeTimeout(req.TimeoutSeconds, defaultPluginDetectionTimeout, maxPluginDetectionTimeout)
+	ctx, cancel := context.WithTimeout(r.Context(), timeout)
+	defer cancel()
+
+	report, err := s.RunPluginDetectionWithReport(ctx, jobType, clusterContext, req.MaxResults)
+	proposals := make([]*plugin_pb.JobProposal, 0)
+	requestID := ""
+	detectorWorkerID := ""
+	totalProposals := int32(0)
+	if report != nil {
+		proposals = report.Proposals
+		requestID = report.RequestID
+		detectorWorkerID = report.WorkerID
+		if report.Complete != nil {
+			totalProposals = report.Complete.TotalProposals
+		}
+	}
+
+	proposalPayloads := make([]map[string]interface{}, 0, len(proposals))
+	for _, proposal := range proposals {
+		payload, marshalErr := protoMessageToMap(proposal)
+		if marshalErr != nil {
+			glog.Warningf("failed to marshal proposal for jobType=%s: %v", jobType, marshalErr)
+			continue
+		}
+		proposalPayloads = append(proposalPayloads, payload)
+	}
+
+	sort.Slice(proposalPayloads, func(i, j int) bool {
+		iPriorityStr, _ := proposalPayloads[i]["priority"].(string)
+		jPriorityStr, _ := proposalPayloads[j]["priority"].(string)
+
+		iPriority := plugin_pb.JobPriority_value[iPriorityStr]
+		jPriority := plugin_pb.JobPriority_value[jPriorityStr]
+
+		if iPriority != jPriority {
+			return iPriority > jPriority
+		}
+		iID, _ := proposalPayloads[i]["proposal_id"].(string)
+		jID, _ := proposalPayloads[j]["proposal_id"].(string)
+		return iID < jID
+	})
+
+	activities := s.ListPluginActivities(jobType, 500)
+	filteredActivities := make([]interface{}, 0, len(activities))
+	if requestID != "" {
+		for i := len(activities) - 1; i >= 0; i-- {
+			activity := activities[i]
+			if activity.RequestID != requestID {
+				continue
+			}
+			filteredActivities = append(filteredActivities, activity)
+		}
+	}
+
+	response := map[string]interface{}{
+		"job_type":           jobType,
+		"request_id":         requestID,
+		"detector_worker_id": detectorWorkerID,
+		"total_proposals":    totalProposals,
+		"count":              len(proposalPayloads),
+		"proposals":          proposalPayloads,
+		"activities":         filteredActivities,
+	}
+
+	if err != nil {
+		response["error"] = err.Error()
+		writeJSON(w, http.StatusInternalServerError, response)
+		return
+	}
+
+	writeJSON(w, http.StatusOK, response)
+}
+
+// RunPluginJobTypeAPI runs full workflow for one job type: detect then dispatch detected jobs.
+func (s *AdminServer) RunPluginJobTypeAPI(w http.ResponseWriter, r *http.Request) {
+	jobType := strings.TrimSpace(mux.Vars(r)["jobType"])
+	if jobType == "" {
+		writeJSONError(w, http.StatusBadRequest, "jobType is required")
+		return
+	}
+
+	var req struct {
+		ClusterContext json.RawMessage `json:"cluster_context"`
+		MaxResults     int32           `json:"max_results"`
+		TimeoutSeconds int             `json:"timeout_seconds"`
+		Attempt        int32           `json:"attempt"`
+	}
+
+	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 {
+		req.Attempt = 1
+	}
+
+	clusterContext, err := s.parseOrBuildClusterContext(req.ClusterContext)
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	timeout := normalizeTimeout(req.TimeoutSeconds, defaultPluginRunTimeout, maxPluginRunTimeout)
+	ctx, cancel := context.WithTimeout(r.Context(), timeout)
+	defer cancel()
+
+	proposals, err := s.RunPluginDetection(ctx, jobType, clusterContext, req.MaxResults)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	detectedCount := len(proposals)
+
+	filteredProposals, skippedActiveCount, err := s.FilterPluginProposalsWithActiveJobs(jobType, proposals)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	type executionResult struct {
+		JobID      string                 `json:"job_id"`
+		Success    bool                   `json:"success"`
+		Error      string                 `json:"error,omitempty"`
+		Completion map[string]interface{} `json:"completion,omitempty"`
+	}
+
+	results := make([]executionResult, 0, len(filteredProposals))
+	successCount := 0
+	errorCount := 0
+
+	for index, proposal := range filteredProposals {
+		job := buildJobSpecFromProposal(jobType, proposal, index)
+		completed, execErr := s.ExecutePluginJob(ctx, job, clusterContext, req.Attempt)
+
+		result := executionResult{
+			JobID:   job.JobId,
+			Success: execErr == nil,
+		}
+
+		if completed != nil {
+			if payload, marshalErr := protoMessageToMap(completed); marshalErr == nil {
+				result.Completion = payload
+			}
+		}
+
+		if execErr != nil {
+			result.Error = execErr.Error()
+			errorCount++
+		} else {
+			successCount++
+		}
+
+		results = append(results, result)
+	}
+
+	writeJSON(w, http.StatusOK, map[string]interface{}{
+		"job_type":               jobType,
+		"detected_count":         detectedCount,
+		"ready_to_execute_count": len(filteredProposals),
+		"skipped_active_count":   skippedActiveCount,
+		"executed_count":         len(results),
+		"success_count":          successCount,
+		"error_count":            errorCount,
+		"execution_results":      results,
+	})
+}
+
+// ExecutePluginJobAPI executes one job on a capable worker and waits for completion.
+func (s *AdminServer) ExecutePluginJobAPI(w http.ResponseWriter, r *http.Request) {
+	var req struct {
+		Job            json.RawMessage `json:"job"`
+		ClusterContext json.RawMessage `json:"cluster_context"`
+		Attempt        int32           `json:"attempt"`
+		TimeoutSeconds int             `json:"timeout_seconds"`
+	}
+
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "invalid request body: "+err.Error())
+		return
+	}
+	if len(req.Job) == 0 {
+		writeJSONError(w, http.StatusBadRequest, "job is required")
+		return
+	}
+
+	job := &plugin_pb.JobSpec{}
+	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}).Unmarshal(req.Job, job); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "invalid job payload: "+err.Error())
+		return
+	}
+
+	clusterContext, err := s.parseOrBuildClusterContext(req.ClusterContext)
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	if req.Attempt < 1 {
+		req.Attempt = 1
+	}
+
+	timeout := normalizeTimeout(req.TimeoutSeconds, defaultPluginExecutionTimeout, maxPluginExecutionTimeout)
+	ctx, cancel := context.WithTimeout(r.Context(), timeout)
+	defer cancel()
+
+	completed, err := s.ExecutePluginJob(ctx, job, clusterContext, req.Attempt)
+	if err != nil {
+		if completed != nil {
+			payload, marshalErr := protoMessageToMap(completed)
+			if marshalErr == nil {
+				writeJSON(w, http.StatusInternalServerError, map[string]interface{}{"error": err.Error(), "completion": payload})
+				return
+			}
+		}
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	renderProtoJSON(w, http.StatusOK, completed)
+}
+
+func (s *AdminServer) parseOrBuildClusterContext(raw json.RawMessage) (*plugin_pb.ClusterContext, error) {
+	if len(raw) == 0 {
+		return s.buildDefaultPluginClusterContext(), nil
+	}
+
+	contextMessage := &plugin_pb.ClusterContext{}
+	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}).Unmarshal(raw, contextMessage); err != nil {
+		return nil, fmt.Errorf("invalid cluster_context payload: %w", err)
+	}
+
+	fallback := s.buildDefaultPluginClusterContext()
+	if len(contextMessage.MasterGrpcAddresses) == 0 {
+		contextMessage.MasterGrpcAddresses = append(contextMessage.MasterGrpcAddresses, fallback.MasterGrpcAddresses...)
+	}
+	if len(contextMessage.FilerGrpcAddresses) == 0 {
+		contextMessage.FilerGrpcAddresses = append(contextMessage.FilerGrpcAddresses, fallback.FilerGrpcAddresses...)
+	}
+	if len(contextMessage.VolumeGrpcAddresses) == 0 {
+		contextMessage.VolumeGrpcAddresses = append(contextMessage.VolumeGrpcAddresses, fallback.VolumeGrpcAddresses...)
+	}
+	if contextMessage.Metadata == nil {
+		contextMessage.Metadata = map[string]string{}
+	}
+	contextMessage.Metadata["source"] = "admin"
+
+	return contextMessage, nil
+}
+
+func (s *AdminServer) buildDefaultPluginClusterContext() *plugin_pb.ClusterContext {
+	clusterContext := &plugin_pb.ClusterContext{
+		MasterGrpcAddresses: make([]string, 0),
+		FilerGrpcAddresses:  make([]string, 0),
+		VolumeGrpcAddresses: make([]string, 0),
+		Metadata: map[string]string{
+			"source": "admin",
+		},
+	}
+
+	masterAddress := string(s.masterClient.GetMaster(context.Background()))
+	if masterAddress != "" {
+		clusterContext.MasterGrpcAddresses = append(clusterContext.MasterGrpcAddresses, masterAddress)
+	}
+
+	filerSeen := map[string]struct{}{}
+	for _, filer := range s.GetAllFilers() {
+		filer = strings.TrimSpace(filer)
+		if filer == "" {
+			continue
+		}
+		if _, exists := filerSeen[filer]; exists {
+			continue
+		}
+		filerSeen[filer] = struct{}{}
+		clusterContext.FilerGrpcAddresses = append(clusterContext.FilerGrpcAddresses, filer)
+	}
+
+	volumeSeen := map[string]struct{}{}
+	if volumeServers, err := s.GetClusterVolumeServers(); err == nil {
+		for _, server := range volumeServers.VolumeServers {
+			address := strings.TrimSpace(server.GetDisplayAddress())
+			if address == "" {
+				address = strings.TrimSpace(server.Address)
+			}
+			if address == "" {
+				continue
+			}
+			if _, exists := volumeSeen[address]; exists {
+				continue
+			}
+			volumeSeen[address] = struct{}{}
+			clusterContext.VolumeGrpcAddresses = append(clusterContext.VolumeGrpcAddresses, address)
+		}
+	} else {
+		glog.V(1).Infof("failed to build default plugin volume context: %v", err)
+	}
+
+	sort.Strings(clusterContext.MasterGrpcAddresses)
+	sort.Strings(clusterContext.FilerGrpcAddresses)
+	sort.Strings(clusterContext.VolumeGrpcAddresses)
+
+	return clusterContext
+}
+
+const parseProtoJSONBodyMaxBytes = 1 << 20 // 1 MB
+
+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)
+	}
+	if len(data) == 0 {
+		return fmt.Errorf("request body is empty")
+	}
+	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}).Unmarshal(data, message); err != nil {
+		return fmt.Errorf("invalid protobuf json: %w", err)
+	}
+	return nil
+}
+
+func renderProtoJSON(w http.ResponseWriter, statusCode int, message proto.Message) {
+	payload, err := protojson.MarshalOptions{
+		UseProtoNames:   true,
+		EmitUnpopulated: true,
+	}.Marshal(message)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "failed to encode response: "+err.Error())
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(statusCode)
+	_, _ = w.Write(payload)
+}
+
+func protoMessageToMap(message proto.Message) (map[string]interface{}, error) {
+	payload, err := protojson.MarshalOptions{UseProtoNames: true}.Marshal(message)
+	if err != nil {
+		return nil, err
+	}
+	out := map[string]interface{}{}
+	if err := json.Unmarshal(payload, &out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func normalizeTimeout(timeoutSeconds int, defaultTimeout, maxTimeout time.Duration) time.Duration {
+	if timeoutSeconds <= 0 {
+		return defaultTimeout
+	}
+	timeout := time.Duration(timeoutSeconds) * time.Second
+	if timeout > maxTimeout {
+		return maxTimeout
+	}
+	return timeout
+}
+
+func buildJobSpecFromProposal(jobType string, proposal *plugin_pb.JobProposal, index int) *plugin_pb.JobSpec {
+	now := timestamppb.Now()
+	suffix := make([]byte, 4)
+	if _, err := rand.Read(suffix); err != nil {
+		// Fallback to simpler ID if rand fails
+		suffix = []byte(fmt.Sprintf("%d", index))
+	}
+	jobID := fmt.Sprintf("%s-%d-%s", jobType, now.AsTime().UnixNano(), hex.EncodeToString(suffix))
+
+	jobSpec := &plugin_pb.JobSpec{
+		JobId:      jobID,
+		JobType:    jobType,
+		Priority:   plugin_pb.JobPriority_JOB_PRIORITY_NORMAL,
+		CreatedAt:  now,
+		Labels:     make(map[string]string),
+		Parameters: make(map[string]*plugin_pb.ConfigValue),
+		DedupeKey:  "",
+	}
+
+	if proposal != nil {
+		jobSpec.Summary = proposal.Summary
+		jobSpec.Detail = proposal.Detail
+		if proposal.Priority != plugin_pb.JobPriority_JOB_PRIORITY_UNSPECIFIED {
+			jobSpec.Priority = proposal.Priority
+		}
+		jobSpec.DedupeKey = proposal.DedupeKey
+		jobSpec.Parameters = plugin.CloneConfigValueMap(proposal.Parameters)
+		if proposal.Labels != nil {
+			for k, v := range proposal.Labels {
+				jobSpec.Labels[k] = v
+			}
+		}
+	}
+
+	return jobSpec
+}
+
+func parsePositiveInt(raw string, defaultValue int) int {
+	value, err := strconv.Atoi(strings.TrimSpace(raw))
+	if err != nil || value <= 0 {
+		return defaultValue
+	}
+	return value
+}
+
+// cloneConfigValueMap is now exported by the plugin package as CloneConfigValueMap

weed/admin/dash/plugin_api_test.go

@@ -0,0 +1,33 @@
+package dash
+
+import (
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+func TestBuildJobSpecFromProposalDoesNotReuseProposalID(t *testing.T) {
+	t.Parallel()
+
+	proposal := &plugin_pb.JobProposal{
+		ProposalId: "vacuum-2",
+		DedupeKey:  "vacuum:2",
+		JobType:    "vacuum",
+	}
+
+	jobA := buildJobSpecFromProposal("vacuum", proposal, 0)
+	jobB := buildJobSpecFromProposal("vacuum", proposal, 1)
+
+	if jobA.JobId == proposal.ProposalId {
+		t.Fatalf("job id must not reuse proposal id: %s", jobA.JobId)
+	}
+	if jobB.JobId == proposal.ProposalId {
+		t.Fatalf("job id must not reuse proposal id: %s", jobB.JobId)
+	}
+	if jobA.JobId == jobB.JobId {
+		t.Fatalf("job ids must be unique across jobs: %s", jobA.JobId)
+	}
+	if jobA.DedupeKey != proposal.DedupeKey {
+		t.Fatalf("dedupe key must be preserved: got=%s want=%s", jobA.DedupeKey, proposal.DedupeKey)
+	}
+}

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 {

weed/admin/dash/worker_grpc_server.go

@@ -5,11 +5,11 @@ import (
 	"fmt"
 	"io"
 	"net"
+	"strconv"
 	"sync"
 	"time"
 
 	"github.com/seaweedfs/seaweedfs/weed/admin/maintenance"
-	"github.com/seaweedfs/seaweedfs/weed/admin/plugin"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/pb"
 	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
@@ -95,18 +95,9 @@ func (s *WorkerGrpcServer) StartWithTLS(port int) error {
 	grpcServer := pb.NewGrpcServer(security.LoadServerTLS(util.GetViper(), "grpc.admin"))
 
 	worker_pb.RegisterWorkerServiceServer(grpcServer, s)
-
-	// Register plugin service if plugin manager is available
-	if s.adminServer.GetPluginManager() != nil {
-		// Cast the interface{} to *plugin.Manager
-		if pm, ok := s.adminServer.GetPluginManager().(*plugin.Manager); ok {
-			if pluginGrpcServer := pm.GetGRPCServer(); pluginGrpcServer != nil {
-				plugin_pb.RegisterPluginServiceServer(grpcServer, pluginGrpcServer)
-				plugin_pb.RegisterAdminQueryServiceServer(grpcServer, pluginGrpcServer)
-				plugin_pb.RegisterAdminCommandServiceServer(grpcServer, pluginGrpcServer)
-				glog.Infof("Registered plugin services on worker gRPC server")
-			}
-		}
+	if plugin := s.adminServer.GetPlugin(); plugin != nil {
+		plugin_pb.RegisterPluginControlServiceServer(grpcServer, plugin)
+		glog.V(0).Infof("Plugin gRPC service registered on worker gRPC server")
 	}
 
 	s.grpcServer = grpcServer
@@ -129,6 +120,25 @@ func (s *WorkerGrpcServer) StartWithTLS(port int) error {
 	return nil
 }
 
+// ListenPort returns the currently bound worker gRPC listen port.
+func (s *WorkerGrpcServer) ListenPort() int {
+	if s == nil || s.listener == nil {
+		return 0
+	}
+	if tcpAddr, ok := s.listener.Addr().(*net.TCPAddr); ok {
+		return tcpAddr.Port
+	}
+	_, portStr, err := net.SplitHostPort(s.listener.Addr().String())
+	if err != nil {
+		return 0
+	}
+	port, err := strconv.Atoi(portStr)
+	if err != nil {
+		return 0
+	}
+	return port
+}
+
 // Stop stops the gRPC server
 func (s *WorkerGrpcServer) Stop() error {
 	if !s.running {

weed/admin/handlers/admin_handlers_routes_test.go

@@ -0,0 +1,93 @@
+package handlers
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/gorilla/sessions"
+	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
+)
+
+func TestSetupRoutes_RegistersPluginSchedulerStatesAPI_NoAuth(t *testing.T) {
+	router := mux.NewRouter()
+
+	newRouteTestAdminHandlers().SetupRoutes(router, false, "", "", "", "", true)
+
+	if !hasRoute(router, http.MethodGet, "/api/plugin/scheduler-states") {
+		t.Fatalf("expected GET /api/plugin/scheduler-states to be registered in no-auth mode")
+	}
+	if !hasRoute(router, http.MethodGet, "/api/plugin/jobs/example/detail") {
+		t.Fatalf("expected GET /api/plugin/jobs/:jobId/detail to be registered in no-auth mode")
+	}
+}
+
+func TestSetupRoutes_RegistersPluginSchedulerStatesAPI_WithAuth(t *testing.T) {
+	router := mux.NewRouter()
+
+	newRouteTestAdminHandlers().SetupRoutes(router, true, "admin", "password", "", "", true)
+
+	if !hasRoute(router, http.MethodGet, "/api/plugin/scheduler-states") {
+		t.Fatalf("expected GET /api/plugin/scheduler-states to be registered in auth mode")
+	}
+	if !hasRoute(router, http.MethodGet, "/api/plugin/jobs/example/detail") {
+		t.Fatalf("expected GET /api/plugin/jobs/:jobId/detail to be registered in auth mode")
+	}
+}
+
+func TestSetupRoutes_RegistersPluginPages_NoAuth(t *testing.T) {
+	router := mux.NewRouter()
+
+	newRouteTestAdminHandlers().SetupRoutes(router, false, "", "", "", "", true)
+
+	assertHasRoute(t, router, http.MethodGet, "/plugin")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/configuration")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/queue")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/detection")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/execution")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/monitoring")
+}
+
+func TestSetupRoutes_RegistersPluginPages_WithAuth(t *testing.T) {
+	router := mux.NewRouter()
+
+	newRouteTestAdminHandlers().SetupRoutes(router, true, "admin", "password", "", "", true)
+
+	assertHasRoute(t, router, http.MethodGet, "/plugin")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/configuration")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/queue")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/detection")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/execution")
+	assertHasRoute(t, router, http.MethodGet, "/plugin/monitoring")
+}
+
+func newRouteTestAdminHandlers() *AdminHandlers {
+	adminServer := &dash.AdminServer{}
+	store := sessions.NewCookieStore([]byte("test-session-key"))
+	return &AdminHandlers{
+		adminServer:            adminServer,
+		sessionStore:           store,
+		authHandlers:           &AuthHandlers{adminServer: adminServer, sessionStore: store},
+		clusterHandlers:        &ClusterHandlers{adminServer: adminServer},
+		fileBrowserHandlers:    &FileBrowserHandlers{adminServer: adminServer},
+		userHandlers:           &UserHandlers{adminServer: adminServer},
+		policyHandlers:         &PolicyHandlers{adminServer: adminServer},
+		pluginHandlers:         &PluginHandlers{adminServer: adminServer},
+		mqHandlers:             &MessageQueueHandlers{adminServer: adminServer},
+		serviceAccountHandlers: &ServiceAccountHandlers{adminServer: adminServer},
+	}
+}
+
+func hasRoute(router *mux.Router, method string, path string) bool {
+	req := httptest.NewRequest(method, path, nil)
+	var match mux.RouteMatch
+	return router.Match(req, &match)
+}
+
+func assertHasRoute(t *testing.T, router *mux.Router, method string, path string) {
+	t.Helper()
+	if !hasRoute(router, method, path) {
+		t.Fatalf("expected %s %s to be registered", method, path)
+	}
+}

weed/admin/handlers/auth_handlers.go

@@ -3,52 +3,65 @@ package handlers
 import (
 	"net/http"
 
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/sessions"
 	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
+	"github.com/seaweedfs/seaweedfs/weed/glog"
 )
 
 // AuthHandlers contains authentication-related HTTP handlers
 type AuthHandlers struct {
-	adminServer *dash.AdminServer
+	adminServer  *dash.AdminServer
+	sessionStore sessions.Store
 }
 
 // NewAuthHandlers creates a new instance of AuthHandlers
-func NewAuthHandlers(adminServer *dash.AdminServer) *AuthHandlers {
+func NewAuthHandlers(adminServer *dash.AdminServer, store sessions.Store) *AuthHandlers {
 	return &AuthHandlers{
-		adminServer: adminServer,
+		adminServer:  adminServer,
+		sessionStore: store,
 	}
 }
 
 // ShowLogin displays the login page
-func (a *AuthHandlers) ShowLogin(c *gin.Context) {
-	session := sessions.Default(c)
-
-	// If already authenticated, redirect to admin
-	if session.Get("authenticated") == true {
-		c.Redirect(http.StatusSeeOther, "/admin")
-		return
+func (a *AuthHandlers) ShowLogin(w http.ResponseWriter, r *http.Request) {
+	session, err := a.sessionStore.Get(r, dash.SessionName())
+	var csrfToken string
+	if err == nil {
+		if authenticated, _ := session.Values["authenticated"].(bool); authenticated {
+			http.Redirect(w, r, "/admin", http.StatusSeeOther)
+			return
+		}
+	} else {
+		glog.V(1).Infof("Failed to load session for login page: %v", err)
 	}
 
-	errorMessage := c.Query("error")
+	if session != nil {
+		token, tokenErr := dash.EnsureSessionCSRFToken(session, r, w)
+		if tokenErr != nil {
+			glog.V(1).Infof("Failed to ensure CSRF token for login page: %v", tokenErr)
+		} else {
+			csrfToken = token
+		}
+	}
+
+	errorMessage := r.URL.Query().Get("error")
 
 	// Render login template
-	c.Header("Content-Type", "text/html")
-	loginComponent := layout.LoginForm(c, "SeaweedFS Admin", errorMessage)
-	err := loginComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render login template: " + err.Error()})
+	w.Header().Set("Content-Type", "text/html")
+	loginComponent := layout.LoginForm("SeaweedFS Admin", errorMessage, csrfToken)
+	if err := loginComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render login template: "+err.Error())
 		return
 	}
 }
 
 // HandleLogin handles login form submission
-func (a *AuthHandlers) HandleLogin(adminUser, adminPassword, readOnlyUser, readOnlyPassword string) gin.HandlerFunc {
-	return a.adminServer.HandleLogin(adminUser, adminPassword, readOnlyUser, readOnlyPassword)
+func (a *AuthHandlers) HandleLogin(adminUser, adminPassword, readOnlyUser, readOnlyPassword string) http.HandlerFunc {
+	return a.adminServer.HandleLogin(a.sessionStore, adminUser, adminPassword, readOnlyUser, readOnlyPassword)
 }
 
 // HandleLogout handles user logout
-func (a *AuthHandlers) HandleLogout(c *gin.Context) {
-	a.adminServer.HandleLogout(c)
+func (a *AuthHandlers) HandleLogout(w http.ResponseWriter, r *http.Request) {
+	a.adminServer.HandleLogout(a.sessionStore, w, r)
 }

weed/admin/handlers/cluster_handlers.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"strconv"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
 	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
@@ -24,402 +24,387 @@ func NewClusterHandlers(adminServer *dash.AdminServer) *ClusterHandlers {
 }
 
 // ShowClusterVolumeServers renders the cluster volume servers page
-func (h *ClusterHandlers) ShowClusterVolumeServers(c *gin.Context) {
+func (h *ClusterHandlers) ShowClusterVolumeServers(w http.ResponseWriter, r *http.Request) {
 	// Get cluster volume servers data
 	volumeServersData, err := h.adminServer.GetClusterVolumeServers()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get cluster volume servers: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster volume servers: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	volumeServersData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	volumeServersComponent := app.ClusterVolumeServers(*volumeServersData)
-	layoutComponent := layout.Layout(c, volumeServersComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, volumeServersComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowClusterVolumes renders the cluster volumes page
-func (h *ClusterHandlers) ShowClusterVolumes(c *gin.Context) {
+func (h *ClusterHandlers) ShowClusterVolumes(w http.ResponseWriter, r *http.Request) {
 	// Get pagination and sorting parameters from query string
 	page := 1
-	if p := c.Query("page"); p != "" {
+	if p := r.URL.Query().Get("page"); p != "" {
 		if parsed, err := strconv.Atoi(p); err == nil && parsed > 0 {
 			page = parsed
 		}
 	}
 
 	pageSize := 100
-	if ps := c.Query("pageSize"); ps != "" {
+	if ps := r.URL.Query().Get("pageSize"); ps != "" {
 		if parsed, err := strconv.Atoi(ps); err == nil && parsed > 0 && parsed <= 1000 {
 			pageSize = parsed
 		}
 	}
 
-	sortBy := c.DefaultQuery("sortBy", "id")
-	sortOrder := c.DefaultQuery("sortOrder", "asc")
-	collection := c.Query("collection") // Optional collection filter
+	sortBy := defaultQuery(r.URL.Query().Get("sortBy"), "id")
+	sortOrder := defaultQuery(r.URL.Query().Get("sortOrder"), "asc")
+	collection := r.URL.Query().Get("collection") // Optional collection filter
 
 	// Get cluster volumes data
 	volumesData, err := h.adminServer.GetClusterVolumes(page, pageSize, sortBy, sortOrder, collection)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get cluster volumes: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster volumes: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	volumesData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	volumesComponent := app.ClusterVolumes(*volumesData)
-	layoutComponent := layout.Layout(c, volumesComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, volumesComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowVolumeDetails renders the volume details page
-func (h *ClusterHandlers) ShowVolumeDetails(c *gin.Context) {
-	volumeIDStr := c.Param("id")
-	server := c.Param("server")
+func (h *ClusterHandlers) ShowVolumeDetails(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	volumeIDStr := vars["id"]
+	server := vars["server"]
 
 	if volumeIDStr == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Volume ID is required"})
+		writeJSONError(w, http.StatusBadRequest, "Volume ID is required")
 		return
 	}
 
 	if server == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Server is required"})
+		writeJSONError(w, http.StatusBadRequest, "Server is required")
 		return
 	}
 
 	volumeID, err := strconv.Atoi(volumeIDStr)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid volume ID"})
+		writeJSONError(w, http.StatusBadRequest, "Invalid volume ID")
 		return
 	}
 
 	// Get volume details
 	volumeDetails, err := h.adminServer.GetVolumeDetails(volumeID, server)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get volume details: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get volume details: "+err.Error())
 		return
 	}
 
+	username := usernameOrDefault(r)
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	volumeDetailsComponent := app.VolumeDetails(*volumeDetails)
-	layoutComponent := layout.Layout(c, volumeDetailsComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, volumeDetailsComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowClusterCollections renders the cluster collections page
-func (h *ClusterHandlers) ShowClusterCollections(c *gin.Context) {
+func (h *ClusterHandlers) ShowClusterCollections(w http.ResponseWriter, r *http.Request) {
 	// Get cluster collections data
 	collectionsData, err := h.adminServer.GetClusterCollections()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get cluster collections: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster collections: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	collectionsData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	collectionsComponent := app.ClusterCollections(*collectionsData)
-	layoutComponent := layout.Layout(c, collectionsComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, collectionsComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowCollectionDetails renders the collection detail page
-func (h *ClusterHandlers) ShowCollectionDetails(c *gin.Context) {
-	collectionName := c.Param("name")
+func (h *ClusterHandlers) ShowCollectionDetails(w http.ResponseWriter, r *http.Request) {
+	collectionName := mux.Vars(r)["name"]
 	if collectionName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Collection name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Collection name is required")
 		return
 	}
 
 	// Parse query parameters
-	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
-	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "25"))
-	sortBy := c.DefaultQuery("sort_by", "volume_id")
-	sortOrder := c.DefaultQuery("sort_order", "asc")
+	query := r.URL.Query()
+	page, _ := strconv.Atoi(defaultQuery(query.Get("page"), "1"))
+	pageSize, _ := strconv.Atoi(defaultQuery(query.Get("page_size"), "25"))
+	sortBy := defaultQuery(query.Get("sort_by"), "volume_id")
+	sortOrder := defaultQuery(query.Get("sort_order"), "asc")
 
 	// Get collection details data (volumes and EC volumes)
 	collectionDetailsData, err := h.adminServer.GetCollectionDetails(collectionName, page, pageSize, sortBy, sortOrder)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get collection details: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get collection details: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	collectionDetailsData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	collectionDetailsComponent := app.CollectionDetails(*collectionDetailsData)
-	layoutComponent := layout.Layout(c, collectionDetailsComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, collectionDetailsComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowClusterEcShards handles the cluster EC shards page (individual shards view)
-func (h *ClusterHandlers) ShowClusterEcShards(c *gin.Context) {
+func (h *ClusterHandlers) ShowClusterEcShards(w http.ResponseWriter, r *http.Request) {
 	// Parse query parameters
-	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
-	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "100"))
-	sortBy := c.DefaultQuery("sort_by", "volume_id")
-	sortOrder := c.DefaultQuery("sort_order", "asc")
-	collection := c.DefaultQuery("collection", "")
+	query := r.URL.Query()
+	page, _ := strconv.Atoi(defaultQuery(query.Get("page"), "1"))
+	pageSize, _ := strconv.Atoi(defaultQuery(query.Get("page_size"), "100"))
+	sortBy := defaultQuery(query.Get("sort_by"), "volume_id")
+	sortOrder := defaultQuery(query.Get("sort_order"), "asc")
+	collection := defaultQuery(query.Get("collection"), "")
 
 	// Get data from admin server
 	data, err := h.adminServer.GetClusterEcVolumes(page, pageSize, sortBy, sortOrder, collection)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	data.Username = username
 
 	// Render template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	ecVolumesComponent := app.ClusterEcVolumes(*data)
-	layoutComponent := layout.Layout(c, ecVolumesComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, ecVolumesComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 }
 
 // ShowEcVolumeDetails renders the EC volume details page
-func (h *ClusterHandlers) ShowEcVolumeDetails(c *gin.Context) {
-	volumeIDStr := c.Param("id")
+func (h *ClusterHandlers) ShowEcVolumeDetails(w http.ResponseWriter, r *http.Request) {
+	volumeIDStr := mux.Vars(r)["id"]
 
 	if volumeIDStr == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Volume ID is required"})
+		writeJSONError(w, http.StatusBadRequest, "Volume ID is required")
 		return
 	}
 
 	volumeID, err := strconv.Atoi(volumeIDStr)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid volume ID"})
+		writeJSONError(w, http.StatusBadRequest, "Invalid volume ID")
 		return
 	}
 
 	// Check that volumeID is within uint32 range
 	if volumeID < 0 || uint64(volumeID) > math.MaxUint32 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Volume ID out of range"})
+		writeJSONError(w, http.StatusBadRequest, "Volume ID out of range")
 		return
 	}
 
 	// Parse sorting parameters
-	sortBy := c.DefaultQuery("sort_by", "shard_id")
-	sortOrder := c.DefaultQuery("sort_order", "asc")
+	query := r.URL.Query()
+	sortBy := defaultQuery(query.Get("sort_by"), "shard_id")
+	sortOrder := defaultQuery(query.Get("sort_order"), "asc")
 
 	// Get EC volume details
 	ecVolumeDetails, err := h.adminServer.GetEcVolumeDetails(uint32(volumeID), sortBy, sortOrder)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get EC volume details: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get EC volume details: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	ecVolumeDetails.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	ecVolumeDetailsComponent := app.EcVolumeDetails(*ecVolumeDetails)
-	layoutComponent := layout.Layout(c, ecVolumeDetailsComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, ecVolumeDetailsComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowClusterMasters renders the cluster masters page
-func (h *ClusterHandlers) ShowClusterMasters(c *gin.Context) {
+func (h *ClusterHandlers) ShowClusterMasters(w http.ResponseWriter, r *http.Request) {
 	// Get cluster masters data
 	mastersData, err := h.adminServer.GetClusterMasters()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get cluster masters: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster masters: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	mastersData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	mastersComponent := app.ClusterMasters(*mastersData)
-	layoutComponent := layout.Layout(c, mastersComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, mastersComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowClusterFilers renders the cluster filers page
-func (h *ClusterHandlers) ShowClusterFilers(c *gin.Context) {
+func (h *ClusterHandlers) ShowClusterFilers(w http.ResponseWriter, r *http.Request) {
 	// Get cluster filers data
 	filersData, err := h.adminServer.GetClusterFilers()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get cluster filers: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster filers: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	filersData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	filersComponent := app.ClusterFilers(*filersData)
-	layoutComponent := layout.Layout(c, filersComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, filersComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowClusterBrokers renders the cluster message brokers page
-func (h *ClusterHandlers) ShowClusterBrokers(c *gin.Context) {
+func (h *ClusterHandlers) ShowClusterBrokers(w http.ResponseWriter, r *http.Request) {
 	// Get cluster brokers data
 	brokersData, err := h.adminServer.GetClusterBrokers()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get cluster brokers: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster brokers: "+err.Error())
 		return
 	}
 
-	// Set username
-	username := c.GetString("username")
-	if username == "" {
-		username = "admin"
-	}
+	username := usernameOrDefault(r)
 	brokersData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	brokersComponent := app.ClusterBrokers(*brokersData)
-	layoutComponent := layout.Layout(c, brokersComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, brokersComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // GetClusterTopology returns the cluster topology as JSON
-func (h *ClusterHandlers) GetClusterTopology(c *gin.Context) {
+func (h *ClusterHandlers) GetClusterTopology(w http.ResponseWriter, r *http.Request) {
 	topology, err := h.adminServer.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)
 }
 
 // GetMasters returns master node information
-func (h *ClusterHandlers) GetMasters(c *gin.Context) {
-	// Simple master info
-	c.JSON(http.StatusOK, gin.H{"masters": []gin.H{{"address": "localhost:9333"}}})
+func (h *ClusterHandlers) GetMasters(w http.ResponseWriter, r *http.Request) {
+	mastersData, err := h.adminServer.GetClusterMasters()
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster masters: "+err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, mastersData)
 }
 
 // GetVolumeServers returns volume server information
-func (h *ClusterHandlers) GetVolumeServers(c *gin.Context) {
+func (h *ClusterHandlers) GetVolumeServers(w http.ResponseWriter, r *http.Request) {
 	topology, err := h.adminServer.GetClusterTopology()
 	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{"volume_servers": topology.VolumeServers})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"volume_servers": topology.VolumeServers})
 }
 
 // VacuumVolume handles volume vacuum requests via API
-func (h *ClusterHandlers) VacuumVolume(c *gin.Context) {
-	volumeIDStr := c.Param("id")
-	server := c.Param("server")
+func (h *ClusterHandlers) VacuumVolume(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	volumeIDStr := vars["id"]
+	server := vars["server"]
 
 	if volumeIDStr == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Volume ID is required"})
+		writeJSONError(w, http.StatusBadRequest, "Volume ID is required")
 		return
 	}
 
 	volumeID, err := strconv.Atoi(volumeIDStr)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid volume ID"})
+		writeJSONError(w, http.StatusBadRequest, "Invalid volume ID")
+		return
+	}
+
+	if server == "" {
+		writeJSONError(w, http.StatusBadRequest, "Server is required")
 		return
 	}
 
 	// Perform vacuum operation
 	err = h.adminServer.VacuumVolume(volumeID, server)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "Failed to vacuum volume: " + err.Error(),
-		})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to vacuum volume: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message":   "Volume vacuum started successfully",
 		"volume_id": volumeID,
 		"server":    server,
 	})
 }
+
+func usernameOrDefault(r *http.Request) string {
+	username := dash.UsernameFromContext(r.Context())
+	if username == "" {
+		return "admin"
+	}
+	return username
+}

weed/admin/handlers/file_browser_handlers.go

@@ -16,7 +16,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gin-gonic/gin"
 	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
@@ -59,16 +58,16 @@ func (h *FileBrowserHandlers) newClientWithTimeout(timeout time.Duration) http.C
 }
 
 // ShowFileBrowser renders the file browser page
-func (h *FileBrowserHandlers) ShowFileBrowser(c *gin.Context) {
+func (h *FileBrowserHandlers) ShowFileBrowser(w http.ResponseWriter, r *http.Request) {
 	// Get path from query parameter, default to root
-	path := c.DefaultQuery("path", "/")
+	path := defaultQuery(r.URL.Query().Get("path"), "/")
 	// Normalize Windows-style paths for consistency
 	path = util.CleanWindowsPath(path)
 
 	// Get pagination parameters
-	lastFileName := c.DefaultQuery("lastFileName", "")
+	lastFileName := r.URL.Query().Get("lastFileName")
 
-	pageSize, err := strconv.Atoi(c.DefaultQuery("limit", "20"))
+	pageSize, err := strconv.Atoi(defaultQuery(r.URL.Query().Get("limit"), "20"))
 	if err != nil || pageSize < 1 {
 		pageSize = 20
 	}
@@ -79,36 +78,42 @@ func (h *FileBrowserHandlers) ShowFileBrowser(c *gin.Context) {
 	// Get file browser data with cursor-based pagination
 	browserData, err := h.adminServer.GetFileBrowser(path, lastFileName, pageSize)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get file browser data: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get file browser data: "+err.Error())
 		return
 	}
 
 	// Set username
-	username := c.GetString("username")
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 	browserData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	browserComponent := app.FileBrowser(*browserData)
-	layoutComponent := layout.Layout(c, browserComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, browserComponent)
+	err = layoutComponent.Render(r.Context(), w)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // DeleteFile handles file deletion API requests
-func (h *FileBrowserHandlers) DeleteFile(c *gin.Context) {
+func (h *FileBrowserHandlers) DeleteFile(w http.ResponseWriter, r *http.Request) {
 	var request struct {
 		Path string `json:"path" binding:"required"`
 	}
 
-	if err := c.ShouldBindJSON(&request); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &request); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
+		return
+	}
+
+	if strings.TrimSpace(request.Path) == "" {
+		writeJSONError(w, http.StatusBadRequest, "path is required")
 		return
 	}
 
@@ -124,29 +129,36 @@ func (h *FileBrowserHandlers) DeleteFile(c *gin.Context) {
 		return err
 	})
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete file: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to delete file: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{"message": "File deleted successfully"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "File deleted successfully"})
 }
 
 // DeleteMultipleFiles handles multiple file deletion API requests
-func (h *FileBrowserHandlers) DeleteMultipleFiles(c *gin.Context) {
+func (h *FileBrowserHandlers) DeleteMultipleFiles(w http.ResponseWriter, r *http.Request) {
 	var request struct {
 		Paths []string `json:"paths" binding:"required"`
 	}
 
-	if err := c.ShouldBindJSON(&request); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &request); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
 		return
 	}
 
 	if len(request.Paths) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "No paths provided"})
+		writeJSONError(w, http.StatusBadRequest, "No paths provided")
 		return
 	}
 
+	for _, path := range request.Paths {
+		if strings.TrimSpace(path) == "" {
+			writeJSONError(w, http.StatusBadRequest, "path is required")
+			return
+		}
+	}
+
 	var deletedCount int
 	var failedCount int
 	var errors []string
@@ -189,37 +201,40 @@ func (h *FileBrowserHandlers) DeleteMultipleFiles(c *gin.Context) {
 		} else {
 			response["message"] = fmt.Sprintf("Deleted %d item(s), failed to delete %d item(s)", deletedCount, failedCount)
 		}
-		c.JSON(http.StatusOK, response)
+		writeJSON(w, http.StatusOK, response)
 	} else {
 		response["message"] = "Failed to delete all selected items"
-		c.JSON(http.StatusInternalServerError, response)
+		writeJSON(w, http.StatusInternalServerError, response)
 	}
 }
 
 // CreateFolder handles folder creation requests
-func (h *FileBrowserHandlers) CreateFolder(c *gin.Context) {
+func (h *FileBrowserHandlers) CreateFolder(w http.ResponseWriter, r *http.Request) {
 	var request struct {
 		Path       string `json:"path" binding:"required"`
 		FolderName string `json:"folder_name" binding:"required"`
 	}
 
-	if err := c.ShouldBindJSON(&request); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request: " + err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &request); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "Invalid request: "+err.Error())
+		return
+	}
+
+	if strings.TrimSpace(request.Path) == "" {
+		writeJSONError(w, http.StatusBadRequest, "path is required")
 		return
 	}
 
 	// Clean and validate folder name
 	folderName := strings.TrimSpace(request.FolderName)
 	if folderName == "" || strings.Contains(folderName, "/") || strings.Contains(folderName, "\\") {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid folder name"})
+		writeJSONError(w, http.StatusBadRequest, "Invalid folder name")
 		return
 	}
 
 	// Create full path for new folder
-	fullPath := filepath.Join(request.Path, folderName)
-	if !strings.HasPrefix(fullPath, "/") {
-		fullPath = "/" + fullPath
-	}
+	base := "/" + strings.TrimPrefix(request.Path, "/")
+	fullPath := path.Join(base, folderName)
 
 	// Create folder via filer
 	err := h.adminServer.WithFilerClient(func(client filer_pb.SeaweedFilerClient) error {
@@ -241,32 +256,32 @@ func (h *FileBrowserHandlers) CreateFolder(c *gin.Context) {
 		return err
 	})
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create folder: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create folder: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{"message": "Folder created successfully"})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"message": "Folder created successfully"})
 }
 
 // UploadFile handles file upload requests
-func (h *FileBrowserHandlers) UploadFile(c *gin.Context) {
+func (h *FileBrowserHandlers) UploadFile(w http.ResponseWriter, r *http.Request) {
 	// Get the current path
-	currentPath := c.PostForm("path")
+	currentPath := r.FormValue("path")
 	if currentPath == "" {
 		currentPath = "/"
 	}
 
 	// Parse multipart form
-	err := c.Request.ParseMultipartForm(1 << 30) // 1GB max memory for large file uploads
+	err := r.ParseMultipartForm(1 << 30) // 1GB max memory for large file uploads
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse multipart form: " + err.Error()})
+		writeJSONError(w, http.StatusBadRequest, "Failed to parse multipart form: "+err.Error())
 		return
 	}
 
 	// Get uploaded files (supports multiple files)
-	files := c.Request.MultipartForm.File["files"]
+	files := r.MultipartForm.File["files"]
 	if len(files) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "No files uploaded"})
+		writeJSONError(w, http.StatusBadRequest, "No files uploaded")
 		return
 	}
 
@@ -292,16 +307,8 @@ func (h *FileBrowserHandlers) UploadFile(c *gin.Context) {
 			fullPath = "/" + fullPath
 		}
 
-		// Open the file
-		file, err := fileHeader.Open()
-		if err != nil {
-			failedUploads = append(failedUploads, fmt.Sprintf("%s: %v", fileName, err))
-			continue
-		}
-
 		// Upload file to filer
 		err = h.uploadFileToFiler(fullPath, fileHeader)
-		file.Close()
 
 		if err != nil {
 			failedUploads = append(failedUploads, fmt.Sprintf("%s: %v", fileName, err))
@@ -331,10 +338,10 @@ func (h *FileBrowserHandlers) UploadFile(c *gin.Context) {
 		} else {
 			response["message"] = fmt.Sprintf("Uploaded %d file(s), %d failed", len(uploadResults), len(failedUploads))
 		}
-		c.JSON(http.StatusOK, response)
+		writeJSON(w, http.StatusOK, response)
 	} else {
 		response["message"] = "All file uploads failed"
-		c.JSON(http.StatusInternalServerError, response)
+		writeJSON(w, http.StatusInternalServerError, response)
 	}
 }
 
@@ -561,23 +568,23 @@ func (h *FileBrowserHandlers) fetchFileContent(filePath string, timeout time.Dur
 
 // DownloadFile handles file download requests by proxying through the Admin UI server
 // This ensures mTLS works correctly since the Admin UI server has the client certificates
-func (h *FileBrowserHandlers) DownloadFile(c *gin.Context) {
-	filePath := c.Query("path")
+func (h *FileBrowserHandlers) DownloadFile(w http.ResponseWriter, r *http.Request) {
+	filePath := r.URL.Query().Get("path")
 	if filePath == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "File path is required"})
+		writeJSONError(w, http.StatusBadRequest, "File path is required")
 		return
 	}
 
 	// Get filer address
 	filerAddress := h.adminServer.GetFilerAddress()
 	if filerAddress == "" {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Filer address not configured"})
+		writeJSONError(w, http.StatusInternalServerError, "Filer address not configured")
 		return
 	}
 
 	// Validate filer address to prevent SSRF
 	if err := h.validateFilerAddress(filerAddress); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Invalid filer address configuration"})
+		writeJSONError(w, http.StatusInternalServerError, "Invalid filer address configuration")
 		return
 	}
 	filerHttpAddress := pb.ServerAddress(filerAddress).ToHttpAddress()
@@ -585,7 +592,7 @@ func (h *FileBrowserHandlers) DownloadFile(c *gin.Context) {
 	// Validate and sanitize the file path
 	cleanFilePath, err := h.validateAndCleanFilePath(filePath)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid file path: " + err.Error()})
+		writeJSONError(w, http.StatusBadRequest, "Invalid file path: "+err.Error())
 		return
 	}
 
@@ -593,7 +600,7 @@ func (h *FileBrowserHandlers) DownloadFile(c *gin.Context) {
 	downloadURL := fmt.Sprintf("%s%s", filerHttpAddress, cleanFilePath)
 	downloadURL, err = h.httpClient.NormalizeHttpScheme(downloadURL)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to construct download URL: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to construct download URL: "+err.Error())
 		return
 	}
 
@@ -602,9 +609,9 @@ func (h *FileBrowserHandlers) DownloadFile(c *gin.Context) {
 	// Safe: filerAddress validated by validateFilerAddress() to match configured filer
 	// Safe: cleanFilePath validated and cleaned by validateAndCleanFilePath() to prevent path traversal
 	// Use request context so download is cancelled when client disconnects
-	req, err := http.NewRequestWithContext(c.Request.Context(), "GET", downloadURL, nil)
+	req, err := http.NewRequestWithContext(r.Context(), "GET", downloadURL, nil)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create request: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create request: "+err.Error())
 		return
 	}
 	client := h.newClientWithTimeout(5 * time.Minute) // Longer timeout for large file downloads
@@ -613,7 +620,7 @@ func (h *FileBrowserHandlers) DownloadFile(c *gin.Context) {
 
 	resp, err := client.Do(req)
 	if err != nil {
-		c.JSON(http.StatusBadGateway, gin.H{"error": "Failed to fetch file from filer: " + err.Error()})
+		writeJSONError(w, http.StatusBadGateway, "Failed to fetch file from filer: "+err.Error())
 		return
 	}
 	defer resp.Body.Close()
@@ -621,10 +628,10 @@ func (h *FileBrowserHandlers) DownloadFile(c *gin.Context) {
 	if resp.StatusCode != http.StatusOK {
 		body, err := io.ReadAll(resp.Body)
 		if err != nil {
-			c.JSON(resp.StatusCode, gin.H{"error": fmt.Sprintf("Filer returned status %d but failed to read response body: %v", resp.StatusCode, err)})
+			writeJSONError(w, resp.StatusCode, fmt.Sprintf("Filer returned status %d but failed to read response body: %v", resp.StatusCode, err))
 			return
 		}
-		c.JSON(resp.StatusCode, gin.H{"error": fmt.Sprintf("Filer returned status %d: %s", resp.StatusCode, string(body))})
+		writeJSONError(w, resp.StatusCode, fmt.Sprintf("Filer returned status %d: %s", resp.StatusCode, string(body)))
 		return
 	}
 
@@ -632,33 +639,33 @@ func (h *FileBrowserHandlers) DownloadFile(c *gin.Context) {
 	fileName := filepath.Base(cleanFilePath)
 	// Use mime.FormatMediaType for RFC 6266 compliant Content-Disposition,
 	// properly handling non-ASCII characters and special characters
-	c.Header("Content-Disposition", mime.FormatMediaType("attachment", map[string]string{"filename": fileName}))
+	w.Header().Set("Content-Disposition", mime.FormatMediaType("attachment", map[string]string{"filename": fileName}))
 
 	// Use content type from filer response, or default to octet-stream
 	contentType := resp.Header.Get("Content-Type")
 	if contentType == "" {
 		contentType = "application/octet-stream"
 	}
-	c.Header("Content-Type", contentType)
+	w.Header().Set("Content-Type", contentType)
 
 	// Set content length if available
 	if resp.ContentLength > 0 {
-		c.Header("Content-Length", fmt.Sprintf("%d", resp.ContentLength))
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", resp.ContentLength))
 	}
 
 	// Stream the response body to the client
-	c.Status(http.StatusOK)
-	_, err = io.Copy(c.Writer, resp.Body)
+	w.WriteHeader(http.StatusOK)
+	_, err = io.Copy(w, resp.Body)
 	if err != nil {
 		glog.Errorf("Error streaming file download: %v", err)
 	}
 }
 
 // ViewFile handles file viewing requests (for text files, images, etc.)
-func (h *FileBrowserHandlers) ViewFile(c *gin.Context) {
-	filePath := c.Query("path")
+func (h *FileBrowserHandlers) ViewFile(w http.ResponseWriter, r *http.Request) {
+	filePath := r.URL.Query().Get("path")
 	if filePath == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "File path is required"})
+		writeJSONError(w, http.StatusBadRequest, "File path is required")
 		return
 	}
 
@@ -704,7 +711,7 @@ func (h *FileBrowserHandlers) ViewFile(c *gin.Context) {
 		return nil
 	})
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get file metadata: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get file metadata: "+err.Error())
 		return
 	}
 
@@ -752,7 +759,7 @@ func (h *FileBrowserHandlers) ViewFile(c *gin.Context) {
 		}
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"file":     fileEntry,
 		"content":  content,
 		"viewable": viewable,
@@ -761,10 +768,10 @@ func (h *FileBrowserHandlers) ViewFile(c *gin.Context) {
 }
 
 // GetFileProperties handles file properties requests
-func (h *FileBrowserHandlers) GetFileProperties(c *gin.Context) {
-	filePath := c.Query("path")
+func (h *FileBrowserHandlers) GetFileProperties(w http.ResponseWriter, r *http.Request) {
+	filePath := r.URL.Query().Get("path")
 	if filePath == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "File path is required"})
+		writeJSONError(w, http.StatusBadRequest, "File path is required")
 		return
 	}
 
@@ -853,11 +860,11 @@ func (h *FileBrowserHandlers) GetFileProperties(c *gin.Context) {
 		return nil
 	})
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get file properties: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get file properties: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, properties)
+	writeJSON(w, http.StatusOK, properties)
 }
 
 // Helper function to format bytes

weed/admin/handlers/http_helpers.go

@@ -0,0 +1,28 @@
+package handlers
+
+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)
+}
+
+func defaultQuery(value, fallback string) string {
+	return httputil.DefaultQuery(value, fallback)
+}

weed/admin/handlers/maintenance_handlers.go

@@ -1,550 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/seaweedfs/seaweedfs/weed/admin/config"
-	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
-	"github.com/seaweedfs/seaweedfs/weed/admin/maintenance"
-	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
-	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
-	"github.com/seaweedfs/seaweedfs/weed/glog"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/balance"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/erasure_coding"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/vacuum"
-	"github.com/seaweedfs/seaweedfs/weed/worker/types"
-)
-
-// MaintenanceHandlers handles maintenance-related HTTP requests
-type MaintenanceHandlers struct {
-	adminServer *dash.AdminServer
-}
-
-// NewMaintenanceHandlers creates a new instance of MaintenanceHandlers
-func NewMaintenanceHandlers(adminServer *dash.AdminServer) *MaintenanceHandlers {
-	return &MaintenanceHandlers{
-		adminServer: adminServer,
-	}
-}
-
-// ShowTaskDetail displays the task detail page
-func (h *MaintenanceHandlers) ShowTaskDetail(c *gin.Context) {
-	taskID := c.Param("id")
-
-	if h.adminServer == nil {
-		c.String(http.StatusInternalServerError, "Admin server not initialized")
-		return
-	}
-
-	taskDetail, err := h.adminServer.GetMaintenanceTaskDetail(taskID)
-	if err != nil {
-		glog.Errorf("DEBUG ShowTaskDetail: error getting task detail for %s: %v", taskID, err)
-		c.String(http.StatusNotFound, "Task not found: %s (Error: %v)", taskID, err)
-		return
-	}
-
-	c.Header("Content-Type", "text/html")
-	taskDetailComponent := app.TaskDetail(taskDetail)
-	layoutComponent := layout.Layout(c, taskDetailComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		glog.Errorf("DEBUG ShowTaskDetail: render error: %v", err)
-		c.String(http.StatusInternalServerError, "Failed to render template: %v", err)
-		return
-	}
-
-}
-
-// ShowMaintenanceQueue displays the maintenance queue page
-func (h *MaintenanceHandlers) ShowMaintenanceQueue(c *gin.Context) {
-	// Add timeout to prevent hanging
-	ctx, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
-	defer cancel()
-
-	// Use a channel to handle timeout for data retrieval
-	type result struct {
-		data *maintenance.MaintenanceQueueData
-		err  error
-	}
-	resultChan := make(chan result, 1)
-
-	go func() {
-		data, err := h.getMaintenanceQueueData()
-		resultChan <- result{data: data, err: err}
-	}()
-
-	select {
-	case res := <-resultChan:
-		if res.err != nil {
-			glog.V(1).Infof("ShowMaintenanceQueue: error getting data: %v", res.err)
-			c.JSON(http.StatusInternalServerError, gin.H{"error": res.err.Error()})
-			return
-		}
-
-		glog.V(2).Infof("ShowMaintenanceQueue: got data with %d tasks", len(res.data.Tasks))
-
-		// Render HTML template
-		c.Header("Content-Type", "text/html")
-		maintenanceComponent := app.MaintenanceQueue(res.data)
-		layoutComponent := layout.Layout(c, maintenanceComponent)
-		err := layoutComponent.Render(ctx, c.Writer)
-		if err != nil {
-			glog.V(1).Infof("ShowMaintenanceQueue: render error: %v", err)
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
-			return
-		}
-
-		glog.V(3).Infof("ShowMaintenanceQueue: template rendered successfully")
-
-	case <-ctx.Done():
-		glog.Warningf("ShowMaintenanceQueue: timeout waiting for data")
-		c.JSON(http.StatusRequestTimeout, gin.H{
-			"error":      "Request timeout - maintenance data retrieval took too long. This may indicate a system issue.",
-			"suggestion": "Try refreshing the page or contact system administrator if the problem persists.",
-		})
-		return
-	}
-}
-
-// ShowMaintenanceWorkers displays the maintenance workers page
-func (h *MaintenanceHandlers) ShowMaintenanceWorkers(c *gin.Context) {
-	if h.adminServer == nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Admin server not initialized"})
-		return
-	}
-	workersData, err := h.adminServer.GetMaintenanceWorkersData()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	// Render HTML template
-	c.Header("Content-Type", "text/html")
-	workersComponent := app.MaintenanceWorkers(workersData)
-	layoutComponent := layout.Layout(c, workersComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
-		return
-	}
-}
-
-// ShowMaintenanceConfig displays the maintenance configuration page
-func (h *MaintenanceHandlers) ShowMaintenanceConfig(c *gin.Context) {
-	config, err := h.getMaintenanceConfig()
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	// Get the schema for dynamic form rendering
-	schema := maintenance.GetMaintenanceConfigSchema()
-
-	// Render HTML template using schema-driven approach
-	c.Header("Content-Type", "text/html")
-	configComponent := app.MaintenanceConfigSchema(config, schema)
-	layoutComponent := layout.Layout(c, configComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
-		return
-	}
-}
-
-// ShowTaskConfig displays the configuration page for a specific task type
-func (h *MaintenanceHandlers) ShowTaskConfig(c *gin.Context) {
-	taskTypeName := c.Param("taskType")
-
-	// Get the schema for this task type
-	schema := tasks.GetTaskConfigSchema(taskTypeName)
-	if schema == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "Task type not found or no schema available"})
-		return
-	}
-
-	// Get the UI provider for current configuration
-	uiRegistry := tasks.GetGlobalUIRegistry()
-	typesRegistry := tasks.GetGlobalTypesRegistry()
-
-	var provider types.TaskUIProvider
-	for workerTaskType := range typesRegistry.GetAllDetectors() {
-		if string(workerTaskType) == taskTypeName {
-			provider = uiRegistry.GetProvider(workerTaskType)
-			break
-		}
-	}
-
-	if provider == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "UI provider not found for task type"})
-		return
-	}
-
-	// Get current configuration
-	currentConfig := provider.GetCurrentConfig()
-
-	// Note: Do NOT apply schema defaults to current config as it overrides saved values
-	// Only apply defaults when creating new configs, not when displaying existing ones
-
-	// Create task configuration data
-	configData := &maintenance.TaskConfigData{
-		TaskType:    maintenance.MaintenanceTaskType(taskTypeName),
-		TaskName:    schema.DisplayName,
-		TaskIcon:    schema.Icon,
-		Description: schema.Description,
-	}
-
-	// Render HTML template using schema-based approach
-	c.Header("Content-Type", "text/html")
-	taskConfigComponent := app.TaskConfigSchema(configData, schema, currentConfig)
-	layoutComponent := layout.Layout(c, taskConfigComponent)
-	err := layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
-		return
-	}
-}
-
-// UpdateTaskConfig updates task configuration from form
-func (h *MaintenanceHandlers) UpdateTaskConfig(c *gin.Context) {
-	taskTypeName := c.Param("taskType")
-	taskType := types.TaskType(taskTypeName)
-
-	// Parse form data
-	err := c.Request.ParseForm()
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse form data: " + err.Error()})
-		return
-	}
-
-	// Debug logging - show received form data
-	glog.V(1).Infof("Received form data for task type %s:", taskTypeName)
-	for key, values := range c.Request.PostForm {
-		glog.V(1).Infof("  %s: %v", key, values)
-	}
-
-	// Get the task configuration schema
-	schema := tasks.GetTaskConfigSchema(taskTypeName)
-	if schema == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "Schema not found for task type: " + taskTypeName})
-		return
-	}
-
-	// Create a new config instance based on task type and apply schema defaults
-	var config TaskConfig
-	switch taskType {
-	case types.TaskTypeVacuum:
-		config = &vacuum.Config{}
-	case types.TaskTypeBalance:
-		config = &balance.Config{}
-	case types.TaskTypeErasureCoding:
-		config = &erasure_coding.Config{}
-	default:
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Unsupported task type: " + taskTypeName})
-		return
-	}
-
-	// Apply schema defaults first using type-safe method
-	if err := schema.ApplyDefaultsToConfig(config); err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to apply defaults: " + err.Error()})
-		return
-	}
-
-	// First, get the current configuration to preserve existing values
-	currentUIRegistry := tasks.GetGlobalUIRegistry()
-	currentTypesRegistry := tasks.GetGlobalTypesRegistry()
-
-	var currentProvider types.TaskUIProvider
-	for workerTaskType := range currentTypesRegistry.GetAllDetectors() {
-		if string(workerTaskType) == string(taskType) {
-			currentProvider = currentUIRegistry.GetProvider(workerTaskType)
-			break
-		}
-	}
-
-	if currentProvider != nil {
-		// Copy current config values to the new config
-		currentConfig := currentProvider.GetCurrentConfig()
-		if currentConfigProtobuf, ok := currentConfig.(TaskConfig); ok {
-			// Apply current values using protobuf directly - no map conversion needed!
-			currentPolicy := currentConfigProtobuf.ToTaskPolicy()
-			if err := config.FromTaskPolicy(currentPolicy); err != nil {
-				glog.Warningf("Failed to load current config for %s: %v", taskTypeName, err)
-			}
-		}
-	}
-
-	// Parse form data using schema-based approach (this will override with new values)
-	err = h.parseTaskConfigFromForm(c.Request.PostForm, schema, config)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse configuration: " + err.Error()})
-		return
-	}
-
-	// Debug logging - show parsed config values
-	switch taskType {
-	case types.TaskTypeVacuum:
-		if vacuumConfig, ok := config.(*vacuum.Config); ok {
-			glog.V(1).Infof("Parsed vacuum config - GarbageThreshold: %f, MinVolumeAgeSeconds: %d, MinIntervalSeconds: %d",
-				vacuumConfig.GarbageThreshold, vacuumConfig.MinVolumeAgeSeconds, vacuumConfig.MinIntervalSeconds)
-		}
-	case types.TaskTypeErasureCoding:
-		if ecConfig, ok := config.(*erasure_coding.Config); ok {
-			glog.V(1).Infof("Parsed EC config - FullnessRatio: %f, QuietForSeconds: %d, MinSizeMB: %d, CollectionFilter: '%s'",
-				ecConfig.FullnessRatio, ecConfig.QuietForSeconds, ecConfig.MinSizeMB, ecConfig.CollectionFilter)
-		}
-	case types.TaskTypeBalance:
-		if balanceConfig, ok := config.(*balance.Config); ok {
-			glog.V(1).Infof("Parsed balance config - Enabled: %v, MaxConcurrent: %d, ScanIntervalSeconds: %d, ImbalanceThreshold: %f, MinServerCount: %d",
-				balanceConfig.Enabled, balanceConfig.MaxConcurrent, balanceConfig.ScanIntervalSeconds, balanceConfig.ImbalanceThreshold, balanceConfig.MinServerCount)
-		}
-	}
-
-	// Validate the configuration
-	if validationErrors := schema.ValidateConfig(config); len(validationErrors) > 0 {
-		errorMessages := make([]string, len(validationErrors))
-		for i, err := range validationErrors {
-			errorMessages[i] = err.Error()
-		}
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Configuration validation failed", "details": errorMessages})
-		return
-	}
-
-	// Apply configuration using UIProvider
-	uiRegistry := tasks.GetGlobalUIRegistry()
-	typesRegistry := tasks.GetGlobalTypesRegistry()
-
-	var provider types.TaskUIProvider
-	for workerTaskType := range typesRegistry.GetAllDetectors() {
-		if string(workerTaskType) == string(taskType) {
-			provider = uiRegistry.GetProvider(workerTaskType)
-			break
-		}
-	}
-
-	if provider == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "UI provider not found for task type"})
-		return
-	}
-
-	// Apply configuration using provider
-	err = provider.ApplyTaskConfig(config)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to apply configuration: " + err.Error()})
-		return
-	}
-
-	// Save task configuration to protobuf file using ConfigPersistence
-	if h.adminServer != nil && h.adminServer.GetConfigPersistence() != nil {
-		err = h.saveTaskConfigToProtobuf(taskType, config)
-		if err != nil {
-			glog.Warningf("Failed to save task config to protobuf file: %v", err)
-			// Don't fail the request, just log the warning
-		}
-	} else if h.adminServer == nil {
-		glog.Warningf("Failed to save task config: admin server not initialized")
-	}
-
-	// Trigger a configuration reload in the maintenance manager
-	if h.adminServer != nil {
-		if manager := h.adminServer.GetMaintenanceManager(); manager != nil {
-			err = manager.ReloadTaskConfigurations()
-			if err != nil {
-				glog.Warningf("Failed to reload task configurations: %v", err)
-			} else {
-				glog.V(1).Infof("Successfully reloaded task configurations after updating %s", taskTypeName)
-			}
-		}
-	}
-
-	// Redirect back to task configuration page
-	c.Redirect(http.StatusSeeOther, "/maintenance/config/"+taskTypeName)
-}
-
-// parseTaskConfigFromForm parses form data using schema definitions
-func (h *MaintenanceHandlers) parseTaskConfigFromForm(formData map[string][]string, schema *tasks.TaskConfigSchema, config interface{}) error {
-	configValue := reflect.ValueOf(config)
-	if configValue.Kind() == reflect.Ptr {
-		configValue = configValue.Elem()
-	}
-
-	if configValue.Kind() != reflect.Struct {
-		return fmt.Errorf("config must be a struct or pointer to struct")
-	}
-
-	configType := configValue.Type()
-
-	for i := 0; i < configValue.NumField(); i++ {
-		field := configValue.Field(i)
-		fieldType := configType.Field(i)
-
-		// Handle embedded structs recursively
-		if fieldType.Anonymous && field.Kind() == reflect.Struct {
-			err := h.parseTaskConfigFromForm(formData, schema, field.Addr().Interface())
-			if err != nil {
-				return fmt.Errorf("error parsing embedded struct %s: %w", fieldType.Name, err)
-			}
-			continue
-		}
-
-		// Get JSON tag name
-		jsonTag := fieldType.Tag.Get("json")
-		if jsonTag == "" {
-			continue
-		}
-
-		// Remove options like ",omitempty"
-		if commaIdx := strings.Index(jsonTag, ","); commaIdx > 0 {
-			jsonTag = jsonTag[:commaIdx]
-		}
-
-		// Find corresponding schema field
-		schemaField := schema.GetFieldByName(jsonTag)
-		if schemaField == nil {
-			continue
-		}
-
-		// Parse value based on field type
-		if err := h.parseFieldFromForm(formData, schemaField, field); err != nil {
-			return fmt.Errorf("error parsing field %s: %w", schemaField.DisplayName, err)
-		}
-	}
-
-	return nil
-}
-
-// parseFieldFromForm parses a single field value from form data
-func (h *MaintenanceHandlers) parseFieldFromForm(formData map[string][]string, schemaField *config.Field, fieldValue reflect.Value) error {
-	if !fieldValue.CanSet() {
-		return nil
-	}
-
-	switch schemaField.Type {
-	case config.FieldTypeBool:
-		// Checkbox fields - present means true, absent means false
-		_, exists := formData[schemaField.JSONName]
-		fieldValue.SetBool(exists)
-
-	case config.FieldTypeInt:
-		if values, ok := formData[schemaField.JSONName]; ok && len(values) > 0 {
-			if intVal, err := strconv.Atoi(values[0]); err != nil {
-				return fmt.Errorf("invalid integer value: %s", values[0])
-			} else {
-				fieldValue.SetInt(int64(intVal))
-			}
-		}
-
-	case config.FieldTypeFloat:
-		if values, ok := formData[schemaField.JSONName]; ok && len(values) > 0 {
-			if floatVal, err := strconv.ParseFloat(values[0], 64); err != nil {
-				return fmt.Errorf("invalid float value: %s", values[0])
-			} else {
-				fieldValue.SetFloat(floatVal)
-			}
-		}
-
-	case config.FieldTypeString:
-		if values, ok := formData[schemaField.JSONName]; ok && len(values) > 0 {
-			fieldValue.SetString(values[0])
-		}
-
-	case config.FieldTypeInterval:
-		// Parse interval fields with value + unit
-		valueKey := schemaField.JSONName + "_value"
-		unitKey := schemaField.JSONName + "_unit"
-
-		if valueStrs, ok := formData[valueKey]; ok && len(valueStrs) > 0 {
-			value, err := strconv.Atoi(valueStrs[0])
-			if err != nil {
-				return fmt.Errorf("invalid interval value: %s", valueStrs[0])
-			}
-
-			unit := "minutes" // default
-			if unitStrs, ok := formData[unitKey]; ok && len(unitStrs) > 0 {
-				unit = unitStrs[0]
-			}
-
-			// Convert to seconds
-			seconds := config.IntervalValueUnitToSeconds(value, unit)
-			fieldValue.SetInt(int64(seconds))
-		}
-
-	default:
-		return fmt.Errorf("unsupported field type: %s", schemaField.Type)
-	}
-
-	return nil
-}
-
-// UpdateMaintenanceConfig updates maintenance configuration from form
-func (h *MaintenanceHandlers) UpdateMaintenanceConfig(c *gin.Context) {
-	var config maintenance.MaintenanceConfig
-	if err := c.ShouldBind(&config); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-
-	err := h.updateMaintenanceConfig(&config)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-
-	c.Redirect(http.StatusSeeOther, "/maintenance/config")
-}
-
-// Helper methods that delegate to AdminServer
-
-func (h *MaintenanceHandlers) getMaintenanceQueueData() (*maintenance.MaintenanceQueueData, error) {
-	if h.adminServer == nil {
-		return nil, fmt.Errorf("admin server not initialized")
-	}
-	// Use the exported method from AdminServer used by the JSON API
-	return h.adminServer.GetMaintenanceQueueData()
-}
-
-func (h *MaintenanceHandlers) getMaintenanceConfig() (*maintenance.MaintenanceConfigData, error) {
-	if h.adminServer == nil {
-		return nil, fmt.Errorf("admin server not initialized")
-	}
-	// Delegate to AdminServer's real persistence method
-	return h.adminServer.GetMaintenanceConfigData()
-}
-
-func (h *MaintenanceHandlers) updateMaintenanceConfig(config *maintenance.MaintenanceConfig) error {
-	if h.adminServer == nil {
-		return fmt.Errorf("admin server not initialized")
-	}
-	// Delegate to AdminServer's real persistence method
-	return h.adminServer.UpdateMaintenanceConfigData(config)
-}
-
-// saveTaskConfigToProtobuf saves task configuration to protobuf file
-func (h *MaintenanceHandlers) saveTaskConfigToProtobuf(taskType types.TaskType, config TaskConfig) error {
-	configPersistence := h.adminServer.GetConfigPersistence()
-	if configPersistence == nil {
-		return fmt.Errorf("config persistence not available")
-	}
-
-	// Use the new ToTaskPolicy method - much simpler and more maintainable!
-	taskPolicy := config.ToTaskPolicy()
-
-	// Save using task-specific methods
-	switch taskType {
-	case types.TaskTypeVacuum:
-		return configPersistence.SaveVacuumTaskPolicy(taskPolicy)
-	case types.TaskTypeErasureCoding:
-		return configPersistence.SaveErasureCodingTaskPolicy(taskPolicy)
-	case types.TaskTypeBalance:
-		return configPersistence.SaveBalanceTaskPolicy(taskPolicy)
-	default:
-		return fmt.Errorf("unsupported task type for protobuf persistence: %s", taskType)
-	}
-}

weed/admin/handlers/maintenance_handlers_test.go

@@ -1,389 +0,0 @@
-package handlers
-
-import (
-	"net/url"
-	"testing"
-
-	"github.com/seaweedfs/seaweedfs/weed/admin/config"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/balance"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/base"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/erasure_coding"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/vacuum"
-)
-
-func TestParseTaskConfigFromForm_WithEmbeddedStruct(t *testing.T) {
-	// Create a maintenance handlers instance for testing
-	h := &MaintenanceHandlers{}
-
-	// Test with balance config
-	t.Run("Balance Config", func(t *testing.T) {
-		// Simulate form data
-		formData := url.Values{
-			"enabled":                     {"on"},      // checkbox field
-			"scan_interval_seconds_value": {"30"},      // interval field
-			"scan_interval_seconds_unit":  {"minutes"}, // interval unit
-			"max_concurrent":              {"2"},       // number field
-			"imbalance_threshold":         {"0.15"},    // float field
-			"min_server_count":            {"3"},       // number field
-		}
-
-		// Get schema
-		schema := tasks.GetTaskConfigSchema("balance")
-		if schema == nil {
-			t.Fatal("Failed to get balance schema")
-		}
-
-		// Create config instance
-		config := &balance.Config{}
-
-		// Parse form data
-		err := h.parseTaskConfigFromForm(formData, schema, config)
-		if err != nil {
-			t.Fatalf("Failed to parse form data: %v", err)
-		}
-
-		// Verify embedded struct fields were set correctly
-		if !config.Enabled {
-			t.Errorf("Expected Enabled=true, got %v", config.Enabled)
-		}
-
-		if config.ScanIntervalSeconds != 1800 { // 30 minutes * 60
-			t.Errorf("Expected ScanIntervalSeconds=1800, got %v", config.ScanIntervalSeconds)
-		}
-
-		if config.MaxConcurrent != 2 {
-			t.Errorf("Expected MaxConcurrent=2, got %v", config.MaxConcurrent)
-		}
-
-		// Verify balance-specific fields were set correctly
-		if config.ImbalanceThreshold != 0.15 {
-			t.Errorf("Expected ImbalanceThreshold=0.15, got %v", config.ImbalanceThreshold)
-		}
-
-		if config.MinServerCount != 3 {
-			t.Errorf("Expected MinServerCount=3, got %v", config.MinServerCount)
-		}
-	})
-
-	// Test with vacuum config
-	t.Run("Vacuum Config", func(t *testing.T) {
-		// Simulate form data
-		formData := url.Values{
-			// "enabled" field omitted to simulate unchecked checkbox
-			"scan_interval_seconds_value":  {"4"},     // interval field
-			"scan_interval_seconds_unit":   {"hours"}, // interval unit
-			"max_concurrent":               {"3"},     // number field
-			"garbage_threshold":            {"0.4"},   // float field
-			"min_volume_age_seconds_value": {"2"},     // interval field
-			"min_volume_age_seconds_unit":  {"days"},  // interval unit
-			"min_interval_seconds_value":   {"1"},     // interval field
-			"min_interval_seconds_unit":    {"days"},  // interval unit
-		}
-
-		// Get schema
-		schema := tasks.GetTaskConfigSchema("vacuum")
-		if schema == nil {
-			t.Fatal("Failed to get vacuum schema")
-		}
-
-		// Create config instance
-		config := &vacuum.Config{}
-
-		// Parse form data
-		err := h.parseTaskConfigFromForm(formData, schema, config)
-		if err != nil {
-			t.Fatalf("Failed to parse form data: %v", err)
-		}
-
-		// Verify embedded struct fields were set correctly
-		if config.Enabled {
-			t.Errorf("Expected Enabled=false, got %v", config.Enabled)
-		}
-
-		if config.ScanIntervalSeconds != 14400 { // 4 hours * 3600
-			t.Errorf("Expected ScanIntervalSeconds=14400, got %v", config.ScanIntervalSeconds)
-		}
-
-		if config.MaxConcurrent != 3 {
-			t.Errorf("Expected MaxConcurrent=3, got %v", config.MaxConcurrent)
-		}
-
-		// Verify vacuum-specific fields were set correctly
-		if config.GarbageThreshold != 0.4 {
-			t.Errorf("Expected GarbageThreshold=0.4, got %v", config.GarbageThreshold)
-		}
-
-		if config.MinVolumeAgeSeconds != 172800 { // 2 days * 86400
-			t.Errorf("Expected MinVolumeAgeSeconds=172800, got %v", config.MinVolumeAgeSeconds)
-		}
-
-		if config.MinIntervalSeconds != 86400 { // 1 day * 86400
-			t.Errorf("Expected MinIntervalSeconds=86400, got %v", config.MinIntervalSeconds)
-		}
-	})
-
-	// Test with erasure coding config
-	t.Run("Erasure Coding Config", func(t *testing.T) {
-		// Simulate form data
-		formData := url.Values{
-			"enabled":                     {"on"},              // checkbox field
-			"scan_interval_seconds_value": {"2"},               // interval field
-			"scan_interval_seconds_unit":  {"hours"},           // interval unit
-			"max_concurrent":              {"1"},               // number field
-			"quiet_for_seconds_value":     {"10"},              // interval field
-			"quiet_for_seconds_unit":      {"minutes"},         // interval unit
-			"fullness_ratio":              {"0.85"},            // float field
-			"collection_filter":           {"test_collection"}, // string field
-			"min_size_mb":                 {"50"},              // number field
-		}
-
-		// Get schema
-		schema := tasks.GetTaskConfigSchema("erasure_coding")
-		if schema == nil {
-			t.Fatal("Failed to get erasure_coding schema")
-		}
-
-		// Create config instance
-		config := &erasure_coding.Config{}
-
-		// Parse form data
-		err := h.parseTaskConfigFromForm(formData, schema, config)
-		if err != nil {
-			t.Fatalf("Failed to parse form data: %v", err)
-		}
-
-		// Verify embedded struct fields were set correctly
-		if !config.Enabled {
-			t.Errorf("Expected Enabled=true, got %v", config.Enabled)
-		}
-
-		if config.ScanIntervalSeconds != 7200 { // 2 hours * 3600
-			t.Errorf("Expected ScanIntervalSeconds=7200, got %v", config.ScanIntervalSeconds)
-		}
-
-		if config.MaxConcurrent != 1 {
-			t.Errorf("Expected MaxConcurrent=1, got %v", config.MaxConcurrent)
-		}
-
-		// Verify erasure coding-specific fields were set correctly
-		if config.QuietForSeconds != 600 { // 10 minutes * 60
-			t.Errorf("Expected QuietForSeconds=600, got %v", config.QuietForSeconds)
-		}
-
-		if config.FullnessRatio != 0.85 {
-			t.Errorf("Expected FullnessRatio=0.85, got %v", config.FullnessRatio)
-		}
-
-		if config.CollectionFilter != "test_collection" {
-			t.Errorf("Expected CollectionFilter='test_collection', got %v", config.CollectionFilter)
-		}
-
-		if config.MinSizeMB != 50 {
-			t.Errorf("Expected MinSizeMB=50, got %v", config.MinSizeMB)
-		}
-	})
-}
-
-func TestConfigurationValidation(t *testing.T) {
-	// Test that config structs can be validated and converted to protobuf format
-	taskTypes := []struct {
-		name   string
-		config interface{}
-	}{
-		{
-			"balance",
-			&balance.Config{
-				BaseConfig: base.BaseConfig{
-					Enabled:             true,
-					ScanIntervalSeconds: 2400,
-					MaxConcurrent:       3,
-				},
-				ImbalanceThreshold: 0.18,
-				MinServerCount:     4,
-			},
-		},
-		{
-			"vacuum",
-			&vacuum.Config{
-				BaseConfig: base.BaseConfig{
-					Enabled:             false,
-					ScanIntervalSeconds: 7200,
-					MaxConcurrent:       2,
-				},
-				GarbageThreshold:    0.35,
-				MinVolumeAgeSeconds: 86400,
-				MinIntervalSeconds:  604800,
-			},
-		},
-		{
-			"erasure_coding",
-			&erasure_coding.Config{
-				BaseConfig: base.BaseConfig{
-					Enabled:             true,
-					ScanIntervalSeconds: 3600,
-					MaxConcurrent:       1,
-				},
-				QuietForSeconds:  900,
-				FullnessRatio:    0.9,
-				CollectionFilter: "important",
-				MinSizeMB:        100,
-			},
-		},
-	}
-
-	for _, test := range taskTypes {
-		t.Run(test.name, func(t *testing.T) {
-			// Test that configs can be converted to protobuf TaskPolicy
-			switch cfg := test.config.(type) {
-			case *balance.Config:
-				policy := cfg.ToTaskPolicy()
-				if policy == nil {
-					t.Fatal("ToTaskPolicy returned nil")
-				}
-				if policy.Enabled != cfg.Enabled {
-					t.Errorf("Expected Enabled=%v, got %v", cfg.Enabled, policy.Enabled)
-				}
-				if policy.MaxConcurrent != int32(cfg.MaxConcurrent) {
-					t.Errorf("Expected MaxConcurrent=%v, got %v", cfg.MaxConcurrent, policy.MaxConcurrent)
-				}
-			case *vacuum.Config:
-				policy := cfg.ToTaskPolicy()
-				if policy == nil {
-					t.Fatal("ToTaskPolicy returned nil")
-				}
-				if policy.Enabled != cfg.Enabled {
-					t.Errorf("Expected Enabled=%v, got %v", cfg.Enabled, policy.Enabled)
-				}
-				if policy.MaxConcurrent != int32(cfg.MaxConcurrent) {
-					t.Errorf("Expected MaxConcurrent=%v, got %v", cfg.MaxConcurrent, policy.MaxConcurrent)
-				}
-			case *erasure_coding.Config:
-				policy := cfg.ToTaskPolicy()
-				if policy == nil {
-					t.Fatal("ToTaskPolicy returned nil")
-				}
-				if policy.Enabled != cfg.Enabled {
-					t.Errorf("Expected Enabled=%v, got %v", cfg.Enabled, policy.Enabled)
-				}
-				if policy.MaxConcurrent != int32(cfg.MaxConcurrent) {
-					t.Errorf("Expected MaxConcurrent=%v, got %v", cfg.MaxConcurrent, policy.MaxConcurrent)
-				}
-			default:
-				t.Fatalf("Unknown config type: %T", test.config)
-			}
-
-			// Test that configs can be validated
-			switch cfg := test.config.(type) {
-			case *balance.Config:
-				if err := cfg.Validate(); err != nil {
-					t.Errorf("Validation failed: %v", err)
-				}
-			case *vacuum.Config:
-				if err := cfg.Validate(); err != nil {
-					t.Errorf("Validation failed: %v", err)
-				}
-			case *erasure_coding.Config:
-				if err := cfg.Validate(); err != nil {
-					t.Errorf("Validation failed: %v", err)
-				}
-			}
-		})
-	}
-}
-
-func TestParseFieldFromForm_EdgeCases(t *testing.T) {
-	h := &MaintenanceHandlers{}
-
-	// Test checkbox parsing (boolean fields)
-	t.Run("Checkbox Fields", func(t *testing.T) {
-		tests := []struct {
-			name          string
-			formData      url.Values
-			expectedValue bool
-		}{
-			{"Checked checkbox", url.Values{"test_field": {"on"}}, true},
-			{"Unchecked checkbox", url.Values{}, false},
-			{"Empty value checkbox", url.Values{"test_field": {""}}, true}, // Present but empty means checked
-		}
-
-		for _, test := range tests {
-			t.Run(test.name, func(t *testing.T) {
-				schema := &tasks.TaskConfigSchema{
-					Schema: config.Schema{
-						Fields: []*config.Field{
-							{
-								JSONName:  "test_field",
-								Type:      config.FieldTypeBool,
-								InputType: "checkbox",
-							},
-						},
-					},
-				}
-
-				type TestConfig struct {
-					TestField bool `json:"test_field"`
-				}
-
-				config := &TestConfig{}
-				err := h.parseTaskConfigFromForm(test.formData, schema, config)
-				if err != nil {
-					t.Fatalf("parseTaskConfigFromForm failed: %v", err)
-				}
-
-				if config.TestField != test.expectedValue {
-					t.Errorf("Expected %v, got %v", test.expectedValue, config.TestField)
-				}
-			})
-		}
-	})
-
-	// Test interval parsing
-	t.Run("Interval Fields", func(t *testing.T) {
-		tests := []struct {
-			name         string
-			value        string
-			unit         string
-			expectedSecs int
-		}{
-			{"Minutes", "30", "minutes", 1800},
-			{"Hours", "2", "hours", 7200},
-			{"Days", "1", "days", 86400},
-		}
-
-		for _, test := range tests {
-			t.Run(test.name, func(t *testing.T) {
-				formData := url.Values{
-					"test_field_value": {test.value},
-					"test_field_unit":  {test.unit},
-				}
-
-				schema := &tasks.TaskConfigSchema{
-					Schema: config.Schema{
-						Fields: []*config.Field{
-							{
-								JSONName:  "test_field",
-								Type:      config.FieldTypeInterval,
-								InputType: "interval",
-							},
-						},
-					},
-				}
-
-				type TestConfig struct {
-					TestField int `json:"test_field"`
-				}
-
-				config := &TestConfig{}
-				err := h.parseTaskConfigFromForm(formData, schema, config)
-				if err != nil {
-					t.Fatalf("parseTaskConfigFromForm failed: %v", err)
-				}
-
-				if config.TestField != test.expectedSecs {
-					t.Errorf("Expected %d seconds, got %d", test.expectedSecs, config.TestField)
-				}
-			})
-		}
-	})
-}

weed/admin/handlers/mq_handlers.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
 	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
@@ -23,146 +23,152 @@ func NewMessageQueueHandlers(adminServer *dash.AdminServer) *MessageQueueHandler
 }
 
 // ShowBrokers renders the message queue brokers page
-func (h *MessageQueueHandlers) ShowBrokers(c *gin.Context) {
+func (h *MessageQueueHandlers) ShowBrokers(w http.ResponseWriter, r *http.Request) {
 	// Get cluster brokers data
 	brokersData, err := h.adminServer.GetClusterBrokers()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get cluster brokers: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get cluster brokers: "+err.Error())
 		return
 	}
 
 	// Set username
-	username := c.GetString("username")
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 	brokersData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	brokersComponent := app.ClusterBrokers(*brokersData)
-	layoutComponent := layout.Layout(c, brokersComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, brokersComponent)
+	err = layoutComponent.Render(r.Context(), w)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowTopics renders the message queue topics page
-func (h *MessageQueueHandlers) ShowTopics(c *gin.Context) {
+func (h *MessageQueueHandlers) ShowTopics(w http.ResponseWriter, r *http.Request) {
 	// Get topics data
 	topicsData, err := h.adminServer.GetTopics()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get topics: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get topics: "+err.Error())
 		return
 	}
 
 	// Set username
-	username := c.GetString("username")
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 	topicsData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	topicsComponent := app.Topics(*topicsData)
-	layoutComponent := layout.Layout(c, topicsComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, topicsComponent)
+	err = layoutComponent.Render(r.Context(), w)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowSubscribers renders the message queue subscribers page
-func (h *MessageQueueHandlers) ShowSubscribers(c *gin.Context) {
+func (h *MessageQueueHandlers) ShowSubscribers(w http.ResponseWriter, r *http.Request) {
 	// Get subscribers data
 	subscribersData, err := h.adminServer.GetSubscribers()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get subscribers: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get subscribers: "+err.Error())
 		return
 	}
 
 	// Set username
-	username := c.GetString("username")
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 	subscribersData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	subscribersComponent := app.Subscribers(*subscribersData)
-	layoutComponent := layout.Layout(c, subscribersComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, subscribersComponent)
+	err = layoutComponent.Render(r.Context(), w)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // ShowTopicDetails renders the topic details page
-func (h *MessageQueueHandlers) ShowTopicDetails(c *gin.Context) {
+func (h *MessageQueueHandlers) ShowTopicDetails(w http.ResponseWriter, r *http.Request) {
 	// Get topic parameters from URL
-	namespace := c.Param("namespace")
-	topicName := c.Param("topic")
+	vars := mux.Vars(r)
+	namespace := vars["namespace"]
+	topicName := vars["topic"]
 
 	if namespace == "" || topicName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Missing namespace or topic name"})
+		writeJSONError(w, http.StatusBadRequest, "Missing namespace or topic name")
 		return
 	}
 
 	// Get topic details data
 	topicDetailsData, err := h.adminServer.GetTopicDetails(namespace, topicName)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get topic details: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get topic details: "+err.Error())
 		return
 	}
 
 	// Set username
-	username := c.GetString("username")
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 	topicDetailsData.Username = username
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	topicDetailsComponent := app.TopicDetails(*topicDetailsData)
-	layoutComponent := layout.Layout(c, topicDetailsComponent)
-	err = layoutComponent.Render(c.Request.Context(), c.Writer)
+	viewCtx := layout.NewViewContext(r, username, dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, topicDetailsComponent)
+	err = layoutComponent.Render(r.Context(), w)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // GetTopicDetailsAPI returns topic details as JSON for AJAX calls
-func (h *MessageQueueHandlers) GetTopicDetailsAPI(c *gin.Context) {
+func (h *MessageQueueHandlers) GetTopicDetailsAPI(w http.ResponseWriter, r *http.Request) {
 	// Get topic parameters from URL
-	namespace := c.Param("namespace")
-	topicName := c.Param("topic")
+	vars := mux.Vars(r)
+	namespace := vars["namespace"]
+	topicName := vars["topic"]
 
 	if namespace == "" || topicName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Missing namespace or topic name"})
+		writeJSONError(w, http.StatusBadRequest, "Missing namespace or topic name")
 		return
 	}
 
 	// Get topic details data
 	topicDetailsData, err := h.adminServer.GetTopicDetails(namespace, topicName)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get topic details: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get topic details: "+err.Error())
 		return
 	}
 
 	// Return JSON data
-	c.JSON(http.StatusOK, topicDetailsData)
+	writeJSON(w, http.StatusOK, topicDetailsData)
 }
 
 // CreateTopicAPI creates a new topic with retention configuration
-func (h *MessageQueueHandlers) CreateTopicAPI(c *gin.Context) {
+func (h *MessageQueueHandlers) CreateTopicAPI(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		Namespace      string `json:"namespace" binding:"required"`
 		Name           string `json:"name" binding:"required"`
@@ -173,30 +179,30 @@ func (h *MessageQueueHandlers) CreateTopicAPI(c *gin.Context) {
 		} `json:"retention"`
 	}
 
-	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
 	}
 
 	// Validate inputs
 	if req.PartitionCount < 1 || req.PartitionCount > 100 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Partition count must be between 1 and 100"})
+		writeJSONError(w, http.StatusBadRequest, "Partition count must be between 1 and 100")
 		return
 	}
 
 	if req.Retention.Enabled && req.Retention.RetentionSeconds <= 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Retention seconds must be positive when retention is enabled"})
+		writeJSONError(w, http.StatusBadRequest, "Retention seconds must be positive when retention is enabled")
 		return
 	}
 
 	// Create the topic via admin server
 	err := h.adminServer.CreateTopicWithRetention(req.Namespace, req.Name, req.PartitionCount, req.Retention.Enabled, req.Retention.RetentionSeconds)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create topic: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create topic: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "Topic created successfully",
 		"topic":   fmt.Sprintf("%s.%s", req.Namespace, req.Name),
 	})
@@ -211,27 +217,27 @@ type UpdateTopicRetentionRequest struct {
 	} `json:"retention"`
 }
 
-func (h *MessageQueueHandlers) UpdateTopicRetentionAPI(c *gin.Context) {
+func (h *MessageQueueHandlers) UpdateTopicRetentionAPI(w http.ResponseWriter, r *http.Request) {
 	var request UpdateTopicRetentionRequest
-	if err := c.ShouldBindJSON(&request); err != nil {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+	if err := decodeJSONBody(newJSONMaxReader(w, r), &request); err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
 	// Validate required fields
 	if request.Namespace == "" || request.Name == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "namespace and name are required"})
+		writeJSONError(w, http.StatusBadRequest, "namespace and name are required")
 		return
 	}
 
 	// Update the topic retention
 	err := h.adminServer.UpdateTopicRetention(request.Namespace, request.Name, request.Retention.Enabled, request.Retention.RetentionSeconds)
 	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{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "Topic retention updated successfully",
 		"topic":   request.Namespace + "." + request.Name,
 	})

weed/admin/handlers/plugin_handlers.go

@@ -1,95 +1,69 @@
 package handlers
 
 import (
-"net/http"
+	"bytes"
+	"net/http"
 
-"github.com/gin-gonic/gin"
+	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
+	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
+	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
 )
 
+// PluginHandlers handles plugin UI pages.
 type PluginHandlers struct {
-adminServer interface{}
-pluginMgr   interface{}
+	adminServer *dash.AdminServer
 }
 
-func NewPluginHandlers(adminServer interface{}, pluginMgr interface{}) *PluginHandlers {
-return &PluginHandlers{
-adminServer: adminServer,
-pluginMgr:   pluginMgr,
-}
+// NewPluginHandlers creates a new instance of PluginHandlers.
+func NewPluginHandlers(adminServer *dash.AdminServer) *PluginHandlers {
+	return &PluginHandlers{
+		adminServer: adminServer,
+	}
 }
 
-// ListPluginsAPI returns list of connected plugins
-func (h *PluginHandlers) ListPluginsAPI(c *gin.Context) {
-result := []map[string]interface{}{}
-c.JSON(http.StatusOK, result)
+// ShowPlugin displays plugin overview page.
+func (h *PluginHandlers) ShowPlugin(w http.ResponseWriter, r *http.Request) {
+	h.renderPluginPage(w, r, "overview")
 }
 
-// ListJobsAPI returns jobs for a specific type
-func (h *PluginHandlers) ListJobsAPI(c *gin.Context) {
-jobType := c.Param("type")
-result := map[string]interface{}{
-"job_type": jobType,
-"jobs":     []interface{}{},
-}
-c.JSON(http.StatusOK, result)
+// ShowPluginConfiguration displays plugin configuration page.
+func (h *PluginHandlers) ShowPluginConfiguration(w http.ResponseWriter, r *http.Request) {
+	h.renderPluginPage(w, r, "configuration")
 }
 
-// GetConfigAPI returns configuration for a job type
-func (h *PluginHandlers) GetConfigAPI(c *gin.Context) {
-jobType := c.Param("type")
-result := map[string]interface{}{
-"type": jobType,
-}
-c.JSON(http.StatusOK, result)
+// ShowPluginDetection displays plugin detection jobs page.
+func (h *PluginHandlers) ShowPluginDetection(w http.ResponseWriter, r *http.Request) {
+	h.renderPluginPage(w, r, "detection")
 }
 
-// SaveConfigAPI saves configuration for a job type
-func (h *PluginHandlers) SaveConfigAPI(c *gin.Context) {
-jobType := c.Param("type")
-result := map[string]string{
-"status": "saved",
-"type":   jobType,
-}
-c.JSON(http.StatusOK, result)
+// ShowPluginQueue displays plugin job queue page.
+func (h *PluginHandlers) ShowPluginQueue(w http.ResponseWriter, r *http.Request) {
+	h.renderPluginPage(w, r, "queue")
 }
 
-// GetDetectionHistoryAPI returns detection history for a job type
-func (h *PluginHandlers) GetDetectionHistoryAPI(c *gin.Context) {
-jobType := c.Param("type")
-result := map[string]interface{}{
-"job_type": jobType,
-"records":  []interface{}{},
-}
-c.JSON(http.StatusOK, result)
+// ShowPluginExecution displays plugin execution jobs page.
+func (h *PluginHandlers) ShowPluginExecution(w http.ResponseWriter, r *http.Request) {
+	h.renderPluginPage(w, r, "execution")
 }
 
-// GetExecutionHistoryAPI returns execution history for a job type
-func (h *PluginHandlers) GetExecutionHistoryAPI(c *gin.Context) {
-jobType := c.Param("type")
-result := map[string]interface{}{
-"job_type": jobType,
-"records":  []interface{}{},
-}
-c.JSON(http.StatusOK, result)
+// ShowPluginMonitoring displays plugin monitoring page.
+func (h *PluginHandlers) ShowPluginMonitoring(w http.ResponseWriter, r *http.Request) {
+	// Backward-compatible alias for the old monitoring URL.
+	h.renderPluginPage(w, r, "detection")
 }
 
-// TriggerDetectionAPI manually triggers detection
-func (h *PluginHandlers) TriggerDetectionAPI(c *gin.Context) {
-jobType := c.Param("type")
-result := map[string]interface{}{
-"status":   "triggered",
-"job_type": jobType,
-"job_ids":  []string{},
-}
-c.JSON(http.StatusOK, result)
-}
+func (h *PluginHandlers) renderPluginPage(w http.ResponseWriter, r *http.Request, page string) {
+	component := app.Plugin(page)
+	viewCtx := layout.NewViewContext(r, dash.UsernameFromContext(r.Context()), dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, component)
 
-// CancelJobAPI cancels a job
-func (h *PluginHandlers) CancelJobAPI(c *gin.Context) {
-jobID := c.Param("id")
-result := map[string]string{
-"status": "cancelled",
-"job_id": jobID,
-}
-c.JSON(http.StatusOK, result)
+	var buf bytes.Buffer
+	if err := layoutComponent.Render(r.Context(), &buf); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(buf.Bytes())
 }

weed/admin/handlers/policy_handlers.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
 	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
@@ -26,53 +26,53 @@ func NewPolicyHandlers(adminServer *dash.AdminServer) *PolicyHandlers {
 }
 
 // ShowPolicies renders the policies management page
-func (h *PolicyHandlers) ShowPolicies(c *gin.Context) {
+func (h *PolicyHandlers) ShowPolicies(w http.ResponseWriter, r *http.Request) {
 	// Get policies data from the server
-	policiesData := h.getPoliciesData(c)
+	policiesData := h.getPoliciesData(r)
 
 	// Render HTML template
-	c.Header("Content-Type", "text/html")
+	w.Header().Set("Content-Type", "text/html")
 	policiesComponent := app.Policies(policiesData)
-	layoutComponent := layout.Layout(c, policiesComponent)
-	err := layoutComponent.Render(c.Request.Context(), c.Writer)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+	viewCtx := layout.NewViewContext(r, dash.UsernameFromContext(r.Context()), dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, policiesComponent)
+	if err := layoutComponent.Render(r.Context(), w); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // GetPolicies returns the list of policies as JSON
-func (h *PolicyHandlers) GetPolicies(c *gin.Context) {
+func (h *PolicyHandlers) GetPolicies(w http.ResponseWriter, r *http.Request) {
 	policies, err := h.adminServer.GetPolicies()
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get policies: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get policies: "+err.Error())
 		return
 	}
-	c.JSON(http.StatusOK, gin.H{"policies": policies})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"policies": policies})
 }
 
 // CreatePolicy handles policy creation
-func (h *PolicyHandlers) CreatePolicy(c *gin.Context) {
+func (h *PolicyHandlers) CreatePolicy(w http.ResponseWriter, r *http.Request) {
 	var req dash.CreatePolicyRequest
-	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
 	}
 
 	// Validate policy name
 	if req.Name == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Policy name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Policy name is required")
 		return
 	}
 
 	// Check if policy already exists
 	existingPolicy, err := h.adminServer.GetPolicy(req.Name)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to check existing policy: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to check existing policy: "+err.Error())
 		return
 	}
 	if existingPolicy != nil {
-		c.JSON(http.StatusConflict, gin.H{"error": "Policy with this name already exists"})
+		writeJSONError(w, http.StatusConflict, "Policy with this name already exists")
 		return
 	}
 
@@ -80,11 +80,11 @@ func (h *PolicyHandlers) CreatePolicy(c *gin.Context) {
 	err = h.adminServer.CreatePolicy(req.Name, req.Document)
 	if err != nil {
 		glog.Errorf("Failed to create policy %s: %v", req.Name, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create policy: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create policy: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusCreated, gin.H{
+	writeJSON(w, http.StatusCreated, map[string]interface{}{
 		"success": true,
 		"message": "Policy created successfully",
 		"policy":  req.Name,
@@ -92,49 +92,49 @@ func (h *PolicyHandlers) CreatePolicy(c *gin.Context) {
 }
 
 // GetPolicy returns a specific policy
-func (h *PolicyHandlers) GetPolicy(c *gin.Context) {
-	policyName := c.Param("name")
+func (h *PolicyHandlers) GetPolicy(w http.ResponseWriter, r *http.Request) {
+	policyName := mux.Vars(r)["name"]
 	if policyName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Policy name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Policy name is required")
 		return
 	}
 
 	policy, err := h.adminServer.GetPolicy(policyName)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get policy: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get policy: "+err.Error())
 		return
 	}
 
 	if policy == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "Policy not found"})
+		writeJSONError(w, http.StatusNotFound, "Policy not found")
 		return
 	}
 
-	c.JSON(http.StatusOK, policy)
+	writeJSON(w, http.StatusOK, policy)
 }
 
 // UpdatePolicy handles policy updates
-func (h *PolicyHandlers) UpdatePolicy(c *gin.Context) {
-	policyName := c.Param("name")
+func (h *PolicyHandlers) UpdatePolicy(w http.ResponseWriter, r *http.Request) {
+	policyName := mux.Vars(r)["name"]
 	if policyName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Policy name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Policy name is required")
 		return
 	}
 
 	var req dash.UpdatePolicyRequest
-	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
 	}
 
 	// Check if policy exists
 	existingPolicy, err := h.adminServer.GetPolicy(policyName)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to check existing policy: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to check existing policy: "+err.Error())
 		return
 	}
 	if existingPolicy == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "Policy not found"})
+		writeJSONError(w, http.StatusNotFound, "Policy not found")
 		return
 	}
 
@@ -142,11 +142,11 @@ func (h *PolicyHandlers) UpdatePolicy(c *gin.Context) {
 	err = h.adminServer.UpdatePolicy(policyName, req.Document)
 	if err != nil {
 		glog.Errorf("Failed to update policy %s: %v", policyName, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update policy: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to update policy: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"success": true,
 		"message": "Policy updated successfully",
 		"policy":  policyName,
@@ -154,21 +154,21 @@ func (h *PolicyHandlers) UpdatePolicy(c *gin.Context) {
 }
 
 // DeletePolicy handles policy deletion
-func (h *PolicyHandlers) DeletePolicy(c *gin.Context) {
-	policyName := c.Param("name")
+func (h *PolicyHandlers) DeletePolicy(w http.ResponseWriter, r *http.Request) {
+	policyName := mux.Vars(r)["name"]
 	if policyName == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Policy name is required"})
+		writeJSONError(w, http.StatusBadRequest, "Policy name is required")
 		return
 	}
 
 	// Check if policy exists
 	existingPolicy, err := h.adminServer.GetPolicy(policyName)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to check existing policy: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to check existing policy: "+err.Error())
 		return
 	}
 	if existingPolicy == nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "Policy not found"})
+		writeJSONError(w, http.StatusNotFound, "Policy not found")
 		return
 	}
 
@@ -176,11 +176,11 @@ func (h *PolicyHandlers) DeletePolicy(c *gin.Context) {
 	err = h.adminServer.DeletePolicy(policyName)
 	if err != nil {
 		glog.Errorf("Failed to delete policy %s: %v", policyName, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete policy: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to delete policy: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"success": true,
 		"message": "Policy deleted successfully",
 		"policy":  policyName,
@@ -188,60 +188,54 @@ func (h *PolicyHandlers) DeletePolicy(c *gin.Context) {
 }
 
 // ValidatePolicy validates a policy document without saving it
-func (h *PolicyHandlers) ValidatePolicy(c *gin.Context) {
+func (h *PolicyHandlers) ValidatePolicy(w http.ResponseWriter, r *http.Request) {
 	var req struct {
-		Document policy_engine.PolicyDocument `json:"document" binding:"required"`
+		Document policy_engine.PolicyDocument `json:"document"`
 	}
 
-	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
 	}
 
 	// Basic validation
 	if req.Document.Version == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Policy version is required"})
+		writeJSONError(w, http.StatusBadRequest, "Policy version is required")
 		return
 	}
 
 	if len(req.Document.Statement) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Policy must have at least one statement"})
+		writeJSONError(w, http.StatusBadRequest, "Policy must have at least one statement")
 		return
 	}
 
 	// Validate each statement
 	for i, statement := range req.Document.Statement {
 		if statement.Effect != "Allow" && statement.Effect != "Deny" {
-			c.JSON(http.StatusBadRequest, gin.H{
-				"error": fmt.Sprintf("Statement %d: Effect must be 'Allow' or 'Deny'", i+1),
-			})
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("Statement %d: Effect must be 'Allow' or 'Deny'", i+1))
 			return
 		}
 
 		if len(statement.Action.Strings()) == 0 {
-			c.JSON(http.StatusBadRequest, gin.H{
-				"error": fmt.Sprintf("Statement %d: Action is required", i+1),
-			})
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("Statement %d: Action is required", i+1))
 			return
 		}
 
 		if len(statement.Resource.Strings()) == 0 {
-			c.JSON(http.StatusBadRequest, gin.H{
-				"error": fmt.Sprintf("Statement %d: Resource is required", i+1),
-			})
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("Statement %d: Resource is required", i+1))
 			return
 		}
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"valid":   true,
 		"message": "Policy document is valid",
 	})
 }
 
 // getPoliciesData retrieves policies data from the server
-func (h *PolicyHandlers) getPoliciesData(c *gin.Context) dash.PoliciesData {
-	username := c.GetString("username")
+func (h *PolicyHandlers) getPoliciesData(r *http.Request) dash.PoliciesData {
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}

weed/admin/handlers/service_account_handlers.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
 	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
@@ -26,153 +26,154 @@ func NewServiceAccountHandlers(adminServer *dash.AdminServer) *ServiceAccountHan
 }
 
 // ShowServiceAccounts renders the service accounts management page
-func (h *ServiceAccountHandlers) ShowServiceAccounts(c *gin.Context) {
-	data := h.getServiceAccountsData(c)
+func (h *ServiceAccountHandlers) ShowServiceAccounts(w http.ResponseWriter, r *http.Request) {
+	data := h.getServiceAccountsData(r)
 
 	// Render to buffer first to avoid partial writes on error
 	var buf bytes.Buffer
 	component := app.ServiceAccounts(data)
-	layoutComponent := layout.Layout(c, component)
-	err := layoutComponent.Render(c.Request.Context(), &buf)
+	viewCtx := layout.NewViewContext(r, dash.UsernameFromContext(r.Context()), dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, component)
+	err := layoutComponent.Render(r.Context(), &buf)
 	if err != nil {
 		glog.Errorf("Failed to render service accounts template: %v", err)
-		c.AbortWithStatus(http.StatusInternalServerError)
+		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
 	// Only write to response if render succeeded
-	c.Header("Content-Type", "text/html")
-	c.Writer.Write(buf.Bytes())
+	w.Header().Set("Content-Type", "text/html")
+	_, _ = w.Write(buf.Bytes())
 }
 
 // GetServiceAccounts returns the list of service accounts as JSON
-func (h *ServiceAccountHandlers) GetServiceAccounts(c *gin.Context) {
-	parentUser := c.Query("parent_user")
+func (h *ServiceAccountHandlers) GetServiceAccounts(w http.ResponseWriter, r *http.Request) {
+	parentUser := r.URL.Query().Get("parent_user")
 
-	accounts, err := h.adminServer.GetServiceAccounts(c.Request.Context(), parentUser)
+	accounts, err := h.adminServer.GetServiceAccounts(r.Context(), parentUser)
 	if err != nil {
 		glog.Errorf("Failed to get service accounts: %v", err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get service accounts"})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get service accounts")
 		return
 	}
-	c.JSON(http.StatusOK, gin.H{"service_accounts": accounts})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"service_accounts": accounts})
 }
 
 // CreateServiceAccount handles service account creation
-func (h *ServiceAccountHandlers) CreateServiceAccount(c *gin.Context) {
+func (h *ServiceAccountHandlers) CreateServiceAccount(w http.ResponseWriter, r *http.Request) {
 	var req dash.CreateServiceAccountRequest
-	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 req.ParentUser == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "ParentUser is required"})
+		writeJSONError(w, http.StatusBadRequest, "ParentUser is required")
 		return
 	}
 
-	sa, err := h.adminServer.CreateServiceAccount(c.Request.Context(), req)
+	sa, err := h.adminServer.CreateServiceAccount(r.Context(), req)
 	if err != nil {
 		glog.Errorf("Failed to create service account for user %s: %v", req.ParentUser, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create service account"})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create service account")
 		return
 	}
 
-	c.JSON(http.StatusCreated, gin.H{
+	writeJSON(w, http.StatusCreated, map[string]interface{}{
 		"message":         "Service account created successfully",
 		"service_account": sa,
 	})
 }
 
 // GetServiceAccountDetails returns detailed information about a service account
-func (h *ServiceAccountHandlers) GetServiceAccountDetails(c *gin.Context) {
-	id := c.Param("id")
+func (h *ServiceAccountHandlers) GetServiceAccountDetails(w http.ResponseWriter, r *http.Request) {
+	id := mux.Vars(r)["id"]
 	if id == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Service account ID is required"})
+		writeJSONError(w, http.StatusBadRequest, "Service account ID is required")
 		return
 	}
 
-	sa, err := h.adminServer.GetServiceAccountDetails(c.Request.Context(), id)
+	sa, err := h.adminServer.GetServiceAccountDetails(r.Context(), id)
 	if err != nil {
 		// Distinguish not-found errors from internal errors
 		if errors.Is(err, dash.ErrServiceAccountNotFound) {
-			c.JSON(http.StatusNotFound, gin.H{"error": "Service account not found: " + err.Error()})
+			writeJSONError(w, http.StatusNotFound, "Service account not found: "+err.Error())
 		} else {
 			glog.Errorf("Failed to get service account details for %s: %v", id, err)
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get service account details"})
+			writeJSONError(w, http.StatusInternalServerError, "Failed to get service account details")
 		}
 		return
 	}
 
-	c.JSON(http.StatusOK, sa)
+	writeJSON(w, http.StatusOK, sa)
 }
 
 // UpdateServiceAccount handles service account updates
-func (h *ServiceAccountHandlers) UpdateServiceAccount(c *gin.Context) {
-	id := c.Param("id")
+func (h *ServiceAccountHandlers) UpdateServiceAccount(w http.ResponseWriter, r *http.Request) {
+	id := mux.Vars(r)["id"]
 	if id == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Service account ID is required"})
+		writeJSONError(w, http.StatusBadRequest, "Service account ID is required")
 		return
 	}
 
 	var req dash.UpdateServiceAccountRequest
-	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
 	}
 
-	sa, err := h.adminServer.UpdateServiceAccount(c.Request.Context(), id, req)
+	sa, err := h.adminServer.UpdateServiceAccount(r.Context(), id, req)
 	if err != nil {
 		// Distinguish not-found errors from internal errors
 		if errors.Is(err, dash.ErrServiceAccountNotFound) {
-			c.JSON(http.StatusNotFound, gin.H{"error": "Service account not found"})
+			writeJSONError(w, http.StatusNotFound, "Service account not found")
 		} else {
 			glog.Errorf("Failed to update service account %s: %v", id, err)
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update service account"})
+			writeJSONError(w, http.StatusInternalServerError, "Failed to update service account")
 		}
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message":         "Service account updated successfully",
 		"service_account": sa,
 	})
 }
 
 // DeleteServiceAccount handles service account deletion
-func (h *ServiceAccountHandlers) DeleteServiceAccount(c *gin.Context) {
-	id := c.Param("id")
+func (h *ServiceAccountHandlers) DeleteServiceAccount(w http.ResponseWriter, r *http.Request) {
+	id := mux.Vars(r)["id"]
 	if id == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Service account ID is required"})
+		writeJSONError(w, http.StatusBadRequest, "Service account ID is required")
 		return
 	}
 
-	err := h.adminServer.DeleteServiceAccount(c.Request.Context(), id)
+	err := h.adminServer.DeleteServiceAccount(r.Context(), id)
 	if err != nil {
 		// Distinguish not-found errors from internal errors
 		if errors.Is(err, dash.ErrServiceAccountNotFound) {
-			c.JSON(http.StatusNotFound, gin.H{"error": "Service account not found"})
+			writeJSONError(w, http.StatusNotFound, "Service account not found")
 		} else {
 			glog.Errorf("Failed to delete service account %s: %v", id, err)
-			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete service account"})
+			writeJSONError(w, http.StatusInternalServerError, "Failed to delete service account")
 		}
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "Service account deleted successfully",
 	})
 }
 
 // getServiceAccountsData retrieves service accounts data for the template
-func (h *ServiceAccountHandlers) getServiceAccountsData(c *gin.Context) dash.ServiceAccountsData {
-	username := c.GetString("username")
+func (h *ServiceAccountHandlers) getServiceAccountsData(r *http.Request) dash.ServiceAccountsData {
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 
 	// Get all service accounts
-	accounts, err := h.adminServer.GetServiceAccounts(c.Request.Context(), "")
+	accounts, err := h.adminServer.GetServiceAccounts(r.Context(), "")
 	if err != nil {
 		glog.Errorf("Failed to get service accounts: %v", err)
 		return dash.ServiceAccountsData{
@@ -193,7 +194,7 @@ func (h *ServiceAccountHandlers) getServiceAccountsData(c *gin.Context) dash.Ser
 
 	// Get available users for dropdown
 	var availableUsers []string
-	users, err := h.adminServer.GetObjectStoreUsers(c.Request.Context())
+	users, err := h.adminServer.GetObjectStoreUsers(r.Context())
 	if err != nil {
 		glog.Errorf("Failed to get users for dropdown: %v", err)
 	} else {

weed/admin/handlers/user_handlers.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/gin-gonic/gin"
+	"github.com/gorilla/mux"
 	"github.com/seaweedfs/seaweedfs/weed/admin/dash"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/app"
 	"github.com/seaweedfs/seaweedfs/weed/admin/view/layout"
@@ -25,256 +25,259 @@ func NewUserHandlers(adminServer *dash.AdminServer) *UserHandlers {
 }
 
 // ShowObjectStoreUsers renders the object store users management page
-func (h *UserHandlers) ShowObjectStoreUsers(c *gin.Context) {
+func (h *UserHandlers) ShowObjectStoreUsers(w http.ResponseWriter, r *http.Request) {
 	// Get object store users data from the server
-	usersData := h.getObjectStoreUsersData(c)
+	usersData := h.getObjectStoreUsersData(r)
 
 	// Render HTML template
 	// Add cache-control headers to prevent browser caching of inline JavaScript
-	c.Header("Content-Type", "text/html")
-	c.Header("Cache-Control", "no-cache, no-store, must-revalidate")
-	c.Header("Pragma", "no-cache")
-	c.Header("Expires", "0")
-	c.Header("ETag", fmt.Sprintf("\"%d\"", time.Now().Unix()))
+	w.Header().Set("Content-Type", "text/html")
+	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Expires", "0")
+	w.Header().Set("ETag", fmt.Sprintf("\"%d\"", time.Now().Unix()))
 	usersComponent := app.ObjectStoreUsers(usersData)
-	layoutComponent := layout.Layout(c, usersComponent)
-	err := layoutComponent.Render(c.Request.Context(), c.Writer)
+	viewCtx := layout.NewViewContext(r, dash.UsernameFromContext(r.Context()), dash.CSRFTokenFromContext(r.Context()))
+	layoutComponent := layout.Layout(viewCtx, usersComponent)
+	err := layoutComponent.Render(r.Context(), w)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to render template: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to render template: "+err.Error())
 		return
 	}
 }
 
 // GetUsers returns the list of users as JSON
-func (h *UserHandlers) GetUsers(c *gin.Context) {
-	users, err := h.adminServer.GetObjectStoreUsers(c.Request.Context())
+func (h *UserHandlers) GetUsers(w http.ResponseWriter, r *http.Request) {
+	users, err := h.adminServer.GetObjectStoreUsers(r.Context())
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get users: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get users: "+err.Error())
 		return
 	}
-	c.JSON(http.StatusOK, gin.H{"users": users})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"users": users})
 }
 
 // CreateUser handles user creation
-func (h *UserHandlers) CreateUser(c *gin.Context) {
+func (h *UserHandlers) CreateUser(w http.ResponseWriter, r *http.Request) {
 	var req dash.CreateUserRequest
-	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
 	}
 
 	// Validate required fields
 	if req.Username == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username is required"})
+		writeJSONError(w, http.StatusBadRequest, "Username is required")
 		return
 	}
 
 	user, err := h.adminServer.CreateObjectStoreUser(req)
 	if err != nil {
 		glog.Errorf("Failed to create user %s: %v", req.Username, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create user: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create user: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusCreated, gin.H{
+	writeJSON(w, http.StatusCreated, map[string]interface{}{
 		"message": "User created successfully",
 		"user":    user,
 	})
 }
 
 // UpdateUser handles user updates
-func (h *UserHandlers) UpdateUser(c *gin.Context) {
-	username := c.Param("username")
+func (h *UserHandlers) UpdateUser(w http.ResponseWriter, r *http.Request) {
+	username := mux.Vars(r)["username"]
 	if username == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username is required"})
+		writeJSONError(w, http.StatusBadRequest, "Username is required")
 		return
 	}
 
 	var req dash.UpdateUserRequest
-	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
 	}
 
 	user, err := h.adminServer.UpdateObjectStoreUser(username, req)
 	if err != nil {
 		glog.Errorf("Failed to update user %s: %v", username, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update user: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to update user: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "User updated successfully",
 		"user":    user,
 	})
 }
 
 // DeleteUser handles user deletion
-func (h *UserHandlers) DeleteUser(c *gin.Context) {
-	username := c.Param("username")
+func (h *UserHandlers) DeleteUser(w http.ResponseWriter, r *http.Request) {
+	username := mux.Vars(r)["username"]
 	if username == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username is required"})
+		writeJSONError(w, http.StatusBadRequest, "Username is required")
 		return
 	}
 
 	err := h.adminServer.DeleteObjectStoreUser(username)
 	if err != nil {
 		glog.Errorf("Failed to delete user %s: %v", username, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete user: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to delete user: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "User deleted successfully",
 	})
 }
 
 // GetUserDetails returns detailed information about a specific user
-func (h *UserHandlers) GetUserDetails(c *gin.Context) {
-	username := c.Param("username")
+func (h *UserHandlers) GetUserDetails(w http.ResponseWriter, r *http.Request) {
+	username := mux.Vars(r)["username"]
 	if username == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username is required"})
+		writeJSONError(w, http.StatusBadRequest, "Username is required")
 		return
 	}
 
 	user, err := h.adminServer.GetObjectStoreUserDetails(username)
 	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "User not found: " + err.Error()})
+		writeJSONError(w, http.StatusNotFound, "User not found: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, user)
+	writeJSON(w, http.StatusOK, user)
 }
 
 // CreateAccessKey creates a new access key for a user
-func (h *UserHandlers) CreateAccessKey(c *gin.Context) {
-	username := c.Param("username")
+func (h *UserHandlers) CreateAccessKey(w http.ResponseWriter, r *http.Request) {
+	username := mux.Vars(r)["username"]
 	if username == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username is required"})
+		writeJSONError(w, http.StatusBadRequest, "Username is required")
 		return
 	}
 
 	accessKey, err := h.adminServer.CreateAccessKey(username)
 	if err != nil {
 		glog.Errorf("Failed to create access key for user %s: %v", username, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create access key: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to create access key: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusCreated, gin.H{
+	writeJSON(w, http.StatusCreated, map[string]interface{}{
 		"message":    "Access key created successfully",
 		"access_key": accessKey,
 	})
 }
 
 // DeleteAccessKey deletes an access key for a user
-func (h *UserHandlers) DeleteAccessKey(c *gin.Context) {
-	username := c.Param("username")
-	accessKeyId := c.Param("accessKeyId")
+func (h *UserHandlers) DeleteAccessKey(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	username := vars["username"]
+	accessKeyId := vars["accessKeyId"]
 
 	if username == "" || accessKeyId == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username and access key ID are required"})
+		writeJSONError(w, http.StatusBadRequest, "Username and access key ID are required")
 		return
 	}
 
 	err := h.adminServer.DeleteAccessKey(username, accessKeyId)
 	if err != nil {
 		glog.Errorf("Failed to delete access key %s for user %s: %v", accessKeyId, username, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete access key: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to delete access key: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "Access key deleted successfully",
 	})
 }
 
 // UpdateAccessKeyStatus updates the status of an access key for a user
-func (h *UserHandlers) UpdateAccessKeyStatus(c *gin.Context) {
-	username := c.Param("username")
-	accessKeyId := c.Param("accessKeyId")
+func (h *UserHandlers) UpdateAccessKeyStatus(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	username := vars["username"]
+	accessKeyId := vars["accessKeyId"]
 
 	if username == "" || accessKeyId == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username and access key ID are required"})
+		writeJSONError(w, http.StatusBadRequest, "Username and access key ID are required")
 		return
 	}
 
 	var req dash.UpdateAccessKeyStatusRequest
-	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
 	}
 
 	// Validate status
 	if req.Status != dash.AccessKeyStatusActive && req.Status != dash.AccessKeyStatusInactive {
-		c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Status must be '%s' or '%s'", dash.AccessKeyStatusActive, dash.AccessKeyStatusInactive)})
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("Status must be '%s' or '%s'", dash.AccessKeyStatusActive, dash.AccessKeyStatusInactive))
 		return
 	}
 
 	err := h.adminServer.UpdateAccessKeyStatus(username, accessKeyId, req.Status)
 	if err != nil {
 		glog.Errorf("Failed to update access key status %s for user %s: %v", accessKeyId, username, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update access key status: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to update access key status: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "Access key updated successfully",
 	})
 }
 
 // GetUserPolicies returns the policies for a user
-func (h *UserHandlers) GetUserPolicies(c *gin.Context) {
-	username := c.Param("username")
+func (h *UserHandlers) GetUserPolicies(w http.ResponseWriter, r *http.Request) {
+	username := mux.Vars(r)["username"]
 	if username == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username is required"})
+		writeJSONError(w, http.StatusBadRequest, "Username is required")
 		return
 	}
 
 	policies, err := h.adminServer.GetUserPolicies(username)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get user policies: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to get user policies: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{"policies": policies})
+	writeJSON(w, http.StatusOK, map[string]interface{}{"policies": policies})
 }
 
 // UpdateUserPolicies updates the policies for a user
-func (h *UserHandlers) UpdateUserPolicies(c *gin.Context) {
-	username := c.Param("username")
+func (h *UserHandlers) UpdateUserPolicies(w http.ResponseWriter, r *http.Request) {
+	username := mux.Vars(r)["username"]
 	if username == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "Username is required"})
+		writeJSONError(w, http.StatusBadRequest, "Username is required")
 		return
 	}
 
 	var req dash.UpdateUserPoliciesRequest
-	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
 	}
 
 	err := h.adminServer.UpdateUserPolicies(username, req.Actions)
 	if err != nil {
 		glog.Errorf("Failed to update policies for user %s: %v", username, err)
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update user policies: " + err.Error()})
+		writeJSONError(w, http.StatusInternalServerError, "Failed to update user policies: "+err.Error())
 		return
 	}
 
-	c.JSON(http.StatusOK, gin.H{
+	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"message": "User policies updated successfully",
 	})
 }
 
 // getObjectStoreUsersData retrieves object store users data from the server
-func (h *UserHandlers) getObjectStoreUsersData(c *gin.Context) dash.ObjectStoreUsersData {
-	username := c.GetString("username")
+func (h *UserHandlers) getObjectStoreUsersData(r *http.Request) dash.ObjectStoreUsersData {
+	username := dash.UsernameFromContext(r.Context())
 	if username == "" {
 		username = "admin"
 	}
 
 	// Get object store users
-	users, err := h.adminServer.GetObjectStoreUsers(c.Request.Context())
+	users, err := h.adminServer.GetObjectStoreUsers(r.Context())
 	if err != nil {
 		glog.Errorf("Failed to get object store users: %v", err)
 		// Return empty data on error

weed/admin/internal/httputil/httputil.go

@@ -0,0 +1,42 @@
+package httputil
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+)
+
+const MaxJSONBodyBytes = 1 << 20
+
+func NewJSONMaxReader(w http.ResponseWriter, r *http.Request) io.Reader {
+	return http.MaxBytesReader(w, r.Body, MaxJSONBodyBytes)
+}
+
+func DecodeJSONBody(r io.Reader, v interface{}) error {
+	decoder := json.NewDecoder(r)
+	return decoder.Decode(v)
+}
+
+func WriteJSON(w http.ResponseWriter, status int, payload interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	if payload == nil {
+		return
+	}
+	if err := json.NewEncoder(w).Encode(payload); err != nil {
+		glog.Errorf("failed to encode JSON response (status=%d, payload=%T): %v", status, payload, err)
+	}
+}
+
+func WriteJSONError(w http.ResponseWriter, status int, message string) {
+	WriteJSON(w, status, map[string]string{"error": message})
+}
+
+func DefaultQuery(value, fallback string) string {
+	if value == "" {
+		return fallback
+	}
+	return value
+}

weed/admin/maintenance/maintenance_queue.go

@@ -130,10 +130,10 @@ func (mq *MaintenanceQueue) cleanupCompletedTasks() {
 // AddTask adds a new maintenance task to the queue with deduplication
 func (mq *MaintenanceQueue) AddTask(task *MaintenanceTask) {
 	mq.mutex.Lock()
-	defer mq.mutex.Unlock()
 
 	// Check for duplicate tasks (same type + volume + not completed)
 	if mq.hasDuplicateTask(task) {
+		mq.mutex.Unlock()
 		glog.V(1).Infof("Task skipped (duplicate): %s for volume %d on %s (already queued or running)",
 			task.Type, task.VolumeID, task.Server)
 		return
@@ -169,16 +169,23 @@ func (mq *MaintenanceQueue) AddTask(task *MaintenanceTask) {
 		return mq.pendingTasks[i].ScheduledAt.Before(mq.pendingTasks[j].ScheduledAt)
 	})
 
-	// Save task state to persistence
-	mq.saveTaskState(task)
-
 	scheduleInfo := ""
 	if !task.ScheduledAt.IsZero() && time.Until(task.ScheduledAt) > time.Minute {
 		scheduleInfo = fmt.Sprintf(", scheduled for %v", task.ScheduledAt.Format("15:04:05"))
 	}
 
+	// Snapshot task state while lock is still held to avoid data race;
+	// also capture log fields from the snapshot so the live task pointer
+	// is not accessed after mq.mutex is released.
+	taskSnapshot := snapshotTask(task)
+	mq.mutex.Unlock()
+
+	// Save task state to persistence outside the lock to avoid blocking
+	// RegisterWorker and HTTP handlers (GetTasks) during disk I/O
+	mq.saveTaskState(taskSnapshot)
+
 	glog.Infof("Task queued: %s (%s) volume %d on %s, priority %d%s, reason: %s",
-		task.ID, task.Type, task.VolumeID, task.Server, task.Priority, scheduleInfo, task.Reason)
+		taskSnapshot.ID, taskSnapshot.Type, taskSnapshot.VolumeID, taskSnapshot.Server, taskSnapshot.Priority, scheduleInfo, taskSnapshot.Reason)
 }
 
 // hasDuplicateTask checks if a similar task already exists (same type, volume, and not completed)
@@ -286,11 +293,14 @@ func (mq *MaintenanceQueue) GetNextTask(workerID string, capabilities []Maintena
 
 	// Now acquire write lock to actually assign the task
 	mq.mutex.Lock()
-	defer mq.mutex.Unlock()
+
+	// Capture ID before the re-check so it is available for logging after unlock.
+	selectedTaskID := selectedTask.ID
 
 	// Re-check that the task is still available (it might have been assigned to another worker)
-	if selectedIndex >= len(mq.pendingTasks) || mq.pendingTasks[selectedIndex].ID != selectedTask.ID {
-		glog.V(2).Infof("Task %s no longer available for worker %s: assigned to another worker", selectedTask.ID, workerID)
+	if selectedIndex >= len(mq.pendingTasks) || mq.pendingTasks[selectedIndex].ID != selectedTaskID {
+		mq.mutex.Unlock()
+		glog.V(2).Infof("Task %s no longer available for worker %s: assigned to another worker", selectedTaskID, workerID)
 		return nil
 	}
 
@@ -331,6 +341,7 @@ func (mq *MaintenanceQueue) GetNextTask(workerID string, capabilities []Maintena
 				if len(selectedTask.AssignmentHistory) > 0 {
 					selectedTask.AssignmentHistory = selectedTask.AssignmentHistory[:len(selectedTask.AssignmentHistory)-1]
 				}
+				mq.mutex.Unlock()
 				// Return nil so the task is not removed from pendingTasks and not returned to the worker
 				return nil
 			}
@@ -348,11 +359,15 @@ func (mq *MaintenanceQueue) GetNextTask(workerID string, capabilities []Maintena
 	// Track pending operation
 	mq.trackPendingOperation(selectedTask)
 
-	// Save task state after assignment
-	mq.saveTaskState(selectedTask)
+	// Snapshot task state while lock is still held to avoid data race
+	selectedSnapshot := snapshotTask(selectedTask)
+	mq.mutex.Unlock()
+
+	// Save task state to persistence outside the lock
+	mq.saveTaskState(selectedSnapshot)
 
 	glog.Infof("Task assigned: %s (%s) → worker %s (volume %d, server %s)",
-		selectedTask.ID, selectedTask.Type, workerID, selectedTask.VolumeID, selectedTask.Server)
+		selectedSnapshot.ID, selectedSnapshot.Type, workerID, selectedSnapshot.VolumeID, selectedSnapshot.Server)
 
 	return selectedTask
 }
@@ -360,10 +375,10 @@ func (mq *MaintenanceQueue) GetNextTask(workerID string, capabilities []Maintena
 // CompleteTask marks a task as completed
 func (mq *MaintenanceQueue) CompleteTask(taskID string, error string) {
 	mq.mutex.Lock()
-	defer mq.mutex.Unlock()
 
 	task, exists := mq.tasks[taskID]
 	if !exists {
+		mq.mutex.Unlock()
 		glog.Warningf("Attempted to complete non-existent task: %s", taskID)
 		return
 	}
@@ -388,6 +403,12 @@ func (mq *MaintenanceQueue) CompleteTask(taskID string, error string) {
 		duration = completedTime.Sub(*task.StartedAt)
 	}
 
+	// Capture workerID before it may be cleared during retry
+	originalWorkerID := task.WorkerID
+
+	var taskToSave *MaintenanceTask
+	var logFn func()
+
 	if error != "" {
 		task.Status = TaskStatusFailed
 		task.Error = error
@@ -420,10 +441,12 @@ func (mq *MaintenanceQueue) CompleteTask(taskID string, error string) {
 				mq.integration.SyncTask(task)
 			}
 
-			// Save task state after retry setup
-			mq.saveTaskState(task)
-			glog.Warningf("Task failed, scheduling retry: %s (%s) attempt %d/%d, worker %s, duration %v, error: %s",
-				taskID, task.Type, task.RetryCount, task.MaxRetries, task.WorkerID, duration, error)
+			taskToSave = task
+			retryCount, maxRetries := task.RetryCount, task.MaxRetries
+			logFn = func() {
+				glog.Warningf("Task failed, scheduling retry: %s (%s) attempt %d/%d, worker %s, duration %v, error: %s",
+					taskID, task.Type, retryCount, maxRetries, originalWorkerID, duration, error)
+			}
 		} else {
 			// Record unassignment due to permanent failure
 			if task.WorkerID != "" && len(task.AssignmentHistory) > 0 {
@@ -435,23 +458,27 @@ func (mq *MaintenanceQueue) CompleteTask(taskID string, error string) {
 				}
 			}
 
-			// Save task state after permanent failure
-			mq.saveTaskState(task)
-			glog.Errorf("Task failed permanently: %s (%s) worker %s, duration %v, after %d retries: %s",
-				taskID, task.Type, task.WorkerID, duration, task.MaxRetries, error)
+			taskToSave = task
+			maxRetries := task.MaxRetries
+			logFn = func() {
+				glog.Errorf("Task failed permanently: %s (%s) worker %s, duration %v, after %d retries: %s",
+					taskID, task.Type, originalWorkerID, duration, maxRetries, error)
+			}
 		}
 	} else {
 		task.Status = TaskStatusCompleted
 		task.Progress = 100
-		// Save task state after successful completion
-		mq.saveTaskState(task)
-		glog.Infof("Task completed: %s (%s) worker %s, duration %v, volume %d",
-			taskID, task.Type, task.WorkerID, duration, task.VolumeID)
+		taskToSave = task
+		volumeID := task.VolumeID
+		logFn = func() {
+			glog.Infof("Task completed: %s (%s) worker %s, duration %v, volume %d",
+				taskID, task.Type, originalWorkerID, duration, volumeID)
+		}
 	}
 
-	// Update worker
-	if task.WorkerID != "" {
-		if worker, exists := mq.workers[task.WorkerID]; exists {
+	// Update worker load and capture state before releasing lock
+	if originalWorkerID != "" {
+		if worker, exists := mq.workers[originalWorkerID]; exists {
 			worker.CurrentTask = nil
 			worker.CurrentLoad--
 			if worker.CurrentLoad == 0 {
@@ -459,16 +486,32 @@ func (mq *MaintenanceQueue) CompleteTask(taskID string, error string) {
 			}
 		}
 	}
+	taskStatus := task.Status
+	taskCount := len(mq.tasks)
+	// Snapshot task state while lock is still held to avoid data race
+	var taskToSaveSnapshot *MaintenanceTask
+	if taskToSave != nil {
+		taskToSaveSnapshot = snapshotTask(taskToSave)
+	}
+	mq.mutex.Unlock()
+
+	// Save task state to persistence outside the lock
+	if taskToSaveSnapshot != nil {
+		mq.saveTaskState(taskToSaveSnapshot)
+	}
+
+	if logFn != nil {
+		logFn()
+	}
 
 	// Remove pending operation (unless it's being retried)
-	if task.Status != TaskStatusPending {
+	if taskStatus != TaskStatusPending {
 		mq.removePendingOperation(taskID)
 	}
 
-	// Periodically cleanup old completed tasks (every 10th completion)
-	if task.Status == TaskStatusCompleted {
-		// Simple counter-based trigger for cleanup
-		if len(mq.tasks)%10 == 0 {
+	// Periodically cleanup old completed tasks (when total task count is a multiple of 10)
+	if taskStatus == TaskStatusCompleted {
+		if taskCount%10 == 0 {
 			go mq.cleanupCompletedTasks()
 		}
 	}
@@ -476,35 +519,46 @@ func (mq *MaintenanceQueue) CompleteTask(taskID string, error string) {
 
 // UpdateTaskProgress updates the progress of a running task
 func (mq *MaintenanceQueue) UpdateTaskProgress(taskID string, progress float64) {
-	mq.mutex.RLock()
-	defer mq.mutex.RUnlock()
+	mq.mutex.Lock()
 
-	if task, exists := mq.tasks[taskID]; exists {
-		oldProgress := task.Progress
-		task.Progress = progress
-		task.Status = TaskStatusInProgress
-
-		// Update pending operation status
-		mq.updatePendingOperationStatus(taskID, "in_progress")
-
-		// Log progress at significant milestones or changes
-		if progress == 0 {
-			glog.V(1).Infof("Task started: %s (%s) worker %s, volume %d",
-				taskID, task.Type, task.WorkerID, task.VolumeID)
-		} else if progress >= 100 {
-			glog.V(1).Infof("Task progress: %s (%s) worker %s, %.1f%% complete",
-				taskID, task.Type, task.WorkerID, progress)
-		} else if progress-oldProgress >= 25 { // Log every 25% increment
-			glog.V(1).Infof("Task progress: %s (%s) worker %s, %.1f%% complete",
-				taskID, task.Type, task.WorkerID, progress)
-		}
-
-		// Save task state after progress update
-		if progress == 0 || progress >= 100 || progress-oldProgress >= 10 {
-			mq.saveTaskState(task)
-		}
-	} else {
+	task, exists := mq.tasks[taskID]
+	if !exists {
+		mq.mutex.Unlock()
 		glog.V(2).Infof("Progress update for unknown task: %s (%.1f%%)", taskID, progress)
+		return
+	}
+
+	oldProgress := task.Progress
+	task.Progress = progress
+	task.Status = TaskStatusInProgress
+
+	// Update pending operation status while lock is held
+	mq.updatePendingOperationStatus(taskID, "in_progress")
+
+	// Determine whether to persist and capture log fields before unlocking
+	shouldSave := progress == 0 || progress >= 100 || progress-oldProgress >= 10
+	var taskSnapshot *MaintenanceTask
+	if shouldSave {
+		taskSnapshot = snapshotTask(task)
+	}
+	taskType, workerID, volumeID := task.Type, task.WorkerID, task.VolumeID
+	mq.mutex.Unlock()
+
+	// Log progress at significant milestones or changes
+	if progress == 0 {
+		glog.V(1).Infof("Task started: %s (%s) worker %s, volume %d",
+			taskID, taskType, workerID, volumeID)
+	} else if progress >= 100 {
+		glog.V(1).Infof("Task progress: %s (%s) worker %s, %.1f%% complete",
+			taskID, taskType, workerID, progress)
+	} else if progress-oldProgress >= 25 { // Log every 25% increment
+		glog.V(1).Infof("Task progress: %s (%s) worker %s, %.1f%% complete",
+			taskID, taskType, workerID, progress)
+	}
+
+	// Save task state outside the lock to avoid blocking readers
+	if taskSnapshot != nil {
+		mq.saveTaskState(taskSnapshot)
 	}
 }
 
@@ -1004,3 +1058,41 @@ func (mq *MaintenanceQueue) updatePendingOperationStatus(taskID string, status s
 
 	pendingOps.UpdateOperationStatus(taskID, status)
 }
+
+// snapshotTask returns a shallow copy of t with slice and map fields deep-copied
+// so that the snapshot can be safely passed to saveTaskState after mq.mutex is
+// released without racing against concurrent mutations of the live task struct.
+// Must be called with mq.mutex held.
+func snapshotTask(t *MaintenanceTask) *MaintenanceTask {
+	cp := *t // copy all scalar / pointer-sized fields
+
+	// Deep-copy AssignmentHistory: the slice header and each record pointer.
+	// Records themselves are never mutated after being appended, so copying
+	// the pointers is sufficient.
+	if t.AssignmentHistory != nil {
+		cp.AssignmentHistory = make([]*TaskAssignmentRecord, len(t.AssignmentHistory))
+		copy(cp.AssignmentHistory, t.AssignmentHistory)
+	}
+
+	// Deep-copy Tags map to avoid concurrent map read/write.
+	if t.Tags != nil {
+		cp.Tags = make(map[string]string, len(t.Tags))
+		for k, v := range t.Tags {
+			cp.Tags[k] = v
+		}
+	}
+
+	// Copy optional time pointers so a concurrent nil-assignment (e.g. retry
+	// path clearing StartedAt) does not race with maintenanceTaskToProtobuf
+	// reading the pointed-to value.
+	if t.StartedAt != nil {
+		ts := *t.StartedAt
+		cp.StartedAt = &ts
+	}
+	if t.CompletedAt != nil {
+		tc := *t.CompletedAt
+		cp.CompletedAt = &tc
+	}
+
+	return &cp
+}

weed/admin/plugin/DESIGN.md

@@ -0,0 +1,205 @@
+# Admin Worker Plugin System (Design)
+
+This document describes the plugin system for admin-managed workers, implemented in parallel with the current maintenance/worker mechanism.
+
+## Scope
+
+- Add a new plugin protocol and runtime model for multi-language workers.
+- Keep all current admin + worker code paths untouched.
+- Use gRPC for all admin-worker communication.
+- Let workers describe job configuration UI declaratively via protobuf.
+- Persist all job type configuration under admin server data directory.
+- Support detector workers and executor workers per job type.
+- Add end-to-end workflow observability (activities, active jobs, progress).
+
+## New Contract
+
+- Proto file: `weed/pb/plugin.proto`
+- gRPC service: `PluginControlService.WorkerStream`
+- Connection model: worker-initiated long-lived bidirectional stream.
+
+Why this model:
+
+- Works for workers in any language with gRPC support.
+- Avoids admin dialing constraints in NAT/private networks.
+- Allows command/response, progress streaming, and heartbeat over one channel.
+
+## Core Runtime Components (Admin Side)
+
+1. `PluginRegistry`
+- Tracks connected workers and their per-job-type capabilities.
+- Maintains liveness via heartbeat timeout.
+
+2. `SchemaCoordinator`
+- For each job type, asks one capable worker for `JobTypeDescriptor`.
+- Caches descriptor version and refresh timestamp.
+
+3. `ConfigStore`
+- Persists descriptor + saved config values in `dataDir`.
+- Stores both:
+  - Admin-owned runtime config (detection interval, dispatch concurrency, retry).
+  - Worker-owned config values (plugin-specific detection/execution knobs).
+
+4. `DetectorScheduler`
+- Per job type, chooses one detector worker (`can_detect=true`).
+- Sends `RunDetectionRequest` with saved configs + cluster context.
+- Accepts `DetectionProposals`, dedupes by `dedupe_key`, inserts jobs.
+
+5. `JobDispatcher`
+- Chooses executor worker (`can_execute=true`) for each pending job.
+- Sends `ExecuteJobRequest`.
+- Consumes `JobProgressUpdate` and `JobCompleted`.
+
+6. `WorkflowMonitor`
+- Builds live counters and timeline from events:
+  - activities per job type,
+  - active jobs,
+  - per-job progress/state,
+  - worker health/load.
+
+## Worker Responsibilities
+
+1. Register capabilities on connect (`WorkerHello`).
+2. Expose job type descriptor (`ConfigSchemaResponse`) including UI schemas:
+- admin config form,
+- worker config form,
+- defaults.
+3. Run detection on demand (`RunDetectionRequest`) and return proposals.
+4. Execute assigned jobs (`ExecuteJobRequest`) and stream progress.
+5. Heartbeat regularly with slot usage and running work.
+6. Handle cancellation requests (`CancelRequest`) for in-flight detection/execution.
+
+## Declarative UI Model
+
+UI is fully derived from protobuf schema:
+
+- `ConfigForm`
+- `ConfigSection`
+- `ConfigField`
+- `ConfigOption`
+- `ValidationRule`
+- `ConfigValue` (typed scalar/list/map/object value container)
+
+Result:
+
+- Admin can render forms without hardcoded task structs.
+- New job types can ship UI schema from worker binary alone.
+- Worker language is irrelevant as long as it can emit protobuf messages.
+
+## Detection and Dispatch Flow
+
+1. Worker connects and registers capabilities.
+2. Admin requests descriptor per job type.
+3. Admin persists descriptor and editable config values.
+4. On detection interval (admin-owned setting):
+- Admin chooses one detector worker for that job type.
+- Sends `RunDetectionRequest` with:
+  - `AdminRuntimeConfig`,
+  - `admin_config_values`,
+  - `worker_config_values`,
+  - `ClusterContext` (master/filer/volume grpc locations, metadata).
+5. Detector emits `DetectionProposals` and `DetectionComplete`.
+6. Admin dedupes and enqueues jobs.
+7. Dispatcher assigns jobs to any eligible executor worker.
+8. Executor emits `JobProgressUpdate` and `JobCompleted`.
+9. Monitor updates workflow UI in near-real-time.
+
+## Persistence Layout (Admin Data Dir)
+
+Current layout under `<admin-data-dir>/plugin/`:
+
+- `job_types/<job_type>/descriptor.pb`
+- `job_types/<job_type>/descriptor.json`
+- `job_types/<job_type>/config.pb`
+- `job_types/<job_type>/config.json`
+- `job_types/<job_type>/runs.json`
+- `jobs/tracked_jobs.json`
+- `activities/activities.json`
+
+`config.pb` should use `PersistedJobTypeConfig` from `plugin.proto`.
+
+## Admin UI
+
+- Route: `/plugin`
+- Includes:
+  - runtime status,
+  - workers/capabilities,
+  - declarative descriptor-driven config forms,
+  - run history (last 10 success + last 10 errors),
+  - tracked jobs and activity stream,
+  - manual actions for schema refresh, detection, and detect+execute workflow.
+
+## Scheduling Policy (Initial)
+
+Detector selection per job type:
+- only workers with `can_detect=true`.
+- prefer healthy worker with highest free detection slots.
+- lease ends when heartbeat timeout or stream drop.
+
+Execution dispatch:
+- only workers with `can_execute=true`.
+- select by available execution slots and least active jobs.
+- retry on failure using admin runtime retry config.
+
+## Safety and Reliability
+
+- Idempotency: dedupe proposals by (`job_type`, `dedupe_key`).
+- Backpressure: enforce max jobs per detection run.
+- Timeouts: detection and execution timeout from admin runtime config.
+- Replay-safe persistence: write job state changes before emitting UI events.
+- Heartbeat-based failover for detector/executor reassignment.
+
+## Backward Compatibility
+
+- Legacy `worker.proto` runtime remains internally available where still referenced.
+- External CLI worker path is moved to plugin runtime behavior.
+- Runtime is enabled by default on admin worker gRPC server.
+
+## Incremental Rollout Plan
+
+Phase 1
+- Introduce protocol and storage models only.
+
+Phase 2
+- Build admin registry/scheduler/dispatcher behind feature flag.
+
+Phase 3
+- Add dedicated plugin UI pages and metrics.
+
+Phase 4
+- Port one existing job type (e.g. vacuum) as external worker plugin.
+
+Phase 4 status (starter)
+- Added `weed worker` command as an external `plugin.proto` worker process.
+- Initial handler implements `vacuum` job type with:
+  - declarative descriptor/config form response (`ConfigSchemaResponse`),
+  - detection via master topology scan (`RunDetectionRequest`),
+  - execution via existing vacuum task logic (`ExecuteJobRequest`),
+  - heartbeat/load reporting for monitor UI.
+- Legacy maintenance-worker-specific CLI path is removed.
+
+Run example:
+- Start admin: `weed admin -master=localhost:9333`
+- Start worker: `weed worker -admin=localhost:23646`
+- Optional explicit job type: `weed worker -admin=localhost:23646 -jobType=vacuum`
+- Optional stable worker ID persistence: `weed worker -admin=localhost:23646 -workingDir=/var/lib/seaweedfs-plugin`
+
+Phase 5
+- Migrate remaining job types and deprecate old mechanism.
+
+## Agreed Defaults
+
+1. Detector multiplicity
+- Exactly one detector worker per job type at a time. Admin selects one worker and runs detection there.
+
+2. Secret handling
+- No encryption at rest required for plugin config in this phase.
+
+3. Schema compatibility
+- No migration policy required yet; this is a new system.
+
+4. Execution ownership
+- Same worker is allowed to do both detection and execution.
+
+5. Retention
+- Keep last 10 successful runs and last 10 error runs per job type.

weed/admin/plugin/config_manager.go

@@ -1,376 +0,0 @@
-package plugin
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-)
-
-// ConfigManager handles JSON-based configuration persistence
-type ConfigManager struct {
-	mu              sync.RWMutex
-	configDir       string
-	defaultConfigFile string
-	pluginConfigs   map[string]*PluginConfig
-	configVersions  map[string]int64
-	lastModified    map[string]time.Time
-	backupDir       string
-	maxBackups      int
-}
-
-// NewConfigManager creates a new configuration manager
-func NewConfigManager(configDir string) (*ConfigManager, error) {
-	// Ensure config directory exists
-	if err := os.MkdirAll(configDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create config directory: %w", err)
-	}
-
-	backupDir := filepath.Join(configDir, "backups")
-	if err := os.MkdirAll(backupDir, 0755); err != nil {
-		return nil, fmt.Errorf("failed to create backup directory: %w", err)
-	}
-
-	return &ConfigManager{
-		configDir:         configDir,
-		defaultConfigFile: filepath.Join(configDir, "plugins.json"),
-		pluginConfigs:     make(map[string]*PluginConfig),
-		configVersions:    make(map[string]int64),
-		lastModified:      make(map[string]time.Time),
-		backupDir:         backupDir,
-		maxBackups:        10,
-	}, nil
-}
-
-// SaveConfig persists a plugin configuration to disk
-func (cm *ConfigManager) SaveConfig(config *PluginConfig, backup bool) error {
-	cm.mu.Lock()
-	defer cm.mu.Unlock()
-
-	if backup {
-		if err := cm.backupExistingConfig(config.PluginID); err != nil {
-			return fmt.Errorf("failed to backup config: %w", err)
-		}
-	}
-
-	configFile := filepath.Join(cm.configDir, fmt.Sprintf("%s.json", config.PluginID))
-	configData := map[string]interface{}{
-		"plugin_id":              config.PluginID,
-		"properties":             config.Properties,
-		"job_types":              config.JobTypes,
-		"max_retries":            config.MaxRetries,
-		"health_check_interval":  config.HealthCheckInterval.String(),
-		"job_timeout":            config.JobTimeout.String(),
-		"environment":            config.Environment,
-	}
-
-	data, err := json.MarshalIndent(configData, "", "  ")
-	if err != nil {
-		return fmt.Errorf("failed to marshal config: %w", err)
-	}
-
-	if err := ioutil.WriteFile(configFile, data, 0644); err != nil {
-		return fmt.Errorf("failed to write config file: %w", err)
-	}
-
-	// Update in-memory state
-	cm.pluginConfigs[config.PluginID] = config
-	cm.configVersions[config.PluginID]++
-	cm.lastModified[config.PluginID] = time.Now()
-
-	return nil
-}
-
-// LoadConfig loads a plugin configuration from disk
-func (cm *ConfigManager) LoadConfig(pluginID string) (*PluginConfig, error) {
-	cm.mu.Lock()
-	defer cm.mu.Unlock()
-
-	configFile := filepath.Join(cm.configDir, fmt.Sprintf("%s.json", pluginID))
-
-	data, err := ioutil.ReadFile(configFile)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read config file: %w", err)
-	}
-
-	var configData map[string]interface{}
-	if err := json.Unmarshal(data, &configData); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal config: %w", err)
-	}
-
-	config := &PluginConfig{
-		PluginID:    pluginID,
-		Properties:  make(map[string]string),
-		JobTypes:    make(map[string]*JobTypeConfig),
-		Environment: make(map[string]string),
-	}
-
-	// Parse basic fields
-	if props, ok := configData["properties"].(map[string]interface{}); ok {
-		for k, v := range props {
-			if str, ok := v.(string); ok {
-				config.Properties[k] = str
-			}
-		}
-	}
-
-	if maxRetries, ok := configData["max_retries"].(float64); ok {
-		config.MaxRetries = int(maxRetries)
-	}
-
-	if hcInterval, ok := configData["health_check_interval"].(string); ok {
-		if duration, err := time.ParseDuration(hcInterval); err == nil {
-			config.HealthCheckInterval = duration
-		}
-	}
-
-	if timeout, ok := configData["job_timeout"].(string); ok {
-		if duration, err := time.ParseDuration(timeout); err == nil {
-			config.JobTimeout = duration
-		}
-	}
-
-	if env, ok := configData["environment"].(map[string]interface{}); ok {
-		for k, v := range env {
-			if str, ok := v.(string); ok {
-				config.Environment[k] = str
-			}
-		}
-	}
-
-	// Parse job types
-	if jobTypes, ok := configData["job_types"].(map[string]interface{}); ok {
-		for jobType, typeConfig := range jobTypes {
-			if typeCfg, ok := typeConfig.(map[string]interface{}); ok {
-				jtc := &JobTypeConfig{
-					Type:       jobType,
-					Parameters: make(map[string]string),
-				}
-
-				if enabled, ok := typeCfg["enabled"].(bool); ok {
-					jtc.Enabled = enabled
-				}
-
-				if priority, ok := typeCfg["priority"].(float64); ok {
-					jtc.Priority = int(priority)
-				}
-
-				if interval, ok := typeCfg["interval"].(string); ok {
-					if duration, err := time.ParseDuration(interval); err == nil {
-						jtc.Interval = duration
-					}
-				}
-
-				if maxConcurrent, ok := typeCfg["max_concurrent"].(float64); ok {
-					jtc.MaxConcurrent = int(maxConcurrent)
-				}
-
-				if params, ok := typeCfg["parameters"].(map[string]interface{}); ok {
-					for pk, pv := range params {
-						if str, ok := pv.(string); ok {
-							jtc.Parameters[pk] = str
-						}
-					}
-				}
-
-				config.JobTypes[jobType] = jtc
-			}
-		}
-	}
-
-	cm.pluginConfigs[pluginID] = config
-	cm.configVersions[pluginID]++
-	cm.lastModified[pluginID] = time.Now()
-
-	return config, nil
-}
-
-// GetConfig retrieves a configuration from memory
-func (cm *ConfigManager) GetConfig(pluginID string) (*PluginConfig, bool) {
-	cm.mu.RLock()
-	defer cm.mu.RUnlock()
-
-	config, exists := cm.pluginConfigs[pluginID]
-	return config, exists
-}
-
-// ListConfigs returns all loaded configurations
-func (cm *ConfigManager) ListConfigs() map[string]*PluginConfig {
-	cm.mu.RLock()
-	defer cm.mu.RUnlock()
-
-	result := make(map[string]*PluginConfig)
-	for pluginID, config := range cm.pluginConfigs {
-		result[pluginID] = config
-	}
-	return result
-}
-
-// DeleteConfig removes a configuration
-func (cm *ConfigManager) DeleteConfig(pluginID string) error {
-	cm.mu.Lock()
-	defer cm.mu.Unlock()
-
-	configFile := filepath.Join(cm.configDir, fmt.Sprintf("%s.json", pluginID))
-	if err := os.Remove(configFile); err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("failed to delete config file: %w", err)
-	}
-
-	delete(cm.pluginConfigs, pluginID)
-	delete(cm.configVersions, pluginID)
-	delete(cm.lastModified, pluginID)
-
-	return nil
-}
-
-// GetVersion returns the version number of a configuration
-func (cm *ConfigManager) GetVersion(pluginID string) int64 {
-	cm.mu.RLock()
-	defer cm.mu.RUnlock()
-
-	return cm.configVersions[pluginID]
-}
-
-// GetLastModified returns the last modification time of a configuration
-func (cm *ConfigManager) GetLastModified(pluginID string) time.Time {
-	cm.mu.RLock()
-	defer cm.mu.RUnlock()
-
-	return cm.lastModified[pluginID]
-}
-
-// backupExistingConfig creates a backup of an existing configuration
-func (cm *ConfigManager) backupExistingConfig(pluginID string) error {
-	configFile := filepath.Join(cm.configDir, fmt.Sprintf("%s.json", pluginID))
-
-	// Check if file exists
-	if _, err := os.Stat(configFile); os.IsNotExist(err) {
-		return nil // No existing config to back up
-	}
-
-	// Create backup filename with timestamp
-	backupFilename := fmt.Sprintf("%s_%d.json.bak", pluginID, time.Now().Unix())
-	backupFile := filepath.Join(cm.backupDir, backupFilename)
-
-	data, err := ioutil.ReadFile(configFile)
-	if err != nil {
-		return fmt.Errorf("failed to read config for backup: %w", err)
-	}
-
-	if err := ioutil.WriteFile(backupFile, data, 0644); err != nil {
-		return fmt.Errorf("failed to write backup file: %w", err)
-	}
-
-	// Cleanup old backups
-	cm.cleanupOldBackups(pluginID)
-
-	return nil
-}
-
-// cleanupOldBackups removes old backup files, keeping only maxBackups
-func (cm *ConfigManager) cleanupOldBackups(pluginID string) {
-	pattern := filepath.Join(cm.backupDir, fmt.Sprintf("%s_*.json.bak", pluginID))
-	files, err := filepath.Glob(pattern)
-	if err != nil {
-		return
-	}
-
-	if len(files) > cm.maxBackups {
-		// Sort by modification time and remove oldest
-		for i := 0; i < len(files)-cm.maxBackups; i++ {
-			os.Remove(files[i])
-		}
-	}
-}
-
-// LoadAllConfigs loads all configurations from the config directory
-func (cm *ConfigManager) LoadAllConfigs() error {
-	cm.mu.Lock()
-	defer cm.mu.Unlock()
-
-	files, err := filepath.Glob(filepath.Join(cm.configDir, "*.json"))
-	if err != nil {
-		return fmt.Errorf("failed to list config files: %w", err)
-	}
-
-	for _, file := range files {
-		filename := filepath.Base(file)
-		pluginID := filename[:len(filename)-5] // Remove .json extension
-
-		if pluginID == "plugins" {
-			continue // Skip main config file
-		}
-
-		data, err := ioutil.ReadFile(file)
-		if err != nil {
-			continue
-		}
-
-		var configData map[string]interface{}
-		if err := json.Unmarshal(data, &configData); err != nil {
-			continue
-		}
-
-		// Basic parsing (simplified)
-		config := &PluginConfig{
-			PluginID:    pluginID,
-			Properties:  make(map[string]string),
-			JobTypes:    make(map[string]*JobTypeConfig),
-			Environment: make(map[string]string),
-		}
-
-		cm.pluginConfigs[pluginID] = config
-		cm.configVersions[pluginID] = 1
-		cm.lastModified[pluginID] = time.Now()
-	}
-
-	return nil
-}
-
-// ExportConfigs exports all configurations to a JSON file
-func (cm *ConfigManager) ExportConfigs() (string, error) {
-	cm.mu.RLock()
-	defer cm.mu.RUnlock()
-
-	exportData := make(map[string]interface{})
-	for pluginID, config := range cm.pluginConfigs {
-		exportData[pluginID] = config
-	}
-
-	data, err := json.MarshalIndent(exportData, "", "  ")
-	if err != nil {
-		return "", fmt.Errorf("failed to marshal configs: %w", err)
-	}
-
-	return string(data), nil
-}
-
-// ImportConfigs imports configurations from a JSON string
-func (cm *ConfigManager) ImportConfigs(jsonData string) error {
-	var importData map[string]interface{}
-	if err := json.Unmarshal([]byte(jsonData), &importData); err != nil {
-		return fmt.Errorf("failed to unmarshal import data: %w", err)
-	}
-
-	cm.mu.Lock()
-	defer cm.mu.Unlock()
-
-	for pluginID, configData := range importData {
-		if _, ok := configData.(map[string]interface{}); ok {
-			config := &PluginConfig{
-				PluginID:    pluginID,
-				Properties:  make(map[string]string),
-				JobTypes:    make(map[string]*JobTypeConfig),
-				Environment: make(map[string]string),
-			}
-			cm.pluginConfigs[pluginID] = config
-			cm.configVersions[pluginID]++
-			cm.lastModified[pluginID] = time.Now()
-		}
-	}
-
-	return nil
-}

weed/admin/plugin/config_store.go

@@ -0,0 +1,739 @@
+package plugin
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+	"google.golang.org/protobuf/encoding/protojson"
+	"google.golang.org/protobuf/proto"
+)
+
+const (
+	pluginDirName           = "plugin"
+	jobTypesDirName         = "job_types"
+	jobsDirName             = "jobs"
+	jobDetailsDirName       = "job_details"
+	activitiesDirName       = "activities"
+	descriptorPBFileName    = "descriptor.pb"
+	descriptorJSONFileName  = "descriptor.json"
+	configPBFileName        = "config.pb"
+	configJSONFileName      = "config.json"
+	runsJSONFileName        = "runs.json"
+	trackedJobsJSONFileName = "tracked_jobs.json"
+	activitiesJSONFileName  = "activities.json"
+	defaultDirPerm          = 0o755
+	defaultFilePerm         = 0o644
+)
+
+// validJobTypePattern is the canonical pattern for safe job type names.
+// Only letters, digits, underscore, dash, and dot are allowed, which prevents
+// path traversal because '/', '\\', and whitespace are rejected.
+var validJobTypePattern = regexp.MustCompile(`^[A-Za-z0-9_.-]+$`)
+
+// ConfigStore persists plugin configuration and bounded run history.
+// If admin data dir is empty, it transparently falls back to in-memory mode.
+type ConfigStore struct {
+	configured bool
+	baseDir    string
+
+	mu sync.RWMutex
+
+	memDescriptors map[string]*plugin_pb.JobTypeDescriptor
+	memConfigs     map[string]*plugin_pb.PersistedJobTypeConfig
+	memRunHistory  map[string]*JobTypeRunHistory
+	memTrackedJobs []TrackedJob
+	memActivities  []JobActivity
+	memJobDetails  map[string]TrackedJob
+}
+
+func NewConfigStore(adminDataDir string) (*ConfigStore, error) {
+	store := &ConfigStore{
+		configured:     adminDataDir != "",
+		memDescriptors: make(map[string]*plugin_pb.JobTypeDescriptor),
+		memConfigs:     make(map[string]*plugin_pb.PersistedJobTypeConfig),
+		memRunHistory:  make(map[string]*JobTypeRunHistory),
+		memJobDetails:  make(map[string]TrackedJob),
+	}
+
+	if adminDataDir == "" {
+		return store, nil
+	}
+
+	store.baseDir = filepath.Join(adminDataDir, pluginDirName)
+	if err := os.MkdirAll(filepath.Join(store.baseDir, jobTypesDirName), defaultDirPerm); err != nil {
+		return nil, fmt.Errorf("create plugin job_types dir: %w", err)
+	}
+	if err := os.MkdirAll(filepath.Join(store.baseDir, jobsDirName), defaultDirPerm); err != nil {
+		return nil, fmt.Errorf("create plugin jobs dir: %w", err)
+	}
+	if err := os.MkdirAll(filepath.Join(store.baseDir, jobsDirName, jobDetailsDirName), defaultDirPerm); err != nil {
+		return nil, fmt.Errorf("create plugin job_details dir: %w", err)
+	}
+	if err := os.MkdirAll(filepath.Join(store.baseDir, activitiesDirName), defaultDirPerm); err != nil {
+		return nil, fmt.Errorf("create plugin activities dir: %w", err)
+	}
+
+	return store, nil
+}
+
+func (s *ConfigStore) IsConfigured() bool {
+	return s.configured
+}
+
+func (s *ConfigStore) BaseDir() string {
+	return s.baseDir
+}
+
+func (s *ConfigStore) SaveDescriptor(jobType string, descriptor *plugin_pb.JobTypeDescriptor) error {
+	if descriptor == nil {
+		return fmt.Errorf("descriptor is nil")
+	}
+	if _, err := sanitizeJobType(jobType); err != nil {
+		return err
+	}
+
+	clone := proto.Clone(descriptor).(*plugin_pb.JobTypeDescriptor)
+	if clone.JobType == "" {
+		clone.JobType = jobType
+	}
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if !s.configured {
+		s.memDescriptors[jobType] = clone
+		return nil
+	}
+
+	jobTypeDir, err := s.ensureJobTypeDir(jobType)
+	if err != nil {
+		return err
+	}
+
+	pbPath := filepath.Join(jobTypeDir, descriptorPBFileName)
+	jsonPath := filepath.Join(jobTypeDir, descriptorJSONFileName)
+
+	if err := writeProtoFiles(clone, pbPath, jsonPath); err != nil {
+		return fmt.Errorf("save descriptor for %s: %w", jobType, err)
+	}
+
+	return nil
+}
+
+func (s *ConfigStore) LoadDescriptor(jobType string) (*plugin_pb.JobTypeDescriptor, error) {
+	if _, err := sanitizeJobType(jobType); err != nil {
+		return nil, err
+	}
+
+	s.mu.RLock()
+	if !s.configured {
+		d := s.memDescriptors[jobType]
+		s.mu.RUnlock()
+		if d == nil {
+			return nil, nil
+		}
+		return proto.Clone(d).(*plugin_pb.JobTypeDescriptor), nil
+	}
+	s.mu.RUnlock()
+
+	pbPath := filepath.Join(s.baseDir, jobTypesDirName, jobType, descriptorPBFileName)
+	data, err := os.ReadFile(pbPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("read descriptor for %s: %w", jobType, err)
+	}
+
+	var descriptor plugin_pb.JobTypeDescriptor
+	if err := proto.Unmarshal(data, &descriptor); err != nil {
+		return nil, fmt.Errorf("unmarshal descriptor for %s: %w", jobType, err)
+	}
+	return &descriptor, nil
+}
+
+func (s *ConfigStore) SaveJobTypeConfig(config *plugin_pb.PersistedJobTypeConfig) error {
+	if config == nil {
+		return fmt.Errorf("job type config is nil")
+	}
+	if config.JobType == "" {
+		return fmt.Errorf("job type config has empty job_type")
+	}
+	sanitizedJobType, err := sanitizeJobType(config.JobType)
+	if err != nil {
+		return err
+	}
+	// Use the sanitized job type going forward to ensure it is safe for filesystem paths.
+	config.JobType = sanitizedJobType
+
+	clone := proto.Clone(config).(*plugin_pb.PersistedJobTypeConfig)
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if !s.configured {
+		s.memConfigs[config.JobType] = clone
+		return nil
+	}
+
+	jobTypeDir, err := s.ensureJobTypeDir(config.JobType)
+	if err != nil {
+		return err
+	}
+
+	pbPath := filepath.Join(jobTypeDir, configPBFileName)
+	jsonPath := filepath.Join(jobTypeDir, configJSONFileName)
+
+	if err := writeProtoFiles(clone, pbPath, jsonPath); err != nil {
+		return fmt.Errorf("save job type config for %s: %w", config.JobType, err)
+	}
+
+	return nil
+}
+
+func (s *ConfigStore) LoadJobTypeConfig(jobType string) (*plugin_pb.PersistedJobTypeConfig, error) {
+	if _, err := sanitizeJobType(jobType); err != nil {
+		return nil, err
+	}
+
+	s.mu.RLock()
+	if !s.configured {
+		cfg := s.memConfigs[jobType]
+		s.mu.RUnlock()
+		if cfg == nil {
+			return nil, nil
+		}
+		return proto.Clone(cfg).(*plugin_pb.PersistedJobTypeConfig), nil
+	}
+	s.mu.RUnlock()
+
+	pbPath := filepath.Join(s.baseDir, jobTypesDirName, jobType, configPBFileName)
+	data, err := os.ReadFile(pbPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("read job type config for %s: %w", jobType, err)
+	}
+
+	var config plugin_pb.PersistedJobTypeConfig
+	if err := proto.Unmarshal(data, &config); err != nil {
+		return nil, fmt.Errorf("unmarshal job type config for %s: %w", jobType, err)
+	}
+
+	return &config, nil
+}
+
+func (s *ConfigStore) AppendRunRecord(jobType string, record *JobRunRecord) error {
+	if record == nil {
+		return fmt.Errorf("run record is nil")
+	}
+	if _, err := sanitizeJobType(jobType); err != nil {
+		return err
+	}
+
+	safeRecord := *record
+	if safeRecord.JobType == "" {
+		safeRecord.JobType = jobType
+	}
+	if safeRecord.CompletedAt == nil || safeRecord.CompletedAt.IsZero() {
+		safeRecord.CompletedAt = timeToPtr(time.Now().UTC())
+	}
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	history, err := s.loadRunHistoryLocked(jobType)
+	if err != nil {
+		return err
+	}
+
+	if safeRecord.Outcome == RunOutcomeSuccess {
+		history.SuccessfulRuns = append(history.SuccessfulRuns, safeRecord)
+	} else {
+		safeRecord.Outcome = RunOutcomeError
+		history.ErrorRuns = append(history.ErrorRuns, safeRecord)
+	}
+
+	history.SuccessfulRuns = trimRuns(history.SuccessfulRuns, MaxSuccessfulRunHistory)
+	history.ErrorRuns = trimRuns(history.ErrorRuns, MaxErrorRunHistory)
+	history.LastUpdatedTime = timeToPtr(time.Now().UTC())
+
+	return s.saveRunHistoryLocked(jobType, history)
+}
+
+func (s *ConfigStore) LoadRunHistory(jobType string) (*JobTypeRunHistory, error) {
+	if _, err := sanitizeJobType(jobType); err != nil {
+		return nil, err
+	}
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	history, err := s.loadRunHistoryLocked(jobType)
+	if err != nil {
+		return nil, err
+	}
+	return cloneRunHistory(history), nil
+}
+
+func (s *ConfigStore) SaveTrackedJobs(jobs []TrackedJob) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	clone := cloneTrackedJobs(jobs)
+
+	if !s.configured {
+		s.memTrackedJobs = clone
+		return nil
+	}
+
+	encoded, err := json.MarshalIndent(clone, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encode tracked jobs: %w", err)
+	}
+
+	path := filepath.Join(s.baseDir, jobsDirName, trackedJobsJSONFileName)
+	if err := atomicWriteFile(path, encoded, defaultFilePerm); err != nil {
+		return fmt.Errorf("write tracked jobs: %w", err)
+	}
+	return nil
+}
+
+func (s *ConfigStore) LoadTrackedJobs() ([]TrackedJob, error) {
+	s.mu.RLock()
+	if !s.configured {
+		out := cloneTrackedJobs(s.memTrackedJobs)
+		s.mu.RUnlock()
+		return out, nil
+	}
+	s.mu.RUnlock()
+
+	path := filepath.Join(s.baseDir, jobsDirName, trackedJobsJSONFileName)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("read tracked jobs: %w", err)
+	}
+
+	var jobs []TrackedJob
+	if err := json.Unmarshal(data, &jobs); err != nil {
+		return nil, fmt.Errorf("parse tracked jobs: %w", err)
+	}
+	return cloneTrackedJobs(jobs), nil
+}
+
+func (s *ConfigStore) SaveJobDetail(job TrackedJob) error {
+	jobID, err := sanitizeJobID(job.JobID)
+	if err != nil {
+		return err
+	}
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	clone := cloneTrackedJob(job)
+	clone.JobID = jobID
+
+	if !s.configured {
+		s.memJobDetails[jobID] = clone
+		return nil
+	}
+
+	encoded, err := json.MarshalIndent(clone, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encode job detail: %w", err)
+	}
+
+	path := filepath.Join(s.baseDir, jobsDirName, jobDetailsDirName, jobDetailFileName(jobID))
+	if err := atomicWriteFile(path, encoded, defaultFilePerm); err != nil {
+		return fmt.Errorf("write job detail: %w", err)
+	}
+
+	return nil
+}
+
+func (s *ConfigStore) LoadJobDetail(jobID string) (*TrackedJob, error) {
+	jobID, err := sanitizeJobID(jobID)
+	if err != nil {
+		return nil, err
+	}
+
+	s.mu.RLock()
+	if !s.configured {
+		job, ok := s.memJobDetails[jobID]
+		s.mu.RUnlock()
+		if !ok {
+			return nil, nil
+		}
+		clone := cloneTrackedJob(job)
+		return &clone, nil
+	}
+	s.mu.RUnlock()
+
+	path := filepath.Join(s.baseDir, jobsDirName, jobDetailsDirName, jobDetailFileName(jobID))
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("read job detail: %w", err)
+	}
+
+	var job TrackedJob
+	if err := json.Unmarshal(data, &job); err != nil {
+		return nil, fmt.Errorf("parse job detail: %w", err)
+	}
+	clone := cloneTrackedJob(job)
+	return &clone, nil
+}
+
+func (s *ConfigStore) SaveActivities(activities []JobActivity) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	clone := cloneActivities(activities)
+
+	if !s.configured {
+		s.memActivities = clone
+		return nil
+	}
+
+	encoded, err := json.MarshalIndent(clone, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encode activities: %w", err)
+	}
+
+	path := filepath.Join(s.baseDir, activitiesDirName, activitiesJSONFileName)
+	if err := atomicWriteFile(path, encoded, defaultFilePerm); err != nil {
+		return fmt.Errorf("write activities: %w", err)
+	}
+	return nil
+}
+
+func (s *ConfigStore) LoadActivities() ([]JobActivity, error) {
+	s.mu.RLock()
+	if !s.configured {
+		out := cloneActivities(s.memActivities)
+		s.mu.RUnlock()
+		return out, nil
+	}
+	s.mu.RUnlock()
+
+	path := filepath.Join(s.baseDir, activitiesDirName, activitiesJSONFileName)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("read activities: %w", err)
+	}
+
+	var activities []JobActivity
+	if err := json.Unmarshal(data, &activities); err != nil {
+		return nil, fmt.Errorf("parse activities: %w", err)
+	}
+	return cloneActivities(activities), nil
+}
+
+func (s *ConfigStore) ListJobTypes() ([]string, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	jobTypeSet := make(map[string]struct{})
+
+	if !s.configured {
+		for jobType := range s.memDescriptors {
+			jobTypeSet[jobType] = struct{}{}
+		}
+		for jobType := range s.memConfigs {
+			jobTypeSet[jobType] = struct{}{}
+		}
+		for jobType := range s.memRunHistory {
+			jobTypeSet[jobType] = struct{}{}
+		}
+	} else {
+		jobTypesPath := filepath.Join(s.baseDir, jobTypesDirName)
+		entries, err := os.ReadDir(jobTypesPath)
+		if err != nil {
+			if os.IsNotExist(err) {
+				return []string{}, nil
+			}
+			return nil, fmt.Errorf("list job types: %w", err)
+		}
+		for _, entry := range entries {
+			if !entry.IsDir() {
+				continue
+			}
+			jobType := strings.TrimSpace(entry.Name())
+			if _, err := sanitizeJobType(jobType); err != nil {
+				continue
+			}
+			jobTypeSet[jobType] = struct{}{}
+		}
+	}
+
+	jobTypes := make([]string, 0, len(jobTypeSet))
+	for jobType := range jobTypeSet {
+		jobTypes = append(jobTypes, jobType)
+	}
+	sort.Strings(jobTypes)
+	return jobTypes, nil
+}
+
+func (s *ConfigStore) loadRunHistoryLocked(jobType string) (*JobTypeRunHistory, error) {
+	if !s.configured {
+		history, ok := s.memRunHistory[jobType]
+		if !ok {
+			history = &JobTypeRunHistory{JobType: jobType}
+			s.memRunHistory[jobType] = history
+		}
+		return cloneRunHistory(history), nil
+	}
+
+	runsPath := filepath.Join(s.baseDir, jobTypesDirName, jobType, runsJSONFileName)
+	data, err := os.ReadFile(runsPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &JobTypeRunHistory{JobType: jobType}, nil
+		}
+		return nil, fmt.Errorf("read run history for %s: %w", jobType, err)
+	}
+
+	var history JobTypeRunHistory
+	if err := json.Unmarshal(data, &history); err != nil {
+		return nil, fmt.Errorf("parse run history for %s: %w", jobType, err)
+	}
+	if history.JobType == "" {
+		history.JobType = jobType
+	}
+	return &history, nil
+}
+
+func (s *ConfigStore) saveRunHistoryLocked(jobType string, history *JobTypeRunHistory) error {
+	if !s.configured {
+		s.memRunHistory[jobType] = cloneRunHistory(history)
+		return nil
+	}
+
+	jobTypeDir, err := s.ensureJobTypeDir(jobType)
+	if err != nil {
+		return err
+	}
+
+	encoded, err := json.MarshalIndent(history, "", "  ")
+	if err != nil {
+		return fmt.Errorf("encode run history for %s: %w", jobType, err)
+	}
+
+	runsPath := filepath.Join(jobTypeDir, runsJSONFileName)
+	if err := atomicWriteFile(runsPath, encoded, defaultFilePerm); err != nil {
+		return fmt.Errorf("write run history for %s: %w", jobType, err)
+	}
+	return nil
+}
+
+func (s *ConfigStore) ensureJobTypeDir(jobType string) (string, error) {
+	if !s.configured {
+		return "", nil
+	}
+	jobTypeDir := filepath.Join(s.baseDir, jobTypesDirName, jobType)
+	if err := os.MkdirAll(jobTypeDir, defaultDirPerm); err != nil {
+		return "", fmt.Errorf("create job type dir for %s: %w", jobType, err)
+	}
+	return jobTypeDir, nil
+}
+
+func sanitizeJobType(jobType string) (string, error) {
+	jobType = strings.TrimSpace(jobType)
+	if jobType == "" {
+		return "", fmt.Errorf("job type is empty")
+	}
+	// Enforce a strict, path-safe pattern for job types: only letters, digits, underscore, dash and dot.
+	// This prevents path traversal because '/', '\\' and whitespace are rejected.
+	if !validJobTypePattern.MatchString(jobType) {
+		return "", fmt.Errorf("invalid job type %q: must match %s", jobType, validJobTypePattern.String())
+	}
+	return jobType, nil
+}
+
+// validJobIDPattern allows letters, digits, dash, underscore, and dot.
+// url.PathEscape in jobDetailFileName provides a second layer of defense.
+var validJobIDPattern = regexp.MustCompile(`^[A-Za-z0-9_.-]+$`)
+
+func sanitizeJobID(jobID string) (string, error) {
+	jobID = strings.TrimSpace(jobID)
+	if jobID == "" {
+		return "", fmt.Errorf("job id is empty")
+	}
+	if !validJobIDPattern.MatchString(jobID) {
+		return "", fmt.Errorf("invalid job id %q: must match %s", jobID, validJobIDPattern.String())
+	}
+	return jobID, nil
+}
+
+func jobDetailFileName(jobID string) string {
+	return url.PathEscape(jobID) + ".json"
+}
+
+func trimRuns(runs []JobRunRecord, maxKeep int) []JobRunRecord {
+	if len(runs) == 0 {
+		return runs
+	}
+	sort.Slice(runs, func(i, j int) bool {
+		ti := time.Time{}
+		if runs[i].CompletedAt != nil {
+			ti = *runs[i].CompletedAt
+		}
+		tj := time.Time{}
+		if runs[j].CompletedAt != nil {
+			tj = *runs[j].CompletedAt
+		}
+		return ti.After(tj)
+	})
+	if len(runs) > maxKeep {
+		runs = runs[:maxKeep]
+	}
+	return runs
+}
+
+func cloneRunHistory(in *JobTypeRunHistory) *JobTypeRunHistory {
+	if in == nil {
+		return nil
+	}
+	out := *in
+	if in.SuccessfulRuns != nil {
+		out.SuccessfulRuns = append([]JobRunRecord(nil), in.SuccessfulRuns...)
+	}
+	if in.ErrorRuns != nil {
+		out.ErrorRuns = append([]JobRunRecord(nil), in.ErrorRuns...)
+	}
+	return &out
+}
+
+func cloneTrackedJobs(in []TrackedJob) []TrackedJob {
+	if len(in) == 0 {
+		return nil
+	}
+
+	out := make([]TrackedJob, len(in))
+	for i := range in {
+		out[i] = cloneTrackedJob(in[i])
+	}
+	return out
+}
+
+func cloneTrackedJob(in TrackedJob) TrackedJob {
+	out := in
+	if in.Parameters != nil {
+		out.Parameters = make(map[string]interface{}, len(in.Parameters))
+		for key, value := range in.Parameters {
+			out.Parameters[key] = deepCopyGenericValue(value)
+		}
+	}
+	if in.Labels != nil {
+		out.Labels = make(map[string]string, len(in.Labels))
+		for key, value := range in.Labels {
+			out.Labels[key] = value
+		}
+	}
+	if in.ResultOutputValues != nil {
+		out.ResultOutputValues = make(map[string]interface{}, len(in.ResultOutputValues))
+		for key, value := range in.ResultOutputValues {
+			out.ResultOutputValues[key] = deepCopyGenericValue(value)
+		}
+	}
+	return out
+}
+
+func deepCopyGenericValue(val interface{}) interface{} {
+	switch v := val.(type) {
+	case map[string]interface{}:
+		res := make(map[string]interface{}, len(v))
+		for k, val := range v {
+			res[k] = deepCopyGenericValue(val)
+		}
+		return res
+	case []interface{}:
+		res := make([]interface{}, len(v))
+		for i, val := range v {
+			res[i] = deepCopyGenericValue(val)
+		}
+		return res
+	default:
+		return v
+	}
+}
+
+func cloneActivities(in []JobActivity) []JobActivity {
+	if len(in) == 0 {
+		return nil
+	}
+
+	out := make([]JobActivity, len(in))
+	for i := range in {
+		out[i] = in[i]
+		if in[i].Details != nil {
+			out[i].Details = make(map[string]interface{}, len(in[i].Details))
+			for key, value := range in[i].Details {
+				out[i].Details[key] = deepCopyGenericValue(value)
+			}
+		}
+	}
+	return out
+}
+
+// writeProtoFiles writes message to both a binary protobuf file (pbPath) and a
+// human-readable JSON file (jsonPath) using atomicWriteFile for each.
+// The .pb file is the authoritative source of truth: all reads use proto.Unmarshal
+// on the .pb file. The .json file is for human inspection only, so a partial
+// failure where .pb succeeds but .json fails leaves the store in a consistent state.
+func writeProtoFiles(message proto.Message, pbPath string, jsonPath string) error {
+	pbData, err := proto.Marshal(message)
+	if err != nil {
+		return fmt.Errorf("marshal protobuf: %w", err)
+	}
+	if err := atomicWriteFile(pbPath, pbData, defaultFilePerm); err != nil {
+		return fmt.Errorf("write protobuf file: %w", err)
+	}
+
+	jsonData, err := protojson.MarshalOptions{
+		Multiline:       true,
+		Indent:          "  ",
+		EmitUnpopulated: true,
+	}.Marshal(message)
+	if err != nil {
+		return fmt.Errorf("marshal json: %w", err)
+	}
+	if err := atomicWriteFile(jsonPath, jsonData, defaultFilePerm); err != nil {
+		return fmt.Errorf("write json file: %w", err)
+	}
+
+	return nil
+}
+func atomicWriteFile(filename string, data []byte, perm os.FileMode) error {
+	dir := filepath.Dir(filename)
+	if err := os.MkdirAll(dir, defaultDirPerm); err != nil {
+		return fmt.Errorf("create directory %s: %w", dir, err)
+	}
+	tmpFile := filename + ".tmp"
+	if err := os.WriteFile(tmpFile, data, perm); err != nil {
+		return err
+	}
+	if err := os.Rename(tmpFile, filename); err != nil {
+		_ = os.Remove(tmpFile)
+		return err
+	}
+	return nil
+}

weed/admin/plugin/config_store_test.go

@@ -0,0 +1,257 @@
+package plugin
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+func TestConfigStoreDescriptorRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	tempDir := t.TempDir()
+	store, err := NewConfigStore(tempDir)
+	if err != nil {
+		t.Fatalf("NewConfigStore: %v", err)
+	}
+
+	descriptor := &plugin_pb.JobTypeDescriptor{
+		JobType:           "vacuum",
+		DisplayName:       "Vacuum",
+		Description:       "Vacuum volumes",
+		DescriptorVersion: 1,
+	}
+
+	if err := store.SaveDescriptor("vacuum", descriptor); err != nil {
+		t.Fatalf("SaveDescriptor: %v", err)
+	}
+
+	got, err := store.LoadDescriptor("vacuum")
+	if err != nil {
+		t.Fatalf("LoadDescriptor: %v", err)
+	}
+	if got == nil {
+		t.Fatalf("LoadDescriptor: nil descriptor")
+	}
+	if got.DisplayName != descriptor.DisplayName {
+		t.Fatalf("unexpected display name: got %q want %q", got.DisplayName, descriptor.DisplayName)
+	}
+
+}
+
+func TestConfigStoreRunHistoryRetention(t *testing.T) {
+	t.Parallel()
+
+	store, err := NewConfigStore(t.TempDir())
+	if err != nil {
+		t.Fatalf("NewConfigStore: %v", err)
+	}
+
+	base := time.Now().UTC().Add(-24 * time.Hour)
+	for i := 0; i < 15; i++ {
+		err := store.AppendRunRecord("balance", &JobRunRecord{
+			RunID:       "s" + time.Duration(i).String(),
+			JobID:       "job-success",
+			JobType:     "balance",
+			WorkerID:    "worker-a",
+			Outcome:     RunOutcomeSuccess,
+			CompletedAt: timeToPtr(base.Add(time.Duration(i) * time.Minute)),
+		})
+		if err != nil {
+			t.Fatalf("AppendRunRecord success[%d]: %v", i, err)
+		}
+	}
+
+	for i := 0; i < 12; i++ {
+		err := store.AppendRunRecord("balance", &JobRunRecord{
+			RunID:       "e" + time.Duration(i).String(),
+			JobID:       "job-error",
+			JobType:     "balance",
+			WorkerID:    "worker-b",
+			Outcome:     RunOutcomeError,
+			CompletedAt: timeToPtr(base.Add(time.Duration(i) * time.Minute)),
+		})
+		if err != nil {
+			t.Fatalf("AppendRunRecord error[%d]: %v", i, err)
+		}
+	}
+
+	history, err := store.LoadRunHistory("balance")
+	if err != nil {
+		t.Fatalf("LoadRunHistory: %v", err)
+	}
+	if len(history.SuccessfulRuns) != MaxSuccessfulRunHistory {
+		t.Fatalf("successful retention mismatch: got %d want %d", len(history.SuccessfulRuns), MaxSuccessfulRunHistory)
+	}
+	if len(history.ErrorRuns) != MaxErrorRunHistory {
+		t.Fatalf("error retention mismatch: got %d want %d", len(history.ErrorRuns), MaxErrorRunHistory)
+	}
+
+	for i := 1; i < len(history.SuccessfulRuns); i++ {
+		t1 := time.Time{}
+		if history.SuccessfulRuns[i-1].CompletedAt != nil {
+			t1 = *history.SuccessfulRuns[i-1].CompletedAt
+		}
+		t2 := time.Time{}
+		if history.SuccessfulRuns[i].CompletedAt != nil {
+			t2 = *history.SuccessfulRuns[i].CompletedAt
+		}
+		if t1.Before(t2) {
+			t.Fatalf("successful run order not descending at %d", i)
+		}
+	}
+	for i := 1; i < len(history.ErrorRuns); i++ {
+		t1 := time.Time{}
+		if history.ErrorRuns[i-1].CompletedAt != nil {
+			t1 = *history.ErrorRuns[i-1].CompletedAt
+		}
+		t2 := time.Time{}
+		if history.ErrorRuns[i].CompletedAt != nil {
+			t2 = *history.ErrorRuns[i].CompletedAt
+		}
+		if t1.Before(t2) {
+			t.Fatalf("error run order not descending at %d", i)
+		}
+	}
+}
+
+func TestConfigStoreListJobTypes(t *testing.T) {
+	t.Parallel()
+
+	store, err := NewConfigStore("")
+	if err != nil {
+		t.Fatalf("NewConfigStore: %v", err)
+	}
+
+	if err := store.SaveDescriptor("vacuum", &plugin_pb.JobTypeDescriptor{JobType: "vacuum"}); err != nil {
+		t.Fatalf("SaveDescriptor: %v", err)
+	}
+	if err := store.SaveJobTypeConfig(&plugin_pb.PersistedJobTypeConfig{
+		JobType:      "balance",
+		AdminRuntime: &plugin_pb.AdminRuntimeConfig{Enabled: true},
+	}); err != nil {
+		t.Fatalf("SaveJobTypeConfig: %v", err)
+	}
+	if err := store.AppendRunRecord("ec", &JobRunRecord{Outcome: RunOutcomeSuccess, CompletedAt: timeToPtr(time.Now().UTC())}); err != nil {
+		t.Fatalf("AppendRunRecord: %v", err)
+	}
+
+	got, err := store.ListJobTypes()
+	if err != nil {
+		t.Fatalf("ListJobTypes: %v", err)
+	}
+	want := []string{"balance", "ec", "vacuum"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected job types: got=%v want=%v", got, want)
+	}
+}
+
+func TestConfigStoreMonitorStateRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	store, err := NewConfigStore(t.TempDir())
+	if err != nil {
+		t.Fatalf("NewConfigStore: %v", err)
+	}
+
+	tracked := []TrackedJob{
+		{
+			JobID:     "job-1",
+			JobType:   "vacuum",
+			State:     "running",
+			Progress:  55,
+			WorkerID:  "worker-a",
+			CreatedAt: timeToPtr(time.Now().UTC().Add(-2 * time.Minute)),
+			UpdatedAt: timeToPtr(time.Now().UTC().Add(-1 * time.Minute)),
+		},
+	}
+	activities := []JobActivity{
+		{
+			JobID:      "job-1",
+			JobType:    "vacuum",
+			Source:     "worker_progress",
+			Message:    "processing",
+			Stage:      "running",
+			OccurredAt: timeToPtr(time.Now().UTC()),
+			Details: map[string]interface{}{
+				"step": "scan",
+			},
+		},
+	}
+
+	if err := store.SaveTrackedJobs(tracked); err != nil {
+		t.Fatalf("SaveTrackedJobs: %v", err)
+	}
+	if err := store.SaveActivities(activities); err != nil {
+		t.Fatalf("SaveActivities: %v", err)
+	}
+
+	gotTracked, err := store.LoadTrackedJobs()
+	if err != nil {
+		t.Fatalf("LoadTrackedJobs: %v", err)
+	}
+	if len(gotTracked) != 1 || gotTracked[0].JobID != tracked[0].JobID {
+		t.Fatalf("unexpected tracked jobs: %+v", gotTracked)
+	}
+
+	gotActivities, err := store.LoadActivities()
+	if err != nil {
+		t.Fatalf("LoadActivities: %v", err)
+	}
+	if len(gotActivities) != 1 || gotActivities[0].Message != activities[0].Message {
+		t.Fatalf("unexpected activities: %+v", gotActivities)
+	}
+	if gotActivities[0].Details["step"] != "scan" {
+		t.Fatalf("unexpected activity details: %+v", gotActivities[0].Details)
+	}
+}
+
+func TestConfigStoreJobDetailRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	store, err := NewConfigStore(t.TempDir())
+	if err != nil {
+		t.Fatalf("NewConfigStore: %v", err)
+	}
+
+	input := TrackedJob{
+		JobID:     "job-detail-1",
+		JobType:   "vacuum",
+		Summary:   "detail summary",
+		Detail:    "detail payload",
+		CreatedAt: timeToPtr(time.Now().UTC().Add(-2 * time.Minute)),
+		UpdatedAt: timeToPtr(time.Now().UTC()),
+		Parameters: map[string]interface{}{
+			"volume_id": map[string]interface{}{"int64_value": "3"},
+		},
+		Labels: map[string]string{
+			"source": "detector",
+		},
+		ResultOutputValues: map[string]interface{}{
+			"moved": map[string]interface{}{"bool_value": true},
+		},
+	}
+
+	if err := store.SaveJobDetail(input); err != nil {
+		t.Fatalf("SaveJobDetail: %v", err)
+	}
+
+	got, err := store.LoadJobDetail(input.JobID)
+	if err != nil {
+		t.Fatalf("LoadJobDetail: %v", err)
+	}
+	if got == nil {
+		t.Fatalf("LoadJobDetail returned nil")
+	}
+	if got.Detail != input.Detail {
+		t.Fatalf("unexpected detail: got=%q want=%q", got.Detail, input.Detail)
+	}
+	if got.Labels["source"] != "detector" {
+		t.Fatalf("unexpected labels: %+v", got.Labels)
+	}
+	if got.ResultOutputValues == nil {
+		t.Fatalf("expected result output values")
+	}
+}

weed/admin/plugin/dispatcher.go

@@ -1,382 +0,0 @@
-package plugin
-
-import (
-	"fmt"
-	"sync"
-	"time"
-)
-
-// Dispatcher orchestrates job detection scheduling and dispatch
-type Dispatcher struct {
-	mu                        sync.RWMutex
-	registry                  *Registry
-	queue                     *JobQueue
-	detectionSchedules        map[string]*DetectionSchedule
-	jobTypeStateManagement    map[string]*JobTypeState
-	lastDetectionTime         map[string]time.Time
-	detectionConcurrencyLimit map[string]int
-}
-
-// DetectionSchedule holds scheduling information for a detection type
-type DetectionSchedule struct {
-	DetectionType      string
-	Interval           time.Duration
-	LastExecuted       time.Time
-	NextExecutionTime  time.Time
-	ExecutionCount     int64
-	FailureCount       int64
-	AverageExecutionMs float64
-}
-
-// JobTypeState manages state for a specific job type
-type JobTypeState struct {
-	JobType             string
-	mu                  sync.RWMutex
-	ActiveCount         int
-	MaxConcurrent       int
-	PendingCount        int
-	CompletedCount      int
-	FailedCount         int
-	LastError           string
-	LastExecutionTime   time.Time
-	AverageExecutionMs  float64
-	ExecutionHistory    []time.Duration
-	MaxHistorySize      int
-}
-
-// NewDispatcher creates a new job dispatcher
-func NewDispatcher(registry *Registry, queue *JobQueue) *Dispatcher {
-	return &Dispatcher{
-		registry:                  registry,
-		queue:                     queue,
-		detectionSchedules:        make(map[string]*DetectionSchedule),
-		jobTypeStateManagement:    make(map[string]*JobTypeState),
-		lastDetectionTime:         make(map[string]time.Time),
-		detectionConcurrencyLimit: make(map[string]int),
-	}
-}
-
-// RegisterDetectionType registers a detection type with scheduling info
-func (d *Dispatcher) RegisterDetectionType(detectionType string, interval time.Duration, maxConcurrent int) error {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	if _, exists := d.detectionSchedules[detectionType]; exists {
-		return fmt.Errorf("detection type %s already registered", detectionType)
-	}
-
-	d.detectionSchedules[detectionType] = &DetectionSchedule{
-		DetectionType:     detectionType,
-		Interval:          interval,
-		NextExecutionTime: time.Now(),
-	}
-
-	d.detectionConcurrencyLimit[detectionType] = maxConcurrent
-	d.jobTypeStateManagement[detectionType] = &JobTypeState{
-		JobType:        detectionType,
-		MaxConcurrent:  maxConcurrent,
-		MaxHistorySize: 100,
-		ExecutionHistory: make([]time.Duration, 0, 100),
-	}
-
-	return nil
-}
-
-// UnregisterDetectionType removes a detection type
-func (d *Dispatcher) UnregisterDetectionType(detectionType string) error {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	if _, exists := d.detectionSchedules[detectionType]; !exists {
-		return fmt.Errorf("detection type %s not found", detectionType)
-	}
-
-	delete(d.detectionSchedules, detectionType)
-	delete(d.detectionConcurrencyLimit, detectionType)
-	delete(d.jobTypeStateManagement, detectionType)
-	delete(d.lastDetectionTime, detectionType)
-
-	return nil
-}
-
-// ScheduleDetections checks and schedules detection jobs that are due
-func (d *Dispatcher) ScheduleDetections() []string {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	var scheduledJobs []string
-	now := time.Now()
-
-	for detectionType, schedule := range d.detectionSchedules {
-		if now.After(schedule.NextExecutionTime) {
-			// Check if we haven't exceeded concurrency limit
-			state := d.jobTypeStateManagement[detectionType]
-			state.mu.RLock()
-			activeCount := state.ActiveCount
-			maxConcurrent := state.MaxConcurrent
-			state.mu.RUnlock()
-
-			if activeCount >= maxConcurrent {
-				continue // Skip this detection type for now
-			}
-
-			// Create and enqueue job
-			jobID := fmt.Sprintf("det-%s-%d", detectionType, now.UnixNano())
-			job := &Job{
-				ID:        jobID,
-				Type:      detectionType,
-				State:     JobStatePending,
-				CreatedAt: now,
-			}
-
-			if err := d.queue.Enqueue(job); err != nil {
-				continue
-			}
-
-			// Update schedule
-			schedule.NextExecutionTime = now.Add(schedule.Interval)
-			schedule.ExecutionCount++
-			d.lastDetectionTime[detectionType] = now
-
-			scheduledJobs = append(scheduledJobs, jobID)
-
-			// Update state
-			state.mu.Lock()
-			state.PendingCount++
-			state.mu.Unlock()
-		}
-	}
-
-	return scheduledJobs
-}
-
-// DispatchJob assigns a job to an available plugin
-func (d *Dispatcher) DispatchJob(job *Job) (string, error) {
-	d.mu.RLock()
-	defer d.mu.RUnlock()
-
-	// Find plugins capable of handling this job type
-	plugins := d.registry.GetPluginsByCapability(job.Type)
-	if len(plugins) == 0 {
-		return "", fmt.Errorf("no plugins available for job type %s", job.Type)
-	}
-
-	// Find least loaded available plugin
-	var selectedPlugin *ConnectedPlugin
-	minLoad := int(^uint32(0) >> 1)
-
-	for _, plugin := range plugins {
-		if plugin.IsHealthy(30 * time.Second) {
-			plugin.mu.RLock()
-			if plugin.ActiveJobs < plugin.MaxConcurrentJobs && plugin.ActiveJobs < minLoad {
-				selectedPlugin = plugin
-				minLoad = plugin.ActiveJobs
-			}
-			plugin.mu.RUnlock()
-		}
-	}
-
-	if selectedPlugin == nil {
-		return "", fmt.Errorf("no healthy plugins available for job type %s", job.Type)
-	}
-
-	// Assign job to plugin
-	job.PluginID = selectedPlugin.ID
-	job.SetState(JobStateScheduled)
-	selectedPlugin.IncActiveJobs()
-
-	// Update job type state
-	state := d.jobTypeStateManagement[job.Type]
-	state.mu.Lock()
-	state.ActiveCount++
-	state.PendingCount--
-	state.mu.Unlock()
-
-	return selectedPlugin.ID, nil
-}
-
-// CompleteJob marks a job as completed
-func (d *Dispatcher) CompleteJob(job *Job, result *JobResult) error {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	job.Result = result
-	job.SetState(JobStateCompleted)
-
-	// Update plugin
-	if plugin, err := d.registry.GetPlugin(job.PluginID); err == nil {
-		plugin.DecActiveJobs()
-	}
-
-	// Update state
-	if state, exists := d.jobTypeStateManagement[job.Type]; exists {
-		state.mu.Lock()
-		state.ActiveCount--
-		state.CompletedCount++
-		if job.ExecutionTime > 0 {
-			state.ExecutionHistory = append(state.ExecutionHistory, job.ExecutionTime)
-			if len(state.ExecutionHistory) > state.MaxHistorySize {
-				state.ExecutionHistory = state.ExecutionHistory[1:]
-			}
-			d.updateAverageExecutionTime(state)
-		}
-		state.LastExecutionTime = time.Now()
-		state.mu.Unlock()
-	}
-
-	// Update detection schedule if applicable
-	if schedule, exists := d.detectionSchedules[job.Type]; exists {
-		schedule.LastExecuted = time.Now()
-	}
-
-	// Record execution
-	record := &ExecutionRecord{
-		JobID:       job.ID,
-		JobType:     job.Type,
-		PluginID:    job.PluginID,
-		State:       job.State,
-		CreatedAt:   job.CreatedAt,
-		StartedAt:   job.StartedAt,
-		CompletedAt: job.CompletedAt,
-		Result:      result,
-	}
-	d.queue.RecordExecution(record)
-
-	return nil
-}
-
-// FailJob marks a job as failed
-func (d *Dispatcher) FailJob(job *Job, errorMsg string) error {
-	d.mu.Lock()
-	defer d.mu.Unlock()
-
-	job.LastError = errorMsg
-	job.SetState(JobStateFailed)
-
-	// Update plugin
-	if plugin, err := d.registry.GetPlugin(job.PluginID); err == nil {
-		plugin.DecActiveJobs()
-	}
-
-	// Update state
-	if state, exists := d.jobTypeStateManagement[job.Type]; exists {
-		state.mu.Lock()
-		state.ActiveCount--
-		state.FailedCount++
-		state.LastError = errorMsg
-		state.LastExecutionTime = time.Now()
-		state.mu.Unlock()
-	}
-
-	// Update detection schedule
-	if schedule, exists := d.detectionSchedules[job.Type]; exists {
-		schedule.FailureCount++
-		schedule.LastExecuted = time.Now()
-	}
-
-	// Record execution
-	record := &ExecutionRecord{
-		JobID:       job.ID,
-		JobType:     job.Type,
-		PluginID:    job.PluginID,
-		State:       job.State,
-		CreatedAt:   job.CreatedAt,
-		StartedAt:   job.StartedAt,
-		CompletedAt: job.CompletedAt,
-		LastError:   errorMsg,
-	}
-	d.queue.RecordExecution(record)
-
-	return nil
-}
-
-// updateAverageExecutionTime recalculates average execution time from history
-func (d *Dispatcher) updateAverageExecutionTime(state *JobTypeState) {
-	if len(state.ExecutionHistory) == 0 {
-		state.AverageExecutionMs = 0
-		return
-	}
-
-	var total int64
-	for _, duration := range state.ExecutionHistory {
-		total += duration.Milliseconds()
-	}
-	state.AverageExecutionMs = float64(total) / float64(len(state.ExecutionHistory))
-}
-
-// GetJobTypeState returns the state for a specific job type
-func (d *Dispatcher) GetJobTypeState(jobType string) *JobTypeState {
-	d.mu.RLock()
-	defer d.mu.RUnlock()
-
-	if state, exists := d.jobTypeStateManagement[jobType]; exists {
-		return state
-	}
-	return nil
-}
-
-// GetAllJobTypeStates returns all job type states
-func (d *Dispatcher) GetAllJobTypeStates() map[string]*JobTypeState {
-	d.mu.RLock()
-	defer d.mu.RUnlock()
-
-	result := make(map[string]*JobTypeState)
-	for jobType, state := range d.jobTypeStateManagement {
-		result[jobType] = state
-	}
-	return result
-}
-
-// GetDetectionSchedule returns the schedule for a detection type
-func (d *Dispatcher) GetDetectionSchedule(detectionType string) *DetectionSchedule {
-	d.mu.RLock()
-	defer d.mu.RUnlock()
-
-	if schedule, exists := d.detectionSchedules[detectionType]; exists {
-		return schedule
-	}
-	return nil
-}
-
-// GetDueDetections returns all detection types that are due for execution
-func (d *Dispatcher) GetDueDetections() []string {
-	d.mu.RLock()
-	defer d.mu.RUnlock()
-
-	var due []string
-	now := time.Now()
-
-	for detectionType, schedule := range d.detectionSchedules {
-		if now.After(schedule.NextExecutionTime) {
-			due = append(due, detectionType)
-		}
-	}
-
-	return due
-}
-
-// GetDispatcherStats returns overall dispatcher statistics
-func (d *Dispatcher) GetDispatcherStats() map[string]interface{} {
-	d.mu.RLock()
-	defer d.mu.RUnlock()
-
-	totalActive := 0
-	totalCompleted := 0
-	totalFailed := 0
-
-	for _, state := range d.jobTypeStateManagement {
-		state.mu.RLock()
-		totalActive += state.ActiveCount
-		totalCompleted += state.CompletedCount
-		totalFailed += state.FailedCount
-		state.mu.RUnlock()
-	}
-
-	return map[string]interface{}{
-		"detection_types_registered": len(d.detectionSchedules),
-		"total_active_jobs":          totalActive,
-		"total_completed_jobs":       totalCompleted,
-		"total_failed_jobs":          totalFailed,
-		"job_type_states":            len(d.jobTypeStateManagement),
-	}
-}

weed/admin/plugin/grpc_server.go

@@ -1,457 +0,0 @@
-package plugin
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
-)
-
-// GRPCServer implements the plugin service gRPC handlers
-type GRPCServer struct {
-	mu            sync.RWMutex
-	registry      *Registry
-	queue         *JobQueue
-	dispatcher    *Dispatcher
-	configMgr     *ConfigManager
-	streamMu      sync.RWMutex
-	activeStreams map[string][]chan interface{}
-	plugin_pb.UnimplementedPluginServiceServer
-	plugin_pb.UnimplementedAdminQueryServiceServer
-	plugin_pb.UnimplementedAdminCommandServiceServer
-}
-
-// NewGRPCServer creates a new gRPC server
-func NewGRPCServer(registry *Registry, queue *JobQueue, dispatcher *Dispatcher, configMgr *ConfigManager) *GRPCServer {
-	return &GRPCServer{
-		registry:      registry,
-		queue:         queue,
-		dispatcher:    dispatcher,
-		configMgr:     configMgr,
-		activeStreams: make(map[string][]chan interface{}),
-	}
-}
-
-// Connect registers a plugin with the master
-func (gs *GRPCServer) Connect(ctx context.Context, req *plugin_pb.PluginConnectRequest) (*plugin_pb.PluginConnectResponse, error) {
-	if req.PluginId == "" {
-		return nil, fmt.Errorf("plugin_id is required")
-	}
-
-	// Create ConnectedPlugin instance
-	plugin := &ConnectedPlugin{
-		ID:                  req.PluginId,
-		Name:                req.PluginName,
-		Version:             req.Version,
-		Status:              "CONNECTED",
-		Capabilities:        req.Capabilities,
-		MaxConcurrentJobs:   int(req.MaxConcurrentJobs),
-		ConnectedAt:         time.Now(),
-		LastHeartbeat:       time.Now(),
-		Metadata:            req.Metadata,
-		HealthCheckInterval: 30 * time.Second,
-		JobTimeout:          5 * time.Minute,
-	}
-
-	// Register plugin
-	if err := gs.registry.RegisterPlugin(plugin); err != nil {
-		return nil, fmt.Errorf("failed to register plugin: %w", err)
-	}
-
-	// Load or create configuration
-	config, err := gs.configMgr.LoadConfig(req.PluginId)
-	if err != nil {
-		// Create default config
-		config = &PluginConfig{
-			PluginID:            req.PluginId,
-			Properties:          make(map[string]string),
-			JobTypes:            make(map[string]*JobTypeConfig),
-			MaxRetries:          3,
-			HealthCheckInterval: 30 * time.Second,
-			JobTimeout:          5 * time.Minute,
-			Environment:         make(map[string]string),
-		}
-		gs.configMgr.SaveConfig(config, false)
-	}
-
-	// Build response
-	pbConfig := &plugin_pb.PluginConfig{
-		PluginId:    config.PluginID,
-		Properties:  config.Properties,
-		MaxRetries:  int32(config.MaxRetries),
-		Environment: config.Environment,
-	}
-
-	response := &plugin_pb.PluginConnectResponse{
-		Success:       true,
-		Message:       "Plugin registered successfully",
-		MasterId:      "master-1",
-		Config:        pbConfig,
-		AssignedTypes: req.Capabilities,
-	}
-
-	return response, nil
-}
-
-// ExecuteJob processes a detection or maintenance job
-func (gs *GRPCServer) ExecuteJob(ctx context.Context, req *plugin_pb.ExecuteJobRequest) (*plugin_pb.ExecuteJobResponse, error) {
-	if req.JobId == "" || req.JobType == "" {
-		return nil, fmt.Errorf("job_id and job_type are required")
-	}
-
-	response := &plugin_pb.ExecuteJobResponse{
-		JobId:   req.JobId,
-		Status:  plugin_pb.ExecutionStatus_EXECUTION_STATUS_ACCEPTED,
-		Message: "Job accepted for execution",
-	}
-
-	return response, nil
-}
-
-// ReportHealth processes health reports from plugins
-func (gs *GRPCServer) ReportHealth(ctx context.Context, report *plugin_pb.HealthReport) (*plugin_pb.HealthReportResponse, error) {
-	if report.PluginId == "" {
-		return nil, fmt.Errorf("plugin_id is required")
-	}
-
-	// Update heartbeat
-	if err := gs.registry.UpdateHeartbeat(report.PluginId); err != nil {
-		return nil, fmt.Errorf("plugin not found: %w", err)
-	}
-
-	// Update plugin stats
-	if plugin, err := gs.registry.GetPlugin(report.PluginId); err == nil {
-		plugin.mu.Lock()
-		plugin.ActiveJobs = int(report.ActiveJobs)
-		plugin.CPUUsagePercent = float64(report.CpuPercent)
-		plugin.MemoryUsageBytes = report.MemoryBytes
-		plugin.mu.Unlock()
-	}
-
-	return &plugin_pb.HealthReportResponse{
-		Acknowledged: true,
-		Feedback:     "Health report received",
-	}, nil
-}
-
-// GetConfig retrieves the latest configuration
-func (gs *GRPCServer) GetConfig(ctx context.Context, req *plugin_pb.GetConfigRequest) (*plugin_pb.GetConfigResponse, error) {
-	if req.PluginId == "" {
-		return nil, fmt.Errorf("plugin_id is required")
-	}
-
-	config, exists := gs.configMgr.GetConfig(req.PluginId)
-	if !exists {
-		return nil, fmt.Errorf("config not found for plugin: %s", req.PluginId)
-	}
-
-	pbConfig := &plugin_pb.PluginConfig{
-		PluginId:    config.PluginID,
-		Properties:  config.Properties,
-		MaxRetries:  int32(config.MaxRetries),
-		Environment: config.Environment,
-	}
-
-	response := &plugin_pb.GetConfigResponse{
-		Config:  pbConfig,
-		Version: gs.configMgr.GetVersion(req.PluginId),
-	}
-
-	return response, nil
-}
-
-// SubmitResult sends job execution results back to master
-func (gs *GRPCServer) SubmitResult(ctx context.Context, req *plugin_pb.JobResultRequest) (*plugin_pb.JobResultResponse, error) {
-	if req.JobId == "" {
-		return nil, fmt.Errorf("job_id is required")
-	}
-
-	actions := []string{}
-
-	// Process results based on job status
-	switch req.Status {
-	case plugin_pb.ExecutionStatus_EXECUTION_STATUS_COMPLETED:
-		actions = append(actions, "ARCHIVED")
-	case plugin_pb.ExecutionStatus_EXECUTION_STATUS_FAILED:
-		actions = append(actions, "RETRY", "NOTIFY_ADMIN")
-	}
-
-	response := &plugin_pb.JobResultResponse{
-		Acknowledged:  true,
-		ActionsToTake: actions,
-	}
-
-	return response, nil
-}
-
-// GetPluginStats returns statistics for all connected plugins
-func (gs *GRPCServer) GetPluginStats(ctx context.Context, req *plugin_pb.GetPluginStatsRequest) (*plugin_pb.GetPluginStatsResponse, error) {
-	response := &plugin_pb.GetPluginStatsResponse{
-		Stats: []*plugin_pb.PluginStats{},
-	}
-
-	var plugins []*ConnectedPlugin
-	if req.PluginId != "" {
-		if plugin, err := gs.registry.GetPlugin(req.PluginId); err == nil {
-			plugins = append(plugins, plugin)
-		}
-	} else {
-		plugins = gs.registry.ListPlugins(false)
-	}
-
-	for _, plugin := range plugins {
-		stat := &plugin_pb.PluginStats{
-			PluginId:           plugin.ID,
-			Status:             plugin.Status,
-			ActiveJobs:         int32(plugin.ActiveJobs),
-			CompletedJobs:      int32(plugin.CompletedJobs),
-			FailedJobs:         int32(plugin.FailedJobs),
-			TotalDetections:    plugin.TotalDetections,
-			AvgExecutionTimeMs: float32(plugin.AvgExecutionTimeMs),
-			CpuUsagePercent:    float32(plugin.CPUUsagePercent),
-			MemoryUsageBytes:   plugin.MemoryUsageBytes,
-			UptimeSeconds:      int32(time.Since(plugin.ConnectedAt).Seconds()),
-		}
-		response.Stats = append(response.Stats, stat)
-	}
-
-	return response, nil
-}
-
-// ListPlugins returns information about all registered plugins
-func (gs *GRPCServer) ListPlugins(ctx context.Context, req *plugin_pb.ListPluginsRequest) (*plugin_pb.ListPluginsResponse, error) {
-	response := &plugin_pb.ListPluginsResponse{
-		Plugins: []*plugin_pb.PluginInfo{},
-	}
-
-	plugins := gs.registry.ListPlugins(!req.IncludeDisabled)
-
-	for _, plugin := range plugins {
-		// Filter by capability if specified
-		if len(req.FilterByCapability) > 0 {
-			hasCapability := false
-			for _, filterCap := range req.FilterByCapability {
-				for _, cap := range plugin.Capabilities {
-					if cap == filterCap {
-						hasCapability = true
-						break
-					}
-				}
-				if hasCapability {
-					break
-				}
-			}
-			if !hasCapability {
-				continue
-			}
-		}
-
-		info := &plugin_pb.PluginInfo{
-			PluginId:          plugin.ID,
-			Name:              plugin.Name,
-			Version:           plugin.Version,
-			Status:            plugin.Status,
-			Capabilities:      plugin.Capabilities,
-			MaxConcurrentJobs: int32(plugin.MaxConcurrentJobs),
-			ActiveJobs:        int32(plugin.ActiveJobs),
-			Metadata:          plugin.Metadata,
-		}
-		response.Plugins = append(response.Plugins, info)
-	}
-
-	return response, nil
-}
-
-// ListJobs returns current and historical job information
-func (gs *GRPCServer) ListJobs(ctx context.Context, req *plugin_pb.ListJobsRequest) (*plugin_pb.ListJobsResponse, error) {
-	response := &plugin_pb.ListJobsResponse{
-		Jobs: []*plugin_pb.JobInfo{},
-	}
-
-	var records []*ExecutionRecord
-	limit := int(req.Limit)
-	if limit <= 0 {
-		limit = 100
-	}
-
-	if req.PluginId != "" {
-		records = gs.queue.GetHistoryForPlugin(req.PluginId, limit)
-	} else {
-		records = gs.queue.GetHistory(limit)
-	}
-
-	for _, record := range records {
-		info := &plugin_pb.JobInfo{
-			JobId:      record.JobID,
-			JobType:    record.JobType,
-			PluginId:   record.PluginID,
-			RetryCount: int32(record.RetryCount),
-			LastError:  record.LastError,
-		}
-		response.Jobs = append(response.Jobs, info)
-	}
-
-	response.TotalCount = int32(gs.queue.HistorySize())
-	return response, nil
-}
-
-// GetJobStatus returns detailed status of a specific job
-func (gs *GRPCServer) GetJobStatus(ctx context.Context, req *plugin_pb.GetJobStatusRequest) (*plugin_pb.GetJobStatusResponse, error) {
-	if req.JobId == "" {
-		return nil, fmt.Errorf("job_id is required")
-	}
-
-	// Search in queue history
-	records := gs.queue.GetHistory(10000)
-	for _, record := range records {
-		if record.JobID == req.JobId {
-			response := &plugin_pb.GetJobStatusResponse{
-				DetailedStatus: record.State.String(),
-			}
-			return response, nil
-		}
-	}
-
-	return nil, fmt.Errorf("job not found: %s", req.JobId)
-}
-
-// GetPluginLogs returns logs from a specific plugin (stub implementation)
-func (gs *GRPCServer) GetPluginLogs(ctx context.Context, req *plugin_pb.GetPluginLogsRequest) (*plugin_pb.GetPluginLogsResponse, error) {
-	response := &plugin_pb.GetPluginLogsResponse{
-		Entries: []*plugin_pb.LogEntry{},
-	}
-	return response, nil
-}
-
-// SaveConfig persists plugin configuration
-func (gs *GRPCServer) SaveConfig(ctx context.Context, req *plugin_pb.SaveConfigRequest) (*plugin_pb.SaveConfigResponse, error) {
-	if req.Config == nil {
-		return nil, fmt.Errorf("config is required")
-	}
-
-	// Convert from protobuf config to internal config
-	config := &PluginConfig{
-		PluginID:    req.Config.PluginId,
-		Properties:  req.Config.Properties,
-		MaxRetries:  int(req.Config.MaxRetries),
-		Environment: req.Config.Environment,
-		JobTypes:    make(map[string]*JobTypeConfig),
-	}
-
-	if err := gs.configMgr.SaveConfig(config, req.BackupExisting); err != nil {
-		return nil, fmt.Errorf("failed to save config: %w", err)
-	}
-
-	response := &plugin_pb.SaveConfigResponse{
-		Success:       true,
-		Message:       "Configuration saved successfully",
-		ConfigVersion: gs.configMgr.GetVersion(req.Config.PluginId),
-	}
-
-	return response, nil
-}
-
-// ReloadConfig reloads configuration without restarting
-func (gs *GRPCServer) ReloadConfig(ctx context.Context, req *plugin_pb.ReloadConfigRequest) (*plugin_pb.ReloadConfigResponse, error) {
-	if req.PluginId == "" {
-		return nil, fmt.Errorf("plugin_id is required")
-	}
-
-	if _, err := gs.configMgr.LoadConfig(req.PluginId); err != nil {
-		return nil, fmt.Errorf("failed to reload config: %w", err)
-	}
-
-	response := &plugin_pb.ReloadConfigResponse{
-		Success: true,
-		Message: "Configuration reloaded successfully",
-	}
-
-	return response, nil
-}
-
-// EnablePlugin enables a specific plugin
-func (gs *GRPCServer) EnablePlugin(ctx context.Context, req *plugin_pb.EnablePluginRequest) (*plugin_pb.EnablePluginResponse, error) {
-	if err := gs.registry.UpdatePluginStatus(req.PluginId, "ENABLED"); err != nil {
-		return nil, fmt.Errorf("failed to enable plugin: %w", err)
-	}
-
-	response := &plugin_pb.EnablePluginResponse{
-		Success: true,
-		Message: "Plugin enabled successfully",
-	}
-
-	return response, nil
-}
-
-// DisablePlugin disables a specific plugin
-func (gs *GRPCServer) DisablePlugin(ctx context.Context, req *plugin_pb.DisablePluginRequest) (*plugin_pb.DisablePluginResponse, error) {
-	if err := gs.registry.UpdatePluginStatus(req.PluginId, "DISABLED"); err != nil {
-		return nil, fmt.Errorf("failed to disable plugin: %w", err)
-	}
-
-	response := &plugin_pb.DisablePluginResponse{
-		Success: true,
-		Message: "Plugin disabled successfully",
-	}
-
-	return response, nil
-}
-
-// TriggerDetection manually triggers a detection for specific types
-func (gs *GRPCServer) TriggerDetection(ctx context.Context, req *plugin_pb.TriggerDetectionRequest) (*plugin_pb.TriggerDetectionResponse, error) {
-	response := &plugin_pb.TriggerDetectionResponse{
-		Success:         true,
-		TriggeredJobIds: []string{},
-	}
-
-	for _, detectionType := range req.DetectionTypes {
-		jobID := fmt.Sprintf("trig-%s-%d", detectionType, time.Now().UnixNano())
-		job := &Job{
-			ID:        jobID,
-			Type:      detectionType,
-			State:     JobStatePending,
-			CreatedAt: time.Now(),
-		}
-
-		if err := gs.queue.Enqueue(job); err != nil {
-			continue
-		}
-		response.TriggeredJobIds = append(response.TriggeredJobIds, jobID)
-	}
-
-	return response, nil
-}
-
-// CancelJob cancels a running job
-func (gs *GRPCServer) CancelJob(ctx context.Context, req *plugin_pb.CancelJobRequest) (*plugin_pb.CancelJobResponse, error) {
-	if req.JobId == "" {
-		return nil, fmt.Errorf("job_id is required")
-	}
-
-	if gs.queue.RemoveJob(req.JobId) {
-		return &plugin_pb.CancelJobResponse{
-			Success: true,
-			Message: "Job cancelled successfully",
-		}, nil
-	}
-
-	return &plugin_pb.CancelJobResponse{
-		Success: false,
-		Message: "Job not found or already completed",
-	}, nil
-}
-
-// PurgeHistory clears job history
-func (gs *GRPCServer) PurgeHistory(ctx context.Context, req *plugin_pb.PurgeHistoryRequest) (*plugin_pb.PurgeHistoryResponse, error) {
-	beforeTime := time.Unix(0, req.BeforeTimestampMs*1000000)
-	deleted := gs.queue.PurgeOldHistory(beforeTime)
-
-	response := &plugin_pb.PurgeHistoryResponse{
-		Success:        true,
-		RecordsDeleted: int32(deleted),
-	}
-
-	return response, nil
-}

weed/admin/plugin/job_execution_plan.go

@@ -0,0 +1,231 @@
+package plugin
+
+import (
+	"encoding/base64"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding"
+	"google.golang.org/protobuf/proto"
+)
+
+func enrichTrackedJobParameters(jobType string, parameters map[string]interface{}) map[string]interface{} {
+	if len(parameters) == 0 {
+		return parameters
+	}
+	if _, exists := parameters["execution_plan"]; exists {
+		return parameters
+	}
+
+	taskParams, ok := decodeTaskParamsFromPlainParameters(parameters)
+	if !ok || taskParams == nil {
+		return parameters
+	}
+
+	plan := buildExecutionPlan(strings.TrimSpace(jobType), taskParams)
+	if plan == nil {
+		return parameters
+	}
+
+	enriched := make(map[string]interface{}, len(parameters)+1)
+	for key, value := range parameters {
+		enriched[key] = value
+	}
+	enriched["execution_plan"] = plan
+	return enriched
+}
+
+func decodeTaskParamsFromPlainParameters(parameters map[string]interface{}) (*worker_pb.TaskParams, bool) {
+	rawField, ok := parameters["task_params_pb"]
+	if !ok || rawField == nil {
+		return nil, false
+	}
+
+	fieldMap, ok := rawField.(map[string]interface{})
+	if !ok {
+		return nil, false
+	}
+
+	bytesValue, _ := fieldMap["bytes_value"].(string)
+	bytesValue = strings.TrimSpace(bytesValue)
+	if bytesValue == "" {
+		return nil, false
+	}
+
+	payload, err := base64.StdEncoding.DecodeString(bytesValue)
+	if err != nil {
+		return nil, false
+	}
+
+	params := &worker_pb.TaskParams{}
+	if err := proto.Unmarshal(payload, params); err != nil {
+		return nil, false
+	}
+
+	return params, true
+}
+
+func buildExecutionPlan(jobType string, params *worker_pb.TaskParams) map[string]interface{} {
+	if params == nil {
+		return nil
+	}
+
+	normalizedJobType := strings.TrimSpace(jobType)
+	if normalizedJobType == "" && params.GetErasureCodingParams() != nil {
+		normalizedJobType = "erasure_coding"
+	}
+
+	switch normalizedJobType {
+	case "erasure_coding":
+		return buildErasureCodingExecutionPlan(params)
+	default:
+		return nil
+	}
+}
+
+func buildErasureCodingExecutionPlan(params *worker_pb.TaskParams) map[string]interface{} {
+	if params == nil {
+		return nil
+	}
+
+	ecParams := params.GetErasureCodingParams()
+	if ecParams == nil {
+		return nil
+	}
+
+	dataShards := int(ecParams.DataShards)
+	if dataShards <= 0 {
+		dataShards = int(erasure_coding.DataShardsCount)
+	}
+	parityShards := int(ecParams.ParityShards)
+	if parityShards <= 0 {
+		parityShards = int(erasure_coding.ParityShardsCount)
+	}
+	totalShards := dataShards + parityShards
+
+	sources := make([]map[string]interface{}, 0, len(params.Sources))
+	for _, source := range params.Sources {
+		if source == nil {
+			continue
+		}
+		sources = append(sources, buildExecutionEndpoint(
+			source.Node,
+			source.DataCenter,
+			source.Rack,
+			source.VolumeId,
+			source.ShardIds,
+			dataShards,
+		))
+	}
+
+	targets := make([]map[string]interface{}, 0, len(params.Targets))
+	shardAssignments := make([]map[string]interface{}, 0, totalShards)
+	for targetIndex, target := range params.Targets {
+		if target == nil {
+			continue
+		}
+
+		targets = append(targets, buildExecutionEndpoint(
+			target.Node,
+			target.DataCenter,
+			target.Rack,
+			target.VolumeId,
+			target.ShardIds,
+			dataShards,
+		))
+
+		for _, shardID := range normalizeShardIDs(target.ShardIds) {
+			kind, label := classifyShardID(shardID, dataShards)
+			shardAssignments = append(shardAssignments, map[string]interface{}{
+				"shard_id":           shardID,
+				"kind":               kind,
+				"label":              label,
+				"target_index":       targetIndex + 1,
+				"target_node":        strings.TrimSpace(target.Node),
+				"target_data_center": strings.TrimSpace(target.DataCenter),
+				"target_rack":        strings.TrimSpace(target.Rack),
+				"target_volume_id":   int(target.VolumeId),
+			})
+		}
+	}
+	sort.Slice(shardAssignments, func(i, j int) bool {
+		left, _ := shardAssignments[i]["shard_id"].(int)
+		right, _ := shardAssignments[j]["shard_id"].(int)
+		return left < right
+	})
+
+	plan := map[string]interface{}{
+		"job_type":      "erasure_coding",
+		"task_id":       strings.TrimSpace(params.TaskId),
+		"volume_id":     int(params.VolumeId),
+		"collection":    strings.TrimSpace(params.Collection),
+		"data_shards":   dataShards,
+		"parity_shards": parityShards,
+		"total_shards":  totalShards,
+		"sources":       sources,
+		"targets":       targets,
+		"source_count":  len(sources),
+		"target_count":  len(targets),
+	}
+
+	if len(shardAssignments) > 0 {
+		plan["shard_assignments"] = shardAssignments
+	}
+
+	return plan
+}
+
+func buildExecutionEndpoint(
+	node string,
+	dataCenter string,
+	rack string,
+	volumeID uint32,
+	shardIDs []uint32,
+	dataShardCount int,
+) map[string]interface{} {
+	allShards := normalizeShardIDs(shardIDs)
+	dataShards := make([]int, 0, len(allShards))
+	parityShards := make([]int, 0, len(allShards))
+	for _, shardID := range allShards {
+		if shardID < dataShardCount {
+			dataShards = append(dataShards, shardID)
+		} else {
+			parityShards = append(parityShards, shardID)
+		}
+	}
+
+	return map[string]interface{}{
+		"node":             strings.TrimSpace(node),
+		"data_center":      strings.TrimSpace(dataCenter),
+		"rack":             strings.TrimSpace(rack),
+		"volume_id":        int(volumeID),
+		"shard_ids":        allShards,
+		"data_shard_ids":   dataShards,
+		"parity_shard_ids": parityShards,
+	}
+}
+
+func normalizeShardIDs(shardIDs []uint32) []int {
+	if len(shardIDs) == 0 {
+		return nil
+	}
+
+	out := make([]int, 0, len(shardIDs))
+	for _, shardID := range shardIDs {
+		out = append(out, int(shardID))
+	}
+	sort.Ints(out)
+	return out
+}
+
+func classifyShardID(shardID int, dataShardCount int) (kind string, label string) {
+	if dataShardCount <= 0 {
+		dataShardCount = int(erasure_coding.DataShardsCount)
+	}
+	if shardID < dataShardCount {
+		return "data", "D" + strconv.Itoa(shardID)
+	}
+	return "parity", "P" + strconv.Itoa(shardID)
+}

weed/admin/plugin/job_queue.go

@@ -1,298 +0,0 @@
-package plugin
-
-import (
-	"container/heap"
-	"fmt"
-	"sync"
-	"time"
-)
-
-// JobQueue manages job queueing with priority, deduplication, retry and history
-type JobQueue struct {
-	mu              sync.RWMutex
-	priorityQueue   *PriorityQueue
-	seenJobs        map[string]bool // For deduplication
-	jobHistory      []*ExecutionRecord
-	maxHistorySize  int
-	deduplicationTTL time.Duration
-	lastSeenJob     map[string]time.Time
-}
-
-// PriorityQueue implements heap.Interface for job ordering
-type PriorityQueue []*Job
-
-func (pq PriorityQueue) Len() int { return len(pq) }
-
-func (pq PriorityQueue) Less(i, j int) bool {
-	// Higher priority jobs come first
-	if pq[i].Type != pq[j].Type {
-		return pq[i].Type < pq[j].Type
-	}
-	// If same type, earlier creation time comes first
-	return pq[i].CreatedAt.Before(pq[j].CreatedAt)
-}
-
-func (pq PriorityQueue) Swap(i, j int) {
-	pq[i], pq[j] = pq[j], pq[i]
-}
-
-func (pq *PriorityQueue) Push(x interface{}) {
-	*pq = append(*pq, x.(*Job))
-}
-
-func (pq *PriorityQueue) Pop() interface{} {
-	old := *pq
-	n := len(old)
-	item := old[n-1]
-	*pq = old[0 : n-1]
-	return item
-}
-
-// NewJobQueue creates a new job queue
-func NewJobQueue(maxHistorySize int, deduplicationTTL time.Duration) *JobQueue {
-	jq := &JobQueue{
-		priorityQueue:    &PriorityQueue{},
-		seenJobs:         make(map[string]bool),
-		jobHistory:       make([]*ExecutionRecord, 0, maxHistorySize),
-		maxHistorySize:   maxHistorySize,
-		deduplicationTTL: deduplicationTTL,
-		lastSeenJob:      make(map[string]time.Time),
-	}
-	heap.Init(jq.priorityQueue)
-	return jq
-}
-
-// Enqueue adds a job to the queue with deduplication
-func (jq *JobQueue) Enqueue(job *Job) error {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-
-	// Check for duplicates within TTL window
-	if lastSeen, exists := jq.lastSeenJob[job.ID]; exists {
-		if time.Since(lastSeen) < jq.deduplicationTTL {
-			return fmt.Errorf("job %s already enqueued recently", job.ID)
-		}
-	}
-
-	job.SetState(JobStatePending)
-	heap.Push(jq.priorityQueue, job)
-	jq.seenJobs[job.ID] = true
-	jq.lastSeenJob[job.ID] = time.Now()
-
-	return nil
-}
-
-// Dequeue retrieves the next job from the queue
-func (jq *JobQueue) Dequeue() *Job {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-
-	if jq.priorityQueue.Len() == 0 {
-		return nil
-	}
-
-	job := heap.Pop(jq.priorityQueue).(*Job)
-	return job
-}
-
-// Peek returns the next job without removing it
-func (jq *JobQueue) Peek() *Job {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-
-	if jq.priorityQueue.Len() == 0 {
-		return nil
-	}
-
-	return (*jq.priorityQueue)[0]
-}
-
-// Size returns the current queue size
-func (jq *JobQueue) Size() int {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-	return jq.priorityQueue.Len()
-}
-
-// RecordExecution adds an execution record to history
-func (jq *JobQueue) RecordExecution(record *ExecutionRecord) {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-
-	jq.jobHistory = append(jq.jobHistory, record)
-
-	// Keep history size bounded
-	if len(jq.jobHistory) > jq.maxHistorySize {
-		// Remove oldest entries
-		removeCount := len(jq.jobHistory) - jq.maxHistorySize
-		jq.jobHistory = jq.jobHistory[removeCount:]
-	}
-}
-
-// GetHistory returns job execution history
-func (jq *JobQueue) GetHistory(limit int) []*ExecutionRecord {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-
-	if limit <= 0 || limit > len(jq.jobHistory) {
-		limit = len(jq.jobHistory)
-	}
-
-	// Return the most recent entries
-	startIdx := len(jq.jobHistory) - limit
-	if startIdx < 0 {
-		startIdx = 0
-	}
-
-	result := make([]*ExecutionRecord, limit)
-	copy(result, jq.jobHistory[startIdx:])
-	return result
-}
-
-// GetHistoryForPlugin returns history for a specific plugin
-func (jq *JobQueue) GetHistoryForPlugin(pluginID string, limit int) []*ExecutionRecord {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-
-	var result []*ExecutionRecord
-	for i := len(jq.jobHistory) - 1; i >= 0 && len(result) < limit; i-- {
-		if jq.jobHistory[i].PluginID == pluginID {
-			result = append(result, jq.jobHistory[i])
-		}
-	}
-	return result
-}
-
-// GetHistoryForJobType returns history for a specific job type
-func (jq *JobQueue) GetHistoryForJobType(jobType string, limit int) []*ExecutionRecord {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-
-	var result []*ExecutionRecord
-	for i := len(jq.jobHistory) - 1; i >= 0 && len(result) < limit; i-- {
-		if jq.jobHistory[i].JobType == jobType {
-			result = append(result, jq.jobHistory[i])
-		}
-	}
-	return result
-}
-
-// ClearHistory removes all execution history
-func (jq *JobQueue) ClearHistory() {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-	jq.jobHistory = make([]*ExecutionRecord, 0, jq.maxHistorySize)
-}
-
-// PurgeOldHistory removes history entries older than the specified time
-func (jq *JobQueue) PurgeOldHistory(beforeTime time.Time) int {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-
-	removed := 0
-	newHistory := make([]*ExecutionRecord, 0)
-
-	for _, record := range jq.jobHistory {
-		if record.CreatedAt.After(beforeTime) {
-			newHistory = append(newHistory, record)
-		} else {
-			removed++
-		}
-	}
-
-	jq.jobHistory = newHistory
-	return removed
-}
-
-// HistorySize returns the number of records in history
-func (jq *JobQueue) HistorySize() int {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-	return len(jq.jobHistory)
-}
-
-// RetryJob re-enqueues a failed job up to maxRetries times
-func (jq *JobQueue) RetryJob(job *Job, maxRetries int) error {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-
-	if job.RetryCount >= maxRetries {
-		return fmt.Errorf("job %s exceeded max retries (%d)", job.ID, maxRetries)
-	}
-
-	job.RetryCount++
-	job.SetState(JobStatePending)
-	heap.Push(jq.priorityQueue, job)
-
-	return nil
-}
-
-// GetExecutionStats returns statistics about job executions
-func (jq *JobQueue) GetExecutionStats() map[string]interface{} {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-
-	completed := 0
-	failed := 0
-	totalExecutionTime := int64(0)
-
-	for _, record := range jq.jobHistory {
-		switch record.State {
-		case JobStateCompleted:
-			completed++
-		case JobStateFailed:
-			failed++
-		}
-		if record.CompletedAt != nil && record.StartedAt != nil {
-			totalExecutionTime += record.CompletedAt.Sub(*record.StartedAt).Milliseconds()
-		}
-	}
-
-	avgExecutionTime := int64(0)
-	if completed+failed > 0 {
-		avgExecutionTime = totalExecutionTime / int64(completed+failed)
-	}
-
-	return map[string]interface{}{
-		"total_history":          len(jq.jobHistory),
-		"completed_jobs":         completed,
-		"failed_jobs":            failed,
-		"avg_execution_time_ms":  avgExecutionTime,
-		"current_queue_size":     jq.priorityQueue.Len(),
-	}
-}
-
-// GetQueuedJobs returns all jobs currently in the queue
-func (jq *JobQueue) GetQueuedJobs() []*Job {
-	jq.mu.RLock()
-	defer jq.mu.RUnlock()
-
-	result := make([]*Job, len(*jq.priorityQueue))
-	copy(result, *jq.priorityQueue)
-	return result
-}
-
-// RemoveJob removes a specific job from the queue
-func (jq *JobQueue) RemoveJob(jobID string) bool {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-
-	for i, job := range *jq.priorityQueue {
-		if job.ID == jobID {
-			heap.Remove(jq.priorityQueue, i)
-			return true
-		}
-	}
-	return false
-}
-
-// PurgeQueuedJobs clears all pending jobs from the queue
-func (jq *JobQueue) PurgeQueuedJobs() int {
-	jq.mu.Lock()
-	defer jq.mu.Unlock()
-
-	count := jq.priorityQueue.Len()
-	*jq.priorityQueue = PriorityQueue{}
-	heap.Init(jq.priorityQueue)
-	return count
-}

weed/admin/plugin/manager.go

@@ -1,498 +0,0 @@
-package plugin
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-)
-
-// Manager is the main component orchestrating the plugin system
-type Manager struct {
-	mu                sync.RWMutex
-	registry          *Registry
-	queue             *JobQueue
-	dispatcher        *Dispatcher
-	configMgr         *ConfigManager
-	grpcServer        *GRPCServer
-	isRunning         bool
-	stopChan          chan bool
-	scheduleTicker    *time.Ticker
-	healthCheckTicker *time.Ticker
-	detectionTicker   *time.Ticker
-	wg                sync.WaitGroup
-	ctx               context.Context
-	cancel            context.CancelFunc
-	config            *ManagerConfig
-}
-
-// ManagerConfig holds configuration for the plugin manager
-type ManagerConfig struct {
-	ConfigDir              string
-	ScheduleInterval       time.Duration
-	HealthCheckInterval    time.Duration
-	DetectionInterval      time.Duration
-	MaxQueueSize           int
-	MaxHistorySize         int
-	DeduplicationTTL       time.Duration
-	HealthCheckTimeout     time.Duration
-	FailureDetectionWindow time.Duration
-	FailureThreshold       int
-}
-
-// DefaultManagerConfig returns default configuration
-func DefaultManagerConfig(configDir string) *ManagerConfig {
-	return &ManagerConfig{
-		ConfigDir:              configDir,
-		ScheduleInterval:       5 * time.Second,
-		HealthCheckInterval:    30 * time.Second,
-		DetectionInterval:      10 * time.Second,
-		MaxQueueSize:           10000,
-		MaxHistorySize:         5000,
-		DeduplicationTTL:       1 * time.Minute,
-		HealthCheckTimeout:     90 * time.Second,
-		FailureDetectionWindow: 5 * time.Minute,
-		FailureThreshold:       3,
-	}
-}
-
-// NewManager creates a new plugin manager instance
-func NewManager(config *ManagerConfig) (*Manager, error) {
-	if config == nil {
-		return nil, fmt.Errorf("config is required")
-	}
-
-	// Create configuration manager
-	configMgr, err := NewConfigManager(config.ConfigDir)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create config manager: %w", err)
-	}
-
-	// Create registry
-	registry := NewRegistry(
-		config.HealthCheckTimeout,
-		config.FailureDetectionWindow,
-		config.FailureThreshold,
-	)
-
-	// Create job queue
-	queue := NewJobQueue(config.MaxHistorySize, config.DeduplicationTTL)
-
-	// Create dispatcher
-	dispatcher := NewDispatcher(registry, queue)
-
-	// Create gRPC server
-	grpcServer := NewGRPCServer(registry, queue, dispatcher, configMgr)
-
-	ctx, cancel := context.WithCancel(context.Background())
-
-	manager := &Manager{
-		registry:   registry,
-		queue:      queue,
-		dispatcher: dispatcher,
-		configMgr:  configMgr,
-		grpcServer: grpcServer,
-		stopChan:   make(chan bool),
-		ctx:        ctx,
-		cancel:     cancel,
-		config:     config,
-	}
-
-	return manager, nil
-}
-
-// Start initializes and starts the plugin manager
-func (m *Manager) Start() error {
-	m.mu.Lock()
-	if m.isRunning {
-		m.mu.Unlock()
-		return fmt.Errorf("manager already running")
-	}
-	m.isRunning = true
-	m.mu.Unlock()
-
-	// Load existing configurations
-	if err := m.configMgr.LoadAllConfigs(); err != nil {
-		m.isRunning = false
-		return fmt.Errorf("failed to load configurations: %w", err)
-	}
-
-	// Start background tasks
-	m.wg.Add(3)
-	go m.schedulerLoop()
-	go m.healthCheckLoop()
-	go m.detectionLoop()
-
-	return nil
-}
-
-// Stop gracefully stops the plugin manager
-func (m *Manager) Stop() error {
-	m.mu.Lock()
-	if !m.isRunning {
-		m.mu.Unlock()
-		return fmt.Errorf("manager not running")
-	}
-	m.isRunning = false
-	m.mu.Unlock()
-
-	// Signal all goroutines to stop
-	m.cancel()
-	close(m.stopChan)
-
-	// Wait for all goroutines to finish
-	done := make(chan struct{})
-	go func() {
-		m.wg.Wait()
-		close(done)
-	}()
-
-	select {
-	case <-done:
-		return nil
-	case <-time.After(30 * time.Second):
-		return fmt.Errorf("timeout waiting for manager to stop")
-	}
-}
-
-// schedulerLoop periodically schedules detection jobs
-func (m *Manager) schedulerLoop() {
-	defer m.wg.Done()
-
-	m.scheduleTicker = time.NewTicker(m.config.ScheduleInterval)
-	defer m.scheduleTicker.Stop()
-
-	for {
-		select {
-		case <-m.ctx.Done():
-			return
-		case <-m.stopChan:
-			return
-		case <-m.scheduleTicker.C:
-			m.performScheduling()
-		}
-	}
-}
-
-// performScheduling executes the scheduling logic
-func (m *Manager) performScheduling() {
-	scheduledJobs := m.dispatcher.ScheduleDetections()
-	if len(scheduledJobs) > 0 {
-		// Jobs have been queued for processing
-	}
-}
-
-// healthCheckLoop periodically checks plugin health
-func (m *Manager) healthCheckLoop() {
-	defer m.wg.Done()
-
-	m.healthCheckTicker = time.NewTicker(m.config.HealthCheckInterval)
-	defer m.healthCheckTicker.Stop()
-
-	for {
-		select {
-		case <-m.ctx.Done():
-			return
-		case <-m.stopChan:
-			return
-		case <-m.healthCheckTicker.C:
-			m.performHealthCheck()
-		}
-	}
-}
-
-// performHealthCheck checks health of all plugins
-func (m *Manager) performHealthCheck() {
-	plugins := m.registry.ListPlugins(true)
-
-	for _, plugin := range plugins {
-		isHealthy, _ := m.registry.HealthCheck(plugin.ID)
-		if !isHealthy {
-			// Check if exceeded threshold
-			if m.registry.HasExceededFailureThreshold(plugin.ID) {
-				m.registry.UnregisterPlugin(plugin.ID)
-			}
-		}
-	}
-}
-
-// detectionLoop periodically triggers detection execution
-func (m *Manager) detectionLoop() {
-	defer m.wg.Done()
-
-	m.detectionTicker = time.NewTicker(m.config.DetectionInterval)
-	defer m.detectionTicker.Stop()
-
-	for {
-		select {
-		case <-m.ctx.Done():
-			return
-		case <-m.stopChan:
-			return
-		case <-m.detectionTicker.C:
-			m.processDetectionJobs()
-		}
-	}
-}
-
-// processDetectionJobs dequeues and dispatches pending jobs
-func (m *Manager) processDetectionJobs() {
-	for {
-		job := m.queue.Dequeue()
-		if job == nil {
-			break
-		}
-
-		// Dispatch job to available plugin
-		pluginID, err := m.dispatcher.DispatchJob(job)
-		if err != nil {
-			// Requeue job if dispatch failed
-			m.queue.Enqueue(job)
-			break
-		}
-
-		job.PluginID = pluginID
-	}
-}
-
-// IsRunning returns whether the manager is currently running
-func (m *Manager) IsRunning() bool {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.isRunning
-}
-
-// RegisterDetectionType registers a new detection type
-func (m *Manager) RegisterDetectionType(detectionType string, interval time.Duration, maxConcurrent int) error {
-	return m.dispatcher.RegisterDetectionType(detectionType, interval, maxConcurrent)
-}
-
-// UnregisterDetectionType unregisters a detection type
-func (m *Manager) UnregisterDetectionType(detectionType string) error {
-	return m.dispatcher.UnregisterDetectionType(detectionType)
-}
-
-// GetStats returns overall statistics
-func (m *Manager) GetStats() map[string]interface{} {
-	return map[string]interface{}{
-		"registry":   m.registry.GetStats(),
-		"queue":      m.queue.GetExecutionStats(),
-		"dispatcher": m.dispatcher.GetDispatcherStats(),
-		"running":    m.IsRunning(),
-	}
-}
-
-// GetPluginStats returns statistics for a specific plugin
-func (m *Manager) GetPluginStats(pluginID string) (map[string]interface{}, error) {
-	plugin, err := m.registry.GetPlugin(pluginID)
-	if err != nil {
-		return nil, err
-	}
-
-	plugin.mu.RLock()
-	defer plugin.mu.RUnlock()
-
-	return map[string]interface{}{
-		"id":                      plugin.ID,
-		"name":                    plugin.Name,
-		"version":                 plugin.Version,
-		"status":                  plugin.Status,
-		"capabilities":            plugin.Capabilities,
-		"active_jobs":             plugin.ActiveJobs,
-		"completed_jobs":          plugin.CompletedJobs,
-		"failed_jobs":             plugin.FailedJobs,
-		"total_detections":        plugin.TotalDetections,
-		"avg_execution_time_ms":   plugin.AvgExecutionTimeMs,
-		"cpu_usage_percent":       plugin.CPUUsagePercent,
-		"memory_usage_bytes":      plugin.MemoryUsageBytes,
-		"connected_at":            plugin.ConnectedAt,
-		"last_heartbeat":          plugin.LastHeartbeat,
-		"uptime_seconds":          int(time.Since(plugin.ConnectedAt).Seconds()),
-	}, nil
-}
-
-// ListPlugins returns all registered plugins
-func (m *Manager) ListPlugins(includeUnhealthy bool) []*ConnectedPlugin {
-	return m.registry.ListPlugins(includeUnhealthy)
-}
-
-// ListJobs returns job history
-func (m *Manager) ListJobs(limit int) []*ExecutionRecord {
-	return m.queue.GetHistory(limit)
-}
-
-// ListJobsForPlugin returns jobs for a specific plugin
-func (m *Manager) ListJobsForPlugin(pluginID string, limit int) []*ExecutionRecord {
-	return m.queue.GetHistoryForPlugin(pluginID, limit)
-}
-
-// ListJobsForType returns jobs for a specific type
-func (m *Manager) ListJobsForType(jobType string, limit int) []*ExecutionRecord {
-	return m.queue.GetHistoryForJobType(jobType, limit)
-}
-
-// TriggerDetection manually triggers detection for specific types
-func (m *Manager) TriggerDetection(detectionTypes []string) ([]string, error) {
-	var jobIDs []string
-
-	for _, detectionType := range detectionTypes {
-		jobID := fmt.Sprintf("manual-%s-%d", detectionType, time.Now().UnixNano())
-		job := &Job{
-			ID:        jobID,
-			Type:      detectionType,
-			State:     JobStatePending,
-			CreatedAt: time.Now(),
-		}
-
-		if err := m.queue.Enqueue(job); err != nil {
-			continue
-		}
-		jobIDs = append(jobIDs, jobID)
-	}
-
-	return jobIDs, nil
-}
-
-// GetJobStatus returns the status of a specific job
-func (m *Manager) GetJobStatus(jobID string) (*ExecutionRecord, error) {
-	records := m.queue.GetHistory(10000)
-	for _, record := range records {
-		if record.JobID == jobID {
-			return record, nil
-		}
-	}
-	return nil, fmt.Errorf("job not found: %s", jobID)
-}
-
-// CancelJob cancels a pending or scheduled job
-func (m *Manager) CancelJob(jobID string) error {
-	if !m.queue.RemoveJob(jobID) {
-		return fmt.Errorf("job not found or already completed: %s", jobID)
-	}
-	return nil
-}
-
-// PurgeHistory removes old job history
-func (m *Manager) PurgeHistory(beforeTime time.Time) int {
-	return m.queue.PurgeOldHistory(beforeTime)
-}
-
-// SaveConfig saves plugin configuration
-func (m *Manager) SaveConfig(config *PluginConfig, backup bool) error {
-	return m.configMgr.SaveConfig(config, backup)
-}
-
-// LoadConfig loads plugin configuration
-func (m *Manager) LoadConfig(pluginID string) (*PluginConfig, error) {
-	config, err := m.configMgr.LoadConfig(pluginID)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load config: %w", err)
-	}
-	return config, nil
-}
-
-// ListConfigs returns all loaded configurations
-func (m *Manager) ListConfigs() map[string]*PluginConfig {
-	return m.configMgr.ListConfigs()
-}
-
-// DeleteConfig deletes a configuration
-func (m *Manager) DeleteConfig(pluginID string) error {
-	return m.configMgr.DeleteConfig(pluginID)
-}
-
-// GetRegistry returns the plugin registry
-func (m *Manager) GetRegistry() *Registry {
-	return m.registry
-}
-
-// GetQueue returns the job queue
-func (m *Manager) GetQueue() *JobQueue {
-	return m.queue
-}
-
-// GetDispatcher returns the dispatcher
-func (m *Manager) GetDispatcher() *Dispatcher {
-	return m.dispatcher
-}
-
-// GetGRPCServer returns the gRPC server
-func (m *Manager) GetGRPCServer() *GRPCServer {
-	return m.grpcServer
-}
-
-// GetDetectionHistory returns detection history for a job type
-func (m *Manager) GetDetectionHistory(jobType string) []DetectionRecord {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	configs := m.configMgr.ListConfigs()
-	for _, cfg := range configs {
-		if jobCfg, ok := cfg.GetJobTypeConfig(jobType); ok {
-			cfg.mu.RLock()
-			defer cfg.mu.RUnlock()
-			history := make([]DetectionRecord, len(jobCfg.DetectionHistory))
-			copy(history, jobCfg.DetectionHistory)
-			return history
-		}
-	}
-	return []DetectionRecord{}
-}
-
-// GetExecutionHistory returns execution history for a job type
-func (m *Manager) GetExecutionHistory(jobType string) []ExecutionRecord {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	configs := m.configMgr.ListConfigs()
-	for _, cfg := range configs {
-		if jobCfg, ok := cfg.GetJobTypeConfig(jobType); ok {
-			cfg.mu.RLock()
-			defer cfg.mu.RUnlock()
-			history := make([]ExecutionRecord, len(jobCfg.ExecutionHistory))
-			copy(history, jobCfg.ExecutionHistory)
-			return history
-		}
-	}
-	return []ExecutionRecord{}
-}
-
-// RecordDetection adds a detection record to history
-func (m *Manager) RecordDetection(jobType string, record *DetectionRecord) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	configs := m.configMgr.ListConfigs()
-	for _, cfg := range configs {
-		if jobCfg, ok := cfg.GetJobTypeConfig(jobType); ok {
-			cfg.mu.Lock()
-			maxSize := 50
-			jobCfg.DetectionHistory = append([]DetectionRecord{*record}, jobCfg.DetectionHistory...)
-			if len(jobCfg.DetectionHistory) > maxSize {
-				jobCfg.DetectionHistory = jobCfg.DetectionHistory[:maxSize]
-			}
-			cfg.mu.Unlock()
-			break
-		}
-	}
-}
-
-// RecordExecution adds an execution record to history
-func (m *Manager) RecordExecution(jobType string, record *ExecutionRecord) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	configs := m.configMgr.ListConfigs()
-	for _, cfg := range configs {
-		if jobCfg, ok := cfg.GetJobTypeConfig(jobType); ok {
-			cfg.mu.Lock()
-			maxSize := 100
-			jobCfg.ExecutionHistory = append([]ExecutionRecord{*record}, jobCfg.ExecutionHistory...)
-			if len(jobCfg.ExecutionHistory) > maxSize {
-				jobCfg.ExecutionHistory = jobCfg.ExecutionHistory[:maxSize]
-			}
-			cfg.mu.Unlock()
-			break
-		}
-	}
-}

weed/admin/plugin/plugin_cancel_test.go

@@ -0,0 +1,112 @@
+package plugin
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+func TestRunDetectionSendsCancelOnContextDone(t *testing.T) {
+	t.Parallel()
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New plugin error: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	const workerID = "worker-detect"
+	const jobType = "vacuum"
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: workerID,
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: jobType, CanDetect: true, MaxDetectionConcurrency: 1},
+		},
+	})
+	session := &streamSession{workerID: workerID, outgoing: make(chan *plugin_pb.AdminToWorkerMessage, 4)}
+	pluginSvc.putSession(session)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	errCh := make(chan error, 1)
+	go func() {
+		_, runErr := pluginSvc.RunDetection(ctx, jobType, &plugin_pb.ClusterContext{}, 10)
+		errCh <- runErr
+	}()
+
+	first := <-session.outgoing
+	if first.GetRunDetectionRequest() == nil {
+		t.Fatalf("expected first message to be run_detection_request")
+	}
+
+	cancel()
+
+	second := <-session.outgoing
+	cancelReq := second.GetCancelRequest()
+	if cancelReq == nil {
+		t.Fatalf("expected second message to be cancel_request")
+	}
+	if cancelReq.TargetId != first.RequestId {
+		t.Fatalf("unexpected cancel target id: got=%s want=%s", cancelReq.TargetId, first.RequestId)
+	}
+	if cancelReq.TargetKind != plugin_pb.WorkKind_WORK_KIND_DETECTION {
+		t.Fatalf("unexpected cancel target kind: %v", cancelReq.TargetKind)
+	}
+
+	runErr := <-errCh
+	if !errors.Is(runErr, context.Canceled) {
+		t.Fatalf("expected context canceled error, got %v", runErr)
+	}
+}
+
+func TestExecuteJobSendsCancelOnContextDone(t *testing.T) {
+	t.Parallel()
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New plugin error: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	const workerID = "worker-exec"
+	const jobType = "vacuum"
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: workerID,
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: jobType, CanExecute: true, MaxExecutionConcurrency: 1},
+		},
+	})
+	session := &streamSession{workerID: workerID, outgoing: make(chan *plugin_pb.AdminToWorkerMessage, 4)}
+	pluginSvc.putSession(session)
+
+	job := &plugin_pb.JobSpec{JobId: "job-1", JobType: jobType}
+	ctx, cancel := context.WithCancel(context.Background())
+	errCh := make(chan error, 1)
+	go func() {
+		_, runErr := pluginSvc.ExecuteJob(ctx, job, &plugin_pb.ClusterContext{}, 1)
+		errCh <- runErr
+	}()
+
+	first := <-session.outgoing
+	if first.GetExecuteJobRequest() == nil {
+		t.Fatalf("expected first message to be execute_job_request")
+	}
+
+	cancel()
+
+	second := <-session.outgoing
+	cancelReq := second.GetCancelRequest()
+	if cancelReq == nil {
+		t.Fatalf("expected second message to be cancel_request")
+	}
+	if cancelReq.TargetId != first.RequestId {
+		t.Fatalf("unexpected cancel target id: got=%s want=%s", cancelReq.TargetId, first.RequestId)
+	}
+	if cancelReq.TargetKind != plugin_pb.WorkKind_WORK_KIND_EXECUTION {
+		t.Fatalf("unexpected cancel target kind: %v", cancelReq.TargetKind)
+	}
+
+	runErr := <-errCh
+	if !errors.Is(runErr, context.Canceled) {
+		t.Fatalf("expected context canceled error, got %v", runErr)
+	}
+}

weed/admin/plugin/plugin_config_bootstrap_test.go

@@ -0,0 +1,125 @@
+package plugin
+
+import (
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+func TestEnsureJobTypeConfigFromDescriptorBootstrapsDefaults(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	descriptor := &plugin_pb.JobTypeDescriptor{
+		JobType:           "vacuum",
+		DescriptorVersion: 3,
+		AdminConfigForm: &plugin_pb.ConfigForm{
+			DefaultValues: map[string]*plugin_pb.ConfigValue{
+				"scan_scope": {Kind: &plugin_pb.ConfigValue_StringValue{StringValue: "all"}},
+			},
+		},
+		WorkerConfigForm: &plugin_pb.ConfigForm{
+			DefaultValues: map[string]*plugin_pb.ConfigValue{
+				"threshold": {Kind: &plugin_pb.ConfigValue_DoubleValue{DoubleValue: 0.3}},
+			},
+		},
+		AdminRuntimeDefaults: &plugin_pb.AdminRuntimeDefaults{
+			Enabled:                       true,
+			DetectionIntervalSeconds:      60,
+			DetectionTimeoutSeconds:       20,
+			MaxJobsPerDetection:           30,
+			GlobalExecutionConcurrency:    4,
+			PerWorkerExecutionConcurrency: 2,
+			RetryLimit:                    3,
+			RetryBackoffSeconds:           5,
+		},
+	}
+
+	if err := pluginSvc.ensureJobTypeConfigFromDescriptor("vacuum", descriptor); err != nil {
+		t.Fatalf("ensureJobTypeConfigFromDescriptor: %v", err)
+	}
+
+	cfg, err := pluginSvc.LoadJobTypeConfig("vacuum")
+	if err != nil {
+		t.Fatalf("LoadJobTypeConfig: %v", err)
+	}
+	if cfg == nil {
+		t.Fatalf("expected non-nil config")
+	}
+	if cfg.DescriptorVersion != 3 {
+		t.Fatalf("unexpected descriptor version: got=%d", cfg.DescriptorVersion)
+	}
+	if cfg.AdminRuntime == nil || !cfg.AdminRuntime.Enabled {
+		t.Fatalf("expected enabled admin settings")
+	}
+	if cfg.AdminRuntime.GlobalExecutionConcurrency != 4 {
+		t.Fatalf("unexpected global execution concurrency: %d", cfg.AdminRuntime.GlobalExecutionConcurrency)
+	}
+	if _, ok := cfg.AdminConfigValues["scan_scope"]; !ok {
+		t.Fatalf("missing admin default value")
+	}
+	if _, ok := cfg.WorkerConfigValues["threshold"]; !ok {
+		t.Fatalf("missing worker default value")
+	}
+}
+
+func TestEnsureJobTypeConfigFromDescriptorDoesNotOverwriteExisting(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	if err := pluginSvc.SaveJobTypeConfig(&plugin_pb.PersistedJobTypeConfig{
+		JobType: "balance",
+		AdminRuntime: &plugin_pb.AdminRuntimeConfig{
+			Enabled:                    true,
+			GlobalExecutionConcurrency: 9,
+		},
+		AdminConfigValues: map[string]*plugin_pb.ConfigValue{
+			"custom": {Kind: &plugin_pb.ConfigValue_StringValue{StringValue: "keep"}},
+		},
+	}); err != nil {
+		t.Fatalf("SaveJobTypeConfig: %v", err)
+	}
+
+	descriptor := &plugin_pb.JobTypeDescriptor{
+		JobType:           "balance",
+		DescriptorVersion: 7,
+		AdminConfigForm: &plugin_pb.ConfigForm{
+			DefaultValues: map[string]*plugin_pb.ConfigValue{
+				"custom": {Kind: &plugin_pb.ConfigValue_StringValue{StringValue: "overwrite"}},
+			},
+		},
+		AdminRuntimeDefaults: &plugin_pb.AdminRuntimeDefaults{
+			Enabled:                    true,
+			GlobalExecutionConcurrency: 1,
+		},
+	}
+
+	if err := pluginSvc.ensureJobTypeConfigFromDescriptor("balance", descriptor); err != nil {
+		t.Fatalf("ensureJobTypeConfigFromDescriptor: %v", err)
+	}
+
+	cfg, err := pluginSvc.LoadJobTypeConfig("balance")
+	if err != nil {
+		t.Fatalf("LoadJobTypeConfig: %v", err)
+	}
+	if cfg == nil {
+		t.Fatalf("expected config")
+	}
+	if cfg.AdminRuntime == nil || cfg.AdminRuntime.GlobalExecutionConcurrency != 9 {
+		t.Fatalf("existing admin settings should be preserved, got=%v", cfg.AdminRuntime)
+	}
+	custom := cfg.AdminConfigValues["custom"]
+	if custom == nil || custom.GetStringValue() != "keep" {
+		t.Fatalf("existing admin config should be preserved")
+	}
+}

weed/admin/plugin/plugin_detection_test.go

@@ -0,0 +1,197 @@
+package plugin
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+func TestRunDetectionIncludesLatestSuccessfulRun(t *testing.T) {
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New plugin error: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	jobType := "vacuum"
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: jobType, CanDetect: true, MaxDetectionConcurrency: 1},
+		},
+	})
+	session := &streamSession{workerID: "worker-a", outgoing: make(chan *plugin_pb.AdminToWorkerMessage, 1)}
+	pluginSvc.putSession(session)
+
+	oldSuccess := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
+	latestSuccess := time.Date(2026, 2, 1, 0, 0, 0, 0, time.UTC)
+	if err := pluginSvc.store.AppendRunRecord(jobType, &JobRunRecord{Outcome: RunOutcomeSuccess, CompletedAt: timeToPtr(oldSuccess)}); err != nil {
+		t.Fatalf("AppendRunRecord old success: %v", err)
+	}
+	if err := pluginSvc.store.AppendRunRecord(jobType, &JobRunRecord{Outcome: RunOutcomeError, CompletedAt: timeToPtr(latestSuccess.Add(2 * time.Hour))}); err != nil {
+		t.Fatalf("AppendRunRecord error run: %v", err)
+	}
+	if err := pluginSvc.store.AppendRunRecord(jobType, &JobRunRecord{Outcome: RunOutcomeSuccess, CompletedAt: timeToPtr(latestSuccess)}); err != nil {
+		t.Fatalf("AppendRunRecord latest success: %v", err)
+	}
+
+	resultCh := make(chan error, 1)
+	go func() {
+		_, runErr := pluginSvc.RunDetection(context.Background(), jobType, &plugin_pb.ClusterContext{}, 10)
+		resultCh <- runErr
+	}()
+
+	message := <-session.outgoing
+	detectRequest := message.GetRunDetectionRequest()
+	if detectRequest == nil {
+		t.Fatalf("expected run detection request message")
+	}
+	if detectRequest.LastSuccessfulRun == nil {
+		t.Fatalf("expected last_successful_run to be set")
+	}
+	if got := detectRequest.LastSuccessfulRun.AsTime().UTC(); !got.Equal(latestSuccess) {
+		t.Fatalf("unexpected last_successful_run, got=%s want=%s", got, latestSuccess)
+	}
+
+	pluginSvc.handleDetectionComplete("worker-a", &plugin_pb.DetectionComplete{
+		RequestId: message.RequestId,
+		JobType:   jobType,
+		Success:   true,
+	})
+
+	if runErr := <-resultCh; runErr != nil {
+		t.Fatalf("RunDetection error: %v", runErr)
+	}
+}
+
+func TestRunDetectionOmitsLastSuccessfulRunWhenNoSuccessHistory(t *testing.T) {
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New plugin error: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	jobType := "vacuum"
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: jobType, CanDetect: true, MaxDetectionConcurrency: 1},
+		},
+	})
+	session := &streamSession{workerID: "worker-a", outgoing: make(chan *plugin_pb.AdminToWorkerMessage, 1)}
+	pluginSvc.putSession(session)
+
+	if err := pluginSvc.store.AppendRunRecord(jobType, &JobRunRecord{
+		Outcome:     RunOutcomeError,
+		CompletedAt: timeToPtr(time.Date(2026, 2, 10, 0, 0, 0, 0, time.UTC)),
+	}); err != nil {
+		t.Fatalf("AppendRunRecord error run: %v", err)
+	}
+
+	resultCh := make(chan error, 1)
+	go func() {
+		_, runErr := pluginSvc.RunDetection(context.Background(), jobType, &plugin_pb.ClusterContext{}, 10)
+		resultCh <- runErr
+	}()
+
+	message := <-session.outgoing
+	detectRequest := message.GetRunDetectionRequest()
+	if detectRequest == nil {
+		t.Fatalf("expected run detection request message")
+	}
+	if detectRequest.LastSuccessfulRun != nil {
+		t.Fatalf("expected last_successful_run to be nil when no success history")
+	}
+
+	pluginSvc.handleDetectionComplete("worker-a", &plugin_pb.DetectionComplete{
+		RequestId: message.RequestId,
+		JobType:   jobType,
+		Success:   true,
+	})
+
+	if runErr := <-resultCh; runErr != nil {
+		t.Fatalf("RunDetection error: %v", runErr)
+	}
+}
+
+func TestRunDetectionWithReportCapturesDetectionActivities(t *testing.T) {
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New plugin error: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	jobType := "vacuum"
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: jobType, CanDetect: true, MaxDetectionConcurrency: 1},
+		},
+	})
+	session := &streamSession{workerID: "worker-a", outgoing: make(chan *plugin_pb.AdminToWorkerMessage, 1)}
+	pluginSvc.putSession(session)
+
+	reportCh := make(chan *DetectionReport, 1)
+	errCh := make(chan error, 1)
+	go func() {
+		report, runErr := pluginSvc.RunDetectionWithReport(context.Background(), jobType, &plugin_pb.ClusterContext{}, 10)
+		reportCh <- report
+		errCh <- runErr
+	}()
+
+	message := <-session.outgoing
+	requestID := message.GetRequestId()
+	if requestID == "" {
+		t.Fatalf("expected request id in detection request")
+	}
+
+	pluginSvc.handleDetectionProposals("worker-a", &plugin_pb.DetectionProposals{
+		RequestId: requestID,
+		JobType:   jobType,
+		Proposals: []*plugin_pb.JobProposal{
+			{
+				ProposalId: "proposal-1",
+				JobType:    jobType,
+				Summary:    "vacuum proposal",
+				Detail:     "based on garbage ratio",
+			},
+		},
+	})
+	pluginSvc.handleDetectionComplete("worker-a", &plugin_pb.DetectionComplete{
+		RequestId:      requestID,
+		JobType:        jobType,
+		Success:        true,
+		TotalProposals: 1,
+	})
+
+	report := <-reportCh
+	if report == nil {
+		t.Fatalf("expected detection report")
+	}
+	if report.RequestID == "" {
+		t.Fatalf("expected detection report request id")
+	}
+	if report.WorkerID != "worker-a" {
+		t.Fatalf("expected worker-a, got %q", report.WorkerID)
+	}
+	if len(report.Proposals) != 1 {
+		t.Fatalf("expected one proposal in report, got %d", len(report.Proposals))
+	}
+	if runErr := <-errCh; runErr != nil {
+		t.Fatalf("RunDetectionWithReport error: %v", runErr)
+	}
+
+	activities := pluginSvc.ListActivities(jobType, 0)
+	stages := map[string]bool{}
+	for _, activity := range activities {
+		if activity.RequestID != report.RequestID {
+			continue
+		}
+		stages[activity.Stage] = true
+	}
+	if !stages["requested"] || !stages["proposal"] || !stages["completed"] {
+		t.Fatalf("expected requested/proposal/completed activities, got stages=%v", stages)
+	}
+}

weed/admin/plugin/plugin_monitor.go

@@ -0,0 +1,896 @@
+package plugin
+
+import (
+	"encoding/json"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+	"google.golang.org/protobuf/encoding/protojson"
+)
+
+const (
+	maxTrackedJobsTotal = 1000
+	maxActivityRecords  = 4000
+	maxRelatedJobs      = 100
+)
+
+var (
+	StateSucceeded = strings.ToLower(plugin_pb.JobState_JOB_STATE_SUCCEEDED.String())
+	StateFailed    = strings.ToLower(plugin_pb.JobState_JOB_STATE_FAILED.String())
+	StateCanceled  = strings.ToLower(plugin_pb.JobState_JOB_STATE_CANCELED.String())
+)
+
+// activityLess reports whether activity a occurred after activity b (newest-first order).
+// A nil OccurredAt is treated as the zero time.
+func activityLess(a, b JobActivity) bool {
+	ta := time.Time{}
+	if a.OccurredAt != nil {
+		ta = *a.OccurredAt
+	}
+	tb := time.Time{}
+	if b.OccurredAt != nil {
+		tb = *b.OccurredAt
+	}
+	return ta.After(tb)
+}
+
+func (r *Plugin) loadPersistedMonitorState() error {
+	trackedJobs, err := r.store.LoadTrackedJobs()
+	if err != nil {
+		return err
+	}
+	activities, err := r.store.LoadActivities()
+	if err != nil {
+		return err
+	}
+
+	if len(trackedJobs) > 0 {
+		r.jobsMu.Lock()
+		for i := range trackedJobs {
+			job := trackedJobs[i]
+			if strings.TrimSpace(job.JobID) == "" {
+				continue
+			}
+			// Backward compatibility: migrate older inline detail payloads
+			// out of tracked_jobs.json into dedicated per-job detail files.
+			if hasTrackedJobRichDetails(job) {
+				if err := r.store.SaveJobDetail(job); err != nil {
+					glog.Warningf("Plugin failed to migrate detail snapshot for job %s: %v", job.JobID, err)
+				}
+			}
+			stripTrackedJobDetailFields(&job)
+			jobCopy := job
+			r.jobs[job.JobID] = &jobCopy
+		}
+		r.pruneTrackedJobsLocked()
+		r.jobsMu.Unlock()
+	}
+
+	if len(activities) > maxActivityRecords {
+		activities = activities[len(activities)-maxActivityRecords:]
+	}
+	if len(activities) > 0 {
+		r.activitiesMu.Lock()
+		r.activities = append([]JobActivity(nil), activities...)
+		r.activitiesMu.Unlock()
+	}
+
+	return nil
+}
+
+func (r *Plugin) ListTrackedJobs(jobType string, state string, limit int) []TrackedJob {
+	r.jobsMu.RLock()
+	defer r.jobsMu.RUnlock()
+
+	normalizedJobType := strings.TrimSpace(jobType)
+	normalizedState := strings.TrimSpace(strings.ToLower(state))
+
+	items := make([]TrackedJob, 0, len(r.jobs))
+	for _, job := range r.jobs {
+		if job == nil {
+			continue
+		}
+		if normalizedJobType != "" && job.JobType != normalizedJobType {
+			continue
+		}
+		if normalizedState != "" && strings.ToLower(job.State) != normalizedState {
+			continue
+		}
+		items = append(items, cloneTrackedJob(*job))
+	}
+
+	sort.Slice(items, func(i, j int) bool {
+		ti := time.Time{}
+		if items[i].UpdatedAt != nil {
+			ti = *items[i].UpdatedAt
+		}
+		tj := time.Time{}
+		if items[j].UpdatedAt != nil {
+			tj = *items[j].UpdatedAt
+		}
+		if !ti.Equal(tj) {
+			return ti.After(tj)
+		}
+		return items[i].JobID < items[j].JobID
+	})
+
+	if limit > 0 && len(items) > limit {
+		items = items[:limit]
+	}
+	return items
+}
+
+func (r *Plugin) GetTrackedJob(jobID string) (*TrackedJob, bool) {
+	r.jobsMu.RLock()
+	defer r.jobsMu.RUnlock()
+
+	job, ok := r.jobs[jobID]
+	if !ok || job == nil {
+		return nil, false
+	}
+	clone := cloneTrackedJob(*job)
+	return &clone, true
+}
+
+func (r *Plugin) ListActivities(jobType string, limit int) []JobActivity {
+	r.activitiesMu.RLock()
+	defer r.activitiesMu.RUnlock()
+
+	normalized := strings.TrimSpace(jobType)
+	activities := make([]JobActivity, 0, len(r.activities))
+	for _, activity := range r.activities {
+		if normalized != "" && activity.JobType != normalized {
+			continue
+		}
+		activities = append(activities, activity)
+	}
+
+	sort.Slice(activities, func(i, j int) bool {
+		return activityLess(activities[i], activities[j])
+	})
+	if limit > 0 && len(activities) > limit {
+		activities = activities[:limit]
+	}
+	return activities
+}
+
+func (r *Plugin) ListJobActivities(jobID string, limit int) []JobActivity {
+	normalizedJobID := strings.TrimSpace(jobID)
+	if normalizedJobID == "" {
+		return nil
+	}
+
+	r.activitiesMu.RLock()
+	activities := make([]JobActivity, 0, len(r.activities))
+	for _, activity := range r.activities {
+		if strings.TrimSpace(activity.JobID) != normalizedJobID {
+			continue
+		}
+		activities = append(activities, activity)
+	}
+	r.activitiesMu.RUnlock()
+
+	sort.Slice(activities, func(i, j int) bool {
+		return !activityLess(activities[i], activities[j]) // oldest-first for job timeline
+	})
+	if limit > 0 && len(activities) > limit {
+		activities = activities[len(activities)-limit:]
+	}
+	return activities
+}
+
+func (r *Plugin) BuildJobDetail(jobID string, activityLimit int, relatedLimit int) (*JobDetail, bool, error) {
+	normalizedJobID := strings.TrimSpace(jobID)
+	if normalizedJobID == "" {
+		return nil, false, nil
+	}
+
+	// Clamp relatedLimit to a safe range to avoid excessive memory allocation from untrusted input.
+	if relatedLimit <= 0 {
+		relatedLimit = 0
+	} else if relatedLimit > maxRelatedJobs {
+		relatedLimit = maxRelatedJobs
+	}
+
+	r.jobsMu.RLock()
+	trackedSnapshot, ok := r.jobs[normalizedJobID]
+	if ok && trackedSnapshot != nil {
+		candidate := cloneTrackedJob(*trackedSnapshot)
+		stripTrackedJobDetailFields(&candidate)
+		trackedSnapshot = &candidate
+	} else {
+		trackedSnapshot = nil
+	}
+	r.jobsMu.RUnlock()
+
+	detailJob, err := r.store.LoadJobDetail(normalizedJobID)
+	if err != nil {
+		return nil, false, err
+	}
+
+	if trackedSnapshot == nil && detailJob == nil {
+		return nil, false, nil
+	}
+	if detailJob == nil && trackedSnapshot != nil {
+		clone := cloneTrackedJob(*trackedSnapshot)
+		detailJob = &clone
+	}
+	if detailJob == nil {
+		return nil, false, nil
+	}
+	if trackedSnapshot != nil {
+		mergeTrackedStatusIntoDetail(detailJob, trackedSnapshot)
+	}
+	detailJob.Parameters = enrichTrackedJobParameters(detailJob.JobType, detailJob.Parameters)
+
+	r.activitiesMu.RLock()
+	activities := append([]JobActivity(nil), r.activities...)
+	r.activitiesMu.RUnlock()
+
+	detail := &JobDetail{
+		Job:         detailJob,
+		Activities:  filterJobActivitiesFromSlice(activities, normalizedJobID, activityLimit),
+		LastUpdated: timeToPtr(time.Now().UTC()),
+	}
+
+	if history, err := r.store.LoadRunHistory(detailJob.JobType); err != nil {
+		return nil, true, err
+	} else if history != nil {
+		for i := range history.SuccessfulRuns {
+			record := history.SuccessfulRuns[i]
+			if strings.TrimSpace(record.JobID) == normalizedJobID {
+				recordCopy := record
+				detail.RunRecord = &recordCopy
+				break
+			}
+		}
+		if detail.RunRecord == nil {
+			for i := range history.ErrorRuns {
+				record := history.ErrorRuns[i]
+				if strings.TrimSpace(record.JobID) == normalizedJobID {
+					recordCopy := record
+					detail.RunRecord = &recordCopy
+					break
+				}
+			}
+		}
+	}
+
+	if relatedLimit > 0 {
+		related := make([]TrackedJob, 0, relatedLimit)
+		r.jobsMu.RLock()
+		for _, candidate := range r.jobs {
+			if strings.TrimSpace(candidate.JobType) != strings.TrimSpace(detailJob.JobType) {
+				continue
+			}
+			if strings.TrimSpace(candidate.JobID) == normalizedJobID {
+				continue
+			}
+			cloned := cloneTrackedJob(*candidate)
+			stripTrackedJobDetailFields(&cloned)
+			related = append(related, cloned)
+			if len(related) >= relatedLimit {
+				break
+			}
+		}
+		r.jobsMu.RUnlock()
+		detail.RelatedJobs = related
+	}
+
+	return detail, true, nil
+}
+
+func filterJobActivitiesFromSlice(all []JobActivity, jobID string, limit int) []JobActivity {
+	if strings.TrimSpace(jobID) == "" || len(all) == 0 {
+		return nil
+	}
+
+	activities := make([]JobActivity, 0, len(all))
+	for _, activity := range all {
+		if strings.TrimSpace(activity.JobID) != jobID {
+			continue
+		}
+		activities = append(activities, activity)
+	}
+
+	sort.Slice(activities, func(i, j int) bool {
+		return !activityLess(activities[i], activities[j]) // oldest-first for job timeline
+	})
+	if limit > 0 && len(activities) > limit {
+		activities = activities[len(activities)-limit:]
+	}
+	return activities
+}
+
+func stripTrackedJobDetailFields(job *TrackedJob) {
+	if job == nil {
+		return
+	}
+	job.Detail = ""
+	job.Parameters = nil
+	job.Labels = nil
+	job.ResultOutputValues = nil
+}
+
+func hasTrackedJobRichDetails(job TrackedJob) bool {
+	return strings.TrimSpace(job.Detail) != "" ||
+		len(job.Parameters) > 0 ||
+		len(job.Labels) > 0 ||
+		len(job.ResultOutputValues) > 0
+}
+
+func mergeTrackedStatusIntoDetail(detail *TrackedJob, tracked *TrackedJob) {
+	if detail == nil || tracked == nil {
+		return
+	}
+
+	if detail.JobType == "" {
+		detail.JobType = tracked.JobType
+	}
+	if detail.RequestID == "" {
+		detail.RequestID = tracked.RequestID
+	}
+	if detail.WorkerID == "" {
+		detail.WorkerID = tracked.WorkerID
+	}
+	if detail.DedupeKey == "" {
+		detail.DedupeKey = tracked.DedupeKey
+	}
+	if detail.Summary == "" {
+		detail.Summary = tracked.Summary
+	}
+	if detail.State == "" {
+		detail.State = tracked.State
+	}
+	if detail.Progress == 0 {
+		detail.Progress = tracked.Progress
+	}
+	if detail.Stage == "" {
+		detail.Stage = tracked.Stage
+	}
+	if detail.Message == "" {
+		detail.Message = tracked.Message
+	}
+	if detail.Attempt == 0 {
+		detail.Attempt = tracked.Attempt
+	}
+	if detail.CreatedAt == nil || detail.CreatedAt.IsZero() {
+		detail.CreatedAt = tracked.CreatedAt
+	}
+	if detail.UpdatedAt == nil || detail.UpdatedAt.IsZero() {
+		detail.UpdatedAt = tracked.UpdatedAt
+	}
+	if detail.CompletedAt == nil || detail.CompletedAt.IsZero() {
+		detail.CompletedAt = tracked.CompletedAt
+	}
+	if detail.ErrorMessage == "" {
+		detail.ErrorMessage = tracked.ErrorMessage
+	}
+	if detail.ResultSummary == "" {
+		detail.ResultSummary = tracked.ResultSummary
+	}
+}
+
+func (r *Plugin) handleJobProgressUpdate(workerID string, update *plugin_pb.JobProgressUpdate) {
+	if update == nil {
+		return
+	}
+
+	now := time.Now().UTC()
+	resolvedWorkerID := strings.TrimSpace(workerID)
+
+	if strings.TrimSpace(update.JobId) != "" {
+		r.jobsMu.Lock()
+		job := r.jobs[update.JobId]
+		if job == nil {
+			job = &TrackedJob{
+				JobID:     update.JobId,
+				JobType:   update.JobType,
+				RequestID: update.RequestId,
+				WorkerID:  resolvedWorkerID,
+				CreatedAt: timeToPtr(now),
+			}
+			r.jobs[update.JobId] = job
+		}
+
+		if update.JobType != "" {
+			job.JobType = update.JobType
+		}
+		if update.RequestId != "" {
+			job.RequestID = update.RequestId
+		}
+		if job.WorkerID != "" {
+			resolvedWorkerID = job.WorkerID
+		} else if resolvedWorkerID != "" {
+			job.WorkerID = resolvedWorkerID
+		}
+		job.State = strings.ToLower(update.State.String())
+		job.Progress = update.ProgressPercent
+		job.Stage = update.Stage
+		job.Message = update.Message
+		job.UpdatedAt = timeToPtr(now)
+		r.pruneTrackedJobsLocked()
+		r.dirtyJobs = true
+		r.jobsMu.Unlock()
+	}
+
+	r.trackWorkerActivities(update.JobType, update.JobId, update.RequestId, resolvedWorkerID, update.Activities)
+	if update.Message != "" || update.Stage != "" {
+		source := "worker_progress"
+		if strings.TrimSpace(update.JobId) == "" {
+			source = "worker_detection"
+		}
+		r.appendActivity(JobActivity{
+			JobID:      update.JobId,
+			JobType:    update.JobType,
+			RequestID:  update.RequestId,
+			WorkerID:   resolvedWorkerID,
+			Source:     source,
+			Message:    update.Message,
+			Stage:      update.Stage,
+			OccurredAt: timeToPtr(now),
+		})
+	}
+}
+
+func (r *Plugin) trackExecutionStart(requestID, workerID string, job *plugin_pb.JobSpec, attempt int32) {
+	if job == nil || strings.TrimSpace(job.JobId) == "" {
+		return
+	}
+
+	now := time.Now().UTC()
+
+	r.jobsMu.Lock()
+	tracked := r.jobs[job.JobId]
+	if tracked == nil {
+		tracked = &TrackedJob{
+			JobID:     job.JobId,
+			CreatedAt: timeToPtr(now),
+		}
+		r.jobs[job.JobId] = tracked
+	}
+
+	tracked.JobType = job.JobType
+	tracked.RequestID = requestID
+	tracked.WorkerID = workerID
+	tracked.DedupeKey = job.DedupeKey
+	tracked.Summary = job.Summary
+	tracked.State = strings.ToLower(plugin_pb.JobState_JOB_STATE_ASSIGNED.String())
+	tracked.Progress = 0
+	tracked.Stage = "assigned"
+	tracked.Message = "job assigned to worker"
+	tracked.Attempt = attempt
+	if tracked.CreatedAt == nil || tracked.CreatedAt.IsZero() {
+		tracked.CreatedAt = timeToPtr(now)
+	}
+	tracked.UpdatedAt = timeToPtr(now)
+	trackedSnapshot := cloneTrackedJob(*tracked)
+	r.pruneTrackedJobsLocked()
+	r.dirtyJobs = true
+	r.jobsMu.Unlock()
+	r.persistJobDetailSnapshot(job.JobId, func(detail *TrackedJob) {
+		detail.JobID = job.JobId
+		detail.JobType = job.JobType
+		detail.RequestID = requestID
+		detail.WorkerID = workerID
+		detail.DedupeKey = job.DedupeKey
+		detail.Summary = job.Summary
+		detail.Detail = job.Detail
+		detail.Parameters = enrichTrackedJobParameters(job.JobType, configValueMapToPlain(job.Parameters))
+		if len(job.Labels) > 0 {
+			labels := make(map[string]string, len(job.Labels))
+			for key, value := range job.Labels {
+				labels[key] = value
+			}
+			detail.Labels = labels
+		} else {
+			detail.Labels = nil
+		}
+		detail.State = trackedSnapshot.State
+		detail.Progress = trackedSnapshot.Progress
+		detail.Stage = trackedSnapshot.Stage
+		detail.Message = trackedSnapshot.Message
+		detail.Attempt = attempt
+		if detail.CreatedAt == nil || detail.CreatedAt.IsZero() {
+			detail.CreatedAt = trackedSnapshot.CreatedAt
+		}
+		detail.UpdatedAt = trackedSnapshot.UpdatedAt
+	})
+
+	r.appendActivity(JobActivity{
+		JobID:      job.JobId,
+		JobType:    job.JobType,
+		RequestID:  requestID,
+		WorkerID:   workerID,
+		Source:     "admin_dispatch",
+		Message:    "job assigned",
+		Stage:      "assigned",
+		OccurredAt: timeToPtr(now),
+	})
+}
+
+func (r *Plugin) trackExecutionQueued(job *plugin_pb.JobSpec) {
+	if job == nil || strings.TrimSpace(job.JobId) == "" {
+		return
+	}
+
+	now := time.Now().UTC()
+
+	r.jobsMu.Lock()
+	tracked := r.jobs[job.JobId]
+	if tracked == nil {
+		tracked = &TrackedJob{
+			JobID:     job.JobId,
+			CreatedAt: timeToPtr(now),
+		}
+		r.jobs[job.JobId] = tracked
+	}
+
+	tracked.JobType = job.JobType
+	tracked.DedupeKey = job.DedupeKey
+	tracked.Summary = job.Summary
+	tracked.State = strings.ToLower(plugin_pb.JobState_JOB_STATE_PENDING.String())
+	tracked.Progress = 0
+	tracked.Stage = "queued"
+	tracked.Message = "waiting for available executor"
+	if tracked.CreatedAt == nil || tracked.CreatedAt.IsZero() {
+		tracked.CreatedAt = timeToPtr(now)
+	}
+	tracked.UpdatedAt = timeToPtr(now)
+	trackedSnapshot := cloneTrackedJob(*tracked)
+	r.pruneTrackedJobsLocked()
+	r.dirtyJobs = true
+	r.jobsMu.Unlock()
+	r.persistJobDetailSnapshot(job.JobId, func(detail *TrackedJob) {
+		detail.JobID = job.JobId
+		detail.JobType = job.JobType
+		detail.DedupeKey = job.DedupeKey
+		detail.Summary = job.Summary
+		detail.Detail = job.Detail
+		detail.Parameters = enrichTrackedJobParameters(job.JobType, configValueMapToPlain(job.Parameters))
+		if len(job.Labels) > 0 {
+			labels := make(map[string]string, len(job.Labels))
+			for key, value := range job.Labels {
+				labels[key] = value
+			}
+			detail.Labels = labels
+		} else {
+			detail.Labels = nil
+		}
+		detail.State = trackedSnapshot.State
+		detail.Progress = trackedSnapshot.Progress
+		detail.Stage = trackedSnapshot.Stage
+		detail.Message = trackedSnapshot.Message
+		if detail.CreatedAt == nil || detail.CreatedAt.IsZero() {
+			detail.CreatedAt = trackedSnapshot.CreatedAt
+		}
+		detail.UpdatedAt = trackedSnapshot.UpdatedAt
+	})
+
+	r.appendActivity(JobActivity{
+		JobID:      job.JobId,
+		JobType:    job.JobType,
+		Source:     "admin_scheduler",
+		Message:    "job queued for execution",
+		Stage:      "queued",
+		OccurredAt: timeToPtr(now),
+	})
+}
+
+func (r *Plugin) trackExecutionCompletion(completed *plugin_pb.JobCompleted) *TrackedJob {
+	if completed == nil || strings.TrimSpace(completed.JobId) == "" {
+		return nil
+	}
+
+	now := time.Now().UTC()
+	if completed.CompletedAt != nil {
+		now = completed.CompletedAt.AsTime().UTC()
+	}
+
+	r.jobsMu.Lock()
+	tracked := r.jobs[completed.JobId]
+	if tracked == nil {
+		tracked = &TrackedJob{
+			JobID:     completed.JobId,
+			CreatedAt: timeToPtr(now),
+		}
+		r.jobs[completed.JobId] = tracked
+	}
+
+	if completed.JobType != "" {
+		tracked.JobType = completed.JobType
+	}
+	if completed.RequestId != "" {
+		tracked.RequestID = completed.RequestId
+	}
+	if completed.Success {
+		tracked.State = strings.ToLower(plugin_pb.JobState_JOB_STATE_SUCCEEDED.String())
+		tracked.Progress = 100
+		tracked.Stage = "completed"
+		if completed.Result != nil {
+			tracked.ResultSummary = completed.Result.Summary
+		}
+		tracked.Message = tracked.ResultSummary
+		if tracked.Message == "" {
+			tracked.Message = "completed"
+		}
+		tracked.ErrorMessage = ""
+	} else {
+		tracked.State = strings.ToLower(plugin_pb.JobState_JOB_STATE_FAILED.String())
+		tracked.Stage = "failed"
+		tracked.ErrorMessage = completed.ErrorMessage
+		tracked.Message = completed.ErrorMessage
+	}
+
+	tracked.UpdatedAt = timeToPtr(now)
+	tracked.CompletedAt = timeToPtr(now)
+	r.pruneTrackedJobsLocked()
+	clone := cloneTrackedJob(*tracked)
+	r.dirtyJobs = true
+	r.jobsMu.Unlock()
+	r.persistJobDetailSnapshot(completed.JobId, func(detail *TrackedJob) {
+		detail.JobID = completed.JobId
+		if completed.JobType != "" {
+			detail.JobType = completed.JobType
+		}
+		if completed.RequestId != "" {
+			detail.RequestID = completed.RequestId
+		}
+		detail.State = clone.State
+		detail.Progress = clone.Progress
+		detail.Stage = clone.Stage
+		detail.Message = clone.Message
+		detail.ErrorMessage = clone.ErrorMessage
+		detail.ResultSummary = clone.ResultSummary
+		if completed.Success && completed.Result != nil {
+			detail.ResultOutputValues = configValueMapToPlain(completed.Result.OutputValues)
+		} else {
+			detail.ResultOutputValues = nil
+		}
+		if detail.CreatedAt == nil || detail.CreatedAt.IsZero() {
+			detail.CreatedAt = clone.CreatedAt
+		}
+		if detail.UpdatedAt == nil || detail.UpdatedAt.IsZero() {
+			detail.UpdatedAt = clone.UpdatedAt
+		}
+		if detail.CompletedAt == nil || detail.CompletedAt.IsZero() {
+			detail.CompletedAt = clone.CompletedAt
+		}
+	})
+
+	r.appendActivity(JobActivity{
+		JobID:      completed.JobId,
+		JobType:    completed.JobType,
+		RequestID:  completed.RequestId,
+		WorkerID:   clone.WorkerID,
+		Source:     "worker_completion",
+		Message:    clone.Message,
+		Stage:      clone.Stage,
+		OccurredAt: timeToPtr(now),
+	})
+
+	return &clone
+}
+
+func (r *Plugin) trackWorkerActivities(jobType, jobID, requestID, workerID string, events []*plugin_pb.ActivityEvent) {
+	if len(events) == 0 {
+		return
+	}
+	for _, event := range events {
+		if event == nil {
+			continue
+		}
+		timestamp := time.Now().UTC()
+		if event.CreatedAt != nil {
+			timestamp = event.CreatedAt.AsTime().UTC()
+		}
+		r.appendActivity(JobActivity{
+			JobID:      jobID,
+			JobType:    jobType,
+			RequestID:  requestID,
+			WorkerID:   workerID,
+			Source:     strings.ToLower(event.Source.String()),
+			Message:    event.Message,
+			Stage:      event.Stage,
+			Details:    configValueMapToPlain(event.Details),
+			OccurredAt: timeToPtr(timestamp),
+		})
+	}
+}
+
+func (r *Plugin) appendActivity(activity JobActivity) {
+	if activity.OccurredAt == nil || activity.OccurredAt.IsZero() {
+		activity.OccurredAt = timeToPtr(time.Now().UTC())
+	}
+
+	r.activitiesMu.Lock()
+	r.activities = append(r.activities, activity)
+	if len(r.activities) > maxActivityRecords {
+		r.activities = r.activities[len(r.activities)-maxActivityRecords:]
+	}
+	r.dirtyActivities = true
+	r.activitiesMu.Unlock()
+}
+
+func (r *Plugin) pruneTrackedJobsLocked() {
+	if len(r.jobs) <= maxTrackedJobsTotal {
+		return
+	}
+
+	type sortableJob struct {
+		jobID     string
+		updatedAt time.Time
+	}
+	terminalJobs := make([]sortableJob, 0)
+	for jobID, job := range r.jobs {
+		if job.State == StateSucceeded ||
+			job.State == StateFailed ||
+			job.State == StateCanceled {
+			updAt := time.Time{}
+			if job.UpdatedAt != nil {
+				updAt = *job.UpdatedAt
+			}
+			terminalJobs = append(terminalJobs, sortableJob{jobID, updAt})
+		}
+	}
+
+	if len(terminalJobs) == 0 {
+		return
+	}
+
+	sort.Slice(terminalJobs, func(i, j int) bool {
+		return terminalJobs[i].updatedAt.Before(terminalJobs[j].updatedAt)
+	})
+
+	toDelete := len(r.jobs) - maxTrackedJobsTotal
+	if toDelete <= 0 {
+		return
+	}
+	if toDelete > len(terminalJobs) {
+		toDelete = len(terminalJobs)
+	}
+
+	for i := 0; i < toDelete; i++ {
+		delete(r.jobs, terminalJobs[i].jobID)
+	}
+}
+
+func configValueMapToPlain(values map[string]*plugin_pb.ConfigValue) map[string]interface{} {
+	if len(values) == 0 {
+		return nil
+	}
+
+	payload, err := protojson.MarshalOptions{UseProtoNames: true}.Marshal(&plugin_pb.ValueMap{Fields: values})
+	if err != nil {
+		return nil
+	}
+
+	decoded := map[string]interface{}{}
+	if err := json.Unmarshal(payload, &decoded); err != nil {
+		return nil
+	}
+
+	fields, ok := decoded["fields"].(map[string]interface{})
+	if !ok {
+		return nil
+	}
+	return fields
+}
+
+func (r *Plugin) persistTrackedJobsSnapshot() {
+	r.jobsMu.Lock()
+	r.dirtyJobs = false
+	jobs := make([]TrackedJob, 0, len(r.jobs))
+	for _, job := range r.jobs {
+		if job == nil || strings.TrimSpace(job.JobID) == "" {
+			continue
+		}
+		clone := cloneTrackedJob(*job)
+		stripTrackedJobDetailFields(&clone)
+		jobs = append(jobs, clone)
+	}
+	r.jobsMu.Unlock()
+
+	if len(jobs) == 0 {
+		return
+	}
+
+	sort.Slice(jobs, func(i, j int) bool {
+		ti := time.Time{}
+		if jobs[i].UpdatedAt != nil {
+			ti = *jobs[i].UpdatedAt
+		}
+		tj := time.Time{}
+		if jobs[j].UpdatedAt != nil {
+			tj = *jobs[j].UpdatedAt
+		}
+		if !ti.Equal(tj) {
+			return ti.After(tj)
+		}
+		return jobs[i].JobID < jobs[j].JobID
+	})
+	if len(jobs) > maxTrackedJobsTotal {
+		jobs = jobs[:maxTrackedJobsTotal]
+	}
+
+	if err := r.store.SaveTrackedJobs(jobs); err != nil {
+		glog.Warningf("Plugin failed to persist tracked jobs: %v", err)
+	}
+}
+
+func (r *Plugin) persistJobDetailSnapshot(jobID string, apply func(detail *TrackedJob)) {
+	normalizedJobID, _ := sanitizeJobID(jobID)
+	if normalizedJobID == "" {
+		return
+	}
+
+	r.jobDetailsMu.Lock()
+	defer r.jobDetailsMu.Unlock()
+
+	detail, err := r.store.LoadJobDetail(normalizedJobID)
+	if err != nil {
+		glog.Warningf("Plugin failed to load job detail snapshot for %s: %v", normalizedJobID, err)
+		return
+	}
+	if detail == nil {
+		detail = &TrackedJob{
+			JobID: normalizedJobID,
+		}
+	}
+
+	if apply != nil {
+		apply(detail)
+	}
+
+	if err := r.store.SaveJobDetail(*detail); err != nil {
+		glog.Warningf("Plugin failed to persist job detail snapshot for %s: %v", normalizedJobID, err)
+	}
+}
+
+func (r *Plugin) persistActivitiesSnapshot() {
+	r.activitiesMu.Lock()
+	r.dirtyActivities = false
+	activities := append([]JobActivity(nil), r.activities...)
+	r.activitiesMu.Unlock()
+
+	if len(activities) == 0 {
+		return
+	}
+
+	if len(activities) > maxActivityRecords {
+		activities = activities[len(activities)-maxActivityRecords:]
+	}
+
+	if err := r.store.SaveActivities(activities); err != nil {
+		glog.Warningf("Plugin failed to persist activities: %v", err)
+	}
+}
+
+func (r *Plugin) persistenceLoop() {
+	defer r.wg.Done()
+	for {
+		select {
+		case <-r.shutdownCh:
+			r.persistTrackedJobsSnapshot()
+			r.persistActivitiesSnapshot()
+			return
+		case <-r.persistTicker.C:
+			r.jobsMu.RLock()
+			needsJobsFlush := r.dirtyJobs
+			r.jobsMu.RUnlock()
+			if needsJobsFlush {
+				r.persistTrackedJobsSnapshot()
+			}
+
+			r.activitiesMu.RLock()
+			needsActivitiesFlush := r.dirtyActivities
+			r.activitiesMu.RUnlock()
+			if needsActivitiesFlush {
+				r.persistActivitiesSnapshot()
+			}
+		}
+	}
+}

weed/admin/plugin/plugin_monitor_test.go

@@ -0,0 +1,600 @@
+package plugin
+
+import (
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func TestPluginLoadsPersistedMonitorStateOnStart(t *testing.T) {
+	t.Parallel()
+
+	dataDir := t.TempDir()
+	store, err := NewConfigStore(dataDir)
+	if err != nil {
+		t.Fatalf("NewConfigStore: %v", err)
+	}
+
+	seedJobs := []TrackedJob{
+		{
+			JobID:     "job-seeded",
+			JobType:   "vacuum",
+			State:     "running",
+			CreatedAt: timeToPtr(time.Now().UTC().Add(-2 * time.Minute)),
+			UpdatedAt: timeToPtr(time.Now().UTC().Add(-1 * time.Minute)),
+		},
+	}
+	seedActivities := []JobActivity{
+		{
+			JobID:      "job-seeded",
+			JobType:    "vacuum",
+			Source:     "worker_progress",
+			Message:    "seeded",
+			OccurredAt: timeToPtr(time.Now().UTC().Add(-30 * time.Second)),
+		},
+	}
+
+	if err := store.SaveTrackedJobs(seedJobs); err != nil {
+		t.Fatalf("SaveTrackedJobs: %v", err)
+	}
+	if err := store.SaveActivities(seedActivities); err != nil {
+		t.Fatalf("SaveActivities: %v", err)
+	}
+
+	pluginSvc, err := New(Options{DataDir: dataDir})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	gotJobs := pluginSvc.ListTrackedJobs("", "", 0)
+	if len(gotJobs) != 1 || gotJobs[0].JobID != "job-seeded" {
+		t.Fatalf("unexpected loaded jobs: %+v", gotJobs)
+	}
+
+	gotActivities := pluginSvc.ListActivities("", 0)
+	if len(gotActivities) != 1 || gotActivities[0].Message != "seeded" {
+		t.Fatalf("unexpected loaded activities: %+v", gotActivities)
+	}
+}
+
+func TestPluginPersistsMonitorStateAfterJobUpdates(t *testing.T) {
+	t.Parallel()
+
+	dataDir := t.TempDir()
+	pluginSvc, err := New(Options{DataDir: dataDir})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	job := &plugin_pb.JobSpec{
+		JobId:   "job-persist",
+		JobType: "vacuum",
+		Summary: "persist test",
+	}
+	pluginSvc.trackExecutionStart("req-persist", "worker-a", job, 1)
+
+	pluginSvc.trackExecutionCompletion(&plugin_pb.JobCompleted{
+		RequestId:   "req-persist",
+		JobId:       "job-persist",
+		JobType:     "vacuum",
+		Success:     true,
+		Result:      &plugin_pb.JobResult{Summary: "done"},
+		CompletedAt: timestamppb.New(time.Now().UTC()),
+	})
+	pluginSvc.Shutdown()
+
+	store, err := NewConfigStore(dataDir)
+	if err != nil {
+		t.Fatalf("NewConfigStore: %v", err)
+	}
+
+	trackedJobs, err := store.LoadTrackedJobs()
+	if err != nil {
+		t.Fatalf("LoadTrackedJobs: %v", err)
+	}
+	if len(trackedJobs) == 0 {
+		t.Fatalf("expected persisted tracked jobs")
+	}
+
+	found := false
+	for _, tracked := range trackedJobs {
+		if tracked.JobID == "job-persist" {
+			found = true
+			if tracked.State == "" {
+				t.Fatalf("persisted job state should not be empty")
+			}
+		}
+	}
+	if !found {
+		t.Fatalf("persisted tracked jobs missing job-persist")
+	}
+
+	activities, err := store.LoadActivities()
+	if err != nil {
+		t.Fatalf("LoadActivities: %v", err)
+	}
+	if len(activities) == 0 {
+		t.Fatalf("expected persisted activities")
+	}
+}
+
+func TestTrackExecutionQueuedMarksPendingState(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.trackExecutionQueued(&plugin_pb.JobSpec{
+		JobId:     "job-pending-1",
+		JobType:   "vacuum",
+		DedupeKey: "vacuum:1",
+		Summary:   "pending queue item",
+	})
+
+	jobs := pluginSvc.ListTrackedJobs("vacuum", "", 10)
+	if len(jobs) != 1 {
+		t.Fatalf("expected one tracked pending job, got=%d", len(jobs))
+	}
+	job := jobs[0]
+	if job.JobID != "job-pending-1" {
+		t.Fatalf("unexpected pending job id: %s", job.JobID)
+	}
+	if job.State != "job_state_pending" {
+		t.Fatalf("unexpected pending job state: %s", job.State)
+	}
+	if job.Stage != "queued" {
+		t.Fatalf("unexpected pending job stage: %s", job.Stage)
+	}
+
+	activities := pluginSvc.ListActivities("vacuum", 50)
+	found := false
+	for _, activity := range activities {
+		if activity.JobID == "job-pending-1" && activity.Stage == "queued" && activity.Source == "admin_scheduler" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("expected queued activity for pending job")
+	}
+}
+
+func TestHandleJobProgressUpdateCarriesWorkerIDInActivities(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	job := &plugin_pb.JobSpec{
+		JobId:   "job-progress-worker",
+		JobType: "vacuum",
+	}
+	pluginSvc.trackExecutionStart("req-progress-worker", "worker-a", job, 1)
+
+	pluginSvc.handleJobProgressUpdate("worker-a", &plugin_pb.JobProgressUpdate{
+		RequestId:       "req-progress-worker",
+		JobId:           "job-progress-worker",
+		JobType:         "vacuum",
+		State:           plugin_pb.JobState_JOB_STATE_RUNNING,
+		ProgressPercent: 42.0,
+		Stage:           "scan",
+		Message:         "in progress",
+		Activities: []*plugin_pb.ActivityEvent{
+			{
+				Source:  plugin_pb.ActivitySource_ACTIVITY_SOURCE_EXECUTOR,
+				Message: "volume scanned",
+				Stage:   "scan",
+			},
+		},
+	})
+
+	activities := pluginSvc.ListActivities("vacuum", 0)
+	if len(activities) == 0 {
+		t.Fatalf("expected activity entries")
+	}
+
+	foundProgress := false
+	foundEvent := false
+	for _, activity := range activities {
+		if activity.Source == "worker_progress" && activity.Message == "in progress" {
+			foundProgress = true
+			if activity.WorkerID != "worker-a" {
+				t.Fatalf("worker_progress activity worker mismatch: got=%q want=%q", activity.WorkerID, "worker-a")
+			}
+		}
+		if activity.Message == "volume scanned" {
+			foundEvent = true
+			if activity.WorkerID != "worker-a" {
+				t.Fatalf("worker event worker mismatch: got=%q want=%q", activity.WorkerID, "worker-a")
+			}
+		}
+	}
+
+	if !foundProgress {
+		t.Fatalf("expected worker_progress activity")
+	}
+	if !foundEvent {
+		t.Fatalf("expected worker activity event")
+	}
+}
+
+func TestHandleJobProgressUpdateWithoutJobIDTracksDetectionActivities(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.handleJobProgressUpdate("worker-detector", &plugin_pb.JobProgressUpdate{
+		RequestId: "detect-req-1",
+		JobType:   "vacuum",
+		State:     plugin_pb.JobState_JOB_STATE_RUNNING,
+		Stage:     "decision_summary",
+		Message:   "VACUUM: No tasks created for 3 volumes",
+		Activities: []*plugin_pb.ActivityEvent{
+			{
+				Source:  plugin_pb.ActivitySource_ACTIVITY_SOURCE_DETECTOR,
+				Stage:   "decision_summary",
+				Message: "VACUUM: No tasks created for 3 volumes",
+			},
+		},
+	})
+
+	activities := pluginSvc.ListActivities("vacuum", 0)
+	if len(activities) == 0 {
+		t.Fatalf("expected activity entries")
+	}
+
+	foundDetectionProgress := false
+	foundDetectorEvent := false
+	for _, activity := range activities {
+		if activity.RequestID != "detect-req-1" {
+			continue
+		}
+		if activity.Source == "worker_detection" {
+			foundDetectionProgress = true
+			if activity.WorkerID != "worker-detector" {
+				t.Fatalf("worker_detection worker mismatch: got=%q want=%q", activity.WorkerID, "worker-detector")
+			}
+		}
+		if activity.Source == "activity_source_detector" {
+			foundDetectorEvent = true
+			if activity.WorkerID != "worker-detector" {
+				t.Fatalf("detector event worker mismatch: got=%q want=%q", activity.WorkerID, "worker-detector")
+			}
+		}
+	}
+
+	if !foundDetectionProgress {
+		t.Fatalf("expected worker_detection activity")
+	}
+	if !foundDetectorEvent {
+		t.Fatalf("expected detector activity event")
+	}
+}
+
+func TestHandleJobCompletedCarriesWorkerIDInActivitiesAndRunHistory(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	job := &plugin_pb.JobSpec{
+		JobId:   "job-complete-worker",
+		JobType: "vacuum",
+	}
+	pluginSvc.trackExecutionStart("req-complete-worker", "worker-b", job, 1)
+
+	pluginSvc.handleJobCompleted(&plugin_pb.JobCompleted{
+		RequestId: "req-complete-worker",
+		JobId:     "job-complete-worker",
+		JobType:   "vacuum",
+		Success:   true,
+		Activities: []*plugin_pb.ActivityEvent{
+			{
+				Source:  plugin_pb.ActivitySource_ACTIVITY_SOURCE_EXECUTOR,
+				Message: "finalizer done",
+				Stage:   "finalize",
+			},
+		},
+		CompletedAt: timestamppb.Now(),
+	})
+	pluginSvc.Shutdown()
+
+	activities := pluginSvc.ListActivities("vacuum", 0)
+	foundWorkerEvent := false
+	for _, activity := range activities {
+		if activity.Message == "finalizer done" {
+			foundWorkerEvent = true
+			if activity.WorkerID != "worker-b" {
+				t.Fatalf("worker completion event worker mismatch: got=%q want=%q", activity.WorkerID, "worker-b")
+			}
+		}
+	}
+	if !foundWorkerEvent {
+		t.Fatalf("expected completion worker event activity")
+	}
+
+	history, err := pluginSvc.LoadRunHistory("vacuum")
+	if err != nil {
+		t.Fatalf("LoadRunHistory: %v", err)
+	}
+	if history == nil || len(history.SuccessfulRuns) == 0 {
+		t.Fatalf("expected successful run history entry")
+	}
+	if history.SuccessfulRuns[0].WorkerID != "worker-b" {
+		t.Fatalf("run history worker mismatch: got=%q want=%q", history.SuccessfulRuns[0].WorkerID, "worker-b")
+	}
+}
+
+func TestTrackExecutionStartStoresJobPayloadDetails(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{DataDir: t.TempDir()})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.trackExecutionStart("req-payload", "worker-c", &plugin_pb.JobSpec{
+		JobId:   "job-payload",
+		JobType: "vacuum",
+		Summary: "payload summary",
+		Detail:  "payload detail",
+		Parameters: map[string]*plugin_pb.ConfigValue{
+			"volume_id": {
+				Kind: &plugin_pb.ConfigValue_Int64Value{Int64Value: 9},
+			},
+		},
+		Labels: map[string]string{
+			"source": "detector",
+		},
+	}, 2)
+	pluginSvc.Shutdown()
+
+	job, found := pluginSvc.GetTrackedJob("job-payload")
+	if !found || job == nil {
+		t.Fatalf("expected tracked job")
+	}
+	if job.Detail != "" {
+		t.Fatalf("expected in-memory tracked job detail to be stripped, got=%q", job.Detail)
+	}
+	if job.Attempt != 2 {
+		t.Fatalf("unexpected attempt: %d", job.Attempt)
+	}
+	if len(job.Labels) != 0 {
+		t.Fatalf("expected in-memory labels to be stripped, got=%+v", job.Labels)
+	}
+	if len(job.Parameters) != 0 {
+		t.Fatalf("expected in-memory parameters to be stripped, got=%+v", job.Parameters)
+	}
+
+	detail, found, err := pluginSvc.BuildJobDetail("job-payload", 100, 0)
+	if err != nil {
+		t.Fatalf("BuildJobDetail: %v", err)
+	}
+	if !found || detail == nil || detail.Job == nil {
+		t.Fatalf("expected disk-backed job detail")
+	}
+	if detail.Job.Detail != "payload detail" {
+		t.Fatalf("unexpected disk-backed detail: %q", detail.Job.Detail)
+	}
+	if got := detail.Job.Labels["source"]; got != "detector" {
+		t.Fatalf("unexpected disk-backed label source: %q", got)
+	}
+	if got, ok := detail.Job.Parameters["volume_id"].(map[string]interface{}); !ok || got["int64_value"] != "9" {
+		t.Fatalf("unexpected disk-backed parameters payload: %#v", detail.Job.Parameters["volume_id"])
+	}
+}
+
+func TestTrackExecutionStartStoresErasureCodingExecutionPlan(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{DataDir: t.TempDir()})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	taskParams := &worker_pb.TaskParams{
+		TaskId:     "task-ec-1",
+		VolumeId:   29,
+		Collection: "photos",
+		Sources: []*worker_pb.TaskSource{
+			{
+				Node:       "source-a:8080",
+				DataCenter: "dc1",
+				Rack:       "rack1",
+				VolumeId:   29,
+			},
+		},
+		Targets: []*worker_pb.TaskTarget{
+			{
+				Node:       "target-a:8080",
+				DataCenter: "dc1",
+				Rack:       "rack2",
+				VolumeId:   29,
+				ShardIds:   []uint32{0, 10},
+			},
+			{
+				Node:       "target-b:8080",
+				DataCenter: "dc2",
+				Rack:       "rack3",
+				VolumeId:   29,
+				ShardIds:   []uint32{1, 11},
+			},
+		},
+		TaskParams: &worker_pb.TaskParams_ErasureCodingParams{
+			ErasureCodingParams: &worker_pb.ErasureCodingTaskParams{
+				DataShards:   10,
+				ParityShards: 4,
+			},
+		},
+	}
+	payload, err := proto.Marshal(taskParams)
+	if err != nil {
+		t.Fatalf("Marshal task params: %v", err)
+	}
+
+	pluginSvc.trackExecutionStart("req-ec-plan", "worker-ec", &plugin_pb.JobSpec{
+		JobId:   "job-ec-plan",
+		JobType: "erasure_coding",
+		Parameters: map[string]*plugin_pb.ConfigValue{
+			"task_params_pb": {
+				Kind: &plugin_pb.ConfigValue_BytesValue{BytesValue: payload},
+			},
+		},
+	}, 1)
+	pluginSvc.Shutdown()
+
+	detail, found, err := pluginSvc.BuildJobDetail("job-ec-plan", 100, 0)
+	if err != nil {
+		t.Fatalf("BuildJobDetail: %v", err)
+	}
+	if !found || detail == nil || detail.Job == nil {
+		t.Fatalf("expected disk-backed detail")
+	}
+
+	rawPlan, ok := detail.Job.Parameters["execution_plan"]
+	if !ok {
+		t.Fatalf("expected execution_plan in parameters, got=%+v", detail.Job.Parameters)
+	}
+	plan, ok := rawPlan.(map[string]interface{})
+	if !ok {
+		t.Fatalf("unexpected execution_plan type: %T", rawPlan)
+	}
+	if plan["job_type"] != "erasure_coding" {
+		t.Fatalf("unexpected execution plan job type: %+v", plan["job_type"])
+	}
+	if plan["volume_id"] != float64(29) {
+		t.Fatalf("unexpected execution plan volume id: %+v", plan["volume_id"])
+	}
+	targets, ok := plan["targets"].([]interface{})
+	if !ok || len(targets) != 2 {
+		t.Fatalf("unexpected targets in execution plan: %+v", plan["targets"])
+	}
+	assignments, ok := plan["shard_assignments"].([]interface{})
+	if !ok || len(assignments) != 4 {
+		t.Fatalf("unexpected shard assignments in execution plan: %+v", plan["shard_assignments"])
+	}
+	firstAssignment, ok := assignments[0].(map[string]interface{})
+	if !ok {
+		t.Fatalf("unexpected first assignment payload: %+v", assignments[0])
+	}
+	if firstAssignment["shard_id"] != float64(0) || firstAssignment["kind"] != "data" {
+		t.Fatalf("unexpected first assignment: %+v", firstAssignment)
+	}
+}
+
+func TestBuildJobDetailIncludesActivitiesAndRunRecord(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{DataDir: t.TempDir()})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.trackExecutionStart("req-detail", "worker-z", &plugin_pb.JobSpec{
+		JobId:   "job-detail",
+		JobType: "vacuum",
+		Summary: "detail summary",
+	}, 1)
+	pluginSvc.handleJobProgressUpdate("worker-z", &plugin_pb.JobProgressUpdate{
+		RequestId: "req-detail",
+		JobId:     "job-detail",
+		JobType:   "vacuum",
+		State:     plugin_pb.JobState_JOB_STATE_RUNNING,
+		Stage:     "scan",
+		Message:   "scanning volume",
+	})
+	pluginSvc.handleJobCompleted(&plugin_pb.JobCompleted{
+		RequestId: "req-detail",
+		JobId:     "job-detail",
+		JobType:   "vacuum",
+		Success:   true,
+		Result: &plugin_pb.JobResult{
+			Summary: "done",
+			OutputValues: map[string]*plugin_pb.ConfigValue{
+				"affected": {
+					Kind: &plugin_pb.ConfigValue_Int64Value{Int64Value: 1},
+				},
+			},
+		},
+		CompletedAt: timestamppb.Now(),
+	})
+	pluginSvc.Shutdown()
+
+	detail, found, err := pluginSvc.BuildJobDetail("job-detail", 100, 5)
+	if err != nil {
+		t.Fatalf("BuildJobDetail error: %v", err)
+	}
+	if !found || detail == nil {
+		t.Fatalf("expected job detail")
+	}
+	if detail.Job == nil || detail.Job.JobID != "job-detail" {
+		t.Fatalf("unexpected job detail payload: %+v", detail.Job)
+	}
+	if detail.RunRecord == nil || detail.RunRecord.JobID != "job-detail" {
+		t.Fatalf("expected run record for job-detail, got=%+v", detail.RunRecord)
+	}
+	if len(detail.Activities) == 0 {
+		t.Fatalf("expected activity timeline entries")
+	}
+	if detail.Job.ResultOutputValues == nil {
+		t.Fatalf("expected result output values")
+	}
+}
+
+func TestBuildJobDetailLoadsFromDiskWhenMemoryCleared(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{DataDir: t.TempDir()})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.trackExecutionStart("req-disk", "worker-d", &plugin_pb.JobSpec{
+		JobId:   "job-disk",
+		JobType: "vacuum",
+		Summary: "disk summary",
+		Detail:  "disk detail payload",
+	}, 1)
+	pluginSvc.Shutdown()
+
+	pluginSvc.jobsMu.Lock()
+	pluginSvc.jobs = map[string]*TrackedJob{}
+	pluginSvc.jobsMu.Unlock()
+	pluginSvc.activitiesMu.Lock()
+	pluginSvc.activities = nil
+	pluginSvc.activitiesMu.Unlock()
+
+	detail, found, err := pluginSvc.BuildJobDetail("job-disk", 100, 0)
+	if err != nil {
+		t.Fatalf("BuildJobDetail: %v", err)
+	}
+	if !found || detail == nil || detail.Job == nil {
+		t.Fatalf("expected detail from disk")
+	}
+	if detail.Job.Detail != "disk detail payload" {
+		t.Fatalf("unexpected disk detail payload: %q", detail.Job.Detail)
+	}
+}

weed/admin/plugin/plugin_scheduler.go

@@ -0,0 +1,945 @@
+package plugin
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+var errExecutorAtCapacity = errors.New("executor is at capacity")
+
+const (
+	defaultSchedulerTick                       = 5 * time.Second
+	defaultScheduledDetectionInterval          = 300 * time.Second
+	defaultScheduledDetectionTimeout           = 45 * time.Second
+	defaultScheduledExecutionTimeout           = 90 * time.Second
+	defaultScheduledMaxResults           int32 = 1000
+	defaultScheduledExecutionConcurrency       = 1
+	defaultScheduledPerWorkerConcurrency       = 1
+	maxScheduledExecutionConcurrency           = 128
+	defaultScheduledRetryBackoff               = 5 * time.Second
+	defaultClusterContextTimeout               = 10 * time.Second
+	defaultWaitingBacklogFloor                 = 8
+	defaultWaitingBacklogMultiplier            = 4
+)
+
+type schedulerPolicy struct {
+	DetectionInterval      time.Duration
+	DetectionTimeout       time.Duration
+	ExecutionTimeout       time.Duration
+	RetryBackoff           time.Duration
+	MaxResults             int32
+	ExecutionConcurrency   int
+	PerWorkerConcurrency   int
+	RetryLimit             int
+	ExecutorReserveBackoff time.Duration
+}
+
+func (r *Plugin) schedulerLoop() {
+	defer r.wg.Done()
+	ticker := time.NewTicker(r.schedulerTick)
+	defer ticker.Stop()
+
+	// Try once immediately on startup.
+	r.runSchedulerTick()
+
+	for {
+		select {
+		case <-r.shutdownCh:
+			return
+		case <-ticker.C:
+			r.runSchedulerTick()
+		}
+	}
+}
+
+func (r *Plugin) runSchedulerTick() {
+	jobTypes := r.registry.DetectableJobTypes()
+	if len(jobTypes) == 0 {
+		return
+	}
+
+	active := make(map[string]struct{}, len(jobTypes))
+	for _, jobType := range jobTypes {
+		active[jobType] = struct{}{}
+
+		policy, enabled, err := r.loadSchedulerPolicy(jobType)
+		if err != nil {
+			glog.Warningf("Plugin scheduler failed to load policy for %s: %v", jobType, err)
+			continue
+		}
+		if !enabled {
+			r.clearSchedulerJobType(jobType)
+			continue
+		}
+
+		if !r.markDetectionDue(jobType, policy.DetectionInterval) {
+			continue
+		}
+
+		r.wg.Add(1)
+		go func(jt string, p schedulerPolicy) {
+			defer r.wg.Done()
+			r.runScheduledDetection(jt, p)
+		}(jobType, policy)
+	}
+
+	r.pruneSchedulerState(active)
+	r.pruneDetectorLeases(active)
+}
+
+func (r *Plugin) loadSchedulerPolicy(jobType string) (schedulerPolicy, bool, error) {
+	cfg, err := r.store.LoadJobTypeConfig(jobType)
+	if err != nil {
+		return schedulerPolicy{}, false, err
+	}
+	descriptor, err := r.store.LoadDescriptor(jobType)
+	if err != nil {
+		return schedulerPolicy{}, false, err
+	}
+
+	adminRuntime := deriveSchedulerAdminRuntime(cfg, descriptor)
+	if adminRuntime == nil {
+		return schedulerPolicy{}, false, nil
+	}
+	if !adminRuntime.Enabled {
+		return schedulerPolicy{}, false, nil
+	}
+
+	policy := schedulerPolicy{
+		DetectionInterval:      durationFromSeconds(adminRuntime.DetectionIntervalSeconds, defaultScheduledDetectionInterval),
+		DetectionTimeout:       durationFromSeconds(adminRuntime.DetectionTimeoutSeconds, defaultScheduledDetectionTimeout),
+		ExecutionTimeout:       defaultScheduledExecutionTimeout,
+		RetryBackoff:           durationFromSeconds(adminRuntime.RetryBackoffSeconds, defaultScheduledRetryBackoff),
+		MaxResults:             adminRuntime.MaxJobsPerDetection,
+		ExecutionConcurrency:   int(adminRuntime.GlobalExecutionConcurrency),
+		PerWorkerConcurrency:   int(adminRuntime.PerWorkerExecutionConcurrency),
+		RetryLimit:             int(adminRuntime.RetryLimit),
+		ExecutorReserveBackoff: 200 * time.Millisecond,
+	}
+
+	if policy.DetectionInterval < r.schedulerTick {
+		policy.DetectionInterval = r.schedulerTick
+	}
+	if policy.MaxResults <= 0 {
+		policy.MaxResults = defaultScheduledMaxResults
+	}
+	if policy.ExecutionConcurrency <= 0 {
+		policy.ExecutionConcurrency = defaultScheduledExecutionConcurrency
+	}
+	if policy.ExecutionConcurrency > maxScheduledExecutionConcurrency {
+		policy.ExecutionConcurrency = maxScheduledExecutionConcurrency
+	}
+	if policy.PerWorkerConcurrency <= 0 {
+		policy.PerWorkerConcurrency = defaultScheduledPerWorkerConcurrency
+	}
+	if policy.PerWorkerConcurrency > policy.ExecutionConcurrency {
+		policy.PerWorkerConcurrency = policy.ExecutionConcurrency
+	}
+	if policy.RetryLimit < 0 {
+		policy.RetryLimit = 0
+	}
+
+	// Plugin protocol currently has only detection timeout in admin settings.
+	execTimeout := time.Duration(adminRuntime.DetectionTimeoutSeconds*2) * time.Second
+	if execTimeout < defaultScheduledExecutionTimeout {
+		execTimeout = defaultScheduledExecutionTimeout
+	}
+	policy.ExecutionTimeout = execTimeout
+
+	return policy, true, nil
+}
+
+func (r *Plugin) ListSchedulerStates() ([]SchedulerJobTypeState, error) {
+	jobTypes, err := r.ListKnownJobTypes()
+	if err != nil {
+		return nil, err
+	}
+
+	r.schedulerMu.Lock()
+	nextDetectionAt := make(map[string]time.Time, len(r.nextDetectionAt))
+	for jobType, nextRun := range r.nextDetectionAt {
+		nextDetectionAt[jobType] = nextRun
+	}
+	detectionInFlight := make(map[string]bool, len(r.detectionInFlight))
+	for jobType, inFlight := range r.detectionInFlight {
+		detectionInFlight[jobType] = inFlight
+	}
+	r.schedulerMu.Unlock()
+
+	states := make([]SchedulerJobTypeState, 0, len(jobTypes))
+	for _, jobType := range jobTypes {
+		state := SchedulerJobTypeState{
+			JobType:           jobType,
+			DetectionInFlight: detectionInFlight[jobType],
+		}
+
+		if nextRun, ok := nextDetectionAt[jobType]; ok && !nextRun.IsZero() {
+			nextRunUTC := nextRun.UTC()
+			state.NextDetectionAt = &nextRunUTC
+		}
+
+		policy, enabled, loadErr := r.loadSchedulerPolicy(jobType)
+		if loadErr != nil {
+			state.PolicyError = loadErr.Error()
+		} else {
+			state.Enabled = enabled
+			if enabled {
+				state.DetectionIntervalSeconds = secondsFromDuration(policy.DetectionInterval)
+				state.DetectionTimeoutSeconds = secondsFromDuration(policy.DetectionTimeout)
+				state.ExecutionTimeoutSeconds = secondsFromDuration(policy.ExecutionTimeout)
+				state.MaxJobsPerDetection = policy.MaxResults
+				state.GlobalExecutionConcurrency = policy.ExecutionConcurrency
+				state.PerWorkerExecutionConcurrency = policy.PerWorkerConcurrency
+				state.RetryLimit = policy.RetryLimit
+				state.RetryBackoffSeconds = secondsFromDuration(policy.RetryBackoff)
+			}
+		}
+
+		leasedWorkerID := r.getDetectorLease(jobType)
+		if leasedWorkerID != "" {
+			state.DetectorWorkerID = leasedWorkerID
+			if worker, ok := r.registry.Get(leasedWorkerID); ok {
+				if capability := worker.Capabilities[jobType]; capability != nil && capability.CanDetect {
+					state.DetectorAvailable = true
+				}
+			}
+		}
+		if state.DetectorWorkerID == "" {
+			detector, detectorErr := r.registry.PickDetector(jobType)
+			if detectorErr == nil && detector != nil {
+				state.DetectorAvailable = true
+				state.DetectorWorkerID = detector.WorkerID
+			}
+		}
+
+		executors, executorErr := r.registry.ListExecutors(jobType)
+		if executorErr == nil {
+			state.ExecutorWorkerCount = len(executors)
+		}
+
+		states = append(states, state)
+	}
+
+	return states, nil
+}
+
+func deriveSchedulerAdminRuntime(
+	cfg *plugin_pb.PersistedJobTypeConfig,
+	descriptor *plugin_pb.JobTypeDescriptor,
+) *plugin_pb.AdminRuntimeConfig {
+	if cfg != nil && cfg.AdminRuntime != nil {
+		adminConfig := *cfg.AdminRuntime
+		return &adminConfig
+	}
+
+	if descriptor == nil || descriptor.AdminRuntimeDefaults == nil {
+		return nil
+	}
+
+	defaults := descriptor.AdminRuntimeDefaults
+	return &plugin_pb.AdminRuntimeConfig{
+		Enabled:                       defaults.Enabled,
+		DetectionIntervalSeconds:      defaults.DetectionIntervalSeconds,
+		DetectionTimeoutSeconds:       defaults.DetectionTimeoutSeconds,
+		MaxJobsPerDetection:           defaults.MaxJobsPerDetection,
+		GlobalExecutionConcurrency:    defaults.GlobalExecutionConcurrency,
+		PerWorkerExecutionConcurrency: defaults.PerWorkerExecutionConcurrency,
+		RetryLimit:                    defaults.RetryLimit,
+		RetryBackoffSeconds:           defaults.RetryBackoffSeconds,
+	}
+}
+
+func (r *Plugin) markDetectionDue(jobType string, interval time.Duration) bool {
+	now := time.Now().UTC()
+
+	r.schedulerMu.Lock()
+	defer r.schedulerMu.Unlock()
+
+	if r.detectionInFlight[jobType] {
+		return false
+	}
+
+	nextRun, exists := r.nextDetectionAt[jobType]
+	if exists && now.Before(nextRun) {
+		return false
+	}
+
+	r.nextDetectionAt[jobType] = now.Add(interval)
+	r.detectionInFlight[jobType] = true
+	return true
+}
+
+func (r *Plugin) finishDetection(jobType string) {
+	r.schedulerMu.Lock()
+	delete(r.detectionInFlight, jobType)
+	r.schedulerMu.Unlock()
+}
+
+func (r *Plugin) pruneSchedulerState(activeJobTypes map[string]struct{}) {
+	r.schedulerMu.Lock()
+	defer r.schedulerMu.Unlock()
+
+	for jobType := range r.nextDetectionAt {
+		if _, ok := activeJobTypes[jobType]; !ok {
+			delete(r.nextDetectionAt, jobType)
+			delete(r.detectionInFlight, jobType)
+		}
+	}
+}
+
+func (r *Plugin) clearSchedulerJobType(jobType string) {
+	r.schedulerMu.Lock()
+	delete(r.nextDetectionAt, jobType)
+	delete(r.detectionInFlight, jobType)
+	r.schedulerMu.Unlock()
+	r.clearDetectorLease(jobType, "")
+}
+
+func (r *Plugin) pruneDetectorLeases(activeJobTypes map[string]struct{}) {
+	r.detectorLeaseMu.Lock()
+	defer r.detectorLeaseMu.Unlock()
+
+	for jobType := range r.detectorLeases {
+		if _, ok := activeJobTypes[jobType]; !ok {
+			delete(r.detectorLeases, jobType)
+		}
+	}
+}
+
+func (r *Plugin) runScheduledDetection(jobType string, policy schedulerPolicy) {
+	defer r.finishDetection(jobType)
+
+	start := time.Now().UTC()
+	r.appendActivity(JobActivity{
+		JobType:    jobType,
+		Source:     "admin_scheduler",
+		Message:    "scheduled detection started",
+		Stage:      "detecting",
+		OccurredAt: timeToPtr(start),
+	})
+
+	if skip, waitingCount, waitingThreshold := r.shouldSkipDetectionForWaitingJobs(jobType, policy); skip {
+		r.appendActivity(JobActivity{
+			JobType:    jobType,
+			Source:     "admin_scheduler",
+			Message:    fmt.Sprintf("scheduled detection skipped: waiting backlog %d reached threshold %d", waitingCount, waitingThreshold),
+			Stage:      "skipped_waiting_backlog",
+			OccurredAt: timeToPtr(time.Now().UTC()),
+		})
+		return
+	}
+
+	clusterContext, err := r.loadSchedulerClusterContext()
+	if err != nil {
+		r.appendActivity(JobActivity{
+			JobType:    jobType,
+			Source:     "admin_scheduler",
+			Message:    fmt.Sprintf("scheduled detection aborted: %v", err),
+			Stage:      "failed",
+			OccurredAt: timeToPtr(time.Now().UTC()),
+		})
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), policy.DetectionTimeout)
+	proposals, err := r.RunDetection(ctx, jobType, clusterContext, policy.MaxResults)
+	cancel()
+	if err != nil {
+		r.appendActivity(JobActivity{
+			JobType:    jobType,
+			Source:     "admin_scheduler",
+			Message:    fmt.Sprintf("scheduled detection failed: %v", err),
+			Stage:      "failed",
+			OccurredAt: timeToPtr(time.Now().UTC()),
+		})
+		return
+	}
+
+	r.appendActivity(JobActivity{
+		JobType:    jobType,
+		Source:     "admin_scheduler",
+		Message:    fmt.Sprintf("scheduled detection completed: %d proposal(s)", len(proposals)),
+		Stage:      "detected",
+		OccurredAt: timeToPtr(time.Now().UTC()),
+	})
+
+	filteredByActive, skippedActive := r.filterProposalsWithActiveJobs(jobType, proposals)
+	if skippedActive > 0 {
+		r.appendActivity(JobActivity{
+			JobType:    jobType,
+			Source:     "admin_scheduler",
+			Message:    fmt.Sprintf("scheduled detection skipped %d proposal(s) due to active assigned/running jobs", skippedActive),
+			Stage:      "deduped_active_jobs",
+			OccurredAt: timeToPtr(time.Now().UTC()),
+		})
+	}
+
+	if len(filteredByActive) == 0 {
+		return
+	}
+
+	filtered := r.filterScheduledProposals(filteredByActive)
+	if len(filtered) != len(filteredByActive) {
+		r.appendActivity(JobActivity{
+			JobType:    jobType,
+			Source:     "admin_scheduler",
+			Message:    fmt.Sprintf("scheduled detection deduped %d proposal(s) within this run", len(filteredByActive)-len(filtered)),
+			Stage:      "deduped",
+			OccurredAt: timeToPtr(time.Now().UTC()),
+		})
+	}
+
+	if len(filtered) == 0 {
+		return
+	}
+
+	r.dispatchScheduledProposals(jobType, filtered, clusterContext, policy)
+}
+
+func (r *Plugin) loadSchedulerClusterContext() (*plugin_pb.ClusterContext, error) {
+	if r.clusterContextProvider == nil {
+		return nil, fmt.Errorf("cluster context provider is not configured")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), defaultClusterContextTimeout)
+	defer cancel()
+
+	clusterContext, err := r.clusterContextProvider(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if clusterContext == nil {
+		return nil, fmt.Errorf("cluster context provider returned nil")
+	}
+	return clusterContext, nil
+}
+
+func (r *Plugin) dispatchScheduledProposals(
+	jobType string,
+	proposals []*plugin_pb.JobProposal,
+	clusterContext *plugin_pb.ClusterContext,
+	policy schedulerPolicy,
+) {
+	jobQueue := make(chan *plugin_pb.JobSpec, len(proposals))
+	for index, proposal := range proposals {
+		job := buildScheduledJobSpec(jobType, proposal, index)
+		r.trackExecutionQueued(job)
+		select {
+		case <-r.shutdownCh:
+			close(jobQueue)
+			return
+		default:
+			jobQueue <- job
+		}
+	}
+	close(jobQueue)
+
+	var wg sync.WaitGroup
+	var statsMu sync.Mutex
+	successCount := 0
+	errorCount := 0
+
+	workerCount := policy.ExecutionConcurrency
+	if workerCount < 1 {
+		workerCount = 1
+	}
+
+	for i := 0; i < workerCount; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			for job := range jobQueue {
+				select {
+				case <-r.shutdownCh:
+					return
+				default:
+				}
+
+				for {
+					select {
+					case <-r.shutdownCh:
+						return
+					default:
+					}
+
+					executor, release, reserveErr := r.reserveScheduledExecutor(jobType, policy)
+					if reserveErr != nil {
+						select {
+						case <-r.shutdownCh:
+							return
+						default:
+						}
+						statsMu.Lock()
+						errorCount++
+						statsMu.Unlock()
+						r.appendActivity(JobActivity{
+							JobType:    jobType,
+							Source:     "admin_scheduler",
+							Message:    fmt.Sprintf("scheduled execution reservation failed: %v", reserveErr),
+							Stage:      "failed",
+							OccurredAt: timeToPtr(time.Now().UTC()),
+						})
+						break
+					}
+
+					err := r.executeScheduledJobWithExecutor(executor, job, clusterContext, policy)
+					release()
+					if errors.Is(err, errExecutorAtCapacity) {
+						r.trackExecutionQueued(job)
+						if !waitForShutdownOrTimer(r.shutdownCh, policy.ExecutorReserveBackoff) {
+							return
+						}
+						continue
+					}
+					if err != nil {
+						statsMu.Lock()
+						errorCount++
+						statsMu.Unlock()
+						r.appendActivity(JobActivity{
+							JobID:      job.JobId,
+							JobType:    job.JobType,
+							Source:     "admin_scheduler",
+							Message:    fmt.Sprintf("scheduled execution failed: %v", err),
+							Stage:      "failed",
+							OccurredAt: timeToPtr(time.Now().UTC()),
+						})
+						break
+					}
+
+					statsMu.Lock()
+					successCount++
+					statsMu.Unlock()
+					break
+				}
+			}
+		}()
+	}
+
+	wg.Wait()
+
+	r.appendActivity(JobActivity{
+		JobType:    jobType,
+		Source:     "admin_scheduler",
+		Message:    fmt.Sprintf("scheduled execution finished: success=%d error=%d", successCount, errorCount),
+		Stage:      "executed",
+		OccurredAt: timeToPtr(time.Now().UTC()),
+	})
+}
+
+func (r *Plugin) reserveScheduledExecutor(
+	jobType string,
+	policy schedulerPolicy,
+) (*WorkerSession, func(), error) {
+	deadline := time.Now().Add(policy.ExecutionTimeout)
+	if policy.ExecutionTimeout <= 0 {
+		deadline = time.Now().Add(10 * time.Minute) // Default cap
+	}
+
+	for {
+		select {
+		case <-r.shutdownCh:
+			return nil, nil, fmt.Errorf("plugin is shutting down")
+		default:
+		}
+
+		if time.Now().After(deadline) {
+			return nil, nil, fmt.Errorf("timed out waiting for executor capacity for %s", jobType)
+		}
+
+		executors, err := r.registry.ListExecutors(jobType)
+		if err != nil {
+			if !waitForShutdownOrTimer(r.shutdownCh, policy.ExecutorReserveBackoff) {
+				return nil, nil, fmt.Errorf("plugin is shutting down")
+			}
+			continue
+		}
+
+		for _, executor := range executors {
+			release, ok := r.tryReserveExecutorCapacity(executor, jobType, policy)
+			if !ok {
+				continue
+			}
+			return executor, release, nil
+		}
+
+		if !waitForShutdownOrTimer(r.shutdownCh, policy.ExecutorReserveBackoff) {
+			return nil, nil, fmt.Errorf("plugin is shutting down")
+		}
+	}
+}
+
+func (r *Plugin) tryReserveExecutorCapacity(
+	executor *WorkerSession,
+	jobType string,
+	policy schedulerPolicy,
+) (func(), bool) {
+	if executor == nil || strings.TrimSpace(executor.WorkerID) == "" {
+		return nil, false
+	}
+
+	limit := schedulerWorkerExecutionLimit(executor, jobType, policy)
+	if limit <= 0 {
+		return nil, false
+	}
+	heartbeatUsed := 0
+	if executor.Heartbeat != nil && executor.Heartbeat.ExecutionSlotsUsed > 0 {
+		heartbeatUsed = int(executor.Heartbeat.ExecutionSlotsUsed)
+	}
+
+	workerID := strings.TrimSpace(executor.WorkerID)
+
+	r.schedulerExecMu.Lock()
+	reserved := r.schedulerExecReservations[workerID]
+	if heartbeatUsed+reserved >= limit {
+		r.schedulerExecMu.Unlock()
+		return nil, false
+	}
+	r.schedulerExecReservations[workerID] = reserved + 1
+	r.schedulerExecMu.Unlock()
+
+	release := func() {
+		r.releaseExecutorCapacity(workerID)
+	}
+	return release, true
+}
+
+func (r *Plugin) releaseExecutorCapacity(workerID string) {
+	workerID = strings.TrimSpace(workerID)
+	if workerID == "" {
+		return
+	}
+
+	r.schedulerExecMu.Lock()
+	defer r.schedulerExecMu.Unlock()
+
+	current := r.schedulerExecReservations[workerID]
+	if current <= 1 {
+		delete(r.schedulerExecReservations, workerID)
+		return
+	}
+	r.schedulerExecReservations[workerID] = current - 1
+}
+
+func schedulerWorkerExecutionLimit(executor *WorkerSession, jobType string, policy schedulerPolicy) int {
+	limit := policy.PerWorkerConcurrency
+	if limit <= 0 {
+		limit = defaultScheduledPerWorkerConcurrency
+	}
+
+	if capability := executor.Capabilities[jobType]; capability != nil && capability.MaxExecutionConcurrency > 0 {
+		capLimit := int(capability.MaxExecutionConcurrency)
+		if capLimit < limit {
+			limit = capLimit
+		}
+	}
+
+	if executor.Heartbeat != nil && executor.Heartbeat.ExecutionSlotsTotal > 0 {
+		heartbeatLimit := int(executor.Heartbeat.ExecutionSlotsTotal)
+		if heartbeatLimit < limit {
+			limit = heartbeatLimit
+		}
+	}
+
+	if limit < 0 {
+		return 0
+	}
+	return limit
+}
+
+func (r *Plugin) executeScheduledJobWithExecutor(
+	executor *WorkerSession,
+	job *plugin_pb.JobSpec,
+	clusterContext *plugin_pb.ClusterContext,
+	policy schedulerPolicy,
+) error {
+	maxAttempts := policy.RetryLimit + 1
+	if maxAttempts < 1 {
+		maxAttempts = 1
+	}
+
+	var lastErr error
+	for attempt := 1; attempt <= maxAttempts; attempt++ {
+		select {
+		case <-r.shutdownCh:
+			return fmt.Errorf("plugin is shutting down")
+		default:
+		}
+
+		execCtx, cancel := context.WithTimeout(context.Background(), policy.ExecutionTimeout)
+		_, err := r.executeJobWithExecutor(execCtx, executor, job, clusterContext, int32(attempt))
+		cancel()
+		if err == nil {
+			return nil
+		}
+		if isExecutorAtCapacityError(err) {
+			return errExecutorAtCapacity
+		}
+		lastErr = err
+
+		if attempt < maxAttempts {
+			r.appendActivity(JobActivity{
+				JobID:      job.JobId,
+				JobType:    job.JobType,
+				Source:     "admin_scheduler",
+				Message:    fmt.Sprintf("retrying job attempt %d/%d after error: %v", attempt, maxAttempts, err),
+				Stage:      "retry",
+				OccurredAt: timeToPtr(time.Now().UTC()),
+			})
+			if !waitForShutdownOrTimer(r.shutdownCh, policy.RetryBackoff) {
+				return fmt.Errorf("plugin is shutting down")
+			}
+		}
+	}
+
+	if lastErr == nil {
+		lastErr = fmt.Errorf("execution failed without an explicit error")
+	}
+	return lastErr
+}
+
+func (r *Plugin) shouldSkipDetectionForWaitingJobs(jobType string, policy schedulerPolicy) (bool, int, int) {
+	waitingCount := r.countWaitingTrackedJobs(jobType)
+	threshold := waitingBacklogThreshold(policy)
+	if threshold <= 0 {
+		return false, waitingCount, threshold
+	}
+	return waitingCount >= threshold, waitingCount, threshold
+}
+
+func (r *Plugin) countWaitingTrackedJobs(jobType string) int {
+	normalizedJobType := strings.TrimSpace(jobType)
+	if normalizedJobType == "" {
+		return 0
+	}
+
+	waiting := 0
+	r.jobsMu.RLock()
+	for _, job := range r.jobs {
+		if job == nil {
+			continue
+		}
+		if strings.TrimSpace(job.JobType) != normalizedJobType {
+			continue
+		}
+		if !isWaitingTrackedJobState(job.State) {
+			continue
+		}
+		waiting++
+	}
+	r.jobsMu.RUnlock()
+
+	return waiting
+}
+
+func waitingBacklogThreshold(policy schedulerPolicy) int {
+	concurrency := policy.ExecutionConcurrency
+	if concurrency <= 0 {
+		concurrency = defaultScheduledExecutionConcurrency
+	}
+	threshold := concurrency * defaultWaitingBacklogMultiplier
+	if threshold < defaultWaitingBacklogFloor {
+		threshold = defaultWaitingBacklogFloor
+	}
+	if policy.MaxResults > 0 && threshold > int(policy.MaxResults) {
+		threshold = int(policy.MaxResults)
+	}
+	return threshold
+}
+
+func isExecutorAtCapacityError(err error) bool {
+	if err == nil {
+		return false
+	}
+	if errors.Is(err, errExecutorAtCapacity) {
+		return true
+	}
+	return strings.Contains(strings.ToLower(err.Error()), "executor is at capacity")
+}
+
+func buildScheduledJobSpec(jobType string, proposal *plugin_pb.JobProposal, index int) *plugin_pb.JobSpec {
+	now := timestamppb.Now()
+
+	jobID := fmt.Sprintf("%s-scheduled-%d-%d", jobType, now.AsTime().UnixNano(), index)
+
+	job := &plugin_pb.JobSpec{
+		JobId:       jobID,
+		JobType:     jobType,
+		Priority:    plugin_pb.JobPriority_JOB_PRIORITY_NORMAL,
+		Parameters:  map[string]*plugin_pb.ConfigValue{},
+		Labels:      map[string]string{},
+		CreatedAt:   now,
+		ScheduledAt: now,
+	}
+
+	if proposal == nil {
+		return job
+	}
+
+	if proposal.JobType != "" {
+		job.JobType = proposal.JobType
+	}
+	job.Summary = proposal.Summary
+	job.Detail = proposal.Detail
+	if proposal.Priority != plugin_pb.JobPriority_JOB_PRIORITY_UNSPECIFIED {
+		job.Priority = proposal.Priority
+	}
+	job.DedupeKey = proposal.DedupeKey
+	job.Parameters = CloneConfigValueMap(proposal.Parameters)
+	if proposal.Labels != nil {
+		job.Labels = make(map[string]string, len(proposal.Labels))
+		for k, v := range proposal.Labels {
+			job.Labels[k] = v
+		}
+	}
+	if proposal.NotBefore != nil {
+		job.ScheduledAt = proposal.NotBefore
+	}
+
+	return job
+}
+
+func durationFromSeconds(seconds int32, defaultValue time.Duration) time.Duration {
+	if seconds <= 0 {
+		return defaultValue
+	}
+	return time.Duration(seconds) * time.Second
+}
+
+func secondsFromDuration(duration time.Duration) int32 {
+	if duration <= 0 {
+		return 0
+	}
+	return int32(duration / time.Second)
+}
+
+func waitForShutdownOrTimer(shutdown <-chan struct{}, duration time.Duration) bool {
+	if duration <= 0 {
+		return true
+	}
+
+	timer := time.NewTimer(duration)
+	defer timer.Stop()
+
+	select {
+	case <-shutdown:
+		return false
+	case <-timer.C:
+		return true
+	}
+}
+
+func (r *Plugin) filterProposalsWithActiveJobs(jobType string, proposals []*plugin_pb.JobProposal) ([]*plugin_pb.JobProposal, int) {
+	if len(proposals) == 0 {
+		return proposals, 0
+	}
+
+	activeKeys := make(map[string]struct{})
+	r.jobsMu.RLock()
+	for _, job := range r.jobs {
+		if job == nil {
+			continue
+		}
+		if strings.TrimSpace(job.JobType) != strings.TrimSpace(jobType) {
+			continue
+		}
+		if !isActiveTrackedJobState(job.State) {
+			continue
+		}
+
+		key := strings.TrimSpace(job.DedupeKey)
+		if key == "" {
+			key = strings.TrimSpace(job.JobID)
+		}
+		if key == "" {
+			continue
+		}
+		activeKeys[key] = struct{}{}
+	}
+	r.jobsMu.RUnlock()
+
+	if len(activeKeys) == 0 {
+		return proposals, 0
+	}
+
+	filtered := make([]*plugin_pb.JobProposal, 0, len(proposals))
+	skipped := 0
+	for _, proposal := range proposals {
+		if proposal == nil {
+			continue
+		}
+		key := proposalExecutionKey(proposal)
+		if key != "" {
+			if _, exists := activeKeys[key]; exists {
+				skipped++
+				continue
+			}
+		}
+		filtered = append(filtered, proposal)
+	}
+
+	return filtered, skipped
+}
+
+func proposalExecutionKey(proposal *plugin_pb.JobProposal) string {
+	if proposal == nil {
+		return ""
+	}
+	key := strings.TrimSpace(proposal.DedupeKey)
+	if key != "" {
+		return key
+	}
+	return strings.TrimSpace(proposal.ProposalId)
+}
+
+func isActiveTrackedJobState(state string) bool {
+	normalized := strings.ToLower(strings.TrimSpace(state))
+	switch normalized {
+	case "pending", "assigned", "running", "in_progress", "job_state_pending", "job_state_assigned", "job_state_running":
+		return true
+	default:
+		return false
+	}
+}
+
+func isWaitingTrackedJobState(state string) bool {
+	normalized := strings.ToLower(strings.TrimSpace(state))
+	return normalized == "pending" || normalized == "job_state_pending"
+}
+
+func (r *Plugin) filterScheduledProposals(proposals []*plugin_pb.JobProposal) []*plugin_pb.JobProposal {
+	filtered := make([]*plugin_pb.JobProposal, 0, len(proposals))
+	seenInRun := make(map[string]struct{}, len(proposals))
+
+	for _, proposal := range proposals {
+		if proposal == nil {
+			continue
+		}
+
+		key := proposal.DedupeKey
+		if key == "" {
+			key = proposal.ProposalId
+		}
+		if key == "" {
+			filtered = append(filtered, proposal)
+			continue
+		}
+
+		if _, exists := seenInRun[key]; exists {
+			continue
+		}
+
+		seenInRun[key] = struct{}{}
+		filtered = append(filtered, proposal)
+	}
+
+	return filtered
+}

weed/admin/plugin/plugin_scheduler_test.go

@@ -0,0 +1,583 @@
+package plugin
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+func TestLoadSchedulerPolicyUsesAdminConfig(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	err = pluginSvc.SaveJobTypeConfig(&plugin_pb.PersistedJobTypeConfig{
+		JobType: "vacuum",
+		AdminRuntime: &plugin_pb.AdminRuntimeConfig{
+			Enabled:                       true,
+			DetectionIntervalSeconds:      30,
+			DetectionTimeoutSeconds:       20,
+			MaxJobsPerDetection:           123,
+			GlobalExecutionConcurrency:    5,
+			PerWorkerExecutionConcurrency: 2,
+			RetryLimit:                    4,
+			RetryBackoffSeconds:           7,
+		},
+	})
+	if err != nil {
+		t.Fatalf("SaveJobTypeConfig: %v", err)
+	}
+
+	policy, enabled, err := pluginSvc.loadSchedulerPolicy("vacuum")
+	if err != nil {
+		t.Fatalf("loadSchedulerPolicy: %v", err)
+	}
+	if !enabled {
+		t.Fatalf("expected enabled policy")
+	}
+	if policy.MaxResults != 123 {
+		t.Fatalf("unexpected max results: got=%d", policy.MaxResults)
+	}
+	if policy.ExecutionConcurrency != 5 {
+		t.Fatalf("unexpected global concurrency: got=%d", policy.ExecutionConcurrency)
+	}
+	if policy.PerWorkerConcurrency != 2 {
+		t.Fatalf("unexpected per-worker concurrency: got=%d", policy.PerWorkerConcurrency)
+	}
+	if policy.RetryLimit != 4 {
+		t.Fatalf("unexpected retry limit: got=%d", policy.RetryLimit)
+	}
+}
+
+func TestLoadSchedulerPolicyUsesDescriptorDefaultsWhenConfigMissing(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	err = pluginSvc.store.SaveDescriptor("ec", &plugin_pb.JobTypeDescriptor{
+		JobType: "ec",
+		AdminRuntimeDefaults: &plugin_pb.AdminRuntimeDefaults{
+			Enabled:                       true,
+			DetectionIntervalSeconds:      60,
+			DetectionTimeoutSeconds:       25,
+			MaxJobsPerDetection:           30,
+			GlobalExecutionConcurrency:    4,
+			PerWorkerExecutionConcurrency: 2,
+			RetryLimit:                    3,
+			RetryBackoffSeconds:           6,
+		},
+	})
+	if err != nil {
+		t.Fatalf("SaveDescriptor: %v", err)
+	}
+
+	policy, enabled, err := pluginSvc.loadSchedulerPolicy("ec")
+	if err != nil {
+		t.Fatalf("loadSchedulerPolicy: %v", err)
+	}
+	if !enabled {
+		t.Fatalf("expected enabled policy from descriptor defaults")
+	}
+	if policy.MaxResults != 30 {
+		t.Fatalf("unexpected max results: got=%d", policy.MaxResults)
+	}
+	if policy.ExecutionConcurrency != 4 {
+		t.Fatalf("unexpected global concurrency: got=%d", policy.ExecutionConcurrency)
+	}
+	if policy.PerWorkerConcurrency != 2 {
+		t.Fatalf("unexpected per-worker concurrency: got=%d", policy.PerWorkerConcurrency)
+	}
+}
+
+func TestReserveScheduledExecutorRespectsPerWorkerLimit(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 4},
+		},
+	})
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 2},
+		},
+	})
+
+	policy := schedulerPolicy{
+		PerWorkerConcurrency:   1,
+		ExecutorReserveBackoff: time.Millisecond,
+	}
+
+	executor1, release1, err := pluginSvc.reserveScheduledExecutor("balance", policy)
+	if err != nil {
+		t.Fatalf("reserve executor 1: %v", err)
+	}
+	defer release1()
+
+	executor2, release2, err := pluginSvc.reserveScheduledExecutor("balance", policy)
+	if err != nil {
+		t.Fatalf("reserve executor 2: %v", err)
+	}
+	defer release2()
+
+	if executor1.WorkerID == executor2.WorkerID {
+		t.Fatalf("expected different executors due per-worker limit, got same worker %s", executor1.WorkerID)
+	}
+}
+
+func TestFilterScheduledProposalsDedupe(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	proposals := []*plugin_pb.JobProposal{
+		{ProposalId: "p1", DedupeKey: "d1"},
+		{ProposalId: "p2", DedupeKey: "d1"}, // same dedupe key
+		{ProposalId: "p3", DedupeKey: "d3"},
+		{ProposalId: "p3"}, // fallback dedupe by proposal id
+		{ProposalId: "p4"},
+		{ProposalId: "p4"}, // same proposal id, no dedupe key
+	}
+
+	filtered := pluginSvc.filterScheduledProposals(proposals)
+	if len(filtered) != 4 {
+		t.Fatalf("unexpected filtered size: got=%d want=4", len(filtered))
+	}
+
+	filtered2 := pluginSvc.filterScheduledProposals(proposals)
+	if len(filtered2) != 4 {
+		t.Fatalf("expected second run dedupe to be per-run only, got=%d", len(filtered2))
+	}
+}
+
+func TestBuildScheduledJobSpecDoesNotReuseProposalID(t *testing.T) {
+	t.Parallel()
+
+	proposal := &plugin_pb.JobProposal{
+		ProposalId: "vacuum-2",
+		DedupeKey:  "vacuum:2",
+		JobType:    "vacuum",
+	}
+
+	jobA := buildScheduledJobSpec("vacuum", proposal, 0)
+	jobB := buildScheduledJobSpec("vacuum", proposal, 1)
+
+	if jobA.JobId == proposal.ProposalId {
+		t.Fatalf("scheduled job id must not reuse proposal id: %s", jobA.JobId)
+	}
+	if jobB.JobId == proposal.ProposalId {
+		t.Fatalf("scheduled job id must not reuse proposal id: %s", jobB.JobId)
+	}
+	if jobA.JobId == jobB.JobId {
+		t.Fatalf("scheduled job ids must be unique across jobs: %s", jobA.JobId)
+	}
+}
+
+func TestFilterProposalsWithActiveJobs(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.trackExecutionStart("req-1", "worker-a", &plugin_pb.JobSpec{
+		JobId:     "job-1",
+		JobType:   "vacuum",
+		DedupeKey: "vacuum:k1",
+	}, 1)
+	pluginSvc.trackExecutionStart("req-2", "worker-b", &plugin_pb.JobSpec{
+		JobId:   "job-2",
+		JobType: "vacuum",
+	}, 1)
+	pluginSvc.trackExecutionQueued(&plugin_pb.JobSpec{
+		JobId:     "job-3",
+		JobType:   "vacuum",
+		DedupeKey: "vacuum:k4",
+	})
+
+	filtered, skipped := pluginSvc.filterProposalsWithActiveJobs("vacuum", []*plugin_pb.JobProposal{
+		{ProposalId: "proposal-1", JobType: "vacuum", DedupeKey: "vacuum:k1"},
+		{ProposalId: "job-2", JobType: "vacuum"},
+		{ProposalId: "proposal-2b", JobType: "vacuum", DedupeKey: "vacuum:k4"},
+		{ProposalId: "proposal-3", JobType: "vacuum", DedupeKey: "vacuum:k3"},
+		{ProposalId: "proposal-4", JobType: "balance", DedupeKey: "balance:k1"},
+	})
+	if skipped != 3 {
+		t.Fatalf("unexpected skipped count: got=%d want=3", skipped)
+	}
+	if len(filtered) != 2 {
+		t.Fatalf("unexpected filtered size: got=%d want=2", len(filtered))
+	}
+	if filtered[0].ProposalId != "proposal-3" || filtered[1].ProposalId != "proposal-4" {
+		t.Fatalf("unexpected filtered proposals: got=%s,%s", filtered[0].ProposalId, filtered[1].ProposalId)
+	}
+}
+
+func TestReserveScheduledExecutorTimesOutWhenNoExecutor(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	policy := schedulerPolicy{
+		ExecutionTimeout:       30 * time.Millisecond,
+		ExecutorReserveBackoff: 5 * time.Millisecond,
+		PerWorkerConcurrency:   1,
+	}
+
+	start := time.Now()
+	pluginSvc.Shutdown()
+	_, _, err = pluginSvc.reserveScheduledExecutor("missing-job-type", policy)
+	if err == nil {
+		t.Fatalf("expected reservation shutdown error")
+	}
+	if time.Since(start) > 50*time.Millisecond {
+		t.Fatalf("reservation returned too late after shutdown: duration=%v", time.Since(start))
+	}
+}
+
+func TestReserveScheduledExecutorWaitsForWorkerCapacity(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 1},
+		},
+	})
+
+	policy := schedulerPolicy{
+		ExecutionTimeout:       time.Second,
+		PerWorkerConcurrency:   8,
+		ExecutorReserveBackoff: 5 * time.Millisecond,
+	}
+
+	_, release1, err := pluginSvc.reserveScheduledExecutor("balance", policy)
+	if err != nil {
+		t.Fatalf("reserve executor 1: %v", err)
+	}
+	defer release1()
+
+	type reserveResult struct {
+		err error
+	}
+	secondReserveCh := make(chan reserveResult, 1)
+	go func() {
+		_, release2, reserveErr := pluginSvc.reserveScheduledExecutor("balance", policy)
+		if release2 != nil {
+			release2()
+		}
+		secondReserveCh <- reserveResult{err: reserveErr}
+	}()
+
+	select {
+	case result := <-secondReserveCh:
+		t.Fatalf("expected second reservation to wait for capacity, got=%v", result.err)
+	case <-time.After(25 * time.Millisecond):
+		// Expected: still waiting.
+	}
+
+	release1()
+
+	select {
+	case result := <-secondReserveCh:
+		if result.err != nil {
+			t.Fatalf("second reservation error: %v", result.err)
+		}
+	case <-time.After(200 * time.Millisecond):
+		t.Fatalf("second reservation did not acquire after capacity release")
+	}
+}
+
+func TestShouldSkipDetectionForWaitingJobs(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	policy := schedulerPolicy{
+		ExecutionConcurrency: 2,
+		MaxResults:           100,
+	}
+	threshold := waitingBacklogThreshold(policy)
+	if threshold <= 0 {
+		t.Fatalf("expected positive waiting threshold")
+	}
+
+	for i := 0; i < threshold; i++ {
+		pluginSvc.trackExecutionQueued(&plugin_pb.JobSpec{
+			JobId:     fmt.Sprintf("job-waiting-%d", i),
+			JobType:   "vacuum",
+			DedupeKey: fmt.Sprintf("vacuum:%d", i),
+		})
+	}
+
+	skip, waitingCount, waitingThreshold := pluginSvc.shouldSkipDetectionForWaitingJobs("vacuum", policy)
+	if !skip {
+		t.Fatalf("expected detection to skip when waiting backlog reaches threshold")
+	}
+	if waitingCount != threshold {
+		t.Fatalf("unexpected waiting count: got=%d want=%d", waitingCount, threshold)
+	}
+	if waitingThreshold != threshold {
+		t.Fatalf("unexpected waiting threshold: got=%d want=%d", waitingThreshold, threshold)
+	}
+}
+
+func TestWaitingBacklogThresholdHonorsMaxResultsCap(t *testing.T) {
+	t.Parallel()
+
+	policy := schedulerPolicy{
+		ExecutionConcurrency: 8,
+		MaxResults:           6,
+	}
+	threshold := waitingBacklogThreshold(policy)
+	if threshold != 6 {
+		t.Fatalf("expected threshold to be capped by max results, got=%d", threshold)
+	}
+}
+
+func TestListSchedulerStatesIncludesPolicyAndState(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	const jobType = "vacuum"
+	err = pluginSvc.SaveJobTypeConfig(&plugin_pb.PersistedJobTypeConfig{
+		JobType: jobType,
+		AdminRuntime: &plugin_pb.AdminRuntimeConfig{
+			Enabled:                       true,
+			DetectionIntervalSeconds:      45,
+			DetectionTimeoutSeconds:       30,
+			MaxJobsPerDetection:           80,
+			GlobalExecutionConcurrency:    3,
+			PerWorkerExecutionConcurrency: 2,
+			RetryLimit:                    1,
+			RetryBackoffSeconds:           9,
+		},
+	})
+	if err != nil {
+		t.Fatalf("SaveJobTypeConfig: %v", err)
+	}
+
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: jobType, CanDetect: true, CanExecute: true},
+		},
+	})
+
+	nextDetectionAt := time.Now().UTC().Add(2 * time.Minute).Round(time.Second)
+	pluginSvc.schedulerMu.Lock()
+	pluginSvc.nextDetectionAt[jobType] = nextDetectionAt
+	pluginSvc.detectionInFlight[jobType] = true
+	pluginSvc.schedulerMu.Unlock()
+
+	states, err := pluginSvc.ListSchedulerStates()
+	if err != nil {
+		t.Fatalf("ListSchedulerStates: %v", err)
+	}
+
+	state := findSchedulerState(states, jobType)
+	if state == nil {
+		t.Fatalf("missing scheduler state for %s", jobType)
+	}
+	if !state.Enabled {
+		t.Fatalf("expected enabled scheduler state")
+	}
+	if state.PolicyError != "" {
+		t.Fatalf("unexpected policy error: %s", state.PolicyError)
+	}
+	if !state.DetectionInFlight {
+		t.Fatalf("expected detection in flight")
+	}
+	if state.NextDetectionAt == nil {
+		t.Fatalf("expected next detection time")
+	}
+	if state.NextDetectionAt.Unix() != nextDetectionAt.Unix() {
+		t.Fatalf("unexpected next detection time: got=%v want=%v", state.NextDetectionAt, nextDetectionAt)
+	}
+	if state.DetectionIntervalSeconds != 45 {
+		t.Fatalf("unexpected detection interval: got=%d", state.DetectionIntervalSeconds)
+	}
+	if state.DetectionTimeoutSeconds != 30 {
+		t.Fatalf("unexpected detection timeout: got=%d", state.DetectionTimeoutSeconds)
+	}
+	if state.ExecutionTimeoutSeconds != 90 {
+		t.Fatalf("unexpected execution timeout: got=%d", state.ExecutionTimeoutSeconds)
+	}
+	if state.MaxJobsPerDetection != 80 {
+		t.Fatalf("unexpected max jobs per detection: got=%d", state.MaxJobsPerDetection)
+	}
+	if state.GlobalExecutionConcurrency != 3 {
+		t.Fatalf("unexpected global execution concurrency: got=%d", state.GlobalExecutionConcurrency)
+	}
+	if state.PerWorkerExecutionConcurrency != 2 {
+		t.Fatalf("unexpected per worker execution concurrency: got=%d", state.PerWorkerExecutionConcurrency)
+	}
+	if state.RetryLimit != 1 {
+		t.Fatalf("unexpected retry limit: got=%d", state.RetryLimit)
+	}
+	if state.RetryBackoffSeconds != 9 {
+		t.Fatalf("unexpected retry backoff: got=%d", state.RetryBackoffSeconds)
+	}
+	if !state.DetectorAvailable || state.DetectorWorkerID != "worker-a" {
+		t.Fatalf("unexpected detector assignment: available=%v worker=%s", state.DetectorAvailable, state.DetectorWorkerID)
+	}
+	if state.ExecutorWorkerCount != 1 {
+		t.Fatalf("unexpected executor worker count: got=%d", state.ExecutorWorkerCount)
+	}
+}
+
+func TestListSchedulerStatesShowsDisabledWhenNoPolicy(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	const jobType = "balance"
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: jobType, CanDetect: true, CanExecute: true},
+		},
+	})
+
+	states, err := pluginSvc.ListSchedulerStates()
+	if err != nil {
+		t.Fatalf("ListSchedulerStates: %v", err)
+	}
+
+	state := findSchedulerState(states, jobType)
+	if state == nil {
+		t.Fatalf("missing scheduler state for %s", jobType)
+	}
+	if state.Enabled {
+		t.Fatalf("expected disabled scheduler state")
+	}
+	if state.PolicyError != "" {
+		t.Fatalf("unexpected policy error: %s", state.PolicyError)
+	}
+	if !state.DetectorAvailable || state.DetectorWorkerID != "worker-b" {
+		t.Fatalf("unexpected detector details: available=%v worker=%s", state.DetectorAvailable, state.DetectorWorkerID)
+	}
+	if state.ExecutorWorkerCount != 1 {
+		t.Fatalf("unexpected executor worker count: got=%d", state.ExecutorWorkerCount)
+	}
+}
+
+func findSchedulerState(states []SchedulerJobTypeState, jobType string) *SchedulerJobTypeState {
+	for i := range states {
+		if states[i].JobType == jobType {
+			return &states[i]
+		}
+	}
+	return nil
+}
+
+func TestPickDetectorPrefersLeasedWorker(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true},
+		},
+	})
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true},
+		},
+	})
+
+	pluginSvc.setDetectorLease("vacuum", "worker-b")
+
+	detector, err := pluginSvc.pickDetector("vacuum")
+	if err != nil {
+		t.Fatalf("pickDetector: %v", err)
+	}
+	if detector.WorkerID != "worker-b" {
+		t.Fatalf("expected leased detector worker-b, got=%s", detector.WorkerID)
+	}
+}
+
+func TestPickDetectorReassignsWhenLeaseIsStale(t *testing.T) {
+	t.Parallel()
+
+	pluginSvc, err := New(Options{})
+	if err != nil {
+		t.Fatalf("New: %v", err)
+	}
+	defer pluginSvc.Shutdown()
+
+	pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true},
+		},
+	})
+	pluginSvc.setDetectorLease("vacuum", "worker-stale")
+
+	detector, err := pluginSvc.pickDetector("vacuum")
+	if err != nil {
+		t.Fatalf("pickDetector: %v", err)
+	}
+	if detector.WorkerID != "worker-a" {
+		t.Fatalf("expected reassigned detector worker-a, got=%s", detector.WorkerID)
+	}
+
+	lease := pluginSvc.getDetectorLease("vacuum")
+	if lease != "worker-a" {
+		t.Fatalf("expected detector lease to be updated to worker-a, got=%s", lease)
+	}
+}

weed/admin/plugin/plugin_schema_prefetch.go

@@ -0,0 +1,66 @@
+package plugin
+
+import (
+	"context"
+	"sort"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+const descriptorPrefetchTimeout = 20 * time.Second
+
+func (r *Plugin) prefetchDescriptorsFromHello(hello *plugin_pb.WorkerHello) {
+	if hello == nil || len(hello.Capabilities) == 0 {
+		return
+	}
+
+	jobTypeSet := make(map[string]struct{})
+	for _, capability := range hello.Capabilities {
+		if capability == nil || capability.JobType == "" {
+			continue
+		}
+		if !capability.CanDetect && !capability.CanExecute {
+			continue
+		}
+		jobTypeSet[capability.JobType] = struct{}{}
+	}
+
+	if len(jobTypeSet) == 0 {
+		return
+	}
+
+	jobTypes := make([]string, 0, len(jobTypeSet))
+	for jobType := range jobTypeSet {
+		jobTypes = append(jobTypes, jobType)
+	}
+	sort.Strings(jobTypes)
+
+	for _, jobType := range jobTypes {
+		select {
+		case <-r.shutdownCh:
+			return
+		default:
+		}
+
+		descriptor, err := r.store.LoadDescriptor(jobType)
+		if err != nil {
+			glog.Warningf("Plugin descriptor prefetch check failed for %s: %v", jobType, err)
+			continue
+		}
+		if descriptor != nil {
+			continue
+		}
+
+		ctx, cancel := context.WithTimeout(r.ctx, descriptorPrefetchTimeout)
+		_, err = r.RequestConfigSchema(ctx, jobType, false)
+		cancel()
+		if err != nil {
+			glog.V(1).Infof("Plugin descriptor prefetch skipped for %s: %v", jobType, err)
+			continue
+		}
+
+		glog.V(1).Infof("Plugin descriptor prefetched for job_type=%s", jobType)
+	}
+}

weed/admin/plugin/registry.go

@@ -2,310 +2,464 @@ package plugin
 
 import (
 	"fmt"
+	"sort"
+	"strings"
 	"sync"
 	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
 )
 
-// Registry manages plugin registration and lifecycle
+const defaultWorkerStaleTimeout = 2 * time.Minute
+
+// WorkerSession contains tracked worker metadata and plugin status.
+type WorkerSession struct {
+	WorkerID        string
+	WorkerInstance  string
+	Address         string
+	WorkerVersion   string
+	ProtocolVersion string
+	ConnectedAt     time.Time
+	LastSeenAt      time.Time
+	Capabilities    map[string]*plugin_pb.JobTypeCapability
+	Heartbeat       *plugin_pb.WorkerHeartbeat
+}
+
+// Registry tracks connected plugin workers and capability-based selection.
 type Registry struct {
-	mu                     sync.RWMutex
-	plugins                map[string]*ConnectedPlugin
-	capabilityIndex        map[string][]string // Maps capability to plugin IDs
-	healthCheckTimeout     time.Duration
-	failureDetectionWindow time.Duration
-	failureThreshold       int
-	pluginFailureCount     map[string]int
+	mu             sync.RWMutex
+	sessions       map[string]*WorkerSession
+	staleAfter     time.Duration
+	detectorCursor map[string]int
+	executorCursor map[string]int
 }
 
-// NewRegistry creates a new plugin registry
-func NewRegistry(healthCheckTimeout, failureDetectionWindow time.Duration, failureThreshold int) *Registry {
+func NewRegistry() *Registry {
 	return &Registry{
-		plugins:                make(map[string]*ConnectedPlugin),
-		capabilityIndex:        make(map[string][]string),
-		healthCheckTimeout:     healthCheckTimeout,
-		failureDetectionWindow: failureDetectionWindow,
-		failureThreshold:       failureThreshold,
-		pluginFailureCount:     make(map[string]int),
+		sessions:       make(map[string]*WorkerSession),
+		staleAfter:     defaultWorkerStaleTimeout,
+		detectorCursor: make(map[string]int),
+		executorCursor: make(map[string]int),
 	}
 }
 
-// RegisterPlugin adds a plugin to the registry
-func (r *Registry) RegisterPlugin(plugin *ConnectedPlugin) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	if _, exists := r.plugins[plugin.ID]; exists {
-		return fmt.Errorf("plugin %s already registered", plugin.ID)
-	}
-
-	r.plugins[plugin.ID] = plugin
-	r.pluginFailureCount[plugin.ID] = 0
-
-	// Build capability index
-	for _, cap := range plugin.Capabilities {
-		r.capabilityIndex[cap] = append(r.capabilityIndex[cap], plugin.ID)
-	}
-
-	return nil
-}
-
-// UnregisterPlugin removes a plugin from the registry
-func (r *Registry) UnregisterPlugin(pluginID string) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	plugin, exists := r.plugins[pluginID]
-	if !exists {
-		return fmt.Errorf("plugin %s not found", pluginID)
-	}
-
-	// Remove from capability index
-	for _, cap := range plugin.Capabilities {
-		for i, id := range r.capabilityIndex[cap] {
-			if id == pluginID {
-				r.capabilityIndex[cap] = append(r.capabilityIndex[cap][:i], r.capabilityIndex[cap][i+1:]...)
-				break
-			}
-		}
-	}
-
-	delete(r.plugins, pluginID)
-	delete(r.pluginFailureCount, pluginID)
-
-	return nil
-}
-
-// GetPlugin retrieves a plugin by ID
-func (r *Registry) GetPlugin(pluginID string) (*ConnectedPlugin, error) {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	plugin, exists := r.plugins[pluginID]
-	if !exists {
-		return nil, fmt.Errorf("plugin %s not found", pluginID)
-	}
-
-	return plugin, nil
-}
-
-// GetPluginsByCapability returns all plugins with a specific capability
-func (r *Registry) GetPluginsByCapability(capability string) []*ConnectedPlugin {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	pluginIDs, exists := r.capabilityIndex[capability]
-	if !exists {
-		return []*ConnectedPlugin{}
-	}
-
-	var result []*ConnectedPlugin
-	for _, id := range pluginIDs {
-		if plugin, ok := r.plugins[id]; ok {
-			result = append(result, plugin)
-		}
-	}
-
-	return result
-}
-
-// ListPlugins returns all registered plugins
-func (r *Registry) ListPlugins(includeUnhealthy bool) []*ConnectedPlugin {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	var result []*ConnectedPlugin
-
-	for _, plugin := range r.plugins {
-		if !includeUnhealthy && time.Since(plugin.LastHeartbeat) > r.healthCheckTimeout {
+func (r *Registry) UpsertFromHello(hello *plugin_pb.WorkerHello) *WorkerSession {
+	now := time.Now()
+	caps := make(map[string]*plugin_pb.JobTypeCapability, len(hello.Capabilities))
+	for _, c := range hello.Capabilities {
+		if c == nil || c.JobType == "" {
 			continue
 		}
-		result = append(result, plugin)
+		caps[c.JobType] = cloneJobTypeCapability(c)
 	}
 
-	return result
-}
-
-// HealthCheck verifies plugin health based on heartbeat status
-func (r *Registry) HealthCheck(pluginID string) (bool, error) {
-	r.mu.RLock()
-	plugin, exists := r.plugins[pluginID]
-	r.mu.RUnlock()
-
-	if !exists {
-		return false, fmt.Errorf("plugin %s not found", pluginID)
-	}
-
-	isHealthy := plugin.IsHealthy(r.healthCheckTimeout)
-
-	if !isHealthy {
-		r.mu.Lock()
-		r.pluginFailureCount[pluginID]++
-		r.mu.Unlock()
-	} else {
-		r.mu.Lock()
-		r.pluginFailureCount[pluginID] = 0
-		r.mu.Unlock()
-	}
-
-	return isHealthy, nil
-}
-
-// GetFailureCount returns the current failure count for a plugin
-func (r *Registry) GetFailureCount(pluginID string) int {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	return r.pluginFailureCount[pluginID]
-}
-
-// HasExceededFailureThreshold checks if a plugin has exceeded the failure threshold
-func (r *Registry) HasExceededFailureThreshold(pluginID string) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	return r.pluginFailureCount[pluginID] > r.failureThreshold
-}
-
-// ResetFailureCount resets the failure counter for a plugin
-func (r *Registry) ResetFailureCount(pluginID string) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.pluginFailureCount[pluginID] = 0
-}
-
-// Count returns the total number of registered plugins
-func (r *Registry) Count() int {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	return len(r.plugins)
-}
-
-// CountHealthy returns the number of healthy plugins
-func (r *Registry) CountHealthy() int {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	count := 0
-	for _, plugin := range r.plugins {
-		if plugin.IsHealthy(r.healthCheckTimeout) {
-			count++
-		}
-	}
-	return count
-}
-
-// GetCapabilities returns all registered capabilities
-func (r *Registry) GetCapabilities() []string {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	var capabilities []string
-	for cap := range r.capabilityIndex {
-		capabilities = append(capabilities, cap)
-	}
-	return capabilities
-}
-
-// UpdateHeartbeat updates the heartbeat timestamp for a plugin
-func (r *Registry) UpdateHeartbeat(pluginID string) error {
-	r.mu.RLock()
-	plugin, exists := r.plugins[pluginID]
-	r.mu.RUnlock()
-
-	if !exists {
-		return fmt.Errorf("plugin %s not found", pluginID)
-	}
-
-	plugin.UpdateHeartbeat()
-	r.ResetFailureCount(pluginID)
-	return nil
-}
-
-// GetUnhealthyPlugins returns plugins that have failed health checks
-func (r *Registry) GetUnhealthyPlugins() []*ConnectedPlugin {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	var unhealthy []*ConnectedPlugin
-	for _, plugin := range r.plugins {
-		if !plugin.IsHealthy(r.healthCheckTimeout) {
-			unhealthy = append(unhealthy, plugin)
-		}
-	}
-	return unhealthy
-}
-
-// RemoveUnhealthyPlugins removes plugins that have exceeded the failure threshold
-func (r *Registry) RemoveUnhealthyPlugins() []string {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	var removed []string
-	for pluginID, failureCount := range r.pluginFailureCount {
-		if failureCount > r.failureThreshold {
-			if plugin, exists := r.plugins[pluginID]; exists {
-				// Remove from capability index
-				for _, cap := range plugin.Capabilities {
-					for i, id := range r.capabilityIndex[cap] {
-						if id == pluginID {
-							r.capabilityIndex[cap] = append(r.capabilityIndex[cap][:i], r.capabilityIndex[cap][i+1:]...)
-							break
-						}
-					}
-				}
-				delete(r.plugins, pluginID)
-				delete(r.pluginFailureCount, pluginID)
-				removed = append(removed, pluginID)
+	session, ok := r.sessions[hello.WorkerId]
+	if !ok {
+		session = &WorkerSession{
+			WorkerID:    hello.WorkerId,
+			ConnectedAt: now,
+		}
+		r.sessions[hello.WorkerId] = session
+	}
+
+	session.WorkerInstance = hello.WorkerInstanceId
+	session.Address = hello.Address
+	session.WorkerVersion = hello.WorkerVersion
+	session.ProtocolVersion = hello.ProtocolVersion
+	session.LastSeenAt = now
+	session.Capabilities = caps
+
+	return cloneWorkerSession(session)
+}
+
+func (r *Registry) Remove(workerID string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	delete(r.sessions, workerID)
+}
+
+func (r *Registry) UpdateHeartbeat(workerID string, heartbeat *plugin_pb.WorkerHeartbeat) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	session, ok := r.sessions[workerID]
+	if !ok {
+		return
+	}
+	session.Heartbeat = cloneWorkerHeartbeat(heartbeat)
+	session.LastSeenAt = time.Now()
+}
+
+func (r *Registry) Get(workerID string) (*WorkerSession, bool) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	session, ok := r.sessions[workerID]
+	if !ok || r.isSessionStaleLocked(session, time.Now()) {
+		return nil, false
+	}
+	return cloneWorkerSession(session), true
+}
+
+func (r *Registry) List() []*WorkerSession {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	out := make([]*WorkerSession, 0, len(r.sessions))
+	now := time.Now()
+	for _, s := range r.sessions {
+		if r.isSessionStaleLocked(s, now) {
+			continue
+		}
+		out = append(out, cloneWorkerSession(s))
+	}
+	sort.Slice(out, func(i, j int) bool {
+		return out[i].WorkerID < out[j].WorkerID
+	})
+	return out
+}
+
+// DetectableJobTypes returns sorted job types that currently have at least one detect-capable worker.
+func (r *Registry) DetectableJobTypes() []string {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	jobTypes := make(map[string]struct{})
+	now := time.Now()
+	for _, session := range r.sessions {
+		if r.isSessionStaleLocked(session, now) {
+			continue
+		}
+		for jobType, capability := range session.Capabilities {
+			if capability == nil || !capability.CanDetect {
+				continue
 			}
+			jobTypes[jobType] = struct{}{}
 		}
 	}
-	return removed
-}
 
-// UpdatePluginStatus updates the status field of a plugin
-func (r *Registry) UpdatePluginStatus(pluginID, status string) error {
-	r.mu.RLock()
-	plugin, exists := r.plugins[pluginID]
-	r.mu.RUnlock()
-
-	if !exists {
-		return fmt.Errorf("plugin %s not found", pluginID)
+	out := make([]string, 0, len(jobTypes))
+	for jobType := range jobTypes {
+		out = append(out, jobType)
 	}
-
-	plugin.mu.Lock()
-	plugin.Status = status
-	plugin.mu.Unlock()
-
-	return nil
+	sort.Strings(out)
+	return out
 }
 
-// GetStats returns statistics for all plugins
-func (r *Registry) GetStats() map[string]interface{} {
+// JobTypes returns sorted job types known by connected workers regardless of capability kind.
+func (r *Registry) JobTypes() []string {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 
-	totalPlugins := len(r.plugins)
-	healthyPlugins := 0
-	totalActiveJobs := 0
-	totalCompletedJobs := 0
-	totalFailedJobs := 0
-
-	for _, plugin := range r.plugins {
-		if plugin.IsHealthy(r.healthCheckTimeout) {
-			healthyPlugins++
+	jobTypes := make(map[string]struct{})
+	now := time.Now()
+	for _, session := range r.sessions {
+		if r.isSessionStaleLocked(session, now) {
+			continue
+		}
+		for jobType := range session.Capabilities {
+			if jobType == "" {
+				continue
+			}
+			jobTypes[jobType] = struct{}{}
 		}
-		plugin.mu.RLock()
-		totalActiveJobs += plugin.ActiveJobs
-		totalCompletedJobs += plugin.CompletedJobs
-		totalFailedJobs += plugin.FailedJobs
-		plugin.mu.RUnlock()
 	}
 
-	return map[string]interface{}{
-		"total_plugins":     totalPlugins,
-		"healthy_plugins":   healthyPlugins,
-		"unhealthy_plugins": totalPlugins - healthyPlugins,
-		"total_active_jobs": totalActiveJobs,
-		"total_completed":   totalCompletedJobs,
-		"total_failed":      totalFailedJobs,
-		"capabilities":      len(r.capabilityIndex),
+	out := make([]string, 0, len(jobTypes))
+	for jobType := range jobTypes {
+		out = append(out, jobType)
+	}
+	sort.Strings(out)
+	return out
+}
+
+// PickSchemaProvider picks one worker for schema requests.
+// Preference order:
+// 1) workers that can detect this job type
+// 2) workers that can execute this job type
+// tie-break: more free slots, then lexical worker ID.
+func (r *Registry) PickSchemaProvider(jobType string) (*WorkerSession, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	var candidates []*WorkerSession
+	now := time.Now()
+	for _, s := range r.sessions {
+		if r.isSessionStaleLocked(s, now) {
+			continue
+		}
+		capability := s.Capabilities[jobType]
+		if capability == nil {
+			continue
+		}
+		if capability.CanDetect || capability.CanExecute {
+			candidates = append(candidates, s)
+		}
+	}
+
+	if len(candidates) == 0 {
+		return nil, fmt.Errorf("no worker available for schema job_type=%s", jobType)
+	}
+
+	sort.Slice(candidates, func(i, j int) bool {
+		a := candidates[i]
+		b := candidates[j]
+		ac := a.Capabilities[jobType]
+		bc := b.Capabilities[jobType]
+
+		// Prefer detect-capable providers first.
+		if ac.CanDetect != bc.CanDetect {
+			return ac.CanDetect
+		}
+
+		aSlots := availableDetectionSlots(a, ac) + availableExecutionSlots(a, ac)
+		bSlots := availableDetectionSlots(b, bc) + availableExecutionSlots(b, bc)
+		if aSlots != bSlots {
+			return aSlots > bSlots
+		}
+		return a.WorkerID < b.WorkerID
+	})
+
+	return cloneWorkerSession(candidates[0]), nil
+}
+
+// PickDetector picks one detector worker for a job type.
+func (r *Registry) PickDetector(jobType string) (*WorkerSession, error) {
+	return r.pickByKind(jobType, true)
+}
+
+// PickExecutor picks one executor worker for a job type.
+func (r *Registry) PickExecutor(jobType string) (*WorkerSession, error) {
+	return r.pickByKind(jobType, false)
+}
+
+// ListExecutors returns sorted executor candidates for one job type.
+// Ordering is by most available execution slots, then lexical worker ID.
+// The top tie group is rotated round-robin to prevent sticky assignment.
+func (r *Registry) ListExecutors(jobType string) ([]*WorkerSession, error) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	candidates := r.collectByKindLocked(jobType, false, time.Now())
+	if len(candidates) == 0 {
+		return nil, fmt.Errorf("no executor worker available for job_type=%s", jobType)
+	}
+
+	sortByKind(candidates, jobType, false)
+	r.rotateTopCandidatesLocked(candidates, jobType, false)
+
+	out := make([]*WorkerSession, 0, len(candidates))
+	for _, candidate := range candidates {
+		out = append(out, cloneWorkerSession(candidate))
+	}
+	return out, nil
+}
+
+func (r *Registry) pickByKind(jobType string, detect bool) (*WorkerSession, error) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	candidates := r.collectByKindLocked(jobType, detect, time.Now())
+
+	if len(candidates) == 0 {
+		kind := "executor"
+		if detect {
+			kind = "detector"
+		}
+		return nil, fmt.Errorf("no %s worker available for job_type=%s", kind, jobType)
+	}
+
+	sortByKind(candidates, jobType, detect)
+	r.rotateTopCandidatesLocked(candidates, jobType, detect)
+
+	return cloneWorkerSession(candidates[0]), nil
+}
+
+func (r *Registry) collectByKindLocked(jobType string, detect bool, now time.Time) []*WorkerSession {
+	var candidates []*WorkerSession
+	for _, session := range r.sessions {
+		if r.isSessionStaleLocked(session, now) {
+			continue
+		}
+		capability := session.Capabilities[jobType]
+		if capability == nil {
+			continue
+		}
+		if detect && capability.CanDetect {
+			candidates = append(candidates, session)
+		}
+		if !detect && capability.CanExecute {
+			candidates = append(candidates, session)
+		}
+	}
+	return candidates
+}
+
+func (r *Registry) isSessionStaleLocked(session *WorkerSession, now time.Time) bool {
+	if session == nil {
+		return true
+	}
+	if r.staleAfter <= 0 {
+		return false
+	}
+
+	lastSeen := session.LastSeenAt
+	if lastSeen.IsZero() {
+		lastSeen = session.ConnectedAt
+	}
+	if lastSeen.IsZero() {
+		return false
+	}
+	return now.Sub(lastSeen) > r.staleAfter
+}
+
+func sortByKind(candidates []*WorkerSession, jobType string, detect bool) {
+	sort.Slice(candidates, func(i, j int) bool {
+		a := candidates[i]
+		b := candidates[j]
+		ac := a.Capabilities[jobType]
+		bc := b.Capabilities[jobType]
+
+		aSlots := availableSlotsByKind(a, ac, detect)
+		bSlots := availableSlotsByKind(b, bc, detect)
+
+		if aSlots != bSlots {
+			return aSlots > bSlots
+		}
+		return a.WorkerID < b.WorkerID
+	})
+}
+
+func (r *Registry) rotateTopCandidatesLocked(candidates []*WorkerSession, jobType string, detect bool) {
+	if len(candidates) < 2 {
+		return
+	}
+
+	capability := candidates[0].Capabilities[jobType]
+	topSlots := availableSlotsByKind(candidates[0], capability, detect)
+	tieEnd := 1
+	for tieEnd < len(candidates) {
+		nextCapability := candidates[tieEnd].Capabilities[jobType]
+		if availableSlotsByKind(candidates[tieEnd], nextCapability, detect) != topSlots {
+			break
+		}
+		tieEnd++
+	}
+	if tieEnd <= 1 {
+		return
+	}
+
+	cursorKey := strings.TrimSpace(jobType)
+	if cursorKey == "" {
+		cursorKey = "*"
+	}
+
+	var offset int
+	if detect {
+		offset = r.detectorCursor[cursorKey] % tieEnd
+		r.detectorCursor[cursorKey] = (offset + 1) % tieEnd
+	} else {
+		offset = r.executorCursor[cursorKey] % tieEnd
+		r.executorCursor[cursorKey] = (offset + 1) % tieEnd
+	}
+
+	if offset == 0 {
+		return
+	}
+
+	prefix := append([]*WorkerSession(nil), candidates[:tieEnd]...)
+	for i := 0; i < tieEnd; i++ {
+		candidates[i] = prefix[(i+offset)%tieEnd]
 	}
 }
+
+func availableSlotsByKind(
+	session *WorkerSession,
+	capability *plugin_pb.JobTypeCapability,
+	detect bool,
+) int {
+	if detect {
+		return availableDetectionSlots(session, capability)
+	}
+	return availableExecutionSlots(session, capability)
+}
+
+func availableDetectionSlots(session *WorkerSession, capability *plugin_pb.JobTypeCapability) int {
+	if session.Heartbeat != nil && session.Heartbeat.DetectionSlotsTotal > 0 {
+		free := int(session.Heartbeat.DetectionSlotsTotal - session.Heartbeat.DetectionSlotsUsed)
+		if free < 0 {
+			return 0
+		}
+		return free
+	}
+	if capability.MaxDetectionConcurrency > 0 {
+		return int(capability.MaxDetectionConcurrency)
+	}
+	return 1
+}
+
+func availableExecutionSlots(session *WorkerSession, capability *plugin_pb.JobTypeCapability) int {
+	if session.Heartbeat != nil && session.Heartbeat.ExecutionSlotsTotal > 0 {
+		free := int(session.Heartbeat.ExecutionSlotsTotal - session.Heartbeat.ExecutionSlotsUsed)
+		if free < 0 {
+			return 0
+		}
+		return free
+	}
+	if capability.MaxExecutionConcurrency > 0 {
+		return int(capability.MaxExecutionConcurrency)
+	}
+	return 1
+}
+
+func cloneWorkerSession(in *WorkerSession) *WorkerSession {
+	if in == nil {
+		return nil
+	}
+	out := *in
+	out.Capabilities = make(map[string]*plugin_pb.JobTypeCapability, len(in.Capabilities))
+	for jobType, cap := range in.Capabilities {
+		out.Capabilities[jobType] = cloneJobTypeCapability(cap)
+	}
+	out.Heartbeat = cloneWorkerHeartbeat(in.Heartbeat)
+	return &out
+}
+
+func cloneJobTypeCapability(in *plugin_pb.JobTypeCapability) *plugin_pb.JobTypeCapability {
+	if in == nil {
+		return nil
+	}
+	out := *in
+	return &out
+}
+
+func cloneWorkerHeartbeat(in *plugin_pb.WorkerHeartbeat) *plugin_pb.WorkerHeartbeat {
+	if in == nil {
+		return nil
+	}
+	out := *in
+	if in.RunningWork != nil {
+		out.RunningWork = make([]*plugin_pb.RunningWork, 0, len(in.RunningWork))
+		for _, rw := range in.RunningWork {
+			if rw == nil {
+				continue
+			}
+			clone := *rw
+			out.RunningWork = append(out.RunningWork, &clone)
+		}
+	}
+	if in.QueuedJobsByType != nil {
+		out.QueuedJobsByType = make(map[string]int32, len(in.QueuedJobsByType))
+		for k, v := range in.QueuedJobsByType {
+			out.QueuedJobsByType[k] = v
+		}
+	}
+	if in.Metadata != nil {
+		out.Metadata = make(map[string]string, len(in.Metadata))
+		for k, v := range in.Metadata {
+			out.Metadata[k] = v
+		}
+	}
+	return &out
+}

weed/admin/plugin/registry_test.go

@@ -0,0 +1,321 @@
+package plugin
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
+)
+
+func TestRegistryPickDetectorPrefersMoreFreeSlots(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true, CanExecute: true, MaxDetectionConcurrency: 2, MaxExecutionConcurrency: 2},
+		},
+	})
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true, CanExecute: true, MaxDetectionConcurrency: 4, MaxExecutionConcurrency: 4},
+		},
+	})
+
+	r.UpdateHeartbeat("worker-a", &plugin_pb.WorkerHeartbeat{
+		WorkerId:            "worker-a",
+		DetectionSlotsUsed:  1,
+		DetectionSlotsTotal: 2,
+	})
+	r.UpdateHeartbeat("worker-b", &plugin_pb.WorkerHeartbeat{
+		WorkerId:            "worker-b",
+		DetectionSlotsUsed:  1,
+		DetectionSlotsTotal: 4,
+	})
+
+	picked, err := r.PickDetector("vacuum")
+	if err != nil {
+		t.Fatalf("PickDetector: %v", err)
+	}
+	if picked.WorkerID != "worker-b" {
+		t.Fatalf("unexpected detector picked: got %s want worker-b", picked.WorkerID)
+	}
+}
+
+func TestRegistryPickExecutorAllowsSameWorker(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-x",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanDetect: true, CanExecute: true, MaxDetectionConcurrency: 1, MaxExecutionConcurrency: 1},
+		},
+	})
+
+	detector, err := r.PickDetector("balance")
+	if err != nil {
+		t.Fatalf("PickDetector: %v", err)
+	}
+	executor, err := r.PickExecutor("balance")
+	if err != nil {
+		t.Fatalf("PickExecutor: %v", err)
+	}
+
+	if detector.WorkerID != "worker-x" || executor.WorkerID != "worker-x" {
+		t.Fatalf("expected same worker for detect/execute, got detector=%s executor=%s", detector.WorkerID, executor.WorkerID)
+	}
+}
+
+func TestRegistryDetectableJobTypes(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true, CanExecute: true},
+			{JobType: "balance", CanDetect: false, CanExecute: true},
+		},
+	})
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "ec", CanDetect: true, CanExecute: false},
+			{JobType: "vacuum", CanDetect: true, CanExecute: false},
+		},
+	})
+
+	got := r.DetectableJobTypes()
+	want := []string{"ec", "vacuum"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected detectable job types: got=%v want=%v", got, want)
+	}
+}
+
+func TestRegistryJobTypes(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true},
+			{JobType: "balance", CanExecute: true},
+		},
+	})
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "ec", CanDetect: true},
+		},
+	})
+
+	got := r.JobTypes()
+	want := []string{"balance", "ec", "vacuum"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected job types: got=%v want=%v", got, want)
+	}
+}
+
+func TestRegistryListExecutorsSortedBySlots(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 2},
+		},
+	})
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 4},
+		},
+	})
+
+	r.UpdateHeartbeat("worker-a", &plugin_pb.WorkerHeartbeat{
+		WorkerId:            "worker-a",
+		ExecutionSlotsUsed:  1,
+		ExecutionSlotsTotal: 2,
+	})
+	r.UpdateHeartbeat("worker-b", &plugin_pb.WorkerHeartbeat{
+		WorkerId:            "worker-b",
+		ExecutionSlotsUsed:  1,
+		ExecutionSlotsTotal: 4,
+	})
+
+	executors, err := r.ListExecutors("balance")
+	if err != nil {
+		t.Fatalf("ListExecutors: %v", err)
+	}
+	if len(executors) != 2 {
+		t.Fatalf("unexpected candidate count: got=%d", len(executors))
+	}
+	if executors[0].WorkerID != "worker-b" || executors[1].WorkerID != "worker-a" {
+		t.Fatalf("unexpected executor order: got=%s,%s", executors[0].WorkerID, executors[1].WorkerID)
+	}
+}
+
+func TestRegistryPickExecutorRoundRobinForTopTie(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	for _, workerID := range []string{"worker-a", "worker-b", "worker-c"} {
+		r.UpsertFromHello(&plugin_pb.WorkerHello{
+			WorkerId: workerID,
+			Capabilities: []*plugin_pb.JobTypeCapability{
+				{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 1},
+			},
+		})
+	}
+
+	got := make([]string, 0, 6)
+	for i := 0; i < 6; i++ {
+		executor, err := r.PickExecutor("balance")
+		if err != nil {
+			t.Fatalf("PickExecutor: %v", err)
+		}
+		got = append(got, executor.WorkerID)
+	}
+
+	want := []string{"worker-a", "worker-b", "worker-c", "worker-a", "worker-b", "worker-c"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("unexpected pick order: got=%v want=%v", got, want)
+	}
+}
+
+func TestRegistryListExecutorsRoundRobinForTopTie(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 2},
+		},
+	})
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-b",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 2},
+		},
+	})
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-c",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "balance", CanExecute: true, MaxExecutionConcurrency: 1},
+		},
+	})
+
+	r.UpdateHeartbeat("worker-a", &plugin_pb.WorkerHeartbeat{
+		WorkerId:            "worker-a",
+		ExecutionSlotsUsed:  0,
+		ExecutionSlotsTotal: 2,
+	})
+	r.UpdateHeartbeat("worker-b", &plugin_pb.WorkerHeartbeat{
+		WorkerId:            "worker-b",
+		ExecutionSlotsUsed:  0,
+		ExecutionSlotsTotal: 2,
+	})
+	r.UpdateHeartbeat("worker-c", &plugin_pb.WorkerHeartbeat{
+		WorkerId:            "worker-c",
+		ExecutionSlotsUsed:  0,
+		ExecutionSlotsTotal: 1,
+	})
+
+	firstCall, err := r.ListExecutors("balance")
+	if err != nil {
+		t.Fatalf("ListExecutors first call: %v", err)
+	}
+	secondCall, err := r.ListExecutors("balance")
+	if err != nil {
+		t.Fatalf("ListExecutors second call: %v", err)
+	}
+	thirdCall, err := r.ListExecutors("balance")
+	if err != nil {
+		t.Fatalf("ListExecutors third call: %v", err)
+	}
+
+	if firstCall[0].WorkerID != "worker-a" || firstCall[1].WorkerID != "worker-b" || firstCall[2].WorkerID != "worker-c" {
+		t.Fatalf("unexpected first executor order: got=%s,%s,%s", firstCall[0].WorkerID, firstCall[1].WorkerID, firstCall[2].WorkerID)
+	}
+	if secondCall[0].WorkerID != "worker-b" || secondCall[1].WorkerID != "worker-a" || secondCall[2].WorkerID != "worker-c" {
+		t.Fatalf("unexpected second executor order: got=%s,%s,%s", secondCall[0].WorkerID, secondCall[1].WorkerID, secondCall[2].WorkerID)
+	}
+	if thirdCall[0].WorkerID != "worker-a" || thirdCall[1].WorkerID != "worker-b" || thirdCall[2].WorkerID != "worker-c" {
+		t.Fatalf("unexpected third executor order: got=%s,%s,%s", thirdCall[0].WorkerID, thirdCall[1].WorkerID, thirdCall[2].WorkerID)
+	}
+}
+
+func TestRegistrySkipsStaleWorkersForSelectionAndListing(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	r.staleAfter = 2 * time.Second
+
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-stale",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true, CanExecute: true},
+		},
+	})
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-fresh",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true, CanExecute: true},
+		},
+	})
+
+	r.mu.Lock()
+	r.sessions["worker-stale"].LastSeenAt = time.Now().Add(-10 * time.Second)
+	r.sessions["worker-fresh"].LastSeenAt = time.Now()
+	r.mu.Unlock()
+
+	picked, err := r.PickDetector("vacuum")
+	if err != nil {
+		t.Fatalf("PickDetector: %v", err)
+	}
+	if picked.WorkerID != "worker-fresh" {
+		t.Fatalf("unexpected detector: got=%s want=worker-fresh", picked.WorkerID)
+	}
+
+	if _, ok := r.Get("worker-stale"); ok {
+		t.Fatalf("expected stale worker to be hidden from Get")
+	}
+	if _, ok := r.Get("worker-fresh"); !ok {
+		t.Fatalf("expected fresh worker from Get")
+	}
+
+	listed := r.List()
+	if len(listed) != 1 || listed[0].WorkerID != "worker-fresh" {
+		t.Fatalf("unexpected listed workers: %+v", listed)
+	}
+}
+
+func TestRegistryReturnsNoDetectorWhenAllWorkersStale(t *testing.T) {
+	t.Parallel()
+
+	r := NewRegistry()
+	r.staleAfter = 2 * time.Second
+
+	r.UpsertFromHello(&plugin_pb.WorkerHello{
+		WorkerId: "worker-a",
+		Capabilities: []*plugin_pb.JobTypeCapability{
+			{JobType: "vacuum", CanDetect: true},
+		},
+	})
+
+	r.mu.Lock()
+	r.sessions["worker-a"].LastSeenAt = time.Now().Add(-10 * time.Second)
+	r.mu.Unlock()
+
+	if _, err := r.PickDetector("vacuum"); err == nil {
+		t.Fatalf("expected no detector when all workers are stale")
+	}
+}

weed/admin/plugin/testing/errors.go

@@ -1,6 +0,0 @@
-package testing
-
-import "errors"
-
-// ErrSimulatedError is returned when error simulation is enabled
-var ErrSimulatedError = errors.New("simulated plugin error")

weed/admin/plugin/testing/harness.go

@@ -1,530 +0,0 @@
-package testing
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
-)
-
-// TestHarness provides a complete testing environment for plugins
-type TestHarness struct {
-	mu                sync.RWMutex
-	adminService      *MockPluginService
-	plugins           map[string]*MockPlugin
-	registrations     map[string]*RegistrationRecord
-	jobs              map[string]*JobTracker
-	detections        map[string][]*DetectionRecord
-	executions        map[string]*ExecutionRecord
-	startTime         time.Time
-	timeout           time.Duration
-	testName          string
-	registrationWait  time.Duration
-	executionWait     time.Duration
-	expectedPlugins   int
-	registeredPlugins int
-	failureReasons    []string
-}
-
-// RegistrationRecord tracks plugin registration details
-type RegistrationRecord struct {
-	PluginID           string
-	RegisteredAt       time.Time
-	Version            string
-	Capabilities      []string
-	MaxConcurrentJobs int
-	Status             string
-}
-
-// JobTracker tracks job lifecycle
-type JobTracker struct {
-	JobID        string
-	Type         string
-	PluginID     string
-	Status       plugin_pb.ExecutionStatus
-	CreatedAt    time.Time
-	StartedAt    *time.Time
-	CompletedAt  *time.Time
-	Result       *plugin_pb.JobResult
-	ErrorMessage string
-	Detections   []*DetectionRecord
-}
-
-// DetectionRecord represents a detection result
-type DetectionRecord struct {
-	ResourceID    string
-	DetectionType string
-	Severity      string
-	Description   string
-	Data          []byte
-}
-
-// ExecutionRecord tracks execution details
-type ExecutionRecord struct {
-	ResourceID   string
-	Type         string
-	ExecutedAt   time.Time
-	CompletedAt  *time.Time
-	Success      bool
-	ErrorMessage string
-	Data         []byte
-}
-
-// NewTestHarness creates a new test harness
-func NewTestHarness(testName string) *TestHarness {
-	return &TestHarness{
-		testName:         testName,
-		adminService:     NewMockPluginService(),
-		plugins:          make(map[string]*MockPlugin),
-		registrations:    make(map[string]*RegistrationRecord),
-		jobs:             make(map[string]*JobTracker),
-		detections:       make(map[string][]*DetectionRecord),
-		executions:       make(map[string]*ExecutionRecord),
-		startTime:        time.Now(),
-		timeout:          10 * time.Second,
-		registrationWait: 100 * time.Millisecond,
-		executionWait:    100 * time.Millisecond,
-		failureReasons:   make([]string, 0),
-	}
-}
-
-// SetTimeout sets the overall test timeout
-func (h *TestHarness) SetTimeout(timeout time.Duration) {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	h.timeout = timeout
-}
-
-// SetRegistrationWait sets the wait time for plugin registration
-func (h *TestHarness) SetRegistrationWait(duration time.Duration) {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	h.registrationWait = duration
-}
-
-// SetExecutionWait sets the wait time for job execution
-func (h *TestHarness) SetExecutionWait(duration time.Duration) {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	h.executionWait = duration
-}
-
-// RegisterPlugin simulates plugin registration
-func (h *TestHarness) RegisterPlugin(plugin *MockPlugin) error {
-	h.mu.Lock()
-
-	if plugin == nil {
-		h.failureReasons = append(h.failureReasons, "plugin is nil")
-		h.mu.Unlock()
-		return fmt.Errorf("plugin is nil")
-	}
-
-	h.plugins[plugin.ID] = plugin
-	h.mu.Unlock()
-
-	// Simulate registration with admin service
-	req := &plugin_pb.PluginConnectRequest{
-		PluginId:           plugin.ID,
-		PluginName:         plugin.Name,
-		Version:            plugin.Version,
-		Capabilities:       plugin.Capabilities,
-		CapabilitiesDetail: plugin.CapabilitiesDetail,
-		MaxConcurrentJobs:  int32(plugin.MaxConcurrentJobs),
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), h.timeout)
-	defer cancel()
-
-	resp, err := h.adminService.Connect(ctx, req)
-	if err != nil {
-		h.mu.Lock()
-		h.failureReasons = append(h.failureReasons, fmt.Sprintf("registration failed: %v", err))
-		h.mu.Unlock()
-		return err
-	}
-
-	if !resp.Success {
-		h.mu.Lock()
-		h.failureReasons = append(h.failureReasons, "registration response was not successful")
-		h.mu.Unlock()
-		return fmt.Errorf("registration failed: %s", resp.Message)
-	}
-
-	h.mu.Lock()
-	h.registrations[plugin.ID] = &RegistrationRecord{
-		PluginID:           plugin.ID,
-		RegisteredAt:       time.Now(),
-		Version:            plugin.Version,
-		Capabilities:       plugin.Capabilities,
-		MaxConcurrentJobs:  plugin.MaxConcurrentJobs,
-		Status:             "registered",
-	}
-	h.registeredPlugins++
-	h.mu.Unlock()
-
-	return nil
-}
-
-// RegisterMultiplePlugins registers multiple plugins
-func (h *TestHarness) RegisterMultiplePlugins(plugins ...*MockPlugin) error {
-	for _, plugin := range plugins {
-		if err := h.RegisterPlugin(plugin); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// ExpectPlugins sets the expected number of plugins
-func (h *TestHarness) ExpectPlugins(count int) {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	h.expectedPlugins = count
-}
-
-// DispatchJob sends a job to a plugin
-func (h *TestHarness) DispatchJob(pluginID string, jobType string, payload *plugin_pb.JobPayload) (string, error) {
-	h.mu.RLock()
-	plugin, ok := h.plugins[pluginID]
-	h.mu.RUnlock()
-
-	if !ok {
-		return "", fmt.Errorf("plugin not found: %s", pluginID)
-	}
-
-	jobID := fmt.Sprintf("job-%d-%d", len(h.jobs), time.Now().UnixNano())
-
-	req := &plugin_pb.ExecuteJobRequest{
-		JobId:   jobID,
-		JobType: jobType,
-		Payload: payload,
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), h.timeout)
-	defer cancel()
-
-	// Simulate job dispatch
-	err := h.adminService.SimulateJobExecution(req)
-	if err != nil {
-		h.mu.Lock()
-		h.failureReasons = append(h.failureReasons, fmt.Sprintf("job dispatch failed: %v", err))
-		h.mu.Unlock()
-		return "", err
-	}
-
-	// Wait for job to complete
-	time.Sleep(h.executionWait)
-
-	// Verify job execution
-	plugin.TrackJob(req)
-
-	_, executionErr := plugin.ExecuteJob(ctx, jobID, jobType, payload)
-
-	h.mu.Lock()
-	h.jobs[jobID] = &JobTracker{
-		JobID:      jobID,
-		Type:       jobType,
-		PluginID:   pluginID,
-		Status:     plugin_pb.ExecutionStatus_EXECUTION_STATUS_RUNNING,
-		CreatedAt:  time.Now(),
-	}
-	h.mu.Unlock()
-
-	// Simulate completion after a small delay
-	time.Sleep(h.executionWait)
-
-	h.mu.Lock()
-	h.jobs[jobID].Status = plugin_pb.ExecutionStatus_EXECUTION_STATUS_COMPLETED
-	now := time.Now()
-	h.jobs[jobID].CompletedAt = &now
-	h.mu.Unlock()
-
-	if executionErr != nil {
-		h.mu.Lock()
-		h.jobs[jobID].Status = plugin_pb.ExecutionStatus_EXECUTION_STATUS_FAILED
-		h.jobs[jobID].ErrorMessage = executionErr.Error()
-		h.mu.Unlock()
-	}
-
-	return jobID, nil
-}
-
-// VerifyRegistration checks if a plugin was registered
-func (h *TestHarness) VerifyRegistration(pluginID string) bool {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	_, ok := h.registrations[pluginID]
-	return ok
-}
-
-// VerifyJobCompleted checks if a job completed successfully
-func (h *TestHarness) VerifyJobCompleted(jobID string) bool {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-
-	job, ok := h.jobs[jobID]
-	if !ok {
-		return false
-	}
-
-	return job.Status == plugin_pb.ExecutionStatus_EXECUTION_STATUS_COMPLETED
-}
-
-// VerifyJobFailed checks if a job failed
-func (h *TestHarness) VerifyJobFailed(jobID string) bool {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-
-	job, ok := h.jobs[jobID]
-	if !ok {
-		return false
-	}
-
-	return job.Status == plugin_pb.ExecutionStatus_EXECUTION_STATUS_FAILED
-}
-
-// VerifyPluginCapability checks if a plugin has a capability
-func (h *TestHarness) VerifyPluginCapability(pluginID string, capability string) bool {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-
-	reg, ok := h.registrations[pluginID]
-	if !ok {
-		return false
-	}
-
-	for _, cap := range reg.Capabilities {
-		if cap == capability {
-			return true
-		}
-	}
-
-	return false
-}
-
-// GetJobStatus returns the status of a job
-func (h *TestHarness) GetJobStatus(jobID string) plugin_pb.ExecutionStatus {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-
-	job, ok := h.jobs[jobID]
-	if !ok {
-		return plugin_pb.ExecutionStatus_EXECUTION_STATUS_UNKNOWN
-	}
-
-	return job.Status
-}
-
-// GetPlugin returns a registered plugin
-func (h *TestHarness) GetPlugin(pluginID string) *MockPlugin {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	return h.plugins[pluginID]
-}
-
-// GetRegistrationCount returns the number of registered plugins
-func (h *TestHarness) GetRegistrationCount() int {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	return h.registeredPlugins
-}
-
-// GetJobCount returns the total number of jobs dispatched
-func (h *TestHarness) GetJobCount() int {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	return len(h.jobs)
-}
-
-// SimulateDetection simulates detection results
-func (h *TestHarness) SimulateDetection(pluginID string, result *DetectionRecord) error {
-	h.mu.RLock()
-	plugin, ok := h.plugins[pluginID]
-	h.mu.RUnlock()
-
-	if !ok {
-		return fmt.Errorf("plugin not found: %s", pluginID)
-	}
-
-	plugin.AddDetectionResult(result.ResourceID, result.DetectionType, result.Severity, result.Description, result.Data)
-
-	h.mu.Lock()
-	if _, exists := h.detections[pluginID]; !exists {
-		h.detections[pluginID] = make([]*DetectionRecord, 0)
-	}
-	h.detections[pluginID] = append(h.detections[pluginID], result)
-	h.mu.Unlock()
-
-	return nil
-}
-
-// GetAdminService returns the underlying admin service
-func (h *TestHarness) GetAdminService() *MockPluginService {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	return h.adminService
-}
-
-// GetTestDuration returns the elapsed test time
-func (h *TestHarness) GetTestDuration() time.Duration {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	return time.Since(h.startTime)
-}
-
-// ReportFailure records a test failure reason
-func (h *TestHarness) ReportFailure(reason string) {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	h.failureReasons = append(h.failureReasons, reason)
-}
-
-// HasFailures checks if any failures were recorded
-func (h *TestHarness) HasFailures() bool {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	return len(h.failureReasons) > 0
-}
-
-// GetFailures returns all recorded failures
-func (h *TestHarness) GetFailures() []string {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-	failures := make([]string, len(h.failureReasons))
-	copy(failures, h.failureReasons)
-	return failures
-}
-
-// WaitForRegistration waits for a specific number of plugins to register
-func (h *TestHarness) WaitForRegistration(count int, timeout time.Duration) bool {
-	deadline := time.Now().Add(timeout)
-	for {
-		h.mu.RLock()
-		current := h.registeredPlugins
-		h.mu.RUnlock()
-
-		if current >= count {
-			return true
-		}
-
-		if time.Now().After(deadline) {
-			return false
-		}
-
-		time.Sleep(10 * time.Millisecond)
-	}
-}
-
-// VerifyAdminServiceStats checks admin service statistics
-func (h *TestHarness) VerifyAdminServiceStats(regCount, jobCount int) bool {
-	return h.adminService.GetRegistrationCount() == regCount &&
-		h.adminService.GetJobDispatchCount() == jobCount
-}
-
-// GetCompletedJobCount returns the number of completed jobs
-func (h *TestHarness) GetCompletedJobCount() int {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-
-	count := 0
-	for _, job := range h.jobs {
-		if job.Status == plugin_pb.ExecutionStatus_EXECUTION_STATUS_COMPLETED {
-			count++
-		}
-	}
-	return count
-}
-
-// GetFailedJobCount returns the number of failed jobs
-func (h *TestHarness) GetFailedJobCount() int {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-
-	count := 0
-	for _, job := range h.jobs {
-		if job.Status == plugin_pb.ExecutionStatus_EXECUTION_STATUS_FAILED {
-			count++
-		}
-	}
-	return count
-}
-
-// Cleanup performs cleanup after a test
-func (h *TestHarness) Cleanup() {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-
-	// Reset all plugins
-	for _, plugin := range h.plugins {
-		plugin.Reset()
-	}
-
-	// Reset admin service
-	h.adminService.ResetCounters()
-
-	// Clear tracking
-	h.registrations = make(map[string]*RegistrationRecord)
-	h.jobs = make(map[string]*JobTracker)
-	h.detections = make(map[string][]*DetectionRecord)
-	h.executions = make(map[string]*ExecutionRecord)
-	h.failureReasons = make([]string, 0)
-	h.registeredPlugins = 0
-	h.startTime = time.Now()
-}
-
-// MockExecuteJobStream is a mock implementation of the ExecuteJob stream
-type MockExecuteJobStream struct {
-	responses []*plugin_pb.ExecuteJobResponse
-	mu        sync.Mutex
-}
-
-// Send sends a response on the stream
-func (m *MockExecuteJobStream) Send(resp *plugin_pb.ExecuteJobResponse) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.responses = append(m.responses, resp)
-	return nil
-}
-
-// Recv receives a response from the stream
-func (m *MockExecuteJobStream) Recv() (*plugin_pb.ExecuteJobResponse, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if len(m.responses) == 0 {
-		return nil, fmt.Errorf("no responses")
-	}
-	resp := m.responses[0]
-	m.responses = m.responses[1:]
-	return resp, nil
-}
-
-// SetHeader sets the metadata header
-func (m *MockExecuteJobStream) SetHeader(map[string][]string) error {
-	return nil
-}
-
-// SendHeader sends the metadata header
-func (m *MockExecuteJobStream) SendHeader(map[string][]string) error {
-	return nil
-}
-
-// SetTrailer sets the metadata trailer
-func (m *MockExecuteJobStream) SetTrailer(map[string][]string) {
-}
-
-// Context returns the context
-func (m *MockExecuteJobStream) Context() context.Context {
-	return context.Background()
-}
-
-// SendMsg sends a message on the stream
-func (m *MockExecuteJobStream) SendMsg(interface{}) error {
-	return nil
-}
-
-// RecvMsg receives a message from the stream
-func (m *MockExecuteJobStream) RecvMsg(interface{}) error {
-	return nil
-}

weed/admin/plugin/testing/mock_admin.go

@@ -1,342 +0,0 @@
-package testing
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"google.golang.org/protobuf/types/known/durationpb"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
-)
-
-// MockPluginService simulates the admin-side PluginService for testing
-type MockPluginService struct {
-	mu                   sync.RWMutex
-	plugins              map[string]*MockPluginInstance
-	jobs                 map[string]*MockJob
-	jobCounter           int
-	heartbeats           map[string]*plugin_pb.HealthReport
-	lastHeartbeatTime    map[string]time.Time
-	jobDispatchCalls     int
-	registrationCalls    int
-	receivedHealthReports []plugin_pb.HealthReport
-}
-
-// MockPluginInstance tracks a registered plugin
-type MockPluginInstance struct {
-	ID                    string
-	Name                  string
-	Version               string
-	Status                string
-	Capabilities         []string
-	MaxConcurrentJobs    int
-	ConnectedAt          time.Time
-	LastHeartbeat        time.Time
-	ActiveJobCount       int
-	CompletedJobCount    int
-	FailedJobCount       int
-	CapabilitiesDetail   *plugin_pb.PluginCapabilities
-	Metadata             map[string]string
-}
-
-// MockJob represents a job dispatched to a plugin
-type MockJob struct {
-	ID            string
-	Type          string
-	PluginID      string
-	Payload       *plugin_pb.JobPayload
-	Timeout       time.Duration
-	RetryCount    int
-	Context       map[string]string
-	Status        plugin_pb.ExecutionStatus
-	DispatchedAt  time.Time
-	ExecutedAt    *time.Time
-	Result        *plugin_pb.JobResult
-	ResultMessage string
-	StreamCalls   int
-}
-
-// NewMockPluginService creates a new mock admin service
-func NewMockPluginService() *MockPluginService {
-	return &MockPluginService{
-		plugins:               make(map[string]*MockPluginInstance),
-		jobs:                  make(map[string]*MockJob),
-		heartbeats:            make(map[string]*plugin_pb.HealthReport),
-		lastHeartbeatTime:     make(map[string]time.Time),
-		receivedHealthReports: make([]plugin_pb.HealthReport, 0),
-	}
-}
-
-// Connect handles plugin registration
-func (m *MockPluginService) Connect(ctx context.Context, req *plugin_pb.PluginConnectRequest) (*plugin_pb.PluginConnectResponse, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.registrationCalls++
-
-	// Register the plugin
-	plugin := &MockPluginInstance{
-		ID:                  req.PluginId,
-		Name:                req.PluginName,
-		Version:             req.Version,
-		Status:              "connected",
-		Capabilities:        req.Capabilities,
-		MaxConcurrentJobs:   int(req.MaxConcurrentJobs),
-		ConnectedAt:         time.Now(),
-		LastHeartbeat:       time.Now(),
-		CapabilitiesDetail:  req.CapabilitiesDetail,
-		Metadata:            req.Metadata,
-	}
-	m.plugins[req.PluginId] = plugin
-	m.lastHeartbeatTime[req.PluginId] = time.Now()
-
-	// Build response with assigned types
-	assignedTypes := req.Capabilities
-
-	config := &plugin_pb.PluginConfig{
-		PluginId:   req.PluginId,
-		Properties: make(map[string]string),
-		JobTypes:   make([]*plugin_pb.JobTypeConfig, 0),
-	}
-
-	return &plugin_pb.PluginConnectResponse{
-		Success:      true,
-		Message:      "Plugin registered successfully",
-		MasterId:     "mock-master-001",
-		AssignedTypes: assignedTypes,
-		Config:       config,
-	}, nil
-}
-
-// SimulateJobExecution simulates job execution
-func (m *MockPluginService) SimulateJobExecution(req *plugin_pb.ExecuteJobRequest) error {
-	m.mu.Lock()
-
-	m.jobDispatchCalls++
-
-	// Create job entry
-	job := &MockJob{
-		ID:           req.JobId,
-		Type:         req.JobType,
-		Payload:      req.Payload,
-		Timeout:      durationFromProto(req.Timeout),
-		RetryCount:   int(req.RetryCount),
-		Context:      req.Context,
-		DispatchedAt: time.Now(),
-		Status:       plugin_pb.ExecutionStatus_EXECUTION_STATUS_ACCEPTED,
-		StreamCalls:  0,
-	}
-	m.jobs[req.JobId] = job
-	m.mu.Unlock()
-
-	// Simulate job execution
-	time.Sleep(50 * time.Millisecond)
-
-	// Update job status
-	m.mu.Lock()
-	job.StreamCalls++
-	job.Status = plugin_pb.ExecutionStatus_EXECUTION_STATUS_RUNNING
-	m.mu.Unlock()
-
-	// Simulate processing
-	time.Sleep(50 * time.Millisecond)
-
-	m.mu.Lock()
-	job.StreamCalls++
-	job.Status = plugin_pb.ExecutionStatus_EXECUTION_STATUS_COMPLETED
-	job.ResultMessage = "Job completed successfully"
-	now := time.Now()
-	job.ExecutedAt = &now
-	m.mu.Unlock()
-
-	return nil
-}
-
-// ExecuteJob simulates job dispatch
-func (m *MockPluginService) ExecuteJob(ctx context.Context, req *plugin_pb.ExecuteJobRequest) (*plugin_pb.ExecuteJobResponse, error) {
-	m.mu.Lock()
-	m.jobDispatchCalls++
-	m.mu.Unlock()
-
-	return &plugin_pb.ExecuteJobResponse{
-		JobId:   req.JobId,
-		Status:  plugin_pb.ExecutionStatus_EXECUTION_STATUS_ACCEPTED,
-		Message: "Job accepted",
-	}, nil
-}
-
-// ReportHealth handles plugin health reports
-func (m *MockPluginService) ReportHealth(ctx context.Context, report *plugin_pb.HealthReport) (*plugin_pb.HealthReportResponse, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.heartbeats[report.PluginId] = report
-	m.lastHeartbeatTime[report.PluginId] = time.Now()
-	m.receivedHealthReports = append(m.receivedHealthReports, *report)
-
-	// Update plugin status
-	if plugin, ok := m.plugins[report.PluginId]; ok {
-		plugin.LastHeartbeat = time.Now()
-		plugin.ActiveJobCount = int(report.ActiveJobs)
-	}
-
-	return &plugin_pb.HealthReportResponse{
-		Acknowledged: true,
-		Feedback:     "Health report received",
-	}, nil
-}
-
-// GetConfig handles config retrieval
-func (m *MockPluginService) GetConfig(ctx context.Context, req *plugin_pb.GetConfigRequest) (*plugin_pb.GetConfigResponse, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	config := &plugin_pb.PluginConfig{
-		PluginId:   req.PluginId,
-		Properties: make(map[string]string),
-		JobTypes:   make([]*plugin_pb.JobTypeConfig, 0),
-	}
-
-	return &plugin_pb.GetConfigResponse{
-		Config:  config,
-		Version: 1,
-	}, nil
-}
-
-// SubmitResult handles job result submission
-func (m *MockPluginService) SubmitResult(ctx context.Context, req *plugin_pb.JobResultRequest) (*plugin_pb.JobResultResponse, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if job, ok := m.jobs[req.JobId]; ok {
-		job.Status = req.Status
-		job.Result = req.Result
-		job.ResultMessage = req.Message
-	}
-
-	return &plugin_pb.JobResultResponse{
-		Acknowledged:   true,
-		ActionsToTake: []string{},
-	}, nil
-}
-
-// GetRegistrationCount returns how many times Connect was called
-func (m *MockPluginService) GetRegistrationCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.registrationCalls
-}
-
-// GetJobDispatchCount returns how many times ExecuteJob was called
-func (m *MockPluginService) GetJobDispatchCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.jobDispatchCalls
-}
-
-// GetPluginCount returns the number of registered plugins
-func (m *MockPluginService) GetPluginCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.plugins)
-}
-
-// GetPlugin returns a registered plugin by ID
-func (m *MockPluginService) GetPlugin(pluginID string) *MockPluginInstance {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.plugins[pluginID]
-}
-
-// GetJob returns a dispatched job by ID
-func (m *MockPluginService) GetJob(jobID string) *MockJob {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.jobs[jobID]
-}
-
-// GetJobCount returns the total number of dispatched jobs
-func (m *MockPluginService) GetJobCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.jobs)
-}
-
-// GetLastHeartbeat returns the last heartbeat time for a plugin
-func (m *MockPluginService) GetLastHeartbeat(pluginID string) *time.Time {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if t, ok := m.lastHeartbeatTime[pluginID]; ok {
-		return &t
-	}
-	return nil
-}
-
-// GetHeartbeatCount returns how many heartbeats have been received
-func (m *MockPluginService) GetHeartbeatCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.receivedHealthReports)
-}
-
-// ResetCounters resets all counters for a fresh test
-func (m *MockPluginService) ResetCounters() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.registrationCalls = 0
-	m.jobDispatchCalls = 0
-	m.plugins = make(map[string]*MockPluginInstance)
-	m.jobs = make(map[string]*MockJob)
-	m.heartbeats = make(map[string]*plugin_pb.HealthReport)
-	m.lastHeartbeatTime = make(map[string]time.Time)
-	m.receivedHealthReports = make([]plugin_pb.HealthReport, 0)
-}
-
-// VerifyJobCompleted checks if a job was completed successfully
-func (m *MockPluginService) VerifyJobCompleted(jobID string) bool {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	job, ok := m.jobs[jobID]
-	if !ok {
-		return false
-	}
-	return job.Status == plugin_pb.ExecutionStatus_EXECUTION_STATUS_COMPLETED
-}
-
-// VerifyJobFailed checks if a job failed
-func (m *MockPluginService) VerifyJobFailed(jobID string) bool {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	job, ok := m.jobs[jobID]
-	if !ok {
-		return false
-	}
-	return job.Status == plugin_pb.ExecutionStatus_EXECUTION_STATUS_FAILED
-}
-
-// GetJobStatus returns the current status of a job
-func (m *MockPluginService) GetJobStatus(jobID string) plugin_pb.ExecutionStatus {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	if job, ok := m.jobs[jobID]; ok {
-		return job.Status
-	}
-	return plugin_pb.ExecutionStatus_EXECUTION_STATUS_UNKNOWN
-}
-
-// VerifyPluginRegistered checks if a plugin is registered
-func (m *MockPluginService) VerifyPluginRegistered(pluginID string) bool {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	_, ok := m.plugins[pluginID]
-	return ok
-}
-
-// durationFromProto converts proto Duration to time.Duration
-func durationFromProto(d *durationpb.Duration) time.Duration {
-	if d == nil {
-		return 0
-	}
-	return time.Duration(d.Seconds)*time.Second + time.Duration(d.Nanos)
-}

weed/admin/plugin/testing/mock_plugin.go

@@ -1,449 +0,0 @@
-package testing
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"google.golang.org/grpc"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
-)
-
-// MockPlugin simulates a plugin worker instance for testing
-type MockPlugin struct {
-	mu                      sync.RWMutex
-	ID                      string
-	Name                    string
-	Version                 string
-	Status                  string
-	Capabilities            []string
-	CapabilitiesDetail      *plugin_pb.PluginCapabilities
-	MaxConcurrentJobs       int
-	Config                  *plugin_pb.PluginConfig
-	ActiveJobs              map[string]*MockJobExecution
-	CompletedJobs           int
-	FailedJobs              int
-	ConnectStreamCalls      int
-	ExecuteJobStreamCalls   int
-	ReportHealthCalls       int
-	GetConfigCalls          int
-	SubmitResultCalls       int
-	ReceivedJobs            []*plugin_pb.ExecuteJobRequest
-	ReceivedHealthReports   []*plugin_pb.HealthReport
-	LastError               string
-	SimulateError           bool
-	SimulateErrorType       string
-	SchemaData              []byte
-	DetectionResults        []*DetectionResult
-	ExecutionResults        []*ExecutionResult
-}
-
-// MockJobExecution tracks job execution state
-type MockJobExecution struct {
-	JobID        string
-	Type         string
-	Status       plugin_pb.ExecutionStatus
-	Progress     float32
-	CurrentStep  string
-	StartTime    time.Time
-	EndTime      *time.Time
-	Result       *plugin_pb.JobResult
-	ErrorMessage string
-}
-
-// DetectionResult represents detection results
-type DetectionResult struct {
-	ResourceID   string
-	DetectionType string
-	Severity     string
-	Description  string
-	Data         []byte
-}
-
-// ExecutionResult represents execution results
-type ExecutionResult struct {
-	ResourceID   string
-	Success      bool
-	ErrorMessage string
-	Data         []byte
-}
-
-// NewMockPlugin creates a new mock plugin
-func NewMockPlugin(id, name, version string) *MockPlugin {
-	return &MockPlugin{
-		ID:                    id,
-		Name:                  name,
-		Version:               version,
-		Status:                "ready",
-		Capabilities:          make([]string, 0),
-		CapabilitiesDetail:    &plugin_pb.PluginCapabilities{},
-		MaxConcurrentJobs:     5,
-		Config:                &plugin_pb.PluginConfig{},
-		ActiveJobs:            make(map[string]*MockJobExecution),
-		ReceivedJobs:          make([]*plugin_pb.ExecuteJobRequest, 0),
-		ReceivedHealthReports: make([]*plugin_pb.HealthReport, 0),
-		DetectionResults:      make([]*DetectionResult, 0),
-		ExecutionResults:      make([]*ExecutionResult, 0),
-	}
-}
-
-// AddCapability adds a capability to the plugin
-func (m *MockPlugin) AddCapability(cap string) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.Capabilities = append(m.Capabilities, cap)
-}
-
-// AddDetectionCapability adds a detection capability
-func (m *MockPlugin) AddDetectionCapability(typ, desc string, minInterval int32, requiresFullScan bool) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.CapabilitiesDetail == nil {
-		m.CapabilitiesDetail = &plugin_pb.PluginCapabilities{}
-	}
-	m.CapabilitiesDetail.Detection = append(m.CapabilitiesDetail.Detection, &plugin_pb.DetectionCapability{
-		Type:               typ,
-		Description:        desc,
-		MinIntervalSeconds: minInterval,
-		RequiresFullScan:   requiresFullScan,
-	})
-	m.Capabilities = append(m.Capabilities, typ)
-}
-
-// AddMaintenanceCapability adds a maintenance capability
-func (m *MockPlugin) AddMaintenanceCapability(typ, desc string, requiredDetections []string) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.CapabilitiesDetail == nil {
-		m.CapabilitiesDetail = &plugin_pb.PluginCapabilities{}
-	}
-	m.CapabilitiesDetail.Maintenance = append(m.CapabilitiesDetail.Maintenance, &plugin_pb.MaintenanceCapability{
-		Type:                   typ,
-		Description:            desc,
-		RequiredDetectionTypes: requiredDetections,
-	})
-}
-
-// SetSchema sets the schema data
-func (m *MockPlugin) SetSchema(data []byte) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.SchemaData = data
-}
-
-// AddDetectionResult adds a detection result
-func (m *MockPlugin) AddDetectionResult(resourceID, detectionType, severity, description string, data []byte) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.DetectionResults = append(m.DetectionResults, &DetectionResult{
-		ResourceID:    resourceID,
-		DetectionType: detectionType,
-		Severity:      severity,
-		Description:   description,
-		Data:          data,
-	})
-}
-
-// AddExecutionResult adds an execution result
-func (m *MockPlugin) AddExecutionResult(resourceID string, success bool, errorMsg string, data []byte) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.ExecutionResults = append(m.ExecutionResults, &ExecutionResult{
-		ResourceID:   resourceID,
-		Success:      success,
-		ErrorMessage: errorMsg,
-		Data:         data,
-	})
-}
-
-// GetConfigurationSchema implements schema retrieval
-func (m *MockPlugin) GetConfigurationSchema(ctx context.Context) ([]byte, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	if m.SimulateError && m.SimulateErrorType == "schema" {
-		return nil, ErrSimulatedError
-	}
-
-	return m.SchemaData, nil
-}
-
-// DetectJobs implements detection logic
-func (m *MockPlugin) DetectJobs(ctx context.Context) ([]*DetectionResult, error) {
-	m.mu.Lock()
-	m.ReportHealthCalls++
-	results := make([]*DetectionResult, len(m.DetectionResults))
-	copy(results, m.DetectionResults)
-	m.mu.Unlock()
-
-	if m.SimulateError && m.SimulateErrorType == "detect" {
-		return nil, ErrSimulatedError
-	}
-
-	return results, nil
-}
-
-// ExecuteJob implements job execution
-func (m *MockPlugin) ExecuteJob(ctx context.Context, jobID string, jobType string, payload *plugin_pb.JobPayload) (*ExecutionResult, error) {
-	m.mu.Lock()
-	m.ExecuteJobStreamCalls++
-
-	execution := &MockJobExecution{
-		JobID:      jobID,
-		Type:       jobType,
-		Status:     plugin_pb.ExecutionStatus_EXECUTION_STATUS_RUNNING,
-		StartTime:  time.Now(),
-		Progress:   0,
-		CurrentStep: "initialized",
-	}
-	m.ActiveJobs[jobID] = execution
-	m.mu.Unlock()
-
-	// Simulate execution steps
-	steps := []string{"initialized", "validating", "processing", "finalizing"}
-
-	for i, step := range steps {
-		select {
-		case <-ctx.Done():
-			m.mu.Lock()
-			execution.Status = plugin_pb.ExecutionStatus_EXECUTION_STATUS_CANCELLED
-			execution.ErrorMessage = "context cancelled"
-			delete(m.ActiveJobs, jobID)
-			m.mu.Unlock()
-			return nil, ctx.Err()
-		default:
-		}
-
-		m.mu.Lock()
-		execution.CurrentStep = step
-		execution.Progress = float32((i + 1) * 25)
-		m.mu.Unlock()
-
-		time.Sleep(10 * time.Millisecond)
-	}
-
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if m.SimulateError && m.SimulateErrorType == "execute" {
-		execution.Status = plugin_pb.ExecutionStatus_EXECUTION_STATUS_FAILED
-		execution.ErrorMessage = "simulated execution error"
-		m.FailedJobs++
-		delete(m.ActiveJobs, jobID)
-		return nil, ErrSimulatedError
-	}
-
-	// Get results
-	result := &ExecutionResult{
-		ResourceID:   jobID,
-		Success:      true,
-		ErrorMessage: "",
-	}
-
-	if len(m.ExecutionResults) > 0 {
-		result = m.ExecutionResults[0]
-		m.ExecutionResults = m.ExecutionResults[1:]
-	}
-
-	execution.Status = plugin_pb.ExecutionStatus_EXECUTION_STATUS_COMPLETED
-	execution.Progress = 100
-	execution.CurrentStep = "completed"
-	now := time.Now()
-	execution.EndTime = &now
-
-	m.CompletedJobs++
-	delete(m.ActiveJobs, jobID)
-
-	return result, nil
-}
-
-// ConnectStream simulates the Connect RPC stream
-func (m *MockPlugin) ConnectStream(ctx context.Context, conn grpc.ClientConnInterface) error {
-	m.mu.Lock()
-	m.ConnectStreamCalls++
-	m.mu.Unlock()
-
-	if m.SimulateError && m.SimulateErrorType == "connect" {
-		return ErrSimulatedError
-	}
-
-	return nil
-}
-
-// ExecuteJobStream simulates the ExecuteJob RPC stream
-func (m *MockPlugin) ExecuteJobStream(ctx context.Context, conn grpc.ClientConnInterface, jobID string) error {
-	m.mu.Lock()
-	m.ExecuteJobStreamCalls++
-	m.mu.Unlock()
-
-	if m.SimulateError && m.SimulateErrorType == "executestream" {
-		return ErrSimulatedError
-	}
-
-	return nil
-}
-
-// ReportHealth sends a health report
-func (m *MockPlugin) ReportHealth(ctx context.Context, conn grpc.ClientConnInterface) error {
-	m.mu.Lock()
-	m.ReportHealthCalls++
-
-	activeCount := len(m.ActiveJobs)
-	m.mu.Unlock()
-
-	if m.SimulateError && m.SimulateErrorType == "health" {
-		return ErrSimulatedError
-	}
-
-	report := &plugin_pb.HealthReport{
-		PluginId:   m.ID,
-		TimestampMs: time.Now().UnixMilli(),
-		Status:     plugin_pb.HealthStatus_HEALTH_STATUS_HEALTHY,
-		ActiveJobs: int32(activeCount),
-	}
-
-	m.mu.Lock()
-	m.ReceivedHealthReports = append(m.ReceivedHealthReports, report)
-	m.mu.Unlock()
-
-	return nil
-}
-
-// GetConfig retrieves configuration
-func (m *MockPlugin) GetConfig(ctx context.Context, conn grpc.ClientConnInterface) (*plugin_pb.PluginConfig, error) {
-	m.mu.Lock()
-	m.GetConfigCalls++
-	defer m.mu.Unlock()
-
-	if m.SimulateError && m.SimulateErrorType == "getconfig" {
-		return nil, ErrSimulatedError
-	}
-
-	return m.Config, nil
-}
-
-// SubmitResult submits job results
-func (m *MockPlugin) SubmitResult(ctx context.Context, conn grpc.ClientConnInterface, jobID string, result *plugin_pb.JobResult) error {
-	m.mu.Lock()
-	m.SubmitResultCalls++
-	defer m.mu.Unlock()
-
-	if m.SimulateError && m.SimulateErrorType == "submitresult" {
-		return ErrSimulatedError
-	}
-
-	return nil
-}
-
-// GetActiveJobCount returns the number of active jobs
-func (m *MockPlugin) GetActiveJobCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.ActiveJobs)
-}
-
-// GetCompletedJobCount returns the number of completed jobs
-func (m *MockPlugin) GetCompletedJobCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.CompletedJobs
-}
-
-// GetFailedJobCount returns the number of failed jobs
-func (m *MockPlugin) GetFailedJobCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.FailedJobs
-}
-
-// GetStreamCallCount returns the count of stream calls
-func (m *MockPlugin) GetStreamCallCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.ExecuteJobStreamCalls
-}
-
-// GetHealthReportCount returns the count of health reports sent
-func (m *MockPlugin) GetHealthReportCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.ReportHealthCalls
-}
-
-// EnableErrorSimulation enables error simulation
-func (m *MockPlugin) EnableErrorSimulation(errorType string) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.SimulateError = true
-	m.SimulateErrorType = errorType
-}
-
-// DisableErrorSimulation disables error simulation
-func (m *MockPlugin) DisableErrorSimulation() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.SimulateError = false
-	m.SimulateErrorType = ""
-}
-
-// Reset clears all counters and state
-func (m *MockPlugin) Reset() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.ActiveJobs = make(map[string]*MockJobExecution)
-	m.CompletedJobs = 0
-	m.FailedJobs = 0
-	m.ConnectStreamCalls = 0
-	m.ExecuteJobStreamCalls = 0
-	m.ReportHealthCalls = 0
-	m.GetConfigCalls = 0
-	m.SubmitResultCalls = 0
-	m.ReceivedJobs = make([]*plugin_pb.ExecuteJobRequest, 0)
-	m.ReceivedHealthReports = make([]*plugin_pb.HealthReport, 0)
-	m.LastError = ""
-	m.SimulateError = false
-	m.SimulateErrorType = ""
-}
-
-// GetJobExecution returns execution details for a job
-func (m *MockPlugin) GetJobExecution(jobID string) *MockJobExecution {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.ActiveJobs[jobID]
-}
-
-// TrackJob records a received job
-func (m *MockPlugin) TrackJob(req *plugin_pb.ExecuteJobRequest) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.ReceivedJobs = append(m.ReceivedJobs, req)
-}
-
-// GetReceivedJobCount returns the count of received jobs
-func (m *MockPlugin) GetReceivedJobCount() int {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return len(m.ReceivedJobs)
-}
-
-// SimulateStreamError simulates an error during streaming
-func (m *MockPlugin) SimulateStreamError(reason error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.LastError = reason.Error()
-}
-
-// SetStatus sets the plugin status
-func (m *MockPlugin) SetStatus(status string) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.Status = status
-}
-
-// GetStatus returns the plugin status
-func (m *MockPlugin) GetStatus() string {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-	return m.Status
-}

weed/admin/plugin/types.go

@@ -1,265 +1,103 @@
 package plugin
 
-import (
-	"sync"
-	"time"
-)
-
-// JobState represents the current state of a job in the state machine
-type JobState int
+import "time"
 
 const (
-	JobStatePending JobState = iota
-	JobStateScheduled
-	JobStateRunning
-	JobStateCompleted
-	JobStateFailed
-	JobStateCancelled
+	// Keep exactly the last 10 successful and last 10 error runs per job type.
+	MaxSuccessfulRunHistory = 10
+	MaxErrorRunHistory      = 10
 )
 
-func (s JobState) String() string {
-	switch s {
-	case JobStatePending:
-		return "PENDING"
-	case JobStateScheduled:
-		return "SCHEDULED"
-	case JobStateRunning:
-		return "RUNNING"
-	case JobStateCompleted:
-		return "COMPLETED"
-	case JobStateFailed:
-		return "FAILED"
-	case JobStateCancelled:
-		return "CANCELLED"
-	default:
-		return "UNKNOWN"
+type RunOutcome string
+
+const (
+	RunOutcomeSuccess RunOutcome = "success"
+	RunOutcomeError   RunOutcome = "error"
+)
+
+type JobRunRecord struct {
+	RunID       string     `json:"run_id"`
+	JobID       string     `json:"job_id"`
+	JobType     string     `json:"job_type"`
+	WorkerID    string     `json:"worker_id"`
+	Outcome     RunOutcome `json:"outcome"`
+	Message     string     `json:"message,omitempty"`
+	DurationMs  int64      `json:"duration_ms,omitempty"`
+	CompletedAt *time.Time `json:"completed_at,omitempty"`
+}
+
+type JobTypeRunHistory struct {
+	JobType         string         `json:"job_type"`
+	SuccessfulRuns  []JobRunRecord `json:"successful_runs"`
+	ErrorRuns       []JobRunRecord `json:"error_runs"`
+	LastUpdatedTime *time.Time     `json:"last_updated_time,omitempty"`
+}
+
+type TrackedJob struct {
+	JobID              string                 `json:"job_id"`
+	JobType            string                 `json:"job_type"`
+	RequestID          string                 `json:"request_id"`
+	WorkerID           string                 `json:"worker_id"`
+	DedupeKey          string                 `json:"dedupe_key,omitempty"`
+	Summary            string                 `json:"summary,omitempty"`
+	Detail             string                 `json:"detail,omitempty"`
+	Parameters         map[string]interface{} `json:"parameters,omitempty"`
+	Labels             map[string]string      `json:"labels,omitempty"`
+	State              string                 `json:"state"`
+	Progress           float64                `json:"progress"`
+	Stage              string                 `json:"stage,omitempty"`
+	Message            string                 `json:"message,omitempty"`
+	Attempt            int32                  `json:"attempt,omitempty"`
+	CreatedAt          *time.Time             `json:"created_at,omitempty"`
+	UpdatedAt          *time.Time             `json:"updated_at,omitempty"`
+	CompletedAt        *time.Time             `json:"completed_at,omitempty"`
+	ErrorMessage       string                 `json:"error_message,omitempty"`
+	ResultSummary      string                 `json:"result_summary,omitempty"`
+	ResultOutputValues map[string]interface{} `json:"result_output_values,omitempty"`
+}
+
+type JobActivity struct {
+	JobID      string                 `json:"job_id"`
+	JobType    string                 `json:"job_type"`
+	RequestID  string                 `json:"request_id,omitempty"`
+	WorkerID   string                 `json:"worker_id,omitempty"`
+	Source     string                 `json:"source"`
+	Message    string                 `json:"message"`
+	Stage      string                 `json:"stage,omitempty"`
+	Details    map[string]interface{} `json:"details,omitempty"`
+	OccurredAt *time.Time             `json:"occurred_at,omitempty"`
+}
+
+type JobDetail struct {
+	Job         *TrackedJob   `json:"job"`
+	RunRecord   *JobRunRecord `json:"run_record,omitempty"`
+	Activities  []JobActivity `json:"activities"`
+	RelatedJobs []TrackedJob  `json:"related_jobs,omitempty"`
+	LastUpdated *time.Time    `json:"last_updated,omitempty"`
+}
+
+type SchedulerJobTypeState struct {
+	JobType                       string     `json:"job_type"`
+	Enabled                       bool       `json:"enabled"`
+	PolicyError                   string     `json:"policy_error,omitempty"`
+	DetectionInFlight             bool       `json:"detection_in_flight"`
+	NextDetectionAt               *time.Time `json:"next_detection_at,omitempty"`
+	DetectionIntervalSeconds      int32      `json:"detection_interval_seconds,omitempty"`
+	DetectionTimeoutSeconds       int32      `json:"detection_timeout_seconds,omitempty"`
+	ExecutionTimeoutSeconds       int32      `json:"execution_timeout_seconds,omitempty"`
+	MaxJobsPerDetection           int32      `json:"max_jobs_per_detection,omitempty"`
+	GlobalExecutionConcurrency    int        `json:"global_execution_concurrency,omitempty"`
+	PerWorkerExecutionConcurrency int        `json:"per_worker_execution_concurrency,omitempty"`
+	RetryLimit                    int        `json:"retry_limit,omitempty"`
+	RetryBackoffSeconds           int32      `json:"retry_backoff_seconds,omitempty"`
+	DetectorAvailable             bool       `json:"detector_available"`
+	DetectorWorkerID              string     `json:"detector_worker_id,omitempty"`
+	ExecutorWorkerCount           int        `json:"executor_worker_count"`
+}
+
+func timeToPtr(t time.Time) *time.Time {
+	if t.IsZero() {
+		return nil
 	}
-}
-
-// Job represents a detection or maintenance task
-type Job struct {
-	mu               sync.RWMutex
-	ID               string
-	Type             string
-	PluginID         string
-	State            JobState
-	Payload          interface{}
-	CreatedAt        time.Time
-	StartedAt        *time.Time
-	CompletedAt      *time.Time
-	ExecutionTime    time.Duration
-	RetryCount       int
-	MaxRetries       int
-	LastError        string
-	Result           *JobResult
-	DetectionRecords []DetectionRecord
-}
-
-// GetState safely retrieves the job state
-func (j *Job) GetState() JobState {
-	j.mu.RLock()
-	defer j.mu.RUnlock()
-	return j.State
-}
-
-// SetState safely updates the job state
-func (j *Job) SetState(state JobState) {
-	j.mu.Lock()
-	defer j.mu.Unlock()
-	j.State = state
-	if state == JobStateRunning {
-		now := time.Now()
-		j.StartedAt = &now
-	} else if state == JobStateCompleted || state == JobStateFailed || state == JobStateCancelled {
-		now := time.Now()
-		j.CompletedAt = &now
-		if j.StartedAt != nil {
-			j.ExecutionTime = j.CompletedAt.Sub(*j.StartedAt)
-		}
-	}
-}
-
-// JobResult contains the output from job execution
-type JobResult struct {
-	Success   bool
-	Data      []byte
-	Warnings  []string
-	Errors    []string
-	Metadata  map[string]string
-	Message   string
-}
-
-// DetectionRecord represents a single detection result
-type DetectionRecord struct {
-	DetectionType    string
-	Timestamp        time.Time
-	Severity         string
-	Description      string
-	AffectedResource string
-	RawData          []byte
-}
-
-// ExecutionRecord persists job execution history
-type ExecutionRecord struct {
-	JobID       string
-	JobType     string
-	PluginID    string
-	State       JobState
-	CreatedAt   time.Time
-	StartedAt   *time.Time
-	CompletedAt *time.Time
-	Payload     interface{}
-	Result      *JobResult
-	RetryCount  int
-	LastError   string
-}
-
-// ConnectedPlugin represents a connected plugin instance
-type ConnectedPlugin struct {
-	mu                    sync.RWMutex
-	ID                    string
-	Name                  string
-	Version               string
-	Status                string
-	Capabilities         []string
-	MaxConcurrentJobs    int
-	ActiveJobs           int
-	CompletedJobs        int
-	FailedJobs           int
-	TotalDetections      int64
-	AvgExecutionTimeMs   float64
-	CPUUsagePercent      float64
-	MemoryUsageBytes     int64
-	ConnectedAt          time.Time
-	LastHeartbeat        time.Time
-	Metadata             map[string]string
-	HealthCheckInterval  time.Duration
-	JobTimeout           time.Duration
-}
-
-// IsHealthy checks if the plugin is considered healthy based on heartbeat
-func (cp *ConnectedPlugin) IsHealthy(timeout time.Duration) bool {
-	cp.mu.RLock()
-	defer cp.mu.RUnlock()
-	return time.Since(cp.LastHeartbeat) < timeout
-}
-
-// UpdateHeartbeat updates the last heartbeat timestamp
-func (cp *ConnectedPlugin) UpdateHeartbeat() {
-	cp.mu.Lock()
-	defer cp.mu.Unlock()
-	cp.LastHeartbeat = time.Now()
-}
-
-// IncActiveJobs increments active job counter
-func (cp *ConnectedPlugin) IncActiveJobs() {
-	cp.mu.Lock()
-	defer cp.mu.Unlock()
-	cp.ActiveJobs++
-}
-
-// DecActiveJobs decrements active job counter
-func (cp *ConnectedPlugin) DecActiveJobs() {
-	cp.mu.Lock()
-	defer cp.mu.Unlock()
-	if cp.ActiveJobs > 0 {
-		cp.ActiveJobs--
-	}
-}
-
-// JobTypeConfig defines configuration for a specific job type
-type JobTypeConfig struct {
-	Type              string
-	Enabled           bool
-	Priority          int
-	Interval          time.Duration
-	MaxConcurrent     int
-	Parameters        map[string]string
-	RequiredDetections []string
-	DetectionHistory   []DetectionRecord
-	ExecutionHistory   []ExecutionRecord
-}
-
-// PluginConfig holds all configuration for a plugin
-type PluginConfig struct {
-	mu                  sync.RWMutex
-	PluginID            string
-	Properties          map[string]string
-	JobTypes            map[string]*JobTypeConfig
-	MaxRetries          int
-	HealthCheckInterval time.Duration
-	JobTimeout          time.Duration
-	Environment         map[string]string
-}
-
-// GetProperty safely retrieves a configuration property
-func (pc *PluginConfig) GetProperty(key string) (string, bool) {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-	val, ok := pc.Properties[key]
-	return val, ok
-}
-
-// SetProperty safely sets a configuration property
-func (pc *PluginConfig) SetProperty(key, value string) {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	if pc.Properties == nil {
-		pc.Properties = make(map[string]string)
-	}
-	pc.Properties[key] = value
-}
-
-// GetJobTypeConfig safely retrieves job type configuration
-func (pc *PluginConfig) GetJobTypeConfig(jobType string) (*JobTypeConfig, bool) {
-	pc.mu.RLock()
-	defer pc.mu.RUnlock()
-	cfg, ok := pc.JobTypes[jobType]
-	return cfg, ok
-}
-
-// SetJobTypeConfig safely sets job type configuration
-func (pc *PluginConfig) SetJobTypeConfig(jobType string, cfg *JobTypeConfig) {
-	pc.mu.Lock()
-	defer pc.mu.Unlock()
-	if pc.JobTypes == nil {
-		pc.JobTypes = make(map[string]*JobTypeConfig)
-	}
-	pc.JobTypes[jobType] = cfg
-}
-
-// PluginHealth represents the health status of a plugin
-type PluginHealth struct {
-	mu              sync.RWMutex
-	PluginID        string
-	Status          string
-	ActiveJobs      int
-	CPUPercent      int64
-	MemoryBytes     int64
-	Timestamp       time.Time
-	JobProgressList []JobProgress
-}
-
-// JobProgress tracks progress of an executing job
-type JobProgress struct {
-	JobID           string
-	ProgressPercent float32
-	CurrentStep     string
-}
-
-// DetectionCapability describes what a plugin can detect
-type DetectionCapability struct {
-	Type              string
-	Description       string
-	MinIntervalSeconds int
-	RequiresFullScan  bool
-	OutputMetrics     []string
-}
-
-// MaintenanceCapability describes maintenance operations a plugin can perform
-type MaintenanceCapability struct {
-	Type                    string
-	Description             string
-	RequiredDetectionTypes  []string
-	EstimatedDurationSeconds int
+	return &t
 }