filer: add ObjectTransactionBatch for multi-key object writes (#9649)

A multi-object delete spans many keys that route to different owner filers. The
gateway groups keys by owner and sends one batch per owner; the filer applies
each transaction under its own per-path lock, independent of the others.

A failed transaction (precondition or mutation error) is reported in its own
response without aborting the rest, matching S3 multi-object semantics where
each key succeeds or fails on its own. There is no cross-key atomicity, which S3
batch delete does not require.

weed/server/filer_grpc_server.go

@@ -282,6 +282,39 @@ func (fs *FilerServer) ObjectTransaction(ctx context.Context, req *filer_pb.Obje
 	return &filer_pb.ObjectTransactionResponse{}, nil
 }
 
+// ObjectTransactionBatch applies several object transactions in one round trip,
+// each under its own per-path lock and independent of the others. A failed
+// transaction (precondition or mutation error) is reported in its own response
+// without aborting the rest, matching S3 multi-object semantics where each key
+// succeeds or fails on its own.
+func (fs *FilerServer) ObjectTransactionBatch(ctx context.Context, req *filer_pb.ObjectTransactionBatchRequest) (*filer_pb.ObjectTransactionBatchResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "request is required")
+	}
+	resp := &filer_pb.ObjectTransactionBatchResponse{
+		Responses: make([]*filer_pb.ObjectTransactionResponse, 0, len(req.Transactions)),
+	}
+	for _, txn := range req.Transactions {
+		// Stop early if the caller went away; the request still holds the
+		// unprocessed transactions, so it is retried rather than lost.
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+		if txn == nil {
+			resp.Responses = append(resp.Responses, &filer_pb.ObjectTransactionResponse{Error: "nil transaction"})
+			continue
+		}
+		one, err := fs.ObjectTransaction(ctx, txn)
+		if err != nil {
+			// A transport-level error on one transaction is surfaced as that
+			// transaction's error; the batch RPC itself still succeeds.
+			one = &filer_pb.ObjectTransactionResponse{Error: err.Error()}
+		}
+		resp.Responses = append(resp.Responses, one)
+	}
+	return resp, nil
+}
+
 // applyObjectMutation applies a single mutation while the transaction's path
 // lock is held. PUT entries are expected to be fully prepared by the caller
 // (chunks resolved); mutations here are metadata-scoped. A DELETE of an absent

weed/server/filer_grpc_server_object_txn_test.go

@@ -246,6 +246,92 @@ func TestObjectTransactionRecomputeAscending(t *testing.T) {
 	}
 }
 
+// A batch applies each transaction independently: one failed precondition does
+// not abort the others, matching S3 multi-object delete semantics.
+func TestObjectTransactionBatchIndependent(t *testing.T) {
+	now := time.Unix(1700000000, 0)
+	obj := func(inode uint64) *filer.Entry {
+		return &filer.Entry{
+			Attr:     filer.Attr{Inode: inode, Mtime: now, Crtime: now, Mode: 0644},
+			Extended: map[string][]byte{s3_constants.ExtETagKey: []byte("abc")},
+		}
+	}
+	fs, store := newTxnTestServer(map[string]*filer.Entry{
+		"/buckets/b/a": obj(1),
+		"/buckets/b/c": obj(3),
+	})
+
+	del := func(name string, cond *filer_pb.WriteCondition) *filer_pb.ObjectTransactionRequest {
+		return &filer_pb.ObjectTransactionRequest{
+			LockKey:   "/buckets/b/" + name,
+			Condition: cond,
+			Mutations: []*filer_pb.ObjectMutation{
+				{Type: filer_pb.ObjectMutation_DELETE, Directory: "/buckets/b", Name: name},
+			},
+		}
+	}
+
+	resp, err := fs.ObjectTransactionBatch(context.Background(), &filer_pb.ObjectTransactionBatchRequest{
+		Transactions: []*filer_pb.ObjectTransactionRequest{
+			del("a", nil),
+			del("c", &filer_pb.WriteCondition{Clauses: []*filer_pb.WriteCondition_Clause{
+				{Kind: filer_pb.WriteCondition_IF_ETAG_MATCH, Etags: []string{`"zzz"`}},
+			}}),
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if len(resp.Responses) != 2 {
+		t.Fatalf("want 2 responses, got %d", len(resp.Responses))
+	}
+	if resp.Responses[0].Error != "" {
+		t.Errorf("delete a should succeed: %q", resp.Responses[0].Error)
+	}
+	if resp.Responses[1].ErrorCode != filer_pb.FilerError_PRECONDITION_FAILED {
+		t.Errorf("delete c should fail precondition, got %v", resp.Responses[1].ErrorCode)
+	}
+	if _, ok := store.entries["/buckets/b/a"]; ok {
+		t.Errorf("a should be deleted")
+	}
+	if _, ok := store.entries["/buckets/b/c"]; !ok {
+		t.Errorf("c should survive its failed precondition")
+	}
+}
+
+// A nil transaction in a batch yields an error response in its slot rather than
+// panicking, keeping responses parallel to the requests.
+func TestObjectTransactionBatchNilTransaction(t *testing.T) {
+	now := time.Unix(1700000000, 0)
+	fs, store := newTxnTestServer(map[string]*filer.Entry{
+		"/buckets/b/a": {Attr: filer.Attr{Inode: 1, Mtime: now, Crtime: now, Mode: 0644}},
+	})
+
+	resp, err := fs.ObjectTransactionBatch(context.Background(), &filer_pb.ObjectTransactionBatchRequest{
+		Transactions: []*filer_pb.ObjectTransactionRequest{
+			nil,
+			{LockKey: "/buckets/b/a", Mutations: []*filer_pb.ObjectMutation{
+				{Type: filer_pb.ObjectMutation_DELETE, Directory: "/buckets/b", Name: "a"},
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if len(resp.Responses) != 2 {
+		t.Fatalf("want 2 responses (parallel to requests), got %d", len(resp.Responses))
+	}
+	if resp.Responses[0].Error == "" {
+		t.Errorf("nil transaction should produce an error response")
+	}
+	if resp.Responses[1].Error != "" {
+		t.Errorf("valid transaction should succeed: %q", resp.Responses[1].Error)
+	}
+	if _, ok := store.entries["/buckets/b/a"]; ok {
+		t.Errorf("a should be deleted by the valid transaction")
+	}
+}
+
 // DELETE and PATCH of an absent entry are no-ops, so a replayed transaction
 // does not error.
 func TestObjectTransactionIdempotentNoops(t *testing.T) {