CASSANDRA-21134: Make direct-write classification total over OperationType

RELOCATE (online relocateSSTables) and UNKNOWN (offline sstablesplit)
reach DataComponent.buildWriter() despite writesData==false, so keying the
direct-write classification off writesData left RELOCATE unclassified and
threw under background_write_disk_access_mode: direct.

Make DIRECT_WRITE_SUPPORT total over OperationType.values(): classify
RELOCATE and UNKNOWN as SUPPORTED (both append-only, safe under O_DIRECT)
and the nine genuine non-writers as a new NOT_A_WRITER marker. The
build-time guard now asserts completeness over values(), so a newly-added
OperationType fails at class-load instead of in production.

Author: samueldlightfoot

src/java/org/apache/cassandra/io/DirectIoSupport.java

@@ -40,7 +40,13 @@ public enum DirectIoSupport
      * Direct IO would work but is deliberately disabled for performance or cache-residency
      * reasons. Removing this exclusion requires re-evaluating the policy, not code changes.
      */
-    UNSUPPORTED_POLICY;
+    UNSUPPORTED_POLICY,
+
+    /**
+     * The operation never constructs a data-file writer, so the direct-IO question does not apply.
+     * Exists so a consumer's classification can be total over its operation enum rather than partial.
+     */
+    NOT_A_WRITER;
 
     public boolean isSupported()
     {

src/java/org/apache/cassandra/io/sstable/format/DataComponent.java

@@ -40,6 +40,7 @@
 import org.apache.cassandra.schema.CompressionParams;
 import org.apache.cassandra.schema.TableMetadata;
 
+import static org.apache.cassandra.io.DirectIoSupport.NOT_A_WRITER;
 import static org.apache.cassandra.io.DirectIoSupport.SUPPORTED;
 import static org.apache.cassandra.io.DirectIoSupport.UNSUPPORTED_CORRECTNESS;
 import static org.apache.cassandra.io.DirectIoSupport.UNSUPPORTED_POLICY;
@@ -62,16 +63,35 @@ private static EnumMap<OperationType, DirectIoSupport> buildDirectWriteSupport()
         m.put(OperationType.COMPACTION, SUPPORTED);
         m.put(OperationType.TOMBSTONE_COMPACTION, SUPPORTED);
         m.put(OperationType.STREAM, SUPPORTED);
+        // writesData==false yet these still reach buildWriter() (RELOCATE via relocateSSTables, UNKNOWN via
+        // the offline sstablesplit tool), which is why classification can't key off writesData. CASSANDRA-21134.
+        m.put(OperationType.RELOCATE, SUPPORTED);
+        m.put(OperationType.UNKNOWN, SUPPORTED);
 
         // tryAppend() needs mark()/resetAndTruncate(), unsupported under O_DIRECT.
         m.put(OperationType.SCRUB, UNSUPPORTED_CORRECTNESS);
 
         // Flushed data is hot; keep it in the page cache.
         m.put(OperationType.FLUSH, UNSUPPORTED_POLICY);
 
+        // These never construct a data-file writer (read-only, rewrite a non-data component, or write their
+        // own files), so they never reach buildWriter(). Classified only to keep the map total.
+        m.put(OperationType.P0, NOT_A_WRITER);
+        m.put(OperationType.VERIFY, NOT_A_WRITER);
+        m.put(OperationType.VALIDATION, NOT_A_WRITER);
+        m.put(OperationType.INDEX_BUILD, NOT_A_WRITER);
+        m.put(OperationType.VIEW_BUILD, NOT_A_WRITER);
+        m.put(OperationType.INDEX_SUMMARY, NOT_A_WRITER);
+        m.put(OperationType.KEY_CACHE_SAVE, NOT_A_WRITER);
+        m.put(OperationType.ROW_CACHE_SAVE, NOT_A_WRITER);
+        m.put(OperationType.COUNTER_CACHE_SAVE, NOT_A_WRITER);
+
+        // Total over the enum so a newly-added OperationType fails here at class-load instead of throwing
+        // from buildWriter() in production (CASSANDRA-21134: RELOCATE slipped through the old writesData gate).
         for (OperationType op : OperationType.values())
-            if (op.writesData && !m.containsKey(op))
-                throw new AssertionError("Missing direct-write classification for " + op);
+            if (!m.containsKey(op))
+                throw new AssertionError("Missing direct-write classification for " + op
+                                         + " — every OperationType must be SUPPORTED, UNSUPPORTED_*, or NOT_A_WRITER");
         return m;
     }
 
