Merge remote-tracking branch 'origin/master' into pr11709-merge

# Conflicts:
#	weed/command/filer_remote_sync_dir.go
#	weed/command/filer_remote_sync_dir_test.go

.github/workflows/codeql.yml

@@ -27,7 +27,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.38.3
+        uses: github/codeql-action/init@v4.38.2
         # Override language selection by uncommenting this and choosing your languages
         with:
           languages: go
@@ -35,7 +35,7 @@ jobs:
       # Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
       # If this step fails, then you should remove it and run the build manually (see below).
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v4.38.3
+        uses: github/codeql-action/autobuild@v4.38.2
 
       # ℹ️ Command-line programs to run using the OS shell.
       # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -49,4 +49,4 @@ jobs:
       #     make release
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.38.3
+        uses: github/codeql-action/analyze@v4.38.2

.github/workflows/container_latest.yml

@@ -405,7 +405,7 @@ jobs:
           output: trivy-results.sarif
           exit-code: '0'
       - name: Upload Trivy scan results to GitHub Security
-        uses: github/codeql-action/upload-sarif@v4.38.3
+        uses: github/codeql-action/upload-sarif@v4.38.2
         if: always()
         with:
           sarif_file: trivy-results.sarif

.github/workflows/container_release_unified.yml

@@ -460,7 +460,7 @@ jobs:
 
       - name: Upload Trivy scan results to GitHub Security
         if: always()
-        uses: github/codeql-action/upload-sarif@v4.38.3
+        uses: github/codeql-action/upload-sarif@v4.38.2
         with:
           sarif_file: trivy-results.sarif
           category: trivy-${{ matrix.variant }}

.github/workflows/helm_ci.yml

@@ -39,7 +39,7 @@ jobs:
           check-latest: true
 
       - name: Set up chart-testing
-        uses: helm/chart-testing-action@v2.9.0
+        uses: helm/chart-testing-action@v2.8.0
 
       - name: Run chart-testing (list-changed)
         id: list-changed
@@ -1869,7 +1869,7 @@ jobs:
           echo "IMAGE_TAG=$TAG" >> $GITHUB_ENV
 
       - name: Create kind cluster
-        uses: helm/kind-action@v1.15.1
+        uses: helm/kind-action@v1.15.0
 
       - name: Verify volume resize hook security contexts
         run: |

VOLUME_SERVER_RUST_PLAN.md

@@ -169,7 +169,6 @@ seaweed-volume/
    - `--memprofile`
    - `--compactionMBps` (default 0)
    - `--maintenanceMBps` (default 0)
-   - `--compactionMaxParallelCommits` (default 0)
    - `--fileSizeLimitMB` (default 256)
    - `--concurrentUploadLimitMB` (default 0)
    - `--concurrentDownloadLimitMB` (default 0)

design-durable-volume-id-allocation.md

@@ -1,295 +0,0 @@
-# Design: Durable Volume-ID Allocation Boundary
-
-Issue: https://github.com/seaweedfs/seaweedfs/issues/11763
-
-## Problem
-
-`Topology.NextVolumeId()` allocates `GetMaxVolumeId() + 1`. The high-water
-mark is only as durable as the Raft state that carries it
-(`MaxVolumeIdCommand`), and is otherwise rebuilt from volumes reported by
-*connected* volume servers (`UpAdjustMaxVolumeId` on the heartbeat path).
-
-If the master loses its Raft state while a volume server is offline, the
-rebuilt bound misses that server's volumes. `NextVolumeId()` then reissues
-ids the offline server still holds. When the server rejoins,
-`SyncDataNodeRegistration` / `RegisterVolumeLayout` registers the duplicate
-into a different collection's layout — two live volumes now share one vid in
-different collections, and lookups become ambiguous.
-
-`IsWarmingUp()` does not help: it only covers `WarmupPulseMultiplier`
-heartbeat intervals after a leader change, and a permanently offline server
-never checks in within that window.
-
-### Invariant
-
-A volume id, once allocated, must never be reissued while any volume server
-might still hold a volume with that id. The allocation boundary must
-therefore be durable somewhere that survives master Raft-state loss, and the
-master must refuse to allocate when it cannot establish a safe boundary.
-
-## Options considered
-
-### A. Durable counter in an external store (etcd)
-
-CAS a `max_volume_id` key in etcd (clientv3 is already an indirect
-dependency via the filer store). Strictly correct and simple to reason
-about.
-
-Downsides: a new hard runtime dependency for deployments that do not already
-run etcd — including the single-master / two-volume-server topology from the
-issue, which is exactly the shape that hits this. It also does nothing for
-clusters that do not opt in.
-
-Verdict: viable as an *opt-in* backend (phase 2 below), not acceptable as
-the only fix.
-
-### B. Block growth until all previously-seen servers check in
-
-Needs a roster of previously-seen servers — which lives in the lost Raft
-state. And even with a roster, "not yet rejoined" is indistinguishable from
-"decommissioned for good", so the block can be unbounded. Verdict: rejected
-as specified; the freeze mechanism below keeps the spirit (fail closed on
-*detected* loss, operator-gated) without pretending the roster is known.
-
-### C. Federate the high-water mark to the volume servers (recommended)
-
-The bound doesn't have to live on the master at all: every volume server can
-carry a persisted copy, learned passively. The master echoes its current
-`maxVolumeId` in every heartbeat response; each server folds it into a
-durably persisted `max_volume_id_seen` and reports that value back in every
-heartbeat. The allocation bound is then `max(raft state, local mirror, every
-connected server's report)`.
-
-A permanently offline server is no longer special: while it was up, the echo
-already distributed its high vids to every *other* server, and any single
-surviving veteran restores the bound on reconnect.
-
-Verdict: recommended. No new infrastructure, monotonic by construction,
-rolling-upgrade safe.
-
-### D. Detection only (duplicate-vid alarm on registration)
-
-Cheap, useful forensics, but contains nothing — the ambiguous lookup state
-already exists by the time it fires. Verdict: include as a safety net, not
-the fix.
-
-## Design: four layers + optional external backend
-
-### L1 — Master-side synchronous mirror
-
-Write the bound to a plain file in the master meta dir *before* committing
-to Raft:
-
-- In `Topology.NextVolumeId()`, after computing `next` and before the Raft
-  apply, persist `next` to `<mdir>/max_volume_id` (write tmp + rename +
-  fsync). A Raft failure after the mirror write only over-estimates the
-  bound — a skipped vid is safe.
-- At startup (both Raft implementations), `UpAdjustMaxVolumeId(mirror)`
-  before the server can become leader.
-
-This is a one-file change of scope that already fixes every case where
-`mdir` survives (ephemeral Raft state, `-resumeState=false`, lost snapshot).
-It does not help when `mdir` itself is ephemeral — note the default is
-`os.TempDir()`, so the docs/startup warning below matter.
-
-### L2 — Federated high-water mark (core fix)
-
-Protocol additions (`master.proto`):
-
-```proto
-message Heartbeat {
-  ...
-  // Highest volume id this server has ever observed, persisted locally.
-  // Fed by HeartbeatResponse.max_volume_id echoes and by AllocateVolume
-  // requests; never decreases.
-  uint32 max_volume_id_seen = 28;
-  // Topology id of the master cluster this server last heartbeated to.
-  // Non-empty once the server has heard one echo; used to detect master
-  // state loss.
-  string last_seen_topology_id = 29;
-}
-
-message HeartbeatResponse {
-  ...
-  uint32 max_volume_id = 10;
-  string topology_id = 11;
-}
-```
-
-Volume server:
-
-- Maintain `maxVidSeen` in `Store`, bootstrapped at load time to
-  `max(local volume ids, local EC shard vids, persisted stamp)` — so even a
-  server upgraded mid-incident reports a bound covering its own holdings.
-- Persist `{max_volume_id_seen, last_seen_topology_id}` to a stamp file in
-  each volume dir (`<dir>/.vid_stamp`, JSON, write-tmp-rename-fsync).
-  Multiple dirs are independent filesystems; each keeps its own stamp and
-  the reported value is the max across them. Corrupt/missing stamp = treat
-  as 0 and log; local volume scan still floors the bound.
-- Update the stamp (monotonic CAS) on:
-  - every `HeartbeatResponse` carrying `max_volume_id` / `topology_id`;
-  - every `AllocateVolume` request, *before* the volume files are created
-    (this includes replica placements from `volume.copy` — a copied vid was
-    still allocated once, so folding it in is correct);
-  - local volume/EC-shard creation from any path.
-- Report `max_volume_id_seen` and `last_seen_topology_id` in
-  `CollectHeartbeat()`.
-
-Master:
-
-- `heartbeatResponse()` includes `MaxVolumeId: uint32(Topo.GetMaxVolumeId())`
-  and `TopologyId`.
-- On each heartbeat: `Topo.UpAdjustMaxVolumeId(heartbeat.MaxVolumeIdSeen)`
-  — monotonic, idempotent, and safe against stale or downgraded reporters.
-- Track `last_seen_topology_id` reports for L3.
-
-Safety argument: after a total master state loss, the first heartbeat from
-any veteran restores a bound ≥ every vid that was committed more than one
-echo interval before the loss, because that vid was already echoed to — and
-persisted by — every connected server. A vid committed *within* the final
-echo interval is known only to its allocate target (which stamped it before
-creating the volume), so a collision additionally requires that target to be
-the one that stays offline and to have actually received the allocation.
-Residual hole: vid committed, `AllocateVolume` delivered, then master loses
-*all* state within <1 echo interval, and that target never rejoins while a
-reissue happens. Closing that residual entirely requires synchronous
-durability the master cannot wipe — i.e. option A — which is why it stays
-on the roadmap as the strict backend.
-
-Over-reporting is harmless (skipped ids), under-reporting is the bug; every
-feed into `maxVidSeen` is an upper bound on "still possibly allocated".
-
-### L3 — State-loss detection and growth freeze
-
-`TopologyId` is already a cluster identity that survives Raft-state cleanup
-when `mdir` is kept (`recoverTopologyIdFromSnapshot`), so a *changed*
-topology id means total loss — or a foreign server. Detection: a heartbeat
-reports a non-empty `last_seen_topology_id` different from the leader's own.
-
-On detection:
-
-- Set `Topo.growthFrozen` (atomic), emit `MasterVolumeGrowthFrozen` metric
-  and an ERROR log naming the expected vs. reported topology ids.
-- `NextVolumeId()` fails with an explicit "growth frozen after master state
-  loss" error; `findAndGrow` propagates it so assign/grow RPCs fail fast
-  instead of allocating on an unproven boundary.
-- Operator clears it via `weed shell` (`volume.growth.resume`) / HTTP
-  endpoint after verifying the cluster inventory; or it auto-clears after
-  `master.volumeGrowth.stateLossRecoveryWait` when that is > 0 (default 0 =
-  manual). This is the issue's requested "block new growth until recovery"
-  made explicit rather than window-based.
-
-Genuine ambiguity remains: with no raft history and no veteran reported yet,
-"fresh cluster" and "post-loss, veterans still offline" look identical until
-the first veteran heartbeat. To keep fresh-cluster bootstrap unaffected
-while shrinking that window: when the leader self-minted a topology id with
-no recovered raft state, `NextVolumeId()` additionally waits out one
-warmup-length delay (`IsWarmingUp`-style, counted from leader election) so
-veterans get a pulse to identify themselves. A fresh cluster just grows a
-few seconds later; a wiped cluster hears a mismatch (or at minimum a raised
-`max_volume_id_seen`) inside the same window.
-
-False-positive case: a volume dir cloned into a *different* cluster reports
-a foreign topology id and freezes growth there too. That is arguably a real
-safety signal (foreign volumes are dangerous), and the escape hatch is one
-command; the freeze can also be disabled with
-`-volumeGrowth.freezeOnTopologyMismatch=false` for operators who migrate
-disks deliberately. Deleting `.vid_stamp` before repurposing a dir also
-clears the report at the source.
-
-### L4 — Duplicate-vid detection on registration
-
-Independent of L1–L3, make the collision loud instead of silent:
-
-- In `SyncDataNodeRegistration`, `IncrementalSyncDataNodeRegistration`, and
-  `ApplyVolumeChanges`, before registering `v` check whether `v.Id` is
-  already live under a *different* layout key — `(collection,
-  replicaPlacement, ttl, diskType)` — or in `ecShardMap`. Same vid across
-  replicas of one layout is normal; same vid in two layout keys is always a
-  bug.
-- On conflict: `stats.MasterDuplicateVolumeId` metric (labels: vid, both
-  collections), ERROR log naming both data nodes, and mark the newly
-  reported instance read-only via the existing `SetReplicaReadOnlyFlag`
-  machinery so an ambiguous vid stops accumulating new writes pending
-  operator resolution. The volume still registers — hiding the second copy
-  from lookups would make its data silently unreachable, which is worse
-  than ambiguous-but-alerted.
-- Add `volume.check.duplicate_ids` shell command that scans all layouts +
-  `ecShardMap` and reports conflicts, for post-incident audit of
-  already-corrupted clusters (the issue's repro produces exactly this
-  state).
-
-### Phase 2 (optional): pluggable external counter
-
-For deployments that want the strict guarantee with no residual window,
-introduce a `VolumeIdAllocator` interface used by `NextVolumeId()`:
-
-- `raft` backend: current behavior + L1 mirror (default).
-- `etcd` backend: CAS `seaweedfs/<topologyId>/max_volume_id` via clientv3
-  `Txn(If revision==r).Then(put v+1)`; retries on contention. Configured via
-  `master.volumeIdStore = "etcd"` + endpoints.
-
-With the etcd backend active, L2's echo/report still runs (it feeds
-monitoring and L4) but is no longer load-bearing. Not needed for the
-default path; scoped here so the door stays open.
-
-## Compatibility
-
-- All changes are new proto fields and new files; mixed-version clusters
-  behave exactly as today (absent `max_volume_id_seen` reports contribute
-  nothing; absent echoes leave stamps at their local bootstrap value).
-  Protection engages when both master and a given volume server run the new
-  build.
-- The bound is monotonic everywhere — no rollback risk from replayed or
-  out-of-order reports.
-- Downgrade: a master losing the new fields just rebuilds the bound from
-  live volumes as before — status quo, not a new failure mode.
-
-## Operational notes
-
-- `mdir` defaults to `os.TempDir()`, which many systems wipe on reboot —
-  the issue's "ephemeral /data" is close to the *default* configuration.
-  Add a startup warning when `mdir` resolves under the OS temp dir and
-  volumes exist, and document that persistent `mdir` is required for L1 to
-  help. L2/L3 still protect clusters where `mdir` is lost.
-- `.vid_stamp` must be excluded from volume-file globbing and preserved on
-  disk re-UUID operations.
-- Failure to persist a stamp logs loudly but does not kill the heartbeat;
-  the local volume scan bound still applies.
-
-## Test plan
-
-1. Unit (topology): mirror write/load, corrupt mirror, `NextVolumeId`
-   ordering (mirror before raft apply); `UpAdjustMaxVolumeId` from reported
-   `max_volume_id_seen`.
-2. Unit (storage): stamp bootstrap = max(local vids, EC vids, file);
-   monotonic update from echo and from `AllocateVolume`; corrupt stamp
-   tolerated.
-3. Topology integration test reproducing the issue in-process: register
-   high vids on node B, discard the topology, rebuild with only node A's
-   reports plus stamps → `NextVolumeId` must exceed B's holdings; and the
-   same test *without* stamps to prove the bug still exists absent L2.
-4. Freeze path: mismatch report → `NextVolumeId` error → resume command →
-   growth proceeds.
-5. Duplicate detection: register same vid under two collections → metric,
-   read-only mark, `volume.check.duplicate_ids` reports it.
-6. Mixed-version: heartbeat without new fields, response without new
-   fields — no panic, no behavior change.
-
-## Implementation sketch (files)
-
-- `weed/pb/master.proto`: 4 new fields (regen `master_pb`).
-- `weed/topology/topology.go`: mirror write in `NextVolumeId`; mirror load +
-  stamp-report adjust + freeze check; `growthFrozen` flag + resume API.
-- `weed/server/raft_server.go`, `raft_hashicorp.go`: load mirror at startup.
-- `weed/server/master_grpc_server.go`: echo fields in `heartbeatResponse()`;
-  consume `MaxVolumeIdSeen`/`LastSeenTopologyId` per heartbeat; duplicate
-  detection calls.
-- `weed/topology/topology.go` registration paths: pre-register duplicate
-  check (helper on Topology).
-- `weed/storage/store.go` (+ `disk_location.go`): `maxVidSeen` state, stamp
-  persistence, bootstrap, heartbeat field.
-- `weed/server/volume_grpc_admin.go`: stamp on `AllocateVolume`.
-- `weed/server/volume_grpc_client_to_master.go`: apply echoed bound.
-- `weed/shell`: `volume.growth.resume`, `volume.check.duplicate_ids`.
-- `weed/stats`: `MasterDuplicateVolumeId`, `MasterVolumeGrowthFrozen`.

go.mod

@@ -23,8 +23,8 @@ require (
 	github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 // indirect
 	github.com/facebookgo/stats v0.0.0-20151006221625-1b76add642e4
 	github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4 // indirect
-	github.com/fsnotify/fsnotify v1.10.1 // indirect
-	github.com/go-redsync/redsync/v4 v4.18.0
+	github.com/fsnotify/fsnotify v1.9.0 // indirect
+	github.com/go-redsync/redsync/v4 v4.17.0
 	github.com/go-sql-driver/mysql v1.10.1
 	github.com/go-zookeeper/zk v1.0.4 // indirect
 	github.com/golang/protobuf v1.5.4
@@ -65,7 +65,7 @@ require (
 	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/seaweedfs/goexif v1.0.3
-	github.com/seaweedfs/raft v1.2.2
+	github.com/seaweedfs/raft v1.2.1
 	github.com/sirupsen/logrus v1.9.4 // indirect
 	github.com/spf13/afero v1.15.0 // indirect
 	github.com/spf13/cast v1.10.0 // indirect
@@ -91,7 +91,7 @@ require (
 	gocloud.dev/pubsub/natspubsub v0.46.0
 	gocloud.dev/pubsub/rabbitpubsub v0.46.0
 	golang.org/x/crypto v0.58.0
-	golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297
+	golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597
 	golang.org/x/image v0.46.0
 	golang.org/x/net v0.61.0
 	golang.org/x/oauth2 v0.37.0
@@ -116,13 +116,13 @@ require (
 	github.com/DATA-DOG/go-sqlmock v1.5.2
 	github.com/Jille/raft-grpc-transport v1.6.1
 	github.com/ThreeDotsLabs/watermill v1.5.2
-	github.com/a-h/templ v0.3.1070
+	github.com/a-h/templ v0.3.1020
 	github.com/apache/cassandra-gocql-driver/v2 v2.1.2
 	github.com/apache/iceberg-go v0.7.0
 	github.com/apple/foundationdb/bindings/go v0.0.0-20250911184653-27f7192f47c3
 	github.com/arangodb/go-driver v1.6.9
 	github.com/armon/go-metrics v0.4.1
-	github.com/aws/aws-sdk-go-v2 v1.47.3
+	github.com/aws/aws-sdk-go-v2 v1.47.1
 	github.com/aws/aws-sdk-go-v2/config v1.33.6
 	github.com/aws/aws-sdk-go-v2/credentials v1.20.6
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.114.1
@@ -157,7 +157,7 @@ require (
 	github.com/twmb/avro v1.9.0
 	github.com/xeipuuv/gojsonschema v1.2.0
 	github.com/ydb-platform/ydb-go-sdk-auth-environ v0.5.3
-	github.com/ydb-platform/ydb-go-sdk/v3 v3.155.1
+	github.com/ydb-platform/ydb-go-sdk/v3 v3.151.1
 	go.etcd.io/etcd/client/pkg/v3 v3.7.1
 	go.uber.org/atomic v1.12.0
 	golang.org/x/sync v0.24.0
@@ -172,7 +172,6 @@ require (
 	cloud.google.com/go/pubsub/v2 v2.6.0 // indirect
 	dario.cat/mergo v1.0.2 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/keyvault/internal v0.7.1 // indirect
-	github.com/Azure/azure-sdk-for-go/sdk/storage/internal v0.1.0 // indirect
 	github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c // indirect
 	github.com/FilenCloudDienste/filen-sdk-go v0.0.39 // indirect
 	github.com/ProtonMail/gopenpgp/v3 v3.4.1 // indirect
@@ -294,10 +293,10 @@ require (
 	cloud.google.com/go/iam v1.12.0 // indirect
 	cloud.google.com/go/monitoring v1.30.0 // indirect
 	filippo.io/edwards25519 v1.2.0 // indirect
-	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.2
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.1
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.14.1
 	github.com/Azure/azure-sdk-for-go/sdk/internal v1.12.0 // indirect
-	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.2
+	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.0
 	github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.7.0 // indirect
 	github.com/Azure/go-ntlmssp v0.1.1 // indirect
 	github.com/AzureAD/microsoft-authentication-library-for-go v1.8.0 // indirect
@@ -314,7 +313,7 @@ require (
 	github.com/ProtonMail/go-srp v0.0.7 // indirect
 	github.com/PuerkitoBio/goquery v1.12.0 // indirect
 	github.com/abbot/go-http-auth v0.4.0 // indirect
-	github.com/andybalholm/brotli v1.2.6 // indirect
+	github.com/andybalholm/brotli v1.2.3 // indirect
 	github.com/andybalholm/cascadia v1.3.4 // indirect
 	github.com/appscode/go-querystring v0.0.0-20170504095604-0126cfb3f1dc // indirect
 	github.com/arangodb/go-velocypack v0.0.0-20200318135517-5af53c29c67e // indirect
@@ -333,7 +332,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/sso v1.38.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.1 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.51.1
-	github.com/aws/smithy-go v1.28.5
+	github.com/aws/smithy-go v1.28.1
 	github.com/boltdb/bolt v1.3.1 // indirect
 	github.com/bradenaw/juniper v0.15.3 // indirect
 	github.com/buengese/sgzip v0.1.1 // indirect

go.sum

@@ -34,8 +34,8 @@ filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo=
 filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6 h1:He8afgbRMd7mFxO99hRNu+6tazq8nFF9lIwo9JFroBk=
 github.com/AdaLogics/go-fuzz-headers v0.0.0-20240806141605-e8a1dd7889d6/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.2 h1:utpeoEeZjd+A8J41zvoLsOOrqXHhX1Kx/X/tCW9dEYQ=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.2/go.mod h1:iptorS+VYKFL2N6PnebpS91dubG35eAOEERnT4PJbQU=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.1 h1:zvXfGJCWvywnCA814d8ZiVyt+fm9nnTE8xSb99zRyfo=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.23.1/go.mod h1:iptorS+VYKFL2N6PnebpS91dubG35eAOEERnT4PJbQU=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.14.1 h1:u93s+zU2JD62im61Bm5CZIc1ZrOJaIAWEg0WOrMVkEo=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.14.1/go.mod h1:oXtinPO4OLj9d1DOTrqrL1oRwGhcqadvAmrl6wTeGlk=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.4.0 h1:xFaZZ+IubdftrDHnGGwZ6QvQ3KHTtWl2MCK+GMt2vxs=
@@ -48,12 +48,10 @@ github.com/Azure/azure-sdk-for-go/sdk/keyvault/internal v0.7.1 h1:FbH3BbSb4bvGlu
 github.com/Azure/azure-sdk-for-go/sdk/keyvault/internal v0.7.1/go.mod h1:9V2j0jn9jDEkCkv8w/bKTNppX/d0FVA1ud77xCIP4KA=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1 h1:/Zt+cDPnpC3OVDm/JKLOs7M2DKmLRIIp3XIx9pHHiig=
 github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1/go.mod h1:Ng3urmn6dYe8gnbCMoHHVl5APYz2txho3koEkV2o2HA=
-github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.2 h1:tQJdgQjbKKffEiMOKJmcQPkY01eFHRqWIZVefqP44nI=
-github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.2/go.mod h1:kTkpJchXAdO7LGkKZP97a+Ou8TgaF4NT6MHwOIy5uSQ=
+github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.0 h1:irsmOWwkp0KCTTNS5e2hdFeIvSQClQo2No3IaNmL3Vw=
+github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.8.0/go.mod h1:GWcBkQj3MqN7ozHKLaCCAuNLiXoIGv2RtanfAwSjY/Y=
 github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.7.0 h1:cuiKf1UVyWHu+XSQghPZR/qEF43JIcuk2CDqMlPiT6M=
 github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.7.0/go.mod h1:9JSyvgXLPAOC4jfhgZg58XeU2FJHsGmxuYSclCFQ4ZY=
-github.com/Azure/azure-sdk-for-go/sdk/storage/internal v0.1.0 h1:X/bTwe0qpvmvPPutc+LWo7T4cKMqDP9JHP4k+Co9ZB4=
-github.com/Azure/azure-sdk-for-go/sdk/storage/internal v0.1.0/go.mod h1:+kX7ahyFelQ42F3RScM2CFgHJljp0phc/FieKLYVpFI=
 github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c h1:udKWzYgxTojEKWjV8V+WSxDXJ4NFATAsZjh8iIbsQIg=
 github.com/Azure/go-ansiterm v0.0.0-20250102033503-faa5f7b0171c/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
 github.com/Azure/go-ntlmssp v0.1.1 h1:l+FM/EEMb0U9QZE7mKNEDw5Mu3mFiaa2GKOoTSsNDPw=
@@ -120,8 +118,8 @@ github.com/ThreeDotsLabs/watermill v1.5.2 h1:0ES33Eq1jEsP/pWvtE4n8bE0bs+9Jq7boT7
 github.com/ThreeDotsLabs/watermill v1.5.2/go.mod h1:i9/968UriGphWfEbfMuYSD1qFbYRjb0mE0r+rV0FPp4=
 github.com/TomiHiltunen/geohash-golang v0.0.0-20150112065804-b3e4e625abfb h1:wumPkzt4zaxO4rHPBrjDK8iZMR41C1qs7njNqlacwQg=
 github.com/TomiHiltunen/geohash-golang v0.0.0-20150112065804-b3e4e625abfb/go.mod h1:QiYsIBRQEO+Z4Rz7GoI+dsHVneZNONvhczuA+llOZNM=
-github.com/a-h/templ v0.3.1070 h1:3iCOXHXqFXa99OQzgkUOLJbNzv/QjFGLwKZkBAg+ADA=
-github.com/a-h/templ v0.3.1070/go.mod h1:iIqB3g2RHBe/WlnPwa+Bvhh1TKXHWLRnBD9NWHOLm78=
+github.com/a-h/templ v0.3.1020 h1:ypAT/L5ySWEnZ6Zft/5yfoWXYYkhFNvEFOeeqecg4tw=
+github.com/a-h/templ v0.3.1020/go.mod h1:A2DlK61v+K+NRoGnhmYbNYVmtYHcFO5/AisMvBdDxTM=
 github.com/a1ex3/zstd-seekable-format-go/pkg v0.10.0 h1:iLDOF0rdGTrol/q8OfPIIs5kLD8XvA2q75o6Uq/tgak=
 github.com/a1ex3/zstd-seekable-format-go/pkg v0.10.0/go.mod h1:DrEWcQJjz7t5iF2duaiyhg4jyoF0kxOD6LtECNGkZ/Q=
 github.com/aalpar/deheap v1.1.2 h1:MABHLcnjqsffb8GLkUFDigqpBBxOMz0DoKM9QfELeTw=
@@ -144,8 +142,8 @@ github.com/alexbrainman/sspi v0.0.0-20250919150558-7d374ff0d59e h1:4dAU9FXIyQktp
 github.com/alexbrainman/sspi v0.0.0-20250919150558-7d374ff0d59e/go.mod h1:cEWa1LVoE5KvSD9ONXsZrj0z6KqySlCCNKHlLzbqAt4=
 github.com/anchore/go-lzo v0.1.1 h1:IwL/fvkdtlIrYIXck6WxZ3nb8WjjHziYYmGxlooyOnM=
 github.com/anchore/go-lzo v0.1.1/go.mod h1:3kLx0bve2oN1iDwgM1U5zGku1Tfbdb0No5qp1eL1fIk=
-github.com/andybalholm/brotli v1.2.6 h1:ftYnfj6usCp+UGV5kSJ3+chpMQgU+gJf/AxsUQ52REI=
-github.com/andybalholm/brotli v1.2.6/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
+github.com/andybalholm/brotli v1.2.3 h1:8H1qwOkl2LPfjf3YezB90JnCliZb6SInJ/OJkEbA5NQ=
+github.com/andybalholm/brotli v1.2.3/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
 github.com/andybalholm/cascadia v1.3.4 h1:vM2lgh0Vru9Vwyfm4cQqWP2HHMW0u0+2PAW7Q38Qufg=
 github.com/andybalholm/cascadia v1.3.4/go.mod h1:BLRmbRjpEtNKieZOCCvYj4RqN+KRA41GBe/5O+G93kM=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
@@ -173,8 +171,8 @@ github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJ
 github.com/armon/go-metrics v0.4.1/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4=
 github.com/aws/aws-sdk-go v1.55.8 h1:JRmEUbU52aJQZ2AjX4q4Wu7t4uZjOu71uyNmaWlUkJQ=
 github.com/aws/aws-sdk-go v1.55.8/go.mod h1:ZkViS9AqA6otK+JBBNH2++sx1sgxrPKcSzPPvQkUtXk=
-github.com/aws/aws-sdk-go-v2 v1.47.3 h1:HRoT/MkNi3bjO5xF4dCzLzvVmkvRGHj3/cLINDnJejk=
-github.com/aws/aws-sdk-go-v2 v1.47.3/go.mod h1:xSl+OSI5ZUw6bSMupWc218zE5Pl+65MCCu3ySWFY99A=
+github.com/aws/aws-sdk-go-v2 v1.47.1 h1:uOIZnp4PK3ZhKI0dNrJrhTEsLxbpXHTAJlwoS1pvAtw=
+github.com/aws/aws-sdk-go-v2 v1.47.1/go.mod h1:bttEH6JqnUL8LepvDVfdrds/fZ5bCIxzpe3abyUrhDU=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20 h1:GPRlPwz40I2B2VrBEASOA3Bi77NyeqejNLkifosX0rs=
 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.20/go.mod h1:g7PNzKcsOKWb4fkSRBA7BZVAS6Y8IcxzN+nRohhQ1Q8=
 github.com/aws/aws-sdk-go-v2/config v1.33.6 h1:MBjkSTLczek/UgiK+EYPIoRTqE7gP8vtW3OFbFo7Nug=
@@ -215,8 +213,8 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.1 h1:orIWdNiLgzrhu/11RcPPKO/S
 github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.1/go.mod h1:skwM/xsbR/1ReUTesv9BhpJp1VjajR7DWQnuVLwiXsQ=
 github.com/aws/aws-sdk-go-v2/service/sts v1.51.1 h1:0HOqZXRvMytH6bFHVIc0oJX07sZjfhz0zXtjs6gdE8s=
 github.com/aws/aws-sdk-go-v2/service/sts v1.51.1/go.mod h1:26zA0GhDrLo+yiLI2yXWxqB1PdsShfLikoI7GOEgugM=
-github.com/aws/smithy-go v1.28.5 h1:OqbqKtzY9NUnr2yAe9+hiTdFb20tNaK/lI0PMOGXX9k=
-github.com/aws/smithy-go v1.28.5/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
+github.com/aws/smithy-go v1.28.1 h1:R/nXH00c8qcfCzQVELtRw+eLQWtzv+VAIEFJ1/xxXlQ=
+github.com/aws/smithy-go v1.28.1/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
 github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk=
 github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg=
 github.com/bazelbuild/rules_go v0.46.0 h1:CTefzjN/D3Cdn3rkrM6qMWuQj59OBcuOjyIp3m4hZ7s=
@@ -464,8 +462,8 @@ github.com/fsnotify/fsevents v0.2.0 h1:BRlvlqjvNTfogHfeBOFvSC9N0Ddy+wzQCQukyoD7o
 github.com/fsnotify/fsevents v0.2.0/go.mod h1:B3eEk39i4hz8y1zaWS/wPrAP4O6wkIl7HQwKBr1qH/w=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
-github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
-github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 github.com/fvbommel/sortorder v1.1.0 h1:fUmoe+HLsBTctBDoaBwpQo5N+nrCp8g/BjKb/6ZQmYw=
 github.com/fvbommel/sortorder v1.1.0/go.mod h1:uk88iVf1ovNn1iLfgUVU2F9o5eO30ui720w+kxuqRs0=
 github.com/gabriel-vasile/mimetype v1.4.13 h1:46nXokslUBsAJE/wMsp5gtO500a4F3Nkz9Ufpk2AcUM=
@@ -529,8 +527,8 @@ github.com/go-redis/redis/v7 v7.4.1 h1:PASvf36gyUpr2zdOUS/9Zqc80GbM+9BDyiJSJDDOr
 github.com/go-redis/redis/v7 v7.4.1/go.mod h1:JDNMw23GTyLNC4GZu9njt15ctBQVn7xjRfnwdHj/Dcg=
 github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
 github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
-github.com/go-redsync/redsync/v4 v4.18.0 h1:DDM09PEhmNTf/vziolf2x6391y1hHxF5vQ4ytHl9xQc=
-github.com/go-redsync/redsync/v4 v4.18.0/go.mod h1:yuoqcQ55FS1VypSeVTMqFsJqTdWpEH5eA4MQGKJ9c4M=
+github.com/go-redsync/redsync/v4 v4.17.0 h1:FFJ+uxZs44y4Sq10//IFKic9T94AYl+u3Sog98AHzBo=
+github.com/go-redsync/redsync/v4 v4.17.0/go.mod h1:CKVA6qwT07S/916i+Yd9h1/8YFQhCCpPYTQhvvYytJo=
 github.com/go-resty/resty/v2 v2.17.2 h1:FQW5oHYcIlkCNrMD2lloGScxcHJ0gkjshV3qcQAyHQk=
 github.com/go-resty/resty/v2 v2.17.2/go.mod h1:kCKZ3wWmwJaNc7S29BRtUhJwy7iqmn+2mLtQrOyQlVA=
 github.com/go-sql-driver/mysql v1.10.1 h1:arlSnNLq6a5yxGxV7qg9lF4j0C+KwD6NbQyKr9QL6ME=
@@ -1065,10 +1063,10 @@ github.com/rdleal/intervalst v1.5.0 h1:SEB9bCFz5IqD1yhfH1Wv8IBnY/JQxDplwkxHjT6ha
 github.com/rdleal/intervalst v1.5.0/go.mod h1:xO89Z6BC+LQDH+IPQQw/OESt5UADgFD41tYMUINGpxQ=
 github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0=
 github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4=
-github.com/redis/rueidis v1.0.77 h1:ZR41bgJcm7oRFb3aSDPrRhC0eonDSrPzjvvZvHIlNjM=
-github.com/redis/rueidis v1.0.77/go.mod h1:L8mnCQJJaSNL6I4pIR6Rz732HTGS9vmuXm0yT9dRvjo=
-github.com/redis/rueidis/rueidiscompat v1.0.77 h1:S1xiLQsFv8XQ46e0LelC8ihGqbDzVRocXXZLzVAeh64=
-github.com/redis/rueidis/rueidiscompat v1.0.77/go.mod h1:aXCvRVUTvTHZY0owHuz9JjveO1hyuzyDWrpJh8/E3Ds=
+github.com/redis/rueidis v1.0.76 h1:RdDWuvlYBSp+bTrBvaXqJnNEL3VVzsnjo+0psPFgLc4=
+github.com/redis/rueidis v1.0.76/go.mod h1:UsfHPSbomB6QAVMk4iiFkzRy0nh9o7scDGa+SitvBY4=
+github.com/redis/rueidis/rueidiscompat v1.0.76 h1:7LikbiqCQqCsZXeZ+akgZMnjIV/J0VHih9PIX4gGZC4=
+github.com/redis/rueidis/rueidiscompat v1.0.76/go.mod h1:UatQQLVj4QMIsZtpvRWY28qm6r2d72idhcS+C/RM+Zg=
 github.com/rekby/fixenv v0.6.1 h1:jUFiSPpajT4WY2cYuc++7Y1zWrnCxnovGCIX72PZniM=
 github.com/rekby/fixenv v0.6.1/go.mod h1:/b5LRc06BYJtslRtHKxsPWFT/ySpHV+rWvzTg+XWk4c=
 github.com/relvacode/iso8601 v1.7.0 h1:BXy+V60stMP6cpswc+a93Mq3e65PfXCgDFfhvNNGrdo=
@@ -1108,8 +1106,6 @@ github.com/seaweedfs/goexif v1.0.3 h1:ve/OjI7dxPW8X9YQsv3JuVMaxEyF9Rvfd04ouL+Bz3
 github.com/seaweedfs/goexif v1.0.3/go.mod h1:Oni780Z236sXpIQzk1XoJlTwqrJ02smEin9zQeff7Fk=
 github.com/seaweedfs/raft v1.2.1 h1:QgFl/aaPnagpUxYB6Bx+fFss1NyetVVcJmraMmnaQ5Q=
 github.com/seaweedfs/raft v1.2.1/go.mod h1:fgs/rAVEzjQ7e04XMzG3eJhwZZRmBW+2uRtjakeCGeU=
-github.com/seaweedfs/raft v1.2.2 h1:5OiCQbia7J83WE0whlRGj5oBCEfixqfoOTOeY1IQDXM=
-github.com/seaweedfs/raft v1.2.2/go.mod h1:fgs/rAVEzjQ7e04XMzG3eJhwZZRmBW+2uRtjakeCGeU=
 github.com/secure-systems-lab/go-securesystemslib v0.11.0 h1:iuCR9kcMFD4QurdKrGvPLoKZLv9YvwPYVr0473BdtFs=
 github.com/secure-systems-lab/go-securesystemslib v0.11.0/go.mod h1:+PMOTjUGwHj2vcZ+TFKlb1tXRbrdWE1LYDT5i9JC80Q=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
@@ -1321,8 +1317,8 @@ github.com/ydb-platform/ydb-go-genproto v0.0.0-20260810122915-65bfd5c4b705 h1:7V
 github.com/ydb-platform/ydb-go-genproto v0.0.0-20260810122915-65bfd5c4b705/go.mod h1:Er+FePu1dNUieD+XTMDduGpQuCPssK5Q4BjF+IIXJ3I=
 github.com/ydb-platform/ydb-go-sdk-auth-environ v0.5.3 h1:A48PcmIETWwbEMIGwndv52uME6J1eJ28MBgF7HVR74o=
 github.com/ydb-platform/ydb-go-sdk-auth-environ v0.5.3/go.mod h1:oRGF+67GWLbtNzqGygsPIUsjXmsRXD1KS5m3o5ppm2k=
-github.com/ydb-platform/ydb-go-sdk/v3 v3.155.1 h1:ZMByYe53zZ9R1o23fxJsbNhjzKFQkzpXm6uGj8gWHXQ=
-github.com/ydb-platform/ydb-go-sdk/v3 v3.155.1/go.mod h1:dJXJ1u00IqO8Vsph8fWmYj8b1E7jyphnvJPqA69emBY=
+github.com/ydb-platform/ydb-go-sdk/v3 v3.151.1 h1:T+fB2ZDHpYIGC7DWjK+rzZHLoexBF0zG/n3Q9DGNskY=
+github.com/ydb-platform/ydb-go-sdk/v3 v3.151.1/go.mod h1:dJXJ1u00IqO8Vsph8fWmYj8b1E7jyphnvJPqA69emBY=
 github.com/ydb-platform/ydb-go-yc v0.12.5 h1:qYIeU1N6a92FaDA0+/vR55l5IzRF50MeLZwUWwvy2xQ=
 github.com/ydb-platform/ydb-go-yc v0.12.5/go.mod h1:DlSltVQKEdXJotaAYwoHzMGDF9EJw5S3hg3LXe/5yYw=
 github.com/ydb-platform/ydb-go-yc-metadata v0.6.2 h1:CZFawwHjLcjsxcl/g0dGIXbI2r41okPGLCydF4qTHcc=
@@ -1451,8 +1447,8 @@ golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf
 golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
 golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297 h1:YXnL44eJ77R+ji4/ooy8UsXIhz+lbi2Qgdlc8iRN0gY=
-golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297/go.mod h1:Mkmymgv+uMpSQ/XxJ/7GpdrdYoqm3u72jEbpCLiJmNk=
+golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597 h1:qLvzZeaANDgyVOA8pyHCOStGlXn0rseXma+GQjeuv2g=
+golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597/go.mod h1:EdfpwwqSu+0Li0mzskwHU6FWDV3t9Q+RZDo3QMUtL3Q=
 golang.org/x/image v0.46.0 h1:b1+oYj0Jbp6K5MDT4i4/eZpYlk3V8SJhhDKh6LBHAyQ=
 golang.org/x/image v0.46.0/go.mod h1:3B3W05VGVQyuXucLINLjXKrqISASfi4Xj+iCVkLMwew=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=

k8s/charts/seaweedfs/templates/shared/post-install-bucket-hook.yaml

@@ -18,17 +18,9 @@
 {{- $clusterFilerKey := printf "WEED_CLUSTER_%s_FILER" $clusterUpper }}
 {{- $podSecurityContext := .Values.filer.podSecurityContext }}
 {{- $containerSecurityContext := .Values.filer.containerSecurityContext }}
-{{- $nodeSelector := .Values.filer.nodeSelector }}
-{{- $tolerations := .Values.filer.tolerations }}
-{{- $createBucketsHook := .Values.filer.s3.createBucketsHook }}
 {{- if .Values.allInOne.enabled }}
   {{- $podSecurityContext = .Values.allInOne.podSecurityContext }}
   {{- $containerSecurityContext = .Values.allInOne.containerSecurityContext }}
-  {{- $nodeSelector = .Values.allInOne.nodeSelector }}
-  {{- $tolerations = .Values.allInOne.tolerations }}
-  {{- $createBucketsHook = .Values.allInOne.s3.createBucketsHook }}
-{{- else if .Values.s3.createBuckets }}
-  {{- $createBucketsHook = .Values.s3.createBucketsHook }}
 {{- end }}
 
 {{- /* Check allInOne mode first */}}
@@ -84,18 +76,10 @@ spec:
         app.kubernetes.io/instance: {{ .Release.Name | quote }}
         app.kubernetes.io/component: bucket-hook
     spec:
-      {{- with $createBucketsHook.affinity }}
-      affinity:
-        {{ tpl . $ | indent 8 | trim }}
-      {{- end }}
       restartPolicy: Never
       {{- if $podSecurityContext.enabled }}
       securityContext: {{- omit $podSecurityContext "enabled" | toYaml | nindent 8 }}
       {{- end }}
-      {{- with coalesce $createBucketsHook.tolerations $tolerations }}
-      tolerations:
-        {{ tpl . $ | indent 8 | trim }}
-      {{- end }}
       {{- include "seaweedfs.imagePullSecrets" $ | nindent 6 }}
       containers:
       - name: post-install-job
@@ -290,8 +274,4 @@ spec:
             secretName: {{ include "seaweedfs.fullname" . }}-client-cert
         {{- end }}
     {{- end }}
-      {{- with coalesce $createBucketsHook.nodeSelector $nodeSelector }}
-      nodeSelector:
-        {{ tpl . $ | indent 8 | trim }}
-      {{- end }}
 {{- end }}

k8s/charts/seaweedfs/templates/volume/volume-resize-hook.yaml

@@ -30,19 +30,11 @@ spec:
         app.kubernetes.io/instance: {{ .Release.Name | quote }}
         app.kubernetes.io/component: volume-resize-hook
     spec:
-      {{- with .Values.volume.resizeHook.affinity }}
-      affinity:
-        {{ tpl (printf "{{ $volumeName := \"volume\" }}%s" .) $ | indent 8 | trim }}
-      {{- end }}
       serviceAccountName: {{ $seaweedfsName }}-volume-resize-hook
       restartPolicy: Never
       {{- if .Values.volume.podSecurityContext.enabled }}
       securityContext: {{- omit .Values.volume.podSecurityContext "enabled" | toYaml | nindent 8 }}
       {{- end }}
-      {{- with coalesce .Values.volume.resizeHook.tolerations .Values.volume.tolerations }}
-      tolerations:
-        {{ tpl (printf "{{ $volumeName := \"volume\" }}%s" .) $ | indent 8 | trim }}
-      {{- end }}
       containers:
         - name: resize
           image: {{ .Values.volume.resizeHook.image }}
@@ -66,10 +58,6 @@ spec:
       volumes:
         {{- include "seaweedfs.tmpDirVolume" (list . .Values.volume.containerSecurityContext "" "" false) | nindent 8 }}
       {{- end }}
-      {{- with coalesce .Values.volume.resizeHook.nodeSelector .Values.volume.nodeSelector }}
-      nodeSelector:
-        {{ tpl (printf "{{ $volumeName := \"volume\" }}%s" .) $ | indent 8 | trim }}
-      {{- end }}
 ---
 apiVersion: v1
 kind: ServiceAccount

k8s/charts/seaweedfs/values.yaml

@@ -437,10 +437,6 @@ volume:
   resizeHook:
     enabled: true
     image: alpine/k8s:1.28.4
-    # nodeSelector and tolerations fall back to the volume server's when unset
-    nodeSelector: ""
-    tolerations: ""
-    affinity: ""
 
   # idx (the volume index) may use a separate PERSISTENT volume:
   #
@@ -1087,10 +1083,6 @@ filer:
     #     anonymousRead: false
     createBucketsHook:
       resources: {}
-      # nodeSelector and tolerations fall back to filer's when unset
-      nodeSelector: ""
-      tolerations: ""
-      affinity: ""
 
 s3:
   enabled: false
@@ -1313,10 +1305,6 @@ s3:
 
   createBucketsHook:
     resources: {}
-    # nodeSelector and tolerations fall back to filer's when unset
-    nodeSelector: ""
-    tolerations: ""
-    affinity: ""
 
   ingress:
     enabled: false
@@ -1939,10 +1927,6 @@ allInOne:
     #     anonymousRead: false
     createBucketsHook:
       resources: {}
-      # nodeSelector and tolerations fall back to allInOne's when unset
-      nodeSelector: ""
-      tolerations: ""
-      affinity: ""
 
   # SFTP server configuration
   # Note: Most parameters below default to null, which means they inherit from

other/java/client/src/main/proto/filer.proto

@@ -527,10 +527,6 @@ message AtomicRenameEntryRequest {
     string new_directory = 3;
     string new_name = 4;
     repeated int32 signatures = 5;
-    // When true, the rename fails with ErrEntryAlreadyExists if the target
-    // already exists. Lets a caller that authorized the rename without delete
-    // access on an absent target stay safe if one is created concurrently.
-    bool fail_if_target_exists = 6;
 }
 
 message AtomicRenameEntryResponse {

seaweed-volume/Cargo.lock

@@ -234,9 +234,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.18.1"
+version = "1.16.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e"
+checksum = "a054912289d18629dc78375ba2c3726a3afe3ff71b4edba9dedfca0e3446d1fc"
 dependencies = [
  "aws-lc-sys",
  "zeroize",
@@ -244,15 +244,14 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.45.0"
+version = "0.39.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bff6c3b54fad79a2e60b8102caf565819711497c1f5f092f49508e2f5c31b27"
+checksum = "83a25cf98105baa966497416dbd42565ce3a8cf8dbfd59803ec9ad46f3126399"
 dependencies = [
  "cc",
  "cmake",
  "dunce",
  "fs_extra",
- "pkg-config",
 ]
 
 [[package]]
@@ -2678,12 +2677,6 @@ dependencies = [
  "spki 0.7.3",
 ]
 
-[[package]]
-name = "pkg-config"
-version = "0.3.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
-
 [[package]]
 name = "png"
 version = "0.18.1"
@@ -3396,9 +3389,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.45"
+version = "0.23.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
+checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
 dependencies = [
  "aws-lc-rs",
  "log",
@@ -3443,9 +3436,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.15"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
 dependencies = [
  "aws-lc-rs",
  "ring",

seaweed-volume/README.md

@@ -64,7 +64,6 @@ seaweed-volume --port 8080 --master localhost:9333 --dir /data/vol1 --max 7 \
 | `--whiteList` | | Comma-separated IPs with write permission |
 | `--preStopSeconds` | `10` | Graceful drain period before shutdown |
 | `--compactionMBps` | `0` (unlimited) | Compaction I/O rate limit |
-| `--compactionMaxParallelCommits` | `0` (unlimited) | Max concurrent vacuum commits |
 | `--pprof` | `false` | Enable pprof HTTP handlers |
 
 Set `RUST_LOG=debug` (or `trace`, `info`, `warn`) for log level control.

seaweed-volume/proto/master.proto

@@ -59,8 +59,6 @@ service Seaweed {
   }
   rpc RaftLeadershipTransfer (RaftLeadershipTransferRequest) returns (RaftLeadershipTransferResponse) {
   }
-  rpc ResumeVolumeGrowth (ResumeVolumeGrowthRequest) returns (ResumeVolumeGrowthResponse) {
-  }
   rpc VolumeGrow (VolumeGrowRequest) returns (VolumeGrowResponse) {
   }
   rpc CollectionStatistics (CollectionStatisticsRequest) returns (CollectionStatisticsResponse) {
@@ -121,12 +119,6 @@ message Heartbeat {
   // place of `volumes`. A master that does not understand this never sets
   // volume_digest_supported, so it keeps being sent the whole list.
   repeated VolumeInformationMessage changed_volumes = 28;
-
-  // Highest volume id this server has ever observed, persisted locally. Fed
-  // by HeartbeatResponse.max_volume_id echoes and by AllocateVolume requests.
-  uint32 max_volume_id_seen = 29;
-  // Topology id of the master cluster this server last heartbeated to.
-  string last_seen_topology_id = 30;
 }
 
 message HeartbeatResponse {
@@ -143,12 +135,6 @@ message HeartbeatResponse {
   // The master compares volume digests, so a server that reports one may send
   // changed_volumes in place of its whole list.
   bool volume_digest_supported = 9;
-  // The leader's current allocation bound; servers persist it and report it
-  // back as max_volume_id_seen so the bound survives master state loss.
-  uint32 max_volume_id = 10;
-  // The leader's cluster identity; a different value reported back later
-  // means the master's state was rebuilt.
-  string topology_id = 11;
 }
 
 message VolumeInformationMessage {
@@ -319,18 +305,6 @@ message VolumeGrowRequest {
   string data_node = 7;
   uint32 memory_map_max_size_mb = 8;
   string disk_type = 9;
-  // If > 0, grow only when the average fill ratio of the layout's writable
-  // volumes has reached this threshold (e.g. 0.6). Lets callers pre-grow on
-  // fill level with one call, instead of listing volumes to compute the
-  // ratio themselves. Ignored when there are no writable volumes.
-  float grow_avg_fill_threshold = 10;
-}
-
-message ResumeVolumeGrowthRequest {
-}
-
-message ResumeVolumeGrowthResponse {
-  bool was_frozen = 1;
 }
 
 message AssignResponse {
@@ -637,9 +611,4 @@ message RaftLeadershipTransferResponse {
 }
 
 message VolumeGrowResponse {
-  // Average fill ratio of the layout's writable volumes at request time
-  // (0 when there are none). Reported whether or not growth was triggered.
-  float avg_fill = 1;
-  // Number of writable volumes at request time.
-  uint32 writable_count = 2;
 }

seaweed-volume/proto/volume_server.proto

@@ -571,7 +571,6 @@ message ReadVolumeFileStatusResponse {
     string disk_type = 9;
     VolumeInfo volume_info = 10;
     uint32 version = 11;
-    uint64 expire_at_sec = 12; // TTL expiry counted from the last write; 0 when the volume never expires
 }
 
 message DiskStatus {

seaweed-volume/src/config.rs

@@ -125,11 +125,6 @@ pub struct Cli {
     #[arg(long = "maintenanceMBps", default_value_t = 0)]
     pub maintenance_mb_per_second: u32,
 
-    /// Limit how many vacuum commits run at once on this server; queued
-    /// commits hold no volume lock. 0 means unlimited.
-    #[arg(long = "compactionMaxParallelCommits", default_value_t = 0)]
-    pub max_parallel_vacuum_commits: usize,
-
     /// Limit file size to avoid out of memory.
     #[arg(long = "fileSizeLimitMB", default_value_t = 256)]
     pub file_size_limit_mb: u32,
@@ -268,8 +263,6 @@ pub struct VolumeServerConfig {
     pub mem_profile: String,
     pub compaction_byte_per_second: i64,
     pub maintenance_byte_per_second: i64,
-    /// Max concurrent vacuum commits; 0 means unlimited.
-    pub max_parallel_vacuum_commits: usize,
     pub file_size_limit_bytes: i64,
     pub concurrent_upload_limit: i64,
     pub concurrent_download_limit: i64,
@@ -934,7 +927,6 @@ fn resolve_config_with_env(cli: Cli, env: EnvLookup<'_>) -> VolumeServerConfig {
         mem_profile: cli.mem_profile,
         compaction_byte_per_second: cli.compaction_mb_per_second as i64 * 1024 * 1024,
         maintenance_byte_per_second: cli.maintenance_mb_per_second as i64 * 1024 * 1024,
-        max_parallel_vacuum_commits: cli.max_parallel_vacuum_commits,
         file_size_limit_bytes: cli.file_size_limit_mb as i64 * 1024 * 1024,
         concurrent_upload_limit: cli.concurrent_upload_limit_mb as i64 * 1024 * 1024,
         concurrent_download_limit: cli.concurrent_download_limit_mb as i64 * 1024 * 1024,

seaweed-volume/src/main.rs

@@ -340,14 +340,6 @@ async fn run(
         rack: config.rack.clone(),
         file_size_limit_bytes: config.file_size_limit_bytes,
         maintenance_byte_per_second: config.maintenance_byte_per_second,
-        vacuum_commit_slots: if config.max_parallel_vacuum_commits > 0 {
-            Some(tokio::sync::Semaphore::new(
-                config.max_parallel_vacuum_commits,
-            ))
-        } else {
-            None
-        },
-        vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
         // Go sets isHeartbeating: true unconditionally at startup
         is_heartbeating: std::sync::atomic::AtomicBool::new(true),
         has_master: !config.masters.is_empty(),

seaweed-volume/src/server/grpc_client.rs

@@ -397,7 +397,6 @@ mod tests {
             mem_profile: String::new(),
             compaction_byte_per_second: 0,
             maintenance_byte_per_second: 0,
-            max_parallel_vacuum_commits: 0,
             file_size_limit_bytes: 0,
             concurrent_upload_limit: 0,
             concurrent_download_limit: 0,

seaweed-volume/src/server/grpc_server.rs

@@ -53,29 +53,6 @@ fn needle_not_found(needle_id: NeedleId) -> Status {
     Status::not_found(format!("needle not found {}", needle_id.0))
 }
 
-/// Deadline from the caller's `grpc-timeout` header (TimeoutValue +
-/// H|M|S|m|u|n unit, per the gRPC-over-HTTP2 spec). Tonic's GrpcTimeout layer
-/// drops an over-deadline handler future anyway; parsing it here lets a queued
-/// vacuum commit refuse politely instead of being dropped mid-wait.
-fn grpc_timeout_deadline<T>(request: &Request<T>) -> Option<tokio::time::Instant> {
-    let value = request.metadata().get("grpc-timeout")?.to_str().ok()?;
-    let (digits, unit) = value.split_at(value.len().checked_sub(1)?);
-    if digits.len() > 8 {
-        return None;
-    }
-    let n: u64 = digits.parse().ok()?;
-    let dur = match unit {
-        "H" => std::time::Duration::from_secs(n * 60 * 60),
-        "M" => std::time::Duration::from_secs(n * 60),
-        "S" => std::time::Duration::from_secs(n),
-        "m" => std::time::Duration::from_millis(n),
-        "u" => std::time::Duration::from_micros(n),
-        "n" => std::time::Duration::from_nanos(n),
-        _ => return None,
-    };
-    Some(tokio::time::Instant::now() + dur)
-}
-
 fn unix_now_seconds() -> f64 {
     std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
@@ -1285,12 +1262,8 @@ impl VolumeServer for VolumeGrpcService {
     ) -> Result<Response<volume_server_pb::VacuumVolumeCommitResponse>, Status> {
         self.check_grpc_admin_auth(&request)?;
         self.state.check_maintenance()?;
-        let deadline = grpc_timeout_deadline(&request);
         let vid = VolumeId(request.into_inner().volume_id);
 
-        let _permit = self.state.acquire_vacuum_commit_slot(deadline).await?;
-        self.state.check_maintenance()?;
-
         // Match Go's store_vacuum.go CommitCompactVolume: skip commit if stopping
         if *self.state.is_stopping.read().unwrap() {
             return Err(Status::internal(format!(
@@ -2032,7 +2005,6 @@ impl VolumeServer for VolumeGrpcService {
                 disk_type: store.locations[loc_idx].disk_type.to_string(),
                 volume_info: Some(vol.volume_info().clone()),
                 version: vol.version().0 as u32,
-                expire_at_sec: vol.expire_at_sec(),
             },
         ))
     }
@@ -7375,8 +7347,6 @@ mod tests {
             rack: String::new(),
             file_size_limit_bytes: 0,
             maintenance_byte_per_second: 0,
-            vacuum_commit_slots: None,
-            vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
             is_heartbeating: std::sync::atomic::AtomicBool::new(true),
             has_master: false,
             pre_stop_seconds: 0,
@@ -7491,8 +7461,6 @@ mod tests {
             rack: String::new(),
             file_size_limit_bytes: 0,
             maintenance_byte_per_second: 0,
-            vacuum_commit_slots: None,
-            vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
             is_heartbeating: std::sync::atomic::AtomicBool::new(true),
             has_master: false,
             pre_stop_seconds: 0,
@@ -7604,271 +7572,6 @@ mod tests {
         );
     }
 
-    fn make_commit_limited_service(
-        collection: &str,
-        max_parallel_commits: usize,
-    ) -> (VolumeGrpcService, TempDir) {
-        let (mut service, tmp) = make_local_service_with_volume(collection, None);
-        if max_parallel_commits > 0 {
-            Arc::get_mut(&mut service.state)
-                .unwrap()
-                .vacuum_commit_slots = Some(tokio::sync::Semaphore::new(max_parallel_commits));
-        }
-        (service, tmp)
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 8)]
-    async fn test_vacuum_commit_slots_bound_concurrent_commits() {
-        async fn peak_holders(limit: usize) -> i32 {
-            let (service, _tmp) = make_commit_limited_service("bound_commits", limit);
-            let current = Arc::new(std::sync::atomic::AtomicI32::new(0));
-            let peak = Arc::new(std::sync::atomic::AtomicI32::new(0));
-            let mut workers = Vec::new();
-            for _ in 0..8 {
-                let state = service.state.clone();
-                let current = current.clone();
-                let peak = peak.clone();
-                workers.push(tokio::spawn(async move {
-                    let Ok(Some(_permit)) = state.acquire_vacuum_commit_slot(None).await else {
-                        return;
-                    };
-                    let n = current.fetch_add(1, Ordering::Relaxed) + 1;
-                    peak.fetch_max(n, Ordering::Relaxed);
-                    tokio::time::sleep(std::time::Duration::from_millis(5)).await;
-                    current.fetch_sub(1, Ordering::Relaxed);
-                }));
-            }
-            for w in workers {
-                w.await.unwrap();
-            }
-            peak.load(Ordering::Relaxed)
-        }
-        assert_eq!(peak_holders(1).await, 1);
-        assert!(peak_holders(3).await <= 3);
-    }
-
-    #[tokio::test]
-    async fn test_vacuum_commit_slots_unlimited_by_default() {
-        let (service, _tmp) = make_commit_limited_service("unlimited_commits", 0);
-        for i in 0..8 {
-            service
-                .state
-                .acquire_vacuum_commit_slot(Some(
-                    tokio::time::Instant::now() + std::time::Duration::from_secs(1),
-                ))
-                .await
-                .unwrap_or_else(|e| {
-                    panic!("acquisition {i} must not wait when no limit is configured: {e}")
-                });
-        }
-    }
-
-    #[tokio::test]
-    async fn test_vacuum_commit_slot_not_granted_to_expired_deadline() {
-        let (service, _tmp) = make_commit_limited_service("expired_commit", 1);
-        let slots = service.state.vacuum_commit_slots.as_ref().unwrap();
-        let past = tokio::time::Instant::now() - std::time::Duration::from_secs(1);
-        for _ in 0..100 {
-            let err = service
-                .state
-                .acquire_vacuum_commit_slot(Some(past))
-                .await
-                .expect_err("an expired deadline must not get a slot");
-            assert_eq!(err.code(), tonic::Code::DeadlineExceeded);
-            assert_eq!(
-                slots.available_permits(),
-                1,
-                "a refused acquisition must not keep the slot"
-            );
-        }
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_vacuum_commit_deadline_while_queued() {
-        let (service, _tmp) = make_commit_limited_service("queued_deadline", 1);
-        let state = service.state.clone();
-        let held = state
-            .vacuum_commit_slots
-            .as_ref()
-            .unwrap()
-            .acquire()
-            .await
-            .unwrap();
-
-        let mut request =
-            Request::new(volume_server_pb::VacuumVolumeCommitRequest { volume_id: 1 });
-        request
-            .metadata_mut()
-            .insert("grpc-timeout", "20m".parse().unwrap());
-        let err = service
-            .vacuum_volume_commit(request)
-            .await
-            .expect_err("the queued commit must expire at its deadline");
-        assert_eq!(err.code(), tonic::Code::DeadlineExceeded);
-        assert_eq!(
-            state
-                .vacuum_commit_slots
-                .as_ref()
-                .unwrap()
-                .available_permits(),
-            0,
-            "a refused commit must not consume the held slot"
-        );
-        drop(held);
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_queued_vacuum_commit_holds_no_store_lock() {
-        let (service, _tmp) = make_commit_limited_service("no_lock_commit", 1);
-        service
-            .state
-            .store
-            .write()
-            .unwrap()
-            .compact_volume(VolumeId(1), 0, 0, |_| true)
-            .unwrap();
-        let state = service.state.clone();
-        let held = state
-            .vacuum_commit_slots
-            .as_ref()
-            .unwrap()
-            .acquire()
-            .await
-            .unwrap();
-
-        let committed = tokio::spawn(async move {
-            service
-                .vacuum_volume_commit(Request::new(volume_server_pb::VacuumVolumeCommitRequest {
-                    volume_id: 1,
-                }))
-                .await
-        });
-        tokio::time::timeout(std::time::Duration::from_secs(5), async {
-            while state.vacuum_commits_waiting.load(Ordering::Relaxed) == 0 {
-                tokio::time::sleep(std::time::Duration::from_millis(1)).await;
-            }
-        })
-        .await
-        .expect("the commit must pass the entry checks and wait for a slot");
-
-        tokio::time::timeout(std::time::Duration::from_secs(5), async {
-            loop {
-                if let Ok(_guard) = state.store.try_read() {
-                    return;
-                }
-                tokio::time::sleep(std::time::Duration::from_millis(1)).await;
-            }
-        })
-        .await
-        .expect("store read blocked behind a queued commit");
-
-        drop(held);
-        tokio::time::timeout(std::time::Duration::from_secs(5), committed)
-            .await
-            .expect("queued commit did not run after the slot freed")
-            .unwrap()
-            .unwrap();
-        assert_eq!(
-            state
-                .vacuum_commit_slots
-                .as_ref()
-                .unwrap()
-                .available_permits(),
-            1,
-            "the commit must return its slot"
-        );
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_vacuum_commit_releases_slot_on_error() {
-        let (service, _tmp) = make_commit_limited_service("commit_err", 1);
-        service
-            .vacuum_volume_commit(Request::new(volume_server_pb::VacuumVolumeCommitRequest {
-                volume_id: 42,
-            }))
-            .await
-            .expect_err("committing an unknown volume must fail");
-        assert_eq!(
-            service
-                .state
-                .vacuum_commit_slots
-                .as_ref()
-                .unwrap()
-                .available_permits(),
-            1,
-            "a failed commit must return its slot"
-        );
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_queued_vacuum_commit_does_not_start_in_maintenance() {
-        let (service, _tmp) = make_commit_limited_service("maint_commit", 1);
-        service
-            .state
-            .store
-            .write()
-            .unwrap()
-            .compact_volume(VolumeId(1), 0, 0, |_| true)
-            .unwrap();
-        let revision_before = {
-            let store = service.state.store.read().unwrap();
-            let (_, v) = store.find_volume(VolumeId(1)).unwrap();
-            v.super_block.compaction_revision
-        };
-        let state = service.state.clone();
-        let held = state
-            .vacuum_commit_slots
-            .as_ref()
-            .unwrap()
-            .acquire()
-            .await
-            .unwrap();
-
-        let committed = tokio::spawn(async move {
-            service
-                .vacuum_volume_commit(Request::new(volume_server_pb::VacuumVolumeCommitRequest {
-                    volume_id: 1,
-                }))
-                .await
-        });
-        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
-        while state.vacuum_commits_waiting.load(Ordering::Relaxed) == 0 {
-            assert!(
-                std::time::Instant::now() < deadline,
-                "the commit must pass the entry maintenance check and wait for a slot"
-            );
-            tokio::time::sleep(std::time::Duration::from_millis(1)).await;
-        }
-
-        state.maintenance.store(true, Ordering::Relaxed);
-        drop(held);
-
-        let err = tokio::time::timeout(std::time::Duration::from_secs(5), committed)
-            .await
-            .expect("queued commit did not return after the slot freed")
-            .unwrap()
-            .expect_err("a queued commit must not run in maintenance mode");
-        assert!(err.message().contains("maintenance mode"));
-        let revision_after = {
-            let store = state.store.read().unwrap();
-            let (_, v) = store.find_volume(VolumeId(1)).unwrap();
-            v.super_block.compaction_revision
-        };
-        assert_eq!(
-            revision_before, revision_after,
-            "the volume must not be committed"
-        );
-        assert_eq!(
-            state
-                .vacuum_commit_slots
-                .as_ref()
-                .unwrap()
-                .available_permits(),
-            1,
-            "the refused commit must return its slot"
-        );
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_volume_incremental_copy_streams_remote_only_volume_data() {
         let (service, _tmp, shutdown_tx, dat_bytes, super_block_size, _delete_count) =
@@ -9925,8 +9628,6 @@ mod tests {
             rack: String::new(),
             file_size_limit_bytes: 0,
             maintenance_byte_per_second: 0,
-            vacuum_commit_slots: None,
-            vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
             is_heartbeating: std::sync::atomic::AtomicBool::new(true),
             has_master: false,
             pre_stop_seconds: 0,
@@ -10408,55 +10109,6 @@ mod tests {
         assert!(vif.expire_at_sec <= before + ttl.to_seconds() + 5);
     }
 
-    /// The worker EC encode reads ExpireAtSec out of ReadVolumeFileStatus, so
-    /// persisting a readonly mark must stamp it into the live volume_info too,
-    /// not only into the written .vif. A creation-time stamp would sit a full
-    /// last-write interval early.
-    #[tokio::test]
-    async fn test_mark_readonly_persist_reports_expire_at_sec() {
-        let ttl = crate::storage::needle::ttl::TTL::read("3m").unwrap();
-        let (service, _tmp) = make_local_service_with_volume("ttl", Some(ttl));
-
-        // A later write must move the expiry: pin it ahead of the setup write
-        // so the stale creation-time stamp cannot collide on the same second.
-        let last_write = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_secs()
-            + 60;
-        service
-            .state
-            .store
-            .write()
-            .unwrap()
-            .find_volume_mut(VolumeId(1))
-            .unwrap()
-            .1
-            .set_last_modified_ts_for_test(last_write);
-        service
-            .state
-            .store
-            .write()
-            .unwrap()
-            .find_volume_mut(VolumeId(1))
-            .unwrap()
-            .1
-            .set_read_only_persist(false, true)
-            .unwrap();
-
-        let status = service
-            .read_volume_file_status(Request::new(
-                volume_server_pb::ReadVolumeFileStatusRequest { volume_id: 1 },
-            ))
-            .await
-            .unwrap()
-            .into_inner();
-        assert_eq!(
-            status.volume_info.unwrap().expire_at_sec,
-            last_write + ttl.to_seconds()
-        );
-    }
-
     /// A re-encode must not mix artifacts from a previous run. Generate used to
     /// go straight into the encode, truncating only the `.ecNN` files on the
     /// encoding disk; a stale shard on a sibling disk survived and was later
@@ -11810,8 +11462,6 @@ mod tests {
             rack: String::new(),
             file_size_limit_bytes: 0,
             maintenance_byte_per_second: 0,
-            vacuum_commit_slots: None,
-            vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
             is_heartbeating: std::sync::atomic::AtomicBool::new(true),
             has_master: false,
             pre_stop_seconds: 0,

seaweed-volume/src/server/handlers.rs

@@ -5285,8 +5285,6 @@ mod tests {
             rack: String::new(),
             file_size_limit_bytes: 0,
             maintenance_byte_per_second: 0,
-            vacuum_commit_slots: None,
-            vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
             is_heartbeating: AtomicBool::new(false),
             has_master: false,
             pre_stop_seconds: 0,

seaweed-volume/src/server/heartbeat.rs

@@ -474,14 +474,6 @@ async fn do_heartbeat(
                             )
                             .into());
                         }
-                        let echo_max_volume_id = hb_resp.max_volume_id;
-                        let echo_topology_id = hb_resp.topology_id.clone();
-                        off_runtime(config, state, move |_, state| {
-                            let store = state.store.read().unwrap();
-                            store.update_max_volume_id_seen(echo_max_volume_id);
-                            store.update_last_seen_topology_id(&echo_topology_id);
-                        })
-                        .await?;
                         let options_changed =
                             volume_options_pass(config, state, &hb_resp).await?;
                         if options_changed && maybe_adjust_volume_max(config, state).await? {
@@ -1368,8 +1360,6 @@ fn build_heartbeat_with_ec_status(
         grpc_port: config.grpc_port as u32,
         location_uuids,
         disk_tags,
-        max_volume_id_seen: store.max_volume_id_seen(),
-        last_seen_topology_id: store.last_seen_topology_id(),
         ..Default::default()
     };
     (heartbeat, volumes, actions)
@@ -1495,8 +1485,6 @@ mod tests {
             rack: String::new(),
             file_size_limit_bytes: 0,
             maintenance_byte_per_second: 0,
-            vacuum_commit_slots: None,
-            vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
             is_heartbeating: std::sync::atomic::AtomicBool::new(false),
             has_master: true,
             pre_stop_seconds: 0,

seaweed-volume/src/server/profiling.rs

@@ -136,7 +136,6 @@ mod tests {
             mem_profile: String::new(),
             compaction_byte_per_second: 0,
             maintenance_byte_per_second: 0,
-            max_parallel_vacuum_commits: 0,
             file_size_limit_bytes: 0,
             concurrent_upload_limit: 0,
             concurrent_download_limit: 0,

seaweed-volume/src/server/volume_server.rs

@@ -63,12 +63,6 @@ pub struct VolumeServerState {
     pub file_size_limit_bytes: i64,
     /// Default IO rate limit for maintenance copy/replication work.
     pub maintenance_byte_per_second: i64,
-    /// Bounds concurrent vacuum commits; None means unlimited. Queued commits
-    /// wait on the semaphore, not on the store lock, so reads keep flowing.
-    /// Mirrors Go's `vacuumCommitSlots`.
-    pub vacuum_commit_slots: Option<tokio::sync::Semaphore>,
-    /// Vacuum commits currently waiting for a slot.
-    pub vacuum_commits_waiting: AtomicU32,
     /// Whether the server is connected to master (heartbeat active).
     pub is_heartbeating: AtomicBool,
     /// Whether master addresses are configured.
@@ -150,40 +144,6 @@ impl VolumeServerState {
         Ok(())
     }
 
-    /// Wait for a vacuum commit slot without touching the store lock; the wait
-    /// counts against the caller's `grpc-timeout`. An already-expired deadline
-    /// is refused even when a slot is free, matching Go's post-acquire
-    /// `ctx.Err()` check in `acquireVacuumCommitSlot`.
-    pub async fn acquire_vacuum_commit_slot(
-        &self,
-        deadline: Option<tokio::time::Instant>,
-    ) -> Result<Option<tokio::sync::SemaphorePermit<'_>>, tonic::Status> {
-        let Some(slots) = &self.vacuum_commit_slots else {
-            return Ok(None);
-        };
-        self.vacuum_commits_waiting.fetch_add(1, Ordering::Relaxed);
-        let acquired = match deadline {
-            Some(d) => match tokio::time::timeout_at(d, slots.acquire()).await {
-                Ok(permit) => permit.map_err(|e| tonic::Status::internal(e.to_string())),
-                Err(_) => Err(tonic::Status::deadline_exceeded(
-                    "timed out waiting for a vacuum commit slot",
-                )),
-            },
-            None => slots
-                .acquire()
-                .await
-                .map_err(|e| tonic::Status::internal(e.to_string())),
-        };
-        self.vacuum_commits_waiting.fetch_sub(1, Ordering::Relaxed);
-        let permit = acquired?;
-        if deadline.is_some_and(|d| tokio::time::Instant::now() >= d) {
-            return Err(tonic::Status::deadline_exceeded(
-                "timed out waiting for a vacuum commit slot",
-            ));
-        }
-        Ok(Some(permit))
-    }
-
     /// Build the seed master set from a list of raw `host:port[.grpcPort]`
     /// addresses, normalised the same way Go's `pb.ServerAddress.ToHttpAddress`
     /// does (drop the `.grpcPort` suffix, preserve everything else).

seaweed-volume/src/server/write_queue.rs

@@ -206,8 +206,6 @@ mod tests {
             rack: String::new(),
             file_size_limit_bytes: 0,
             maintenance_byte_per_second: 0,
-            vacuum_commit_slots: None,
-            vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
             is_heartbeating: AtomicBool::new(false),
             has_master: false,
             pre_stop_seconds: 0,

seaweed-volume/src/storage/disk_location.rs

@@ -620,20 +620,11 @@ impl DiskLocation {
             return Err(v.compacting_error());
         }
         if let Some(mut v) = self.volumes.remove(&vid) {
-            match v.destroy(only_empty, only_garbage, keep_remote_data) {
-                Ok(()) => {
-                    crate::metrics::VOLUME_GAUGE
-                        .with_label_values(&[&v.collection, "volume"])
-                        .dec();
-                    Ok(())
-                }
-                Err(e) => {
-                    // A failed destroy left the local files in place, so the
-                    // replica stays registered rather than becoming a phantom.
-                    self.volumes.insert(vid, v);
-                    Err(e)
-                }
-            }
+            crate::metrics::VOLUME_GAUGE
+                .with_label_values(&[&v.collection, "volume"])
+                .dec();
+            v.destroy(only_empty, only_garbage, keep_remote_data)?;
+            Ok(())
         } else {
             Err(VolumeError::NotFound)
         }
@@ -650,13 +641,11 @@ impl DiskLocation {
 
         for vid in vids {
             if let Some(mut v) = self.volumes.remove(&vid) {
+                crate::metrics::VOLUME_GAUGE
+                    .with_label_values(&[&v.collection, "volume"])
+                    .dec();
                 if let Err(e) = v.destroy(false, false, false) {
                     warn!(volume_id = vid.0, error = %e, "delete collection: failed to destroy volume");
-                    self.volumes.insert(vid, v);
-                } else {
-                    crate::metrics::VOLUME_GAUGE
-                        .with_label_values(&[&v.collection, "volume"])
-                        .dec();
                 }
             }
         }

seaweed-volume/src/storage/mod.rs

@@ -11,7 +11,6 @@ pub mod store_ec_mirror;
 pub mod store_ec_reconcile;
 pub mod super_block;
 pub mod types;
-pub mod vid_stamp;
 pub mod volume;
 pub mod volume_idx_rebuild;
 pub mod volume_idx_repair;

seaweed-volume/src/storage/store.rs

@@ -7,7 +7,7 @@
 use std::collections::HashSet;
 use std::io;
 use std::sync::Mutex;
-use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 
 use crate::config::MinFreeSpace;
 use crate::pb::master_pb;
@@ -72,10 +72,6 @@ pub struct Store {
     /// reporting the heartbeat that saw it.
     pub reported_collections: Mutex<HashSet<String>>,
     pub reported_ec_collections: Mutex<HashSet<String>>,
-    pub max_volume_id_seen: AtomicU32,
-    pub last_seen_topology_id: Mutex<String>,
-    pub vid_stamp_lock: Mutex<()>,
-    pub vid_stamp_dirty: std::sync::atomic::AtomicBool,
 }
 
 impl Store {
@@ -95,10 +91,6 @@ impl Store {
             rack: String::new(),
             reported_collections: Mutex::new(HashSet::new()),
             reported_ec_collections: Mutex::new(HashSet::new()),
-            max_volume_id_seen: AtomicU32::new(0),
-            last_seen_topology_id: Mutex::new(String::new()),
-            vid_stamp_lock: Mutex::new(()),
-            vid_stamp_dirty: std::sync::atomic::AtomicBool::new(false),
         }
     }
 
@@ -160,8 +152,6 @@ impl Store {
         // (read-only target, partial copy).
         self.reconcile_ec_shards_across_disks();
 
-        self.fold_location_into_vid_stamp(self.locations.last().unwrap());
-
         Ok(())
     }
 
@@ -427,7 +417,6 @@ impl Store {
         disk_type: DiskType,
         spec: &VolumeSpec<'_>,
     ) -> Result<(), VolumeError> {
-        self.stamp_allocated_vid(vid);
         if self.find_volume(vid).is_some() {
             return Err(VolumeError::AlreadyExists);
         }
@@ -970,7 +959,6 @@ impl Store {
         collection: &str,
         shard_ids: &[ShardId],
     ) -> Result<(), VolumeError> {
-        self.stamp_allocated_vid(vid);
         // Find the location where the EC files live
         let loc_idx = self.find_ec_location(vid, collection).ok_or_else(|| {
             VolumeError::Io(io::Error::new(
@@ -993,7 +981,6 @@ impl Store {
         shard_id: ShardId,
         source_disk_type: &str,
     ) -> Result<(), VolumeError> {
-        self.stamp_allocated_vid(vid);
         // The .ecx may live on a different disk than the shard being mounted
         // (ec.balance / ec.rebuild can spread shards across sibling disks), so
         // look up its owner once and point EcVolume::new at the directory that

seaweed-volume/src/storage/vid_stamp.rs

@@ -1,190 +0,0 @@
-//! Persisted volume-id high-water mark ("vid stamp"), mirroring Go's
-//! `weed/storage/vid_stamp.go`.
-//!
-//! Each volume dir carries a `.vid_stamp` JSON file with the highest volume
-//! id the server has ever observed plus the topology id it last heartbeated
-//! to. The bound is fed by heartbeat echoes, AllocateVolume, and local
-//! volume/EC creation, is reported back in `Heartbeat.max_volume_id_seen`,
-//! and survives master state loss so rebuilt masters cannot reissue ids an
-//! offline server still holds.
-
-use std::fs;
-use std::io;
-use std::path::Path;
-
-use serde::{Deserialize, Serialize};
-
-use crate::storage::types::VolumeId;
-
-use super::store::Store;
-
-const VID_STAMP_FILE_NAME: &str = ".vid_stamp";
-
-#[derive(Serialize, Deserialize, Default)]
-struct VidStamp {
-    #[serde(rename = "maxVolumeId")]
-    max_volume_id: u32,
-    #[serde(rename = "topologyId", default, skip_serializing_if = "String::is_empty")]
-    topology_id: String,
-}
-
-impl Store {
-    pub fn max_volume_id_seen(&self) -> u32 {
-        self.max_volume_id_seen.load(std::sync::atomic::Ordering::Relaxed)
-    }
-
-    pub fn last_seen_topology_id(&self) -> String {
-        self.last_seen_topology_id
-            .lock()
-            .unwrap()
-            .clone()
-    }
-
-    pub fn update_max_volume_id_seen(&self, vid: u32) {
-        use std::sync::atomic::Ordering::Relaxed;
-        let prev = self.max_volume_id_seen.fetch_max(vid, Relaxed);
-        if vid > prev || self.vid_stamp_dirty.load(Relaxed) {
-            self.save_vid_stamps();
-        }
-    }
-
-    pub fn update_last_seen_topology_id(&self, id: &str) {
-        if id.is_empty() {
-            return;
-        }
-        {
-            let mut guard = self.last_seen_topology_id.lock().unwrap();
-            if *guard == id {
-                return;
-            }
-            *guard = id.to_string();
-        }
-        self.save_vid_stamps();
-    }
-
-    /// Seed the bound from a freshly added location: its persisted stamp,
-    /// its volumes, and its EC shards. Called per location from
-    /// `add_location` after the EC reconcile passes have run.
-    pub(crate) fn fold_location_into_vid_stamp(&self, loc: &super::disk_location::DiskLocation) {
-        if let Ok(stamp) = read_vid_stamp(Path::new(&loc.directory)) {
-            self.update_max_volume_id_seen(stamp.max_volume_id);
-            if !stamp.topology_id.is_empty() {
-                self.update_last_seen_topology_id(&stamp.topology_id);
-            }
-        }
-        let mut max_vid: u32 = 0;
-        for vid in loc.volume_ids() {
-            max_vid = max_vid.max(vid.0);
-        }
-        for (vid, _) in loc.ec_volumes() {
-            max_vid = max_vid.max(vid.0);
-        }
-        if max_vid > 0 {
-            self.update_max_volume_id_seen(max_vid);
-        }
-    }
-
-    fn save_vid_stamps(&self) {
-        let _guard = self.vid_stamp_lock.lock().unwrap();
-        let stamp = match serde_json::to_vec(&VidStamp {
-            max_volume_id: self.max_volume_id_seen(),
-            topology_id: self.last_seen_topology_id(),
-        }) {
-            Ok(s) => s,
-            Err(_) => return,
-        };
-        let mut failed = false;
-        for loc in &self.locations {
-            if let Err(e) = write_vid_stamp(Path::new(&loc.directory), &stamp) {
-                tracing::warn!("write vid stamp in {}: {}", loc.directory, e);
-                failed = true;
-            }
-        }
-        self.vid_stamp_dirty
-            .store(failed, std::sync::atomic::Ordering::Relaxed);
-    }
-}
-
-fn read_vid_stamp(dir: &Path) -> io::Result<VidStamp> {
-    let data = fs::read(dir.join(VID_STAMP_FILE_NAME))?;
-    serde_json::from_slice(&data).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
-}
-
-fn write_vid_stamp(dir: &Path, stamp: &[u8]) -> io::Result<()> {
-    let tmp = dir.join(format!("{}.tmp", VID_STAMP_FILE_NAME));
-    {
-        use std::io::Write;
-        let mut f = fs::File::create(&tmp)?;
-        f.write_all(stamp)?;
-        f.sync_all()?;
-    }
-    fs::rename(&tmp, dir.join(VID_STAMP_FILE_NAME))?;
-    if cfg!(unix) {
-        fs::File::open(dir)?.sync_all()?;
-    }
-    Ok(())
-}
-
-/// Stamps the volume id of a newly created volume or EC shard set. Called
-/// from `Store::add_volume` / `Store::mount_ec_shards*` so the bound covers
-/// ids before their files exist.
-impl Store {
-    pub(crate) fn stamp_allocated_vid(&self, vid: VolumeId) {
-        self.update_max_volume_id_seen(vid.0);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::config::MinFreeSpace;
-    use crate::storage::needle_map::NeedleMapKind;
-    use crate::storage::types::DiskType;
-    use tempfile::TempDir;
-
-    fn make_store(dir: &str) -> Store {
-        let mut store = Store::new(NeedleMapKind::InMemory);
-        store
-            .add_location(dir, dir, 10, DiskType::HardDrive, MinFreeSpace::Percent(1.0), Vec::new())
-            .unwrap();
-        store
-    }
-
-    #[test]
-    fn stamp_written_on_bound_increase() {
-        let tmp = TempDir::new().unwrap();
-        let dir = tmp.path().to_str().unwrap();
-        let store = make_store(dir);
-
-        store.update_max_volume_id_seen(42);
-
-        let stamp = read_vid_stamp(tmp.path()).unwrap();
-        assert_eq!(stamp.max_volume_id, 42);
-    }
-
-    #[test]
-    fn stamp_survives_restart() {
-        let tmp = TempDir::new().unwrap();
-        let dir = tmp.path().to_str().unwrap();
-
-        let store = make_store(dir);
-        store.update_max_volume_id_seen(42);
-        store.update_last_seen_topology_id("cluster-a");
-        drop(store);
-
-        let restarted = make_store(dir);
-        assert_eq!(restarted.max_volume_id_seen(), 42);
-        assert_eq!(restarted.last_seen_topology_id(), "cluster-a");
-    }
-
-    #[test]
-    fn bound_is_monotonic() {
-        let tmp = TempDir::new().unwrap();
-        let dir = tmp.path().to_str().unwrap();
-        let store = make_store(dir);
-
-        store.update_max_volume_id_seen(10);
-        store.update_max_volume_id_seen(5);
-        assert_eq!(store.max_volume_id_seen(), 10);
-    }
-}

seaweed-volume/src/storage/volume.rs

@@ -3969,14 +3969,13 @@ impl Volume {
             self.no_write_can_delete && !self.has_remote_file() && !self.no_write_or_delete;
         self.volume_info.read_only = self.no_write_or_delete || marked_can_delete;
         self.volume_info.read_only_can_delete = marked_can_delete;
+        let mut vif = VifVolumeInfo::from_pb(&self.volume_info);
 
-        // Match Go's SaveVolumeInfo: stamp ExpireAtSec into the live volume_info
-        // so read_volume_file_status returns it, not only into the written file.
+        // Match Go's SaveVolumeInfo: compute ExpireAtSec from TTL
         let expire_at_sec = self.expire_at_sec();
         if expire_at_sec > 0 {
-            self.volume_info.expire_at_sec = expire_at_sec;
+            vif.expire_at_sec = expire_at_sec;
         }
-        let vif = VifVolumeInfo::from_pb(&self.volume_info);
 
         let content = serde_json::to_string_pretty(&vif)
             .map_err(|e| VolumeError::Io(io::Error::other(e.to_string())))?;
@@ -5007,12 +5006,13 @@ impl Volume {
                 .get(&storage_name);
             if let Some(backend) = backend {
                 if let Err(e) = backend.delete_file_blocking(&storage_key) {
-                    // Stop short of local cleanup: a failed remote delete must
-                    // not strand a registered replica with no local files.
-                    return Err(VolumeError::Io(io::Error::other(format!(
-                        "volume {} remote object {}/{} delete failed: {}",
-                        self.id, storage_name, storage_key, e
-                    ))));
+                    warn!(
+                        volume_id = self.id.0,
+                        storage_name,
+                        storage_key,
+                        error = %e,
+                        "failed to delete remote tier file during destroy"
+                    );
                 }
             } else {
                 warn!(

seaweed-volume/tests/http_integration.rs

@@ -107,8 +107,6 @@ fn build_test_state(
         rack: String::new(),
         file_size_limit_bytes: 0,
         maintenance_byte_per_second: 0,
-        vacuum_commit_slots: None,
-        vacuum_commits_waiting: std::sync::atomic::AtomicU32::new(0),
         is_heartbeating: std::sync::atomic::AtomicBool::new(true),
         ec_decodes_in_flight: std::sync::Mutex::new(std::collections::HashSet::new()),
         ec_decode_tail: std::sync::Mutex::new(std::collections::HashSet::new()),

test/s3/normal/s3_integration_test.go

@@ -114,7 +114,7 @@ func TestS3Integration(t *testing.T) {
 // findAvailablePort finds an available port by binding to port 0
 
 // startMiniCluster starts a weed mini instance directly without exec.
-// Extra flags can be appended via extraArgs.
+// Extra flags (e.g. "-s3.allowDeleteBucketNotEmpty=false") can be appended via extraArgs.
 func startMiniCluster(t *testing.T, extraArgs ...string) (*TestCluster, error) {
 	// Allocate non-colliding ports (including gRPC offsets) for weed mini.
 	ports := testutil.MustFreeMiniPorts(t, []string{"Master", "Volume", "Filer", "S3"})
@@ -872,7 +872,7 @@ func TestS3DeleteBucketNotEmpty(t *testing.T) {
 		t.Skip("Skipping integration test in short mode")
 	}
 
-	cluster, err := startMiniCluster(t)
+	cluster, err := startMiniCluster(t, "-s3.allowDeleteBucketNotEmpty=false")
 	require.NoError(t, err)
 	defer cluster.Stop()
 

test/s3/versioning/Makefile

@@ -228,8 +228,8 @@ test-with-server: start-server
 # Test with different configurations
 test-versioning-with-configs: check-deps
 	@echo "Testing with different S3 configurations..."
-	@echo "Testing with delete bucket not empty allowed..."
-	@$(WEED_BINARY) mini -s3.port=$(S3_PORT) -s3.allowDeleteBucketNotEmpty=true > weed-test-config1.log 2>&1 & echo $$! > weed-config1.pid
+	@echo "Testing with empty folder allowed..."
+	@$(WEED_BINARY) mini -s3.port=$(S3_PORT) > weed-test-config1.log 2>&1 & echo $$! > weed-config1.pid
 	@sleep 5
 	@go test -v -timeout=5m -run "TestVersioningBasicWorkflow" . || true
 	@if [ -f weed-config1.pid ]; then kill -TERM $$(cat weed-config1.pid) 2>/dev/null || true; rm -f weed-config1.pid; fi

test/sftp/basic_test.go

@@ -3,7 +3,6 @@ package sftp
 import (
 	"bytes"
 	"io"
-	"os"
 	"path"
 	"testing"
 
@@ -603,32 +602,6 @@ func TestFileContent(t *testing.T) {
 		sftpClient.Remove("/binary.bin")
 	})
 
-	t.Run("WriteAtOffsetKeepsExistingBytes", func(t *testing.T) {
-		file, err := sftpClient.Create("/resume.txt")
-		require.NoError(t, err)
-		_, err = file.Write([]byte("hello world"))
-		require.NoError(t, err)
-		require.NoError(t, file.Close())
-
-		// Reopen without O_TRUNC and write past the start, as a resumed upload does
-		file, err = sftpClient.OpenFile("/resume.txt", os.O_WRONLY)
-		require.NoError(t, err)
-		_, err = file.WriteAt([]byte("WORLD!"), 6)
-		require.NoError(t, err)
-		require.NoError(t, file.Close())
-
-		readFile, err := sftpClient.Open("/resume.txt")
-		require.NoError(t, err)
-		content, err := io.ReadAll(readFile)
-		require.NoError(t, err)
-		readFile.Close()
-
-		require.Equal(t, "hello WORLD!", string(content))
-
-		// Clean up
-		sftpClient.Remove("/resume.txt")
-	})
-
 	t.Run("EmptyFile", func(t *testing.T) {
 		file, err := sftpClient.Create("/empty.txt")
 		require.NoError(t, err)

test/volume_server/framework/volume_fixture.go

@@ -16,18 +16,6 @@ import (
 
 func AllocateVolume(t testing.TB, client volume_server_pb.VolumeServerClient, volumeID uint32, collection string) {
 	t.Helper()
-	allocateVolume(t, client, volumeID, collection, "")
-}
-
-// AllocateVolumeWithTTL allocates a volume whose needles expire after ttl
-// (e.g. "10m").
-func AllocateVolumeWithTTL(t testing.TB, client volume_server_pb.VolumeServerClient, volumeID uint32, collection string, ttl string) {
-	t.Helper()
-	allocateVolume(t, client, volumeID, collection, ttl)
-}
-
-func allocateVolume(t testing.TB, client volume_server_pb.VolumeServerClient, volumeID uint32, collection string, ttl string) {
-	t.Helper()
 
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
@@ -36,7 +24,6 @@ func allocateVolume(t testing.TB, client volume_server_pb.VolumeServerClient, vo
 		VolumeId:    volumeID,
 		Collection:  collection,
 		Replication: "000",
-		Ttl:         ttl,
 		Version:     uint32(needle.GetCurrentVersion()),
 	})
 	if err != nil {

weed/admin/dash/admin_server.go

@@ -14,7 +14,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/seaweedfs/seaweedfs/weed/admin/maintenance"
 	adminplugin "github.com/seaweedfs/seaweedfs/weed/admin/plugin"
 	"github.com/seaweedfs/seaweedfs/weed/cluster"
@@ -1156,7 +1155,6 @@ func (s *AdminServer) SetBucketLifecycle(bucketName string, rules []BucketLifecy
 		bucketPath := filerConfig.BucketsPath + "/" + bucketName
 		resp, err := client.ObjectTransaction(context.Background(), &filer_pb.ObjectTransactionRequest{
 			LockKey:   bucketPath,
-			RequestId: uuid.NewString(),
 			RouteKey:  s3_constants.ObjectWriteRouteKeyPrefix + bucketPath,
 			Mutations: []*filer_pb.ObjectMutation{bucketLifecycleMutation(filerConfig.BucketsPath, bucketName, lifecycleXML)},
 		})

weed/admin/dash/bucket_policy.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/google/uuid"
 	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
 	"github.com/seaweedfs/seaweedfs/weed/s3api"
 	"github.com/seaweedfs/seaweedfs/weed/s3api/policy_engine"
@@ -127,7 +126,6 @@ func (s *AdminServer) writeBucketPolicy(bucketName string, policyJSON []byte) er
 		bucketPath := filerConfig.BucketsPath + "/" + bucketName
 		resp, err := client.ObjectTransaction(context.Background(), &filer_pb.ObjectTransactionRequest{
 			LockKey:   bucketPath,
-			RequestId: uuid.NewString(),
 			RouteKey:  s3_constants.ObjectWriteRouteKeyPrefix + bucketPath,
 			Mutations: []*filer_pb.ObjectMutation{bucketPolicyMutation(filerConfig.BucketsPath, bucketName, policyJSON)},
 		})

weed/admin/plugin/host_affinity.go

@@ -1,66 +0,0 @@
-package plugin
-
-import (
-	"strings"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
-	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
-	pluginworker "github.com/seaweedfs/seaweedfs/weed/plugin/worker"
-	"github.com/seaweedfs/seaweedfs/weed/util"
-
-	"google.golang.org/protobuf/proto"
-)
-
-// JobReplicaHosts are the volume-replica hosts a job will read from.
-// Used so executor pick prefers a worker on one of those machines.
-// Sources with ShardIds are EC-cleanup rows, not encode replicas.
-func JobReplicaHosts(job *plugin_pb.JobSpec) []string {
-	if job == nil {
-		return nil
-	}
-	var addrs []string
-	addrs = append(addrs, pluginworker.ReadStringListConfig(job.Parameters, "replica_servers")...)
-	if src := strings.TrimSpace(pluginworker.ReadStringConfig(job.Parameters, "source_server", "")); src != "" {
-		addrs = append(addrs, src)
-	}
-	if payload := pluginworker.ReadBytesConfig(job.Parameters, "task_params_pb"); len(payload) > 0 {
-		params := &worker_pb.TaskParams{}
-		if err := proto.Unmarshal(payload, params); err == nil {
-			for _, s := range params.GetSources() {
-				if s == nil || s.Node == "" || len(s.ShardIds) > 0 {
-					continue
-				}
-				addrs = append(addrs, s.Node)
-			}
-		}
-	}
-	return util.HostKeysFromAddresses(addrs)
-}
-
-// partitionByPreferredHost splits candidates into (host matches, others).
-// No preferred hosts, or no matches, returns (nil, all) so callers keep
-// the existing slots+round-robin path.
-func partitionByPreferredHost(candidates []*WorkerSession, preferredHosts []string) (pref, rest []*WorkerSession) {
-	want := util.HostKeysFromAddresses(preferredHosts)
-	if len(want) == 0 || len(candidates) == 0 {
-		return nil, candidates
-	}
-	set := make(map[string]struct{}, len(want))
-	for _, h := range want {
-		set[h] = struct{}{}
-	}
-	for _, c := range candidates {
-		if c == nil {
-			continue
-		}
-		if _, ok := set[util.HostKey(c.Address)]; ok {
-			pref = append(pref, c)
-			continue
-		}
-		rest = append(rest, c)
-	}
-	if len(pref) == 0 {
-		return nil, candidates
-	}
-	return pref, rest
-}

weed/admin/plugin/plugin.go

@@ -615,7 +615,7 @@ func (r *Plugin) ExecuteJob(
 	releaseGate := r.acquireDetectionExecutionGate(jobType, true)
 	defer releaseGate()
 
-	executor, err := r.registry.PickExecutor(jobType, JobReplicaHosts(job)...)
+	executor, err := r.registry.PickExecutor(jobType)
 	if err != nil {
 		return nil, err
 	}

weed/admin/plugin/plugin_monitor.go

@@ -887,37 +887,6 @@ func (r *Plugin) trackExecutionQueued(job *plugin_pb.JobSpec) {
 	})
 }
 
-// bindQueuedJobWorker records the home worker while the job stays pending/queued.
-func (r *Plugin) bindQueuedJobWorker(job *plugin_pb.JobSpec, workerID string) {
-	if job == nil || strings.TrimSpace(job.JobId) == "" || strings.TrimSpace(workerID) == "" {
-		return
-	}
-
-	now := time.Now().UTC()
-	r.jobsMu.Lock()
-	tracked := r.jobs[job.JobId]
-	if tracked == nil {
-		r.jobsMu.Unlock()
-		return
-	}
-	if isTerminalTrackedJobState(tracked.State) {
-		r.jobsMu.Unlock()
-		return
-	}
-	tracked.WorkerID = workerID
-	tracked.Message = "queued on worker " + workerID
-	tracked.UpdatedAt = timeToPtr(now)
-	snap := cloneTrackedJob(*tracked)
-	r.dirtyJobs = true
-	r.jobsMu.Unlock()
-
-	r.persistJobDetailSnapshot(job.JobId, func(detail *TrackedJob) {
-		detail.WorkerID = snap.WorkerID
-		detail.Message = snap.Message
-		detail.UpdatedAt = snap.UpdatedAt
-	})
-}
-
 func (r *Plugin) cancelQueuedJob(job *plugin_pb.JobSpec, cause error) {
 	reason := "job canceled"
 	if cause != nil {

weed/admin/plugin/plugin_scheduler.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -29,18 +28,12 @@ const (
 	defaultScheduledMaxResults           int32 = 1000
 	defaultScheduledExecutionConcurrency       = 1
 	defaultScheduledPerWorkerConcurrency       = 1
-	// Hold a job on replica-host workers until their reservation load
-	// reaches this; 0 disables the pin and spills immediately.
-	defaultLocalQueuePin = 5
-	// Wait this long after a home worker disappears before stealing
-	// its queue; 0 steals immediately. Covers a reconnect blink.
-	defaultOrphanRehomeGrace         = 30 * time.Second
-	maxScheduledExecutionConcurrency = 128
-	defaultScheduledRetryBackoff     = 5 * time.Second
-	defaultClusterContextTimeout     = 10 * time.Second
-	defaultWaitingBacklogFloor       = 8
-	defaultWaitingBacklogMultiplier  = 4
-	maxEstimatedRuntimeCap           = 8 * time.Hour
+	maxScheduledExecutionConcurrency           = 128
+	defaultScheduledRetryBackoff               = 5 * time.Second
+	defaultClusterContextTimeout               = 10 * time.Second
+	defaultWaitingBacklogFloor                 = 8
+	defaultWaitingBacklogMultiplier            = 4
+	maxEstimatedRuntimeCap                     = 8 * time.Hour
 	// How long started jobs may drain past the run window close.
 	scheduledExecutionDrainGrace = 30 * time.Minute
 )
@@ -56,12 +49,6 @@ type schedulerPolicy struct {
 	PerWorkerConcurrency   int
 	RetryLimit             int
 	ExecutorReserveBackoff time.Duration
-	// LocalQueuePin is K: do not spill off replica-host workers while
-	// min(load(pref)) < K. Zero is the old immediate-spill path.
-	LocalQueuePin int
-	// OrphanRehomeGrace is how long a missing home's queue is held
-	// before steal-without-K. Zero steals as soon as the worker is gone.
-	OrphanRehomeGrace time.Duration
 }
 
 // laneSchedulerLoop is the main scheduling goroutine for a single lane.
@@ -479,8 +466,6 @@ func (r *Plugin) loadSchedulerPolicy(jobType string) (schedulerPolicy, bool, err
 		PerWorkerConcurrency:   int(adminRuntime.PerWorkerExecutionConcurrency),
 		RetryLimit:             int(adminRuntime.RetryLimit),
 		ExecutorReserveBackoff: 200 * time.Millisecond,
-		LocalQueuePin:          defaultLocalQueuePin,
-		OrphanRehomeGrace:      defaultOrphanRehomeGrace,
 	}
 
 	if policy.DetectionInterval < r.schedulerTick {
@@ -511,9 +496,6 @@ func (r *Plugin) loadSchedulerPolicy(jobType string) (schedulerPolicy, bool, err
 	if policy.ExecutionTimeout < defaultScheduledExecutionTimeout {
 		policy.ExecutionTimeout = defaultScheduledExecutionTimeout
 	}
-	if policy.LocalQueuePin < 0 {
-		policy.LocalQueuePin = 0
-	}
 
 	return policy, true, nil
 }
@@ -831,22 +813,19 @@ func (r *Plugin) dispatchScheduledProposals(
 	// whole dispatch lets manual shell operations interleave between jobs.
 	jobsRequireLock := LaneRequiresLock(JobTypeLane(jobType))
 
-	jobs := make([]*plugin_pb.JobSpec, 0, len(proposals))
+	jobQueue := make(chan *plugin_pb.JobSpec, len(proposals))
 	for index, proposal := range proposals {
-		select {
-		case <-r.shutdownCh:
-			for _, job := range jobs {
-				r.cancelQueuedJob(job, errSchedulerShutdown)
-			}
-			return 0, 0, len(jobs)
-		default:
-		}
 		job := buildScheduledJobSpec(jobType, proposal, index)
 		r.trackExecutionQueued(job)
-		jobs = append(jobs, job)
+		select {
+		case <-r.shutdownCh:
+			close(jobQueue)
+			return 0, 0, 0
+		default:
+			jobQueue <- job
+		}
 	}
-
-	queues := r.assignJobsToWorkerQueues(jobType, jobs, policy)
+	close(jobQueue)
 
 	var wg sync.WaitGroup
 	var statsMu sync.Mutex
@@ -863,110 +842,130 @@ func (r *Plugin) dispatchScheduledProposals(
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for {
+
+		jobLoop:
+			for job := range jobQueue {
 				select {
 				case <-r.shutdownCh:
 					return
 				default:
 				}
-				if ctx.Err() != nil {
-					return
-				}
-				if queues.isEmpty() {
-					return
-				}
 
-				item, targetID := r.takeQueuedJob(queues, jobType, policy)
-				if item == nil {
-					if queues.isEmpty() {
-						return
-					}
-					if !waitForShutdownOrTimerWithContext(r.shutdownCh, ctx, policy.ExecutorReserveBackoff) {
-						return
-					}
+				if ctx.Err() != nil {
+					r.cancelQueuedJob(job, ctx.Err())
+					statsMu.Lock()
+					canceledCount++
+					statsMu.Unlock()
 					continue
 				}
-				if ctx.Err() != nil {
-					queues.pushFront(item)
-					return
-				}
 
-				executor, release, reserveErr := r.reserveExecutorByID(jobType, policy, targetID)
-				if reserveErr != nil {
-					queues.pushFront(item)
+				for {
+					select {
+					case <-r.shutdownCh:
+						return
+					default:
+					}
 					if ctx.Err() != nil {
-						return
+						r.cancelQueuedJob(job, ctx.Err())
+						statsMu.Lock()
+						canceledCount++
+						statsMu.Unlock()
+						continue jobLoop
 					}
-					if !waitForShutdownOrTimerWithContext(r.shutdownCh, ctx, policy.ExecutorReserveBackoff) {
-						return
-					}
-					continue
-				}
 
-				var releaseJobLock func()
-				if jobsRequireLock {
-					var lockErr error
-					releaseJobLock, lockErr = r.acquireAdminLock(fmt.Sprintf("plugin scheduler %s job %s", jobType, item.job.JobId))
-					if lockErr != nil {
-						release()
+					executor, release, reserveErr := r.reserveScheduledExecutor(ctx, jobType, policy)
+					if reserveErr != nil {
+						if ctx.Err() != nil {
+							r.cancelQueuedJob(job, ctx.Err())
+							statsMu.Lock()
+							canceledCount++
+							statsMu.Unlock()
+							continue jobLoop
+						}
 						statsMu.Lock()
 						errorCount++
 						statsMu.Unlock()
 						r.appendActivity(JobActivity{
-							JobID:      item.job.JobId,
-							JobType:    item.job.JobType,
+							JobType:    jobType,
 							Source:     "admin_scheduler",
-							Message:    fmt.Sprintf("scheduled execution lock failed: %v", lockErr),
+							Message:    fmt.Sprintf("scheduled execution reservation failed: %v", reserveErr),
 							Stage:      "failed",
 							OccurredAt: timeToPtr(time.Now().UTC()),
 						})
-						continue
+						break
 					}
-					if ctx.Err() != nil {
+
+					var releaseJobLock func()
+					if jobsRequireLock {
+						var lockErr error
+						releaseJobLock, lockErr = r.acquireAdminLock(fmt.Sprintf("plugin scheduler %s job %s", jobType, job.JobId))
+						if lockErr != nil {
+							release()
+							statsMu.Lock()
+							errorCount++
+							statsMu.Unlock()
+							r.appendActivity(JobActivity{
+								JobID:      job.JobId,
+								JobType:    job.JobType,
+								Source:     "admin_scheduler",
+								Message:    fmt.Sprintf("scheduled execution lock failed: %v", lockErr),
+								Stage:      "failed",
+								OccurredAt: timeToPtr(time.Now().UTC()),
+							})
+							break
+						}
+						// The lock may have been held by an operator for a
+						// while; re-check the execution window.
+						if ctx.Err() != nil {
+							releaseJobLock()
+							release()
+							r.cancelQueuedJob(job, ctx.Err())
+							statsMu.Lock()
+							canceledCount++
+							statsMu.Unlock()
+							continue jobLoop
+						}
+					}
+
+					err := r.executeScheduledJobWithExecutor(ctx, executor, job, clusterContext, policy)
+					if releaseJobLock != nil {
 						releaseJobLock()
-						release()
-						queues.pushFront(item)
-						return
 					}
-				}
-
-				err := r.executeScheduledJobWithExecutor(ctx, executor, item.job, clusterContext, policy)
-				if releaseJobLock != nil {
-					releaseJobLock()
-				}
-				release()
-				if errors.Is(err, errExecutorAtCapacity) {
-					queues.pushFront(item)
-					if !waitForShutdownOrTimerWithContext(r.shutdownCh, ctx, policy.ExecutorReserveBackoff) {
-						return
-					}
-					continue
-				}
-				if err != nil {
-					if ctx.Err() != nil || errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
-						r.cancelQueuedJob(item.job, err)
-						statsMu.Lock()
-						canceledCount++
-						statsMu.Unlock()
+					release()
+					if errors.Is(err, errExecutorAtCapacity) {
+						r.trackExecutionQueued(job)
+						if !waitForShutdownOrTimerWithContext(r.shutdownCh, ctx, policy.ExecutorReserveBackoff) {
+							return
+						}
 						continue
 					}
-					statsMu.Lock()
-					errorCount++
-					statsMu.Unlock()
-					r.appendActivity(JobActivity{
-						JobID:      item.job.JobId,
-						JobType:    item.job.JobType,
-						Source:     "admin_scheduler",
-						Message:    fmt.Sprintf("scheduled execution failed: %v", err),
-						Stage:      "failed",
-						OccurredAt: timeToPtr(time.Now().UTC()),
-					})
-					continue
-				}
+					if err != nil {
+						if ctx.Err() != nil || errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
+							r.cancelQueuedJob(job, err)
+							statsMu.Lock()
+							canceledCount++
+							statsMu.Unlock()
+							continue jobLoop
+						}
+						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()
+					statsMu.Lock()
+					successCount++
+					statsMu.Unlock()
+					break
+				}
 			}
 		}()
 	}
@@ -977,8 +976,8 @@ func (r *Plugin) dispatchScheduledProposals(
 	if drainErr == nil {
 		drainErr = errSchedulerShutdown
 	}
-	for _, item := range queues.drain() {
-		r.cancelQueuedJob(item.job, drainErr)
+	for job := range jobQueue {
+		r.cancelQueuedJob(job, drainErr)
 		canceledCount++
 	}
 
@@ -989,7 +988,6 @@ func (r *Plugin) reserveScheduledExecutor(
 	ctx context.Context,
 	jobType string,
 	policy schedulerPolicy,
-	preferredHosts []string,
 ) (*WorkerSession, func(), error) {
 	if ctx == nil {
 		ctx = context.Background()
@@ -1017,7 +1015,7 @@ func (r *Plugin) reserveScheduledExecutor(
 			return nil, nil, fmt.Errorf("timed out waiting for executor capacity for %s", jobType)
 		}
 
-		executors, err := r.registry.ListExecutors(jobType, preferredHosts...)
+		executors, err := r.registry.ListExecutors(jobType)
 		if err != nil {
 			if !waitForShutdownOrTimerWithContext(r.shutdownCh, ctx, policy.ExecutorReserveBackoff) {
 				if ctx.Err() != nil {
@@ -1028,19 +1026,11 @@ func (r *Plugin) reserveScheduledExecutor(
 			continue
 		}
 
-		pref, rest := partitionByPreferredHost(executors, preferredHosts)
-		lane := JobTypeLane(jobType)
-		loadOf := func(e *WorkerSession) int { return r.executorReservationLoad(e, lane) }
-
-		if len(pref) > 0 {
-			sortExecutorsByLoad(pref, loadOf)
-			if executor, release, ok := r.tryReserveFirst(pref, jobType, policy); ok {
-				return executor, release, nil
+		for _, executor := range executors {
+			release, ok := r.tryReserveExecutorCapacity(executor, jobType, policy)
+			if !ok {
+				continue
 			}
-		}
-
-		sortExecutorsByLoad(rest, loadOf)
-		if executor, release, ok := r.tryReserveFirst(rest, jobType, policy); ok {
 			return executor, release, nil
 		}
 
@@ -1061,75 +1051,6 @@ func (r *Plugin) tryReserveExecutorCapacity(
 	return r.tryReserveExecutorCapacityForLane(executor, jobType, policy, JobTypeLane(jobType))
 }
 
-func (r *Plugin) tryReserveFirst(executors []*WorkerSession, jobType string, policy schedulerPolicy) (*WorkerSession, func(), bool) {
-	for _, executor := range executors {
-		release, ok := r.tryReserveExecutorCapacity(executor, jobType, policy)
-		if ok {
-			return executor, release, true
-		}
-	}
-	return nil, nil, false
-}
-
-func (r *Plugin) reserveExecutorByID(jobType string, policy schedulerPolicy, workerID string) (*WorkerSession, func(), error) {
-	workerID = strings.TrimSpace(workerID)
-	if workerID == "" {
-		return nil, nil, fmt.Errorf("executor id is empty")
-	}
-	executors, err := r.registry.ListExecutors(jobType)
-	if err != nil {
-		return nil, nil, err
-	}
-	for _, executor := range executors {
-		if executor == nil || executor.WorkerID != workerID {
-			continue
-		}
-		release, ok := r.tryReserveExecutorCapacity(executor, jobType, policy)
-		if !ok {
-			return nil, nil, errExecutorAtCapacity
-		}
-		return executor, release, nil
-	}
-	return nil, nil, fmt.Errorf("executor %s is not available for %s", workerID, jobType)
-}
-
-func (r *Plugin) executorReservationLoad(executor *WorkerSession, lane SchedulerLane) int {
-	if executor == nil {
-		return 0
-	}
-	load := 0
-	if executor.Heartbeat != nil && executor.Heartbeat.ExecutionSlotsUsed > 0 {
-		load = int(executor.Heartbeat.ExecutionSlotsUsed)
-	}
-	workerID := strings.TrimSpace(executor.WorkerID)
-	if ls := r.lanes[lane]; ls != nil {
-		ls.execMu.Lock()
-		load += ls.execRes[workerID]
-		ls.execMu.Unlock()
-		return load
-	}
-	r.schedulerExecMu.Lock()
-	load += r.schedulerExecReservations[workerID]
-	r.schedulerExecMu.Unlock()
-	return load
-}
-
-func sortExecutorsByLoad(executors []*WorkerSession, load func(*WorkerSession) int) {
-	sort.SliceStable(executors, func(i, j int) bool {
-		if executors[i] == nil {
-			return false
-		}
-		if executors[j] == nil {
-			return true
-		}
-		li, lj := load(executors[i]), load(executors[j])
-		if li != lj {
-			return li < lj
-		}
-		return executors[i].WorkerID < executors[j].WorkerID
-	})
-}
-
 // tryReserveExecutorCapacityForLane reserves an execution slot on the
 // per-lane reservation pool so that lanes cannot starve each other.
 func (r *Plugin) tryReserveExecutorCapacityForLane(
@@ -1656,8 +1577,6 @@ func (r *Plugin) DispatchProposals(
 			ExecutionTimeout:       defaultScheduledExecutionTimeout,
 			RetryBackoff:           defaultScheduledRetryBackoff,
 			ExecutorReserveBackoff: 200 * time.Millisecond,
-			LocalQueuePin:          defaultLocalQueuePin,
-			OrphanRehomeGrace:      defaultOrphanRehomeGrace,
 		}
 	}
 

weed/admin/plugin/plugin_scheduler_test.go

@@ -61,12 +61,6 @@ func TestLoadSchedulerPolicyUsesAdminConfig(t *testing.T) {
 	if policy.JobTypeMaxRuntime != 30*time.Minute {
 		t.Fatalf("unexpected max runtime: got=%v", policy.JobTypeMaxRuntime)
 	}
-	if policy.LocalQueuePin != defaultLocalQueuePin {
-		t.Fatalf("unexpected local queue pin: got=%d", policy.LocalQueuePin)
-	}
-	if policy.OrphanRehomeGrace != defaultOrphanRehomeGrace {
-		t.Fatalf("unexpected orphan rehome grace: got=%v", policy.OrphanRehomeGrace)
-	}
 }
 
 func TestLoadSchedulerPolicyUsesDescriptorDefaultsWhenConfigMissing(t *testing.T) {
@@ -144,13 +138,13 @@ func TestReserveScheduledExecutorRespectsPerWorkerLimit(t *testing.T) {
 		ExecutorReserveBackoff: time.Millisecond,
 	}
 
-	executor1, release1, err := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy, nil)
+	executor1, release1, err := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy)
 	if err != nil {
 		t.Fatalf("reserve executor 1: %v", err)
 	}
 	defer release1()
 
-	executor2, release2, err := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy, nil)
+	executor2, release2, err := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy)
 	if err != nil {
 		t.Fatalf("reserve executor 2: %v", err)
 	}
@@ -272,7 +266,7 @@ func TestReserveScheduledExecutorTimesOutWhenNoExecutor(t *testing.T) {
 
 	start := time.Now()
 	pluginSvc.Shutdown()
-	_, _, err = pluginSvc.reserveScheduledExecutor(context.Background(), "missing-job-type", policy, nil)
+	_, _, err = pluginSvc.reserveScheduledExecutor(context.Background(), "missing-job-type", policy)
 	if err == nil {
 		t.Fatalf("expected reservation shutdown error")
 	}
@@ -303,7 +297,7 @@ func TestReserveScheduledExecutorWaitsForWorkerCapacity(t *testing.T) {
 		ExecutorReserveBackoff: 5 * time.Millisecond,
 	}
 
-	_, release1, err := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy, nil)
+	_, release1, err := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy)
 	if err != nil {
 		t.Fatalf("reserve executor 1: %v", err)
 	}
@@ -314,7 +308,7 @@ func TestReserveScheduledExecutorWaitsForWorkerCapacity(t *testing.T) {
 	}
 	secondReserveCh := make(chan reserveResult, 1)
 	go func() {
-		_, release2, reserveErr := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy, nil)
+		_, release2, reserveErr := pluginSvc.reserveScheduledExecutor(context.Background(), "balance", policy)
 		if release2 != nil {
 			release2()
 		}
@@ -998,50 +992,3 @@ func TestLaneStatus_LifecycleNextDetectionSurvivesDefaultLanePrune(t *testing.T)
 			status.NextDetectionAt, expected)
 	}
 }
-
-func TestReserveWaterfillsPreferredHosts(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	ids := []string{"worker-a", "worker-b", "worker-c", "worker-d"}
-	for _, id := range ids {
-		pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
-			WorkerId: id,
-			Address:  "10.0.0.1:9334",
-			Capabilities: []*plugin_pb.JobTypeCapability{
-				{JobType: "erasure_coding", CanExecute: true, MaxExecutionConcurrency: 8},
-			},
-		})
-	}
-
-	policy := schedulerPolicy{
-		PerWorkerConcurrency:   8,
-		ExecutorReserveBackoff: time.Millisecond,
-		LocalQueuePin:          5,
-	}
-	preferred := []string{"10.0.0.1:8080"}
-
-	seen := map[string]int{}
-	var releases []func()
-	defer func() {
-		for _, release := range releases {
-			release()
-		}
-	}()
-	for i := 0; i < 4; i++ {
-		exec, release, err := pluginSvc.reserveScheduledExecutor(context.Background(), "erasure_coding", policy, preferred)
-		if err != nil {
-			t.Fatalf("reserve %d: %v", i, err)
-		}
-		releases = append(releases, release)
-		seen[exec.WorkerID]++
-	}
-	if len(seen) != 4 {
-		t.Fatalf("want one job per worker, got %v", seen)
-	}
-}

weed/admin/plugin/registry.go

@@ -277,24 +277,14 @@ func (r *Registry) PickDetector(jobType string) (*WorkerSession, error) {
 }
 
 // PickExecutor picks one executor worker for a job type.
-// preferredHosts, when set, ranks workers whose Hello Address host matches a
-// replica/source host ahead of others (same-machine EC pull). Empty means the
-// previous slots+round-robin order.
-func (r *Registry) PickExecutor(jobType string, preferredHosts ...string) (*WorkerSession, error) {
-	list, err := r.ListExecutors(jobType, preferredHosts...)
-	if err != nil {
-		return nil, err
-	}
-	return list[0], nil
+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.
-// preferredHosts, when any worker matches, are listed first (then the rest);
-// rotation applies only inside the preferred group so a local worker is not
-// rotated away in favor of a remote one.
-func (r *Registry) ListExecutors(jobType string, preferredHosts ...string) ([]*WorkerSession, error) {
+func (r *Registry) ListExecutors(jobType string) ([]*WorkerSession, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
@@ -303,16 +293,8 @@ func (r *Registry) ListExecutors(jobType string, preferredHosts ...string) ([]*W
 		return nil, fmt.Errorf("no executor worker available for job_type=%s", jobType)
 	}
 
-	pref, rest := partitionByPreferredHost(candidates, preferredHosts)
-	if len(pref) > 0 {
-		sortByKind(pref, jobType, false)
-		r.rotateTopCandidatesLocked(pref, jobType, false)
-		sortByKind(rest, jobType, false)
-		candidates = append(pref, rest...)
-	} else {
-		sortByKind(candidates, jobType, false)
-		r.rotateTopCandidatesLocked(candidates, jobType, false)
-	}
+	sortByKind(candidates, jobType, false)
+	r.rotateTopCandidatesLocked(candidates, jobType, false)
 
 	out := make([]*WorkerSession, 0, len(candidates))
 	for _, candidate := range candidates {

weed/admin/plugin/registry_test.go

@@ -401,70 +401,3 @@ func TestRegistryHasCapableWorkerIgnoresNilCapability(t *testing.T) {
 		t.Fatalf("expected HasCapableWorker to return false when capability has no detect or execute")
 	}
 }
-
-func TestListExecutorsPrefersMatchingReplicaHost(t *testing.T) {
-	t.Parallel()
-
-	r := NewRegistry()
-	r.UpsertFromHello(&plugin_pb.WorkerHello{
-		WorkerId: "worker-remote",
-		Address:  "10.87.0.4:33646",
-		Capabilities: []*plugin_pb.JobTypeCapability{
-			{JobType: "erasure_coding", CanExecute: true, MaxExecutionConcurrency: 8},
-		},
-	})
-	r.UpsertFromHello(&plugin_pb.WorkerHello{
-		WorkerId: "worker-local",
-		Address:  "10.87.0.3:33646",
-		Capabilities: []*plugin_pb.JobTypeCapability{
-			{JobType: "erasure_coding", CanExecute: true, MaxExecutionConcurrency: 1},
-		},
-	})
-	r.UpdateHeartbeat("worker-remote", &plugin_pb.WorkerHeartbeat{
-		WorkerId: "worker-remote", ExecutionSlotsUsed: 0, ExecutionSlotsTotal: 8,
-	})
-	r.UpdateHeartbeat("worker-local", &plugin_pb.WorkerHeartbeat{
-		WorkerId: "worker-local", ExecutionSlotsUsed: 0, ExecutionSlotsTotal: 1,
-	})
-
-	// Without preference the emptier remote worker wins on slots.
-	plain, err := r.ListExecutors("erasure_coding")
-	if err != nil {
-		t.Fatalf("ListExecutors: %v", err)
-	}
-	if plain[0].WorkerID != "worker-remote" {
-		t.Fatalf("without preference want remote first, got %s", plain[0].WorkerID)
-	}
-
-	// Replica on :8080 of the same host as worker-local.
-	pref, err := r.ListExecutors("erasure_coding", "10.87.0.3:8080")
-	if err != nil {
-		t.Fatalf("ListExecutors preferred: %v", err)
-	}
-	if pref[0].WorkerID != "worker-local" {
-		t.Fatalf("preferred host want worker-local first, got %s", pref[0].WorkerID)
-	}
-	if pref[1].WorkerID != "worker-remote" {
-		t.Fatalf("remote should still be fallback, got %s", pref[1].WorkerID)
-	}
-}
-
-func TestJobReplicaHostsFromSourcesAndReplicaServers(t *testing.T) {
-	t.Parallel()
-	job := &plugin_pb.JobSpec{
-		Parameters: map[string]*plugin_pb.ConfigValue{
-			"source_server": {
-				Kind: &plugin_pb.ConfigValue_StringValue{StringValue: "10.87.0.1:8080"},
-			},
-			"replica_servers": {
-				Kind: &plugin_pb.ConfigValue_StringList{
-					StringList: &plugin_pb.StringList{Values: []string{"10.87.0.1:8080", "10.87.0.2:8081"}},
-				},
-			},
-		},
-	}
-	got := JobReplicaHosts(job)
-	if len(got) != 2 {
-		t.Fatalf("got %v", got)
-	}
-}

weed/admin/plugin/worker_job_queues.go

@@ -1,317 +0,0 @@
-package plugin
-
-import (
-	"sync"
-	"time"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
-)
-
-// queuedJob is one scheduled spec parked on a home worker's admin-side queue.
-type queuedJob struct {
-	job  *plugin_pb.JobSpec
-	home string
-}
-
-// workerJobQueues holds per-worker FIFOs for one dispatch batch.
-// Home assignment is done once up front; run goroutines only pop/steal.
-// leftover is the homeless FIFO: replica hostnames with no currently
-// registered worker. Orphan grace does not apply here.
-type workerJobQueues struct {
-	mu           sync.Mutex
-	q            map[string][]*queuedJob
-	leftover     []*queuedJob
-	remaining    int
-	missingSince map[string]time.Time
-	homes        map[string]struct{}
-}
-
-func newWorkerJobQueues() *workerJobQueues {
-	return &workerJobQueues{
-		q:            make(map[string][]*queuedJob),
-		missingSince: make(map[string]time.Time),
-		homes:        make(map[string]struct{}),
-	}
-}
-
-func (qs *workerJobQueues) hasHome(workerID string) bool {
-	if qs == nil || workerID == "" {
-		return false
-	}
-	_, ok := qs.homes[workerID]
-	return ok
-}
-
-func (qs *workerJobQueues) push(home string, job *plugin_pb.JobSpec) {
-	if qs == nil || job == nil {
-		return
-	}
-	item := &queuedJob{job: job, home: home}
-	qs.mu.Lock()
-	defer qs.mu.Unlock()
-	qs.pushLocked(item, false)
-}
-
-func (qs *workerJobQueues) pushFront(item *queuedJob) {
-	if qs == nil || item == nil {
-		return
-	}
-	qs.mu.Lock()
-	defer qs.mu.Unlock()
-	qs.pushLocked(item, true)
-}
-
-func (qs *workerJobQueues) pushLocked(item *queuedJob, front bool) {
-	qs.remaining++
-	if item.home == "" {
-		if front {
-			qs.leftover = append([]*queuedJob{item}, qs.leftover...)
-			return
-		}
-		qs.leftover = append(qs.leftover, item)
-		return
-	}
-	if front {
-		qs.q[item.home] = append([]*queuedJob{item}, qs.q[item.home]...)
-		return
-	}
-	qs.q[item.home] = append(qs.q[item.home], item)
-}
-
-func (qs *workerJobQueues) isEmpty() bool {
-	if qs == nil {
-		return true
-	}
-	qs.mu.Lock()
-	defer qs.mu.Unlock()
-	return qs.remaining == 0
-}
-
-func (qs *workerJobQueues) queueLen(workerID string) int {
-	if qs == nil {
-		return 0
-	}
-	qs.mu.Lock()
-	defer qs.mu.Unlock()
-	return len(qs.q[workerID])
-}
-
-func (qs *workerJobQueues) leftoverLen() int {
-	if qs == nil {
-		return 0
-	}
-	qs.mu.Lock()
-	defer qs.mu.Unlock()
-	return len(qs.leftover)
-}
-
-func (qs *workerJobQueues) drain() []*queuedJob {
-	if qs == nil {
-		return nil
-	}
-	qs.mu.Lock()
-	defer qs.mu.Unlock()
-	out := make([]*queuedJob, 0, qs.remaining)
-	for id, qq := range qs.q {
-		out = append(out, qq...)
-		qs.q[id] = nil
-	}
-	out = append(out, qs.leftover...)
-	qs.leftover = nil
-	qs.remaining = 0
-	return out
-}
-
-func popFront(qq []*queuedJob) (*queuedJob, []*queuedJob) {
-	item := qq[0]
-	if len(qq) == 1 {
-		return item, nil
-	}
-	return item, qq[1:]
-}
-
-// assignJobsToWorkerQueues parks each job on the least-loaded replica-host
-// worker. A home exists only if a currently registered worker's -address
-// hostname matches a replica host. Otherwise the job is homeless: global
-// leftover FIFO, no fake home, no K, no orphan grace. Single-threaded.
-func (r *Plugin) assignJobsToWorkerQueues(
-	jobType string,
-	jobs []*plugin_pb.JobSpec,
-	_ schedulerPolicy,
-) *workerJobQueues {
-	qs := newWorkerJobQueues()
-	executors, err := r.registry.ListExecutors(jobType)
-	lane := JobTypeLane(jobType)
-	queued := make(map[string]int, len(executors))
-
-	for _, job := range jobs {
-		if job == nil {
-			continue
-		}
-		if err != nil || len(executors) == 0 {
-			qs.push("", job)
-			continue
-		}
-		pref, _ := partitionByPreferredHost(executors, JobReplicaHosts(job))
-		if len(pref) == 0 {
-			// Never registered for that hostname: homeless, not an orphan.
-			qs.push("", job)
-			continue
-		}
-		for _, e := range pref {
-			if e != nil && e.WorkerID != "" {
-				qs.homes[e.WorkerID] = struct{}{}
-			}
-		}
-		sortExecutorsByLoad(pref, func(e *WorkerSession) int {
-			return r.executorReservationLoad(e, lane) + queued[e.WorkerID]
-		})
-		home := pref[0].WorkerID
-		qs.push(home, job)
-		queued[home]++
-		r.bindQueuedJobWorker(job, home)
-	}
-	return qs
-}
-
-// takeQueuedJob pops a job for a free worker.
-// Home worker (hostname matched a replica / has a home-queue identity):
-//  1. own home queue
-//  2. steal from another home if len>=K, or orphan past OrphanRehomeGrace
-//  3. homeless leftover FIFO
-// No-home worker (no matching replica, no home-queue identity):
-//  1. homeless leftover FIFO
-//  2. only if leftover empty: steal (K / orphan), same rules
-func (r *Plugin) takeQueuedJob(
-	qs *workerJobQueues,
-	jobType string,
-	policy schedulerPolicy,
-) (item *queuedJob, targetID string) {
-	if qs == nil {
-		return nil, ""
-	}
-	executors, err := r.registry.ListExecutors(jobType)
-	if err != nil || len(executors) == 0 {
-		return nil, ""
-	}
-	lane := JobTypeLane(jobType)
-	pin := policy.LocalQueuePin
-	defer func() {
-		if item != nil && targetID != "" {
-			r.bindQueuedJobWorker(item.job, targetID)
-		}
-	}()
-
-	qs.mu.Lock()
-	defer qs.mu.Unlock()
-	if qs.remaining == 0 {
-		return nil, ""
-	}
-
-	var bestHome *WorkerSession
-	bestLoad := 0
-	for _, exec := range executors {
-		if len(qs.q[exec.WorkerID]) == 0 {
-			continue
-		}
-		limit := schedulerWorkerExecutionLimit(exec, jobType, policy)
-		if limit <= 0 {
-			continue
-		}
-		load := r.executorReservationLoad(exec, lane)
-		if load >= limit {
-			continue
-		}
-		if bestHome == nil || load < bestLoad || (load == bestLoad && exec.WorkerID < bestHome.WorkerID) {
-			bestHome = exec
-			bestLoad = load
-		}
-	}
-	if bestHome != nil {
-		id := bestHome.WorkerID
-		item, qs.q[id] = popFront(qs.q[id])
-		qs.remaining--
-		return item, id
-	}
-
-	var thief *WorkerSession
-	for _, exec := range executors {
-		limit := schedulerWorkerExecutionLimit(exec, jobType, policy)
-		if limit <= 0 {
-			continue
-		}
-		if r.executorReservationLoad(exec, lane) >= limit {
-			continue
-		}
-		if thief == nil || exec.WorkerID < thief.WorkerID {
-			thief = exec
-		}
-	}
-	if thief == nil {
-		return nil, ""
-	}
-
-	takeLeftover := func() (*queuedJob, string) {
-		if len(qs.leftover) == 0 {
-			return nil, ""
-		}
-		item, qs.leftover = popFront(qs.leftover)
-		qs.remaining--
-		return item, thief.WorkerID
-	}
-	if !qs.hasHome(thief.WorkerID) {
-		if item, id := takeLeftover(); item != nil {
-			return item, id
-		}
-	}
-
-	live := make(map[string]struct{}, len(executors))
-	for _, exec := range executors {
-		live[exec.WorkerID] = struct{}{}
-		delete(qs.missingSince, exec.WorkerID)
-	}
-
-	now := time.Now()
-	grace := policy.OrphanRehomeGrace
-	victimID := ""
-	victimLen := 0
-	victimOrphan := false
-	for id, qq := range qs.q {
-		if len(qq) == 0 {
-			delete(qs.missingSince, id)
-			continue
-		}
-		_, isLive := live[id]
-		orphan := !isLive
-		if isLive {
-			if pin > 0 && len(qq) < pin {
-				continue
-			}
-		} else {
-			if _, ok := qs.missingSince[id]; !ok {
-				qs.missingSince[id] = now
-			}
-			if grace > 0 && now.Sub(qs.missingSince[id]) < grace {
-				continue
-			}
-		}
-		better := victimID == ""
-		if !better && orphan != victimOrphan {
-			better = orphan
-		}
-		if !better && orphan == victimOrphan {
-			better = len(qq) > victimLen || (len(qq) == victimLen && id < victimID)
-		}
-		if better {
-			victimID = id
-			victimLen = len(qq)
-			victimOrphan = orphan
-		}
-	}
-	if victimID != "" {
-		item, qs.q[victimID] = popFront(qs.q[victimID])
-		qs.remaining--
-		return item, thief.WorkerID
-	}
-	return takeLeftover()
-}

weed/admin/plugin/worker_job_queues_test.go

@@ -1,600 +0,0 @@
-package plugin
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/plugin_pb"
-)
-
-func replicaJob(id, source string) *plugin_pb.JobSpec {
-	return &plugin_pb.JobSpec{
-		JobId:     id,
-		JobType:   "erasure_coding",
-		Summary:   id,
-		DedupeKey: id,
-		Parameters: map[string]*plugin_pb.ConfigValue{
-			"source_server": {
-				Kind: &plugin_pb.ConfigValue_StringValue{StringValue: source},
-			},
-		},
-	}
-}
-
-func registerECWorkers(t *testing.T, pluginSvc *Plugin, workers map[string]string) {
-	t.Helper()
-	for id, addr := range workers {
-		pluginSvc.registry.UpsertFromHello(&plugin_pb.WorkerHello{
-			WorkerId: id,
-			Address:  addr,
-			Capabilities: []*plugin_pb.JobTypeCapability{
-				{JobType: "erasure_coding", CanExecute: true, MaxExecutionConcurrency: 8},
-			},
-		})
-	}
-}
-
-func TestAssignJobsWaterfillsPreferredWorkers(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-a": "10.0.0.1:9334",
-		"worker-b": "10.0.0.2:9334",
-		"worker-c": "10.0.0.3:9334",
-		"worker-d": "10.0.0.4:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{
-		replicaJob("j1", "10.0.0.1:8080"),
-		replicaJob("j2", "10.0.0.1:8080"),
-		replicaJob("j3", "10.0.0.1:8080"),
-		replicaJob("j4", "10.0.0.1:8080"),
-	}
-	// All four replica IPs listed so every worker is preferred.
-	for _, job := range jobs {
-		job.Parameters["replica_servers"] = &plugin_pb.ConfigValue{
-			Kind: &plugin_pb.ConfigValue_StringList{StringList: &plugin_pb.StringList{
-				Values: []string{"10.0.0.1:8080", "10.0.0.2:8080", "10.0.0.3:8080", "10.0.0.4:8080"},
-			}},
-		}
-	}
-
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, schedulerPolicy{LocalQueuePin: 5})
-	if qs.queueLen("worker-a")+qs.queueLen("worker-b")+qs.queueLen("worker-c")+qs.queueLen("worker-d") != 4 {
-		t.Fatalf("expected 4 assigned jobs")
-	}
-	for _, id := range []string{"worker-a", "worker-b", "worker-c", "worker-d"} {
-		if qs.queueLen(id) != 1 {
-			t.Fatalf("want 1 job on %s, got %d", id, qs.queueLen(id))
-		}
-	}
-}
-
-func TestAssignAndTakeDoesNotStarveOtherHomes(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{
-		replicaJob("local-1", "10.0.0.1:8080"),
-		replicaJob("local-2", "10.0.0.1:8080"),
-		replicaJob("remote-1", "10.0.0.2:8080"),
-	}
-	policy := schedulerPolicy{PerWorkerConcurrency: 1, LocalQueuePin: 5}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-local") != 2 || qs.queueLen("worker-remote") != 1 {
-		t.Fatalf("homes local=%d remote=%d", qs.queueLen("worker-local"), qs.queueLen("worker-remote"))
-	}
-
-	_, target1 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	_, release1, err := pluginSvc.reserveExecutorByID("erasure_coding", policy, target1)
-	if err != nil {
-		t.Fatalf("reserve 1: %v", err)
-	}
-	defer release1()
-
-	item2, target2 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item2 == nil || target2 != "worker-remote" {
-		t.Fatalf("second take should start remote home, got job=%v target=%s", item2, target2)
-	}
-}
-
-func TestTakeStealsOnlyWhenHomeQueueReachesK(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := make([]*plugin_pb.JobSpec, 0, 6)
-	for i := 0; i < 6; i++ {
-		jobs = append(jobs, replicaJob(fmt.Sprintf("j%d", i), "10.0.0.1:8080"))
-	}
-	policy := schedulerPolicy{PerWorkerConcurrency: 1, LocalQueuePin: 5}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-local") != 6 {
-		t.Fatalf("all jobs should home on local, got %d", qs.queueLen("worker-local"))
-	}
-
-	_, target := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if target != "worker-local" {
-		t.Fatalf("first take want local, got %s", target)
-	}
-	_, release, err := pluginSvc.reserveExecutorByID("erasure_coding", policy, "worker-local")
-	if err != nil {
-		t.Fatalf("reserve local: %v", err)
-	}
-	defer release()
-
-	// 5 still queued on local (>=K) and local has no slot → steal to remote.
-	stolen, stealTarget := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if stolen == nil || stealTarget != "worker-remote" {
-		t.Fatalf("expected steal to remote, got job=%v target=%s", stolen, stealTarget)
-	}
-	if qs.queueLen("worker-local") != 4 {
-		t.Fatalf("after steal want 4 left on local, got %d", qs.queueLen("worker-local"))
-	}
-
-	// 4 < K: do not steal again.
-	if item, tgt := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy); item != nil {
-		t.Fatalf("pin should hold remaining jobs, got target=%s", tgt)
-	}
-}
-
-func TestTakeStealsImmediatelyWhenPinDisabled(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{
-		replicaJob("a", "10.0.0.1:8080"),
-		replicaJob("b", "10.0.0.1:8080"),
-	}
-	policy := schedulerPolicy{PerWorkerConcurrency: 1, LocalQueuePin: 0}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-
-	_, target := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if target != "worker-local" {
-		t.Fatalf("first take want local, got %s", target)
-	}
-	_, release, err := pluginSvc.reserveExecutorByID("erasure_coding", policy, "worker-local")
-	if err != nil {
-		t.Fatalf("reserve local: %v", err)
-	}
-	defer release()
-
-	stolen, stealTarget := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if stolen == nil || stealTarget != "worker-remote" {
-		t.Fatalf("K=0 should steal immediately, got job=%v target=%s", stolen, stealTarget)
-	}
-}
-
-func TestTakeStealsOrphanedHomeWithoutK(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{
-		replicaJob("o1", "10.0.0.1:8080"),
-		replicaJob("o2", "10.0.0.1:8080"),
-	}
-	policy := schedulerPolicy{
-		PerWorkerConcurrency: 1,
-		LocalQueuePin:        5,
-		OrphanRehomeGrace:    30 * time.Second,
-	}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-local") != 2 {
-		t.Fatalf("want 2 on local, got %d", qs.queueLen("worker-local"))
-	}
-
-	pluginSvc.registry.Remove("worker-local")
-
-	if item, tgt := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy); item != nil {
-		t.Fatalf("within grace should hold orphan queue, got target=%s", tgt)
-	}
-	if qs.queueLen("worker-local") != 2 {
-		t.Fatalf("held queue changed: %d", qs.queueLen("worker-local"))
-	}
-
-	qs.mu.Lock()
-	qs.missingSince["worker-local"] = time.Now().Add(-time.Minute)
-	qs.mu.Unlock()
-
-	stolen, stealTarget := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if stolen == nil || stealTarget != "worker-remote" {
-		t.Fatalf("after grace should steal without K, got job=%v target=%s", stolen, stealTarget)
-	}
-	if qs.queueLen("worker-local") != 1 {
-		t.Fatalf("want 1 orphan left, got %d", qs.queueLen("worker-local"))
-	}
-
-	stolen2, stealTarget2 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if stolen2 == nil || stealTarget2 != "worker-remote" {
-		t.Fatalf("second orphan should also move, got job=%v target=%s", stolen2, stealTarget2)
-	}
-}
-
-func TestTakeKeepsOrphanWhenHomeReconnectsDuringGrace(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{replicaJob("blink", "10.0.0.1:8080")}
-	policy := schedulerPolicy{
-		PerWorkerConcurrency: 1,
-		LocalQueuePin:        5,
-		OrphanRehomeGrace:    30 * time.Second,
-	}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	pluginSvc.registry.Remove("worker-local")
-	if item, _ := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy); item != nil {
-		t.Fatal("expected hold during grace")
-	}
-
-	registerECWorkers(t, pluginSvc, map[string]string{"worker-local": "10.0.0.1:9334"})
-	item, target := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item == nil || target != "worker-local" {
-		t.Fatalf("reconnected home should run its queue, got job=%v target=%s", item, target)
-	}
-}
-
-func TestTakeStealsOrphanImmediatelyWhenGraceDisabled(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{replicaJob("o1", "10.0.0.1:8080")}
-	policy := schedulerPolicy{PerWorkerConcurrency: 1, LocalQueuePin: 5, OrphanRehomeGrace: 0}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	pluginSvc.registry.Remove("worker-local")
-
-	stolen, stealTarget := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if stolen == nil || stealTarget != "worker-remote" {
-		t.Fatalf("grace=0 should steal immediately, got job=%v target=%s", stolen, stealTarget)
-	}
-}
-
-func TestBindQueuedJobWorkerKeepsPendingState(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	job := replicaJob("bind-1", "10.0.0.1:8080")
-	pluginSvc.trackExecutionQueued(job)
-	pluginSvc.bindQueuedJobWorker(job, "worker-local")
-
-	pluginSvc.jobsMu.Lock()
-	tracked := pluginSvc.jobs[job.JobId]
-	pluginSvc.jobsMu.Unlock()
-	if tracked == nil {
-		t.Fatal("missing tracked job")
-	}
-	if tracked.State != "job_state_pending" {
-		t.Fatalf("state=%s", tracked.State)
-	}
-	if tracked.Stage != "queued" {
-		t.Fatalf("stage=%s", tracked.Stage)
-	}
-	if tracked.WorkerID != "worker-local" {
-		t.Fatalf("worker=%s", tracked.WorkerID)
-	}
-}
-
-func TestHomelessAllRemoteWorkersUseFIFOWithoutPinOrGrace(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	// Workers never registered on the replica hostname — homeless, not orphan.
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-a": "10.0.0.5:9334",
-		"worker-b": "10.0.0.6:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{
-		replicaJob("h1", "10.0.0.1:8080"),
-		replicaJob("h2", "10.0.0.1:8080"),
-		replicaJob("h3", "10.0.0.1:8080"),
-	}
-	policy := schedulerPolicy{
-		PerWorkerConcurrency: 1,
-		LocalQueuePin:        5,
-		OrphanRehomeGrace:    30 * time.Second,
-	}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-a") != 0 || qs.queueLen("worker-b") != 0 {
-		t.Fatalf("homeless jobs must not get a fake home, a=%d b=%d", qs.queueLen("worker-a"), qs.queueLen("worker-b"))
-	}
-	if qs.leftoverLen() != 3 {
-		t.Fatalf("want 3 homeless FIFO, got %d", qs.leftoverLen())
-	}
-
-	item1, target1 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item1 == nil || item1.job.JobId != "h1" {
-		t.Fatalf("FIFO first want h1, got %v", item1)
-	}
-	_, release1, err := pluginSvc.reserveExecutorByID("erasure_coding", policy, target1)
-	if err != nil {
-		t.Fatalf("reserve 1: %v", err)
-	}
-	defer release1()
-
-	item2, target2 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item2 == nil || item2.job.JobId != "h2" {
-		t.Fatalf("FIFO second want h2 immediately, got %v", item2)
-	}
-	if target2 == "" || target2 == target1 {
-		t.Fatalf("second take should hit the other idle worker, t1=%s t2=%s", target1, target2)
-	}
-	if qs.leftoverLen() != 1 {
-		t.Fatalf("want 1 homeless left, got %d", qs.leftoverLen())
-	}
-}
-
-func TestMixedReplicaLocalJobsStayHomeBeforeHomeless(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{
-		replicaJob("local-1", "10.0.0.1:8080"),
-		replicaJob("local-2", "10.0.0.1:8080"),
-		replicaJob("homeless-1", "10.0.0.9:8080"),
-		replicaJob("homeless-2", "10.0.0.9:8080"),
-	}
-	policy := schedulerPolicy{
-		PerWorkerConcurrency: 1,
-		LocalQueuePin:        5,
-		OrphanRehomeGrace:    30 * time.Second,
-	}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-local") != 2 || qs.queueLen("worker-remote") != 0 || qs.leftoverLen() != 2 {
-		t.Fatalf("homes local=%d remote=%d leftover=%d", qs.queueLen("worker-local"), qs.queueLen("worker-remote"), qs.leftoverLen())
-	}
-
-	item1, target1 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item1 == nil || item1.job.JobId != "local-1" || target1 != "worker-local" {
-		t.Fatalf("first take want local-1 on home, got job=%v target=%s", item1, target1)
-	}
-	_, release, err := pluginSvc.reserveExecutorByID("erasure_coding", policy, "worker-local")
-	if err != nil {
-		t.Fatalf("reserve local: %v", err)
-	}
-	defer release()
-
-	item2, target2 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item2 == nil || item2.job.JobId != "homeless-1" || target2 != "worker-remote" {
-		t.Fatalf("remote should take homeless, not steal pinned home, got job=%v target=%s", item2, target2)
-	}
-	if qs.queueLen("worker-local") != 1 {
-		t.Fatalf("remaining replica-local job must stay home, got %d", qs.queueLen("worker-local"))
-	}
-	if qs.leftoverLen() != 1 {
-		t.Fatalf("one homeless should remain, leftover=%d", qs.leftoverLen())
-	}
-}
-
-func TestIdleHomeWorkerTakesHomelessAfterEmptyHomeQueue(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local": "10.0.0.1:9334",
-	})
-
-	jobs := []*plugin_pb.JobSpec{
-		replicaJob("home-1", "10.0.0.1:8080"),
-		replicaJob("homeless-1", "10.0.0.9:8080"),
-	}
-	policy := schedulerPolicy{
-		PerWorkerConcurrency: 1,
-		LocalQueuePin:        5,
-		OrphanRehomeGrace:    30 * time.Second,
-	}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-local") != 1 || qs.leftoverLen() != 1 {
-		t.Fatalf("home=%d leftover=%d", qs.queueLen("worker-local"), qs.leftoverLen())
-	}
-
-	item1, target1 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item1 == nil || item1.job.JobId != "home-1" || target1 != "worker-local" {
-		t.Fatalf("first take want home-1, got job=%v target=%s", item1, target1)
-	}
-	item2, target2 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item2 == nil || item2.job.JobId != "homeless-1" || target2 != "worker-local" {
-		t.Fatalf("idle home with empty queue may take homeless, got job=%v target=%s", item2, target2)
-	}
-	if qs.leftoverLen() != 0 {
-		t.Fatalf("homeless should be gone, leftover=%d", qs.leftoverLen())
-	}
-}
-
-func TestHomelessWorkerTakesFIFOBeforeStealableHome(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local":  "10.0.0.1:9334",
-		"worker-remote": "10.0.0.2:9334",
-	})
-
-	jobs := make([]*plugin_pb.JobSpec, 0, 7)
-	for i := 0; i < 6; i++ {
-		jobs = append(jobs, replicaJob(fmt.Sprintf("j%d", i), "10.0.0.1:8080"))
-	}
-	jobs = append(jobs, replicaJob("homeless-1", "10.0.0.9:8080"))
-	policy := schedulerPolicy{PerWorkerConcurrency: 1, LocalQueuePin: 5}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-local") != 6 || qs.leftoverLen() != 1 {
-		t.Fatalf("home=%d leftover=%d", qs.queueLen("worker-local"), qs.leftoverLen())
-	}
-	if qs.hasHome("worker-remote") {
-		t.Fatal("remote must have no home identity")
-	}
-
-	_, target := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if target != "worker-local" {
-		t.Fatalf("first take want local, got %s", target)
-	}
-	_, release, err := pluginSvc.reserveExecutorByID("erasure_coding", policy, "worker-local")
-	if err != nil {
-		t.Fatalf("reserve local: %v", err)
-	}
-	defer release()
-
-	item, takeTarget := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item == nil || takeTarget != "worker-remote" || item.job.JobId != "homeless-1" {
-		t.Fatalf("remote must take homeless FIFO before K-steal, got job=%v target=%s", item, takeTarget)
-	}
-	if qs.leftoverLen() != 0 {
-		t.Fatalf("homeless should be gone, leftover=%d", qs.leftoverLen())
-	}
-	if qs.queueLen("worker-local") != 5 {
-		t.Fatalf("stealable home must stay until FIFO empty, got %d", qs.queueLen("worker-local"))
-	}
-
-	stolen, stealTarget := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if stolen == nil || stealTarget != "worker-remote" || stolen.job.JobId == "homeless-1" {
-		t.Fatalf("after FIFO empty remote may steal >=K, got job=%v target=%s", stolen, stealTarget)
-	}
-}
-
-func TestHomeWorkerStealsBeforeHomelessAfterOwnQueueEmpty(t *testing.T) {
-	t.Parallel()
-
-	pluginSvc, err := New(Options{})
-	if err != nil {
-		t.Fatalf("New: %v", err)
-	}
-	defer pluginSvc.Shutdown()
-
-	registerECWorkers(t, pluginSvc, map[string]string{
-		"worker-local": "10.0.0.1:9334",
-		"worker-other": "10.0.0.2:9334",
-	})
-
-	jobs := make([]*plugin_pb.JobSpec, 0, 8)
-	for i := 0; i < 6; i++ {
-		jobs = append(jobs, replicaJob(fmt.Sprintf("j%d", i), "10.0.0.1:8080"))
-	}
-	jobs = append(jobs, replicaJob("other-1", "10.0.0.2:8080"))
-	jobs = append(jobs, replicaJob("homeless-1", "10.0.0.9:8080"))
-	policy := schedulerPolicy{PerWorkerConcurrency: 1, LocalQueuePin: 5}
-	qs := pluginSvc.assignJobsToWorkerQueues("erasure_coding", jobs, policy)
-	if qs.queueLen("worker-local") != 6 || qs.queueLen("worker-other") != 1 || qs.leftoverLen() != 1 {
-		t.Fatalf("local=%d other=%d leftover=%d", qs.queueLen("worker-local"), qs.queueLen("worker-other"), qs.leftoverLen())
-	}
-	if !qs.hasHome("worker-other") {
-		t.Fatal("other must keep home identity")
-	}
-
-	item1, target1 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item1 == nil || target1 != "worker-local" {
-		t.Fatalf("first take want local home, got job=%v target=%s", item1, target1)
-	}
-	_, release, err := pluginSvc.reserveExecutorByID("erasure_coding", policy, "worker-local")
-	if err != nil {
-		t.Fatalf("reserve local: %v", err)
-	}
-	defer release()
-
-	item2, target2 := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if item2 == nil || item2.job.JobId != "other-1" || target2 != "worker-other" {
-		t.Fatalf("other should drain own home first, got job=%v target=%s", item2, target2)
-	}
-
-	stolen, stealTarget := pluginSvc.takeQueuedJob(qs, "erasure_coding", policy)
-	if stolen == nil || stealTarget != "worker-other" || stolen.job.JobId == "homeless-1" {
-		t.Fatalf("home worker with empty own queue still steals before homeless, got job=%v target=%s", stolen, stealTarget)
-	}
-	if qs.leftoverLen() != 1 {
-		t.Fatalf("homeless should still wait, leftover=%d", qs.leftoverLen())
-	}
-}

weed/admin/static/js/admin.js

@@ -396,7 +396,11 @@ window.Dashboard = {
 // Initialize event handlers
 function initializeEventHandlers() {
     // S3 Bucket Management
-   
+    const createBucketForm = document.getElementById('createBucketForm');
+    if (createBucketForm) {
+        createBucketForm.addEventListener('submit', handleCreateBucket);
+    }
+
     // Delete bucket buttons
     document.addEventListener('click', function (e) {
         if (e.target.closest('.delete-bucket-btn')) {

weed/admin/topology/empty_disk_type_test.go

@@ -1,174 +0,0 @@
-package topology
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
-)
-
-// A master that answered a capacity question for a disk type a node lacks
-// published an empty DiskInfo of that type for the node: no capacity, no
-// volumes, DiskId 0 -- the same id as the node's real first disk. Disks are
-// keyed by node and disk id here, so whichever DiskInfo the map iteration
-// visited last won disk 0: an SSD-only node sometimes looked like an empty
-// HDD disk (and a balance destination for HDD volumes), and an HDD node
-// sometimes lost its volumes behind an empty "ssd" disk.
-func TestUpdateTopologyIgnoresEmptyDiskTypeEntries(t *testing.T) {
-	topo := &master_pb.TopologyInfo{
-		Id: "phantom_disk_types",
-		DataCenterInfos: []*master_pb.DataCenterInfo{{
-			Id: "dc1",
-			RackInfos: []*master_pb.RackInfo{{
-				Id: "rack1",
-				DataNodeInfos: []*master_pb.DataNodeInfo{
-					{
-						Id:      "ssd-node",
-						Address: "ssd-node:8080",
-						DiskInfos: map[string]*master_pb.DiskInfo{
-							"ssd": {Type: "ssd", MaxVolumeCount: 200, VolumeCount: 1,
-								VolumeInfos: []*master_pb.VolumeInformationMessage{{Id: 7, DiskType: "ssd"}}},
-							"": {Type: ""}, // the empty entry the master made up
-						},
-					},
-					{
-						Id:      "hdd-node",
-						Address: "hdd-node:8080",
-						DiskInfos: map[string]*master_pb.DiskInfo{
-							"": {Type: "", MaxVolumeCount: 100, VolumeCount: 1,
-								VolumeInfos: []*master_pb.VolumeInformationMessage{{Id: 3}}},
-							"ssd": {Type: "ssd"},
-						},
-					},
-					{
-						// An empty disk of unknown capacity with nothing else on the
-						// node is a disk, not a leftover: it must stay.
-						Id:        "new-node",
-						Address:   "new-node:8080",
-						DiskInfos: map[string]*master_pb.DiskInfo{"": {Type: ""}},
-					},
-				},
-			}},
-		}},
-	}
-
-	at := NewActiveTopology(0)
-	// Map iteration order is random; repeat so a shadowed disk would show.
-	for i := 0; i < 64; i++ {
-		if err := at.UpdateTopology(topo); err != nil {
-			t.Fatalf("UpdateTopology: %v", err)
-		}
-		for node, want := range map[string]string{"ssd-node": "ssd", "hdd-node": "", "new-node": ""} {
-			disks := at.GetNodeDisks(node)
-			if len(disks) != 1 || disks[0].DiskType != want || (node != "new-node" && disks[0].DiskInfo.MaxVolumeCount == 0) {
-				var got []string
-				for _, d := range disks {
-					got = append(got, "\""+d.DiskType+"\"")
-				}
-				t.Fatalf("pass %d: %s disks %v, want exactly its real %q disk", i, node, got, want)
-			}
-		}
-	}
-	if _, _, disks := CountTopologyResources(topo); disks != 3 {
-		t.Errorf("CountTopologyResources disks = %d, want 3 (a made-up empty entry is not a disk)", disks)
-	}
-}
-
-// The volume index is built from the per-disk map, so a shadowed disk 0 also
-// hid its volumes: planners failed to find a volume on the server that holds
-// it ("Could not find volume N on source server").
-func TestUpdateTopologyKeepsVolumesBehindEmptyDiskTypeEntries(t *testing.T) {
-	topo := &master_pb.TopologyInfo{
-		Id: "phantom_disk_types_index",
-		DataCenterInfos: []*master_pb.DataCenterInfo{{
-			Id: "dc1",
-			RackInfos: []*master_pb.RackInfo{{
-				Id: "rack1",
-				DataNodeInfos: []*master_pb.DataNodeInfo{{
-					Id:      "hdd-node",
-					Address: "hdd-node:8080",
-					DiskInfos: map[string]*master_pb.DiskInfo{
-						"": {Type: "", MaxVolumeCount: 100, VolumeCount: 1,
-							VolumeInfos: []*master_pb.VolumeInformationMessage{{Id: 3, Collection: "c1"}}},
-						"ssd": {Type: "ssd"},
-					},
-				}},
-			}},
-		}},
-	}
-
-	at := NewActiveTopology(0)
-	for i := 0; i < 64; i++ {
-		if err := at.UpdateTopology(topo); err != nil {
-			t.Fatalf("UpdateTopology: %v", err)
-		}
-		locations := at.GetVolumeLocations(3, "c1")
-		if len(locations) != 1 || locations[0].ServerID != "hdd-node" {
-			t.Fatalf("pass %d: volume 3 locations %+v, want it on hdd-node", i, locations)
-		}
-	}
-}
-
-// The made-up entry always carries DiskId 0, so it need not collide with a
-// real disk: here each node's only usable disk is location 1 (location 0 is
-// unavailable, so the volume server does not report it). The entry must still
-// not count as a disk, nor reach planners as an empty disk of unknown
-// capacity on a node that has no disk of its type.
-func TestUpdateTopologyIgnoresEmptyDiskTypeEntriesAtAnyDiskId(t *testing.T) {
-	topo := &master_pb.TopologyInfo{
-		Id: "phantom_disk_types_no_collision",
-		DataCenterInfos: []*master_pb.DataCenterInfo{{
-			Id: "dc1",
-			RackInfos: []*master_pb.RackInfo{{
-				Id: "rack1",
-				DataNodeInfos: []*master_pb.DataNodeInfo{
-					{
-						Id:      "ssd-node",
-						Address: "ssd-node:8080",
-						DiskInfos: map[string]*master_pb.DiskInfo{
-							"ssd": {Type: "ssd", DiskId: 1, MaxVolumeCount: 200, VolumeCount: 1,
-								MaxVolumeCountByDisk: map[uint32]int64{1: 200},
-								VolumeInfos:          []*master_pb.VolumeInformationMessage{{Id: 7, DiskType: "ssd", DiskId: 1}}},
-							"": {Type: ""},
-						},
-					},
-					{
-						Id:      "hdd-node",
-						Address: "hdd-node:8080",
-						DiskInfos: map[string]*master_pb.DiskInfo{
-							"": {Type: "", DiskId: 1, MaxVolumeCount: 100, VolumeCount: 1,
-								MaxVolumeCountByDisk: map[uint32]int64{1: 100},
-								VolumeInfos:          []*master_pb.VolumeInformationMessage{{Id: 3, DiskId: 1}}},
-							"ssd": {Type: "ssd"},
-						},
-					},
-				},
-			}},
-		}},
-	}
-
-	at := NewActiveTopology(0)
-	for i := 0; i < 16; i++ {
-		if err := at.UpdateTopology(topo); err != nil {
-			t.Fatalf("UpdateTopology: %v", err)
-		}
-		for node, want := range map[string]string{"ssd-node": "ssd", "hdd-node": ""} {
-			disks := at.GetNodeDisks(node)
-			if len(disks) != 1 || disks[0].DiskType != want || disks[0].DiskID != 1 {
-				var got []string
-				for _, d := range disks {
-					got = append(got, fmt.Sprintf("%q@%d", d.DiskType, d.DiskID))
-				}
-				t.Fatalf("pass %d: %s disks %v, want only its real %q disk 1", i, node, got, want)
-			}
-		}
-	}
-	for _, disk := range at.GetDisksWithEffectiveCapacity(TaskTypeBalance, "", 1) {
-		if disk.DiskID == 0 {
-			t.Errorf("planners offered %s disk 0 (%q), which does not exist", disk.NodeID, disk.DiskType)
-		}
-	}
-	if _, _, disks := CountTopologyResources(topo); disks != 2 {
-		t.Errorf("CountTopologyResources disks = %d, want 2", disks)
-	}
-}

weed/admin/topology/topology_management.go

@@ -9,36 +9,6 @@ import (
 	"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding"
 )
 
-// isEmptyDiskTypeEntry reports a DiskInfo with no capacity and nothing on it.
-func isEmptyDiskTypeEntry(diskInfo *master_pb.DiskInfo) bool {
-	return diskInfo != nil &&
-		diskInfo.MaxVolumeCount <= 0 &&
-		diskInfo.VolumeCount == 0 &&
-		diskInfo.RemoteVolumeCount == 0 &&
-		len(diskInfo.VolumeInfos) == 0 &&
-		len(diskInfo.EcShardInfos) == 0 &&
-		len(diskInfo.MaxVolumeCountByDisk) == 0
-}
-
-// IsPhantomDiskTypeEntry reports whether node's DiskInfo of diskType is an
-// empty entry on a node that has a disk of another type with capacity or
-// data. Masters used to publish such an entry for every disk type a capacity
-// check had asked about; keyed by node and disk id it can replace or pose as
-// a real disk and be offered to planners as an empty destination of a type
-// the node lacks. A node whose entries are all empty keeps them, as disks of
-// unknown capacity.
-func IsPhantomDiskTypeEntry(node *master_pb.DataNodeInfo, diskType string) bool {
-	if node == nil || !isEmptyDiskTypeEntry(node.DiskInfos[diskType]) {
-		return false
-	}
-	for otherType, other := range node.DiskInfos {
-		if otherType != diskType && other != nil && !isEmptyDiskTypeEntry(other) {
-			return true
-		}
-	}
-	return false
-}
-
 // CountTopologyResources counts datacenters, nodes, and disks in topology info
 func CountTopologyResources(topologyInfo *master_pb.TopologyInfo) (dcCount, nodeCount, diskCount int) {
 	if topologyInfo == nil {
@@ -52,10 +22,7 @@ func CountTopologyResources(topologyInfo *master_pb.TopologyInfo) (dcCount, node
 				// DiskInfos is keyed by disk type, so same-type physical disks
 				// collapse into one entry. Count physical disks so the number
 				// matches the per-disk activeDisk map.
-				for diskType, diskInfo := range node.DiskInfos {
-					if IsPhantomDiskTypeEntry(node, diskType) {
-						continue
-					}
+				for _, diskInfo := range node.DiskInfos {
 					diskCount += len(diskInfo.SplitByPhysicalDisk())
 				}
 			}
@@ -115,9 +82,6 @@ func (at *ActiveTopology) UpdateTopology(topologyInfo *master_pb.TopologyInfo) e
 				// One activeDisk per physical disk_id: the master keys
 				// DiskInfos by disk type, so same-type disks must be split out.
 				for diskType, diskInfo := range nodeInfo.DiskInfos {
-					if IsPhantomDiskTypeEntry(nodeInfo, diskType) {
-						continue
-					}
 					perDiskInfos := diskInfo.SplitByPhysicalDisk()
 					for _, perDisk := range perDiskInfos {
 						disk := &activeDisk{

weed/admin/view/app/admin.templ

@@ -256,13 +256,11 @@ templ Admin(data dash.AdminData) {
                                                     if tier.IsRemote {
                                                         <span class="text-muted">-</span>
                                                     } else {
-                                                        <div class="d-flex align-items-center">
-                                                            <div class="progress flex-grow-1" style="height: 20px; min-width: 48px;">
-                                                                <div class="progress-bar" role="progressbar"
-                                                                     style={fmt.Sprintf("width: %d%%", tier.UsagePercent())}>
-                                                                </div>
+                                                        <div class="progress" style="height: 20px;">
+                                                            <div class="progress-bar" role="progressbar"
+                                                                 style={fmt.Sprintf("width: %d%%", tier.UsagePercent())}>
+                                                                {fmt.Sprintf("%d%%", tier.UsagePercent())}
                                                             </div>
-                                                            <span class="ms-2 text-nowrap">{fmt.Sprintf("%d%%", tier.UsagePercent())}</span>
                                                         </div>
                                                     }
                                                 </td>
@@ -447,13 +445,11 @@ templ Admin(data dash.AdminData) {
                                             <td>{vs.DataCenter}</td>
                                             <td>{vs.Rack}</td>
                                             <td>
-                                                <div class="d-flex align-items-center">
-                                                    <div class="progress flex-grow-1" style="height: 20px; min-width: 48px;">
-                                                        <div class="progress-bar" role="progressbar" 
-                                                             style={fmt.Sprintf("width: %d%%", calculatePercent(vs.Volumes, vs.MaxVolumes))}>
-                                                        </div>
+                                                <div class="progress" style="height: 20px;">
+                                                    <div class="progress-bar" role="progressbar" 
+                                                         style={fmt.Sprintf("width: %d%%", calculatePercent(vs.Volumes, vs.MaxVolumes))}>
+                                                        {fmt.Sprintf("%d/%d", vs.Volumes, vs.MaxVolumes)}
                                                     </div>
-                                                    <span class="ms-2 text-nowrap">{fmt.Sprintf("%d/%d", vs.Volumes, vs.MaxVolumes)}</span>
                                                 </div>
                                             </td>
                                             <td>

weed/admin/view/app/admin_templ.go

@@ -342,33 +342,33 @@ func Admin(data dash.AdminData) templ.Component {
 						return templ_7745c5c3_Err
 					}
 				} else {
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 32, "<div class=\"d-flex align-items-center\"><div class=\"progress flex-grow-1\" style=\"height: 20px; min-width: 48px;\"><div class=\"progress-bar\" role=\"progressbar\" style=\"")
+					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 32, "<div class=\"progress\" style=\"height: 20px;\"><div class=\"progress-bar\" role=\"progressbar\" style=\"")
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
 					var templ_7745c5c3_Var18 string
 					templ_7745c5c3_Var18, templ_7745c5c3_Err = templruntime.SanitizeStyleAttributeValues(fmt.Sprintf("width: %d%%", tier.UsagePercent()))
 					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 262, Col: 123}
+						return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 261, Col: 119}
 					}
 					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 33, "\"></div></div><span class=\"ms-2 text-nowrap\">")
+					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 33, "\">")
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
 					var templ_7745c5c3_Var19 string
 					templ_7745c5c3_Var19, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d%%", tier.UsagePercent()))
 					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 265, Col: 132}
+						return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 262, Col: 105}
 					}
 					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var19))
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 34, "</span></div>")
+					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 34, "</div></div>")
 					if templ_7745c5c3_Err != nil {
 						return templ_7745c5c3_Err
 					}
@@ -390,7 +390,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var20 templ.SafeURL
 		templ_7745c5c3_Var20, templ_7745c5c3_Err = templ.JoinURLErrs(dash.PUrl(ctx, "/cluster/mount-clients"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 288, Col: 74}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 286, Col: 74}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var20))
 		if templ_7745c5c3_Err != nil {
@@ -403,7 +403,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var21 string
 		templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d", data.TotalMountClients))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 296, Col: 126}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 294, Col: 126}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
 		if templ_7745c5c3_Err != nil {
@@ -421,7 +421,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var22 templ.SafeURL
 			templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinURLErrs(templ.SafeURL(fmt.Sprintf("//%s/ui/index.html", master.Address)))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 327, Col: 121}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 325, Col: 121}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
 			if templ_7745c5c3_Err != nil {
@@ -434,7 +434,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var23 string
 			templ_7745c5c3_Var23, templ_7745c5c3_Err = templ.JoinStringErrs(master.Address)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 328, Col: 67}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 326, Col: 67}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var23))
 			if templ_7745c5c3_Err != nil {
@@ -467,7 +467,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var24 string
 		templ_7745c5c3_Var24, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d", len(data.MasterNodes)))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 361, Col: 85}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 359, Col: 85}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var24))
 		if templ_7745c5c3_Err != nil {
@@ -480,7 +480,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var25 string
 		templ_7745c5c3_Var25, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d", len(data.VolumeServers)))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 369, Col: 87}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 367, Col: 87}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var25))
 		if templ_7745c5c3_Err != nil {
@@ -493,7 +493,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var26 string
 		templ_7745c5c3_Var26, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d", len(data.FilerNodes)))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 377, Col: 84}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 375, Col: 84}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var26))
 		if templ_7745c5c3_Err != nil {
@@ -506,7 +506,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var27 string
 		templ_7745c5c3_Var27, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d", len(data.S3Nodes)))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 385, Col: 81}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 383, Col: 81}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var27))
 		if templ_7745c5c3_Err != nil {
@@ -519,7 +519,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var28 string
 		templ_7745c5c3_Var28, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d", len(data.MessageBrokers)))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 393, Col: 88}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 391, Col: 88}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var28))
 		if templ_7745c5c3_Err != nil {
@@ -532,7 +532,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var29 templ.SafeURL
 		templ_7745c5c3_Var29, templ_7745c5c3_Err = templ.JoinURLErrs(dash.PUrl(ctx, "/volumes"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 418, Col: 90}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 416, Col: 90}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var29))
 		if templ_7745c5c3_Err != nil {
@@ -545,7 +545,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var30 templ.SafeURL
 		templ_7745c5c3_Var30, templ_7745c5c3_Err = templ.JoinURLErrs(dash.PUrl(ctx, "/cluster"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 419, Col: 90}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 417, Col: 90}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var30))
 		if templ_7745c5c3_Err != nil {
@@ -563,7 +563,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var31 string
 			templ_7745c5c3_Var31, templ_7745c5c3_Err = templ.JoinStringErrs(vs.ID)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 440, Col: 54}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 438, Col: 54}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var31))
 			if templ_7745c5c3_Err != nil {
@@ -576,7 +576,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var32 templ.SafeURL
 			templ_7745c5c3_Var32, templ_7745c5c3_Err = templ.JoinURLErrs(templ.SafeURL(fmt.Sprintf("//%s/ui/index.html", vs.GetDisplayAddress())))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 442, Col: 129}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 440, Col: 129}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var32))
 			if templ_7745c5c3_Err != nil {
@@ -589,7 +589,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var33 string
 			templ_7745c5c3_Var33, templ_7745c5c3_Err = templ.JoinStringErrs(vs.GetDisplayAddress())
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 443, Col: 75}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 441, Col: 75}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var33))
 			if templ_7745c5c3_Err != nil {
@@ -602,7 +602,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var34 string
 			templ_7745c5c3_Var34, templ_7745c5c3_Err = templ.JoinStringErrs(vs.DataCenter)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 447, Col: 62}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 445, Col: 62}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var34))
 			if templ_7745c5c3_Err != nil {
@@ -615,39 +615,39 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var35 string
 			templ_7745c5c3_Var35, templ_7745c5c3_Err = templ.JoinStringErrs(vs.Rack)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 448, Col: 56}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 446, Col: 56}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var35))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 59, "</td><td><div class=\"d-flex align-items-center\"><div class=\"progress flex-grow-1\" style=\"height: 20px; min-width: 48px;\"><div class=\"progress-bar\" role=\"progressbar\" style=\"")
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 59, "</td><td><div class=\"progress\" style=\"height: 20px;\"><div class=\"progress-bar\" role=\"progressbar\" style=\"")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var36 string
 			templ_7745c5c3_Var36, templ_7745c5c3_Err = templruntime.SanitizeStyleAttributeValues(fmt.Sprintf("width: %d%%", calculatePercent(vs.Volumes, vs.MaxVolumes)))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 453, Col: 139}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 450, Col: 135}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var36))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 60, "\"></div></div><span class=\"ms-2 text-nowrap\">")
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 60, "\">")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 			var templ_7745c5c3_Var37 string
 			templ_7745c5c3_Var37, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d/%d", vs.Volumes, vs.MaxVolumes))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 456, Col: 131}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 451, Col: 104}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var37))
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 61, "</span></div></td><td>")
+			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 61, "</div></div></td><td>")
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
@@ -659,7 +659,7 @@ func Admin(data dash.AdminData) templ.Component {
 				var templ_7745c5c3_Var38 string
 				templ_7745c5c3_Var38, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d", vs.EcShards))
 				if templ_7745c5c3_Err != nil {
-					return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 461, Col: 127}
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 457, Col: 127}
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var38))
 				if templ_7745c5c3_Err != nil {
@@ -677,7 +677,7 @@ func Admin(data dash.AdminData) templ.Component {
 					var templ_7745c5c3_Var39 string
 					templ_7745c5c3_Var39, templ_7745c5c3_Err = templ.JoinStringErrs(fmt.Sprintf("%d vol", vs.EcVolumes))
 					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 463, Col: 119}
+						return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 459, Col: 119}
 					}
 					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var39))
 					if templ_7745c5c3_Err != nil {
@@ -701,7 +701,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var40 string
 			templ_7745c5c3_Var40, templ_7745c5c3_Err = templ.JoinStringErrs(formatBytes(vs.DiskUsage))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 470, Col: 74}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 466, Col: 74}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var40))
 			if templ_7745c5c3_Err != nil {
@@ -714,7 +714,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var41 string
 			templ_7745c5c3_Var41, templ_7745c5c3_Err = templ.JoinStringErrs(formatBytes(vs.DiskCapacity))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 470, Col: 107}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 466, Col: 107}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var41))
 			if templ_7745c5c3_Err != nil {
@@ -732,7 +732,7 @@ func Admin(data dash.AdminData) templ.Component {
 				var templ_7745c5c3_Var42 string
 				templ_7745c5c3_Var42, templ_7745c5c3_Err = templ.JoinStringErrs(formatBytes(vs.RemoteSize))
 				if templ_7745c5c3_Err != nil {
-					return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 473, Col: 137}
+					return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 469, Col: 137}
 				}
 				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var42))
 				if templ_7745c5c3_Err != nil {
@@ -761,7 +761,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var43 templ.SafeURL
 		templ_7745c5c3_Var43, templ_7745c5c3_Err = templ.JoinURLErrs(dash.PUrl(ctx, "/filer"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 508, Col: 88}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 504, Col: 88}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var43))
 		if templ_7745c5c3_Err != nil {
@@ -774,7 +774,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var44 templ.SafeURL
 		templ_7745c5c3_Var44, templ_7745c5c3_Err = templ.JoinURLErrs(dash.PUrl(ctx, "/cluster"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 509, Col: 90}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 505, Col: 90}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var44))
 		if templ_7745c5c3_Err != nil {
@@ -792,7 +792,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var45 templ.SafeURL
 			templ_7745c5c3_Var45, templ_7745c5c3_Err = templ.JoinURLErrs(templ.SafeURL(fmt.Sprintf("//%s", filer.Address)))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 528, Col: 106}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 524, Col: 106}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var45))
 			if templ_7745c5c3_Err != nil {
@@ -805,7 +805,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var46 string
 			templ_7745c5c3_Var46, templ_7745c5c3_Err = templ.JoinStringErrs(filer.Address)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 529, Col: 66}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 525, Col: 66}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var46))
 			if templ_7745c5c3_Err != nil {
@@ -818,7 +818,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var47 string
 			templ_7745c5c3_Var47, templ_7745c5c3_Err = templ.JoinStringErrs(filer.DataCenter)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 533, Col: 65}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 529, Col: 65}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var47))
 			if templ_7745c5c3_Err != nil {
@@ -831,7 +831,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var48 string
 			templ_7745c5c3_Var48, templ_7745c5c3_Err = templ.JoinStringErrs(filer.Rack)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 534, Col: 59}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 530, Col: 59}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var48))
 			if templ_7745c5c3_Err != nil {
@@ -844,7 +844,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var49 string
 			templ_7745c5c3_Var49, templ_7745c5c3_Err = templ.JoinStringErrs(filer.LastUpdated.Format("2006-01-02 15:04:05"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 535, Col: 96}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 531, Col: 96}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var49))
 			if templ_7745c5c3_Err != nil {
@@ -868,7 +868,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var50 templ.SafeURL
 		templ_7745c5c3_Var50, templ_7745c5c3_Err = templ.JoinURLErrs(dash.PUrl(ctx, "/cluster/s3"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 568, Col: 93}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 564, Col: 93}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var50))
 		if templ_7745c5c3_Err != nil {
@@ -886,7 +886,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var51 string
 			templ_7745c5c3_Var51, templ_7745c5c3_Err = templ.JoinStringErrs(s3Node.Address)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 585, Col: 63}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 581, Col: 63}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var51))
 			if templ_7745c5c3_Err != nil {
@@ -899,7 +899,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var52 string
 			templ_7745c5c3_Var52, templ_7745c5c3_Err = templ.JoinStringErrs(s3Node.DataCenter)
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 586, Col: 66}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 582, Col: 66}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var52))
 			if templ_7745c5c3_Err != nil {
@@ -912,7 +912,7 @@ func Admin(data dash.AdminData) templ.Component {
 			var templ_7745c5c3_Var53 string
 			templ_7745c5c3_Var53, templ_7745c5c3_Err = templ.JoinStringErrs(s3Node.LastUpdated.Format("2006-01-02 15:04:05"))
 			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 587, Col: 97}
+				return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 583, Col: 97}
 			}
 			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var53))
 			if templ_7745c5c3_Err != nil {
@@ -936,7 +936,7 @@ func Admin(data dash.AdminData) templ.Component {
 		var templ_7745c5c3_Var54 string
 		templ_7745c5c3_Var54, templ_7745c5c3_Err = templ.JoinStringErrs(data.LastUpdated.Format("2006-01-02 15:04:05"))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 611, Col: 81}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `view/app/admin.templ`, Line: 607, Col: 81}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var54))
 		if templ_7745c5c3_Err != nil {

weed/command/filer.go

@@ -154,7 +154,7 @@ func init() {
 	filerS3Options.metricsHttpPort = cmdFiler.Flag.Int("s3.metricsPort", 0, "Prometheus metrics listen port")
 	filerS3Options.metricsHttpIp = cmdFiler.Flag.String("s3.metricsIp", "", "metrics listen ip. If empty, default to same as -s3.ip.bind option.")
 	cmdFiler.Flag.Bool("s3.allowEmptyFolder", true, "deprecated, ignored. Empty folder cleanup is now automatic.")
-	filerS3Options.allowDeleteBucketNotEmpty = cmdFiler.Flag.Bool("s3.allowDeleteBucketNotEmpty", false, "allow recursive deleting all entries along with bucket")
+	filerS3Options.allowDeleteBucketNotEmpty = cmdFiler.Flag.Bool("s3.allowDeleteBucketNotEmpty", true, "allow recursive deleting all entries along with bucket")
 	filerS3Options.autoCreateBucket = cmdFiler.Flag.Bool("s3.autoCreateBucket", true, "create the bucket on upload if it does not exist, for admin identities only")
 	filerS3Options.localSocket = cmdFiler.Flag.String("s3.localSocket", "", "default to /tmp/seaweedfs-s3-<port>.sock")
 	filerS3Options.tlsCACertificate = cmdFiler.Flag.String("s3.cacert.file", "", "path to the TLS CA certificate file")
@@ -280,6 +280,9 @@ func runFiler(cmd *Command, args []string) bool {
 			filerS3Options.bindIp = f.bindIp
 		}
 		filerS3Options.localFilerSocket = f.localSocket
+		if *f.dataCenter != "" && *filerS3Options.dataCenter == "" {
+			filerS3Options.dataCenter = f.dataCenter
+		}
 		// Set S3 metrics IP based on bind IP if not explicitly set
 		if *filerS3Options.metricsHttpIp == "" {
 			*filerS3Options.metricsHttpIp = *filerS3Options.bindIp
@@ -321,6 +324,9 @@ func runFiler(cmd *Command, args []string) bool {
 		if *filerSftpOptions.bindIp == "" {
 			filerSftpOptions.bindIp = f.bindIp
 		}
+		if *f.dataCenter != "" && *filerSftpOptions.dataCenter == "" {
+			filerSftpOptions.dataCenter = f.dataCenter
+		}
 		go func(delay time.Duration) {
 			time.Sleep(delay * time.Second)
 			filerSftpOptions.startSftpServer()

weed/command/filer_remote_gateway_buckets.go

@@ -359,21 +359,13 @@ func (option *RemoteGatewayOptions) makeBucketedEventProcessor(filerSource *sour
 					if message.OldEntry.RemoteEntry != nil && filer.IsSameData(message.OldEntry, message.NewEntry) {
 						glog.V(2).Infof("update meta: %+v", resp)
 						oldDest := toRemoteStorageLocation(oldBucket, util.NewFullPath(resp.Directory, message.OldEntry.Name), oldRemoteStorageMountLocation)
-						updated, err := client.UpdateFileMetadata(oldDest, message.OldEntry, message.NewEntry)
-						if err != nil {
+						if err := client.UpdateFileMetadata(oldDest, message.OldEntry, message.NewEntry); err != nil {
 							return err
 						}
 						remoteEntry := message.NewEntry.RemoteEntry
 						if remoteEntry == nil {
 							remoteEntry = message.OldEntry.RemoteEntry
 						}
-						// the metadata write can rewrite the object (S3 copies
-						// it in place for a Content-Encoding change, minting a
-						// new ETag): restamp from the object the update
-						// produced when the backend reports it
-						if updated != nil {
-							remoteEntry = updated
-						}
 						return updateLocalEntry(option, message.NewParentPath, message.NewEntry, remoteEntry)
 					} else {
 						newDest := toRemoteStorageLocation(newBucket, util.NewFullPath(message.NewParentPath, message.NewEntry.Name), newRemoteStorageMountLocation)

weed/command/filer_remote_sync_dir.go

@@ -242,6 +242,20 @@ func processDeleteEvent(
 		if err := releasePendingSource(filerSource, client, mountedDir, remoteStorageMountLocation, message.OldEntry); err != nil {
 			return err
 		}
+		// The object at the key may have been replaced since the delete: a
+		// rename copies another entry's content onto it, a rewrite uploads
+		// over it, and a copy can land before its entry is visible. Delete
+		// only an object the event's stamp still describes.
+		if live, statErr := client.StatFile(dest); statErr == nil {
+			if oldRemote := message.OldEntry.GetRemoteEntry(); oldRemote == nil ||
+				!describes(oldRemote, live) ||
+				oldRemote.RemoteETag != "" && live.RemoteETag == "" {
+				glog.V(0).Infof("keep %s: the object changed since the delete", remote_storage.FormatLocation(dest))
+				return nil
+			}
+		} else if !errors.Is(statErr, remote_storage.ErrRemoteObjectNotFound) {
+			return statErr
+		}
 		current, err := currentEntry(filerSource, resp.Directory, message.OldEntry.Name)
 		if err != nil {
 			return err
@@ -255,12 +269,8 @@ func processDeleteEvent(
 		glog.V(0).Infof("rmdir  %s", remote_storage.FormatLocation(dest))
 		return client.RemoveDirectory(dest)
 	}
-	// The object at the key may have been replaced since the delete: a rename
-	// copies another entry's content onto it, a rewrite uploads over it, and a
-	// copy can land before its entry is visible. Delete only an object the
-	// event's stamp still describes.
 	glog.V(0).Infof("delete %s", remote_storage.FormatLocation(dest))
-	return deleteRemoteFileIfUnchanged(client, dest, message.OldEntry.GetRemoteEntry())
+	return deleteRemoteFile(client, dest)
 }
 
 // releasePendingSource deletes the source a pending-rename marker on entry
@@ -283,8 +293,19 @@ func releasePendingSource(filerSource filer_pb.FilerClient, client remote_storag
 		glog.V(0).Infof("keep %s: a remote-only entry holds the pending rename's source", remote_storage.FormatLocation(srcDest))
 		return nil
 	}
+	live, err := client.StatFile(srcDest)
+	if errors.Is(err, remote_storage.ErrRemoteObjectNotFound) {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	if stamp := entry.GetRemoteEntry(); !describes(stamp, live) || stamp.RemoteETag != "" && live.RemoteETag == "" {
+		glog.V(0).Infof("keep %s: the pending rename's source changed since", remote_storage.FormatLocation(srcDest))
+		return nil
+	}
 	glog.V(0).Infof("delete %s, the source of a pending rename", remote_storage.FormatLocation(srcDest))
-	return deleteRemoteFileIfUnchanged(client, srcDest, entry.GetRemoteEntry())
+	return deleteRemoteFile(client, srcDest)
 }
 
 // deleteRemoteFile deletes the object and treats an already-absent object as
@@ -296,32 +317,6 @@ func deleteRemoteFile(client remote_storage.RemoteStorageClient, dest *remote_pb
 	return nil
 }
 
-// deleteRemoteFileIfUnchanged deletes the object only while it is still the
-// one stamp describes. Backends offering a conditional delete bind the check
-// and the delete into one preconditioned request; the rest fall back to a
-// guarded stat-then-delete.
-func deleteRemoteFileIfUnchanged(client remote_storage.RemoteStorageClient, dest *remote_pb.RemoteStorageLocation, stamp *filer_pb.RemoteEntry) error {
-	if deleter, ok := client.(remote_storage.RemoteStorageConditionalDeleter); ok {
-		deleted, err := deleter.DeleteFileIfUnchanged(dest, stamp)
-		if err != nil {
-			return err
-		}
-		if !deleted {
-			glog.V(0).Infof("keep %s: the object changed since the delete", remote_storage.FormatLocation(dest))
-		}
-		return nil
-	}
-	live, err := client.StatFile(dest)
-	if err != nil && !errors.Is(err, remote_storage.ErrRemoteObjectNotFound) {
-		return err
-	}
-	if err == nil && !remote_storage.StillCurrent(stamp, live) {
-		glog.V(0).Infof("keep %s: the object changed since the delete", remote_storage.FormatLocation(dest))
-		return nil
-	}
-	return deleteRemoteFile(client, dest)
-}
-
 func processUpdateEvent(
 	filerClient filer_pb.FilerClient,
 	filerSource filer_pb.FilerClient,
@@ -341,16 +336,14 @@ func processUpdateEvent(
 	}
 	oldDest := toRemoteStorageLocation(util.FullPath(mountedDir), util.NewFullPath(resp.Directory, message.OldEntry.Name), remoteStorageMountLocation)
 	dest := toRemoteStorageLocation(util.FullPath(mountedDir), util.NewFullPath(message.NewParentPath, message.NewEntry.Name), remoteStorageMountLocation)
-	eventSource := renameSource{path: util.NewFullPath(resp.Directory, message.OldEntry.Name), loc: oldDest, stamp: message.OldEntry.GetRemoteEntry()}
 	// sourceOf is where a remote-only entry's content is: the source its
 	// pending-rename marker names, which may be an earlier rename's old key,
 	// or else the event's old key
-	sourceOf := func(entry *filer_pb.Entry, fallback renameSource) renameSource {
+	sourceOf := func(entry *filer_pb.Entry, eventSource *remote_pb.RemoteStorageLocation) *remote_pb.RemoteStorageLocation {
 		if src := string(entry.Extended[filer.ExtRemoteRenameSourceKey]); strings.HasPrefix(src, strings.TrimSuffix(mountedDir, "/")+"/") {
-			// a pending entry carries the stamp of the source it reads
-			return renameSource{path: util.FullPath(src), loc: toRemoteStorageLocation(util.FullPath(mountedDir), util.FullPath(src), remoteStorageMountLocation), stamp: entry.GetRemoteEntry()}
+			return toRemoteStorageLocation(util.FullPath(mountedDir), util.FullPath(src), remoteStorageMountLocation)
 		}
-		return fallback
+		return eventSource
 	}
 	if proto.Equal(oldDest, dest) && !shouldSendToRemote(message.NewEntry) {
 		glog.V(2).Infof("skipping updating: %+v", resp)
@@ -370,16 +363,9 @@ func processUpdateEvent(
 		}
 		if remoteEntry != nil {
 			glog.V(2).Infof("update meta: %+v", resp)
-			updated, err := client.UpdateFileMetadata(dest, message.OldEntry, remoteWriteEntry(message.NewEntry, storageClass))
-			if err != nil {
+			if err := client.UpdateFileMetadata(dest, message.OldEntry, remoteWriteEntry(message.NewEntry, storageClass)); err != nil {
 				return err
 			}
-			// a metadata write can rewrite the object (S3 copies it in place
-			// for a Content-Encoding change, minting a new ETag): restamp from
-			// the object the update produced when the backend reports it
-			if updated != nil {
-				remoteEntry = updated
-			}
 			return updateLocalEntry(filerClient, message.NewParentPath, message.NewEntry, remoteEntry)
 		}
 		glog.V(0).Infof("never replicated, uploading %s", remote_storage.FormatLocation(dest))
@@ -398,13 +384,13 @@ func processUpdateEvent(
 			return err
 		}
 		if isRemoteOnly(current) {
-			source := sourceOf(current, eventSource)
+			source := sourceOf(current, oldDest)
 			if err := completeRemoteOnlyRename(filerClient, client, message.NewParentPath, current, source, dest, storageClass); err != nil {
 				return err
 			}
 			// a pending entry the filer copied on this rename leaves the
 			// source its marker named
-			if pending := sourceOf(message.OldEntry, renameSource{}); pending.loc != nil && !proto.Equal(pending.loc, source.loc) {
+			if pending := sourceOf(message.OldEntry, nil); pending != nil && !proto.Equal(pending, source) {
 				return releasePendingSource(filerSource, client, mountedDir, remoteStorageMountLocation, message.OldEntry)
 			}
 			return nil
@@ -430,7 +416,7 @@ func processUpdateEvent(
 	if errors.Is(writeErr, errSuperseded) {
 		glog.Errorf("skipping %s: %v", remote_storage.FormatLocation(dest), writeErr)
 		if !proto.Equal(oldDest, dest) {
-			if err := uploadCurrentEntry(filerClient, filerSource, client, message.NewParentPath, message.NewEntry.Name, eventSource, dest, storageClass, sourceOf); err != nil {
+			if err := uploadCurrentEntry(filerClient, filerSource, client, message.NewParentPath, message.NewEntry.Name, oldDest, dest, storageClass, sourceOf); err != nil {
 				return err
 			}
 			return releaseRenamedSource(filerSource, client, mountedDir, remoteStorageMountLocation, message)
@@ -495,16 +481,9 @@ func isRemoteOnly(entry *filer_pb.Entry) bool {
 // copied over the destination, the entry is stamped with the copy, and the
 // old key goes. With neither object present the content is lost: the event
 // fails and holds the offset for recovery.
-func completeRemoteOnlyRename(filerClient filer_pb.FilerClient, client remote_storage.RemoteStorageClient, dir string, current *filer_pb.Entry, source renameSource, dest *remote_pb.RemoteStorageLocation, storageClass string) error {
-	oldDest := source.loc
-	// the source's recorded stamp; a retry can find the entry already
-	// stamped with the copy, whose ETag a multipart source does not share
-	sourceStamp := source.stamp
-	if sourceStamp == nil {
-		sourceStamp = proto.Clone(current.RemoteEntry).(*filer_pb.RemoteEntry)
-	}
+func completeRemoteOnlyRename(filerClient filer_pb.FilerClient, client remote_storage.RemoteStorageClient, dir string, current *filer_pb.Entry, oldDest, dest *remote_pb.RemoteStorageLocation, storageClass string) error {
 	if existing, err := client.StatFile(dest); err == nil {
-		if remote_storage.Describes(current.RemoteEntry, existing) {
+		if describes(current.RemoteEntry, existing) {
 			glog.V(0).Infof("%s already holds the renamed content", remote_storage.FormatLocation(dest))
 			if len(current.Extended[filer.ExtRemoteRenameSourceKey]) > 0 {
 				// reads still go to the source until the stamp clears the marker
@@ -512,7 +491,7 @@ func completeRemoteOnlyRename(filerClient filer_pb.FilerClient, client remote_st
 					return err
 				}
 			}
-			return deleteRenameSource(filerClient, client, dir, current.Name, source, sourceStamp)
+			return deleteRenameSource(filerClient, client, dir, current.Name, oldDest)
 		}
 		glog.V(0).Infof("%s holds an object the entry does not describe (size %d, want %d); replacing it from %s", remote_storage.FormatLocation(dest), existing.RemoteSize, current.RemoteEntry.RemoteSize, remote_storage.FormatLocation(oldDest))
 	} else if !errors.Is(err, remote_storage.ErrRemoteObjectNotFound) {
@@ -538,34 +517,32 @@ func completeRemoteOnlyRename(filerClient filer_pb.FilerClient, client remote_st
 	if err := updateLocalEntry(filerClient, dir, current, remoteEntry); err != nil {
 		return err
 	}
-	return deleteRenameSource(filerClient, client, dir, current.Name, source, sourceStamp)
-}
-
-// renameSource is where a renamed remote-only entry's content was read
-// from: the path, the object it maps to, and the stamp describing it.
-type renameSource struct {
-	path  util.FullPath
-	loc   *remote_pb.RemoteStorageLocation
-	stamp *filer_pb.RemoteEntry
+	return deleteRenameSource(filerClient, client, dir, current.Name, oldDest)
 }
 
 // deleteRenameSource deletes a rename's old key once the renamed entry no
 // longer reads it: an entry still carrying the pending-source marker (its
-// stamp lost a race) keeps the source, and the event is retried. The key is
-// left alone when the object there is no longer the one stamp describes, as
-// when another rename copied onto it, visible yet or not.
-func deleteRenameSource(filerClient filer_pb.FilerClient, client remote_storage.RemoteStorageClient, dir, name string, source renameSource, stamp *filer_pb.RemoteEntry) error {
+// stamp lost a race) keeps the source, and the event is retried.
+func deleteRenameSource(filerClient filer_pb.FilerClient, client remote_storage.RemoteStorageClient, dir, name string, oldDest *remote_pb.RemoteStorageLocation) error {
 	current, err := currentEntry(filerClient, dir, name)
 	if err != nil {
 		return err
 	}
 	if current != nil && len(current.Extended[filer.ExtRemoteRenameSourceKey]) > 0 {
-		return fmt.Errorf("%s still reads %s", util.NewFullPath(dir, name), remote_storage.FormatLocation(source.loc))
+		return fmt.Errorf("%s still reads %s", util.NewFullPath(dir, name), remote_storage.FormatLocation(oldDest))
 	}
-	if err := deleteRemoteFileIfUnchanged(client, source.loc, stamp); err != nil {
-		return err
+	return deleteRemoteFile(client, oldDest)
+}
+
+// describes reports whether the object a stat returned is the one the entry's
+// stamp describes: same size, and the same ETag when both sides carry one (a
+// copy written as one stream can legitimately carry a different ETag from a
+// multipart original).
+func describes(stamp, object *filer_pb.RemoteEntry) bool {
+	if stamp == nil || object == nil || stamp.RemoteSize != object.RemoteSize {
+		return false
 	}
-	return nil
+	return stamp.RemoteETag == "" || object.RemoteETag == "" || stamp.RemoteETag == object.RemoteETag
 }
 
 // openRemoteObject streams the object when the client can, and reads it whole
@@ -590,7 +567,7 @@ func openRemoteObject(client remote_storage.RemoteStorageClient, loc *remote_pb.
 // up once. A remote-only entry is finished the way completeRemoteOnlyRename
 // finishes a rename: its stamp can already describe the destination (a sync
 // plus remote.uncache in the meantime), and only then is it complete.
-func uploadCurrentEntry(filerClient filer_pb.FilerClient, filerSource filer_pb.FilerClient, client remote_storage.RemoteStorageClient, dir, name string, oldSource renameSource, dest *remote_pb.RemoteStorageLocation, storageClass string, sourceOf func(*filer_pb.Entry, renameSource) renameSource) error {
+func uploadCurrentEntry(filerClient filer_pb.FilerClient, filerSource filer_pb.FilerClient, client remote_storage.RemoteStorageClient, dir, name string, oldDest, dest *remote_pb.RemoteStorageLocation, storageClass string, sourceOf func(*filer_pb.Entry, *remote_pb.RemoteStorageLocation) *remote_pb.RemoteStorageLocation) error {
 	current, _, _, err := filer_pb.GetEntry(context.Background(), filerSource, util.NewFullPath(dir, name))
 	if errors.Is(err, filer_pb.ErrNotFound) {
 		return nil
@@ -602,7 +579,7 @@ func uploadCurrentEntry(filerClient filer_pb.FilerClient, filerSource filer_pb.F
 		return nil
 	}
 	if isRemoteOnly(current) {
-		return completeRemoteOnlyRename(filerClient, client, dir, current, sourceOf(current, oldSource), dest, storageClass)
+		return completeRemoteOnlyRename(filerClient, client, dir, current, sourceOf(current, oldDest), dest, storageClass)
 	}
 	if shouldSendToRemote(current) {
 		glog.V(0).Infof("leaving %s to the rewrite that superseded the rename", remote_storage.FormatLocation(dest))

weed/command/filer_remote_sync_dir_test.go

@@ -691,14 +691,8 @@ type recordingRemote struct {
 	// objects present on the remote, by path: StatFile and ReadFile answer
 	// from it, everything else is ErrRemoteObjectNotFound.
 	objects map[string][]byte
-	// statETag is the ETag StatFile reports for a present object, unless
-	// statETags names one for its path.
-	statETag  string
-	statETags map[string]string
-	statMtime int64
-	// metadataUpdateResult is the RemoteEntry UpdateFileMetadata reports; nil
-	// means the update left the object untouched
-	metadataUpdateResult *filer_pb.RemoteEntry
+	// statETag is the ETag StatFile reports for a present object.
+	statETag string
 }
 
 func (r *recordingRemote) WriteFile(loc *remote_pb.RemoteStorageLocation, entry *filer_pb.Entry, reader io.Reader) (*filer_pb.RemoteEntry, error) {
@@ -727,11 +721,7 @@ func (r *recordingRemote) StatFile(loc *remote_pb.RemoteStorageLocation) (*filer
 	if !ok {
 		return nil, remote_storage.ErrRemoteObjectNotFound
 	}
-	etag := r.statETag
-	if e, ok := r.statETags[loc.Path]; ok {
-		etag = e
-	}
-	return &filer_pb.RemoteEntry{StorageName: loc.Name, RemoteSize: int64(len(body)), RemoteETag: etag, RemoteMtime: r.statMtime}, nil
+	return &filer_pb.RemoteEntry{StorageName: loc.Name, RemoteSize: int64(len(body)), RemoteETag: r.statETag}, nil
 }
 
 func (r *recordingRemote) ReadFile(loc *remote_pb.RemoteStorageLocation, offset int64, size int64) ([]byte, error) {
@@ -747,9 +737,9 @@ func (r *recordingRemote) DeleteFile(loc *remote_pb.RemoteStorageLocation) error
 	return r.deleteErr
 }
 
-func (r *recordingRemote) UpdateFileMetadata(loc *remote_pb.RemoteStorageLocation, oldEntry, newEntry *filer_pb.Entry) (*filer_pb.RemoteEntry, error) {
+func (r *recordingRemote) UpdateFileMetadata(loc *remote_pb.RemoteStorageLocation, oldEntry, newEntry *filer_pb.Entry) error {
 	r.metadataUpdates = append(r.metadataUpdates, loc)
-	return r.metadataUpdateResult, nil
+	return nil
 }
 
 // TestRenameWithInheritedRemoteEntryWritesNewKey reproduces #11261: a rename
@@ -1397,7 +1387,7 @@ func TestSupersededRenameUploadsCurrentEntry(t *testing.T) {
 		current := entryWith("b.txt", &filer_pb.RemoteEntry{StorageName: "gcs", RemoteMtime: 1786096669, RemoteSize: 1024})
 		remote := &recordingRemote{}
 		filerClient := &stubFilerClient{entry: current}
-		err := uploadCurrentEntry(filerClient, filerClient, remote, "/buckets/b/dir", "b.txt", renameSource{loc: wantDelete}, wantWrite, "", eventSource)
+		err := uploadCurrentEntry(filerClient, filerClient, remote, "/buckets/b/dir", "b.txt", wantDelete, wantWrite, "", eventSource)
 		if err == nil || !strings.Contains(err.Error(), "neither") {
 			t.Errorf("err = %v, want the lost-content failure", err)
 		}
@@ -1408,9 +1398,9 @@ func TestSupersededRenameUploadsCurrentEntry(t *testing.T) {
 
 	t.Run("uncached with the destination already synced: complete without a write", func(t *testing.T) {
 		current := entryWith("b.txt", &filer_pb.RemoteEntry{StorageName: "gcs", RemoteMtime: 1786096669, RemoteSize: 7})
-		remote := &recordingRemote{objects: map[string][]byte{"/b/dir/a.txt": []byte("payload"), "/b/dir/b.txt": []byte("payload")}}
+		remote := &recordingRemote{objects: map[string][]byte{"/b/dir/b.txt": []byte("payload")}}
 		filerClient := &stubFilerClient{entry: current}
-		if err := uploadCurrentEntry(filerClient, filerClient, remote, "/buckets/b/dir", "b.txt", renameSource{loc: wantDelete}, wantWrite, "", eventSource); err != nil {
+		if err := uploadCurrentEntry(filerClient, filerClient, remote, "/buckets/b/dir", "b.txt", wantDelete, wantWrite, "", eventSource); err != nil {
 			t.Fatalf("err = %v, want nil: the destination object matches the entry's stamp", err)
 		}
 		if len(remote.writes) != 0 {
@@ -1443,7 +1433,7 @@ func TestCompleteRemoteOnlyRenameClearsThePendingSourceFirst(t *testing.T) {
 		current := pending()
 		filerClient := &stubFilerClient{entry: current}
 		remote := &recordingRemote{objects: objects(), statETag: `"copy"`}
-		if err := completeRemoteOnlyRename(filerClient, remote, "/buckets/b/dst", current, renameSource{path: "/buckets/b/src/a.jpg", loc: oldDest}, dest, ""); err != nil {
+		if err := completeRemoteOnlyRename(filerClient, remote, "/buckets/b/dst", current, oldDest, dest, ""); err != nil {
 			t.Fatalf("err = %v", err)
 		}
 		if filerClient.updates != 1 {
@@ -1458,7 +1448,7 @@ func TestCompleteRemoteOnlyRenameClearsThePendingSourceFirst(t *testing.T) {
 		// the stamp did not land: the filer still has the marker
 		filerClient := &stubFilerClient{entry: pending()}
 		remote := &recordingRemote{objects: objects(), statETag: `"copy"`}
-		if err := completeRemoteOnlyRename(filerClient, remote, "/buckets/b/dst", pending(), renameSource{path: "/buckets/b/src/a.jpg", loc: oldDest}, dest, ""); err == nil {
+		if err := completeRemoteOnlyRename(filerClient, remote, "/buckets/b/dst", pending(), oldDest, dest, ""); err == nil {
 			t.Fatal("err = nil, want the event retried")
 		}
 		if len(remote.deletes) != 0 {
@@ -1468,8 +1458,8 @@ func TestCompleteRemoteOnlyRenameClearsThePendingSourceFirst(t *testing.T) {
 }
 
 // eventSource resolves a rename's source to the event's old key.
-func eventSource(_ *filer_pb.Entry, source renameSource) renameSource {
-	return source
+func eventSource(_ *filer_pb.Entry, oldDest *remote_pb.RemoteStorageLocation) *remote_pb.RemoteStorageLocation {
+	return oldDest
 }
 
 func TestRenameOfAPendingEntryFollowsItsSource(t *testing.T) {
@@ -1515,7 +1505,7 @@ func TestRenameOfAPendingEntryFollowsItsSource(t *testing.T) {
 
 	t.Run("the second rename copies from the marker's source", func(t *testing.T) {
 		current := pendingC()
-		remote := &recordingRemote{objects: objects(), statETag: `"a"`}
+		remote := &recordingRemote{objects: objects()}
 		filerClient := &stubFilerClient{entry: current}
 		if err := processUpdateEvent(filerClient, filerClient, "", remote, mountedDir, mountLoc, event("b.jpg", "c.jpg")); err != nil {
 			t.Fatal(err)
@@ -1721,98 +1711,3 @@ func TestMetadataOnlyUpdateRestampsSyncTs(t *testing.T) {
 		t.Error("the restamped entry should read synced")
 	}
 }
-
-func TestCompleteRemoteOnlyRenameKeepsAReusedOldKey(t *testing.T) {
-	// A was renamed to B, then D to A before the sync got to the first
-	// rename: the object at A is now D's, and the only copy of it
-	oldDest := &remote_pb.RemoteStorageLocation{Name: "b2", Bucket: "bucket", Path: "/b/a.jpg"}
-	dest := &remote_pb.RemoteStorageLocation{Name: "b2", Bucket: "bucket", Path: "/b/b.jpg"}
-	current := &filer_pb.Entry{Name: "b.jpg", RemoteEntry: &filer_pb.RemoteEntry{RemoteETag: `"a"`, RemoteSize: 6}}
-	remote := &recordingRemote{objects: map[string][]byte{"/b/a.jpg": []byte("data-d"), "/b/b.jpg": []byte("data-a")}, statETag: `"a"`}
-	remote.statETags = map[string]string{"/b/a.jpg": `"d"`}
-	filerClient := &stubFilerClient{entry: current}
-	if err := completeRemoteOnlyRename(filerClient, remote, "/buckets/b", current, renameSource{path: "/buckets/b/a.jpg", loc: oldDest}, dest, ""); err != nil {
-		t.Fatal(err)
-	}
-	if len(remote.deletes) != 0 {
-		t.Errorf("deletes = %+v, want the reused key kept", remote.deletes)
-	}
-}
-
-func TestCompleteRemoteOnlyRenameRetryUsesTheSourceStamp(t *testing.T) {
-	// an earlier run copied a multipart source and stamped the entry with
-	// the copy's ETag, then failed to delete the source
-	oldDest := &remote_pb.RemoteStorageLocation{Name: "b2", Bucket: "bucket", Path: "/b/a.jpg"}
-	dest := &remote_pb.RemoteStorageLocation{Name: "b2", Bucket: "bucket", Path: "/b/b.jpg"}
-	current := &filer_pb.Entry{Name: "b.jpg", RemoteEntry: &filer_pb.RemoteEntry{RemoteETag: `"copy"`, RemoteSize: 6}}
-	remote := &recordingRemote{objects: map[string][]byte{"/b/a.jpg": []byte("data-a"), "/b/b.jpg": []byte("data-a")},
-		statETags: map[string]string{"/b/a.jpg": `"a-2"`, "/b/b.jpg": `"copy"`}}
-	source := renameSource{path: "/buckets/b/a.jpg", loc: oldDest, stamp: &filer_pb.RemoteEntry{RemoteETag: `"a-2"`, RemoteSize: 6}}
-	if err := completeRemoteOnlyRename(&stubFilerClient{entry: current}, remote, "/buckets/b", current, source, dest, ""); err != nil {
-		t.Fatal(err)
-	}
-	if len(remote.deletes) != 1 || remote.deletes[0].Path != "/b/a.jpg" {
-		t.Errorf("deletes = %+v, want the unchanged source deleted on the retry", remote.deletes)
-	}
-}
-
-// TestMetadataUpdateRestampsTheUpdatedObject: a metadata-only update can
-// rewrite the remote object itself (S3 changes Content-Encoding through an
-// in-place copy, minting a new ETag and mtime). The stamp saved back to the
-// filer must be the one the update produced — a stat instead could fail the
-// freshness comparison on the legitimately new ETag and keep the stale
-// stamp, so a later delete would keep the object.
-func TestMetadataUpdateRestampsTheUpdatedObject(t *testing.T) {
-	const mountedDir = "/buckets"
-	mountLoc := &remote_pb.RemoteStorageLocation{Name: "gcs", Bucket: "bucket", Path: "/"}
-	stamp := &filer_pb.RemoteEntry{StorageName: "gcs", RemoteETag: `"orig"`, RemoteSize: 3, RemoteMtime: 100}
-	resp := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/b/vol",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:      &filer_pb.Entry{Name: "f", Attributes: &filer_pb.FuseAttributes{Mtime: 100}, RemoteEntry: stamp},
-			NewParentPath: "/buckets/b/vol",
-			NewEntry: &filer_pb.Entry{Name: "f", Attributes: &filer_pb.FuseAttributes{Mtime: 100}, RemoteEntry: stamp,
-				Extended: map[string][]byte{"Content-Encoding": []byte("gzip")}},
-		},
-	}
-	remote := &recordingRemote{
-		objects:              map[string][]byte{"/b/vol/f": []byte("old")},
-		metadataUpdateResult: &filer_pb.RemoteEntry{StorageName: "gcs", RemoteETag: `"new"`, RemoteSize: 3, RemoteMtime: 200},
-	}
-	filerClient := &stubFilerClient{}
-	if err := processUpdateEvent(filerClient, filerClient, "", remote, mountedDir, mountLoc, resp); err != nil {
-		t.Fatal(err)
-	}
-	if len(remote.metadataUpdates) != 1 {
-		t.Fatalf("metadataUpdates = %+v, want one", remote.metadataUpdates)
-	}
-	got := filerClient.updated.Entry.RemoteEntry
-	if filerClient.updates != 1 || got.RemoteMtime != 200 || got.RemoteETag != `"new"` {
-		t.Fatalf("stamped RemoteEntry = %+v, want the update's result (mtime 200, etag \"new\")", got)
-	}
-}
-
-// TestMetadataUpdateKeepsTheStoredStampOnNilResult: a backend that did not
-// rewrite the object reports no stamp; the entry keeps its own.
-func TestMetadataUpdateKeepsTheStoredStampOnNilResult(t *testing.T) {
-	const mountedDir = "/buckets"
-	mountLoc := &remote_pb.RemoteStorageLocation{Name: "gcs", Bucket: "bucket", Path: "/"}
-	stamp := &filer_pb.RemoteEntry{StorageName: "gcs", RemoteETag: `"orig"`, RemoteSize: 3, RemoteMtime: 100}
-	resp := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/b/vol",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:      &filer_pb.Entry{Name: "f", Attributes: &filer_pb.FuseAttributes{Mtime: 100}, RemoteEntry: stamp},
-			NewParentPath: "/buckets/b/vol",
-			NewEntry: &filer_pb.Entry{Name: "f", Attributes: &filer_pb.FuseAttributes{Mtime: 100}, RemoteEntry: stamp,
-				Extended: map[string][]byte{"Content-Encoding": []byte("gzip")}},
-		},
-	}
-	remote := &recordingRemote{objects: map[string][]byte{"/b/vol/f": []byte("old")}}
-	filerClient := &stubFilerClient{}
-	if err := processUpdateEvent(filerClient, filerClient, "", remote, mountedDir, mountLoc, resp); err != nil {
-		t.Fatal(err)
-	}
-	if filerClient.updates != 1 || filerClient.updated.Entry.RemoteEntry.RemoteMtime != 100 {
-		t.Fatalf("stamped RemoteEntry = %+v, want the entry's own stamp kept (mtime 100)", filerClient.updated.Entry.RemoteEntry)
-	}
-}

weed/command/mini.go

@@ -12,7 +12,6 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
-	"sort"
 	"strings"
 	"sync"
 	"time"
@@ -65,9 +64,8 @@ var (
 	miniS3Options     S3Options
 	miniWebDavOptions WebDavOption
 	miniAdminOptions  AdminOptions
-	// Flags explicitly provided on the command line or via WEED_* env vars,
-	// captured before the saved options file is applied
-	explicitFlags                 map[string]bool
+	// Track which port flags were explicitly passed on CLI before config file is applied
+	explicitPortFlags             map[string]bool
 	miniEnableWebDAV              *bool
 	miniEnableS3                  *bool
 	miniEnableAdminUI             *bool
@@ -378,19 +376,6 @@ The S3 endpoint is available at http://localhost:8333. For client
 configuration and IAM setup, see the project documentation or use the
 Admin UI (http://localhost:23646) to manage users and policies.
 
-Notes:
-- Values mini computes itself (currently master.volumeSizeLimitMB) are
-  pinned in <dir>/mini.options and applied again on the next start to
-  keep them stable; applied values are printed at startup. Command-line
-  flags are never saved and always win over saved values. Edit or
-  delete mini.options to reset a computed value.
-- The official Docker image ships /etc/seaweedfs/filer.toml, which keeps
-  the filer metadata in /data/filerldb2 regardless of -dir; mini warns
-  at startup when a configured store dir is outside -dir. If you set
-  -dir to another path, keep /data on a persistent volume as well.
-  Otherwise the metadata is lost when the container is recreated, and
-  buckets list no objects although the volume files are still in -dir.
-
 `,
 }
 
@@ -407,7 +392,7 @@ var (
 	miniMetricsHttpIp               = cmdMini.Flag.String("metricsIp", "", "metrics listen ip. If empty, default to same as -ip.bind option.")
 	miniS3Config                    = cmdMini.Flag.String("s3.config", "", "path to the S3 config file")
 	miniIamConfig                   = cmdMini.Flag.String("s3.iam.config", "", "path to the advanced IAM config file for S3")
-	miniS3AllowDeleteBucketNotEmpty = cmdMini.Flag.Bool("s3.allowDeleteBucketNotEmpty", false, "allow recursive deleting all entries along with bucket")
+	miniS3AllowDeleteBucketNotEmpty = cmdMini.Flag.Bool("s3.allowDeleteBucketNotEmpty", true, "allow recursive deleting all entries along with bucket")
 	miniS3AutoCreateBucket          = cmdMini.Flag.Bool("s3.autoCreateBucket", true, "create the bucket on upload if it does not exist, for admin identities only")
 	miniBucket                      = cmdMini.Flag.String("bucket", "", "comma-separated S3 bucket names to create on startup if they do not already exist; leave empty to skip. Falls back to S3_BUCKET env var.")
 	miniTableBucket                 = cmdMini.Flag.String("tableBucket", "", "comma-separated S3 Tables buckets to create on startup if they do not already exist, each name[:FORMAT] with FORMAT one of ICEBERG (default) or LANCE, e.g. warehouse,vectors:LANCE; leave empty to skip. Falls back to S3_TABLE_BUCKET env var.")
@@ -501,7 +486,6 @@ func initMiniVolumeFlags() {
 	miniOptions.v.readMode = cmdMini.Flag.String("volume.readMode", "proxy", "[local|proxy|redirect] how to deal with non-local volume: 'not found|read in remote node|redirect volume location'.")
 	miniOptions.v.compactionMBPerSecond = cmdMini.Flag.Int("volume.compactionMBps", 0, "limit compaction speed in mega bytes per second")
 	miniOptions.v.maintenanceMBPerSecond = cmdMini.Flag.Int("volume.maintenanceMBps", 0, "limit maintenance IO rate in MB/s")
-	miniOptions.v.maxParallelVacuumCommits = cmdMini.Flag.Int("volume.compactionMaxParallelCommits", 0, "limit how many vacuum commits run at once on this server; queued commits hold no volume lock. 0 means unlimited")
 	miniOptions.v.fileSizeLimitMB = cmdMini.Flag.Int("volume.fileSizeLimitMB", 256, "limit file size to avoid out of memory")
 	miniOptions.v.ldbTimeout = cmdMini.Flag.Int64("volume.index.leveldbTimeout", 0, "alive time for leveldb")
 	miniOptions.v.concurrentUploadLimitMB = cmdMini.Flag.Int("volume.concurrentUploadLimitMB", 0, "limit total concurrent upload size")
@@ -839,8 +823,8 @@ func findAvailablePortOnIP(ip string, startPort int, maxAttempts int, reservedPo
 // If the port is not available, it finds the next available port and updates the pointer
 // The reservedPorts map contains ports that should not be allocated (for gRPC collision avoidance)
 func ensurePortAvailableOnIP(portPtr *int, serviceName string, ip string, reservedPorts map[int]bool, flagName string) error {
-	// Check if this port was explicitly specified by the user (from CLI or env, before the config file was applied)
-	isExplicitPort := explicitFlags[flagName]
+	// Check if this port was explicitly specified by the user (from CLI, before config file was applied)
+	isExplicitPort := explicitPortFlags[flagName]
 
 	if *portPtr == 0 {
 		return nil
@@ -1088,16 +1072,10 @@ func initializeGrpcPortsOnIP(bindIp string) {
 	}
 }
 
-// miniOptionsFilePath returns the path of the mini.options file under the
-// first -dir folder.
-func miniOptionsFilePath(dataFolder string) string {
-	return filepath.Join(util.ResolvePath(util.StringSplit(dataFolder, ",")[0]), "mini.options")
-}
-
 // loadMiniConfigurationFile reads the mini.options file and returns parsed options
 // File format: one option per line, without leading dash (e.g., "ip=127.0.0.1")
 func loadMiniConfigurationFile(dataFolder string) (map[string]string, error) {
-	configFile := miniOptionsFilePath(dataFolder)
+	configFile := filepath.Join(util.ResolvePath(util.StringSplit(dataFolder, ",")[0]), "mini.options")
 
 	options := make(map[string]string)
 
@@ -1145,112 +1123,31 @@ func loadMiniConfigurationFile(dataFolder string) (map[string]string, error) {
 	return options, nil
 }
 
-// applyConfigFileOptions sets command-line flags from loaded configuration
-// file. Options for flags the user provided explicitly (command line or
-// WEED_* env var) are skipped, so passing a flag always wins over the saved
-// value — including passing it at its default value. Returns a map of the
-// applied keys to their display values (secrets redacted).
-func applyConfigFileOptions(options map[string]string) map[string]string {
-	keys := make([]string, 0, len(options))
-	for key := range options {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-
-	applied := make(map[string]string)
-	for _, key := range keys {
-		value := options[key]
-		// Redact secrets (admin.password, admin.readOnlyPassword, ...) in
-		// logs and the startup message; only flag.Value.Set sees the value.
-		display := value
-		if isSensitiveOption(key) {
-			display = "*****"
-		}
-		if explicitFlags[key] {
-			glog.V(2).Infof("Skipping config file option %s=%s (explicitly specified)", key, display)
+// applyConfigFileOptions sets command-line flags from loaded configuration file
+func applyConfigFileOptions(options map[string]string) {
+	for key, value := range options {
+		// Skip port flags that were explicitly passed on CLI
+		if explicitPortFlags[key] {
+			glog.V(2).Infof("Skipping config file option %s=%s (explicitly specified on command line)", key, value)
 			continue
 		}
+		// Set the flag value if it hasn't been explicitly set on command line
 		flag := cmdMini.Flag.Lookup(key)
-		if flag == nil {
-			continue
-		}
-		if err := flag.Value.Set(value); err != nil {
-			glog.Warningf("Failed to apply config file option: %s=%s: %v", key, display, err)
-			continue
-		}
-		glog.V(2).Infof("Applied config file option: %s=%s", key, display)
-		applied[key] = display
-	}
-	return applied
-}
-
-// isSensitiveOption reports whether a saved option holds a secret that must
-// not appear in logs or the startup message.
-func isSensitiveOption(key string) bool {
-	k := strings.ToLower(key)
-	return strings.Contains(k, "password") || strings.Contains(k, "secret") || strings.Contains(k, "token")
-}
-
-// warnIfFilerStoreOutsideDir warns when a filer.toml configures a local
-// filer store outside the -dir folders and the master meta folder. When a
-// filer.toml is found the filer skips defaultLevelDbDirectory, so metadata
-// can silently land on a path the volume data doesn't use — in a container
-// that path is lost on recreate unless it is persisted separately.
-func warnIfFilerStoreOutsideDir(dataFolders string, metaFolder string) {
-	if !util.LoadConfiguration("filer", false) {
-		return
-	}
-	v := util.GetViper()
-	folders := append(util.StringSplit(dataFolders, ","), metaFolder)
-	inside := func(storeDir string) bool {
-		// The filer stores open the configured dir verbatim, so absolutize it
-		// the same way (relative to the working directory) rather than
-		// expanding "~", which the store never expands.
-		resolved, err := filepath.Abs(storeDir)
-		if err != nil {
-			return false
-		}
-		for _, folder := range folders {
-			base, err := filepath.Abs(util.ResolvePath(folder))
-			if err != nil {
-				continue
-			}
-			// Resolve symlinks only when both sides exist, so a not-yet-
-			// created store dir under a symlinked -dir still compares
-			// lexically against the same spelling.
-			r, b := resolved, base
-			if er, err := filepath.EvalSymlinks(resolved); err == nil {
-				if eb, err := filepath.EvalSymlinks(base); err == nil {
-					r, b = er, eb
+		if flag != nil {
+			// Only set if not already set (by command line)
+			if flag.Value.String() == flag.DefValue {
+				if err := flag.Value.Set(value); err != nil {
+					glog.Warningf("Failed to apply config file option: %s=%s: %v", key, value, err)
+				} else {
+					glog.V(2).Infof("Applied config file option: %s=%s", key, value)
 				}
 			}
-			if rel, err := filepath.Rel(b, r); err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
-				return true
-			}
-		}
-		return false
-	}
-	// Local filer stores keep metadata under a "dir" key; check both the
-	// default store (leveldb2.enabled) and path-specific stores
-	// (leveldb2.<id>.enabled, keyed under <section>.location).
-	localStores := map[string]bool{"leveldb": true, "leveldb2": true, "leveldb3": true}
-	for _, key := range v.AllKeys() {
-		if !strings.HasSuffix(key, ".enabled") || !v.GetBool(key) {
-			continue
-		}
-		section := strings.TrimSuffix(key, ".enabled")
-		if !localStores[strings.Split(section, ".")[0]] {
-			continue
-		}
-		if storeDir := v.GetString(section + ".dir"); storeDir != "" && !inside(storeDir) {
-			glog.Warningf("filer store %s uses dir %s from filer.toml, outside -dir %s; persist that path or filer metadata will be lost when the container is recreated", section, storeDir, dataFolders)
 		}
 	}
 }
 
-// saveMiniConfiguration writes values mini computed itself to mini.options.
-// Command-line flags are never saved, so a dropped flag cannot resurrect on
-// the next start; the file exists to pin environment-derived values.
+// saveMiniConfiguration saves the current mini configuration to a file
+// The file format uses option=value format without leading dashes
 func saveMiniConfiguration(dataFolder string) error {
 	configDir := util.ResolvePath(util.StringSplit(dataFolder, ",")[0])
 	if err := os.MkdirAll(configDir, 0755); err != nil {
@@ -1262,15 +1159,29 @@ func saveMiniConfiguration(dataFolder string) error {
 
 	var sb strings.Builder
 	sb.WriteString("#!/bin/bash\n")
-	sb.WriteString("# Mini server auto-computed options\n")
+	sb.WriteString("# Mini server configuration\n")
 	sb.WriteString("# Format: option=value (no leading dash)\n")
-	sb.WriteString("# This file is loaded on startup if it exists\n")
-	sb.WriteString("# Command-line flags are not saved; only values mini computed itself.\n\n")
+	sb.WriteString("# This file is loaded on startup if it exists\n\n")
 
-	// Pin the auto-calculated volume size so it stays stable across restarts
-	// even as free disk space changes. Delete this line to force
-	// recalculation on the next startup.
+	// Collect all flags that were explicitly passed (except "dir")
+	cmdMini.Flag.Visit(func(f *flag.Flag) {
+		// Skip the "dir" option - it's environment-specific
+		if f.Name == "dir" {
+			return
+		}
+		value := f.Value.String()
+		// Quote the value if it contains spaces
+		if strings.Contains(value, " ") {
+			sb.WriteString(fmt.Sprintf("%s=\"%s\"\n", f.Name, value))
+		} else {
+			sb.WriteString(fmt.Sprintf("%s=%s\n", f.Name, value))
+		}
+	})
+
+	// Add auto-calculated volume size if it was computed
 	if !isFlagPassed("master.volumeSizeLimitMB") && miniMasterOptions.volumeSizeLimitMB != nil {
+		sb.WriteString(fmt.Sprintf("\n# Auto-calculated volume size based on total disk capacity\n"))
+		sb.WriteString(fmt.Sprintf("# Delete this line to force recalculation on next startup\n"))
 		sb.WriteString(fmt.Sprintf("master.volumeSizeLimitMB=%d\n", *miniMasterOptions.volumeSizeLimitMB))
 	}
 
@@ -1292,32 +1203,21 @@ func runMini(cmd *Command, args []string) bool {
 	// can opt back into verbose output.
 	quietMiniLogs()
 
-	// Capture which flags were explicitly provided on the command line or via
-	// WEED_* env vars BEFORE the saved options file is applied. Saved options
-	// only fill in flags the user did not provide this run, so passing a flag
-	// at its default value also resets a saved value.
-	explicitFlags = make(map[string]bool)
-	cmdMini.Flag.Visit(func(f *flag.Flag) {
-		explicitFlags[f.Name] = true
-	})
+	// Capture which port flags were explicitly passed on CLI BEFORE config file is applied
+	// This is necessary to distinguish user-specified ports from defaults or config file options
+	explicitPortFlags = make(map[string]bool)
+	portFlagNames := []string{"master.port", "filer.port", "volume.port", "s3.port", "s3.port.iceberg", "webdav.port", "admin.port", "s3.iam.readOnly"}
+	for _, flagName := range portFlagNames {
+		explicitPortFlags[flagName] = isFlagPassed(flagName)
+	}
 
-	// Load configuration from file if it exists. Capture the path before
-	// applying: a saved "dir" option can change miniDataFolders.
-	optionsFile := miniOptionsFilePath(*miniDataFolders)
+	// Load configuration from file if it exists
 	configOptions, err := loadMiniConfigurationFile(*miniDataFolders)
 	if err != nil {
 		glog.Warningf("Error loading configuration file: %v", err)
 	}
-	// Apply loaded options to flags (explicitly provided flags win)
-	appliedOptions := applyConfigFileOptions(configOptions)
-	if len(appliedOptions) > 0 {
-		pairs := make([]string, 0, len(appliedOptions))
-		for k, v := range appliedOptions {
-			pairs = append(pairs, k+"="+v)
-		}
-		sort.Strings(pairs)
-		fmt.Printf("  Applying %d saved option(s) from %s: %s\n", len(appliedOptions), optionsFile, strings.Join(pairs, " "))
-	}
+	// Apply loaded options to flags (CLI flags will override these)
+	applyConfigFileOptions(configOptions)
 
 	if *miniOptions.debug {
 		grace.StartDebugServer(*miniOptions.debugPort)
@@ -1407,6 +1307,7 @@ func runMini(cmd *Command, args []string) bool {
 
 	miniFilerOptions.dataCenter = miniDataCenter
 	miniFilerOptions.rack = miniRack
+	miniS3Options.dataCenter = miniDataCenter
 	miniFilerOptions.disableHttp = miniDisableHttp
 	miniMasterOptions.disableHttp = miniDisableHttp
 
@@ -1445,14 +1346,10 @@ func runMini(cmd *Command, args []string) bool {
 		glog.Fatalf("Check Meta Folder (-dir=\"%s\") Writable: %s", *miniMasterOptions.metaFolder, err)
 	}
 	miniFilerOptions.defaultLevelDbDirectory = miniMasterOptions.metaFolder
-	warnIfFilerStoreOutsideDir(*miniDataFolders, *miniMasterOptions.metaFolder)
 
-	// Calculate and set optimal volume size limit based on available disk space.
-	// Skip when the user passed -master.volumeSizeLimitMB explicitly, and when
-	// the value was loaded from mini.options — file-applied flags are not in
-	// Visit, and the saved pin must survive restarts.
-	_, sizeLimitFromFile := appliedOptions["master.volumeSizeLimitMB"]
-	if !isFlagPassed("master.volumeSizeLimitMB") && !sizeLimitFromFile {
+	// Calculate and set optimal volume size limit based on available disk space
+	// Only auto-calculate if user didn't explicitly specify a value via -master.volumeSizeLimitMB
+	if !isFlagPassed("master.volumeSizeLimitMB") {
 		// User didn't override, use auto-calculated value
 		// The -dir flag can accept comma-separated directories; use the first one for disk space calculation.
 		// miniDataFolders was already tilde-resolved at the top of runMini.
@@ -1627,30 +1524,13 @@ func startMiniServices(miniWhiteList []string, allServicesReady chan struct{}) {
 			if miniProgressBoard != nil {
 				miniProgressBoard.starting("Iceberg")
 			}
-			// Probe only when the catalog listener actually bound; otherwise the
-			// port may answer as an unrelated process and get advertised as the
-			// catalog.
-			if miniS3Options.icebergBound.Load() {
-				waitForServiceReady("Iceberg", *miniS3Options.portIceberg, bindIp)
-			} else {
-				if miniProgressBoard != nil {
-					miniProgressBoard.failed("Iceberg")
-				}
-				glog.Warningf("Iceberg catalog on port %d did not start; see S3 startup log", *miniS3Options.portIceberg)
-			}
+			waitForServiceReady("Iceberg", *miniS3Options.portIceberg, bindIp)
 		}
 		if miniS3Options.portLance != nil && *miniS3Options.portLance > 0 {
 			if miniProgressBoard != nil {
 				miniProgressBoard.starting("Lance")
 			}
-			if miniS3Options.lanceBound.Load() {
-				waitForServiceReady("Lance", *miniS3Options.portLance, bindIp)
-			} else {
-				if miniProgressBoard != nil {
-					miniProgressBoard.failed("Lance")
-				}
-				glog.Warningf("Lance namespace server on port %d did not start; see S3 startup log", *miniS3Options.portLance)
-			}
+			waitForServiceReady("Lance", *miniS3Options.portLance, bindIp)
 		}
 	}
 	if *miniEnableWebDAV {
@@ -1865,10 +1745,10 @@ func startMiniAdminWithWorker(allServicesReady chan struct{}) {
 		// the admin UI would otherwise print an endpoint nothing is listening on.
 		var icebergPort, lancePort int
 		if miniEnableS3 != nil && *miniEnableS3 {
-			if miniS3Options.portIceberg != nil && *miniS3Options.portIceberg > 0 && miniS3Options.icebergBound.Load() {
+			if miniS3Options.portIceberg != nil {
 				icebergPort = *miniS3Options.portIceberg
 			}
-			if miniS3Options.portLance != nil && *miniS3Options.portLance > 0 && miniS3Options.lanceBound.Load() {
+			if miniS3Options.portLance != nil {
 				lancePort = *miniS3Options.portLance
 			}
 		}

weed/command/s3.go

@@ -12,7 +12,6 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
-	"sync/atomic"
 	"time"
 
 	"github.com/gorilla/mux"
@@ -88,14 +87,6 @@ type S3Options struct {
 	// its HTTP/gRPC servers once the ctx is cancelled, in addition to on
 	// interrupt. Used by weed mini to orchestrate an ordered shutdown.
 	shutdownCtx context.Context
-
-	// icebergBound/lanceBound record whether the auxiliary catalog listeners
-	// bound their ports. The aux binds happen before the S3 listener serves,
-	// so once the S3 port answers these are final; mini reads them to probe
-	// and advertise only catalogs that are actually running instead of
-	// whatever process may hold the configured port.
-	icebergBound atomic.Bool
-	lanceBound   atomic.Bool
 }
 
 func init() {
@@ -123,7 +114,7 @@ func init() {
 	s3StandaloneOptions.metricsHttpPort = cmdS3.Flag.Int("metricsPort", 0, "Prometheus metrics listen port")
 	s3StandaloneOptions.metricsHttpIp = cmdS3.Flag.String("metricsIp", "", "metrics listen ip. If empty, default to same as -ip.bind option.")
 	cmdS3.Flag.Bool("allowEmptyFolder", true, "deprecated, ignored. Empty folder cleanup is now automatic.")
-	s3StandaloneOptions.allowDeleteBucketNotEmpty = cmdS3.Flag.Bool("allowDeleteBucketNotEmpty", false, "allow recursive deleting all entries along with bucket")
+	s3StandaloneOptions.allowDeleteBucketNotEmpty = cmdS3.Flag.Bool("allowDeleteBucketNotEmpty", true, "allow recursive deleting all entries along with bucket")
 	s3StandaloneOptions.autoCreateBucket = cmdS3.Flag.Bool("autoCreateBucket", true, "create the bucket on upload if it does not exist, for admin identities only")
 	s3StandaloneOptions.localFilerSocket = cmdS3.Flag.String("localFilerSocket", "", "local filer socket path")
 	s3StandaloneOptions.localSocket = cmdS3.Flag.String("localSocket", "", "default to /tmp/seaweedfs-s3-<port>.sock")
@@ -408,16 +399,12 @@ func (s3opt *S3Options) startS3Server() bool {
 
 	// Start Iceberg REST Catalog server if enabled
 	if *s3opt.portIceberg > 0 {
-		if httpS := s3opt.startIcebergServer(s3ApiServer); httpS != nil {
-			httpServers = append(httpServers, httpS)
-		}
+		httpServers = append(httpServers, s3opt.startIcebergServer(s3ApiServer))
 	}
 
 	// Start Lance Namespace server if enabled
 	if s3opt.portLance != nil && *s3opt.portLance > 0 {
-		if httpS := s3opt.startLanceServer(s3ApiServer); httpS != nil {
-			httpServers = append(httpServers, httpS)
-		}
+		httpServers = append(httpServers, s3opt.startLanceServer(s3ApiServer))
 	}
 
 	if runtime.GOOS != "windows" {
@@ -614,12 +601,8 @@ func (s3opt *S3Options) startIcebergServer(s3ApiServer *s3api.S3ApiServer) *http
 	icebergListener, icebergLocalListener, err := util.NewIpAndLocalListeners(
 		*s3opt.bindIp, *s3opt.portIceberg, time.Duration(*s3opt.idleTimeout)*time.Second)
 	if err != nil {
-		// The catalog is auxiliary to the S3 gateway; a port conflict must not
-		// take the whole server down.
-		glog.Errorf("Iceberg REST Catalog listener on %s error: %v", listenAddress, err)
-		return nil
+		glog.Fatalf("Iceberg REST Catalog listener on %s error: %v", listenAddress, err)
 	}
-	s3opt.icebergBound.Store(true)
 
 	glog.V(0).Infof("Start Iceberg REST Catalog Server at http://%s", listenAddress)
 
@@ -634,7 +617,7 @@ func (s3opt *S3Options) startIcebergServer(s3ApiServer *s3api.S3ApiServer) *http
 	}
 	go func() {
 		if err := httpS.Serve(icebergListener); err != nil && err != http.ErrServerClosed {
-			glog.Errorf("Iceberg REST Catalog Server Fail to serve: %v", err)
+			glog.Fatalf("Iceberg REST Catalog Server Fail to serve: %v", err)
 		}
 	}()
 	return httpS
@@ -660,10 +643,8 @@ func (s3opt *S3Options) startLanceServer(s3ApiServer *s3api.S3ApiServer) *http.S
 	lanceListener, lanceLocalListener, err := util.NewIpAndLocalListeners(
 		*s3opt.bindIp, *s3opt.portLance, time.Duration(*s3opt.idleTimeout)*time.Second)
 	if err != nil {
-		glog.Errorf("Lance Namespace listener on %s error: %v", listenAddress, err)
-		return nil
+		glog.Fatalf("Lance Namespace listener on %s error: %v", listenAddress, err)
 	}
-	s3opt.lanceBound.Store(true)
 
 	glog.V(0).Infof("Start Lance Namespace Server at http://%s", listenAddress)
 
@@ -677,7 +658,7 @@ func (s3opt *S3Options) startLanceServer(s3ApiServer *s3api.S3ApiServer) *http.S
 	}
 	go func() {
 		if err := httpS.Serve(lanceListener); err != nil && err != http.ErrServerClosed {
-			glog.Errorf("Lance Namespace Server Fail to serve: %v", err)
+			glog.Fatalf("Lance Namespace Server Fail to serve: %v", err)
 		}
 	}()
 	return httpS

weed/command/s3_aux_listener_test.go

@@ -1,59 +0,0 @@
-package command
-
-import (
-	"net"
-	"testing"
-
-	"github.com/seaweedfs/seaweedfs/weed/s3api"
-)
-
-func holdPort(t *testing.T) int {
-	t.Helper()
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("listen: %v", err)
-	}
-	t.Cleanup(func() { l.Close() })
-	return l.Addr().(*net.TCPAddr).Port
-}
-
-// An occupied auxiliary catalog port must not take the S3 gateway down, must
-// return no server for shutdown registration, and must not report the catalog
-// as bound for mini's readiness checks.
-func TestAuxListenerBindFailureIsNonFatal(t *testing.T) {
-	icebergPort := holdPort(t)
-	lancePort := holdPort(t)
-
-	bind := "127.0.0.1"
-	empty := ""
-	zero := 0
-	idle := 10
-	s3opt := &S3Options{
-		bindIp:                &bind,
-		ip:                    &bind,
-		port:                  &zero,
-		portHttps:             &zero,
-		portIceberg:           &icebergPort,
-		portLance:             &lancePort,
-		idleTimeout:           &idle,
-		icebergCredentialRole: &empty,
-		externalUrl:           &empty,
-		tlsPrivateKey:         &empty,
-	}
-	s3a := &s3api.S3ApiServer{}
-
-	if s := s3opt.startIcebergServer(s3a); s != nil {
-		s.Close()
-		t.Error("startIcebergServer on an occupied port should return nil")
-	}
-	if s3opt.icebergBound.Load() {
-		t.Error("icebergBound must stay false when the listener failed to bind")
-	}
-	if s := s3opt.startLanceServer(s3a); s != nil {
-		s.Close()
-		t.Error("startLanceServer on an occupied port should return nil")
-	}
-	if s3opt.lanceBound.Load() {
-		t.Error("lanceBound must stay false when the listener failed to bind")
-	}
-}

weed/command/s3_iceberg_endpoint_test.go

@@ -92,8 +92,7 @@ func TestDeriveS3AdvertisedEndpoint(t *testing.T) {
 		},
 	}
 
-	for i := range tests {
-		tc := &tests[i]
+	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			got := tc.opt.deriveS3AdvertisedEndpoint()
 			if got != tc.want {

weed/command/server.go

@@ -149,7 +149,6 @@ func init() {
 	serverOptions.v.readMode = cmdServer.Flag.String("volume.readMode", "proxy", "[local|proxy|redirect] how to deal with non-local volume: 'not found|read in remote node|redirect volume location'.")
 	serverOptions.v.compactionMBPerSecond = cmdServer.Flag.Int("volume.compactionMBps", 0, "limit compaction speed in mega bytes per second")
 	serverOptions.v.maintenanceMBPerSecond = cmdServer.Flag.Int("volume.maintenanceMBps", 0, "limit maintenance (replication / balance) IO rate in MB/s. Unset is 0, no limitation.")
-	serverOptions.v.maxParallelVacuumCommits = cmdServer.Flag.Int("volume.compactionMaxParallelCommits", 0, "limit how many vacuum commits run at once on this server; queued commits hold no volume lock. 0 means unlimited")
 	serverOptions.v.fileSizeLimitMB = cmdServer.Flag.Int("volume.fileSizeLimitMB", 256, "limit file size to avoid out of memory")
 	serverOptions.v.ldbTimeout = cmdServer.Flag.Int64("volume.index.leveldbTimeout", 0, "alive time for leveldb (default to 0). If leveldb of volume is not accessed in ldbTimeout hours, it will be off loaded to reduce opened files and memory consumption.")
 	serverOptions.v.concurrentUploadLimitMB = cmdServer.Flag.Int("volume.concurrentUploadLimitMB", 0, "limit total concurrent upload size, 0 means unlimited")
@@ -175,7 +174,6 @@ func init() {
 	s3Options.icebergCredentialDuration = cmdServer.Flag.Int("s3.iceberg.credentialDurationSeconds", 3600, "lifetime of credentials vended by the Iceberg catalog")
 	s3Options.domainName = cmdServer.Flag.String("s3.domainName", "", "suffix of the host name in comma separated list, {bucket}.{domainName}")
 	s3Options.allowedOrigins = cmdServer.Flag.String("s3.allowedOrigins", "*", "comma separated list of allowed origins")
-	s3Options.dataCenter = cmdServer.Flag.String("s3.dataCenter", "", "prefer to read and write to volumes in this data center")
 	s3Options.tlsPrivateKey = cmdServer.Flag.String("s3.key.file", "", "path to the TLS private key file")
 	s3Options.tlsCertificate = cmdServer.Flag.String("s3.cert.file", "", "path to the TLS certificate file")
 	s3Options.tlsCACertificate = cmdServer.Flag.String("s3.cacert.file", "", "path to the TLS CA certificate file")
@@ -184,7 +182,7 @@ func init() {
 	s3Options.iamConfig = cmdServer.Flag.String("s3.iam.config", "", "path to the advanced IAM config file for S3. Overrides -iam.config if both are provided.")
 	s3Options.auditLogConfig = cmdServer.Flag.String("s3.auditLogConfig", "", "path to the audit log config file")
 	cmdServer.Flag.Bool("s3.allowEmptyFolder", true, "deprecated, ignored. Empty folder cleanup is now automatic.")
-	s3Options.allowDeleteBucketNotEmpty = cmdServer.Flag.Bool("s3.allowDeleteBucketNotEmpty", false, "allow recursive deleting all entries along with bucket")
+	s3Options.allowDeleteBucketNotEmpty = cmdServer.Flag.Bool("s3.allowDeleteBucketNotEmpty", true, "allow recursive deleting all entries along with bucket")
 	s3Options.autoCreateBucket = cmdServer.Flag.Bool("s3.autoCreateBucket", true, "create the bucket on upload if it does not exist, for admin identities only")
 	s3Options.localSocket = cmdServer.Flag.String("s3.localSocket", "", "default to /tmp/seaweedfs-s3-<port>.sock")
 	s3Options.bindIp = cmdServer.Flag.String("s3.ip.bind", "", "ip address to bind to. If empty, default to same as -ip.bind option.")
@@ -211,7 +209,6 @@ func init() {
 	sftpOptions.clientAliveCountMax = cmdServer.Flag.Int("sftp.clientAliveCountMax", 3, "maximum number of missed keep-alive messages before disconnecting")
 	sftpOptions.userStoreFile = cmdServer.Flag.String("sftp.userStoreFile", "", "path to JSON file containing user credentials and permissions")
 	sftpOptions.trustedUserCAKeysFile = cmdServer.Flag.String("sftp.trustedUserCAKeysFile", "", "path to a file with trusted user CA public keys (OpenSSH authorized_keys format); required when 'certificate' is in -sftp.authMethods")
-	sftpOptions.dataCenter = cmdServer.Flag.String("sftp.dataCenter", "", "prefer to read and write to volumes in this data center")
 	sftpOptions.localSocket = cmdServer.Flag.String("sftp.localSocket", "", "default to /tmp/seaweedfs-sftp-<port>.sock")
 	iamOptions.port = cmdServer.Flag.Int("iam.port", 8111, "iam server http listen port")
 
@@ -339,6 +336,8 @@ func runServer(cmd *Command, args []string) bool {
 	filerOptions.rack = serverRack
 	mqBrokerOptions.dataCenter = serverDataCenter
 	mqBrokerOptions.rack = serverRack
+	s3Options.dataCenter = serverDataCenter
+	sftpOptions.dataCenter = serverDataCenter
 	*filerOptions.disableHttp = *filerOptions.disableHttp || *serverDisableHttp
 	masterOptions.disableHttp = serverDisableHttp
 

weed/command/server_test.go

@@ -11,15 +11,3 @@ func TestServerFilerDisableHttpFlag(t *testing.T) {
 		t.Fatalf("-filer.disableHttp default = %q, want false", flag.DefValue)
 	}
 }
-
-func TestServerGatewayDataCenterFlags(t *testing.T) {
-	for _, name := range []string{"s3.dataCenter", "sftp.dataCenter"} {
-		flag := cmdServer.Flag.Lookup(name)
-		if flag == nil {
-			t.Fatalf("weed server does not expose -%s", name)
-		}
-		if flag.DefValue != "" {
-			t.Fatalf("-%s default = %q, want empty", name, flag.DefValue)
-		}
-	}
-}

weed/command/volume.go

@@ -61,7 +61,6 @@ type VolumeServerOptions struct {
 	memProfile                *string
 	compactionMBPerSecond     *int
 	maintenanceMBPerSecond    *int
-	maxParallelVacuumCommits  *int
 	fileSizeLimitMB           *int
 	concurrentUploadLimitMB   *int
 	concurrentDownloadLimitMB *int
@@ -216,7 +215,6 @@ func init() {
 	v.memProfile = cmdVolume.Flag.String("memprofile", "", "memory profile output file")
 	v.compactionMBPerSecond = cmdVolume.Flag.Int("compactionMBps", 0, "limit background compaction or copying speed in mega bytes per second")
 	v.maintenanceMBPerSecond = cmdVolume.Flag.Int("maintenanceMBps", 0, "limit maintenance (replication / balance) IO rate in MB/s. Unset is 0, no limitation.")
-	v.maxParallelVacuumCommits = cmdVolume.Flag.Int("compactionMaxParallelCommits", 0, "limit how many vacuum commits run at once on this server; queued commits hold no volume lock. 0 means unlimited")
 	v.fileSizeLimitMB = cmdVolume.Flag.Int("fileSizeLimitMB", 256, "limit file size to avoid out of memory")
 	v.ldbTimeout = cmdVolume.Flag.Int64("index.leveldbTimeout", 0, "alive time for leveldb (default to 0). If leveldb of volume is not accessed in ldbTimeout hours, it will be off loaded to reduce opened files and memory consumption.")
 	v.concurrentUploadLimitMB = cmdVolume.Flag.Int("concurrentUploadLimitMB", 0, "limit total concurrent upload size, 0 means unlimited")
@@ -449,7 +447,6 @@ func (v VolumeServerOptions) startVolumeServer(volumeFolders, maxVolumeCounts, v
 		*v.fixJpgOrientation, *v.readMode,
 		*v.compactionMBPerSecond,
 		*v.maintenanceMBPerSecond,
-		*v.maxParallelVacuumCommits,
 		*v.fileSizeLimitMB,
 		int64(*v.concurrentUploadLimitMB)*1024*1024,
 		int64(*v.concurrentDownloadLimitMB)*1024*1024,

weed/command/worker_runtime.go

@@ -82,7 +82,7 @@ func runPluginWorkerWithOptions(options pluginWorkerRunOptions) bool {
 		return false
 	}
 
-	handlers, err := buildPluginWorkerHandlers(options.JobTypes, dialOption, options.MaxExecute, options.WorkingDir, options.Address)
+	handlers, err := buildPluginWorkerHandlers(options.JobTypes, dialOption, options.MaxExecute, options.WorkingDir)
 	if err != nil {
 		glog.Errorf("Failed to build plugin worker handlers: %v", err)
 		return false
@@ -141,7 +141,7 @@ func resolvePluginWorkerID(explicitID string, workingDir string) (string, error)
 // buildPluginWorkerHandlers resolves the comma-separated jobTypes string
 // (which may contain category names like "all", "default", "heavy" and/or
 // explicit job type names/aliases) into a deduplicated slice of JobHandlers.
-func buildPluginWorkerHandlers(jobTypes string, dialOption grpc.DialOption, maxExecute int, workingDir string, workerAddress ...string) ([]pluginworker.JobHandler, error) {
+func buildPluginWorkerHandlers(jobTypes string, dialOption grpc.DialOption, maxExecute int, workingDir string) ([]pluginworker.JobHandler, error) {
 	jobTypes = strings.TrimSpace(jobTypes)
 	if jobTypes == "" {
 		jobTypes = defaultPluginWorkerJobTypes
@@ -152,16 +152,10 @@ func buildPluginWorkerHandlers(jobTypes string, dialOption grpc.DialOption, maxE
 		return nil, err
 	}
 
-	addr := ""
-	if len(workerAddress) > 0 {
-		addr = strings.TrimSpace(workerAddress[0])
-	}
-
 	opts := pluginworker.HandlerBuildOptions{
 		GrpcDialOption: dialOption,
 		MaxExecute:     maxExecute,
 		WorkingDir:     workingDir,
-		WorkerAddress:  addr,
 	}
 
 	handlers := make([]pluginworker.JobHandler, 0, len(factories))

weed/ec/ec_balance_no_space_test.go

@@ -1,359 +0,0 @@
-package ec
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"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"
-	"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding/ecbalancer"
-	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
-	"github.com/seaweedfs/seaweedfs/weed/storage/types"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
-)
-
-// ecBalanceFakeServer answers the EC-shard RPC subset a balance run drives:
-// copy (rejected when full), mount, inventory, unmount, delete. The disk state
-// a real server tracks lives in shards; what the planner saw is rebuilt from it
-// through FetchTopology, so a landed move is visible to the next plan.
-type ecBalanceFakeServer struct {
-	volume_server_pb.UnimplementedVolumeServerServer
-
-	mu        sync.Mutex
-	shards    map[uint32]map[uint32]bool // vid -> shardId -> present
-	full      bool                       // VolumeEcShardsCopy answers "no space left"
-	copyCalls int
-	grpcAddr  string
-	stop      func()
-}
-
-func (f *ecBalanceFakeServer) VolumeEcShardsCopy(ctx context.Context, req *volume_server_pb.VolumeEcShardsCopyRequest) (*volume_server_pb.VolumeEcShardsCopyResponse, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	f.copyCalls++
-	if f.full {
-		return nil, fmt.Errorf("no space left")
-	}
-	return &volume_server_pb.VolumeEcShardsCopyResponse{}, nil
-}
-
-func (f *ecBalanceFakeServer) VolumeEcShardsMount(ctx context.Context, req *volume_server_pb.VolumeEcShardsMountRequest) (*volume_server_pb.VolumeEcShardsMountResponse, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	for _, sid := range req.ShardIds {
-		f.shards[req.VolumeId][sid] = true
-	}
-	return &volume_server_pb.VolumeEcShardsMountResponse{}, nil
-}
-
-func (f *ecBalanceFakeServer) VolumeEcShardsInfo(ctx context.Context, req *volume_server_pb.VolumeEcShardsInfoRequest) (*volume_server_pb.VolumeEcShardsInfoResponse, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	resp := &volume_server_pb.VolumeEcShardsInfoResponse{}
-	for sid := range f.shards[req.VolumeId] {
-		resp.EcShardInfos = append(resp.EcShardInfos, &volume_server_pb.EcShardInfo{
-			VolumeId: req.VolumeId,
-			ShardId:  sid,
-			Size:     1,
-		})
-	}
-	return resp, nil
-}
-
-func (f *ecBalanceFakeServer) VolumeEcShardsUnmount(ctx context.Context, req *volume_server_pb.VolumeEcShardsUnmountRequest) (*volume_server_pb.VolumeEcShardsUnmountResponse, error) {
-	return &volume_server_pb.VolumeEcShardsUnmountResponse{}, nil
-}
-
-func (f *ecBalanceFakeServer) VolumeEcShardsDelete(ctx context.Context, req *volume_server_pb.VolumeEcShardsDeleteRequest) (*volume_server_pb.VolumeEcShardsDeleteResponse, error) {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	for _, sid := range req.ShardIds {
-		delete(f.shards[req.VolumeId], sid)
-	}
-	return &volume_server_pb.VolumeEcShardsDeleteResponse{}, nil
-}
-
-// nodeId returns the "host:httpPort.grpcPort" node id form the cluster uses, so
-// ToGrpcAddress resolves to this server's listener.
-func (f *ecBalanceFakeServer) nodeId() string {
-	host, port, err := net.SplitHostPort(f.grpcAddr)
-	if err != nil {
-		return f.grpcAddr
-	}
-	return fmt.Sprintf("%s:1.%s", host, port)
-}
-
-func (f *ecBalanceFakeServer) shardCount(vid uint32) int {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	return len(f.shards[vid])
-}
-
-func startEcBalanceFakeServer(t *testing.T, vid uint32, present ...uint32) *ecBalanceFakeServer {
-	t.Helper()
-
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("listen: %v", err)
-	}
-
-	f := &ecBalanceFakeServer{
-		shards:   map[uint32]map[uint32]bool{vid: {}},
-		grpcAddr: listener.Addr().String(),
-	}
-	for _, sid := range present {
-		f.shards[vid][sid] = true
-	}
-
-	server := grpc.NewServer()
-	volume_server_pb.RegisterVolumeServerServer(server, f)
-	go func() { _ = server.Serve(listener) }()
-	f.stop = server.Stop
-	t.Cleanup(server.Stop)
-	return f
-}
-
-// fetchEcBalanceTopology builds a FetchTopology that reports the fake servers'
-// live shard inventory.
-func fetchEcBalanceTopology(servers []*ecBalanceFakeServer) func(delay time.Duration) (*master_pb.TopologyInfo, uint64, error) {
-	return func(delay time.Duration) (*master_pb.TopologyInfo, uint64, error) {
-		var nodes []*master_pb.DataNodeInfo
-		for _, f := range servers {
-			di := &master_pb.DiskInfo{Type: string(types.HardDriveType), MaxVolumeCount: 100}
-			f.mu.Lock()
-			for v, set := range f.shards {
-				if len(set) == 0 {
-					continue
-				}
-				si := erasure_coding.NewShardsInfo()
-				for sid := range set {
-					si.Set(erasure_coding.NewShardInfo(erasure_coding.ShardId(sid), 1))
-				}
-				di.EcShardInfos = append(di.EcShardInfos, &master_pb.VolumeEcShardInformationMessage{
-					Id:          v,
-					Collection:  "c1",
-					EcIndexBits: si.Bitmap(),
-					ShardSizes:  si.SizesInt64(),
-					DiskType:    string(types.HardDriveType),
-				})
-			}
-			f.mu.Unlock()
-			nodes = append(nodes, &master_pb.DataNodeInfo{
-				Id:        f.nodeId(),
-				DiskInfos: map[string]*master_pb.DiskInfo{string(types.HardDriveType): di},
-			})
-		}
-		return &master_pb.TopologyInfo{
-			DataCenterInfos: []*master_pb.DataCenterInfo{{
-				Id: "dc1",
-				RackInfos: []*master_pb.RackInfo{{
-					Id:            "r1",
-					DataNodeInfos: nodes,
-				}},
-			}},
-		}, 0, nil
-	}
-}
-
-// TestEcBalanceReplanAfterNoSpaceLeft reproduces seaweedfs/seaweedfs#11753:
-// the planner works from heartbeat free-slot counts that can disagree with the
-// volume server's own check, so a planned target can reject the copy with
-// "no space left" mid-run. The balance must re-plan without that node as a
-// target rather than fail the whole run.
-func TestEcBalanceReplanAfterNoSpaceLeft(t *testing.T) {
-	const vid = uint32(1)
-	var allShards []uint32
-	for sid := 0; sid < erasure_coding.DataShardsCount+erasure_coding.ParityShardsCount; sid++ {
-		allShards = append(allShards, uint32(sid))
-	}
-
-	full := startEcBalanceFakeServer(t, vid)
-	accept := startEcBalanceFakeServer(t, vid)
-	source := startEcBalanceFakeServer(t, vid, allShards...)
-	full.full = true
-
-	env := &Env{
-		GrpcDialOption: grpc.WithTransportCredentials(insecure.NewCredentials()),
-		FetchTopology:  fetchEcBalanceTopology([]*ecBalanceFakeServer{source, full, accept}),
-	}
-
-	err := EcBalance(env, []string{"c1"}, "", nil, types.HardDriveType, 3, 0, true, nil, nil, nil)
-	if err != nil {
-		t.Fatalf("balance should re-plan around the full target, got: %v", err)
-	}
-	if full.copyCalls == 0 {
-		t.Fatalf("expected the full server to have rejected at least one copy")
-	}
-	if got := full.shardCount(vid); got != 0 {
-		t.Fatalf("full server should receive no shards, holds %d", got)
-	}
-	total := source.shardCount(vid) + full.shardCount(vid) + accept.shardCount(vid)
-	if total != len(allShards) {
-		t.Fatalf("shards lost or duplicated: total %d, want %d", total, len(allShards))
-	}
-	if source.shardCount(vid) == len(allShards) {
-		t.Fatalf("no shards were moved off the source")
-	}
-}
-
-// TestEcBalanceReplanAfterNoSpaceLeftStaleSnapshot serves the pre-move
-// topology on every collection after the first, simulating a master heartbeat
-// that lags the landed moves. The re-plan must replay its completed moves onto
-// the stale snapshot instead of re-moving shards off the deleted source.
-func TestEcBalanceReplanAfterNoSpaceLeftStaleSnapshot(t *testing.T) {
-	const vid = uint32(1)
-	var allShards []uint32
-	for sid := 0; sid < erasure_coding.DataShardsCount+erasure_coding.ParityShardsCount; sid++ {
-		allShards = append(allShards, uint32(sid))
-	}
-
-	full := startEcBalanceFakeServer(t, vid)
-	accept := startEcBalanceFakeServer(t, vid)
-	source := startEcBalanceFakeServer(t, vid, allShards...)
-	full.full = true
-
-	live := fetchEcBalanceTopology([]*ecBalanceFakeServer{source, full, accept})
-	var stale *master_pb.TopologyInfo
-	calls := 0
-	fetchTopology := func(delay time.Duration) (*master_pb.TopologyInfo, uint64, error) {
-		topo, size, err := live(delay)
-		if err != nil {
-			return nil, 0, err
-		}
-		calls++
-		if stale == nil {
-			stale = topo
-		}
-		if calls > 1 {
-			return stale, size, nil
-		}
-		return topo, size, nil
-	}
-
-	env := &Env{
-		GrpcDialOption: grpc.WithTransportCredentials(insecure.NewCredentials()),
-		FetchTopology:  fetchTopology,
-	}
-
-	err := EcBalance(env, []string{"c1"}, "", nil, types.HardDriveType, 3, 0, true, nil, nil, nil)
-	if err != nil {
-		t.Fatalf("balance should re-plan around the full target, got: %v", err)
-	}
-	if calls < 2 {
-		t.Fatalf("expected a re-plan, topology collected %d time(s)", calls)
-	}
-	// Each shard lands on the accepting server exactly once; a stale re-plan
-	// would copy already-moved shards again.
-	if got, want := accept.copyCalls, accept.shardCount(vid); got != want {
-		t.Fatalf("accepting server saw %d copies for %d held shards: completed moves were re-planned", got, want)
-	}
-	total := source.shardCount(vid) + full.shardCount(vid) + accept.shardCount(vid)
-	if total != len(allShards) {
-		t.Fatalf("shards lost or duplicated: total %d, want %d", total, len(allShards))
-	}
-}
-
-// TestEcBalanceNoReceivingTargetFails surfaces the refusal when every
-// destination that could take a shard has rejected a copy, rather than
-// reporting success for a plan that moved nothing.
-func TestEcBalanceNoReceivingTargetFails(t *testing.T) {
-	const vid = uint32(1)
-	var allShards []uint32
-	for sid := 0; sid < erasure_coding.DataShardsCount+erasure_coding.ParityShardsCount; sid++ {
-		allShards = append(allShards, uint32(sid))
-	}
-
-	full := startEcBalanceFakeServer(t, vid)
-	source := startEcBalanceFakeServer(t, vid, allShards...)
-	full.full = true
-
-	env := &Env{
-		GrpcDialOption: grpc.WithTransportCredentials(insecure.NewCredentials()),
-		FetchTopology:  fetchEcBalanceTopology([]*ecBalanceFakeServer{source, full}),
-	}
-
-	err := EcBalance(env, []string{"c1"}, "", nil, types.HardDriveType, 3, 0, true, nil, nil, nil)
-	if err == nil {
-		t.Fatalf("balance with no receiving target should fail")
-	}
-	if !strings.Contains(err.Error(), "no space left") {
-		t.Fatalf("expected the refusal to surface, got: %v", err)
-	}
-}
-
-// TestApplyCompletedMovesReplaysDiskState checks that replaying a landed move
-// onto a stale snapshot carries the shard's disk attribution and the per-disk
-// slot accounting, so a re-plan does not treat the just-filled disk as empty.
-func TestApplyCompletedMovesReplaysDiskState(t *testing.T) {
-	const vid = uint32(1)
-
-	source := newEcNode("dc1", "r1", "dn1", 99)
-	source.Info.DiskInfos["hdd"] = &master_pb.DiskInfo{
-		Type: "hdd",
-		EcShardInfos: []*master_pb.VolumeEcShardInformationMessage{{
-			Id:          vid,
-			Collection:  "c1",
-			DiskId:      1,
-			DiskType:    "hdd",
-			EcIndexBits: uint32(erasure_coding.ShardBits(0).Set(5)),
-		}},
-	}
-	si := erasure_coding.NewShardsInfo()
-	si.Set(erasure_coding.NewShardInfo(5, 1))
-	source.Disks = map[uint32]*EcDisk{
-		1: {DiskId: 1, DiskType: "hdd", FreeEcSlots: 99, EcShardCount: 1, EcShards: map[needle.VolumeId]*erasure_coding.ShardsInfo{1: si}},
-	}
-
-	target := newEcNode("dc1", "r1", "dn2", 100)
-	target.Disks = map[uint32]*EcDisk{
-		1: {DiskId: 1, DiskType: "hdd", FreeEcSlots: 10, EcShardCount: 0, EcShards: map[needle.VolumeId]*erasure_coding.ShardsInfo{}},
-		2: {DiskId: 2, DiskType: "hdd", FreeEcSlots: 10, EcShardCount: 0, EcShards: map[needle.VolumeId]*erasure_coding.ShardsInfo{}},
-	}
-
-	nodes := []*EcNode{source, target}
-	move := ecbalancer.Move{
-		VolumeID:   vid,
-		ShardID:    5,
-		Collection: "c1",
-		SourceNode: "dn1",
-		TargetNode: "dn2",
-		TargetDisk: 2,
-		Phase:      "within_rack",
-	}
-	applyCompletedMoves(nodes, []ecbalancer.Move{move}, types.HardDriveType)
-
-	if ecNodeHasShard(source, needle.VolumeId(vid), 5) {
-		t.Fatalf("source still holds shard 5")
-	}
-	if d := source.Disks[1]; d.EcShardCount != 0 || d.FreeEcSlots != 100 {
-		t.Fatalf("source disk counts not restored: %+v", d)
-	}
-	if !ecNodeHasShard(target, needle.VolumeId(vid), 5) {
-		t.Fatalf("target missing shard 5")
-	}
-	if d := target.Disks[2]; d.EcShardCount != 1 || d.FreeEcSlots != 9 {
-		t.Fatalf("target disk 2 not charged: %+v", d)
-	}
-	if d := target.Disks[1]; d.EcShardCount != 0 {
-		t.Fatalf("shard attributed to wrong disk: %+v", d)
-	}
-	if target.FreeEcSlot != 99 {
-		t.Fatalf("target free slots = %d, want 99", target.FreeEcSlot)
-	}
-
-	// Replaying again (or onto a fresher snapshot) must not double-count.
-	applyCompletedMoves(nodes, []ecbalancer.Move{move}, types.HardDriveType)
-	if d := target.Disks[2]; d.EcShardCount != 1 || d.FreeEcSlots != 9 {
-		t.Fatalf("double-applied move: %+v", d)
-	}
-	if target.FreeEcSlot != 99 {
-		t.Fatalf("target free slots = %d, want 99", target.FreeEcSlot)
-	}
-}

weed/ec/ec_common.go

@@ -8,7 +8,6 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/seaweedfs/seaweedfs/weed/glog"
@@ -763,26 +762,6 @@ type ecBalancer struct {
 	// migratingVolumeIds are mid-encode volumes whose shards are ingested from
 	// every disk-type bucket; see EcBalance.
 	migratingVolumeIds map[uint32]bool
-	// noReceiveTargets are node ids the planner may not pick as destinations;
-	// noReceiveDisks narrows that to individual disks on a node: a server-side
-	// auto-pick refusal means no disk qualifies, but an explicit-disk refusal
-	// only convicts that disk. See EcBalance.
-	noReceiveTargets map[string]bool
-	noReceiveDisks   map[string]map[uint32]bool
-	// mu guards the execution journal written by concurrent move tasks.
-	mu sync.Mutex
-	// rejectedTargets and rejectedDisks collect the destinations that refused a
-	// copy this attempt; completedMoves records applied moves so a retry can
-	// replay them onto a stale-heartbeat snapshot; sawOtherErr marks any
-	// failure that is not a "no space left" refusal and makes the run
-	// non-retryable.
-	rejectedTargets map[string]bool
-	rejectedDisks   map[string]map[uint32]bool
-	completedMoves  []ecbalancer.Move
-	sawOtherErr     bool
-	// plannedMoves is the move count of the last plan, for the empty-replan
-	// check in EcBalance.
-	plannedMoves int
 }
 
 // excludeNodes is a set of server addresses kept out of the balance as copy/move
@@ -803,6 +782,32 @@ type ecBalancer struct {
 // so a plain ec.balance -diskType=X never drags deliberately tiered shards of
 // other types onto X disks.
 func EcBalance(env *Env, collections []string, dc string, ecReplicaPlacement *super_block.ReplicaPlacement, diskType types.DiskType, maxParallelization int, ioBytePerSecond int64, applyBalancing bool, excludeNodes map[pb.ServerAddress]struct{}, volumeIds []needle.VolumeId, migratingVolumeIds []needle.VolumeId) (err error) {
+	// collect all ec nodes
+	allEcNodes, totalFreeEcSlots, err := CollectEcNodesForDC(env, dc, diskType)
+	if err != nil {
+		return err
+	}
+
+	// Drop excluded nodes (and the slots they contribute) before planning so they
+	// can be neither a target nor a source for any move this balance plans.
+	if len(excludeNodes) > 0 {
+		kept := allEcNodes[:0]
+		var excludedFreeSlots int
+		for _, en := range allEcNodes {
+			if _, skip := excludeNodes[pb.NewServerAddressFromDataNode(en.Info)]; skip {
+				excludedFreeSlots += en.FreeEcSlot
+				glog.V(0).Infof("EC balance excluding node %s: skipped as unreachable by the encode orphan sweep", en.Info.Id)
+				continue
+			}
+			kept = append(kept, en)
+		}
+		allEcNodes = kept
+		totalFreeEcSlots -= excludedFreeSlots
+	}
+
+	if totalFreeEcSlots < 1 {
+		return fmt.Errorf("no free ec shard slots. only %d left", totalFreeEcSlots)
+	}
 
 	var volumeIdFilter map[uint32]bool
 	if len(volumeIds) > 0 {
@@ -819,277 +824,22 @@ func EcBalance(env *Env, collections []string, dc string, ecReplicaPlacement *su
 		}
 	}
 
-	// The planner's free-slot numbers come from heartbeat snapshots that can lag
-	// the volume server's own accounting, so a planned target can refuse a copy
-	// with "no space left" while shards move concurrently (issue #11753). The
-	// server's refusal is authoritative: re-collect the topology, mark the
-	// refusing targets no-receive, and plan again. They stay usable as sources.
-	noReceiveTargets := make(map[string]bool)
-	noReceiveDisks := make(map[string]map[uint32]bool)
-	var completed []ecbalancer.Move
-	var lastErr error
-	for {
-		// collect all ec nodes
-		allEcNodes, totalFreeEcSlots, err := CollectEcNodesForDC(env, dc, diskType)
-		if err != nil {
-			return err
-		}
+	ecb := &ecBalancer{
+		env:                env,
+		ecNodes:            allEcNodes,
+		replicaPlacement:   ecReplicaPlacement,
+		applyBalancing:     applyBalancing,
+		maxParallelization: maxParallelization,
+		ioBytePerSecond:    ioBytePerSecond,
+		diskType:           diskType,
+		volumeIds:          volumeIdFilter,
+		migratingVolumeIds: migrating,
+	}
 
-		// Drop excluded nodes (and the slots they contribute) before planning so they
-		// can be neither a target nor a source for any move this balance plans.
-		if len(excludeNodes) > 0 {
-			kept := allEcNodes[:0]
-			var excludedFreeSlots int
-			for _, en := range allEcNodes {
-				if _, skip := excludeNodes[pb.NewServerAddressFromDataNode(en.Info)]; skip {
-					excludedFreeSlots += en.FreeEcSlot
-					glog.V(0).Infof("EC balance excluding node %s: skipped as unreachable by the encode orphan sweep", en.Info.Id)
-					continue
-				}
-				kept = append(kept, en)
-			}
-			allEcNodes = kept
-			totalFreeEcSlots -= excludedFreeSlots
-		}
-		// A refused destination's slots cannot take a copy, so they do not
-		// count toward the free-space precheck.
-		for _, en := range allEcNodes {
-			if noReceiveTargets[en.Info.Id] {
-				totalFreeEcSlots -= en.FreeEcSlot
-				continue
-			}
-			for diskId := range noReceiveDisks[en.Info.Id] {
-				if d := en.Disks[diskId]; d != nil {
-					totalFreeEcSlots -= d.FreeEcSlots
-				}
-			}
-		}
-
-		if totalFreeEcSlots < 1 {
-			if lastErr != nil {
-				return fmt.Errorf("no receiving targets remain: %w", lastErr)
-			}
-			return fmt.Errorf("no free ec shard slots. only %d left", totalFreeEcSlots)
-		}
-
-		// A fresh collection can still describe an applied move through a
-		// heartbeat that predates its source delete; replay the journal.
-		applyCompletedMoves(allEcNodes, completed, diskType)
-
-		ecb := &ecBalancer{
-			env:                env,
-			ecNodes:            allEcNodes,
-			replicaPlacement:   ecReplicaPlacement,
-			applyBalancing:     applyBalancing,
-			maxParallelization: maxParallelization,
-			ioBytePerSecond:    ioBytePerSecond,
-			diskType:           diskType,
-			volumeIds:          volumeIdFilter,
-			migratingVolumeIds: migrating,
-			noReceiveTargets:   noReceiveTargets,
-			noReceiveDisks:     noReceiveDisks,
-		}
-
-		if len(collections) == 0 {
-			glog.V(1).Infof("WARNING: No collections to balance EC volumes across.\n")
-		}
-		err = ecb.balance(collections)
-		if !applyBalancing {
-			return err
-		}
-		if err == nil {
-			if lastErr != nil && ecb.plannedMoves == 0 {
-				return fmt.Errorf("no receiving targets remain: %w", lastErr)
-			}
-			return nil
-		}
-
-		// Replan while the failed attempt surfaced newly-refusing targets; a node
-		// once marked can no longer be picked, so the loop terminates. Any other
-		// failure aborts instead of being hidden by the retry.
-		newRejects := ecb.mergeRejectedTargets(noReceiveTargets, noReceiveDisks)
-		if len(newRejects) == 0 || ecb.hasOtherError() {
-			return err
-		}
-		lastErr = err
-		completed = append(completed, ecb.completedMoves...)
-		fmt.Printf("ec.balance: %v reported no space left; re-collecting topology and re-planning without them as targets\n", newRejects)
-	}
-}
-
-// applyCompletedMoves replays already-applied moves onto a freshly collected
-// node list: heartbeats can lag, so the snapshot may still show a moved shard
-// on its deleted source or lack it on its mounted target.
-func applyCompletedMoves(ecNodes []*EcNode, moves []ecbalancer.Move, diskType types.DiskType) {
-	if len(moves) == 0 {
-		return
-	}
-	byID := make(map[string]*EcNode, len(ecNodes))
-	for _, en := range ecNodes {
-		byID[en.Info.Id] = en
-	}
-	for _, m := range moves {
-		vid := needle.VolumeId(m.VolumeID)
-		shardId := erasure_coding.ShardId(m.ShardID)
-		if src := byID[m.SourceNode]; src != nil {
-			removeEcShard(src, vid, shardId)
-		}
-		if m.Phase == "dedup" {
-			continue
-		}
-		if dst := byID[m.TargetNode]; dst != nil && !ecNodeHasShard(dst, vid, shardId) {
-			addEcShard(dst, m.Collection, vid, shardId, m.TargetDisk, diskType)
-		}
-	}
-}
-
-func ecNodeHasShard(ecNode *EcNode, vid needle.VolumeId, shardId erasure_coding.ShardId) bool {
-	for _, diskInfo := range ecNode.Info.DiskInfos {
-		for _, eci := range diskInfo.EcShardInfos {
-			if needle.VolumeId(eci.Id) == vid && erasure_coding.ShardBits(eci.EcIndexBits).Has(shardId) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// removeEcShard drops the shard from the node model, including the per-disk
-// bookkeeping of the disk that reported it.
-func removeEcShard(en *EcNode, vid needle.VolumeId, shardId erasure_coding.ShardId) {
-	for _, diskInfo := range en.Info.DiskInfos {
-		for _, eci := range diskInfo.EcShardInfos {
-			if needle.VolumeId(eci.Id) != vid || !erasure_coding.ShardBits(eci.EcIndexBits).Has(shardId) {
-				continue
-			}
-			if d := en.Disks[eci.DiskId]; d != nil {
-				if si := d.EcShards[vid]; si != nil {
-					si.Delete(shardId)
-				}
-				d.EcShardCount--
-				d.FreeEcSlots++
-			}
-		}
-	}
-	en.DeleteEcVolumeShards(vid, []erasure_coding.ShardId{shardId})
-}
-
-// addEcShard places the shard on the disk the move used when that disk is
-// known; otherwise (TargetDisk 0, server-picked) it falls back to the node's
-// disk-type bucket.
-func addEcShard(en *EcNode, collection string, vid needle.VolumeId, shardId erasure_coding.ShardId, diskId uint32, diskType types.DiskType) {
-	d := en.Disks[diskId]
-	if diskId == 0 || d == nil {
-		en.AddEcVolumeShards(vid, collection, []erasure_coding.ShardId{shardId}, diskType)
-		return
-	}
-	diskInfo := en.Info.DiskInfos[string(diskType)]
-	if diskInfo == nil {
-		diskInfo = &master_pb.DiskInfo{Type: string(diskType)}
-		en.Info.DiskInfos[string(diskType)] = diskInfo
-	}
-	var eci *master_pb.VolumeEcShardInformationMessage
-	for _, e := range diskInfo.EcShardInfos {
-		if needle.VolumeId(e.Id) == vid && e.DiskId == diskId {
-			eci = e
-			break
-		}
-	}
-	if eci == nil {
-		eci = &master_pb.VolumeEcShardInformationMessage{
-			Id:         uint32(vid),
-			Collection: collection,
-			DiskId:     diskId,
-			DiskType:   string(diskType),
-		}
-		diskInfo.EcShardInfos = append(diskInfo.EcShardInfos, eci)
-	}
-	si := erasure_coding.ShardsInfoFromVolumeEcShardInformationMessage(eci)
-	before := si.Count()
-	si.Set(erasure_coding.NewShardInfo(shardId, 0))
-	eci.EcIndexBits = si.Bitmap()
-	eci.ShardSizes = si.SizesInt64()
-	added := si.Count() - before
-
-	en.FreeEcSlot -= added
-	d.EcShardCount += added
-	d.FreeEcSlots -= added
-	if d.EcShards == nil {
-		d.EcShards = make(map[needle.VolumeId]*erasure_coding.ShardsInfo)
-	}
-	if d.EcShards[vid] == nil {
-		d.EcShards[vid] = erasure_coding.NewShardsInfo()
-	}
-	d.EcShards[vid].Set(erasure_coding.NewShardInfo(shardId, 0))
-}
-
-// mergeRejectedTargets folds the destinations this run saw refuse into the
-// no-receive sets and returns the newly added ids; an empty result means no
-// progress is possible.
-func (ecb *ecBalancer) mergeRejectedTargets(noReceiveNodes map[string]bool, noReceiveDisks map[string]map[uint32]bool) (added []string) {
-	ecb.mu.Lock()
-	defer ecb.mu.Unlock()
-	for id := range ecb.rejectedTargets {
-		if !noReceiveNodes[id] {
-			noReceiveNodes[id] = true
-			added = append(added, id)
-		}
-	}
-	for id, disks := range ecb.rejectedDisks {
-		if noReceiveNodes[id] {
-			continue
-		}
-		if noReceiveDisks[id] == nil {
-			noReceiveDisks[id] = make(map[uint32]bool)
-		}
-		for diskId := range disks {
-			if !noReceiveDisks[id][diskId] {
-				noReceiveDisks[id][diskId] = true
-				added = append(added, fmt.Sprintf("%s:disk%d", id, diskId))
-			}
-		}
-	}
-	sort.Strings(added)
-	return
-}
-
-func (ecb *ecBalancer) hasOtherError() bool {
-	ecb.mu.Lock()
-	defer ecb.mu.Unlock()
-	return ecb.sawOtherErr
-}
-
-// recordMoveResult journals an apply-mode move outcome: a success is replayed
-// onto the next attempt's snapshot, a "no space left" marks the target
-// no-receive, and any other failure makes the run non-retryable.
-func (ecb *ecBalancer) recordMoveResult(m ecbalancer.Move, err error) {
-	ecb.mu.Lock()
-	defer ecb.mu.Unlock()
-	switch {
-	case err == nil:
-		ecb.completedMoves = append(ecb.completedMoves, m)
-	case m.TargetNode != "" && volume_move.IsNoSpaceLeftError(err):
-		if m.TargetDisk > 0 {
-			// The refusal convicts only the named disk; the node's other
-			// disks may still have room.
-			if ecb.rejectedDisks == nil {
-				ecb.rejectedDisks = make(map[string]map[uint32]bool)
-			}
-			if ecb.rejectedDisks[m.TargetNode] == nil {
-				ecb.rejectedDisks[m.TargetNode] = make(map[uint32]bool)
-			}
-			ecb.rejectedDisks[m.TargetNode][m.TargetDisk] = true
-		} else {
-			// The server auto-picked and found no usable disk: the whole
-			// node is out.
-			if ecb.rejectedTargets == nil {
-				ecb.rejectedTargets = make(map[string]bool)
-			}
-			ecb.rejectedTargets[m.TargetNode] = true
-		}
-	default:
-		ecb.sawOtherErr = true
+	if len(collections) == 0 {
+		glog.V(1).Infof("WARNING: No collections to balance EC volumes across.\n")
 	}
+	return ecb.balance(collections)
 }
 
 // defaultECRatio resolves a collection's EC data/parity counts, defaulting to
@@ -1102,7 +852,7 @@ func defaultECRatio(_ string) (int, int) {
 // balance plans EC shard moves with the shared planner and executes them. When
 // collections is empty all collections present are balanced.
 func (ecb *ecBalancer) balance(collections []string) error {
-	topo, volumeRatio, selected := toBalancerTopology(ecb.ecNodes, collections, ecb.diskType, ecb.volumeIds, ecb.migratingVolumeIds, ecb.noReceiveTargets, ecb.noReceiveDisks)
+	topo, volumeRatio, selected := toBalancerTopology(ecb.ecNodes, collections, ecb.diskType, ecb.volumeIds, ecb.migratingVolumeIds)
 	if len(ecb.volumeIds) > 0 {
 		requested := make([]uint32, 0, len(ecb.volumeIds))
 		for vid := range ecb.volumeIds {
@@ -1146,7 +896,6 @@ func (ecb *ecBalancer) balance(collections []string) error {
 		}
 		fmt.Printf("planned %d ec shard move(s) and %d ec shard deletion(s)\n", len(moves)-deletions, deletions)
 	}
-	ecb.plannedMoves = len(moves)
 	return ecb.executeMoves(moves)
 }
 
@@ -1158,7 +907,7 @@ func (ecb *ecBalancer) balance(collections []string) error {
 // (0,0 when unreported, e.g. always in OSS), which Plan prefers over the
 // collection ratio for mixed-ratio clusters, and the set of volume ids that made
 // it into the topology.
-func toBalancerTopology(ecNodes []*EcNode, collections []string, diskType types.DiskType, volumeIds map[uint32]bool, migratingVolumeIds map[uint32]bool, noReceiveTargets map[string]bool, noReceiveDisks map[string]map[uint32]bool) (*ecbalancer.Topology, func(collection string, vid uint32) (int, int), map[uint32]bool) {
+func toBalancerTopology(ecNodes []*EcNode, collections []string, diskType types.DiskType, volumeIds map[uint32]bool, migratingVolumeIds map[uint32]bool) (*ecbalancer.Topology, func(collection string, vid uint32) (int, int), map[uint32]bool) {
 	allowed := make(map[string]bool, len(collections))
 	for _, c := range collections {
 		allowed[c] = true
@@ -1175,17 +924,11 @@ func toBalancerTopology(ecNodes []*EcNode, collections []string, diskType types.
 	for _, en := range ecNodes {
 		rackKey := string(en.DC) + ":" + string(en.Rack)
 		node := topo.AddNode(en.Info.Id, string(en.DC), rackKey, en.FreeEcSlot)
-		if noReceiveTargets[en.Info.Id] {
-			node.SetNoReceive()
-		}
 		// Group by physical machine (host) so shards spread across machines, not just
 		// nodes; the id stays the node identity used for moves.
 		node.SetHost(pb.NewServerAddressFromDataNode(en.Info).ToHost())
 		for diskId, d := range en.Disks {
 			node.AddDisk(diskId, d.DiskType, d.FreeEcSlots, d.EcShardCount)
-			if noReceiveDisks[en.Info.Id][diskId] {
-				node.SetDiskNoReceive(diskId)
-			}
 		}
 		for diskTypeKey, diskInfo := range en.Info.DiskInfos {
 			if diskInfo == nil {
@@ -1326,16 +1069,14 @@ func (ecb *ecBalancer) executeMove(byID map[string]*EcNode, m ecbalancer.Move) e
 		// thing making this safe -- and the plan saying so is not evidence. A
 		// topology entry can name a location holding nothing, and deleting on
 		// that basis removes the last copy. Confirm the keep node has it.
-		err := verifyEcShardOnKeepNode(grpcDialOption, m.Collection, vid, m.KeepNode, shardId)
+		if err := verifyEcShardOnKeepNode(grpcDialOption, m.Collection, vid, m.KeepNode, shardId); err != nil {
+			return err
+		}
 		addr := pb.NewServerAddressFromDataNode(src.Info)
-		if err == nil {
-			err = UnmountEcShards(grpcDialOption, vid, addr, shardIds)
+		if err := UnmountEcShards(grpcDialOption, vid, addr, shardIds); err != nil {
+			return err
 		}
-		if err == nil {
-			err = SourceServerDeleteEcShards(grpcDialOption, m.Collection, vid, addr, shardIds)
-		}
-		ecb.recordMoveResult(m, err)
-		return err
+		return SourceServerDeleteEcShards(grpcDialOption, m.Collection, vid, addr, shardIds)
 	}
 
 	dst := byID[m.TargetNode]
@@ -1351,9 +1092,7 @@ func (ecb *ecBalancer) executeMove(byID map[string]*EcNode, m ecbalancer.Move) e
 		// Dry-run: update the in-memory model only.
 		return MoveMountedShardToEcNode(ecb.env, src, m.Collection, vid, shardId, dst, m.TargetDisk, false, ecb.diskType)
 	}
-	err := ecb.applyShardMoveRPC(src, dst, m.Collection, vid, shardId, m.TargetDisk)
-	ecb.recordMoveResult(m, err)
-	return err
+	return ecb.applyShardMoveRPC(src, dst, m.Collection, vid, shardId, m.TargetDisk)
 }
 
 // applyShardMoveRPC copies a shard to the destination disk, verifies the

weed/ec/ec_shard_unmount.go

@@ -135,10 +135,7 @@ func (c *ecShardUnmounter) doShardsUnmount() error {
 		for _, ts := range liveShards {
 			if ts.ShardID == ps.ShardID {
 				if ps.NodeAddress == "" || ps.NodeAddress == ts.NodeAddress {
-					// One node is one unmount target no matter how many of
-					// its disks hold the shard; ambiguity means the shard
-					// lives on more than one node.
-					if result != nil && result.NodeAddress != ts.NodeAddress {
+					if result != nil {
 						return fmt.Errorf("shard %v is ambiguous", ps)
 					}
 					result = ts

weed/ec/ec_shard_unmount_test.go

@@ -1,10 +1,8 @@
 package ec
 
 import (
-	"bytes"
 	"testing"
 
-	"github.com/seaweedfs/seaweedfs/weed/pb/master_pb"
 	"github.com/seaweedfs/seaweedfs/weed/storage/erasure_coding"
 	"github.com/stretchr/testify/assert"
 )
@@ -102,82 +100,3 @@ func TestEcShardStringRoundTrips(t *testing.T) {
 		assert.Equal(t, []*ShardRef{s}, got)
 	}
 }
-
-func unmountTestTopology(nodes map[string]map[string][]uint32) *master_pb.TopologyInfo {
-	var dataNodes []*master_pb.DataNodeInfo
-	for addr, disks := range nodes {
-		diskInfos := map[string]*master_pb.DiskInfo{}
-		for disk, shardIds := range disks {
-			si := erasure_coding.NewShardsInfo()
-			for _, sid := range shardIds {
-				si.Set(erasure_coding.NewShardInfo(erasure_coding.ShardId(sid), 1))
-			}
-			diskInfos[disk] = &master_pb.DiskInfo{
-				Type:           "hdd",
-				MaxVolumeCount: 100,
-				EcShardInfos: []*master_pb.VolumeEcShardInformationMessage{{
-					Id:          100,
-					Collection:  "c1",
-					EcIndexBits: si.Bitmap(),
-					ShardSizes:  si.SizesInt64(),
-					DiskType:    "hdd",
-				}},
-			}
-		}
-		dataNodes = append(dataNodes, &master_pb.DataNodeInfo{
-			Id:        addr,
-			Address:   addr,
-			DiskInfos: diskInfos,
-		})
-	}
-	return &master_pb.TopologyInfo{DataCenterInfos: []*master_pb.DataCenterInfo{{
-		Id:        "dc1",
-		RackInfos: []*master_pb.RackInfo{{Id: "r1", DataNodeInfos: dataNodes}},
-	}}}
-}
-
-// A shard held on two disks of one node is a single unmount target: the
-// unmount RPC addresses the node, not the disk.
-func TestUnmountResolvesShardDuplicatedOnOneNode(t *testing.T) {
-	topo := unmountTestTopology(map[string]map[string][]uint32{
-		"vs3:8080": {"hdd:0": {12}, "hdd:1": {12}},
-		"vs4:8080": {"hdd:0": {13}},
-	})
-
-	for _, shards := range [][]*ShardRef{
-		{{ShardID: 12}},
-		{{ShardID: 12, NodeAddress: "vs3:8080"}},
-	} {
-		var out bytes.Buffer
-		err := UnmountShards(&Env{}, &out, ShardUnmountRequest{
-			Topology: topo,
-			VolumeID: 100,
-			Shards:   shards,
-		})
-		assert.NoError(t, err, "shard %+v", shards)
-		assert.Contains(t, out.String(), "Will unmount 1 shard(s)")
-	}
-}
-
-func TestUnmountStillRejectsShardOnTwoNodes(t *testing.T) {
-	topo := unmountTestTopology(map[string]map[string][]uint32{
-		"vs3:8080": {"hdd:0": {12}},
-		"vs4:8080": {"hdd:0": {12}},
-	})
-
-	var out bytes.Buffer
-	err := UnmountShards(&Env{}, &out, ShardUnmountRequest{
-		Topology: topo,
-		VolumeID: 100,
-		Shards:   []*ShardRef{{ShardID: 12}},
-	})
-	assert.ErrorContains(t, err, "ambiguous")
-
-	out.Reset()
-	err = UnmountShards(&Env{}, &out, ShardUnmountRequest{
-		Topology: topo,
-		VolumeID: 100,
-		Shards:   []*ShardRef{{ShardID: 12, NodeAddress: "vs3:8080"}},
-	})
-	assert.NoError(t, err)
-}

weed/filer/abstract_sql/abstract_sql_store.go

@@ -390,14 +390,6 @@ func (store *AbstractSqlStore) DeleteFolderChildren(ctx context.Context, fullpat
 	return doDeleteFolderChildren()
 }
 
-var likeEscaper = strings.NewReplacer("!", "!!", "%", "!%", "_", "!_")
-
-// LikePattern escapes LIKE wildcards so the prefix matches literally;
-// '!' pairs with the ESCAPE '!' clause emitted by the SqlGenerators.
-func LikePattern(prefix string) string {
-	return likeEscaper.Replace(prefix) + "%"
-}
-
 func (store *AbstractSqlStore) ListDirectoryPrefixedEntries(ctx context.Context, dirPath util.FullPath, startFileName string, includeStartFile bool, limit int64, prefix string, eachEntryFunc filer.ListEachEntryFunc) (lastFileName string, err error) {
 
 	db, bucket, shortPath, err := store.getTxOrDB(ctx, dirPath, true)
@@ -410,7 +402,7 @@ func (store *AbstractSqlStore) ListDirectoryPrefixedEntries(ctx context.Context,
 		sqlText = store.GetSqlListInclusive(bucket)
 	}
 
-	rows, err := db.QueryContext(ctx, sqlText, util.HashStringToLong(string(shortPath)), startFileName, string(shortPath), LikePattern(prefix), limit+1)
+	rows, err := db.QueryContext(ctx, sqlText, util.HashStringToLong(string(shortPath)), startFileName, string(shortPath), prefix+"%", limit+1)
 	if err != nil {
 		return lastFileName, fmt.Errorf("list %s : %v", dirPath, err)
 	}

weed/filer/abstract_sql/abstract_sql_store_test.go

@@ -52,24 +52,6 @@ func TestGetTxOrDBRealBucket(t *testing.T) {
 	}
 }
 
-func TestLikePattern(t *testing.T) {
-	cases := []struct {
-		prefix, want string
-	}{
-		{"", "%"},
-		{"plain", "plain%"},
-		{"call_03_KNl", "call!_03!_KNl%"},
-		{"100%", "100!%%"},
-		{"a!b", "a!!b%"},
-		{`a\b`, `a\b%`},
-	}
-	for _, c := range cases {
-		if got := LikePattern(c.prefix); got != c.want {
-			t.Errorf("LikePattern(%q) = %q, want %q", c.prefix, got, c.want)
-		}
-	}
-}
-
 func TestSplitPoolForKv(t *testing.T) {
 	cases := []struct {
 		maxOpen, mainOpen, kvOpen int

weed/filer/arangodb/arangodb_store_kv.go

@@ -39,7 +39,7 @@ func (store *ArangodbStore) KvGet(ctx context.Context, key []byte) (value []byte
 	}
 	if err != nil {
 		glog.ErrorfCtx(ctx, "kv get: %s %v", string(key), err)
-		return nil, err
+		return nil, filer.ErrKvNotFound
 	}
 	return arrayToBytes(model.Meta), nil
 }

weed/filer/elastic/v7/elastic_store_kv.go

@@ -37,16 +37,13 @@ func (store *ElasticStore) KvGet(ctx context.Context, key []byte) (value []byte,
 	if elastic.IsNotFound(err) {
 		return value, filer.ErrKvNotFound
 	}
-	if err != nil {
-		glog.ErrorfCtx(ctx, "find key(%s),%v.", string(key), err)
-		return value, err
-	}
 	if searchResult != nil && searchResult.Found {
 		esEntry := &ESKVEntry{}
 		if err := jsoniter.Unmarshal(searchResult.Source, esEntry); err == nil {
 			return esEntry.Value, nil
 		}
 	}
+	glog.ErrorfCtx(ctx, "find key(%s),%v.", string(key), err)
 	return value, filer.ErrKvNotFound
 }
 

weed/filer/filechunk_manifest.go

@@ -458,11 +458,11 @@ func retriedStreamFetchChunkData(ctx context.Context, writer io.Writer, urlStrin
 				localProcessed += writtenCount
 				totalWritten += writtenCount
 			})
-			if writeErr != nil {
-				err = writeErr
+			if !shouldRetry {
 				break
 			}
-			if !shouldRetry {
+			if writeErr != nil {
+				err = writeErr
 				break
 			}
 			if err != nil {

weed/filer/filechunk_manifest_test.go

@@ -787,23 +787,3 @@ func TestFetchWholeChunkUsesProvidedFilerJwt(t *testing.T) {
 		return ""
 	}))
 }
-
-// A completed fetch whose destination write failed is a failed copy, not a
-// short success: the caller must see the write error, or a temp disk filling
-// mid-copy would still upload the truncated file.
-func TestRetriedStreamFetchChunkDataReportsWriteError(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte("0123456789"))
-	}))
-	t.Cleanup(srv.Close)
-
-	written, err := retriedStreamFetchChunkData(context.Background(), &failOnWrite{}, []string{srv.URL + "/5,abc"}, "", nil, false, true, 0, 0, nil)
-	assert.Error(t, err)
-	assert.Zero(t, written)
-}
-
-type failOnWrite struct{}
-
-func (w *failOnWrite) Write(p []byte) (int, error) {
-	return 0, fmt.Errorf("no space left")
-}

weed/filer/filer.go

@@ -890,7 +890,7 @@ func (f *Filer) DeleteEmptyParentDirectories(ctx context.Context, dirPath util.F
 	glog.V(2).InfofCtx(ctx, "DeleteEmptyParentDirectories: deleting empty directory %s", dirPath)
 	parentDir, _ := dirPath.DirAndName()
 	if dirEntry, findErr := f.FindEntry(ctx, dirPath); findErr == nil {
-		if delErr := f.doDeleteEntryMetaAndData(f.emptyFolderDeleteContext(ctx, dirPath), dirEntry, false, false, nil); delErr == nil {
+		if delErr := f.doDeleteEntryMetaAndData(ctx, dirEntry, false, false, nil); delErr == nil {
 			// Successfully deleted, continue checking upwards
 			f.DeleteEmptyParentDirectories(ctx, util.FullPath(parentDir), stopAtPath)
 		} else {

weed/filer/filer_delete_entry.go

@@ -80,27 +80,6 @@ func keepsRemoteObject(ctx context.Context) bool {
 	return ctx.Value(keepRemoteObjectKey{}) != nil
 }
 
-// emptyFolderDeleteContext makes deleting a folder that is empty in the filer
-// metadata-only when it is under a remote mount. A mount is populated lazily,
-// so the folder can still hold remote objects never read, and removing its
-// remote directory deletes every object under that prefix.
-func (f *Filer) emptyFolderDeleteContext(ctx context.Context, dirPath util.FullPath) context.Context {
-	if f.IsUnderRemoteMount(dirPath) {
-		return WithKeepRemoteObject(ctx)
-	}
-	return ctx
-}
-
-// IsUnderRemoteMount reports whether p is a remote mount directory or lies under one.
-func (f *Filer) IsUnderRemoteMount(p util.FullPath) bool {
-	if f.RemoteStorage == nil {
-		return false
-	}
-	// Mount rules are keyed with a trailing slash, so this also matches the mount directory itself.
-	_, remoteLoc := f.RemoteStorage.FindMountDirectory(util.FullPath(string(p) + "/"))
-	return remoteLoc != nil
-}
-
 func deleteEventEntry(ctx context.Context, entry *Entry) *Entry {
 	if !keepsRemoteObject(ctx) {
 		return entry
@@ -129,9 +108,6 @@ func (f *Filer) DeleteEntryMetaAndData(ctx context.Context, p util.FullPath, isR
 	if ifNotModifiedAfter > 0 && entry.Attr.Mtime.Unix() > ifNotModifiedAfter {
 		return nil
 	}
-	if !isRecursive && entry.IsDirectory() {
-		ctx = f.emptyFolderDeleteContext(ctx, p)
-	}
 	isDeleteCollection := f.IsBucket(entry)
 	collectionName := ""
 	if isDeleteCollection {
@@ -194,7 +170,7 @@ func (f *Filer) DeleteEntryMetaAndData(ctx context.Context, p util.FullPath, isR
 func (f *Filer) doBatchDeleteFolderMetaAndData(ctx context.Context, entry *Entry, isRecursive, ignoreRecursiveError, shouldDeleteChunks, isDeletingBucket, isFromOtherCluster bool, signatures []int32, onHardLinkIdsFn OnHardLinkIdsFunc) (err error) {
 
 	var dirTombstoneTs int64
-	if isRecursive && !keepsRemoteObject(ctx) {
+	if isRecursive {
 		// Tombstone the directory before its children: when the store drops
 		// the subtree without listing it, or a child error aborts the walk,
 		// the ancestor tombstone still covers every descendant.
@@ -225,9 +201,7 @@ func (f *Filer) doBatchDeleteFolderMetaAndData(ctx context.Context, entry *Entry
 
 			for _, sub := range entries {
 				lastFileName = sub.Name()
-				if !keepsRemoteObject(ctx) {
-					f.noteRemoteDeletion(sub.FullPath, sub.IsDirectory(), time.Now().UnixNano())
-				}
+				f.noteRemoteDeletion(sub.FullPath, sub.IsDirectory(), time.Now().UnixNano())
 				if sub.IsDirectory() {
 					subIsDeletingBucket := f.IsBucket(sub)
 					err = f.doBatchDeleteFolderMetaAndData(ctx, sub, isRecursive, ignoreRecursiveError, shouldDeleteChunks, subIsDeletingBucket, isFromOtherCluster, nil, onHardLinkIdsFn)
@@ -247,9 +221,6 @@ func (f *Filer) doBatchDeleteFolderMetaAndData(ctx context.Context, entry *Entry
 					if len(sub.HardLinkId) != 0 {
 						// hard link chunk data are deleted separately
 						err = onHardLinkIdsFn([]HardLinkId{sub.HardLinkId})
-						if shouldDeleteChunks && f.hardLinkIsOrphaned(ctx, sub.HardLinkId) {
-							chunksToDelete = append(chunksToDelete, sub.GetChunks()...)
-						}
 					} else {
 						if shouldDeleteChunks {
 							chunksToDelete = append(chunksToDelete, sub.GetChunks()...)
@@ -293,10 +264,7 @@ func (f *Filer) doDeleteEntryMetaAndData(ctx context.Context, entry *Entry, shou
 		}
 	}
 
-	// A metadata-only delete owes the remote nothing, so lazy reads stay open.
-	if !keepsRemoteObject(ctx) {
-		f.noteRemoteDeletion(entry.FullPath, entry.IsDirectory(), time.Now().UnixNano())
-	}
+	f.noteRemoteDeletion(entry.FullPath, entry.IsDirectory(), time.Now().UnixNano())
 
 	if storeDeletionErr := f.Store.DeleteOneEntry(ctx, entry); storeDeletionErr != nil {
 		return fmt.Errorf("filer store delete: %w", storeDeletionErr)
@@ -414,10 +382,3 @@ func (f *Filer) maybeDeleteHardLinks(ctx context.Context, hardLinkIds []HardLink
 		}
 	}
 }
-
-// hardLinkIsOrphaned reports whether the shared inode record for hardLinkId
-// is gone, meaning the removed link was the last owner of its chunks.
-func (f *Filer) hardLinkIsOrphaned(ctx context.Context, hardLinkId HardLinkId) bool {
-	_, err := f.Store.KvGet(ctx, hardLinkId)
-	return errors.Is(err, ErrKvNotFound)
-}

weed/filer/filer_delete_entry_test.go

@@ -6,10 +6,7 @@ import (
 	"fmt"
 	"os"
 	"testing"
-	"time"
 
-	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
-	"github.com/seaweedfs/seaweedfs/weed/util"
 	"github.com/stretchr/testify/require"
 )
 
@@ -64,56 +61,3 @@ func TestKeepRemoteObjectMarkerOnlyLivesOnDeleteEvents(t *testing.T) {
 	require.Equal(t, "dir", keep.Last().EventNotification.OldEntry.Name)
 	require.True(t, IsMetadataOnlyDelete(keep.Last().EventNotification.OldEntry))
 }
-
-// A recursive delete that removes the last link to an inode must free the
-// shared chunks: the record that owned them is gone, so nothing else will.
-func TestDeleteFolderFreesLastHardLinkChunks(t *testing.T) {
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, NewFilerRemoteStorage())
-	ctx := context.Background()
-
-	hardLinkId := NewHardLinkId()
-	require.NoError(t, f.CreateEntry(ctx, &Entry{FullPath: "/d", Attr: Attr{Mode: os.ModeDir | 0755}}, nil, false, false, nil, true, 255))
-	linkEntry := &Entry{
-		FullPath:        "/d/a.txt",
-		Attr:            Attr{Mode: 0644, Mtime: time.Now()},
-		HardLinkId:      hardLinkId,
-		HardLinkCounter: 1,
-		Chunks:          []*filer_pb.FileChunk{{FileId: "3,01637037d6"}},
-	}
-	require.NoError(t, f.CreateEntry(ctx, linkEntry, nil, false, false, nil, true, 255))
-
-	require.NoError(t, f.DeleteEntryMetaAndData(ctx, "/d", true, false, true, false, nil, 0))
-
-	_, err := store.KvGet(ctx, hardLinkId)
-	require.ErrorIs(t, err, ErrKvNotFound)
-	require.Equal(t, 1, f.pendingDeletionCount())
-}
-
-// The same delete keeps the shared chunks while another link outside the
-// folder still owns them.
-func TestDeleteFolderKeepsSharedHardLinkChunks(t *testing.T) {
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, NewFilerRemoteStorage())
-	ctx := context.Background()
-
-	hardLinkId := NewHardLinkId()
-	for _, dir := range []string{"/d", "/keep"} {
-		require.NoError(t, f.CreateEntry(ctx, &Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir | 0755}}, nil, false, false, nil, true, 255))
-	}
-	for _, path := range []string{"/d/a.txt", "/keep/b.txt"} {
-		require.NoError(t, f.CreateEntry(ctx, &Entry{
-			FullPath:        util.FullPath(path),
-			Attr:            Attr{Mode: 0644, Mtime: time.Now()},
-			HardLinkId:      hardLinkId,
-			HardLinkCounter: 2,
-			Chunks:          []*filer_pb.FileChunk{{FileId: "3,01637037d6"}},
-		}, nil, false, false, nil, true, 255))
-	}
-
-	require.NoError(t, f.DeleteEntryMetaAndData(ctx, "/d", true, false, true, false, nil, 0))
-
-	_, err := store.KvGet(ctx, hardLinkId)
-	require.NoError(t, err, "surviving link must keep the inode record")
-	require.Equal(t, 0, f.pendingDeletionCount())
-}

weed/filer/filer_lazy_remote.go

@@ -18,15 +18,11 @@ import (
 
 type lazyFetchContextKey struct{}
 
-// lazyParentsContextKey marks a FindEntry issued while materializing missing
-// parents: that fetch's own parent walk would only re-stat the same gaps.
-type lazyParentsContextKey struct{}
-
 // maybeLazyFetchFromRemote is called by FindEntry when the store returns no
 // entry for p. If p is under a remote-storage mount, it stats the remote
 // object, builds a filer Entry from the result, and persists it via
-// CreateEntry together with its missing parent directories: remote.uncache
-// and cache eviction find entries by walking down from the mount directory.
+// CreateEntry with SkipCheckParentDirectory so phantom parent directories
+// under the mount are not required.
 //
 // On a CreateEntry failure after a successful StatFile the in-memory entry is
 // still returned (availability over consistency); the singleflight key is
@@ -131,10 +127,7 @@ func (f *Filer) maybeLazyFetchFromRemote(ctx context.Context, p util.FullPath) (
 			glog.V(2).InfofCtx(ctx, "maybeLazyFetchFromRemote: %s deleted during remote stat", p)
 			return lazyFetchResult{nil}, nil
 		}
-		if ctx.Value(lazyParentsContextKey{}) == nil {
-			f.fetchMissingRemoteParents(persistBaseCtx, mountDir, p)
-		}
-		saveErr := f.CreateEntry(persistCtx, entry, nil, false, false, nil, false, f.MaxFilenameLength)
+		saveErr := f.CreateEntry(persistCtx, entry, nil, false, false, nil, true, f.MaxFilenameLength)
 		if saveErr != nil {
 			glog.Warningf("maybeLazyFetchFromRemote: failed to persist filer entry for %s: %v", p, saveErr)
 			f.lazyFetchGroup.Forget(key)
@@ -164,25 +157,6 @@ func (f *Filer) maybeLazyFetchFromRemote(ctx context.Context, p util.FullPath) (
 	return result.entry, nil
 }
 
-// fetchMissingRemoteParents looks up p's missing parents under mountDir, top
-// down, through lazy fetch. A remote object stored at a parent's key is then
-// materialized first, so creating p promotes it to a prefix object instead of
-// hiding it behind a plain directory. Each missing parent costs one remote
-// stat, once per directory.
-func (f *Filer) fetchMissingRemoteParents(ctx context.Context, mountDir, p util.FullPath) {
-	var missing []util.FullPath
-	for dir, _ := p.DirAndName(); len(dir) > len(mountDir); dir, _ = util.FullPath(dir).DirAndName() {
-		if _, err := f.Store.FindEntry(ctx, util.FullPath(dir)); !errors.Is(err, filer_pb.ErrNotFound) {
-			break
-		}
-		missing = append(missing, util.FullPath(dir))
-	}
-	parentCtx := context.WithValue(ctx, lazyParentsContextKey{}, true)
-	for i := len(missing) - 1; i >= 0; i-- {
-		f.FindEntry(parentCtx, missing[i])
-	}
-}
-
 // retractLazyRemoteEntry deletes the entry at entry.FullPath only when it is
 // still the entry a lazy remote read just materialized — a concurrent write
 // may have replaced it, and deleting by path alone would take that write down.
@@ -202,42 +176,33 @@ func (f *Filer) retractLazyRemoteEntry(ctx context.Context, entry *Entry) {
 	}
 }
 
-// remoteStorageObject resolves the client and object location entry maps to
-// on its mounted remote storage; a nil client means the path is not mounted.
-func (f *Filer) remoteStorageObject(ctx context.Context, entry *Entry) (remote_storage.RemoteStorageClient, *remote_pb.RemoteStorageLocation, error) {
-	mountDir, remoteLoc := f.RemoteStorage.FindMountDirectory(entry.FullPath)
-	if remoteLoc == nil {
-		return nil, nil, nil
-	}
-
-	remoteConf, found := f.RemoteStorage.GetRemoteStorageConf(remoteLoc.Name)
-	if !found {
-		return nil, nil, fmt.Errorf("resolve remote storage client for %s: not found", entry.FullPath)
-	}
-	client, clientErr := f.buildRemoteStorageClient(ctx, remoteConf)
-	if clientErr != nil {
-		return nil, nil, fmt.Errorf("resolve remote storage client for %s: %w", entry.FullPath, clientErr)
-	}
-	if client == nil {
-		return nil, nil, fmt.Errorf("resolve remote storage client for %s: initialization failed", entry.FullPath)
-	}
-
-	return client, MapFullPathToRemoteStorageLocation(mountDir, remoteLoc, entry.FullPath), nil
-}
-
 func (f *Filer) maybeDeleteFromRemote(ctx context.Context, entry *Entry) (bool, error) {
 	if entry == nil || f.RemoteStorage == nil {
 		return false, nil
 	}
 
+	mountDir, remoteLoc := f.RemoteStorage.FindMountDirectory(entry.FullPath)
+	if remoteLoc == nil {
+		return false, nil
+	}
+
 	if !entry.IsDirectory() && entry.Remote == nil {
 		return false, nil
 	}
 
-	client, objectLoc, err := f.remoteStorageObject(ctx, entry)
-	if err != nil || client == nil {
-		return false, err
+	remoteConf, found := f.RemoteStorage.GetRemoteStorageConf(remoteLoc.Name)
+	if !found {
+		return false, fmt.Errorf("resolve remote storage client for %s: not found", entry.FullPath)
 	}
+	client, clientErr := f.buildRemoteStorageClient(ctx, remoteConf)
+	if clientErr != nil {
+		return false, fmt.Errorf("resolve remote storage client for %s: %w", entry.FullPath, clientErr)
+	}
+	if client == nil {
+		return false, fmt.Errorf("resolve remote storage client for %s: initialization failed", entry.FullPath)
+	}
+
+	objectLoc := MapFullPathToRemoteStorageLocation(mountDir, remoteLoc, entry.FullPath)
 
 	if entry.IsDirectory() {
 		if err := client.RemoveDirectory(objectLoc); err != nil {
@@ -261,84 +226,6 @@ func (f *Filer) maybeDeleteFromRemote(ctx context.Context, entry *Entry) (bool,
 	return true, nil
 }
 
-// deleteSweptEntryRemote frees the remote objects a swept entry still owns,
-// mirroring the write-back daemon's delete guards (processDeleteEvent): the
-// source a pending rename marker still reads goes first — nothing else
-// releases it — then the object at the entry's own key, each only while it
-// is still the object the entry's stamp describes.
-func (f *Filer) deleteSweptEntryRemote(ctx context.Context, entry *Entry) error {
-	if entry == nil || f.RemoteStorage == nil || entry.Remote == nil {
-		return nil
-	}
-	client, objectLoc, err := f.remoteStorageObject(ctx, entry)
-	if err != nil || client == nil {
-		return err
-	}
-	if err := f.releasePendingRenameSource(ctx, client, entry); err != nil {
-		return err
-	}
-	return deleteRemoteFileIfUnchanged(ctx, client, objectLoc, entry.Remote)
-}
-
-// releasePendingRenameSource deletes the object a pending-rename marker on
-// entry still reads: the destination copy never landed, so the source key is
-// the content's only location and dropping the entry would orphan it. The
-// source survives while a remote-only entry occupies its path — that entry's
-// content is the same object. The delete binds to entry's stamp, which is
-// the stamp of the source the marker reads. Mirrors the write-back daemon's
-// releasePendingSource.
-func (f *Filer) releasePendingRenameSource(ctx context.Context, client remote_storage.RemoteStorageClient, entry *Entry) error {
-	src := f.RemoteSourcePath(entry, entry.FullPath)
-	if src == entry.FullPath {
-		return nil
-	}
-	srcEntry, err := f.Store.FindEntry(ctx, src)
-	if err != nil && !errors.Is(err, filer_pb.ErrNotFound) {
-		return fmt.Errorf("find rename source %s: %w", src, err)
-	}
-	if srcEntry != nil && len(srcEntry.Content) == 0 && srcEntry.IsInRemoteOnly() {
-		glog.V(0).InfofCtx(ctx, "keep remote source %s of pending rename of %s: a remote-only entry holds its path", src, entry.FullPath)
-		return nil
-	}
-	mountDir, remoteLoc := f.RemoteStorage.FindMountDirectory(src)
-	if remoteLoc == nil {
-		return nil
-	}
-	return deleteRemoteFileIfUnchanged(ctx, client, MapFullPathToRemoteStorageLocation(mountDir, remoteLoc, src), entry.Remote)
-}
-
-// deleteRemoteFileIfUnchanged deletes the remote object only while it is
-// still the one stamp describes. Backends offering a conditional delete bind
-// the check and the delete into one preconditioned request; the rest fall
-// back to a guarded stat-then-delete.
-func deleteRemoteFileIfUnchanged(ctx context.Context, client remote_storage.RemoteStorageClient, objectLoc *remote_pb.RemoteStorageLocation, stamp *filer_pb.RemoteEntry) error {
-	if deleter, ok := client.(remote_storage.RemoteStorageConditionalDeleter); ok {
-		deleted, delErr := deleter.DeleteFileIfUnchanged(objectLoc, stamp)
-		if delErr != nil {
-			return fmt.Errorf("delete remote file %s: %w", remote_storage.FormatLocation(objectLoc), delErr)
-		}
-		if !deleted {
-			glog.V(0).InfofCtx(ctx, "keep %s: the remote object changed since the delete", remote_storage.FormatLocation(objectLoc))
-		}
-		return nil
-	}
-	live, statErr := client.StatFile(objectLoc)
-	if statErr != nil {
-		if errors.Is(statErr, remote_storage.ErrRemoteObjectNotFound) {
-			return nil
-		}
-		return fmt.Errorf("stat remote file %s: %w", remote_storage.FormatLocation(objectLoc), statErr)
-	}
-	if !remote_storage.StillCurrent(stamp, live) {
-		glog.V(0).InfofCtx(ctx, "keep %s: the remote object changed since the delete", remote_storage.FormatLocation(objectLoc))
-		return nil
-	}
-	if err := client.DeleteFile(objectLoc); err != nil && !errors.Is(err, remote_storage.ErrRemoteObjectNotFound) {
-		return fmt.Errorf("delete remote file %s: %w", remote_storage.FormatLocation(objectLoc), err)
-	}
-	return nil
-}
-
 // DeleteFromRemote deletes the object, or for a directory every object, the
 // entry maps to on its mounted remote storage.
 func (f *Filer) DeleteFromRemote(ctx context.Context, entry *Entry) error {

weed/filer/filer_lazy_remote_listing.go

@@ -103,10 +103,6 @@ func (f *Filer) maybeLazyListFromRemote(ctx context.Context, p util.FullPath) {
 		persistCtx := context.WithValue(context.WithoutCancel(ctx), lazyListContextKey{}, true)
 		persistCtx = context.WithValue(persistCtx, lazyFetchContextKey{}, true)
 
-		// Entries listed under p must stay reachable by a walk from the mount
-		// directory, the same reason the lazy fetch fills in missing parents.
-		f.fetchMissingRemoteParents(context.WithoutCancel(ctx), mountDir, p)
-
 		listErr := client.ListDirectory(persistCtx, objectLoc, func(dir string, name string, isDirectory bool, remoteEntry *filer_pb.RemoteEntry) error {
 			childPath := p.Child(name)
 
@@ -219,7 +215,7 @@ func (f *Filer) updateDirectoryListingSyncedAt(ctx context.Context, p util.FullP
 			dirEntry.Extended = make(map[string][]byte)
 		}
 		dirEntry.Extended[xattrRemoteListingSyncedAt] = []byte(fmt.Sprintf("%d", syncTime.Unix()))
-		if saveErr := f.CreateEntry(ctx, dirEntry, nil, false, false, nil, false, f.MaxFilenameLength); saveErr != nil {
+		if saveErr := f.CreateEntry(ctx, dirEntry, nil, false, false, nil, true, f.MaxFilenameLength); saveErr != nil {
 			glog.Warningf("maybeLazyListFromRemote: create dir synced_at for %s: %v", p, saveErr)
 		}
 		return

weed/filer/filer_lazy_remote_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
 	"github.com/seaweedfs/seaweedfs/weed/pb/remote_pb"
 	"github.com/seaweedfs/seaweedfs/weed/remote_storage"
-	"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
 	"github.com/seaweedfs/seaweedfs/weed/util"
 	"github.com/seaweedfs/seaweedfs/weed/util/log_buffer"
 	"github.com/seaweedfs/seaweedfs/weed/wdclient"
@@ -36,7 +35,6 @@ type stubFilerStore struct {
 	kv              map[string][]byte
 	insertErr       error
 	findErr         error
-	findErrByPath   map[string]error
 	kvPutErr        error
 	kvGetErr        error
 	kvDeleteErr     error
@@ -202,9 +200,6 @@ func (s *stubFilerStore) FindEntry(_ context.Context, p util.FullPath) (*Entry,
 	if s.findErr != nil {
 		return nil, s.findErr
 	}
-	if err := s.findErrByPath[string(p)]; err != nil {
-		return nil, err
-	}
 	if e, ok := s.entries[string(p)]; ok {
 		return e, nil
 	}
@@ -259,8 +254,8 @@ func (c *stubRemoteClient) RemoveDirectory(loc *remote_pb.RemoteStorageLocation)
 func (c *stubRemoteClient) WriteFile(*remote_pb.RemoteStorageLocation, *filer_pb.Entry, io.Reader) (*filer_pb.RemoteEntry, error) {
 	return nil, nil
 }
-func (c *stubRemoteClient) UpdateFileMetadata(*remote_pb.RemoteStorageLocation, *filer_pb.Entry, *filer_pb.Entry) (*filer_pb.RemoteEntry, error) {
-	return nil, nil
+func (c *stubRemoteClient) UpdateFileMetadata(*remote_pb.RemoteStorageLocation, *filer_pb.Entry, *filer_pb.Entry) error {
+	return nil
 }
 func (c *stubRemoteClient) DeleteFile(loc *remote_pb.RemoteStorageLocation) error {
 	c.deleteCalls = append(c.deleteCalls, &remote_pb.RemoteStorageLocation{
@@ -281,21 +276,6 @@ func (c *stubRemoteClient) ListBuckets() ([]*remote_storage.Bucket, error) { ret
 func (c *stubRemoteClient) CreateBucket(string) error                      { return nil }
 func (c *stubRemoteClient) DeleteBucket(string) error                      { return nil }
 
-// stubConditionalRemoteClient adds the optional conditional-delete interface:
-// callers binding stat and delete into one preconditioned request never reach
-// StatFile or DeleteFile.
-type stubConditionalRemoteClient struct {
-	stubRemoteClient
-	conditionalResult bool
-	conditionalErr    error
-	conditionalCalls  []*remote_pb.RemoteStorageLocation
-}
-
-func (c *stubConditionalRemoteClient) DeleteFileIfUnchanged(loc *remote_pb.RemoteStorageLocation, _ *filer_pb.RemoteEntry) (bool, error) {
-	c.conditionalCalls = append(c.conditionalCalls, loc)
-	return c.conditionalResult, c.conditionalErr
-}
-
 // --- stub RemoteStorageClientMaker ---
 
 type stubClientMaker struct {
@@ -360,11 +340,6 @@ func putConfigEntry(store *stubFilerStore, path string, content []byte) {
 	}
 }
 
-// putDirEntry stores a plain directory entry, so a lazy fetch below it finds its parent in place.
-func putDirEntry(store *stubFilerStore, path string) {
-	store.entries[path] = &Entry{FullPath: util.FullPath(path), Attr: Attr{Mode: os.ModeDir | 0755}}
-}
-
 // --- tests ---
 
 func TestMaybeLazyFetchFromRemote_HitsRemoteAndPersists(t *testing.T) {
@@ -400,199 +375,6 @@ func TestMaybeLazyFetchFromRemote_HitsRemoteAndPersists(t *testing.T) {
 	assert.Equal(t, []byte("zstd"), stored.Extended["Content-Encoding"])
 }
 
-// pathStatRemoteClient stats only the objects it holds, keyed by remote path.
-type pathStatRemoteClient struct {
-	stubRemoteClient
-	objects   map[string]*filer_pb.RemoteEntry
-	statCalls []string
-}
-
-func (c *pathStatRemoteClient) StatFile(loc *remote_pb.RemoteStorageLocation) (*filer_pb.RemoteEntry, error) {
-	c.statCalls = append(c.statCalls, loc.Path)
-	if remoteEntry, found := c.objects[loc.Path]; found {
-		return remoteEntry, nil
-	}
-	return nil, remote_storage.ErrRemoteObjectNotFound
-}
-
-func newPathStatFiler(t *testing.T, storageType string, client remote_storage.RemoteStorageClient) (*Filer, *stubFilerStore) {
-	t.Helper()
-	t.Cleanup(registerStubMaker(t, storageType, client))
-	conf := &remote_pb.RemoteConf{Name: "mystore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "mystore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-	store := newStubFilerStore()
-	return newTestFiler(t, store, rs), store
-}
-
-func TestMaybeLazyFetchFromRemote_PersistsParentDirectories(t *testing.T) {
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/a/b/file.bin":  {RemoteMtime: 1700000000, RemoteSize: 1234},
-		"/a/b/other.bin": {RemoteMtime: 1700000000, RemoteSize: 5678},
-	}}
-	f, store := newPathStatFiler(t, "stub_lazy_parents", stub)
-
-	const filePath = "/buckets/mybucket/a/b/file.bin"
-	entry, err := f.maybeLazyFetchFromRemote(context.Background(), filePath)
-	require.NoError(t, err)
-	require.NotNil(t, entry)
-	assert.Equal(t, []string{"/a/b/file.bin", "/a", "/a/b"}, stub.statCalls, "each missing parent is stat'ed once")
-
-	for _, dir := range []string{"/buckets/mybucket/a", "/buckets/mybucket/a/b"} {
-		dirEntry := store.getEntry(dir)
-		require.NotNil(t, dirEntry, "parent %s not persisted", dir)
-		assert.True(t, dirEntry.IsDirectory(), "%s should be a directory", dir)
-		assert.Nil(t, dirEntry.Remote, "%s holds no remote object", dir)
-	}
-
-	// A sibling finds its parents in place and stats only itself.
-	stub.statCalls = nil
-	_, err = f.maybeLazyFetchFromRemote(context.Background(), "/buckets/mybucket/a/b/other.bin")
-	require.NoError(t, err)
-	assert.Equal(t, []string{"/a/b/other.bin"}, stub.statCalls)
-
-	// Once the content is cached, eviction walks down from the mount and must reach it.
-	stored := store.getEntry(filePath)
-	require.NotNil(t, stored)
-	stored.Chunks = []*filer_pb.FileChunk{{FileId: "1,01637037d6", Size: 1234}}
-	stored.Remote.LastLocalSyncTsNs = time.Now().UnixNano()
-	require.NoError(t, store.UpdateEntry(context.Background(), stored))
-
-	evictable := f.ListEvictableRemoteEntries(context.Background(), []util.FullPath{"/buckets/mybucket"}, 0)
-	require.Len(t, evictable, 1)
-	assert.Equal(t, util.FullPath(filePath), evictable[0].FullPath)
-}
-
-func TestMaybeLazyFetchFromRemote_ParentLookupStopsAtStoreError(t *testing.T) {
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/a/b/file.bin": {RemoteMtime: 1700000000, RemoteSize: 1234},
-	}}
-	f, store := newPathStatFiler(t, "stub_lazy_parent_store_error", stub)
-	store.findErrByPath = map[string]error{"/buckets/mybucket/a/b": errors.New("store unavailable")}
-
-	_, err := f.maybeLazyFetchFromRemote(context.Background(), "/buckets/mybucket/a/b/file.bin")
-	require.NoError(t, err)
-	assert.Equal(t, []string{"/a/b/file.bin"}, stub.statCalls, "a parent the store cannot read is not treated as missing")
-}
-
-func TestMaybeLazyFetchFromRemote_PromotesRemoteObjectAtParentKey(t *testing.T) {
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/reports":          {RemoteMtime: 1700000000, RemoteSize: 10},
-		"/reports/2026.csv": {RemoteMtime: 1700000000, RemoteSize: 20},
-	}}
-	f, store := newPathStatFiler(t, "stub_lazy_prefix_object", stub)
-
-	_, err := f.maybeLazyFetchFromRemote(context.Background(), "/buckets/mybucket/reports/2026.csv")
-	require.NoError(t, err)
-
-	parent := store.getEntry("/buckets/mybucket/reports")
-	require.NotNil(t, parent)
-	assert.True(t, parent.IsDirectory())
-	assert.Equal(t, []byte("true"), parent.Extended[s3_constants.SeaweedFSPrefixObject], "the remote object at the parent key must stay readable")
-	require.NotNil(t, parent.Remote)
-	assert.Equal(t, int64(10), parent.Remote.RemoteSize)
-}
-
-func TestMaybeLazyFetchFromRemote_StatsEachParentOnce(t *testing.T) {
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/a/b/c/file.bin": {RemoteMtime: 1700000000, RemoteSize: 1234},
-	}}
-	f, _ := newPathStatFiler(t, "stub_lazy_parent_stats", stub)
-
-	_, err := f.maybeLazyFetchFromRemote(context.Background(), "/buckets/mybucket/a/b/c/file.bin")
-	require.NoError(t, err)
-	assert.Equal(t, []string{"/a/b/c/file.bin", "/a", "/a/b", "/a/b/c"}, stub.statCalls,
-		"a parent still missing after its own stat must not be re-stat'ed by the next lookup")
-}
-
-func TestMaybeLazyListFromRemote_PersistsParentDirectories(t *testing.T) {
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{}}
-	stub.listDirFn = func(loc *remote_pb.RemoteStorageLocation, visitFn remote_storage.VisitFunc) error {
-		return visitFn("/", "file.bin", false, &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 1234})
-	}
-	f, store := newPathStatFiler(t, "stub_lazy_list_parents", stub)
-	f.RemoteStorage.mapDirectoryToRemoteStorage("/buckets/listmount", &remote_pb.RemoteStorageLocation{
-		Name:                   "mystore",
-		Bucket:                 "listmount",
-		Path:                   "/",
-		ListingCacheTtlSeconds: 300,
-	})
-
-	f.maybeLazyListFromRemote(context.Background(), util.FullPath("/buckets/listmount/a/b"))
-
-	assert.Equal(t, []string{"/a"}, stub.statCalls, "each missing parent is stat'ed once")
-	for _, dir := range []string{"/buckets/listmount", "/buckets/listmount/a", "/buckets/listmount/a/b"} {
-		dirEntry := store.getEntry(dir)
-		require.NotNil(t, dirEntry, "%s not persisted", dir)
-		assert.True(t, dirEntry.IsDirectory(), "%s should be a directory", dir)
-	}
-
-	child := store.getEntry("/buckets/listmount/a/b/file.bin")
-	require.NotNil(t, child)
-	child.Chunks = []*filer_pb.FileChunk{{FileId: "1,01637037d6", Size: 1234}}
-	child.Remote.LastLocalSyncTsNs = time.Now().UnixNano()
-	require.NoError(t, store.UpdateEntry(context.Background(), child))
-
-	evictable := f.ListEvictableRemoteEntries(context.Background(), []util.FullPath{"/buckets/listmount"}, 0)
-	require.Len(t, evictable, 1)
-	assert.Equal(t, util.FullPath("/buckets/listmount/a/b/file.bin"), evictable[0].FullPath)
-}
-
-func TestDeleteEntryMetaAndData_EmptyFolderUnderMountKeepsRemotePrefix(t *testing.T) {
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/dir/unread.bin": {RemoteMtime: 1700000000, RemoteSize: 1},
-	}}
-	f, store := newPathStatFiler(t, "stub_lazy_empty_folder", stub)
-	dirPath := util.FullPath("/buckets/mybucket/dir")
-	putDirEntry(store, string(dirPath))
-
-	require.NoError(t, f.DeleteEntryMetaAndData(context.Background(), dirPath, false, false, false, false, nil, 0))
-
-	assert.Empty(t, stub.removeCalls, "an empty local folder must not remove its remote prefix")
-	assert.Nil(t, store.getEntry(string(dirPath)))
-	entry, err := f.maybeLazyFetchFromRemote(context.Background(), "/buckets/mybucket/dir/unread.bin")
-	require.NoError(t, err)
-	assert.NotNil(t, entry, "a metadata-only delete must not block lazy reads under the folder")
-}
-
-func TestDeleteEmptyParentDirectories_UnderMountKeepsRemotePrefix(t *testing.T) {
-	stub := &pathStatRemoteClient{}
-	f, store := newPathStatFiler(t, "stub_lazy_expired_parents", stub)
-	f.DirBucketsPath = "/buckets"
-	putDirEntry(store, "/buckets/mybucket/a")
-	putDirEntry(store, "/buckets/mybucket/a/b")
-
-	f.DeleteEmptyParentDirectories(context.Background(), "/buckets/mybucket/a/b", "/buckets")
-
-	assert.Empty(t, stub.removeCalls, "an empty local folder must not remove its remote prefix")
-	assert.Nil(t, store.getEntry("/buckets/mybucket/a/b"))
-	assert.Nil(t, store.getEntry("/buckets/mybucket/a"))
-}
-
-func TestIsUnderRemoteMount(t *testing.T) {
-	rs := NewFilerRemoteStorage()
-	rs.mapDirectoryToRemoteStorage("/buckets/mirror", &remote_pb.RemoteStorageLocation{
-		Name:   "mystore",
-		Bucket: "mirror",
-		Path:   "/",
-	})
-	f := newTestFiler(t, newStubFilerStore(), rs)
-
-	for path, want := range map[util.FullPath]bool{
-		"/buckets/mirror":     true,
-		"/buckets/mirror/a/b": true,
-		"/buckets/mirror2/a":  false,
-		"/buckets/local/a":    false,
-	} {
-		assert.Equal(t, want, f.IsUnderRemoteMount(path), path)
-	}
-}
-
 func TestMaybeLazyFetchFromRemote_NotUnderMount(t *testing.T) {
 	rs := NewFilerRemoteStorage()
 	store := newStubFilerStore()

weed/filer/filer_remote_tombstone.go

@@ -407,7 +407,7 @@ func (f *Filer) onRemoteDeletionEvents(event *filer_pb.SubscribeMetadataResponse
 	if message == nil {
 		return
 	}
-	if message.OldEntry != nil && !IsMetadataOnlyDelete(message.OldEntry) {
+	if message.OldEntry != nil {
 		sourcePath := filer_pb.MetadataEventSourceFullPath(event)
 		if message.NewEntry == nil || sourcePath != filer_pb.MetadataEventTargetFullPath(event) {
 			if f.RemoteStorage != nil && f.remoteTombstones != nil {

weed/filer/filer_remote_tombstone_test.go

@@ -187,7 +187,6 @@ func TestMaybeLazyFetchFromRemote_SyncOffsetReleasesTombstone(t *testing.T) {
 		},
 	}
 	f, store := newMountedTestFiler(t, storageType, stub, 0)
-	putDirEntry(store, "/buckets/mybucket/dir")
 
 	filePath := util.FullPath("/buckets/mybucket/dir/a.txt")
 	deleteTsNs := time.Now().UnixNano()
@@ -223,7 +222,6 @@ func TestDeleteEntryMetaAndData_TombstonesPath(t *testing.T) {
 		},
 	}
 	f, store := newMountedTestFiler(t, storageType, stub, 0)
-	putDirEntry(store, "/buckets/mybucket/dir")
 
 	filePath := util.FullPath("/buckets/mybucket/dir/a.txt")
 	store.entries[string(filePath)] = &Entry{
@@ -259,35 +257,6 @@ func TestDeleteEntryMetaAndData_TombstonesPath(t *testing.T) {
 	assert.Equal(t, 1, stub.statCalls)
 }
 
-func TestOnMetadataChangeEvent_MetadataOnlyDeleteSkipsTombstone(t *testing.T) {
-	const storageType = "stub_tomb_metadata_only"
-	stub := &countingRemoteClient{
-		stubRemoteClient: stubRemoteClient{
-			statResult: &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 11},
-		},
-	}
-	f, store := newMountedTestFiler(t, storageType, stub, 0)
-	putDirEntry(store, "/buckets/mybucket/dir")
-
-	f.onMetadataChangeEvent(&filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		TsNs:      time.Now().UnixNano(),
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry: &filer_pb.Entry{
-				Name:        "dir",
-				IsDirectory: true,
-				Extended:    map[string][]byte{ExtKeepRemoteObjectKey: []byte("true")},
-			},
-		},
-	})
-
-	// nothing is owed to the remote, so objects under the folder stay readable
-	entry, err := f.maybeLazyFetchFromRemote(context.Background(), "/buckets/mybucket/dir/a.txt")
-	require.NoError(t, err)
-	require.NotNil(t, entry)
-	assert.Equal(t, 1, stub.statCalls)
-}
-
 func TestOnMetadataChangeEvent_PeerDeleteTombstones(t *testing.T) {
 	const storageType = "stub_tomb_peer"
 	stub := &countingRemoteClient{

weed/filer/meta_aggregator_replay_test.go

@@ -3,7 +3,6 @@ package filer
 import (
 	"context"
 	"errors"
-	"os"
 	"sync"
 	"testing"
 	"time"
@@ -12,7 +11,6 @@ import (
 
 	"github.com/seaweedfs/seaweedfs/weed/pb"
 	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
-	"github.com/seaweedfs/seaweedfs/weed/pb/remote_pb"
 	"github.com/seaweedfs/seaweedfs/weed/stats"
 	"github.com/seaweedfs/seaweedfs/weed/util"
 )
@@ -710,825 +708,3 @@ func TestPendingDeleteRecordKeepsItsTime(t *testing.T) {
 		t.Fatalf("MpDl = %v, %v, %v; want 100", ts, found, err)
 	}
 }
-
-// A replayed directory delete must remove the local subtree too: the origin
-// only emits the directory's own key, and children the peer holds that the
-// origin never listed would orphan under the missing parent.
-func TestReplayDirectoryDeleteSweepsLocalChildren(t *testing.T) {
-	store := newStubFilerStore()
-	f := newReplayTestFiler(store)
-	ctx := context.Background()
-
-	put := func(path string, isDir bool) {
-		e := &Entry{FullPath: util.FullPath(path)}
-		if isDir {
-			e.Attr.Mode = os.ModeDir
-		}
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatalf("insert %s: %v", path, err)
-		}
-	}
-	put("/d", true)
-	put("/d/a.txt", false)
-	put("/d/sub", true)
-	put("/d/sub/nested.txt", false)
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-
-	for _, path := range []string{"/d", "/d/a.txt", "/d/sub", "/d/sub/nested.txt"} {
-		if _, err := store.FindEntry(ctx, util.FullPath(path)); !errors.Is(err, filer_pb.ErrNotFound) {
-			t.Fatalf("expected %s gone after replayed directory delete, got %v", path, err)
-		}
-	}
-}
-
-// The sweep locks each child under locks Replay already holds, so it cannot
-// wait on a child a local write holds — a rename could hold the child while
-// waiting on one of the replayed paths. Contention fails the replay instead,
-// and a retry after the local write sweeps normally.
-func TestReplaySweepFailsOnChildLockContention(t *testing.T) {
-	store := newStubFilerStore()
-	f := newReplayTestFiler(store)
-	ctx := context.Background()
-
-	if err := store.InsertEntry(ctx, &Entry{FullPath: "/d", Attr: Attr{Mode: os.ModeDir}}); err != nil {
-		t.Fatal(err)
-	}
-	if err := store.InsertEntry(ctx, &Entry{FullPath: "/d/a.txt"}); err != nil {
-		t.Fatal(err)
-	}
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry: &filer_pb.Entry{Name: "d", IsDirectory: true},
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-
-	held := f.EntryLockTable.AcquireLock("test local write", "/d/a.txt", util.ExclusiveLock)
-	if err := f.Replay(event); err == nil {
-		f.EntryLockTable.ReleaseLock("/d/a.txt", held)
-		t.Fatal("replay succeeded while a child lock was held by a local write")
-	}
-	f.EntryLockTable.ReleaseLock("/d/a.txt", held)
-
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay after the local write: %v", err)
-	}
-	for _, path := range []string{"/d", "/d/a.txt"} {
-		if _, err := store.FindEntry(ctx, util.FullPath(path)); !errors.Is(err, filer_pb.ErrNotFound) {
-			t.Fatalf("expected %s gone after the retried delete, got %v", path, err)
-		}
-	}
-}
-
-func TestReplayFileDeleteKeepsSiblingEntries(t *testing.T) {
-	store := newStubFilerStore()
-	f := newReplayTestFiler(store)
-	ctx := context.Background()
-
-	dir := &Entry{FullPath: "/d", Attr: Attr{Mode: os.ModeDir}}
-	if err := store.InsertEntry(ctx, dir); err != nil {
-		t.Fatal(err)
-	}
-	for _, name := range []string{"gone.txt", "kept.txt"} {
-		if err := store.InsertEntry(ctx, &Entry{FullPath: util.NewFullPath("/d", name)}); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/d",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry: &filer_pb.Entry{Name: "gone.txt"},
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-	if _, err := store.FindEntry(ctx, "/d/gone.txt"); !errors.Is(err, filer_pb.ErrNotFound) {
-		t.Fatalf("expected deleted file gone, got %v", err)
-	}
-	if _, err := store.FindEntry(ctx, "/d/kept.txt"); err != nil {
-		t.Fatalf("expected sibling kept, got %v", err)
-	}
-}
-
-func TestReplayDirectoryDeleteKeepsNewerChildren(t *testing.T) {
-	store := newStubFilerStore()
-	f := newReplayTestFiler(store)
-	ctx := context.Background()
-
-	eventTs := time.Now().UnixNano()
-	put := func(path string, isDir bool, mtime time.Time) {
-		e := &Entry{FullPath: util.FullPath(path), Attr: Attr{Mtime: mtime}}
-		if isDir {
-			e.Attr.Mode = os.ModeDir
-		}
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatalf("insert %s: %v", path, err)
-		}
-	}
-	old := time.Unix(1600000000, 0)
-	newer := time.Unix(0, eventTs).Add(time.Second)
-	put("/d", true, old)
-	put("/d/old.txt", false, old)
-	put("/d/sub", true, old)
-	put("/d/sub/newer.txt", false, newer)
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: eventTs,
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-
-	if _, err := store.FindEntry(ctx, "/d/old.txt"); !errors.Is(err, filer_pb.ErrNotFound) {
-		t.Fatalf("older child should be swept, got %v", err)
-	}
-	for _, path := range []string{"/d", "/d/sub", "/d/sub/newer.txt"} {
-		if _, err := store.FindEntry(ctx, util.FullPath(path)); err != nil {
-			t.Fatalf("newer child and its ancestors should survive: %s: %v", path, err)
-		}
-	}
-}
-
-// A directory kept for newer descendants still records the delete: a stale
-// create replayed later for another child must be fenced by it.
-func TestReplayKeptDirectoryDeleteFencesStaleCreates(t *testing.T) {
-	store := newStubFilerStore()
-	f := newReplayTestFiler(store)
-	ctx := context.Background()
-
-	eventTs := time.Now().UnixNano()
-	old := time.Unix(1600000000, 0)
-	newer := time.Unix(0, eventTs).Add(time.Second)
-	put := func(path string, isDir bool, mtime time.Time) {
-		e := &Entry{FullPath: util.FullPath(path), Attr: Attr{Mtime: mtime}}
-		if isDir {
-			e.Attr.Mode = os.ModeDir
-		}
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatalf("insert %s: %v", path, err)
-		}
-	}
-	put("/d", true, old)
-	put("/d/newer.txt", false, newer)
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry: &filer_pb.Entry{Name: "d", IsDirectory: true},
-		},
-		TsNs: eventTs,
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-	if _, err := store.FindEntry(ctx, "/d"); err != nil {
-		t.Fatalf("newer child should keep the directory: %v", err)
-	}
-
-	stale := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/d",
-		EventNotification: &filer_pb.EventNotification{
-			NewEntry: &filer_pb.Entry{Name: "late.txt"},
-		},
-		TsNs: eventTs - int64(time.Minute),
-	}
-	if err := f.Replay(stale); err != nil {
-		t.Fatalf("replay stale create: %v", err)
-	}
-	if _, err := store.FindEntry(ctx, "/d/late.txt"); !errors.Is(err, filer_pb.ErrNotFound) {
-		t.Fatal("stale create resurrected a child under a directory the origin deleted")
-	}
-}
-
-// A swept hard link drops the shared inode record with the entry. When the
-// record is gone the sweep must free the chunks no sibling link can reach.
-func TestReplayDirectoryDeleteFreesOrphanedHardLinkChunks(t *testing.T) {
-	store := newStubFilerStore()
-	f := newReplayTestFiler(store)
-	f.FilerConf = NewFilerConf()
-	f.FileIdDeletionQueue = util.NewUnboundedQueue()
-	ctx := context.Background()
-
-	hardLinkId := NewHardLinkId()
-	inode := &Entry{
-		FullPath:        "/d/a.txt",
-		Attr:            Attr{Mtime: time.Now()},
-		HardLinkId:      hardLinkId,
-		HardLinkCounter: 1,
-		Chunks:          []*filer_pb.FileChunk{{FileId: "3,01637037d6"}},
-	}
-	blob, err := inode.EncodeAttributesAndChunks()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := store.KvPut(ctx, hardLinkId, blob); err != nil {
-		t.Fatal(err)
-	}
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	put(&Entry{FullPath: "/d", Attr: Attr{Mode: os.ModeDir}})
-	put(&Entry{FullPath: "/d/a.txt", Attr: Attr{Mtime: time.Now()}, HardLinkId: hardLinkId, HardLinkCounter: 1})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: true,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-
-	if _, err := store.KvGet(ctx, hardLinkId); !errors.Is(err, ErrKvNotFound) {
-		t.Fatalf("hard link record should be gone, got %v", err)
-	}
-	if got := f.pendingDeletionCount(); got != 1 {
-		t.Fatalf("pending deletions = %d, want the orphaned shared chunks queued", got)
-	}
-}
-
-// A sibling link outside the swept tree keeps the inode record, so the shared
-// chunks stay owned and must not be deleted.
-func TestReplayDirectoryDeleteKeepsSharedHardLinkChunks(t *testing.T) {
-	store := newStubFilerStore()
-	f := newReplayTestFiler(store)
-	f.FilerConf = NewFilerConf()
-	f.FileIdDeletionQueue = util.NewUnboundedQueue()
-	ctx := context.Background()
-
-	hardLinkId := NewHardLinkId()
-	inode := &Entry{
-		FullPath:        "/d/a.txt",
-		Attr:            Attr{Mtime: time.Now()},
-		HardLinkId:      hardLinkId,
-		HardLinkCounter: 2,
-		Chunks:          []*filer_pb.FileChunk{{FileId: "3,01637037d6"}},
-	}
-	blob, err := inode.EncodeAttributesAndChunks()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := store.KvPut(ctx, hardLinkId, blob); err != nil {
-		t.Fatal(err)
-	}
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	put(&Entry{FullPath: "/d", Attr: Attr{Mode: os.ModeDir}})
-	put(&Entry{FullPath: "/d/a.txt", Attr: Attr{Mtime: time.Now()}, HardLinkId: hardLinkId, HardLinkCounter: 2})
-	put(&Entry{FullPath: "/keep", Attr: Attr{Mode: os.ModeDir}})
-	put(&Entry{FullPath: "/keep/b.txt", Attr: Attr{Mtime: time.Now()}, HardLinkId: hardLinkId, HardLinkCounter: 2})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: true,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-
-	if _, err := store.KvGet(ctx, hardLinkId); err != nil {
-		t.Fatalf("surviving link must keep the inode record: %v", err)
-	}
-	if got := f.pendingDeletionCount(); got != 0 {
-		t.Fatalf("pending deletions = %d, want 0 while a sibling link owns the chunks", got)
-	}
-}
-
-// A replayed directory delete must mirror the origin's remote cleanup: entries
-// the lagging peer alone still holds lose their remote objects too, and record
-// tombstones so lazy remote fetches cannot resurrect them.
-func TestReplayDirectoryDeleteSweepsRemoteObjects(t *testing.T) {
-	const storageType = "stub_replay_remote"
-	stub := &stubRemoteClient{
-		statResult: &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "replaystore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "replaystore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-	f.onMetadataChangeEvent(event)
-
-	if _, err := store.FindEntry(ctx, "/buckets/mybucket/d/f.txt"); !errors.Is(err, filer_pb.ErrNotFound) {
-		t.Fatalf("swept child should be gone, got %v", err)
-	}
-	if len(stub.deleteCalls) != 1 || stub.deleteCalls[0].Path != "/d/f.txt" {
-		t.Fatalf("expected one remote delete of /d/f.txt, got %v", stub.deleteCalls)
-	}
-	if got := f.remoteTombstones.dirs["/buckets/mybucket/d"]; got != event.TsNs {
-		t.Fatalf("dir tombstone stamped %d, want the event ts %d", got, event.TsNs)
-	}
-}
-
-// A metadata-only delete keeps remote objects: the event's marker means the
-// remote tree stays authoritative, so the sweep must not touch it.
-func TestReplayDirectoryDeleteKeepRemoteObjects(t *testing.T) {
-	const storageType = "stub_replay_remote_keep"
-	stub := &stubRemoteClient{}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "keepstore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "keepstore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry: &filer_pb.Entry{
-				Name:        "d",
-				IsDirectory: true,
-				Extended:    map[string][]byte{ExtKeepRemoteObjectKey: []byte("true")},
-			},
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-	f.onMetadataChangeEvent(event)
-
-	if len(stub.deleteCalls) != 0 {
-		t.Fatalf("metadata-only delete must not touch remote objects, got %v", stub.deleteCalls)
-	}
-	if len(f.remoteTombstones.files)+len(f.remoteTombstones.dirs) != 0 {
-		t.Fatalf("metadata-only delete must not record tombstones, got %v", f.remoteTombstones.dirs)
-	}
-}
-
-// A delayed sweep must not erase an object another writer replaced since the
-// entry's stamp was recorded — the same guard the write-back daemon applies.
-func TestReplayDirectoryDeleteKeepsReplacedRemoteObject(t *testing.T) {
-	const storageType = "stub_replay_remote_replaced"
-	stub := &stubRemoteClient{
-		statResult: &filer_pb.RemoteEntry{RemoteMtime: 1700000099, RemoteSize: 10},
-	}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "replacestore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "replacestore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-
-	if len(stub.deleteCalls) != 0 {
-		t.Fatalf("a replaced remote object must be kept, got %v", stub.deleteCalls)
-	}
-}
-
-// A backend offering a conditional delete must serve the sweep: the check and
-// the delete bind into one preconditioned request, so a replacement landing
-// between them cannot be deleted.
-func TestReplayDirectoryDeleteUsesConditionalRemoteDelete(t *testing.T) {
-	const storageType = "stub_replay_remote_cond"
-	stub := &stubConditionalRemoteClient{conditionalResult: true}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "condstore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "condstore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-
-	if len(stub.conditionalCalls) != 1 || stub.conditionalCalls[0].Path != "/d/f.txt" {
-		t.Fatalf("expected one conditional delete of /d/f.txt, got %v", stub.conditionalCalls)
-	}
-	if len(stub.deleteCalls) != 0 {
-		t.Fatalf("an unconditional delete must not run beside the conditional one, got %v", stub.deleteCalls)
-	}
-}
-
-// A conditional delete reporting the object changed keeps the remote object
-// but still sweeps the local metadata: the entry the peer held is gone either
-// way.
-func TestReplayDirectoryDeleteKeepsChangedRemoteObject(t *testing.T) {
-	const storageType = "stub_replay_remote_cond_keep"
-	stub := &stubConditionalRemoteClient{conditionalResult: false}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "condkeepstore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "condkeepstore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-	if _, err := store.FindEntry(ctx, "/buckets/mybucket/d/f.txt"); !errors.Is(err, filer_pb.ErrNotFound) {
-		t.Fatalf("swept child should be gone, got %v", err)
-	}
-	if len(stub.deleteCalls) != 0 {
-		t.Fatalf("a changed remote object must be kept, got %v", stub.deleteCalls)
-	}
-}
-
-// A failed remote delete aborts the sweep so the replication stream retries
-// instead of orphaning the object no other event will ever name.
-func TestReplayDirectoryDeleteFailsOnRemoteDeleteError(t *testing.T) {
-	const storageType = "stub_replay_remote_err"
-	stub := &stubRemoteClient{
-		statResult: &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-		deleteErr:  errors.New("remote unavailable"),
-	}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "errstore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "errstore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err == nil {
-		t.Fatal("a failed remote delete must fail the replay for retry")
-	}
-	if _, err := store.FindEntry(ctx, "/buckets/mybucket/d/f.txt"); err != nil {
-		t.Fatalf("the child must survive for the retry, got %v", err)
-	}
-}
-
-// A swept entry deleted while its rename copy was still pending reads its
-// content from the source the marker names: removing the entry must release
-// that object too, or it is orphaned — the destination key may hold nothing.
-func TestReplayDirectoryDeleteReleasesPendingRenameSource(t *testing.T) {
-	const storageType = "stub_replay_remote_rename_src"
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/d/src.txt": {RemoteMtime: 1700000000, RemoteSize: 10},
-	}}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "srcstore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "srcstore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/dst.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-		Extended: map[string][]byte{ExtRemoteRenameSourceKey: []byte("/buckets/mybucket/d/src.txt")},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-	if _, err := store.FindEntry(ctx, "/buckets/mybucket/d/dst.txt"); !errors.Is(err, filer_pb.ErrNotFound) {
-		t.Fatalf("swept child should be gone, got %v", err)
-	}
-	if len(stub.deleteCalls) != 1 || stub.deleteCalls[0].Path != "/d/src.txt" {
-		t.Fatalf("expected one remote delete of the pending rename's source /d/src.txt, got %v", stub.deleteCalls)
-	}
-}
-
-// The source survives while a remote-only entry holds its path: that entry's
-// content is the same object. The swept destination entry's own object still
-// goes while its stamp describes it.
-func TestReplayDirectoryDeleteKeepsPendingRenameSourceOwnedByRemoteOnly(t *testing.T) {
-	const storageType = "stub_replay_remote_rename_owned"
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/d/dst.txt":     {RemoteMtime: 1700000000, RemoteSize: 10},
-		"/other/src.txt": {RemoteMtime: 1700000000, RemoteSize: 10},
-	}}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "ownstore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "ownstore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	put := func(e *Entry) {
-		if err := store.InsertEntry(ctx, e); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for _, dir := range []string{"/buckets", "/buckets/mybucket", "/buckets/mybucket/d", "/buckets/mybucket/other"} {
-		put(&Entry{FullPath: util.FullPath(dir), Attr: Attr{Mode: os.ModeDir}})
-	}
-	put(&Entry{
-		FullPath: "/buckets/mybucket/d/dst.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-		Extended: map[string][]byte{ExtRemoteRenameSourceKey: []byte("/buckets/mybucket/other/src.txt")},
-	})
-	put(&Entry{
-		FullPath: "/buckets/mybucket/other/src.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	})
-
-	event := &filer_pb.SubscribeMetadataResponse{
-		Directory: "/buckets/mybucket",
-		EventNotification: &filer_pb.EventNotification{
-			OldEntry:     &filer_pb.Entry{Name: "d", IsDirectory: true},
-			DeleteChunks: false,
-		},
-		TsNs: time.Now().UnixNano(),
-	}
-	if err := f.Replay(event); err != nil {
-		t.Fatalf("replay: %v", err)
-	}
-	if len(stub.deleteCalls) != 1 || stub.deleteCalls[0].Path != "/d/dst.txt" {
-		t.Fatalf("expected one remote delete of /d/dst.txt, got %v", stub.deleteCalls)
-	}
-	if _, err := store.FindEntry(ctx, "/buckets/mybucket/other/src.txt"); err != nil {
-		t.Fatalf("the remote-only source holder must survive, got %v", err)
-	}
-}
-
-// A remote-only entry that took the path since the listing reads the object
-// at the key as its only copy — the sweep must keep both.
-func TestReplaySweepKeepsRemoteOnlyOwnerOfPath(t *testing.T) {
-	const storageType = "stub_replay_remote_owner"
-	stub := &pathStatRemoteClient{objects: map[string]*filer_pb.RemoteEntry{
-		"/d/f.txt": {RemoteMtime: 1700000099, RemoteSize: 20},
-	}}
-	defer registerStubMaker(t, storageType, stub)()
-
-	conf := &remote_pb.RemoteConf{Name: "ownerstore", Type: storageType}
-	rs := NewFilerRemoteStorage()
-	rs.storageNameToConf[conf.Name] = conf
-	rs.mapDirectoryToRemoteStorage("/buckets/mybucket", &remote_pb.RemoteStorageLocation{
-		Name:   "ownerstore",
-		Bucket: "mybucket",
-		Path:   "/",
-	})
-
-	store := newStubFilerStore()
-	f := newTestFiler(t, store, rs)
-	ctx := context.Background()
-
-	owner := &Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000099, RemoteSize: 20},
-	}
-	if err := store.InsertEntry(ctx, owner); err != nil {
-		t.Fatal(err)
-	}
-
-	stale := &Entry{
-		FullPath: "/buckets/mybucket/d/f.txt",
-		Attr:     Attr{Mtime: time.Now(), Mode: 0644},
-		Remote:   &filer_pb.RemoteEntry{RemoteMtime: 1700000000, RemoteSize: 10},
-	}
-	sweep := &folderSweep{chunksByPath: make(map[util.FullPath][]*filer_pb.FileChunk)}
-	message := &filer_pb.EventNotification{OldEntry: &filer_pb.Entry{Name: "d", IsDirectory: true}}
-	kept, err := f.deleteSweptChild(ctx, stale, message, 0, sweep, false, true)
-	if err != nil {
-		t.Fatalf("deleteSweptChild: %v", err)
-	}
-	if !kept {
-		t.Fatal("a remote-only entry that took the path must be kept")
-	}
-	if _, err := store.FindEntry(ctx, "/buckets/mybucket/d/f.txt"); err != nil {
-		t.Fatalf("the remote-only owner must survive, got %v", err)
-	}
-	if len(stub.deleteCalls) != 0 {
-		t.Fatalf("the owned remote object must be kept, got %v", stub.deleteCalls)
-	}
-}

weed/filer/meta_replay.go

@@ -2,15 +2,12 @@ package filer
 
 import (
 	"context"
-	"errors"
-	"fmt"
 	"slices"
 	"strings"
 
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
 	"github.com/seaweedfs/seaweedfs/weed/util"
-	"google.golang.org/protobuf/proto"
 )
 
 // Replay applies the delete and the insert as separate, non-transactional
@@ -81,26 +78,10 @@ func (f *Filer) Replay(resp *filer_pb.SubscribeMetadataResponse) error {
 			return err
 		}
 		if !newer {
-			// A directory delete on the origin removed the whole subtree, but
-			// only the directory's own key replicates. Sweep local children the
-			// origin never listed, or they orphan under a missing parent.
-			keepDir := false
-			if message.OldEntry.IsDirectory {
-				var err error
-				keepDir, err = f.deleteReplayedFolderChildren(ctx, oldPath, message, resp.TsNs)
-				if err != nil {
-					return err
-				}
+			glog.V(4).Infof("deleting %v", oldPath)
+			if err := f.Store.DeleteEntry(ctx, oldPath); err != nil {
+				return err
 			}
-			if !keepDir {
-				glog.V(4).Infof("deleting %v", oldPath)
-				if err := f.Store.DeleteEntry(ctx, oldPath); err != nil {
-					return err
-				}
-			}
-			// The origin deleted the directory even when a newer descendant
-			// keeps its entry here — recording the delete fences stale child
-			// creates that would otherwise resurrect under it.
 			f.notePathChange(oldPath, resp.TsNs, true)
 		}
 	}
@@ -123,161 +104,6 @@ func (f *Filer) Replay(resp *filer_pb.SubscribeMetadataResponse) error {
 	return nil
 }
 
-// deleteReplayedFolderChildren removes local entries under dir, and queues
-// the chunks of removed files for deletion. Children this filer committed
-// after the event stay — a newer local write wins over a delayed delete —
-// along with the directories that hold them.
-func (f *Filer) deleteReplayedFolderChildren(ctx context.Context, dir util.FullPath, message *filer_pb.EventNotification, tsNs int64) (bool, error) {
-	sweep := &folderSweep{chunksByPath: make(map[util.FullPath][]*filer_pb.FileChunk)}
-	kept, err := f.sweepReplayedFolder(ctx, dir, message, tsNs, sweep)
-	// Flush what was collected even on error: the entries already deleted
-	// cannot be listed again on retry, so their chunks must be queued now.
-	sweep.flush(ctx, f)
-	if err != nil {
-		return false, err
-	}
-	return kept, nil
-}
-
-// folderSweep accumulates the chunks of removed children for deletion. It
-// flushes in batches so a large subtree cannot hold every chunk reference in
-// memory at once, and so chunk queueing overlaps the listing work.
-type folderSweep struct {
-	chunksByPath map[util.FullPath][]*filer_pb.FileChunk
-	count        int
-}
-
-const folderSweepChunkBatch = 4096
-
-func (s *folderSweep) add(path util.FullPath, chunks []*filer_pb.FileChunk) {
-	s.chunksByPath[path] = append(s.chunksByPath[path], chunks...)
-	s.count += len(chunks)
-}
-
-func (s *folderSweep) flush(ctx context.Context, f *Filer) {
-	for path, chunks := range s.chunksByPath {
-		f.DeleteChunks(ctx, path, chunks)
-	}
-	s.chunksByPath = make(map[util.FullPath][]*filer_pb.FileChunk)
-	s.count = 0
-}
-
-// sweepReplayedFolder deletes every child of dir whose local commit is not
-// newer than the event, working subtree-first so nested entries go too.
-// It reports whether a newer descendant keeps dir alive — the caller then
-// keeps the dir entry itself.
-func (f *Filer) sweepReplayedFolder(ctx context.Context, dir util.FullPath, message *filer_pb.EventNotification, tsNs int64, sweep *folderSweep) (kept bool, err error) {
-	keepRemote := IsMetadataOnlyDelete(message.OldEntry)
-	deleteRemote := !keepRemote && !message.GetIsFromOtherCluster()
-	lastFileName := ""
-	for {
-		entries, _, lerr := f.ListDirectoryEntries(ctx, dir, lastFileName, false, PaginationSize, "", "", "")
-		if lerr != nil {
-			return false, fmt.Errorf("list folder %s: %w", dir, lerr)
-		}
-		for _, sub := range entries {
-			lastFileName = sub.Name()
-			childKept := false
-			if tsNs > 0 {
-				localTsNs, tsErr := f.localCommitTsNs(ctx, sub.FullPath)
-				if tsErr != nil {
-					return false, tsErr
-				}
-				childKept = localTsNs > tsNs
-			}
-			if !childKept && sub.IsDirectory() {
-				childKept, err = f.sweepReplayedFolder(ctx, sub.FullPath, message, tsNs, sweep)
-				if err != nil {
-					return false, err
-				}
-			}
-			if childKept {
-				kept = true
-				continue
-			}
-			childKept, err = f.deleteSweptChild(ctx, sub, message, tsNs, sweep, keepRemote, deleteRemote)
-			if err != nil {
-				return false, err
-			}
-			if childKept {
-				kept = true
-			}
-		}
-		if len(entries) < PaginationSize {
-			break
-		}
-	}
-	return kept, nil
-}
-
-// deleteSweptChild removes sub under its entry lock and reports whether the
-// child was kept instead. The listing and the first commit-time check run
-// without the lock, so a local write can land in between: the check runs
-// again under the lock before anything is removed. A remote-only entry that
-// has taken the path since — one the commit record may not cover, such as a
-// lazy fetch materialized from the remote — reads the object at the key as
-// its only copy: the write-back daemon's processDeleteEvent keeps such an
-// object, and the sweep does too.
-func (f *Filer) deleteSweptChild(ctx context.Context, sub *Entry, message *filer_pb.EventNotification, tsNs int64, sweep *folderSweep, keepRemote, deleteRemote bool) (bool, error) {
-	var childLock *util.ActiveLock
-	if lt := f.EntryLockTable; lt != nil {
-		// The sweep already holds locks on the event's paths; waiting for a
-		// descendant here can deadlock against a local rename that holds the
-		// child and waits for one of them. ErrLockContended is transient, so
-		// the replication retry picks the event up once the write settles.
-		var acquired bool
-		childLock, acquired = lt.TryAcquireLock("MetaReplay", sub.FullPath, util.ExclusiveLock)
-		if !acquired {
-			return false, fmt.Errorf("sweep %s: %w", sub.FullPath, util.ErrLockContended)
-		}
-		defer lt.ReleaseLock(sub.FullPath, childLock)
-	}
-	if tsNs > 0 {
-		localTsNs, tsErr := f.localCommitTsNs(ctx, sub.FullPath)
-		if tsErr != nil {
-			return false, tsErr
-		}
-		if localTsNs > tsNs {
-			return true, nil
-		}
-	}
-	current, findErr := f.Store.FindEntry(ctx, sub.FullPath)
-	if findErr != nil && !errors.Is(findErr, filer_pb.ErrNotFound) {
-		return false, fmt.Errorf("find %s: %w", sub.FullPath, findErr)
-	}
-	if current != nil && len(current.Content) == 0 && current.IsInRemoteOnly() &&
-		!proto.Equal(current.ToProtoEntry(), sub.ToProtoEntry()) {
-		glog.V(0).InfofCtx(ctx, "keep %s: a remote-only entry has taken the path since the listing", sub.FullPath)
-		return true, nil
-	}
-	if !keepRemote && f.RemoteStorage != nil && f.remoteTombstones != nil {
-		if _, remoteLoc := f.RemoteStorage.FindMountDirectory(sub.FullPath); remoteLoc != nil {
-			f.remoteTombstones.addFromEvent(string(sub.FullPath), sub.IsDirectory(), tsNs)
-		}
-	}
-	if deleteRemote && !sub.IsDirectory() {
-		if remoteErr := f.deleteSweptEntryRemote(ctx, sub); remoteErr != nil {
-			return false, fmt.Errorf("remote delete %s: %w", sub.FullPath, remoteErr)
-		}
-	}
-	if derr := f.Store.DeleteEntry(ctx, sub.FullPath); derr != nil {
-		return false, fmt.Errorf("delete %s: %w", sub.FullPath, derr)
-	}
-	f.notePathChange(sub.FullPath, tsNs, true)
-	// chunks of a hard-linked child belong to the shared inode record; free
-	// them only once that record is gone. A directory entry can still carry
-	// chunks of its own — an S3 child promotes an existing file to a
-	// directory without dropping them — so the entry's chunks are keyed to
-	// its own path whatever it is.
-	if message.DeleteChunks && len(sub.GetChunks()) > 0 && (len(sub.HardLinkId) == 0 || f.hardLinkIsOrphaned(ctx, sub.HardLinkId)) {
-		sweep.add(sub.FullPath, sub.GetChunks())
-		if sweep.count >= folderSweepChunkBatch {
-			sweep.flush(ctx, f)
-		}
-	}
-	return false, nil
-}
-
 // replayBlockedByLocal reports whether the local store already holds a
 // version of path committed after the event's timestamp. Lookup failures are
 // propagated: a replayed change must not be applied on the guess that the

weed/filer/mongodb/mongodb_store_kv.go

@@ -46,7 +46,7 @@ func (store *MongodbStore) KvGet(ctx context.Context, key []byte) (value []byte,
 	err = store.connect.Database(store.database).Collection(store.collectionName).FindOne(ctx, where).Decode(&data)
 	if err != mongo.ErrNoDocuments && err != nil {
 		glog.ErrorfCtx(ctx, "kv get: %v", err)
-		return nil, err
+		return nil, filer.ErrKvNotFound
 	}
 
 	if len(data.Meta) == 0 {

weed/filer/mysql/mysql_sql_gen.go

@@ -64,12 +64,12 @@ func (gen *SqlGenMysql) nameExpr() string {
 
 func (gen *SqlGenMysql) GetSqlListExclusive(tableName string) string {
 	name := gen.nameExpr()
-	return fmt.Sprintf("SELECT `name`, `meta` FROM `%s` WHERE `dirhash` = ? AND %s > ? AND `directory` = ? AND %s LIKE ? ESCAPE '!' ORDER BY %s ASC LIMIT ?", tableName, name, name, name)
+	return fmt.Sprintf("SELECT `name`, `meta` FROM `%s` WHERE `dirhash` = ? AND %s > ? AND `directory` = ? AND %s LIKE ? ORDER BY %s ASC LIMIT ?", tableName, name, name, name)
 }
 
 func (gen *SqlGenMysql) GetSqlListInclusive(tableName string) string {
 	name := gen.nameExpr()
-	return fmt.Sprintf("SELECT `name`, `meta` FROM `%s` WHERE `dirhash` = ? AND %s >= ? AND `directory` = ? AND %s LIKE ? ESCAPE '!' ORDER BY %s ASC LIMIT ?", tableName, name, name, name)
+	return fmt.Sprintf("SELECT `name`, `meta` FROM `%s` WHERE `dirhash` = ? AND %s >= ? AND `directory` = ? AND %s LIKE ? ORDER BY %s ASC LIMIT ?", tableName, name, name, name)
 }
 
 func (gen *SqlGenMysql) GetSqlCreateTable(tableName string) string {

weed/filer/mysql/mysql_sql_gen_test.go

@@ -65,15 +65,6 @@ func TestListSqlBinaryOrderingOnNonBinaryColumn(t *testing.T) {
 	}
 }
 
-func TestListSqlEscapesLikeWildcards(t *testing.T) {
-	gen := &SqlGenMysql{}
-	for _, got := range []string{gen.GetSqlListExclusive("filemeta"), gen.GetSqlListInclusive("filemeta")} {
-		if !strings.Contains(got, "LIKE ? ESCAPE '!'") {
-			t.Fatalf("list query must declare the escape char matching LikePattern, got: %s", got)
-		}
-	}
-}
-
 func TestIsBinaryCollation(t *testing.T) {
 	binary := []string{"", "binary", "utf8mb4_bin", "utf8mb3_bin", "latin1_bin", "UTF8MB4_BIN"}
 	for _, c := range binary {

weed/filer/postgres/postgres_sql_gen.go

@@ -77,12 +77,12 @@ func (gen *SqlGenPostgres) nameExpr() string {
 
 func (gen *SqlGenPostgres) GetSqlListExclusive(tableName string) string {
 	name := gen.nameExpr()
-	return fmt.Sprintf(`SELECT NAME, meta FROM "%s" WHERE dirhash=$1 AND %s>$2 AND directory=$3 AND %s like $4 ESCAPE '!' ORDER BY %s ASC LIMIT $5`, tableName, name, name, name)
+	return fmt.Sprintf(`SELECT NAME, meta FROM "%s" WHERE dirhash=$1 AND %s>$2 AND directory=$3 AND %s like $4 ORDER BY %s ASC LIMIT $5`, tableName, name, name, name)
 }
 
 func (gen *SqlGenPostgres) GetSqlListInclusive(tableName string) string {
 	name := gen.nameExpr()
-	return fmt.Sprintf(`SELECT NAME, meta FROM "%s" WHERE dirhash=$1 AND %s>=$2 AND directory=$3 AND %s like $4 ESCAPE '!' ORDER BY %s ASC LIMIT $5`, tableName, name, name, name)
+	return fmt.Sprintf(`SELECT NAME, meta FROM "%s" WHERE dirhash=$1 AND %s>=$2 AND directory=$3 AND %s like $4 ORDER BY %s ASC LIMIT $5`, tableName, name, name, name)
 }
 
 func (gen *SqlGenPostgres) GetSqlCreateTable(tableName string) string {

weed/filer/postgres/postgres_sql_gen_test.go

@@ -62,15 +62,6 @@ func TestListSqlBinaryOrderingOnNonBinaryColumn(t *testing.T) {
 	}
 }
 
-func TestListSqlEscapesLikeWildcards(t *testing.T) {
-	gen := &SqlGenPostgres{}
-	for _, got := range []string{gen.GetSqlListExclusive("filemeta"), gen.GetSqlListInclusive("filemeta")} {
-		if !strings.Contains(got, "like $4 ESCAPE '!'") {
-			t.Fatalf("list query must declare the escape char matching LikePattern, got: %s", got)
-		}
-	}
-}
-
 func TestIsByteOrderedCollation(t *testing.T) {
 	byteOrdered := []string{"C", "POSIX", "c", "C.UTF-8", "C.utf8"}
 	for _, c := range byteOrdered {

weed/filer/reader_cache_memory_test.go

@@ -3,7 +3,6 @@ package filer
 import (
 	"context"
 	"fmt"
-	"strconv"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -203,12 +202,6 @@ func TestReaderCacheFailedPrefetchReleasesBudget(t *testing.T) {
 }
 
 func TestReaderCacheUnboundedWithoutBudget(t *testing.T) {
-	if strconv.IntSize == 32 {
-		// Proving the cache has no implicit memory budget needs more than 64
-		// in-flight 4 MiB buffers (>256 MiB) at once; the weed/filer test binary
-		// already runs near the 4 GiB address-space limit on 32-bit.
-		t.Skip("requires >256MiB of in-flight buffers; skipped on 32-bit")
-	}
 	const readers = 96 // more than 256MiB / 4MiB = 64 buffers
 	started := make(chan struct{}, readers)
 	gate := make(chan struct{})

weed/filer/sqlite/sqlite_like_escape_test.go

@@ -1,75 +0,0 @@
-//go:build sqlite
-
-package sqlite
-
-import (
-	"context"
-	"database/sql"
-	"testing"
-
-	"github.com/seaweedfs/seaweedfs/weed/filer"
-	"github.com/seaweedfs/seaweedfs/weed/filer/mysql"
-	"github.com/seaweedfs/seaweedfs/weed/util"
-	_ "modernc.org/sqlite"
-)
-
-func TestListDirectoryPrefixedEntriesEscapesLikeWildcards(t *testing.T) {
-	db, err := sql.Open("sqlite", "file::memory:?cache=shared")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer db.Close()
-
-	_, err = db.Exec(`CREATE TABLE filemeta (dirhash BIGINT, name VARCHAR(1000), directory TEXT, meta BLOB, PRIMARY KEY (dirhash, name))`)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	store := &SqliteStore{}
-	store.SqlGenerator = &mysql.SqlGenMysql{}
-	store.DB = db
-
-	ctx := context.Background()
-	names := []string{
-		"call_03_KNlHPt6grkZMe4WZVwQi9710", // target: literal _ prefix
-		"callX03XKNlZZZ",                   // would match if _ were a wildcard
-		"call_99_other",
-		"100%_done", // % and _ in the name
-		"100aXdone", // would match prefix "100%_" if unescaped
-		"bang!file",
-	}
-	for _, n := range names {
-		entry := &filer.Entry{FullPath: util.FullPath("/dir/" + n)}
-		if err := store.InsertEntry(ctx, entry); err != nil {
-			t.Fatalf("insert %s: %v", n, err)
-		}
-	}
-
-	list := func(prefix string) []string {
-		var got []string
-		_, err := store.ListDirectoryPrefixedEntries(ctx, "/dir", "", false, 100, prefix, func(e *filer.Entry) (bool, error) {
-			got = append(got, e.Name())
-			return true, nil
-		})
-		if err != nil {
-			t.Fatalf("list %q: %v", prefix, err)
-		}
-		return got
-	}
-
-	if got := list("call_03_"); len(got) != 1 || got[0] != "call_03_KNlHPt6grkZMe4WZVwQi9710" {
-		t.Fatalf("prefix with _: got %v", got)
-	}
-	if got := list("call_"); len(got) != 2 {
-		t.Fatalf("prefix call_: got %v", got)
-	}
-	if got := list("100%_"); len(got) != 1 || got[0] != "100%_done" {
-		t.Fatalf("prefix with %%: got %v", got)
-	}
-	if got := list("bang!"); len(got) != 1 || got[0] != "bang!file" {
-		t.Fatalf("prefix with !: got %v", got)
-	}
-	if got := list(""); len(got) != len(names) {
-		t.Fatalf("empty prefix: got %v", got)
-	}
-}

weed/filer/ydb/ydb_queries.go

@@ -55,7 +55,7 @@ const (
 		
 		SELECT name, meta
 		FROM ` + asql.DEFAULT_TABLE + `
-		WHERE dir_hash = $dir_hash AND directory = $directory and name > $start_name and name LIKE $prefix ESCAPE '!'
+		WHERE dir_hash = $dir_hash AND directory = $directory and name > $start_name and name LIKE $prefix
 		ORDER BY name ASC LIMIT $limit;`
 
 	listInclusiveDirectoryQuery = `
@@ -68,6 +68,6 @@ const (
 		
 		SELECT name, meta
 		FROM ` + asql.DEFAULT_TABLE + `
-		WHERE dir_hash = $dir_hash AND directory = $directory and name >= $start_name and name LIKE $prefix ESCAPE '!'
+		WHERE dir_hash = $dir_hash AND directory = $directory and name >= $start_name and name LIKE $prefix
 		ORDER BY name ASC LIMIT $limit;`
 )

weed/filer/ydb/ydb_store.go

@@ -288,7 +288,7 @@ func (store *YdbStore) ListDirectoryPrefixedEntries(ctx context.Context, dirPath
 			table.ValueParam("$dir_hash", types.Int64Value(util.HashStringToLong(*shortDir))),
 			table.ValueParam("$directory", types.UTF8Value(*shortDir)),
 			table.ValueParam("$start_name", types.UTF8Value(startFileName)),
-			table.ValueParam("$prefix", types.UTF8Value(abstract_sql.LikePattern(prefix))),
+			table.ValueParam("$prefix", types.UTF8Value(prefix+"%")),
 			table.ValueParam("$limit", types.Uint64Value(uint64(chunkLimit))),
 		)
 

weed/filer/zip_extract.go

@@ -1,123 +0,0 @@
-package filer
-
-import (
-	"archive/zip"
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-const (
-	// ZipExtractMaxMembers bounds how many members one archive write fans out to.
-	ZipExtractMaxMembers = 100000
-	// ZipExtractMaxBytes bounds the total uncompressed bytes one archive may declare.
-	ZipExtractMaxBytes = int64(1) << 40 // 1 TiB
-
-	// ZipExtractMaxArchiveBytes bounds the compressed bytes one archive may
-	// spool to local disk when the caller passes no tighter limit. It matches
-	// the TUS default max upload size.
-	ZipExtractMaxArchiveBytes = int64(5) << 30 // 5 GiB
-
-)
-
-// zipSpoolMemoryLimit caps how much of one archive is buffered in memory
-// before the spool falls through to a temp file. It is a var rather than a
-// const so tests can shrink it: exercising the temp-file path with the real
-// 32 MiB threshold allocates hundreds of MiB, which tips the 32-bit test
-// binary over its 4 GiB address space.
-var zipSpoolMemoryLimit int64 = 32 << 20 // 32 MiB
-
-// ErrZipTooLarge marks a spool failure caused by the archive exceeding the
-// caller's size limit, so handlers can answer 4xx instead of 5xx.
-var ErrZipTooLarge = errors.New("zip archive too large")
-
-// SpoolZipReader buffers r into a seekable source for zip.NewReader: memory for
-// small archives, a temp file otherwise. At most maxArchiveBytes are buffered;
-// a non-positive limit falls back to ZipExtractMaxArchiveBytes. The returned
-// cleanup releases the spool.
-func SpoolZipReader(r io.Reader, maxArchiveBytes int64) (ra io.ReaderAt, n int64, cleanup func(), err error) {
-	nop := func() {}
-	if maxArchiveBytes <= 0 {
-		maxArchiveBytes = ZipExtractMaxArchiveBytes
-	}
-	head, err := io.ReadAll(io.LimitReader(r, zipSpoolMemoryLimit+1))
-	if err != nil {
-		return nil, 0, nop, err
-	}
-	if int64(len(head)) > maxArchiveBytes {
-		return nil, 0, nop, fmt.Errorf("%w: exceeds %d bytes", ErrZipTooLarge, maxArchiveBytes)
-	}
-	if int64(len(head)) <= zipSpoolMemoryLimit {
-		return bytes.NewReader(head), int64(len(head)), nop, nil
-	}
-	f, err := os.CreateTemp("", "seaweedfs-extract-*.zip")
-	if err != nil {
-		return nil, 0, nop, err
-	}
-	cleanup = func() {
-		name := f.Name()
-		f.Close()
-		os.Remove(name)
-	}
-	if _, err = f.Write(head); err == nil {
-		var rest int64
-		// One byte past the limit so an oversized archive errors out instead
-		// of being silently truncated.
-		if rest, err = io.Copy(f, io.LimitReader(r, maxArchiveBytes+1-int64(len(head)))); err == nil {
-			n = int64(len(head)) + rest
-		}
-	}
-	if err == nil && n > maxArchiveBytes {
-		err = fmt.Errorf("%w: exceeds %d bytes", ErrZipTooLarge, maxArchiveBytes)
-	}
-	if err != nil {
-		cleanup()
-		return nil, 0, nop, err
-	}
-	return f, n, cleanup, nil
-}
-
-// CheckZipLimits enforces the member-count and total-size caps on an opened archive.
-func CheckZipLimits(zr *zip.Reader) error {
-	if len(zr.File) > ZipExtractMaxMembers {
-		return fmt.Errorf("zip archive has %d members, limit %d", len(zr.File), ZipExtractMaxMembers)
-	}
-	var total uint64
-	for _, f := range zr.File {
-		if f.UncompressedSize64 > uint64(ZipExtractMaxBytes)-total {
-			return fmt.Errorf("zip archive uncompressed size exceeds %d bytes", ZipExtractMaxBytes)
-		}
-		total += f.UncompressedSize64
-	}
-	return nil
-}
-
-// SanitizeZipMemberName converts a zip member name into a relative filer path.
-// ok=false means the member must be skipped: absolute or escaping paths,
-// non-regular files such as symlinks and devices.
-func SanitizeZipMemberName(f *zip.File) (name string, ok bool) {
-	mode := f.FileInfo().Mode()
-	if mode&(os.ModeSymlink|os.ModeDevice|os.ModeNamedPipe|os.ModeSocket) != 0 {
-		return "", false
-	}
-	name = strings.TrimSuffix(strings.ReplaceAll(f.Name, "\\", "/"), "/")
-	if name == "" || strings.HasPrefix(name, "/") {
-		return "", false
-	}
-	for _, seg := range strings.Split(name, "/") {
-		if seg == "" || seg == "." || seg == ".." || strings.ContainsRune(seg, '\x00') {
-			return "", false
-		}
-	}
-	// filepath.IsLocal is the check static analysis recognizes: no element may
-	// be "." or "..", the path may not be absolute or empty, and on Windows it
-	// may not be a reserved name.
-	if !filepath.IsLocal(name) {
-		return "", false
-	}
-	return name, true
-}

weed/filer/zip_extract_test.go

@@ -1,166 +0,0 @@
-package filer
-
-import (
-	"archive/zip"
-	"bytes"
-	"io"
-	"math"
-	"os"
-	"strings"
-	"testing"
-	"time"
-)
-
-func zipFile(t *testing.T, name string, mode os.FileMode) *zip.File {
-	t.Helper()
-	h := &zip.FileHeader{Name: name, Method: zip.Store, Modified: time.Unix(1700000000, 0)}
-	h.SetMode(mode)
-	return &zip.File{FileHeader: *h}
-}
-
-func TestSanitizeZipMemberName(t *testing.T) {
-	tests := []struct {
-		name string
-		mode os.FileMode
-		want string
-		ok   bool
-	}{
-		{"a.png", 0644, "a.png", true},
-		{"dir/b.txt", 0644, "dir/b.txt", true},
-		{"dir\\b.txt", 0644, "dir/b.txt", true},
-		{"dir/", os.ModeDir | 0755, "dir", true},
-		{"../escape.txt", 0644, "", false},
-		{"a/../b.txt", 0644, "", false},
-		{"./dot.txt", 0644, "", false},
-		{"/abs.txt", 0644, "", false},
-		{"a//b.txt", 0644, "", false},
-		{"", 0644, "", false},
-		{"link.txt", os.ModeSymlink | 0777, "", false},
-		{"dev", os.ModeDevice | 0666, "", false},
-	}
-	for _, tt := range tests {
-		got, ok := SanitizeZipMemberName(zipFile(t, tt.name, tt.mode))
-		if ok != tt.ok || got != tt.want {
-			t.Errorf("SanitizeZipMemberName(%q, %v) = (%q, %v), want (%q, %v)", tt.name, tt.mode, got, ok, tt.want, tt.ok)
-		}
-	}
-}
-
-// smallZipSpoolLimit drops the in-memory spool threshold to 1 KiB for the
-// duration of a test. Crossing the real 32 MiB threshold needs buffers that
-// are too large for the 32-bit test binary's address space.
-func smallZipSpoolLimit(t *testing.T) {
-	t.Helper()
-	old := zipSpoolMemoryLimit
-	zipSpoolMemoryLimit = 1024
-	t.Cleanup(func() { zipSpoolMemoryLimit = old })
-}
-
-func TestSpoolZipReaderMemory(t *testing.T) {
-	data := []byte(strings.Repeat("x", 1024))
-	ra, n, cleanup, err := SpoolZipReader(bytes.NewReader(data), 0)
-	if err != nil {
-		t.Fatalf("spool: %v", err)
-	}
-	defer cleanup()
-	if n != int64(len(data)) {
-		t.Fatalf("size = %d, want %d", n, len(data))
-	}
-	if _, isFile := ra.(*os.File); isFile {
-		t.Fatal("small archive should spool to memory")
-	}
-	buf := make([]byte, 4)
-	if _, err := ra.ReadAt(buf, 0); err != nil || string(buf) != "xxxx" {
-		t.Fatalf("ReadAt = %q, %v", buf, err)
-	}
-}
-
-func TestSpoolZipReaderTempFile(t *testing.T) {
-	smallZipSpoolLimit(t)
-	data := bytes.Repeat([]byte("y"), int(zipSpoolMemoryLimit)+1)
-	ra, n, cleanup, err := SpoolZipReader(bytes.NewReader(data), 0)
-	if err != nil {
-		t.Fatalf("spool: %v", err)
-	}
-	f, isFile := ra.(*os.File)
-	if !isFile {
-		cleanup()
-		t.Fatal("large archive should spool to a temp file")
-	}
-	name := f.Name()
-	cleanup()
-	if _, err := os.Stat(name); !os.IsNotExist(err) {
-		t.Fatalf("temp file %s still exists after cleanup: %v", name, err)
-	}
-	if n != int64(len(data)) {
-		t.Fatalf("size = %d, want %d", n, len(data))
-	}
-}
-
-func TestSpoolZipReaderLimit(t *testing.T) {
-	smallZipSpoolLimit(t)
-	data := []byte(strings.Repeat("x", 2048))
-	if _, _, _, err := SpoolZipReader(bytes.NewReader(data), 1024); err == nil {
-		t.Fatal("expected limit error for in-memory archive")
-	}
-	if _, _, cleanup, err := SpoolZipReader(bytes.NewReader(bytes.Repeat([]byte("y"), int(zipSpoolMemoryLimit)+1024)), zipSpoolMemoryLimit+512); err == nil {
-		t.Fatal("expected limit error for spooled archive")
-	} else {
-		cleanup()
-	}
-}
-
-func TestCheckZipLimits(t *testing.T) {
-	over := &zip.Reader{File: make([]*zip.File, ZipExtractMaxMembers+1)}
-	for i := range over.File {
-		over.File[i] = &zip.File{}
-	}
-	if err := CheckZipLimits(over); err == nil {
-		t.Fatal("expected member count limit error")
-	}
-
-	big := &zip.Reader{File: []*zip.File{{}}}
-	big.File[0].UncompressedSize64 = uint64(ZipExtractMaxBytes) + 1
-	if err := CheckZipLimits(big); err == nil {
-		t.Fatal("expected total size limit error")
-	}
-
-	overflow := &zip.Reader{File: []*zip.File{{}, {}}}
-	overflow.File[0].UncompressedSize64 = math.MaxUint64
-	overflow.File[1].UncompressedSize64 = math.MaxUint64
-	if err := CheckZipLimits(overflow); err == nil {
-		t.Fatal("expected total size overflow error")
-	}
-
-	ok := &zip.Reader{File: []*zip.File{{}, {}}}
-	if err := CheckZipLimits(ok); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}
-
-func TestSpoolZipReaderRoundTrip(t *testing.T) {
-	var buf bytes.Buffer
-	zw := zip.NewWriter(&buf)
-	w, _ := zw.Create("a/b.txt")
-	w.Write([]byte("hello"))
-	zw.Close()
-
-	ra, n, cleanup, err := SpoolZipReader(bytes.NewReader(buf.Bytes()), 0)
-	if err != nil {
-		t.Fatalf("spool: %v", err)
-	}
-	defer cleanup()
-	zr, err := zip.NewReader(ra, n)
-	if err != nil {
-		t.Fatalf("open zip: %v", err)
-	}
-	rc, err := zr.File[0].Open()
-	if err != nil {
-		t.Fatalf("open member: %v", err)
-	}
-	defer rc.Close()
-	data, _ := io.ReadAll(rc)
-	if string(data) != "hello" {
-		t.Fatalf("member content = %q", data)
-	}
-}

weed/iam/helpers.go

@@ -143,14 +143,8 @@ var baseS3ActionMap = map[string]string{
 	"UploadPart":              s3_constants.ACTION_WRITE,
 	"CompleteMultipartUpload": s3_constants.ACTION_WRITE,
 	"AbortMultipartUpload":    s3_constants.ACTION_WRITE,
-	"ListMultipartUploads":    s3_constants.ACTION_LIST_MULTIPART_UPLOADS,
-	"ListParts":               s3_constants.ACTION_LIST_PARTS,
-	// AWS IAM names for the multipart listing operations get their own
-	// action names so a policy grant cannot widen into a general Read
-	// or Write grant; VerifyActionPermission matches them against the
-	// resolved request action.
-	"ListBucketMultipartUploads": s3_constants.ACTION_LIST_MULTIPART_UPLOADS,
-	"ListMultipartUploadParts":   s3_constants.ACTION_LIST_PARTS,
+	"ListMultipartUploads":    s3_constants.ACTION_WRITE,
+	"ListParts":               s3_constants.ACTION_WRITE,
 	// Retention and legal hold operations
 	"GetObjectRetention":        s3_constants.ACTION_GET_OBJECT_RETENTION,
 	"PutObjectRetention":        s3_constants.ACTION_PUT_OBJECT_RETENTION,
@@ -215,10 +209,6 @@ func MapToIdentitiesAction(action string) string {
 		return "PutBucketPolicy"
 	case s3_constants.ACTION_DELETE_BUCKET_POLICY:
 		return "DeleteBucketPolicy"
-	case s3_constants.ACTION_LIST_MULTIPART_UPLOADS:
-		return "ListBucketMultipartUploads"
-	case s3_constants.ACTION_LIST_PARTS:
-		return "ListMultipartUploadParts"
 	default:
 		return ""
 	}

weed/iam/integration/oidc_provider_store.go

@@ -14,7 +14,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/pb"
 	"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
@@ -564,9 +563,8 @@ func (f *FilerOIDCProviderStore) UpdateProvider(ctx context.Context, filerAddres
 func (f *FilerOIDCProviderStore) deleteProviderEntryIfUnchanged(ctx context.Context, client filer_pb.SeaweedFilerClient, entry *filer_pb.Entry) (bool, error) {
 	fullPath := f.basePath + "/" + entry.Name
 	resp, err := client.ObjectTransaction(ctx, &filer_pb.ObjectTransactionRequest{
-		LockKey:   fullPath,
-		RequestId: uuid.NewString(),
-		RouteKey:  s3_constants.ObjectWriteRouteKeyPrefix + fullPath,
+		LockKey:  fullPath,
+		RouteKey: s3_constants.ObjectWriteRouteKeyPrefix + fullPath,
 		Condition: &filer_pb.WriteCondition{Clauses: []*filer_pb.WriteCondition_Clause{{
 			Kind: filer_pb.WriteCondition_IF_ENTRY_EQUAL, ExpectedEntry: entry,
 		}}},

weed/iam/integration/role_store.go

@@ -11,7 +11,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/karlseguin/ccache/v2"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/iam/policy"
@@ -381,9 +380,8 @@ func (f *FilerRoleStore) UpdateRole(ctx context.Context, filerAddress string, ro
 func (f *FilerRoleStore) deleteRoleEntryIfUnchanged(ctx context.Context, client filer_pb.SeaweedFilerClient, entry *filer_pb.Entry) (bool, error) {
 	fullPath := f.basePath + "/" + entry.Name
 	resp, err := client.ObjectTransaction(ctx, &filer_pb.ObjectTransactionRequest{
-		LockKey:   fullPath,
-		RequestId: uuid.NewString(),
-		RouteKey:  s3_constants.ObjectWriteRouteKeyPrefix + fullPath,
+		LockKey:  fullPath,
+		RouteKey: s3_constants.ObjectWriteRouteKeyPrefix + fullPath,
 		Condition: &filer_pb.WriteCondition{Clauses: []*filer_pb.WriteCondition_Clause{{
 			Kind: filer_pb.WriteCondition_IF_ENTRY_EQUAL, ExpectedEntry: entry,
 		}}},

weed/iam/policy/policy_engine.go

@@ -1240,18 +1240,6 @@ func awsIAMMatch(pattern, value string, evalCtx *EvaluationContext) bool {
 		return true // Universal wildcard
 	}
 
-	// IAM identity ARNs match case-sensitively: identity lookup is
-	// case-sensitive, so a case-variant names a different identity.
-	if strings.HasPrefix(value, "arn:aws:iam::") {
-		if expandedPattern == value {
-			return true
-		}
-		if strings.Contains(expandedPattern, "*") || strings.Contains(expandedPattern, "?") {
-			return wildcard.MatchesWildcard(expandedPattern, value)
-		}
-		return false
-	}
-
 	// Step 3: Case-insensitive exact match
 	if strings.EqualFold(expandedPattern, value) {
 		return true