> entry : futureMap.entrySet()) {
+ MapreduceHFileArchiver.File file = entry.getKey();
+ try {
+ if (!entry.getValue().get()) {
+ LOG.warn("Failed to archive file: {} into directory: {}", file, baseArchiveDir);
+ failures.add(file);
+ }
+ } catch (InterruptedException e) {
+ LOG.error("Archiving interrupted for file: {}", file, e);
+ Thread.currentThread().interrupt(); // Restore interrupt status
+ failures.add(file);
+ } catch (ExecutionException e) {
+ LOG.error("Archiving failed for file: {}", file, e);
+ failures.add(file);
+ }
+ }
+ } finally {
+ hfilesArchiveExecutor.shutdown();
+ }
+ }
+
+ /**
+ * Attempt to archive the passed in file to the archive directory.
+ *
+ * If the same file already exists in the archive, it is moved to a timestamped directory under
+ * the archive directory and the new file is put in its place.
+ * @param archiveDir {@link Path} to the directory that stores the archives of the hfiles
+ * @param currentFile {@link Path} to the original HFile that will be archived
+ * @param archiveStartTime time the archiving started, to resolve naming conflicts
+ * @return true if the file is successfully archived. false if there was a
+ * problem, but the operation still completed.
+ * @throws IOException on failure to complete {@link FileSystem} operations.
+ */
+ private static boolean resolveAndArchiveFile(Path archiveDir, MapreduceHFileArchiver.File currentFile,
+ String archiveStartTime) throws IOException {
+ // build path as it should be in the archive
+ String filename = currentFile.getName();
+ Path archiveFile = new Path(archiveDir, filename);
+ FileSystem fs = currentFile.getFileSystem();
+
+ // An existing destination file in the archive is unexpected, but we handle it here.
+ if (fs.exists(archiveFile)) {
+ if (!fs.exists(currentFile.getPath())) {
+ // If the file already exists in the archive, and there is no current file to archive, then
+ // assume that the file in archive is correct. This is an unexpected situation, suggesting a
+ // race condition or split brain.
+ // In HBASE-26718 this was found when compaction incorrectly happened during warmupRegion.
+ LOG.warn("{} exists in archive. Attempted to archive nonexistent file {}.", archiveFile,
+ currentFile);
+ // We return success to match existing behavior in this method, where FileNotFoundException
+ // in moveAndClose is ignored.
+ return true;
+ }
+ // There is a conflict between the current file and the already existing archived file.
+ // Move the archived file to a timestamped backup. This is a really, really unlikely
+ // situation, where we get the same name for the existing file, but is included just for that
+ // 1 in trillion chance. We are potentially incurring data loss in the archive directory if
+ // the files are not identical. The timestamped backup will be cleaned by HFileCleaner as it
+ // has no references.
+ FileStatus curStatus = fs.getFileStatus(currentFile.getPath());
+ FileStatus archiveStatus = fs.getFileStatus(archiveFile);
+ long curLen = curStatus.getLen();
+ long archiveLen = archiveStatus.getLen();
+ long curMtime = curStatus.getModificationTime();
+ long archiveMtime = archiveStatus.getModificationTime();
+ if (curLen != archiveLen) {
+ LOG.error(
+ "{} already exists in archive with different size than current {}."
+ + " archiveLen: {} currentLen: {} archiveMtime: {} currentMtime: {}",
+ archiveFile, currentFile, archiveLen, curLen, archiveMtime, curMtime);
+ throw new IOException(
+ archiveFile + " already exists in archive with different size" + " than " + currentFile);
+ }
+
+ LOG.error(
+ "{} already exists in archive, moving to timestamped backup and overwriting"
+ + " current {}. archiveLen: {} currentLen: {} archiveMtime: {} currentMtime: {}",
+ archiveFile, currentFile, archiveLen, curLen, archiveMtime, curMtime);
+
+ // move the archive file to the stamped backup
+ Path backedupArchiveFile = new Path(archiveDir, filename + SEPARATOR + archiveStartTime);
+ if (!fs.rename(archiveFile, backedupArchiveFile)) {
+ LOG.error("Could not rename archive file to backup: " + backedupArchiveFile
+ + ", deleting existing file in favor of newer.");
+ // try to delete the existing file, if we can't rename it
+ if (!fs.delete(archiveFile, false)) {
+ throw new IOException("Couldn't delete existing archive file (" + archiveFile
+ + ") or rename it to the backup file (" + backedupArchiveFile
+ + ") to make room for similarly named file.");
+ }
+ } else {
+ LOG.info("Backed up archive file from {} to {}.", archiveFile, backedupArchiveFile);
+ }
+ }
+
+ LOG.trace("No existing file in archive for {}, free to archive original file.", archiveFile);
+
+ // at this point, we should have a free spot for the archive file
+ boolean success = false;
+ for (int i = 0; !success && i < DEFAULT_RETRIES_NUMBER; ++i) {
+ if (i > 0) {
+ // Ensure that the archive directory exists.
+ // The previous "move to archive" operation has failed probably because
+ // the cleaner has removed our archive directory (HBASE-7643).
+ // (we're in a retry loop, so don't worry too much about the exception)
+ try {
+ if (!fs.exists(archiveDir)) {
+ if (fs.mkdirs(archiveDir)) {
+ LOG.debug("Created archive directory {}", archiveDir);
+ }
+ }
+ } catch (IOException e) {
+ LOG.warn("Failed to create directory {}", archiveDir, e);
+ }
+ }
+
+ try {
+ success = currentFile.moveAndClose(archiveFile);
+ } catch (FileNotFoundException fnfe) {
+ LOG.warn("Failed to archive " + currentFile
+ + " because it does not exist! Skipping and continuing on.", fnfe);
+ success = true;
+ } catch (IOException e) {
+ success = false;
+ // When HFiles are placed on a filesystem other than HDFS a rename operation can be a
+ // non-atomic file copy operation. It can take a long time to copy a large hfile and if
+ // interrupted there may be a partially copied file present at the destination. We must
+ // remove the partially copied file, if any, or otherwise the archive operation will fail
+ // indefinitely from this point.
+ LOG.warn("Failed to archive " + currentFile + " on try #" + i, e);
+ try {
+ fs.delete(archiveFile, false);
+ } catch (FileNotFoundException fnfe) {
+ // This case is fine.
+ } catch (IOException ee) {
+ // Complain about other IO exceptions
+ LOG.warn("Failed to clean up from failure to archive " + currentFile + " on try #" + i,
+ ee);
+ }
+ }
+ }
+
+ if (!success) {
+ LOG.error("Failed to archive " + currentFile);
+ return false;
+ }
+
+ LOG.debug("Archived from {} to {}", currentFile, archiveFile);
+ return true;
+ }
+
+ /**
+ * Without regard for backup, delete a region. Should be used with caution.
+ * @param regionDir {@link Path} to the region to be deleted.
+ * @param fs FileSystem from which to delete the region
+ * @return true on successful deletion, false otherwise
+ * @throws IOException on filesystem operation failure
+ */
+ private static boolean deleteRegionWithoutArchiving(FileSystem fs, Path regionDir)
+ throws IOException {
+ if (fs.delete(regionDir, true)) {
+ LOG.debug("Deleted {}", regionDir);
+ return true;
+ }
+ LOG.debug("Failed to delete directory {}", regionDir);
+ return false;
+ }
+
+
+ /**
+ * Adapt a type to match the {@link MapreduceHFileArchiver.File} interface, which is used internally for handling
+ * archival/removal of files
+ * @param type to adapt to the {@link MapreduceHFileArchiver.File} interface
+ */
+ private static abstract class FileConverter implements Function {
+ protected final FileSystem fs;
+
+ public FileConverter(FileSystem fs) {
+ this.fs = fs;
+ }
+ }
+
+ /**
+ * Convert a FileStatus to something we can manage in the archiving
+ */
+ private static class FileStatusConverter extends MapreduceHFileArchiver.FileConverter {
+ public FileStatusConverter(FileSystem fs) {
+ super(fs);
+ }
+
+ @Override
+ public MapreduceHFileArchiver.File apply(FileStatus input) {
+ return new MapreduceHFileArchiver.FileablePath(fs, input.getPath());
+ }
+ }
+
+ /**
+ * Wrapper to handle file operations uniformly
+ */
+ private static abstract class File {
+ protected final FileSystem fs;
+
+ public File(FileSystem fs) {
+ this.fs = fs;
+ }
+
+ /**
+ * Check to see if this is a file or a directory
+ * @return true if it is a file, false otherwise
+ * @throws IOException on {@link FileSystem} connection error
+ */
+ abstract boolean isFile() throws IOException;
+
+ /**
+ * @return if this is a directory, returns all the children in the directory, otherwise returns
+ * an empty list
+ */
+ abstract Collection getChildren() throws IOException;
+
+ /**
+ * close any outside readers of the file
+ */
+ abstract void close() throws IOException;
+
+ /** Returns the name of the file (not the full fs path, just the individual file name) */
+ abstract String getName();
+
+ /** Returns the path to this file */
+ abstract Path getPath();
+
+ /**
+ * Move the file to the given destination
+ * @return true on success
+ */
+ public boolean moveAndClose(Path dest) throws IOException {
+ this.close();
+ Path p = this.getPath();
+ return CommonFSUtils.renameAndSetModifyTime(fs, p, dest);
+ }
+
+ /** Returns the {@link FileSystem} on which this file resides */
+ public FileSystem getFileSystem() {
+ return this.fs;
+ }
+
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName() + ", " + getPath().toString();
+ }
+ }
+
+ /**
+ * A {@link MapreduceHFileArchiver.File} that wraps a simple {@link Path} on a {@link FileSystem}.
+ */
+ private static class FileablePath extends MapreduceHFileArchiver.File {
+ private final Path file;
+ private final MapreduceHFileArchiver.FileStatusConverter getAsFile;
+
+ public FileablePath(FileSystem fs, Path file) {
+ super(fs);
+ this.file = file;
+ this.getAsFile = new MapreduceHFileArchiver.FileStatusConverter(fs);
+ }
+
+ @Override
+ public String getName() {
+ return file.getName();
+ }
+
+ @Override
+ public Collection getChildren() throws IOException {
+ if (fs.isFile(file)) {
+ return Collections.emptyList();
+ }
+ return Stream.of(fs.listStatus(file)).map(getAsFile).collect(Collectors.toList());
+ }
+
+ @Override
+ public boolean isFile() throws IOException {
+ return fs.isFile(file);
+ }
+
+ @Override
+ public void close() throws IOException {
+ // NOOP - files are implicitly closed on removal
+ }
+
+ @Override
+ Path getPath() {
+ return file;
+ }
+ }
+}
diff --git a/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestMapreduceRestoreSnapshotHelper.java b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestMapreduceRestoreSnapshotHelper.java
new file mode 100644
index 000000000000..0935ecc7780f
--- /dev/null
+++ b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestMapreduceRestoreSnapshotHelper.java
@@ -0,0 +1,260 @@
+/*
+ * 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.hadoop.hbase.mapreduce;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.LocatedFileStatus;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.fs.RemoteIterator;
+import org.apache.hadoop.hbase.HBaseTestingUtil;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.MetaTableAccessor;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.Put;
+import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.ResultScanner;
+import org.apache.hadoop.hbase.client.Scan;
+import org.apache.hadoop.hbase.client.SnapshotType;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.errorhandling.ForeignExceptionDispatcher;
+import org.apache.hadoop.hbase.io.HFileLink;
+import org.apache.hadoop.hbase.master.assignment.AssignmentManager;
+import org.apache.hadoop.hbase.master.assignment.MergeTableRegionsProcedure;
+import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
+import org.apache.hadoop.hbase.mob.MobUtils;
+import org.apache.hadoop.hbase.monitoring.MonitoredTask;
+import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
+import org.apache.hadoop.hbase.regionserver.HRegion;
+import org.apache.hadoop.hbase.regionserver.HRegionServer;
+import org.apache.hadoop.hbase.regionserver.StoreFileInfo;
+import org.apache.hadoop.hbase.snapshot.SnapshotCreationException;
+import org.apache.hadoop.hbase.snapshot.SnapshotDescriptionUtils;
+import org.apache.hadoop.hbase.snapshot.SnapshotManifest;
+import org.apache.hadoop.hbase.snapshot.SnapshotTTLExpiredException;
+import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils;
+import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils.SnapshotMock;
+import org.apache.hadoop.hbase.testclassification.MediumTests;
+import org.apache.hadoop.hbase.testclassification.RegionServerTests;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.hadoop.hbase.util.CommonFSUtils;
+import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
+import org.apache.hadoop.hbase.util.FSTableDescriptors;
+import org.apache.hadoop.hbase.wal.WALSplitUtil;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription;
+
+/**
+ * Test the restore/clone operation from a file-system point of view.
+ */
+@Tag(RegionServerTests.TAG)
+@Tag(MediumTests.TAG)
+public class TestMapreduceRestoreSnapshotHelper {
+
+ private static final Logger LOG = LoggerFactory.getLogger(TestMapreduceRestoreSnapshotHelper.class);
+
+ protected final static HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil();
+ protected final static String TEST_HFILE = "abc";
+
+ protected Configuration conf;
+ protected Path archiveDir;
+ protected FileSystem fs;
+ protected Path rootDir;
+
+ protected void setupConf(Configuration conf) {
+ }
+
+ @BeforeAll
+ public static void setupCluster() throws Exception {
+ TEST_UTIL.getConfiguration().setInt(AssignmentManager.ASSIGN_MAX_ATTEMPTS, 3);
+ TEST_UTIL.startMiniCluster();
+ }
+
+ @AfterAll
+ public static void tearDownCluster() throws Exception {
+ TEST_UTIL.shutdownMiniCluster();
+ }
+
+ @BeforeEach
+ public void setup() throws Exception {
+ rootDir = TEST_UTIL.getDataTestDir("testRestore");
+ archiveDir = new Path(rootDir, HConstants.HFILE_ARCHIVE_DIRECTORY);
+ fs = TEST_UTIL.getTestFileSystem();
+ conf = TEST_UTIL.getConfiguration();
+ setupConf(conf);
+ CommonFSUtils.setRootDir(conf, rootDir);
+ // Turn off balancer so it doesn't cut in and mess up our placements.
+ TEST_UTIL.getAdmin().balancerSwitch(false, true);
+ }
+
+ @AfterEach
+ public void tearDown() throws Exception {
+ fs.delete(TEST_UTIL.getDataTestDir(), true);
+ }
+
+ protected SnapshotMock createSnapshotMock() throws IOException {
+ return new SnapshotMock(TEST_UTIL.getConfiguration(), fs, rootDir);
+ }
+
+ @Test
+ public void testNoHFileLinkInRootDir() throws IOException {
+ rootDir = TEST_UTIL.getDefaultRootDirPath();
+ CommonFSUtils.setRootDir(conf, rootDir);
+ fs = rootDir.getFileSystem(conf);
+
+ TableName tableName = TableName.valueOf("testNoHFileLinkInRootDir");
+ String snapshotName = tableName.getNameAsString() + "-snapshot";
+ createTableAndSnapshot(tableName, snapshotName);
+
+ Path restoreDir = new Path("/hbase/.tmp-restore");
+ MapreduceRestoreSnapshotHelper.copySnapshotForScanner(conf, fs, rootDir, restoreDir, snapshotName);
+ checkNoHFileLinkInTableDir(tableName);
+ }
+
+ @Test
+ public void testCopyExpiredSnapshotForScanner() throws IOException, InterruptedException {
+ rootDir = TEST_UTIL.getDefaultRootDirPath();
+ CommonFSUtils.setRootDir(conf, rootDir);
+ TableName tableName = TableName.valueOf("testCopyExpiredSnapshotForScanner");
+ String snapshotName = tableName.getNameAsString() + "-snapshot";
+ Path restoreDir = new Path("/hbase/.tmp-expired-snapshot/copySnapshotDest");
+ // create table and put some data into the table
+ byte[] columnFamily = Bytes.toBytes("A");
+ Table table = TEST_UTIL.createTable(tableName, columnFamily);
+ TEST_UTIL.loadTable(table, columnFamily);
+ // create snapshot with ttl = 10 sec
+ Map properties = new HashMap<>();
+ properties.put("TTL", 10);
+ org.apache.hadoop.hbase.client.SnapshotDescription snapshotDesc =
+ new org.apache.hadoop.hbase.client.SnapshotDescription(snapshotName, tableName,
+ SnapshotType.FLUSH, null, EnvironmentEdgeManager.currentTime(), -1, properties);
+ TEST_UTIL.getAdmin().snapshot(snapshotDesc);
+ boolean isExist = TEST_UTIL.getAdmin().listSnapshots().stream()
+ .anyMatch(ele -> snapshotName.equals(ele.getName()));
+ assertTrue(isExist);
+ int retry = 6;
+ while (
+ !SnapshotDescriptionUtils.isExpiredSnapshot(snapshotDesc.getTtl(),
+ snapshotDesc.getCreationTime(), EnvironmentEdgeManager.currentTime()) && retry > 0
+ ) {
+ retry--;
+ Thread.sleep(10 * 1000);
+ }
+ boolean isExpiredSnapshot = SnapshotDescriptionUtils.isExpiredSnapshot(snapshotDesc.getTtl(),
+ snapshotDesc.getCreationTime(), EnvironmentEdgeManager.currentTime());
+ assertTrue(isExpiredSnapshot);
+ assertThrows(SnapshotTTLExpiredException.class, () -> MapreduceRestoreSnapshotHelper
+ .copySnapshotForScanner(conf, fs, rootDir, restoreDir, snapshotName));
+ }
+
+ private void createAndAssertSnapshot(TableName tableName, String snapshotName)
+ throws SnapshotCreationException, IllegalArgumentException, IOException {
+ org.apache.hadoop.hbase.client.SnapshotDescription snapshotDescOne =
+ new org.apache.hadoop.hbase.client.SnapshotDescription(snapshotName, tableName,
+ SnapshotType.FLUSH, null, EnvironmentEdgeManager.currentTime(), -1);
+ TEST_UTIL.getAdmin().snapshot(snapshotDescOne);
+ boolean isExist = TEST_UTIL.getAdmin().listSnapshots().stream()
+ .anyMatch(ele -> snapshotName.equals(ele.getName()));
+ assertTrue(isExist);
+
+ }
+
+ private void flipCompactions(boolean isEnable) {
+ int numLiveRegionServers = TEST_UTIL.getHBaseCluster().getNumLiveRegionServers();
+ for (int serverNumber = 0; serverNumber < numLiveRegionServers; serverNumber++) {
+ HRegionServer regionServer = TEST_UTIL.getHBaseCluster().getRegionServer(serverNumber);
+ regionServer.getCompactSplitThread().setCompactionsEnabled(isEnable);
+ }
+
+ }
+
+ private ProcedureExecutor getMasterProcedureExecutor() {
+ return TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor();
+ }
+
+ protected void createTableAndSnapshot(TableName tableName, String snapshotName)
+ throws IOException {
+ byte[] column = Bytes.toBytes("A");
+ Table table = TEST_UTIL.createTable(tableName, column, 2);
+ TEST_UTIL.loadTable(table, column);
+ TEST_UTIL.getAdmin().snapshot(snapshotName, tableName);
+ }
+
+ private void checkNoHFileLinkInTableDir(TableName tableName) throws IOException {
+ Path[] tableDirs = new Path[] { CommonFSUtils.getTableDir(rootDir, tableName),
+ CommonFSUtils.getTableDir(new Path(rootDir, HConstants.HFILE_ARCHIVE_DIRECTORY), tableName),
+ CommonFSUtils.getTableDir(MobUtils.getMobHome(rootDir), tableName) };
+ for (Path tableDir : tableDirs) {
+ assertFalse(hasHFileLink(tableDir));
+ }
+ }
+
+ private boolean hasHFileLink(Path tableDir) throws IOException {
+ if (fs.exists(tableDir)) {
+ RemoteIterator iterator = fs.listFiles(tableDir, true);
+ while (iterator.hasNext()) {
+ LocatedFileStatus fileStatus = iterator.next();
+ if (fileStatus.isFile() && HFileLink.isHFileLink(fileStatus.getPath())) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private void verifyRestore(final Path rootDir, final TableDescriptor sourceHtd,
+ final TableDescriptor htdClone) throws IOException {
+ List files = SnapshotTestingUtils.listHFileNames(fs,
+ CommonFSUtils.getTableDir(rootDir, htdClone.getTableName()));
+ assertEquals(12, files.size());
+ for (int i = 0; i < files.size(); i += 2) {
+ String linkFile = files.get(i);
+ String refFile = files.get(i + 1);
+ assertTrue(HFileLink.isHFileLink(linkFile), linkFile + " should be a HFileLink");
+ assertTrue(StoreFileInfo.isReference(refFile), refFile + " should be a Reference");
+ assertEquals(sourceHtd.getTableName(), HFileLink.getReferencedTableName(linkFile));
+ Path refPath = getReferredToFile(refFile);
+ LOG.debug("get reference name for file " + refFile + " = " + refPath);
+ assertTrue(HFileLink.isHFileLink(refPath.getName()),
+ refPath.getName() + " should be a HFileLink");
+ assertEquals(linkFile, refPath.getName());
+ }
+ }
+
+ private Path getReferredToFile(final String referenceName) {
+ Path fakeBasePath = new Path(new Path("table", "region"), "cf");
+ return StoreFileInfo.getReferredToFile(new Path(fakeBasePath, referenceName));
+ }
+}
diff --git a/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestTableSnapshotInputFormat.java b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestTableSnapshotInputFormat.java
index 7a9f8d5dfb63..6529048f2e41 100644
--- a/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestTableSnapshotInputFormat.java
+++ b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestTableSnapshotInputFormat.java
@@ -53,7 +53,6 @@
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableSnapshotInputFormat.TableSnapshotRegionRecordReader;
import org.apache.hadoop.hbase.mapreduce.TableSnapshotInputFormat.TableSnapshotRegionSplit;
-import org.apache.hadoop.hbase.snapshot.RestoreSnapshotHelper;
import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils;
import org.apache.hadoop.hbase.testclassification.LargeTests;
import org.apache.hadoop.hbase.testclassification.VerySlowMapReduceTests;
@@ -708,7 +707,7 @@ public void testReadFromRestoredSnapshotViaMR() throws Exception {
SnapshotTestingUtils.createSnapshotAndValidate(admin, tableName, Arrays.asList(FAMILIES),
null, snapshotName, rootDir, fs, true);
Path tempRestoreDir = UTIL.getDataTestDirOnTestFS("restore_" + snapshotName);
- RestoreSnapshotHelper.copySnapshotForScanner(UTIL.getConfiguration(), fs, rootDir,
+ MapreduceRestoreSnapshotHelper.copySnapshotForScanner(UTIL.getConfiguration(), fs, rootDir,
tempRestoreDir, snapshotName);
assertTrue(fs.exists(tempRestoreDir), "Restore directory should exist");