diff --git a/fdbbackup/backup.actor.cpp b/fdbbackup/backup.actor.cpp index 279da196c74..ea360c9575b 100644 --- a/fdbbackup/backup.actor.cpp +++ b/fdbbackup/backup.actor.cpp @@ -2417,24 +2417,24 @@ ACTOR Future runRestore(Database db, } if (performRestore) { - Version restoredVersion = wait(backupAgent.restore(db, - origDb, - KeyRef(tagName), - KeyRef(container), - proxy, - ranges, - waitForDone, - targetVersion, - verbose, - KeyRef(addPrefix), - KeyRef(removePrefix), - LockDB::True, - UnlockDB::True, - onlyApplyMutationLogs, - inconsistentSnapshotOnly, - beginVersion, - encryptionKeyFile, - blobManifestUrl)); + Version restoredVersion = wait(backupAgent.restoreWithBeginVersion(db, + origDb, + KeyRef(tagName), + KeyRef(container), + proxy, + ranges, + waitForDone, + targetVersion, + verbose, + KeyRef(addPrefix), + KeyRef(removePrefix), + LockDB::True, + UnlockDB::True, + onlyApplyMutationLogs, + inconsistentSnapshotOnly, + beginVersion, + encryptionKeyFile, + blobManifestUrl)); if (waitForDone && verbose) { // If restore is now complete then report version restored diff --git a/fdbclient/FileBackupAgent.actor.cpp b/fdbclient/FileBackupAgent.actor.cpp index 6ac61baac90..924e15fae0e 100644 --- a/fdbclient/FileBackupAgent.actor.cpp +++ b/fdbclient/FileBackupAgent.actor.cpp @@ -6583,24 +6583,24 @@ Future FileBackupAgent::restore(Database cx, blobManifestUrl); } -Future FileBackupAgent::restore(Database cx, - Optional cxOrig, - Key tagName, - Key url, - Optional proxy, - Standalone> ranges, - WaitForComplete waitForComplete, - Version targetVersion, - Verbose verbose, - Key addPrefix, - Key removePrefix, - LockDB lockDB, - UnlockDB unlockDB, - OnlyApplyMutationLogs onlyApplyMutationLogs, - InconsistentSnapshotOnly inconsistentSnapshotOnly, - Version beginVersion, - Optional const& encryptionKeyFileName, - Optional blobManifestUrl) { +Future FileBackupAgent::restoreWithBeginVersion(Database cx, + Optional cxOrig, + Key tagName, + Key url, + Optional proxy, + Standalone> ranges, + WaitForComplete waitForComplete, + Version targetVersion, + Verbose verbose, + Key addPrefix, + Key removePrefix, + LockDB lockDB, + UnlockDB unlockDB, + OnlyApplyMutationLogs onlyApplyMutationLogs, + InconsistentSnapshotOnly inconsistentSnapshotOnly, + Version beginVersion, + Optional const& encryptionKeyFileName, + Optional blobManifestUrl) { Standalone> beginVersions; for (auto i = 0; i < ranges.size(); ++i) { beginVersions.push_back(beginVersions.arena(), beginVersion); @@ -6625,23 +6625,23 @@ Future FileBackupAgent::restore(Database cx, blobManifestUrl); } -Future FileBackupAgent::restore(Database cx, - Optional cxOrig, - Key tagName, - Key url, - Optional proxy, - WaitForComplete waitForComplete, - Version targetVersion, - Verbose verbose, - KeyRange range, - Key addPrefix, - Key removePrefix, - LockDB lockDB, - OnlyApplyMutationLogs onlyApplyMutationLogs, - InconsistentSnapshotOnly inconsistentSnapshotOnly, - Version beginVersion, - Optional const& encryptionKeyFileName, - Optional blobManifestUrl) { +Future FileBackupAgent::restoreKeyRange(Database cx, + Optional cxOrig, + Key tagName, + Key url, + Optional proxy, + WaitForComplete waitForComplete, + Version targetVersion, + Verbose verbose, + KeyRange range, + Key addPrefix, + Key removePrefix, + LockDB lockDB, + OnlyApplyMutationLogs onlyApplyMutationLogs, + InconsistentSnapshotOnly inconsistentSnapshotOnly, + Version beginVersion, + Optional const& encryptionKeyFileName, + Optional blobManifestUrl) { Standalone> rangeRef; if (range.begin.empty() && range.end.empty()) { addDefaultBackupRanges(rangeRef); diff --git a/fdbclient/include/fdbclient/BackupAgent.actor.h b/fdbclient/include/fdbclient/BackupAgent.actor.h index e00b62dc084..66bfb2db409 100644 --- a/fdbclient/include/fdbclient/BackupAgent.actor.h +++ b/fdbclient/include/fdbclient/BackupAgent.actor.h @@ -206,42 +206,45 @@ class FileBackupAgent : public BackupAgentBase { Optional const& encryptionKeyFileName = {}, Optional blobManifestUrl = {}); - Future restore(Database cx, - Optional cxOrig, - Key tagName, - Key url, - Optional proxy, - WaitForComplete = WaitForComplete::True, - Version targetVersion = ::invalidVersion, - Verbose = Verbose::True, - KeyRange range = KeyRange(), - Key addPrefix = Key(), - Key removePrefix = Key(), - LockDB = LockDB::True, - OnlyApplyMutationLogs = OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly = InconsistentSnapshotOnly::False, - Version beginVersion = ::invalidVersion, - Optional const& encryptionKeyFileName = {}, - Optional blobManifestUrl = {}); - - Future restore(Database cx, - Optional cxOrig, - Key tagName, - Key url, - Optional proxy, - Standalone> ranges, - WaitForComplete waitForComplete = WaitForComplete::True, - Version targetVersion = ::invalidVersion, - Verbose verbose = Verbose::True, - Key addPrefix = Key(), - Key removePrefix = Key(), - LockDB lockDB = LockDB::True, - UnlockDB unlockDB = UnlockDB::True, - OnlyApplyMutationLogs onlyApplyMutationLogs = OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly inconsistentSnapshotOnly = InconsistentSnapshotOnly::False, - Version beginVersion = ::invalidVersion, - Optional const& encryptionKeyFileName = {}, - Optional blobManifestUrl = {}); + // this method will construct range and version vectors and then call restore() + Future restoreKeyRange(Database cx, + Optional cxOrig, + Key tagName, + Key url, + Optional proxy, + WaitForComplete = WaitForComplete::True, + Version targetVersion = ::invalidVersion, + Verbose = Verbose::True, + KeyRange range = KeyRange(), + Key addPrefix = Key(), + Key removePrefix = Key(), + LockDB = LockDB::True, + OnlyApplyMutationLogs = OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly = InconsistentSnapshotOnly::False, + Version beginVersion = ::invalidVersion, + Optional const& encryptionKeyFileName = {}, + Optional blobManifestUrl = {}); + + // create a version vector of size ranges.size(), all elements are the same, i.e. beginVersion + Future restoreWithBeginVersion( + Database cx, + Optional cxOrig, + Key tagName, + Key url, + Optional proxy, + Standalone> ranges, + WaitForComplete waitForComplete = WaitForComplete::True, + Version targetVersion = ::invalidVersion, + Verbose verbose = Verbose::True, + Key addPrefix = Key(), + Key removePrefix = Key(), + LockDB lockDB = LockDB::True, + UnlockDB unlockDB = UnlockDB::True, + OnlyApplyMutationLogs onlyApplyMutationLogs = OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly inconsistentSnapshotOnly = InconsistentSnapshotOnly::False, + Version beginVersion = ::invalidVersion, + Optional const& encryptionKeyFileName = {}, + Optional blobManifestUrl = {}); Future atomicRestore(Database cx, Key tagName, diff --git a/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp b/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp index b2b646e9b70..24e4e7a9e3e 100644 --- a/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp +++ b/fdbserver/workloads/BackupAndParallelRestoreCorrectness.actor.cpp @@ -377,18 +377,18 @@ struct BackupAndParallelRestoreCorrectnessWorkload : TestWorkload { try { // TODO: Change to my restore agent code TraceEvent(SevError, "MXFastRestore").detail("RestoreFunction", "ShouldChangeToMyOwnRestoreLogic"); - wait(success(backupAgent->restore(cx, - cx, - self->backupTag, - KeyRef(lastBackupContainer), - {}, - WaitForComplete::True, - ::invalidVersion, - Verbose::True, - normalKeys, - Key(), - Key(), - self->locked))); + wait(success(backupAgent->restoreKeyRange(cx, + cx, + self->backupTag, + KeyRef(lastBackupContainer), + {}, + WaitForComplete::True, + ::invalidVersion, + Verbose::True, + normalKeys, + Key(), + Key(), + self->locked))); TraceEvent(SevError, "BARW_RestoreAllowedOverwrittingDatabase", randomID).log(); ASSERT(false); } catch (Error& e) { diff --git a/fdbserver/workloads/BackupCorrectness.actor.cpp b/fdbserver/workloads/BackupCorrectness.actor.cpp index 3326fb26b1a..0d312cafd36 100644 --- a/fdbserver/workloads/BackupCorrectness.actor.cpp +++ b/fdbserver/workloads/BackupCorrectness.actor.cpp @@ -497,18 +497,18 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { // Try doing a restore without clearing the keys if (rowCount > 0) { try { - wait(success(backupAgent->restore(cx, - cx, - self->backupTag, - KeyRef(lastBackupContainer), - {}, - WaitForComplete::True, - ::invalidVersion, - Verbose::True, - normalKeys, - Key(), - Key(), - self->locked))); + wait(success(backupAgent->restoreKeyRange(cx, + cx, + self->backupTag, + KeyRef(lastBackupContainer), + {}, + WaitForComplete::True, + ::invalidVersion, + Verbose::True, + normalKeys, + Key(), + Key(), + self->locked))); TraceEvent(SevError, "BARW_RestoreAllowedOverwrittingDatabase", randomID).log(); ASSERT(false); } catch (Error& e) { @@ -536,23 +536,23 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { })); state Standalone restoreTag(self->backupTag.toString() + "_system"); printf("BackupCorrectness, backupAgent.restore is called for tag:%s\n", restoreTag.toString().c_str()); - wait(success(backupAgent->restore(cx, - cx, - restoreTag, - KeyRef(lastBackupContainer->getURL()), - lastBackupContainer->getProxy(), - systemRestoreRanges, - WaitForComplete::True, - targetVersion, - Verbose::True, - Key(), - Key(), - self->locked, - UnlockDB::True, - OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly::False, - ::invalidVersion, - self->encryptionKeyFileName))); + wait(success(backupAgent->restoreWithBeginVersion(cx, + cx, + restoreTag, + KeyRef(lastBackupContainer->getURL()), + lastBackupContainer->getProxy(), + systemRestoreRanges, + WaitForComplete::True, + targetVersion, + Verbose::True, + Key(), + Key(), + self->locked, + UnlockDB::True, + OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly::False, + ::invalidVersion, + self->encryptionKeyFileName))); printf("BackupCorrectness, backupAgent.restore finished for tag:%s\n", restoreTag.toString().c_str()); return Void(); } @@ -735,22 +735,22 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { restoreIndex, range.toString().c_str(), restoreTag.toString().c_str()); - restores.push_back(backupAgent.restore(cx, - cx, - restoreTag, - KeyRef(lastBackupContainer->getURL()), - lastBackupContainer->getProxy(), - WaitForComplete::True, - targetVersion, - Verbose::True, - range, - Key(), - Key(), - self->locked, - OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly::False, - ::invalidVersion, - self->encryptionKeyFileName)); + restores.push_back(backupAgent.restoreKeyRange(cx, + cx, + restoreTag, + KeyRef(lastBackupContainer->getURL()), + lastBackupContainer->getProxy(), + WaitForComplete::True, + targetVersion, + Verbose::True, + range, + Key(), + Key(), + self->locked, + OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly::False, + ::invalidVersion, + self->encryptionKeyFileName)); } } else { multipleRangesInOneTag = true; @@ -759,23 +759,23 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { printf("BackupCorrectness, backupAgent.restore is called for restoreIndex:%d tag:%s\n", restoreIndex, restoreTag.toString().c_str()); - restores.push_back(backupAgent.restore(cx, - cx, - restoreTag, - KeyRef(lastBackupContainer->getURL()), - lastBackupContainer->getProxy(), - self->restoreRanges, - WaitForComplete::True, - targetVersion, - Verbose::True, - Key(), - Key(), - self->locked, - UnlockDB::True, - OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly::False, - ::invalidVersion, - self->encryptionKeyFileName)); + restores.push_back(backupAgent.restoreWithBeginVersion(cx, + cx, + restoreTag, + KeyRef(lastBackupContainer->getURL()), + lastBackupContainer->getProxy(), + self->restoreRanges, + WaitForComplete::True, + targetVersion, + Verbose::True, + Key(), + Key(), + self->locked, + UnlockDB::True, + OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly::False, + ::invalidVersion, + self->encryptionKeyFileName)); } // Sometimes kill and restart the restore @@ -792,23 +792,24 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { tr->clear(range); return Void(); })); - restores[restoreIndex] = backupAgent.restore(cx, - cx, - restoreTags[restoreIndex], - KeyRef(lastBackupContainer->getURL()), - lastBackupContainer->getProxy(), - self->restoreRanges, - WaitForComplete::True, - ::invalidVersion, - Verbose::True, - Key(), - Key(), - self->locked, - UnlockDB::True, - OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly::False, - ::invalidVersion, - self->encryptionKeyFileName); + restores[restoreIndex] = + backupAgent.restoreWithBeginVersion(cx, + cx, + restoreTags[restoreIndex], + KeyRef(lastBackupContainer->getURL()), + lastBackupContainer->getProxy(), + self->restoreRanges, + WaitForComplete::True, + ::invalidVersion, + Verbose::True, + Key(), + Key(), + self->locked, + UnlockDB::True, + OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly::False, + ::invalidVersion, + self->encryptionKeyFileName); } } else { for (restoreIndex = 0; restoreIndex < restores.size(); restoreIndex++) { @@ -824,22 +825,23 @@ struct BackupAndRestoreCorrectnessWorkload : TestWorkload { tr->clear(self->restoreRanges[restoreIndex]); return Void(); })); - restores[restoreIndex] = backupAgent.restore(cx, - cx, - restoreTags[restoreIndex], - KeyRef(lastBackupContainer->getURL()), - lastBackupContainer->getProxy(), - WaitForComplete::True, - ::invalidVersion, - Verbose::True, - self->restoreRanges[restoreIndex], - Key(), - Key(), - self->locked, - OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly::False, - ::invalidVersion, - self->encryptionKeyFileName); + restores[restoreIndex] = + backupAgent.restoreKeyRange(cx, + cx, + restoreTags[restoreIndex], + KeyRef(lastBackupContainer->getURL()), + lastBackupContainer->getProxy(), + WaitForComplete::True, + ::invalidVersion, + Verbose::True, + self->restoreRanges[restoreIndex], + Key(), + Key(), + self->locked, + OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly::False, + ::invalidVersion, + self->encryptionKeyFileName); } } } diff --git a/fdbserver/workloads/BlobRestoreWorkload.actor.cpp b/fdbserver/workloads/BlobRestoreWorkload.actor.cpp index 116c3152b93..77d9df5b700 100644 --- a/fdbserver/workloads/BlobRestoreWorkload.actor.cpp +++ b/fdbserver/workloads/BlobRestoreWorkload.actor.cpp @@ -130,24 +130,24 @@ struct BlobRestoreWorkload : TestWorkload { ranges.push_back(ranges.arena(), normalKeys); addDefaultBackupRanges(ranges); - Version version = wait(self->backupAgent_.restore(self->extraDb_, - {}, - "default"_sr, - KeyRef(mlogsUrl), - {}, - ranges, - WaitForComplete::False, - self->restoreTargetVersion_, - Verbose::True, - ""_sr, - ""_sr, - LockDB::True, - UnlockDB::True, - OnlyApplyMutationLogs::False, - InconsistentSnapshotOnly::False, - invalidVersion, - {}, - self->blobManifestUrl_.toString())); + Version version = wait(self->backupAgent_.restoreWithBeginVersion(self->extraDb_, + {}, + "default"_sr, + KeyRef(mlogsUrl), + {}, + ranges, + WaitForComplete::False, + self->restoreTargetVersion_, + Verbose::True, + ""_sr, + ""_sr, + LockDB::True, + UnlockDB::True, + OnlyApplyMutationLogs::False, + InconsistentSnapshotOnly::False, + invalidVersion, + {}, + self->blobManifestUrl_.toString())); fmt::print("Submit blob restore to version {} \n", version); return Void(); } diff --git a/fdbserver/workloads/IncrementalBackup.actor.cpp b/fdbserver/workloads/IncrementalBackup.actor.cpp index 6a7b2be1d91..04c461023fb 100644 --- a/fdbserver/workloads/IncrementalBackup.actor.cpp +++ b/fdbserver/workloads/IncrementalBackup.actor.cpp @@ -260,40 +260,40 @@ struct IncrementalBackupWorkload : TestWorkload { } if (!systemRestoreRange.empty()) { TraceEvent("IBackupSystemRestoreAttempt").detail("BeginVersion", beginVersion); - wait(success(self->backupAgent.restore(cx, - cx, - "system_restore"_sr, - backupURL, - {}, - systemRestoreRange, - WaitForComplete::True, - invalidVersion, - Verbose::True, - Key(), - Key(), - LockDB::True, - UnlockDB::True, - OnlyApplyMutationLogs::True, - InconsistentSnapshotOnly::False, - beginVersion))); + wait(success(self->backupAgent.restoreWithBeginVersion(cx, + cx, + "system_restore"_sr, + backupURL, + {}, + systemRestoreRange, + WaitForComplete::True, + invalidVersion, + Verbose::True, + Key(), + Key(), + LockDB::True, + UnlockDB::True, + OnlyApplyMutationLogs::True, + InconsistentSnapshotOnly::False, + beginVersion))); } TraceEvent("IBackupRestoreAttempt").detail("BeginVersion", beginVersion); - wait(success(self->backupAgent.restore(cx, - cx, - Key(self->tag.toString()), - backupURL, - {}, - restoreRange, - WaitForComplete::True, - invalidVersion, - Verbose::True, - Key(), - Key(), - LockDB::True, - UnlockDB::True, - OnlyApplyMutationLogs::True, - InconsistentSnapshotOnly::False, - beginVersion))); + wait(success(self->backupAgent.restoreWithBeginVersion(cx, + cx, + Key(self->tag.toString()), + backupURL, + {}, + restoreRange, + WaitForComplete::True, + invalidVersion, + Verbose::True, + Key(), + Key(), + LockDB::True, + UnlockDB::True, + OnlyApplyMutationLogs::True, + InconsistentSnapshotOnly::False, + beginVersion))); TraceEvent("IBackupRestoreSuccess").log(); } return Void(); diff --git a/fdbserver/workloads/MetaclusterRestoreWorkload.actor.cpp b/fdbserver/workloads/MetaclusterRestoreWorkload.actor.cpp index fc2ca2050e5..2b4425daa63 100644 --- a/fdbserver/workloads/MetaclusterRestoreWorkload.actor.cpp +++ b/fdbserver/workloads/MetaclusterRestoreWorkload.actor.cpp @@ -254,7 +254,8 @@ struct MetaclusterRestoreWorkload : TestWorkload { })); TraceEvent("MetaclusterRestoreWorkloadRestoreCluster").detail("ClusterName", clusterName); - wait(success(backupAgent.restore(dataDb, dataDb, clusterName, StringRef(backupUrl), {}, backupRanges))); + wait(success( + backupAgent.restoreWithBeginVersion(dataDb, dataDb, clusterName, StringRef(backupUrl), {}, backupRanges))); state std::vector messages; if (addToMetacluster) { diff --git a/fdbserver/workloads/RestoreBackup.actor.cpp b/fdbserver/workloads/RestoreBackup.actor.cpp index 3d6a8d5d602..e9e4dd7787a 100644 --- a/fdbserver/workloads/RestoreBackup.actor.cpp +++ b/fdbserver/workloads/RestoreBackup.actor.cpp @@ -121,34 +121,34 @@ struct RestoreBackupWorkload : TestWorkload { if (config.tenantMode == TenantMode::REQUIRED) { // restore system keys - wait(success(self->backupAgent.restore(cx, - cx, - "system_restore"_sr, - Key(self->backupContainer->getURL()), - self->backupContainer->getProxy(), - getSystemBackupRanges(), - WaitForComplete::True, - ::invalidVersion, - Verbose::True))); + wait(success(self->backupAgent.restoreWithBeginVersion(cx, + cx, + "system_restore"_sr, + Key(self->backupContainer->getURL()), + self->backupContainer->getProxy(), + getSystemBackupRanges(), + WaitForComplete::True, + ::invalidVersion, + Verbose::True))); // restore user data - wait(success(self->backupAgent.restore(cx, - cx, - self->tag, - Key(self->backupContainer->getURL()), - self->backupContainer->getProxy(), - WaitForComplete::True, - ::invalidVersion, - Verbose::True, - normalKeys))); + wait(success(self->backupAgent.restoreKeyRange(cx, + cx, + self->tag, + Key(self->backupContainer->getURL()), + self->backupContainer->getProxy(), + WaitForComplete::True, + ::invalidVersion, + Verbose::True, + normalKeys))); } else { - wait(success(self->backupAgent.restore(cx, - cx, - self->tag, - Key(self->backupContainer->getURL()), - self->backupContainer->getProxy(), - WaitForComplete::True, - ::invalidVersion, - Verbose::True))); + wait(success(self->backupAgent.restoreKeyRange(cx, + cx, + self->tag, + Key(self->backupContainer->getURL()), + self->backupContainer->getProxy(), + WaitForComplete::True, + ::invalidVersion, + Verbose::True))); } return Void(); diff --git a/fdbserver/workloads/RestoreFromBlob.actor.cpp b/fdbserver/workloads/RestoreFromBlob.actor.cpp index dc7b316ce80..5f8a61ca0d1 100644 --- a/fdbserver/workloads/RestoreFromBlob.actor.cpp +++ b/fdbserver/workloads/RestoreFromBlob.actor.cpp @@ -60,16 +60,16 @@ struct RestoreFromBlobWorkload : TestWorkload { wait(delay(self->restoreAfter)); if (config.tenantMode == TenantMode::REQUIRED) { // restore system keys followed by user keys - wait(success(backupAgent.restore( + wait(success(backupAgent.restoreWithBeginVersion( cx, {}, self->backupTag, self->backupURL, {}, getSystemBackupRanges(), self->waitForComplete))); Standalone> restoreRanges; restoreRanges.push_back_deep(restoreRanges.arena(), normalKeys); - wait(success(backupAgent.restore( + wait(success(backupAgent.restoreWithBeginVersion( cx, {}, self->backupTag, self->backupURL, {}, restoreRanges, self->waitForComplete))); } else { Standalone> restoreRanges; addDefaultBackupRanges(restoreRanges); - wait(success(backupAgent.restore( + wait(success(backupAgent.restoreWithBeginVersion( cx, {}, self->backupTag, self->backupURL, {}, restoreRanges, self->waitForComplete))); } return Void(); diff --git a/fdbserver/workloads/RestoreMultiRanges.actor.cpp b/fdbserver/workloads/RestoreMultiRanges.actor.cpp index d697f8dc8ff..6bfeb3ae117 100644 --- a/fdbserver/workloads/RestoreMultiRanges.actor.cpp +++ b/fdbserver/workloads/RestoreMultiRanges.actor.cpp @@ -150,15 +150,15 @@ struct RestoreMultiRangesWorkload : TestWorkload { state Standalone> ranges; ranges.push_back_deep(ranges.arena(), KeyRangeRef("a"_sr, "aaaaa"_sr)); ranges.push_back_deep(ranges.arena(), KeyRangeRef("bb"_sr, "bbbbb"_sr)); // Skip "b" - wait(success(self->backupAgent.restore(cx, - cx, - Key(tagName), - Key(container->getURL()), - {}, - ranges, - WaitForComplete::True, - ::invalidVersion, - Verbose::True))); + wait(success(self->backupAgent.restoreWithBeginVersion(cx, + cx, + Key(tagName), + Key(container->getURL()), + {}, + ranges, + WaitForComplete::True, + ::invalidVersion, + Verbose::True))); TraceEvent("RestoreMultiRanges_Success"); return Void(); }