@@ -164,8 +184,7 @@ static boolean isDirectWriteSupported(OperationType operationType)
     {
         DirectIoSupport support = DIRECT_WRITE_SUPPORT.get(operationType);
         if (support == null)
-            throw new IllegalArgumentException("OperationType " + operationType
-                                               + " has no direct-write classification — likely a read-only operation routed through buildWriter()");
+            throw new IllegalStateException("OperationType " + operationType + " has no direct-write classification");
         return support.isSupported();
     }
 

test/unit/org/apache/cassandra/io/sstable/format/DataComponentDirectWriteSelectionTest.java

@@ -79,14 +79,11 @@ public void tearDown()
     }
 
     @Test
-    public void testWriterSelectionMatchesAllowListForEveryDataWritingOp() throws Exception
+    public void testWriterSelectionMatchesAllowListForEveryOp() throws Exception
     {
         DirectIoTestUtils.withDirectWrites(() -> {
             for (OperationType op : OperationType.values())
             {
-                if (!op.writesData)
-                    continue;
-
                 boolean expectDirect = DataComponent.isDirectWriteSupported(op);
                 try (SequentialWriter w = build(compressedMetadata(), op))
                 {
@@ -99,7 +96,7 @@ public void testWriterSelectionMatchesAllowListForEveryDataWritingOp() throws Ex
     }
 
     // The allow-list loop test takes its oracle from isDirectWriteSupported, so it can't catch a bad
-    // reclassification of these two ops. Pin their intent independently.
+    // reclassification of these ops. Pin their intent independently.
     @Test
     public void testScrubAndFlushAreNeverDirectWriteSupported()
     {
@@ -109,15 +106,23 @@ public void testScrubAndFlushAreNeverDirectWriteSupported()
                     DataComponent.isDirectWriteSupported(OperationType.FLUSH));
     }
 
+    // RELOCATE and UNKNOWN are writesData==false but DO reach buildWriter (relocateSSTables / offline
+    // sstablesplit). Pin them SUPPORTED so they can't silently regress to NOT_A_WRITER (CASSANDRA-21134).
+    @Test
+    public void testRelocateAndUnknownAreDirectWriteSupported()
+    {
+        assertTrue("RELOCATE rewrites SSTables via a compaction task and must use direct writes",
+                   DataComponent.isDirectWriteSupported(OperationType.RELOCATE));
+        assertTrue("UNKNOWN reaches buildWriter via the offline sstablesplit tool and must use direct writes",
+                   DataComponent.isDirectWriteSupported(OperationType.UNKNOWN));
+    }
+
     @Test
     public void testUncompressedAlwaysUsesStandardWriter() throws Exception
     {
         DirectIoTestUtils.withDirectWrites(() -> {
             for (OperationType op : OperationType.values())
             {
-                if (!op.writesData)
-                    continue;
-
                 try (SequentialWriter w = build(uncompressedMetadata(), op))
                 {
                     assertTrue("Uncompressed tables must use ChecksummedSequentialWriter for " + op + ", got " + w.getClass().getSimpleName(),
@@ -136,9 +141,6 @@ public void testBufferedModeNeverPicksDirectWriter()
         {
             for (OperationType op : OperationType.values())
             {
-                if (!op.writesData)
-                    continue;
-
                 try (SequentialWriter w = build(compressedMetadata(), op))
                 {
                     assertTrue("Buffered mode must not produce DirectCompressedSequentialWriter for " + op + ", got " + w.getClass().getSimpleName(),