[hotfix] Change commitable to committable to fix typo. (#1318)

Author: zhuangchong

fluss-common/src/main/java/com/alibaba/fluss/lake/committer/LakeCommitter.java

@@ -42,7 +42,7 @@ public interface LakeCommitter<WriteResult, CommittableT> extends AutoCloseable
      * @return the committable object
      * @throws IOException if an I/O error occurs
      */
-    CommittableT toCommitable(List<WriteResult> writeResults) throws IOException;
+    CommittableT toCommittable(List<WriteResult> writeResults) throws IOException;
 
     /**
      * Commits the given committable object.

fluss-common/src/main/java/com/alibaba/fluss/lake/writer/LakeTieringFactory.java

@@ -31,11 +31,11 @@
  * serializers for write results and committable objects.
  *
  * @param <WriteResult> the type of the write result
- * @param <CommitableT> the type of the committable object
+ * @param <CommittableT> the type of the committable object
  * @since 0.7
  */
 @PublicEvolving
-public interface LakeTieringFactory<WriteResult, CommitableT> extends Serializable {
+public interface LakeTieringFactory<WriteResult, CommittableT> extends Serializable {
 
     /**
      * Creates a lake writer to write Fluss's rows to Paimon/Iceberg rows.
@@ -60,13 +60,13 @@ LakeWriter<WriteResult> createLakeWriter(WriterInitContext writerInitContext)
      * @return the lake committer
      * @throws IOException if an I/O error occurs
      */
-    LakeCommitter<WriteResult, CommitableT> createLakeCommitter(
+    LakeCommitter<WriteResult, CommittableT> createLakeCommitter(
             CommitterInitContext committerInitContext) throws IOException;
 
     /**
      * Returns the serializer for committable objects.
      *
      * @return the serializer for committable objects
      */
-    SimpleVersionedSerializer<CommitableT> getCommitableSerializer();
+    SimpleVersionedSerializer<CommittableT> getCommittableSerializer();
 }

fluss-flink/fluss-flink-common/src/main/java/com/alibaba/fluss/flink/tiering/LakeTieringJobBuilder.java

@@ -98,7 +98,7 @@ public JobClient build() throws Exception {
         source.transform(
                         "TieringCommitter",
                         CommittableMessageTypeInfo.of(
-                                () -> lakeTieringFactory.getCommitableSerializer()),
+                                () -> lakeTieringFactory.getCommittableSerializer()),
                         new TieringCommitOperatorFactory(flussConfig, lakeTieringFactory))
                 .setParallelism(1)
                 .setMaxParallelism(1)

fluss-flink/fluss-flink-common/src/main/java/com/alibaba/fluss/flink/tiering/committer/TieringCommitOperator.java

@@ -64,7 +64,7 @@
  *
  * <p>When it collects all {@link TableBucketWriteResult}s of a round of tiering for a table, it
  * will combine all the {@link WriteResult}s to {@link Committable} via method {@link
- * LakeCommitter#toCommitable(List)}, and then call method {@link LakeCommitter#commit(Object)} to
+ * LakeCommitter#toCommittable(List)}, and then call method {@link LakeCommitter#commit(Object)} to
  * commit to lake.
  *
  * <p>Finally, it will also commit the commited lake snapshot to Fluss cluster to make Fluss aware
@@ -180,7 +180,7 @@ private Committable commitWriteResults(
                             .map(TableBucketWriteResult::writeResult)
                             .collect(Collectors.toList());
             // to committable
-            Committable committable = lakeCommitter.toCommitable(writeResults);
+            Committable committable = lakeCommitter.toCommittable(writeResults);
             // before commit to lake, check fluss not missing any lake snapshot commited by fluss
             checkFlussNotMissingLakeSnapshot(tablePath, lakeCommitter, committable);
             long commitedSnapshotId = lakeCommitter.commit(committable);

fluss-flink/fluss-flink-common/src/test/java/com/alibaba/fluss/flink/tiering/TestingLakeTieringFactory.java

@@ -66,8 +66,9 @@ public LakeCommitter<TestingWriteResult, TestingCommittable> createLakeCommitter
     }
 
     @Override
-    public SimpleVersionedSerializer<TestingCommittable> getCommitableSerializer() {
-        throw new UnsupportedOperationException("method getCommitableSerializer is not supported.");
+    public SimpleVersionedSerializer<TestingCommittable> getCommittableSerializer() {
+        throw new UnsupportedOperationException(
+                "method getCommittableSerializer is not supported.");
     }
 
     private static final class TestingLakeWriter implements LakeWriter<TestingWriteResult> {
@@ -107,7 +108,7 @@ public TestingLakeCommitter(@Nullable CommittedLakeSnapshot mockCommittedSnapsho
         }
 
         @Override
-        public TestingCommittable toCommitable(List<TestingWriteResult> testingWriteResults)
+        public TestingCommittable toCommittable(List<TestingWriteResult> testingWriteResults)
                 throws IOException {
             List<Integer> writeResults = new ArrayList<>();
             for (TestingWriteResult testingWriteResult : testingWriteResults) {

fluss-lake/fluss-lake-paimon/src/main/java/com/alibaba/fluss/lake/paimon/tiering/PaimonLakeCommitter.java

@@ -65,7 +65,7 @@ public PaimonLakeCommitter(PaimonCatalogProvider paimonCatalogProvider, TablePat
     }
 
     @Override
-    public PaimonCommittable toCommitable(List<PaimonWriteResult> paimonWriteResults)
+    public PaimonCommittable toCommittable(List<PaimonWriteResult> paimonWriteResults)
             throws IOException {
         ManifestCommittable committable = new ManifestCommittable(COMMIT_IDENTIFIER);
         for (PaimonWriteResult paimonWriteResult : paimonWriteResults) {

fluss-lake/fluss-lake-paimon/src/main/java/com/alibaba/fluss/lake/paimon/tiering/PaimonLakeTieringFactory.java

@@ -59,7 +59,7 @@ public LakeCommitter<PaimonWriteResult, PaimonCommittable> createLakeCommitter(
     }
 
     @Override
-    public SimpleVersionedSerializer<PaimonCommittable> getCommitableSerializer() {
+    public SimpleVersionedSerializer<PaimonCommittable> getCommittableSerializer() {
         return new PaimonCommittableSerializer();
     }
 }

fluss-lake/fluss-lake-paimon/src/test/java/com/alibaba/fluss/lake/paimon/tiering/PaimonTieringTest.java

@@ -120,7 +120,7 @@ void testTieringWriteTable(boolean isPrimaryKeyTable, boolean isPartitioned) thr
         SimpleVersionedSerializer<PaimonWriteResult> writeResultSerializer =
                 paimonLakeTieringFactory.getWriteResultSerializer();
         SimpleVersionedSerializer<PaimonCommittable> committableSerializer =
-                paimonLakeTieringFactory.getCommitableSerializer();
+                paimonLakeTieringFactory.getCommittableSerializer();
 
         try (LakeCommitter<PaimonWriteResult, PaimonCommittable> lakeCommitter =
                 createLakeCommitter(tablePath)) {
@@ -161,7 +161,7 @@ void testTieringWriteTable(boolean isPrimaryKeyTable, boolean isPartitioned) thr
         try (LakeCommitter<PaimonWriteResult, PaimonCommittable> lakeCommitter =
                 createLakeCommitter(tablePath)) {
             // serialize/deserialize committable
-            PaimonCommittable paimonCommittable = lakeCommitter.toCommitable(paimonWriteResults);
+            PaimonCommittable paimonCommittable = lakeCommitter.toCommittable(paimonWriteResults);
             byte[] serialized = committableSerializer.serialize(paimonCommittable);
             paimonCommittable =
                     committableSerializer.deserialize(
@@ -246,7 +246,7 @@ void testMultiPartitionTiering() throws Exception {
         // Commit all data
         try (LakeCommitter<PaimonWriteResult, PaimonCommittable> lakeCommitter =
                 createLakeCommitter(tablePath)) {
-            PaimonCommittable committable = lakeCommitter.toCommitable(paimonWriteResults);
+            PaimonCommittable committable = lakeCommitter.toCommittable(paimonWriteResults);
             long snapshot = lakeCommitter.commit(committable);
             assertThat(snapshot).isEqualTo(1);
         }
@@ -295,7 +295,7 @@ void testThreePartitionTiering() throws Exception {
         // Commit all data
         try (LakeCommitter<PaimonWriteResult, PaimonCommittable> lakeCommitter =
                 createLakeCommitter(tablePath)) {
-            PaimonCommittable committable = lakeCommitter.toCommitable(paimonWriteResults);
+            PaimonCommittable committable = lakeCommitter.toCommittable(paimonWriteResults);
             long snapshot = lakeCommitter.commit(committable);
             assertThat(snapshot).isEqualTo(1);
         }

website/blog/2025-07-01-tiering-service.md

@@ -166,16 +166,16 @@ public interface LakeTieringFactory {
 
 	SimpleVersionedSerializer<WriteResult> getWriteResultSerializer();
 
-	LakeCommitter<WriteResult, CommitableT> createLakeCommitter(
+	LakeCommitter<WriteResult, CommittableT> createLakeCommitter(
             CommitterInitContext committerInitContext);
 
-	SimpleVersionedSerializer<CommitableT> getCommitableSerializer();
+	SimpleVersionedSerializer<CommittableT> getCommittableSerializer();
 }
 ```
 - **createLakeWriter(WriterInitContext)**: builds a `LakeWriter` to convert Fluss rows into the target table format.
 - **getWriteResultSerializer()**: supplies a serializer for the writer’s output.
 - **createLakeCommitter(CommitterInitContext)**: constructs a `LakeCommitter` to finalize and atomically commit data files.
-- **getCommitableSerializer()**: provides a serializer for committable tokens.```
+- **getCommittableSerializer()**: provides a serializer for committable tokens.```
 
 By default, Fluss includes a Paimon-backed tiering factory; Iceberg support is coming soon. Once the `TieringSourceReader` writes a batch of records through the `LakeWriter`, it emits the resulting write metadata downstream to the **TieringCommitOperator**, which then commits those changes both in the lakehouse and back to the Fluss cluster.