[HUDI-845] Added locking capability to allow multiple writers (#2374)

* [HUDI-845] Added locking capability to allow multiple writers
1. Added LockProvider API for pluggable lock methodologies
2. Added Resolution Strategy API to allow for pluggable conflict resolution
3. Added TableService client API to schedule table services
4. Added Transaction Manager for wrapping actions within transactions

hudi-common/src/main/java/org/apache/hudi/common/config/LockConfiguration.java

@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.common.config;
+
+import java.io.Serializable;
+import java.util.Properties;
+
+/**
+ * Configuration for managing locks. Since this configuration needs to be shared with HiveMetaStore based lock,
+ * which is in a different package than other lock providers, we use this as a data transfer object in hoodie-common
+ */
+public class LockConfiguration implements Serializable {
+
+  public static final String LOCK_PREFIX = "hoodie.writer.lock.";
+  public static final String LOCK_ACQUIRE_RETRY_WAIT_TIME_IN_MILLIS_PROP = LOCK_PREFIX + "wait_time_ms_between_retry";
+  public static final String DEFAULT_LOCK_ACQUIRE_RETRY_WAIT_TIME_IN_MILLIS = String.valueOf(5000L);
+  public static final String LOCK_ACQUIRE_CLIENT_RETRY_WAIT_TIME_IN_MILLIS_PROP = LOCK_PREFIX + "client.wait_time_ms_between_retry";
+  public static final String DEFAULT_LOCK_ACQUIRE_CLIENT_RETRY_WAIT_TIME_IN_MILLIS = String.valueOf(10000L);
+  public static final String LOCK_ACQUIRE_NUM_RETRIES_PROP = LOCK_PREFIX + "num_retries";
+  public static final String DEFAULT_LOCK_ACQUIRE_NUM_RETRIES = String.valueOf(3);
+  public static final String LOCK_ACQUIRE_CLIENT_NUM_RETRIES_PROP = LOCK_PREFIX + "client.num_retries";
+  public static final String DEFAULT_LOCK_ACQUIRE_CLIENT_NUM_RETRIES = String.valueOf(0);
+  public static final String LOCK_ACQUIRE_WAIT_TIMEOUT_MS_PROP = LOCK_PREFIX + "wait_time_ms";
+  public static final int DEFAULT_ACQUIRE_LOCK_WAIT_TIMEOUT_MS = 60 * 1000;
+  // configs for file system based locks. NOTE: This only works for DFS with atomic create/delete operation
+  public static final String FILESYSTEM_BASED_LOCK_PROPERTY_PREFIX = LOCK_PREFIX + "filesystem.";
+  public static final String FILESYSTEM_LOCK_PATH_PROP = FILESYSTEM_BASED_LOCK_PROPERTY_PREFIX + "path";
+  // configs for metastore based locks
+  public static final String HIVE_METASTORE_LOCK_PROPERTY_PREFIX = LOCK_PREFIX + "hivemetastore.";
+  public static final String HIVE_DATABASE_NAME_PROP = HIVE_METASTORE_LOCK_PROPERTY_PREFIX + "database";
+  public static final String HIVE_TABLE_NAME_PROP = HIVE_METASTORE_LOCK_PROPERTY_PREFIX + "table";
+  // Zookeeper configs for zk based locks
+  public static final String ZOOKEEPER_BASED_LOCK_PROPERTY_PREFIX = LOCK_PREFIX + "zookeeper.";
+  public static final String ZK_BASE_PATH_PROP = ZOOKEEPER_BASED_LOCK_PROPERTY_PREFIX + "zk_base_path";
+  public static final String ZK_SESSION_TIMEOUT_MS_PROP = ZOOKEEPER_BASED_LOCK_PROPERTY_PREFIX + "zk_session_timeout_ms";
+  public static final int DEFAULT_ZK_SESSION_TIMEOUT_MS = 60 * 1000;
+  public static final String ZK_CONNECTION_TIMEOUT_MS_PROP = ZOOKEEPER_BASED_LOCK_PROPERTY_PREFIX + "zk_connection_timeout_ms";
+  public static final int DEFAULT_ZK_CONNECTION_TIMEOUT_MS = 15 * 1000;
+  public static final String ZK_CONNECT_URL_PROP = ZOOKEEPER_BASED_LOCK_PROPERTY_PREFIX + "url";
+  public static final String ZK_PORT_PROP = ZOOKEEPER_BASED_LOCK_PROPERTY_PREFIX + "port";
+  public static final String ZK_LOCK_KEY_PROP = LOCK_PREFIX + "lock_key";
+
+  private final TypedProperties props;
+
+  public LockConfiguration(Properties props) {
+    this.props = new TypedProperties(props);
+  }
+
+  public TypedProperties getConfig() {
+    return props;
+  }
+
+}

hudi-common/src/main/java/org/apache/hudi/common/lock/LockProvider.java

@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.common.lock;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+
+/**
+ * Pluggable lock implementations using this provider class.
+ */
+public interface LockProvider<T> extends Lock, AutoCloseable {
+
+  @Override
+  default void lockInterruptibly() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  default void lock() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  default boolean tryLock() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  default Condition newCondition() {
+    throw new UnsupportedOperationException();
+  }
+
+  default T getLock() {
+    throw new IllegalArgumentException();
+  }
+
+  @Override
+  default void close() {
+  }
+}

hudi-common/src/main/java/org/apache/hudi/common/lock/LockState.java

@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.common.lock;
+
+/**
+ * Enum to signal the state of the lock.
+ */
+public enum LockState {
+  ACQUIRING, ACQUIRED, ALREADY_ACQUIRED, RELEASING, RELEASED, ALREADY_RELEASED,
+  FAILED_TO_ACQUIRE, FAILED_TO_RELEASE
+}

hudi-common/src/main/java/org/apache/hudi/common/model/HoodieMetadataWrapper.java

@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.common.model;
+
+import org.apache.hudi.avro.model.HoodieArchivedMetaEntry;
+
+public class HoodieMetadataWrapper {
+
+  private HoodieArchivedMetaEntry avroMetadataFromTimeline;
+  private HoodieCommitMetadata commitMetadata;
+  private boolean isAvroMetadata = false;
+
+  public HoodieMetadataWrapper(HoodieArchivedMetaEntry avroMetadataFromTimeline) {
+    this.avroMetadataFromTimeline = avroMetadataFromTimeline;
+    this.isAvroMetadata = true;
+  }
+
+  public HoodieMetadataWrapper(HoodieCommitMetadata commitMetadata) {
+    this.commitMetadata = commitMetadata;
+  }
+
+  public HoodieArchivedMetaEntry getMetadataFromTimeline() {
+    return avroMetadataFromTimeline;
+  }
+
+  public HoodieCommitMetadata getCommitMetadata() {
+    return commitMetadata;
+  }
+
+  public boolean isAvroMetadata() {
+    return isAvroMetadata;
+  }
+}

hudi-common/src/main/java/org/apache/hudi/common/model/TableServiceType.java

@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.common.model;
+
+import org.apache.hudi.common.table.timeline.HoodieTimeline;
+
+/**
+ * Supported runtime table services.
+ */
+public enum TableServiceType {
+  COMPACT, CLUSTER, CLEAN;
+
+  public String getAction() {
+    switch (this) {
+      case COMPACT:
+        return HoodieTimeline.COMPACTION_ACTION;
+      case CLEAN:
+        return HoodieTimeline.CLEAN_ACTION;
+      case CLUSTER:
+        return HoodieTimeline.REPLACE_COMMIT_ACTION;
+      default:
+        throw new IllegalArgumentException("Unknown table service " + this);
+    }
+  }
+}

hudi-common/src/main/java/org/apache/hudi/common/model/WriteConcurrencyMode.java

@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.common.model;
+
+import org.apache.hudi.exception.HoodieException;
+
+import java.util.Locale;
+
+/**
+ * Different concurrency modes for write operations.
+ */
+public enum WriteConcurrencyMode {
+  // Only a single writer can perform write ops
+  SINGLE_WRITER("single_writer"),
+  // Multiple writer can perform write ops with lazy conflict resolution using locks
+  OPTIMISTIC_CONCURRENCY_CONTROL("optimistic_concurrency_control");
+
+  private final String value;
+
+  WriteConcurrencyMode(String value) {
+    this.value = value;
+  }
+
+  /**
+   * Getter for write concurrency mode.
+   * @return
+   */
+  public String value() {
+    return value;
+  }
+
+  /**
+   * Convert string value to WriteConcurrencyMode.
+   */
+  public static WriteConcurrencyMode fromValue(String value) {
+    switch (value.toLowerCase(Locale.ROOT)) {
+      case "single_writer":
+        return SINGLE_WRITER;
+      case "optimistic_concurrency_control":
+        return OPTIMISTIC_CONCURRENCY_CONTROL;
+      default:
+        throw new HoodieException("Invalid value of Type.");
+    }
+  }
+
+  public boolean supportsOptimisticConcurrencyControl() {
+    return this == OPTIMISTIC_CONCURRENCY_CONTROL;
+  }
+
+}

hudi-common/src/main/java/org/apache/hudi/common/model/WriteOperationType.java

@@ -46,6 +46,8 @@ public enum WriteOperationType {
   DELETE_PARTITION("delete_partition"),
   // insert overwrite with dynamic partitioning
   INSERT_OVERWRITE_TABLE("insert_overwrite_table"),
+  // compact
+  COMPACT("compact"),
   // used for old version
   UNKNOWN("unknown");
 
@@ -82,6 +84,10 @@ public enum WriteOperationType {
         return INSERT_OVERWRITE_TABLE;
       case "cluster":
         return CLUSTER;
+      case "compact":
+        return COMPACT;
+      case "unknown":
+        return UNKNOWN;
       default:
         throw new HoodieException("Invalid value of Type.");
     }

hudi-common/src/main/java/org/apache/hudi/common/table/timeline/HoodieDefaultTimeline.java

@@ -143,6 +143,12 @@ public class HoodieDefaultTimeline implements HoodieTimeline {
         details);
   }
 
+  @Override
+  public HoodieTimeline findInstantsAfter(String instantTime) {
+    return new HoodieDefaultTimeline(instants.stream()
+        .filter(s -> HoodieTimeline.compareTimestamps(s.getTimestamp(), GREATER_THAN, instantTime)), details);
+  }
+
   @Override
   public HoodieDefaultTimeline findInstantsAfterOrEquals(String commitTime, int numCommits) {
     return new HoodieDefaultTimeline(instants.stream()

hudi-common/src/main/java/org/apache/hudi/common/table/timeline/HoodieTimeline.java

@@ -171,6 +171,11 @@ public interface HoodieTimeline extends Serializable {
    */
   HoodieTimeline findInstantsAfter(String instantTime, int numCommits);
 
+  /**
+   * Create a new Timeline with all the instants after startTs.
+   */
+  HoodieTimeline findInstantsAfter(String instantTime);
+
   /**
    * Create a new Timeline with all instants before specified time.
    */

hudi-common/src/main/java/org/apache/hudi/common/util/ClusteringUtils.java

@@ -69,26 +69,43 @@ public class ClusteringUtils {
         .filter(Option::isPresent).map(Option::get);
   }
 
+  /**
+   * Get requested replace metadata from timeline.
+   * @param metaClient
+   * @param pendingReplaceInstant
+   * @return
+   * @throws IOException
+   */
+  public static Option<HoodieRequestedReplaceMetadata> getRequestedReplaceMetadata(HoodieTableMetaClient metaClient, HoodieInstant pendingReplaceInstant) throws IOException {
+    final HoodieInstant requestedInstant;
+    if (!pendingReplaceInstant.isRequested()) {
+      // inflight replacecommit files don't have clustering plan.
+      // This is because replacecommit inflight can have workload profile for 'insert_overwrite'.
+      // Get the plan from corresponding requested instant.
+      requestedInstant = HoodieTimeline.getReplaceCommitRequestedInstant(pendingReplaceInstant.getTimestamp());
+    } else {
+      requestedInstant = pendingReplaceInstant;
+    }
+    Option<byte[]> content = metaClient.getActiveTimeline().getInstantDetails(requestedInstant);
+    if (!content.isPresent() || content.get().length == 0) {
+      // few operations create requested file without any content. Assume these are not clustering
+      LOG.warn("No content found in requested file for instant " + pendingReplaceInstant);
+      return Option.empty();
+    }
+    return Option.of(TimelineMetadataUtils.deserializeRequestedReplaceMetadata(content.get()));
+  }
+
+  /**
+   * Get Clustering plan from timeline.
+   * @param metaClient
+   * @param pendingReplaceInstant
+   * @return
+   */
   public static Option<Pair<HoodieInstant, HoodieClusteringPlan>> getClusteringPlan(HoodieTableMetaClient metaClient, HoodieInstant pendingReplaceInstant) {
     try {
-      final HoodieInstant requestedInstant;
-      if (!pendingReplaceInstant.isRequested()) {
-        // inflight replacecommit files don't have clustering plan.
-        // This is because replacecommit inflight can have workload profile for 'insert_overwrite'.
-        // Get the plan from corresponding requested instant.
-        requestedInstant = HoodieTimeline.getReplaceCommitRequestedInstant(pendingReplaceInstant.getTimestamp());
-      } else {
-        requestedInstant = pendingReplaceInstant;
-      }
-      Option<byte[]> content = metaClient.getActiveTimeline().getInstantDetails(requestedInstant);
-      if (!content.isPresent() || content.get().length == 0) {
-        // few operations create requested file without any content. Assume these are not clustering
-        LOG.warn("No content found in requested file for instant " + pendingReplaceInstant);
-        return Option.empty();
-      }
-      HoodieRequestedReplaceMetadata requestedReplaceMetadata = TimelineMetadataUtils.deserializeRequestedReplaceMetadata(content.get());
-      if (WriteOperationType.CLUSTER.name().equals(requestedReplaceMetadata.getOperationType())) {
-        return Option.of(Pair.of(pendingReplaceInstant, requestedReplaceMetadata.getClusteringPlan()));
+      Option<HoodieRequestedReplaceMetadata> requestedReplaceMetadata = getRequestedReplaceMetadata(metaClient, pendingReplaceInstant);
+      if (requestedReplaceMetadata.isPresent() && WriteOperationType.CLUSTER.name().equals(requestedReplaceMetadata.get().getOperationType())) {
+        return Option.of(Pair.of(pendingReplaceInstant, requestedReplaceMetadata.get().getClusteringPlan()));
       }
       return Option.empty();
     } catch (IOException e) {

hudi-common/src/main/java/org/apache/hudi/common/util/CommitUtils.java

@@ -29,6 +29,7 @@ import org.apache.hudi.exception.HoodieException;
 import org.apache.log4j.LogManager;
 import org.apache.log4j.Logger;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -93,4 +94,28 @@ public class CommitUtils {
         + "numReplaceFileIds:" + partitionToReplaceFileIds.values().stream().mapToInt(e -> e.size()).sum());
     return commitMetadata;
   }
+
+  public static HashMap<String, String> getFileIdWithoutSuffixAndRelativePathsFromSpecificRecord(Map<String, List<org.apache.hudi.avro.model.HoodieWriteStat>>
+                                                                                       partitionToWriteStats) {
+    HashMap<String, String> fileIdToPath = new HashMap<>();
+    // list all partitions paths
+    for (Map.Entry<String, List<org.apache.hudi.avro.model.HoodieWriteStat>> entry : partitionToWriteStats.entrySet()) {
+      for (org.apache.hudi.avro.model.HoodieWriteStat stat : entry.getValue()) {
+        fileIdToPath.put(stat.getFileId(), stat.getPath());
+      }
+    }
+    return fileIdToPath;
+  }
+
+  public static HashMap<String, String> getFileIdWithoutSuffixAndRelativePaths(Map<String, List<HoodieWriteStat>>
+      partitionToWriteStats) {
+    HashMap<String, String> fileIdToPath = new HashMap<>();
+    // list all partitions paths
+    for (Map.Entry<String, List<HoodieWriteStat>> entry : partitionToWriteStats.entrySet()) {
+      for (HoodieWriteStat stat : entry.getValue()) {
+        fileIdToPath.put(stat.getFileId(), stat.getPath());
+      }
+    }
+    return fileIdToPath;
+  }
 }

hudi-common/src/main/java/org/apache/hudi/exception/HoodieLockException.java

@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.exception;
+
+/**
+ * <p>
+ * Exception thrown for Hoodie failures. The root of the exception hierarchy.
+ * </p>
+ * <p>
+ * Hoodie Write clients will throw this exception if unable to acquire a lock. This is a runtime (unchecked)
+ * exception.
+ * </p>
+ */
+public class HoodieLockException extends HoodieException {
+
+  public HoodieLockException(String msg) {
+    super(msg);
+  }
+
+  public HoodieLockException(Throwable e) {
+    super(e);
+  }
+
+  public HoodieLockException(String msg, Throwable e) {
+    super(msg, e);
+  }
+}

hudi-common/src/main/java/org/apache/hudi/exception/HoodieWriteConflictException.java

@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hudi.exception;
+
+/**
+ * <p>
+ * Exception thrown for Hoodie failures. The root of the exception hierarchy.
+ * </p>
+ * <p>
+ * Hoodie Write clients will throw this exception if unable to commit due to conflicts. This is a runtime (unchecked)
+ * exception.
+ * </p>
+ */
+public class HoodieWriteConflictException extends HoodieException {
+
+  public HoodieWriteConflictException(String msg) {
+    super(msg);
+  }
+
+  public HoodieWriteConflictException(Throwable e) {
+    super(e);
+  }
+
+  public HoodieWriteConflictException(String msg, Throwable e) {
+    super(msg, e);
+  }
+}

hudi-common/src/test/java/org/apache/hudi/common/testutils/FileCreateUtils.java

@@ -22,14 +22,15 @@ package org.apache.hudi.common.testutils;
 import org.apache.hudi.avro.model.HoodieCleanMetadata;
 import org.apache.hudi.avro.model.HoodieCleanerPlan;
 import org.apache.hudi.avro.model.HoodieRequestedReplaceMetadata;
+import org.apache.hudi.avro.model.HoodieRollbackMetadata;
 import org.apache.hudi.common.fs.FSUtils;
+import org.apache.hudi.common.model.HoodieCommitMetadata;
 import org.apache.hudi.common.model.HoodieFileFormat;
 import org.apache.hudi.common.model.HoodiePartitionMetadata;
 import org.apache.hudi.common.model.HoodieReplaceCommitMetadata;
 import org.apache.hudi.common.model.IOType;
 import org.apache.hudi.common.table.HoodieTableMetaClient;
 import org.apache.hudi.common.table.timeline.HoodieTimeline;
-import org.apache.hudi.common.table.timeline.TimelineMetadataUtils;
 import org.apache.hudi.common.table.view.HoodieTableFileSystemView;
 import org.apache.hudi.common.table.view.TableFileSystemView;
 import org.apache.hudi.exception.HoodieException;
@@ -47,6 +48,8 @@ import java.util.Map;
 
 import static org.apache.hudi.common.table.timeline.TimelineMetadataUtils.serializeCleanMetadata;
 import static org.apache.hudi.common.table.timeline.TimelineMetadataUtils.serializeCleanerPlan;
+import static org.apache.hudi.common.table.timeline.TimelineMetadataUtils.serializeRequestedReplaceMetadata;
+import static org.apache.hudi.common.table.timeline.TimelineMetadataUtils.serializeRollbackMetadata;
 
 public class FileCreateUtils {
 
@@ -117,6 +120,10 @@ public class FileCreateUtils {
     createMetaFile(basePath, instantTime, HoodieTimeline.COMMIT_EXTENSION);
   }
 
+  public static void createCommit(String basePath, String instantTime, HoodieCommitMetadata metadata) throws IOException {
+    createMetaFile(basePath, instantTime, HoodieTimeline.COMMIT_EXTENSION, metadata.toJsonString().getBytes(StandardCharsets.UTF_8));
+  }
+
   public static void createCommit(String basePath, String instantTime, FileSystem fs) throws IOException {
     createMetaFile(basePath, instantTime, HoodieTimeline.COMMIT_EXTENSION, fs);
   }
@@ -149,9 +156,8 @@ public class FileCreateUtils {
     createMetaFile(basePath, instantTime, HoodieTimeline.REPLACE_COMMIT_EXTENSION, metadata.toJsonString().getBytes(StandardCharsets.UTF_8));
   }
 
-  public static void createRequestedReplaceCommit(String basePath, String instantTime, HoodieRequestedReplaceMetadata requestedMetadata) throws IOException {
-    createMetaFile(basePath, instantTime, HoodieTimeline.REQUESTED_REPLACE_COMMIT_EXTENSION,
-        TimelineMetadataUtils.serializeRequestedReplaceMetadata(requestedMetadata).get());
+  public static void createRequestedReplaceCommit(String basePath, String instantTime, HoodieRequestedReplaceMetadata requestedReplaceMetadata) throws IOException {
+    createMetaFile(basePath, instantTime, HoodieTimeline.REQUESTED_REPLACE_COMMIT_EXTENSION, serializeRequestedReplaceMetadata(requestedReplaceMetadata).get());
   }
 
   public static void createInflightReplaceCommit(String basePath, String instantTime) throws IOException {
@@ -170,6 +176,14 @@ public class FileCreateUtils {
     createMetaFile(basePath, instantTime, HoodieTimeline.INFLIGHT_CLEAN_EXTENSION, serializeCleanerPlan(cleanerPlan).get());
   }
 
+  public static void createInflightRollbackFile(String basePath, String instantTime) throws IOException {
+    createMetaFile(basePath, instantTime, HoodieTimeline.INFLIGHT_ROLLBACK_EXTENSION);
+  }
+
+  public static void createRollbackFile(String basePath, String instantTime, HoodieRollbackMetadata rollbackMetadata) throws IOException {
+    createMetaFile(basePath, instantTime, HoodieTimeline.ROLLBACK_EXTENSION, serializeRollbackMetadata(rollbackMetadata).get());
+  }
+
   private static void createAuxiliaryMetaFile(String basePath, String instantTime, String suffix) throws IOException {
     Path parentPath = Paths.get(basePath, HoodieTableMetaClient.AUXILIARYFOLDER_NAME);
     Files.createDirectories(parentPath);

hudi-common/src/test/java/org/apache/hudi/common/testutils/HoodieTestTable.java

@@ -23,7 +23,9 @@ import org.apache.hudi.avro.model.HoodieCleanMetadata;
 import org.apache.hudi.avro.model.HoodieCleanerPlan;
 import org.apache.hudi.avro.model.HoodieCompactionPlan;
 import org.apache.hudi.avro.model.HoodieRequestedReplaceMetadata;
+import org.apache.hudi.avro.model.HoodieRollbackMetadata;
 import org.apache.hudi.common.model.FileSlice;
+import org.apache.hudi.common.model.HoodieCommitMetadata;
 import org.apache.hudi.common.model.HoodieFileFormat;
 import org.apache.hudi.common.model.HoodieReplaceCommitMetadata;
 import org.apache.hudi.common.model.IOType;
@@ -65,6 +67,7 @@ import static org.apache.hudi.common.testutils.FileCreateUtils.createInflightCom
 import static org.apache.hudi.common.testutils.FileCreateUtils.createInflightCompaction;
 import static org.apache.hudi.common.testutils.FileCreateUtils.createInflightDeltaCommit;
 import static org.apache.hudi.common.testutils.FileCreateUtils.createInflightReplaceCommit;
+import static org.apache.hudi.common.testutils.FileCreateUtils.createInflightRollbackFile;
 import static org.apache.hudi.common.testutils.FileCreateUtils.createMarkerFile;
 import static org.apache.hudi.common.testutils.FileCreateUtils.createReplaceCommit;
 import static org.apache.hudi.common.testutils.FileCreateUtils.createRequestedCleanFile;
@@ -72,6 +75,7 @@ import static org.apache.hudi.common.testutils.FileCreateUtils.createRequestedCo
 import static org.apache.hudi.common.testutils.FileCreateUtils.createRequestedCompaction;
 import static org.apache.hudi.common.testutils.FileCreateUtils.createRequestedDeltaCommit;
 import static org.apache.hudi.common.testutils.FileCreateUtils.createRequestedReplaceCommit;
+import static org.apache.hudi.common.testutils.FileCreateUtils.createRollbackFile;
 import static org.apache.hudi.common.testutils.FileCreateUtils.logFileName;
 
 public class HoodieTestTable {
@@ -155,6 +159,15 @@ public class HoodieTestTable {
     return this;
   }
 
+  public HoodieTestTable addCommit(String instantTime, HoodieCommitMetadata metadata) throws Exception {
+    createRequestedCommit(basePath, instantTime);
+    createInflightCommit(basePath, instantTime);
+    createCommit(basePath, instantTime, metadata);
+    currentInstantTime = instantTime;
+    metaClient = HoodieTableMetaClient.reload(metaClient);
+    return this;
+  }
+
   public HoodieTestTable addDeltaCommit(String instantTime) throws Exception {
     createRequestedDeltaCommit(basePath, instantTime);
     createInflightDeltaCommit(basePath, instantTime);
@@ -173,6 +186,13 @@ public class HoodieTestTable {
     return this;
   }
 
+  public HoodieTestTable addRequestedReplace(String instantTime, HoodieRequestedReplaceMetadata requestedReplaceMetadata) throws Exception {
+    createRequestedReplaceCommit(basePath, instantTime, requestedReplaceMetadata);
+    currentInstantTime = instantTime;
+    metaClient = HoodieTableMetaClient.reload(metaClient);
+    return this;
+  }
+
   public HoodieTestTable addInflightClean(String instantTime, HoodieCleanerPlan cleanerPlan) throws IOException {
     createRequestedCleanFile(basePath, instantTime, cleanerPlan);
     createInflightCleanFile(basePath, instantTime, cleanerPlan);
@@ -190,6 +210,14 @@ public class HoodieTestTable {
     return this;
   }
 
+  public HoodieTestTable addRollback(String instantTime, HoodieRollbackMetadata rollbackMetadata) throws IOException {
+    createInflightRollbackFile(basePath, instantTime);
+    createRollbackFile(basePath, instantTime, rollbackMetadata);
+    currentInstantTime = instantTime;
+    metaClient = HoodieTableMetaClient.reload(metaClient);
+    return this;
+  }
+
   public HoodieTestTable addRequestedCompaction(String instantTime) throws IOException {
     createRequestedCompaction(basePath, instantTime);
     currentInstantTime = instantTime;

hudi-common/src/test/java/org/apache/hudi/common/testutils/minicluster/ZookeeperTestService.java

@@ -124,14 +124,14 @@ public class ZookeeperTestService {
     return zooKeeperServer;
   }
 
-  public void stop() throws IOException {
+  public void stop() throws RuntimeException {
     if (!started) {
       return;
     }
 
     standaloneServerFactory.shutdown();
     if (!waitForServerDown(clientPort, CONNECTION_TIMEOUT)) {
-      throw new IOException("Waiting for shutdown of standalone server");
+      throw new RuntimeException("Waiting for shutdown of standalone server");
     }
 
     // clear everything
@@ -232,4 +232,8 @@ public class ZookeeperTestService {
     }
     return false;
   }
+
+  public String connectString() {
+    return bindIP + ":" + clientPort;
+  }
 }

hudi-common/src/test/java/org/apache/hudi/common/util/TestCommitUtils.java

@@ -93,4 +93,4 @@ public class TestCommitUtils {
     writeStat1.setFileId(fileId);
     return writeStat1;
   }
-}
+}